fix : archiving job now works as intended, by archiving by default all orders and parcel infos before today 1 year ago

jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/business/domain/job/DBArchivingJob.java

@@ -45,8 +45,8 @@ public class DBArchivingJob implements Job {
     private static final Integer DEFAULT_NUMBER_OF_DAYS = 365;
     @Override
     public void execute(JobExecutionContext context) throws JobExecutionException {
-        LocalDateTime endDateTime = LocalDateTime.now(ZoneId.of(ZoneId.SHORT_IDS.get("CTT")));
+        LocalDateTime endDateTime = LocalDateTime.now(ZoneId.of(ZoneId.SHORT_IDS.get("CTT"))).minusDays(DEFAULT_NUMBER_OF_DAYS);
-        LocalDateTime startDateTime = endDateTime.minusDays(DEFAULT_NUMBER_OF_DAYS);
+        LocalDateTime startDateTime = null;
         JobDataMap jobDataMap = context.getMergedJobDataMap();
         String parameter = ((String) jobDataMap.get("parameter"));
         if (parameter != null) {
@@ -59,48 +59,62 @@ public class DBArchivingJob implements Job {
                 if (!jsonObject.isNull("endDateTime")) {
                     String endDateStr = jsonObject.getString("endDateTime");
                     endDateTime = LocalDateTime.parse(endDateStr);
+                    if(endDateTime.isAfter(LocalDateTime.now(ZoneId.of(ZoneId.SHORT_IDS.get("CTT"))).minusDays(DEFAULT_NUMBER_OF_DAYS))) {
+                        throw new RuntimeException("Error : Only orders older than 1 year can be archived !");
+                    }
                 }
             }
             catch (JSONException e) {
                 log.error("Error while parsing parameter as JSON, falling back to default parameters.");
             }
         }
-        if (!endDateTime.isAfter(startDateTime)) {
+
-            throw new RuntimeException("EndDateTime must be strictly greater than StartDateTime !");
+        String startDate;
-        }
-        String startDate = startDateTime.toString().substring(0,10);
         endDateTime = endDateTime.plusDays(1);
         String endDate = endDateTime.toString().substring(0,10);
-
+        List<PlatformOrder> platformOrders;
-        // sauvegarde des entrées dans des listes
+        if (startDateTime != null) {
-        // suppression des entrées dans l'ancienne table
+            if(!endDateTime.isAfter(startDateTime))
-        List<PlatformOrder> platformOrders = platformOrderService.fetchPlatformOrdersToArchive(startDate, endDate);
+                throw new RuntimeException("EndDateTime must be strictly greater than StartDateTime !");
-        List<String> platformOrderIDs = platformOrders.stream().map(PlatformOrder::getId).collect(Collectors.toList());
+            startDate = startDateTime.toString().substring(0,10);
-        List<PlatformOrderContent> platformOrderContents = platformOrderContentService.fetchPlatformOrderContentsToArchive(platformOrderIDs);
+            platformOrders = platformOrderService.fetchOrdersToArchiveBetweenDate(startDate, endDate);
-
+            log.info("Archiving entries between ["+startDate+" and "+endDate+"]");
-        log.info("Archiving entries between ["+startDate+" and "+endDate+"]\n"
+        }
-                +"- Platform Order entries : " + platformOrders.size() + "\n"
+        else {
-                +"- Platform Order Content entries : " + platformOrderContents.size());
+            platformOrders = platformOrderService.fetchOrdersToArchiveBeforeDate(endDate);
-        platformOrderService.savePlatformOrderArchive(platformOrders);
+            log.info("Archiving entries before ["+endDate+"]");
-        platformOrderContentService.savePlatformOrderContentArchive(platformOrderContents);
+        }
-        platformOrderService.delBatchMain(platformOrderIDs);
+        if(platformOrders.size() > 0) {
-
+            // sauvegarde des entrées dans des listes
-        List<String> platformOrderTrackingNumber = platformOrders.stream().map(PlatformOrder::getTrackingNumber).collect(Collectors.toList());
+            // suppression des entrées dans l'ancienne table
-        if(platformOrderTrackingNumber.size() > 0) {
+            List<String> platformOrderIDs = platformOrders.stream().map(PlatformOrder::getId).collect(Collectors.toList());
-            List<Parcel> parcels = parcelService.fetchParcelsToArchive(platformOrderTrackingNumber);
+            List<PlatformOrderContent> platformOrderContents = platformOrderContentService.fetchPlatformOrderContentsToArchive(platformOrderIDs);
-            if(parcels.size() > 0) {
+            log.info("- Platform Order entries : " + platformOrders.size() + "\n"
-                log.info("- Parcel entries : " + parcels.size());
+                    + "- Platform Order Content entries : " + platformOrderContents.size());
-                parcelService.saveParcelArchive(parcels);
+            platformOrderService.savePlatformOrderArchive(platformOrders);
-
+            platformOrderContentService.savePlatformOrderContentArchive(platformOrderContents);
-                List<String> parcelIDs = parcels.stream().map(Parcel::getId).collect(Collectors.toList());
+            platformOrderService.delBatchMain(platformOrderIDs);
-                List<ParcelTrace> parcelTraces = parcelTraceService.fetchParcelTracesToArchive(parcelIDs);
+
-                if(parcelTraces.size() > 0) {
+            List<String> platformOrderTrackingNumber = platformOrders.stream().map(PlatformOrder::getTrackingNumber).collect(Collectors.toList());
-                    log.info("- Parcel trace entries : " + parcelTraces.size());
+            if (platformOrderTrackingNumber.size() > 0) {
-                    parcelTraceService.saveParcelTraceArchive(parcelTraces);
+                List<Parcel> parcels = parcelService.fetchParcelsToArchive(platformOrderTrackingNumber);
-                }
+                if (parcels.size() > 0) {
-                parcelService.delBatchMain(parcelIDs);
+                    log.info("- Parcel entries : " + parcels.size());
-            }
+                    parcelService.saveParcelArchive(parcels);
+
+                    List<String> parcelIDs = parcels.stream().map(Parcel::getId).collect(Collectors.toList());
+                    List<ParcelTrace> parcelTraces = parcelTraceService.fetchParcelTracesToArchive(parcelIDs);
+                    if (parcelTraces.size() > 0) {
+                        log.info("- Parcel trace entries : " + parcelTraces.size());
+                        parcelTraceService.saveParcelTraceArchive(parcelTraces);
+                    }
+                    parcelService.delBatchMain(parcelIDs);
+                }
+            }
+            log.info("Archiving Done.");
+        }
+        else {
+            log.info("Nothing to archive !");
         }
-        log.info("Archiving Done.");
     }
 }

jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/business/mapper/PlatformOrderMapper.java

@@ -178,6 +178,7 @@ public interface PlatformOrderMapper extends BaseMapper<PlatformOrder> {
                                                                          @Param("shops") List<String> shops,
                                                                          @Param("erpStatuses") List<Integer> erpStatuses,
                                                                          @Param("warehouses") List<String> warehouses);
-    List<PlatformOrder> fetchPlatformOrdersToArchive(@Param("startDate") String startDate, @Param("endDate") String endDate);
+    List<PlatformOrder> fetchOrdersToArchiveBetweenDate(@Param("startDate") String startDate, @Param("endDate") String endDate);
+    List<PlatformOrder> fetchOrdersToArchiveBeforeDate(@Param("endDate") String endDate);
     void insertPlatformOrdersArchives(@Param("orders") List<PlatformOrder> platformOrders);
 }

jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/business/mapper/xml/PlatformOrderMapper.xml

@@ -528,12 +528,18 @@
             #{erpStatus}
         </foreach>;
     </select>
-    <select id="fetchPlatformOrdersToArchive" resultType="org.jeecg.modules.business.entity.PlatformOrder">
+    <select id="fetchOrdersToArchiveBetweenDate" resultType="org.jeecg.modules.business.entity.PlatformOrder">
         SELECT *
         FROM platform_order po
         WHERE erp_status IN (4,5)
         AND order_time BETWEEN #{startDate} AND #{endDate};
     </select>
+    <select id="fetchOrdersToArchiveBeforeDate" resultType="org.jeecg.modules.business.entity.PlatformOrder">
+        SELECT *
+        FROM platform_order po
+        WHERE erp_status IN (4,5)
+        AND order_time &lt; #{endDate};
+    </select>
     <insert id="insertPlatformOrdersArchives" parameterType="list">
         INSERT INTO platform_order_delete(id, create_by,
                                           create_time, update_by,

jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/business/service/IPlatformOrderService.java

@@ -149,7 +149,16 @@ public interface IPlatformOrderService extends IService<PlatformOrder> {
      * @param endDate End date time
      * @return List of PlatformOrder
      */
-    List<PlatformOrder> fetchPlatformOrdersToArchive(String startDate, String endDate);
+    List<PlatformOrder> fetchOrdersToArchiveBetweenDate(String startDate, String endDate);
+
+    /**
+     * Fetch all platform orders before endDate and of status erp_status 4 or 5
+     * this list will then be archived
+     *
+     * @param endDate Start date time
+     * @return List of PlatformOrder
+     */
+    List<PlatformOrder> fetchOrdersToArchiveBeforeDate(String endDate);
 
     /**
      * Archive a list of platform orders

jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/business/service/impl/PlatformOrderServiceImpl.java

@@ -367,8 +367,12 @@ public class PlatformOrderServiceImpl extends ServiceImpl<PlatformOrderMapper, P
         return platformOrderMap.fetchUninvoicedShippedOrderIDInShops(startDate, endDate, shops, warehouses);
     }
     @Override
-    public List<PlatformOrder> fetchPlatformOrdersToArchive(String startDate, String endDate) {
+    public List<PlatformOrder> fetchOrdersToArchiveBetweenDate(String startDate, String endDate) {
-        return platformOrderMap.fetchPlatformOrdersToArchive(startDate, endDate);
+        return platformOrderMap.fetchOrdersToArchiveBetweenDate(startDate, endDate);
+    }
+    @Override
+    public List<PlatformOrder> fetchOrdersToArchiveBeforeDate(String endDate) {
+        return platformOrderMap.fetchOrdersToArchiveBeforeDate(endDate);
     }
     @Override
     public void savePlatformOrderArchive(List<PlatformOrder> platformOrders) {