Merge pull request 'fix po pdf layout' (#31) from fix-po-pdf-layout into main

Reviewed-on: #31

.idea/jarRepositories.xml

@@ -21,10 +21,20 @@
       <option name="name" value="In project repo" />
       <option name="url" value="file:///D:\Projects\uind-cut-to-pack\cut-to-pack/libs" />
     </remote-repository>
+    <remote-repository>
+      <option name="id" value="in-project" />
+      <option name="name" value="In project repo" />
+      <option name="url" value="file:///C:\Users\USF\Project\Cut-to-pack\cut-to-pack-service/libs" />
+    </remote-repository>
     <remote-repository>
       <option name="id" value="in-project" />
       <option name="name" value="In project repo" />
       <option name="url" value="file:///D:\Project\cut-to-pack-service/libs" />
     </remote-repository>
+    <remote-repository>
+      <option name="id" value="in-project" />
+      <option name="name" value="In project repo" />
+      <option name="url" value="file:///D:\ctp\Project\Cut-to-pack\cut-to-pack-service/libs" />
+    </remote-repository>
   </component>
 </project>

.idea/misc.xml

@@ -1,3 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="ExternalStorageConfigurationManager" enabled="true" />
   <component name="MavenProjectsManager">

pom.xml

@@ -28,6 +28,24 @@
         </repository>
     </repositories>
 
+    <profiles>
+        <profile>
+            <id>dev</id>
+            <activation>
+                <activeByDefault>true</activeByDefault>
+            </activation>
+            <properties>
+                <activatedProperties>dev</activatedProperties>
+            </properties>
+        </profile>
+        <profile>
+            <id>prod</id>
+            <properties>
+                <activatedProperties>prod</activatedProperties>
+            </properties>
+        </profile>
+    </profiles>
+
     <dependencies>
         <dependency>
             <groupId>org.springframework.boot</groupId>
@@ -37,6 +55,12 @@
             <groupId>org.thymeleaf.extras</groupId>
             <artifactId>thymeleaf-extras-java8time</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.apache.pdfbox</groupId>
+            <artifactId>pdfbox</artifactId>
+            <version>2.0.30</version>
+            <scope>compile</scope>
+        </dependency>
         <dependency>
             <groupId>org.thymeleaf.extras</groupId>
             <artifactId>thymeleaf-extras-springsecurity5</artifactId>
@@ -371,7 +395,7 @@
                     <jvmArguments>-Xms1024m</jvmArguments>
                     <jvmArguments>-Xmx8g</jvmArguments>
                 </configuration>
-            </plugin>
+            </plugin><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-compiler-plugin</artifactId><configuration><source>9</source><target>9</target></configuration></plugin>
         </plugins>
     </build>
 </project>

src/main/java/com/utopiaindustries/auth/InventoryAccountRole.java

@@ -0,0 +1,14 @@
+package com.utopiaindustries.auth;
+
+import org.springframework.security.access.prepost.PreAuthorize;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.METHOD, ElementType.TYPE})
+@PreAuthorize("hasAnyRole('ROLE_INVENTORY_ACCOUNT','ROLE_ADMIN')")
+public @interface InventoryAccountRole {
+}

src/main/java/com/utopiaindustries/auth/PurchaseOrderCTPRole.java

@@ -0,0 +1,15 @@
+package com.utopiaindustries.auth;
+
+
+import org.springframework.security.access.prepost.PreAuthorize;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.METHOD, ElementType.TYPE})
+@PreAuthorize( "hasAnyRole('ROLE_PURCHASE_ORDER','ROLE_ADMIN')")
+public @interface PurchaseOrderCTPRole {
+}

src/main/java/com/utopiaindustries/auth/StoreRole.java

@@ -0,0 +1,14 @@
+package com.utopiaindustries.auth;
+
+import org.springframework.security.access.prepost.PreAuthorize;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.METHOD, ElementType.TYPE})
+@PreAuthorize( "hasAnyRole('ROLE_STORE','ROLE_ADMIN')")
+public @interface StoreRole {
+}

src/main/java/com/utopiaindustries/config/DataSourceConfiguration.java

@@ -35,22 +35,22 @@ public class DataSourceConfiguration {
 
     /* COSMOS */
 
-    @Bean(name = "dataSourceCosmos")
-    @ConfigurationProperties(prefix = "spring.cosmosdatasource")
-    public DataSource cosmosDataSource() {
-        return DataSourceBuilder.create().build();
-    }
-
-
-    @Bean(name = "jdbcTemplateCosmos")
-    public JdbcTemplate cosmosJdbcTemplate( @Qualifier( "dataSourceCosmos" ) DataSource ds ) {
-        return new JdbcTemplate( ds );
-    }
-
-    @Bean(name = "namedParameterJdbcTemplateCosmos")
-    public NamedParameterJdbcTemplate cosmosNamedParameterJdbcTemplate( @Qualifier( "dataSourceCosmos" ) DataSource ds ) {
-        return new NamedParameterJdbcTemplate( ds );
-    }
+//    @Bean(name = "dataSourceCosmos")
+//    @ConfigurationProperties(prefix = "spring.cosmosdatasource")
+//    public DataSource cosmosDataSource() {
+//        return DataSourceBuilder.create().build();
+//    }
+//
+//
+//    @Bean(name = "jdbcTemplateCosmos")
+//    public JdbcTemplate cosmosJdbcTemplate( @Qualifier( "dataSourceCosmos" ) DataSource ds ) {
+//        return new JdbcTemplate( ds );
+//    }
+//
+//    @Bean(name = "namedParameterJdbcTemplateCosmos")
+//    public NamedParameterJdbcTemplate cosmosNamedParameterJdbcTemplate( @Qualifier( "dataSourceCosmos" ) DataSource ds ) {
+//        return new NamedParameterJdbcTemplate( ds );
+//    }
 
     /*  LOCAL  */
 
@@ -73,6 +73,4 @@ public class DataSourceConfiguration {
     public NamedParameterJdbcTemplate localNamedParameterJdbcTemplate( @Qualifier( "dataSourceLocal" ) DataSource ds ) {
         return new NamedParameterJdbcTemplate( ds );
     }
-
-
 }

src/main/java/com/utopiaindustries/config/SecurityConfiguration.java

@@ -42,7 +42,7 @@ public class SecurityConfiguration extends WebSecurityConfigurerAdapter {
     protected void configure(HttpSecurity http) throws Exception {
         http.csrf().disable()
                 .authorizeRequests()
-                .antMatchers("/login", "/rest/**")
+                .antMatchers("/login", "/rest/**","/dashboard/**")
                 .permitAll()
                 .antMatchers("/**")
                 .hasAnyRole("USER", "ADMIN")

src/main/java/com/utopiaindustries/controller/DashboardController.java

@@ -0,0 +1,32 @@
+package com.utopiaindustries.controller;
+
+import com.utopiaindustries.service.DashboardService;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.ui.Model;
+
+import java.time.LocalDate;
+
+@Controller
+@RequestMapping("/dashboard")
+public class DashboardController {
+
+    private final DashboardService dashboardService;
+
+    public DashboardController(DashboardService dashboardService) {
+        this.dashboardService = dashboardService;
+    }
+
+    @GetMapping("/{lineNumber}")
+    public String getDashboard(@PathVariable("lineNumber") String lineNumber, Model model) {
+        model.addAttribute("refresh", true);
+        model.addAttribute("phases", dashboardService.getPhasesProgressDayWise(lineNumber));
+        model.addAttribute("date", LocalDate.now());
+        model.addAttribute("day", LocalDate.now().getDayOfWeek());
+        model.addAttribute("detail", dashboardService.getLineDetails(lineNumber) );
+
+        return "dashboard";
+    }
+}

src/main/java/com/utopiaindustries/controller/FinishingController.java

@@ -83,7 +83,6 @@ public class FinishingController {
 
     @GetMapping("segregate-inventory")
     public String segregateFinishedItems(Model model) {
-        model.addAttribute("accounts", inventoryAccountService.findInventoryAccountsForFinishedItems() );
         model.addAttribute("wrapper", new FinishedItemWrapper());
         return "/finishing/segregate-inventory";
     }
@@ -94,12 +93,12 @@ public class FinishingController {
                                                 RedirectAttributes redirectAttributes,
                                                 Model model) {
         try {
-            inventoryService.segregateFinishedItems( wrapper );
+            inventoryService.segregateFinishedItems(wrapper, wrapper.getQaStatus());
             redirectAttributes.addFlashAttribute("success", "Items Successfully saved !");
         } catch (Exception e) {
             redirectAttributes.addFlashAttribute("error", e.getMessage());
         }
-        return "redirect:/finishing/finished-items";
+        return "redirect:/finishing/segregate-inventory";
     }
 
 }

src/main/java/com/utopiaindustries/controller/InventoryAccountController.java

@@ -1,16 +1,15 @@
 package com.utopiaindustries.controller;
 
-import com.utopiaindustries.auth.AdminRole;
+import com.utopiaindustries.auth.InventoryAccountRole;
 import com.utopiaindustries.model.ctp.InventoryAccount;
 import com.utopiaindustries.service.InventoryAccountService;
-import com.utopiaindustries.util.StringUtils;
 import org.springframework.stereotype.Controller;
 import org.springframework.ui.Model;
 import org.springframework.web.bind.annotation.*;
 import org.springframework.web.servlet.mvc.support.RedirectAttributes;
 
 @Controller
-@AdminRole
+@InventoryAccountRole
 @RequestMapping( "/inventory-accounts" )
 public class InventoryAccountController {
 

src/main/java/com/utopiaindustries/controller/JobCardController.java

@@ -8,6 +8,9 @@ import com.utopiaindustries.service.InventoryAccountService;
 import com.utopiaindustries.service.JobCardService;
 import com.utopiaindustries.service.LocationService;
 import com.utopiaindustries.util.StringUtils;
+import org.springframework.core.io.InputStreamResource;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
 import org.springframework.stereotype.Controller;
 import org.springframework.ui.Model;
 import org.springframework.web.bind.annotation.*;
@@ -173,6 +176,11 @@ public class JobCardController {
         return "job-card-view";
     }
 
+    @GetMapping( value = "/pdf/{id}", produces = MediaType.APPLICATION_PDF_VALUE )
+    public ResponseEntity<InputStreamResource> generateJobCardPdf(@PathVariable long id, Model model ) throws Exception {
+        return jobCardService.getJobCardReceivingPdf(id,model);
+    }
+
     private ArrayList<LocalDate> generateDateList(LocalDate start, LocalDate end) {
         ArrayList<LocalDate> localDates = new ArrayList<>();
         while (start.isBefore(end)) {

src/main/java/com/utopiaindustries/controller/POStatusController.java

@@ -0,0 +1,56 @@
+package com.utopiaindustries.controller;
+
+import com.utopiaindustries.auth.PurchaseOrderCTPRole;
+import com.utopiaindustries.model.ctp.POsDetails;
+import com.utopiaindustries.service.InventoryAccountService;
+import com.utopiaindustries.service.PurchaseOrderService;
+import com.utopiaindustries.service.ReportingService;
+import com.utopiaindustries.service.SummaryInventoryReportService;
+import org.springframework.core.io.InputStreamResource;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Controller;
+import org.springframework.ui.Model;
+import org.springframework.web.bind.annotation.*;
+
+@Controller
+@RequestMapping("/po-status")
+@PurchaseOrderCTPRole
+public class POStatusController {
+
+    private final ReportingService reportingService;
+    private final PurchaseOrderService purchaseOrderService;
+
+
+    public POStatusController(ReportingService reportingService, PurchaseOrderService purchaseOrderService) {
+        this.reportingService = reportingService;
+        this.purchaseOrderService = purchaseOrderService;
+    }
+
+    @GetMapping
+    public String homePage( Model model ){
+        return "redirect:/po-status/all-pos";
+    }
+
+    @GetMapping( "/all-pos")
+    public String poReport(@RequestParam(value = "poName", required = false) String poName, Model model){
+
+        model.addAttribute("allPOs",  reportingService.getAllPOs(poName));
+        return "/reporting/po-report";
+    }
+
+    @GetMapping( value = "/po-report-view/{poId}" )
+    public String showJobCardDetail(@PathVariable("poId") long poId, @RequestParam(value = "select-date", required = false) String selectDate ,
+                                    Model model ){
+        model.addAttribute("allJobCard",  reportingService.getAllPoJobCards(poId, selectDate));
+        return "/reporting/po-job-card-report";
+    }
+
+    @GetMapping(value = "/generate-po-pdf", produces = MediaType.APPLICATION_PDF_VALUE)
+    public ResponseEntity<InputStreamResource> sendPoAndReturnPdf(@ModelAttribute POsDetails pOsDetails,
+                                                                  @RequestParam(required = false, defaultValue = "true") boolean includeJobCard,
+                                                                  @RequestParam(required = false, defaultValue = "true") boolean includeStoreDetails,
+                                                                  Model model) throws Exception{
+        return purchaseOrderService.generatePOPdf(pOsDetails, model, includeJobCard, includeStoreDetails);
+    }
+}

src/main/java/com/utopiaindustries/controller/PackagingController.java

@@ -1,14 +1,15 @@
 package com.utopiaindustries.controller;
 
 import com.utopiaindustries.auth.PackagingRole;
+import com.utopiaindustries.model.ctp.FinishedItemWrapper;
 import com.utopiaindustries.service.InventoryAccountService;
 import com.utopiaindustries.service.LocationService;
+import com.utopiaindustries.service.PackagingService;
 import com.utopiaindustries.util.StringUtils;
 import org.springframework.stereotype.Controller;
 import org.springframework.ui.Model;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.servlet.mvc.support.RedirectAttributes;
 
 import java.time.LocalDate;
 
@@ -17,19 +18,40 @@ import java.time.LocalDate;
 @RequestMapping("/packaging" )
 public class PackagingController {
 
-
     private final InventoryAccountService inventoryAccountService;
+    private final PackagingService packagingService;
     private final LocationService locationService;
 
-    public PackagingController(InventoryAccountService inventoryAccountService, LocationService locationService) {
+    public PackagingController(InventoryAccountService inventoryAccountService, PackagingService packagingService, LocationService locationService) {
         this.inventoryAccountService = inventoryAccountService;
+        this.packagingService = packagingService;
         this.locationService = locationService;
     }
 
-
     @GetMapping
     public String showHome(Model model ){
-        return "redirect:/packaging/inventory-accounts";
+        return "redirect:/packaging/receive-inventory";
+    }
+
+    @GetMapping("/receive-inventory")
+    public String packagingItemReceive( Model model ){
+        model.addAttribute("accounts", inventoryAccountService.findInventoryAccounts(6L));
+        model.addAttribute("wrapper", new FinishedItemWrapper() );
+        return "/packaging/receive-inventory-form";
+    }
+
+
+    @PostMapping( "/packaging-items" )
+    public String packagingItems( @ModelAttribute FinishedItemWrapper wrapper,
+                                                 RedirectAttributes redirectAttributes,
+                                                 Model model ){
+        try {
+            packagingService.createPackagingItem( wrapper );
+            redirectAttributes.addFlashAttribute("success", "Items Successfully received !" );
+        } catch ( Exception  e ){
+            redirectAttributes.addFlashAttribute("error", e.getMessage() );
+        }
+        return "redirect:/packaging/receive-inventory";
     }
 
     @GetMapping( "/inventory-accounts" )

src/main/java/com/utopiaindustries/controller/PurchaseOrderCTPController.java

@@ -0,0 +1,96 @@
+package com.utopiaindustries.controller;
+
+import com.utopiaindustries.auth.PurchaseOrderCTPRole;
+import com.utopiaindustries.model.ctp.JobCard;
+import com.utopiaindustries.model.ctp.PurchaseOrderCTP;
+import com.utopiaindustries.service.PurchaseOrderCTPService;
+import com.utopiaindustries.util.StringUtils;
+import org.springframework.security.core.parameters.P;
+import org.springframework.stereotype.Controller;
+import org.springframework.ui.Model;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.servlet.mvc.support.RedirectAttributes;
+
+import java.time.LocalDate;
+import java.util.List;
+
+@Controller
+@RequestMapping("/purchase-order")
+@PurchaseOrderCTPRole
+
+public class PurchaseOrderCTPController {
+    private final PurchaseOrderCTPService purchaseOrderCTPService;
+
+    public PurchaseOrderCTPController(PurchaseOrderCTPService purchaseOrderCTPService) {
+        this.purchaseOrderCTPService = purchaseOrderCTPService;
+    }
+
+    @GetMapping
+    public String showJobCardList(  @RequestParam( value = "purchaseOrderCode", required = false ) String purchaseOrderCode,
+                                    @RequestParam( value = "articleName", required = false ) String articleName,
+                                    @RequestParam( value = "created-start-date", required = false ) String createdStartDate,
+                                    @RequestParam( value = "created-end-date", required = false ) String createdEndDate,
+                                    @RequestParam( value = "limit" , required = false) Long limit,
+                                    Model model ){
+
+        LocalDate startDate = StringUtils.isNullOrEmpty(createdStartDate) ? LocalDate.now().minusDays(30) : LocalDate.parse(createdStartDate);
+        LocalDate endDate = StringUtils.isNullOrEmpty(createdEndDate) ? LocalDate.now() : LocalDate.parse(createdEndDate);
+        model.addAttribute("purchaseOrder", purchaseOrderCTPService.getAllPurchaseOrderCtp(purchaseOrderCode, articleName, startDate.toString(), endDate.toString(), limit) );
+        model.addAttribute("startDate", startDate);
+        model.addAttribute("endDate", endDate);
+        return "/purchaseOrder/purchase-order-list";
+    }
+
+    @GetMapping( "/new" )
+    public String showPurchaseOrderCTPForm( Model model ){
+        model.addAttribute("purchaseOrder", purchaseOrderCTPService.createNewPurchaseOrderCTP() );
+        return "/purchaseOrder/purchase-order-form";
+    }
+
+    @GetMapping( value = "/edit/{id}" )
+    public String showJobCardEditForm( @PathVariable("id") long id,
+                                       Model model ){
+        model.addAttribute("purchaseOrder", purchaseOrderCTPService.searchPurchaseOrderById( id ) );
+        return "/purchaseOrder/purchase-order-form";
+    }
+
+    /*
+     *  draft
+     * */
+    @PostMapping( value ="/edit" , params = "user=draft" )
+    public String saveJobCard( @ModelAttribute PurchaseOrderCTP purchaseOrderCTP,
+                               RedirectAttributes redirectAttributes,
+                               Model model ){
+        try {
+            purchaseOrderCTP.setStatus( PurchaseOrderCTP.Status.DRAFT.name() );
+            purchaseOrderCTPService.save( purchaseOrderCTP );
+            redirectAttributes.addFlashAttribute("success", "Successfully saved!" );
+        } catch ( Exception ex ){
+            redirectAttributes.addFlashAttribute("error", ex.getMessage() );
+        }
+        return "redirect:/purchase-order";
+    }
+
+    @PostMapping( value ="/edit" , params = "user=post" )
+    public String postJobCard( @ModelAttribute PurchaseOrderCTP purchaseOrderCTP,
+                               RedirectAttributes redirectAttributes,
+                               Model model ){
+
+        try {
+            purchaseOrderCTP.setStatus( PurchaseOrderCTP.Status.POSTED.name() );
+            purchaseOrderCTPService.save( purchaseOrderCTP );
+            redirectAttributes.addFlashAttribute("success", "Successfully saved!" );
+        } catch ( Exception ex ){
+            redirectAttributes.addFlashAttribute("error", ex.getMessage() );
+        }
+        return "redirect:/purchase-order";
+    }
+
+    @GetMapping( "/store-items/{id}" )
+    public String getPOStoreItems( @PathVariable("id") long poId,
+                                                     Model model ){
+        model.addAttribute("storeItems",  purchaseOrderCTPService.getStoreItemsByPoId( poId ));
+        return "/reporting/po-store-items-table";
+    }
+
+}

src/main/java/com/utopiaindustries/controller/QualityControlController.java

@@ -87,11 +87,11 @@ public class QualityControlController {
     public String postFinishedItemsAfterQc(@ModelAttribute StitchedItemWrapper wrapper,
                                            RedirectAttributes redirectAttributes) {
         try {
-            inventoryService.createFinishedItemsAgainstStitchedItems( wrapper );
+            inventoryService.createFinishedItemsAgainstStitchedItems(wrapper, wrapper.getQaStatus());
             redirectAttributes.addFlashAttribute("success", " Finished Items Are Generated Against Stitched Items");
         } catch (Exception ex) {
             redirectAttributes.addFlashAttribute("error", ex.getMessage());
         }
-        return "redirect:/quality-control/qc-finished-items";
+        return "redirect:/quality-control/qc-finished-item";
     }
 }

src/main/java/com/utopiaindustries/controller/ReportingController.java

@@ -1,15 +1,20 @@
 package com.utopiaindustries.controller;
 
-import com.utopiaindustries.auth.CuttingRole;
 import com.utopiaindustries.auth.ReportingRole;
+import com.utopiaindustries.model.ctp.POsDetails;
 import com.utopiaindustries.model.ctp.SummaryInventoryReport;
+import com.utopiaindustries.service.InventoryAccountService;
+import com.utopiaindustries.service.PurchaseOrderService;
+import com.utopiaindustries.service.ReportingService;
 import com.utopiaindustries.service.SummaryInventoryReportService;
 import com.utopiaindustries.util.StringUtils;
+import org.springframework.core.io.InputStreamResource;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
 import org.springframework.stereotype.Controller;
 import org.springframework.ui.Model;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.servlet.mvc.support.RedirectAttributes;
 
 import java.time.LocalDate;
 import java.util.ArrayList;
@@ -20,14 +25,26 @@ import java.util.Map;
 @ReportingRole
 @RequestMapping( "/reporting" )
 public class ReportingController {
+    private final ReportingService reportingService;
     private final SummaryInventoryReportService summaryInventoryReportService;
+    private final InventoryAccountService inventoryAccountService;
+    private final PurchaseOrderService purchaseOrderService;
 
-    public ReportingController(SummaryInventoryReportService summaryInventoryReportService2) {
+
+    public ReportingController(SummaryInventoryReportService summaryInventoryReportService2, ReportingService reportingService, InventoryAccountService inventoryAccountService, PurchaseOrderService purchaseOrderService) {
         this.summaryInventoryReportService = summaryInventoryReportService2;
+        this.reportingService = reportingService;
+        this.inventoryAccountService = inventoryAccountService;
+        this.purchaseOrderService = purchaseOrderService;
+    }
+
+    @GetMapping
+    public String homePage( Model model ){
+        return "redirect:/reporting/job-card-report";
     }
 
     @GetMapping( "/summary")
-    public String showMasterBundles(@RequestParam(value = "item-id", required = false ) String itemId, @RequestParam(value = "sku" , required = false) String sku, @RequestParam(value = "start-date", required = false) String startDate, @RequestParam(value = "end-date", required = false) String endDate, Model model ){
+    public String summary(@RequestParam(value = "item-id", required = false ) String itemId, @RequestParam(value = "sku" , required = false) String sku, @RequestParam(value = "start-date", required = false) String startDate, @RequestParam(value = "end-date", required = false) String endDate, Model model ){
 
         LocalDate startDate1 = StringUtils.isNullOrEmpty(startDate) ? LocalDate.now().minusDays(6) : LocalDate.parse(startDate);
         LocalDate endDate1 = StringUtils.isNullOrEmpty(endDate) ? LocalDate.now().plusDays(1) : LocalDate.parse(endDate);
@@ -40,6 +57,68 @@ public class ReportingController {
         return "/reporting/inventory-summary";
     }
 
+    @GetMapping( "/job-card-report")
+    public String jobCardReport(@RequestParam( value = "job-card-id", required = false ) String jobCardId,
+                                Model model, RedirectAttributes redirectAttributes ){
+        if( jobCardId == null || jobCardId.isEmpty()) {
+            redirectAttributes.addFlashAttribute("error", "Please Re-Select Job Card" );
+            return "/reporting/job-card-report";
+        }
+        model.addAttribute("totalProduction",  reportingService.getTotalProduction(jobCardId));
+        model.addAttribute("phasesTimes",  reportingService.getEachPhaseTotalTime(jobCardId));
+        model.addAttribute("segregateItems",  reportingService.getSegregateItems(jobCardId));
+        model.addAttribute("pendingStatus",  reportingService.countPendingItemsOnDifferentPhases(jobCardId));
+        model.addAttribute("completeProduction",  reportingService.getCompleteProduction(jobCardId));
+        model.addAttribute("jobCardProgress",  reportingService.getJobCardProgress(jobCardId));
+        model.addAttribute("cuttingDetails",  reportingService.getCuttingDetails(jobCardId));
+        model.addAttribute("stitchingDetails",  reportingService.getStitchingDetails(jobCardId));
+        model.addAttribute("dailyProgress",  reportingService.getPhasesProgressDayWise(jobCardId));
+
+        return "/reporting/job-card-report";
+    }
+
+    @GetMapping( value = "/cutting-report" )
+    public String cuttingReport(@RequestParam(value = "job-card-id", required = false ) String jobCardId, @RequestParam(value = "accountId" , required = false) String accountId, @RequestParam(value = "start-date", required = false) String startDate, @RequestParam(value = "end-date", required = false) String endDate,  Model model ){
+
+        LocalDate startDate1 = StringUtils.isNullOrEmpty(startDate) ? LocalDate.now().minusDays(31) : LocalDate.parse(startDate);
+        LocalDate endDate1 = StringUtils.isNullOrEmpty(endDate) ? LocalDate.now() : LocalDate.parse(endDate);
+        model.addAttribute("startDate", startDate1);
+        model.addAttribute("endDate", endDate1);
+        model.addAttribute("accounts", inventoryAccountService.getAllCuttingAccounts() );
+        model.addAttribute("cutting",reportingService.getCuttingTableDetails(jobCardId, accountId, startDate1.toString(), endDate1.toString()));
+
+        return "/reporting/cutting-report";
+    }
+
+    @GetMapping( value = "/stitching-report" )
+    public String stitchingReport(@RequestParam(value = "job-card-id", required = false ) String jobCardId, @RequestParam(value = "accountId" , required = false) String accountId, @RequestParam(value = "start-date", required = false) String startDate, @RequestParam(value = "end-date", required = false) String endDate,  Model model ){
+
+        LocalDate startDate1 = StringUtils.isNullOrEmpty(startDate) ? LocalDate.now().minusDays(31) : LocalDate.parse(startDate);
+        LocalDate endDate1 = StringUtils.isNullOrEmpty(endDate) ? LocalDate.now() : LocalDate.parse(endDate);
+        model.addAttribute("startDate", startDate1);
+        model.addAttribute("endDate", endDate1);
+        model.addAttribute("accounts" , inventoryAccountService.findInventoryAccounts( 2L ) );
+        model.addAttribute("stitching",reportingService.getStitchingDetails(jobCardId, accountId, startDate1.toString(), endDate1.toString()));
+
+        return "/reporting/stitching-report";
+    }
+
+    @GetMapping( "/inventory-transactions" )
+    public String getInventoryTransactionsByAccount( @RequestParam( value = "account-id", required = false) String accountId,
+                                                     @RequestParam( value = "jobCard-id", required = false) String jobCardId,
+                                                     @RequestParam( value = "sku", required = false) String sku,
+                                                     @RequestParam( value = "startDate", required = false) String startDate,
+                                                     @RequestParam( value = "endDate", required = false) String endDate,
+                                                     Model model ){
+
+        LocalDate startDate1 = StringUtils.isNullOrEmpty(startDate) ? LocalDate.now().minusDays(31) : LocalDate.parse(startDate);
+        LocalDate endDate1 = StringUtils.isNullOrEmpty(endDate) ? LocalDate.now() : LocalDate.parse(endDate);
+        model.addAttribute("startDate", startDate1);
+        model.addAttribute("endDate", endDate1);
+        model.addAttribute("transactions", reportingService.stitchingItemsTransactions( jobCardId, accountId, sku, startDate1.toString(), endDate1.toString() ));
+        return "/reporting/accounts-transaction-table";
+    }
+
     private ArrayList<LocalDate> generateDateList(LocalDate start, LocalDate end) {
         ArrayList<LocalDate> localDates = new ArrayList<>();
         while (start.isBefore(end)) {

src/main/java/com/utopiaindustries/controller/StitchingController.java

@@ -1,11 +1,9 @@
 package com.utopiaindustries.controller;
 
 import com.utopiaindustries.auth.StitchingRole;
-import com.utopiaindustries.model.ctp.JobCard;
-import com.utopiaindustries.model.ctp.StitchingOfflineItem;
+import com.utopiaindustries.model.ctp.*;
 import com.utopiaindustries.service.*;
 import com.utopiaindustries.util.StringUtils;
-import org.springframework.http.ResponseEntity;
 import org.springframework.stereotype.Controller;
 import org.springframework.ui.Model;
 import org.springframework.web.bind.annotation.*;
@@ -76,8 +74,6 @@ public class StitchingController {
                                          @RequestParam( value = "count", required = false ) Long count,
                                          Model model ) {
         // 2 for stitching
-
-
         model.addAttribute("accounts", inventoryAccountService.getInventoryAccounts(id, title, active, createdBy, startDate, endDate, siteId, count, "PROCESS", "2", false));
         model.addAttribute("locations", locationService.findAll() );
         if(count == null){
@@ -95,13 +91,13 @@ public class StitchingController {
                                             @RequestParam( value = "sku", required = false ) String sku,
                                             @RequestParam( value = "start-date", required = false) String startDate,
                                             @RequestParam( value = "end-date", required = false ) String endDate,
-                                            @RequestParam( value = "job-card-id", required = false ) String jobCardId,
+                                            @RequestParam(value = "bundle-id", required = false) Long bundleId,
                                             @RequestParam( value = "count", required = false, defaultValue = "100") Long count,
-                                            Model model
-    ,RedirectAttributes redirect){
+                                            @RequestParam( value = "status", required = false) String status,
+                                            Model model, RedirectAttributes redirect){
         LocalDate startDate1 = StringUtils.isNullOrEmpty(startDate) ? LocalDate.now().minusDays(30) : LocalDate.parse(startDate);
         LocalDate endDate1 = StringUtils.isNullOrEmpty(endDate) ? LocalDate.now() : LocalDate.parse(endDate);
-        List<StitchingOfflineItem> itemList = bundleService.getStitchedOfflineItems( id, itemId, sku, startDate, endDate, jobCardId ,count );
+        List<StitchingOfflineItem> itemList = bundleService.getStitchedOfflineItems( id, itemId, sku, status, startDate, endDate, bundleId ,count );
         model.addAttribute("items", itemList ) ;
         model.addAttribute("startDate", startDate1);
         model.addAttribute("endDate", endDate1);
@@ -111,22 +107,22 @@ public class StitchingController {
     @GetMapping( "/create-stitching-items")
     public String createFinishItems( Model model ){
         model.addAttribute("accounts" , inventoryAccountService.findInventoryAccounts( 2L ) );
-        model.addAttribute("jobCard", jobCardService.createNewJobCard() );
+        model.addAttribute("bundleWrapper", new BundleWrapper() );
     return "/stitching/stitching-item-form";
     }
 
     @PostMapping( "/create-stitching-items" )
-    public String createStitchedOfflineItems( @ModelAttribute JobCard jobCard,
+    public String createStitchedOfflineItems( @ModelAttribute BundleWrapper bundleWrapper,
                                                RedirectAttributes redirectAttributes,
                                                Model model ){
         try {
-            inventoryService.createStitchingOfflineItemsFromJobCard( jobCard );
-            redirectAttributes.addFlashAttribute("success", "Finished Item Created Successfully");
+            inventoryService.createStitchingOfflineItemsFromJobCard( bundleWrapper );
+            redirectAttributes.addFlashAttribute("success", "Stitch Items Created Successfully");
         } catch ( Exception exception ){
             exception.printStackTrace();
             redirectAttributes.addFlashAttribute( "error", exception.getMessage() );
         }
-        return "redirect:/stitching/stitching-offline-items";
+        return "redirect:/stitching/create-stitching-items";
     }
 
     @PostMapping( "/generate-barcodes" )

src/main/java/com/utopiaindustries/controller/StoreController.java

@@ -0,0 +1,72 @@
+package com.utopiaindustries.controller;
+
+import com.utopiaindustries.auth.StoreRole;
+import com.utopiaindustries.model.ctp.FinishedItemWrapper;
+import com.utopiaindustries.service.InventoryAccountService;
+import com.utopiaindustries.service.LocationService;
+import com.utopiaindustries.service.StoreService;
+import com.utopiaindustries.util.StringUtils;
+import org.springframework.stereotype.Controller;
+import org.springframework.ui.Model;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.servlet.mvc.support.RedirectAttributes;
+
+@Controller
+@StoreRole
+@RequestMapping( "/store" )
+public class StoreController {
+
+    private final InventoryAccountService inventoryAccountService;
+    private final StoreService storeService;
+    private final LocationService locationService;
+
+    public StoreController(InventoryAccountService inventoryAccountService, StoreService storeService, LocationService locationService) {
+        this.inventoryAccountService = inventoryAccountService;
+        this.storeService = storeService;
+        this.locationService = locationService;
+    }
+
+    @GetMapping
+    public String showHome(Model model ){
+        return "redirect:/store/receive-inventory";
+    }
+
+    @GetMapping("/receive-inventory")
+    public String packagingItemReceive( Model model ){
+        model.addAttribute("accounts", inventoryAccountService.findInventoryAccounts(9L));
+        model.addAttribute("wrapper", new FinishedItemWrapper() );
+        return "/store/receive-inventory-form";
+    }
+
+
+    @PostMapping( "/store-items" )
+    public String packagingItems( @ModelAttribute FinishedItemWrapper wrapper,
+                                  RedirectAttributes redirectAttributes,
+                                  Model model ){
+        try {
+            storeService.createStoreItems( wrapper );
+            redirectAttributes.addFlashAttribute("success", "Items Successfully received !" );
+        } catch ( Exception  e ){
+            redirectAttributes.addFlashAttribute("error", e.getMessage() );
+        }
+        return "redirect:/store/receive-inventory";
+    }
+
+    @GetMapping( "/inventory-accounts" )
+    public String showInventoryAccounts(@RequestParam( value = "id", required = false ) String id,
+                                        @RequestParam( value = "title", required = false) String title,
+                                        @RequestParam( value = "active", required = false ) String active,
+                                        @RequestParam( value = "created-by", required = false ) String createdBy,
+                                        @RequestParam( value = "start-date", required = false ) String startDate,
+                                        @RequestParam( value = "end-date", required = false ) String endDate,
+                                        @RequestParam( value = "site-id", required = false ) String siteId,
+                                        @RequestParam( value = "count", required = false ) Long count,
+                                        Model model ){
+        if(StringUtils.isNullOrEmpty( active )){
+            return "redirect:/store/inventory-accounts?id=&title=&active=1&created-by=&start-date=&end-date=&site-id=&site-title=&count=100";
+        }
+        model.addAttribute("accounts", inventoryAccountService.findInventoryAccounts(9L));
+        model.addAttribute("locations", locationService.findAll() );
+        return "/store/inventory-accounts";
+    }
+}

src/main/java/com/utopiaindustries/dao/ctp/BundleDAO.java

@@ -21,14 +21,17 @@ public class BundleDAO {
 	private final String SELECT_QUERY = String.format( "SELECT * FROM %s WHERE id = :id", TABLE_NAME );
 	private final String SELECT_ALL_QUERY = String.format( "SELECT * FROM %s ORDER BY id DESC", TABLE_NAME );
 	private final String DELETE_QUERY = String.format( "DELETE FROM %s WHERE id = :id", TABLE_NAME );
-	private final String INSERT_QUERY = String.format( "INSERT INTO %s (id, item_id, sku, wrap_quantity, barcode, type, created_by, created_at, job_card_id, master_bundle_id) VALUES (:id, :item_id, :sku, :wrap_quantity, :barcode, :type, :created_by, :created_at, :job_card_id, :master_bundle_id) ON DUPLICATE KEY UPDATE item_id = VALUES(item_id), sku = VALUES(sku), wrap_quantity = VALUES(wrap_quantity), barcode = VALUES(barcode), type = VALUES(type), created_by = VALUES(created_by), created_at = VALUES(created_at), job_card_id = VALUES(job_card_id), master_bundle_id = VALUES(master_bundle_id)", TABLE_NAME );
+	private final String INSERT_QUERY = String.format( "INSERT INTO %s (id, item_id, sku, wrap_quantity, barcode, type, created_by, created_at, job_card_id, master_bundle_id, production) VALUES (:id, :item_id, :sku, :wrap_quantity, :barcode, :type, :created_by, :created_at, :job_card_id, :master_bundle_id, :production) ON DUPLICATE KEY UPDATE item_id = VALUES(item_id), sku = VALUES(sku), wrap_quantity = VALUES(wrap_quantity), barcode = VALUES(barcode), type = VALUES(type), created_by = VALUES(created_by), created_at = VALUES(created_at), job_card_id = VALUES(job_card_id), master_bundle_id = VALUES(master_bundle_id), production = VALUES(production)", TABLE_NAME );
 	private final String SELECT_BY_TERM_QUERY = String.format( "SELECT * FROM %s WHERE (id = :id OR sku LIKE :sku OR type LIKE :type OR barcode LIKE :barcode) AND master_bundle_id =0", TABLE_NAME );
 	private final String SELECT_BY_LIMIT = String.format( "SELECT * FROM %s ORDER BY id DESC LIMIT :limit", TABLE_NAME );
 	private final String SELECT_BY_MASTER_ID = String.format( "SELECT * FROM %s WHERE master_bundle_id = :master_bundle_id ORDER BY id DESC", TABLE_NAME );
 	private final String SELECT_BY_IDS = String.format( "SELECT * FROM %s WHERE id IN (:ids)", TABLE_NAME );
-	private final String SELECT_BY_ITEM_ID_AND_JOB_CARD = String.format( "SELECT * FROM %s WHERE item_id = :item_id AND job_card_id = :job_card_id", TABLE_NAME );
+	private final String SELECT_BY_JOB_CARD = String.format( "SELECT * FROM %s WHERE job_card_id = :job_card_id", TABLE_NAME );
 	private final String SELECT_BY_ITEM_IDS_AND_JOB_CARD = String.format( "SELECT * FROM %s WHERE item_id IN (:item_ids) AND job_card_id = :job_card_id", TABLE_NAME );
-
+	private final String SELECT_LIKE_BARCODE = String.format("SELECT * FROM %s WHERE barcode LIKE :barcode", TABLE_NAME);
+	private final String SELECT_FIRST_BUNDLE_BY_JOB_CARD = String.format("SELECT * FROM %s WHERE job_card_id = :job_card_id ORDER BY created_at ASC LIMIT 1", TABLE_NAME);
+	private final String SELECT_LAST_BUNDLE_BY_JOB_CARD = String.format("SELECT * FROM %s WHERE job_card_id = :job_card_id ORDER BY created_at DESC LIMIT 1", TABLE_NAME);
+	private final String SELECT_BY_JOB_CARD_AND_DATE = String.format( "SELECT * FROM %s WHERE job_card_id = :job_card_id AND (:start_date IS NULL OR :end_date IS NULL OR created_at BETWEEN :start_date AND :end_date)", TABLE_NAME );
 
 	public BundleDAO(NamedParameterJdbcTemplate namedParameterJdbcTemplate) {
 		this.namedParameterJdbcTemplate = namedParameterJdbcTemplate;
@@ -40,6 +43,7 @@ public class BundleDAO {
 		params.addValue( "id", bundle.getId() )
 			.addValue( "item_id", bundle.getItemId() )
 			.addValue( "sku", bundle.getSku() )
+			.addValue("production",bundle.getProduction())
 			.addValue( "wrap_quantity", bundle.getWrapQuantity() )
 			.addValue( "barcode", bundle.getBarcode() )
 			.addValue( "type", bundle.getType() )
@@ -61,6 +65,12 @@ public class BundleDAO {
 
 	}
 
+	public List<Bundle> findByBarcodeLike(String barcode) {
+		MapSqlParameterSource params = new MapSqlParameterSource();
+		params.addValue("barcode",  "%" + barcode + "%");
+		return namedParameterJdbcTemplate.query(SELECT_LIKE_BARCODE, params, new BundleRowMapper());
+	}
+
 	// find all
 	public List<Bundle> findAll() {
 		return namedParameterJdbcTemplate.query( SELECT_ALL_QUERY, new BundleRowMapper() );
@@ -124,11 +134,10 @@ public class BundleDAO {
 		return namedParameterJdbcTemplate.query( SELECT_BY_IDS , params, new BundleRowMapper() );
 	}
 
-	public List<Bundle> findByItemIdAndCardId( long itemId, long cardId ){
+	public List<Bundle> findByCardId( long cardId ){
 		MapSqlParameterSource params = new MapSqlParameterSource();
-		params.addValue("item_id", itemId );
 		params.addValue("job_card_id", cardId );
-		return namedParameterJdbcTemplate.query( SELECT_BY_ITEM_ID_AND_JOB_CARD, params, new BundleRowMapper() );
+		return namedParameterJdbcTemplate.query( SELECT_BY_JOB_CARD, params, new BundleRowMapper() );
 	}
 
 	public List<Bundle> findByItemIdsAndCardId( List<Long> itemIds, long cardId ){
@@ -138,4 +147,27 @@ public class BundleDAO {
 		params.addValue("job_card_id", cardId );
 		return namedParameterJdbcTemplate.query( SELECT_BY_ITEM_IDS_AND_JOB_CARD, params, new BundleRowMapper() );
 	}
+
+	public Bundle findFirstBundleByCardId(long cardId) {
+		MapSqlParameterSource params = new MapSqlParameterSource();
+		params.addValue("job_card_id", cardId);
+		return namedParameterJdbcTemplate.queryForObject(SELECT_FIRST_BUNDLE_BY_JOB_CARD, params, new BundleRowMapper());
+	}
+
+	public Bundle findLastBundleByCardId(long cardId) {
+		MapSqlParameterSource params = new MapSqlParameterSource();
+		params.addValue("job_card_id", cardId);
+		return namedParameterJdbcTemplate.query(SELECT_LAST_BUNDLE_BY_JOB_CARD, params, new BundleRowMapper())
+				.stream()
+				.findFirst().orElse(new Bundle());
+	}
+
+	public List<Bundle> findByCardIdAndDATE( long cardId, String startDate, String endDate){
+		MapSqlParameterSource params = new MapSqlParameterSource();
+		params.addValue("job_card_id", cardId );
+		params.addValue( "start_date", startDate );
+		params.addValue( "end_date", endDate );
+		return namedParameterJdbcTemplate.query( SELECT_BY_JOB_CARD_AND_DATE, params, new BundleRowMapper() );
+	}
+
 }

src/main/java/com/utopiaindustries/dao/ctp/BundleRowMapper.java

@@ -16,6 +16,7 @@ public class BundleRowMapper implements RowMapper<Bundle> {
 		bundle.setBarcode( rs.getString( "barcode" ) );
 		bundle.setType( rs.getString( "type" ) );
 		bundle.setCreatedBy( rs.getString( "created_by" ) );
+		bundle.setProduction(rs.getBigDecimal("production"));
 		if ( rs.getTimestamp( "created_at" ) != null ) {
 			bundle.setCreatedAt( rs.getTimestamp( "created_at" ).toLocalDateTime() );
 		}

src/main/java/com/utopiaindustries/dao/ctp/CutPieceDAO.java

@@ -21,8 +21,8 @@ public class CutPieceDAO {
 	private final String SELECT_ALL_QUERY = String.format( "SELECT * FROM %s ORDER BY id DESC", TABLE_NAME );
 	private final String DELETE_QUERY = String.format( "DELETE FROM %s WHERE id = :id", TABLE_NAME );
 	private final String SELECT_BY_ITEM_IDS = String.format( "SELECT * FROM %s WHERE job_card_item_id IN (:item_ids)", TABLE_NAME );
-	private final String SELECT_BY_ITEM_IDS_AND_GROUP_BY = String.format( "SELECT  id,job_card_item_id,type,SUM(quantity) AS quantity FROM %s WHERE job_card_item_id IN (:item_ids) GROUP BY job_card_item_id, type", TABLE_NAME );
-	private final String INSERT_QUERY = String.format( "INSERT INTO %s (id, job_card_item_id, type, quantity) VALUES (:id, :job_card_item_id, :type, :quantity) ON DUPLICATE KEY UPDATE job_card_item_id = VALUES(job_card_item_id), type = VALUES(type), quantity = VALUES(quantity)", TABLE_NAME );
+	private final String SELECT_BY_ITEM_IDS_AND_GROUP_BY = String.format( "SELECT  id,job_card_item_id,`type`,SUM(quantity) AS quantity FROM %s WHERE job_card_item_id IN (:item_ids) GROUP BY job_card_item_id, `type`", TABLE_NAME );
+	private final String INSERT_QUERY = String.format( "INSERT INTO %s (id, job_card_item_id, `type`, quantity) VALUES (:id, :job_card_item_id, :type, :quantity) ON DUPLICATE KEY UPDATE job_card_item_id = VALUES(job_card_item_id), `type` = VALUES(`type`), quantity = VALUES(quantity)", TABLE_NAME );
 	private final String DELETE_BY_ITEM_ID = String.format( "DELETE FROM %s WHERE job_card_item_id = :job_card_item_id", TABLE_NAME );
 
 	public CutPieceDAO(NamedParameterJdbcTemplate namedParameterJdbcTemplate) {

src/main/java/com/utopiaindustries/dao/ctp/CutPieceTypeDAO.java

@@ -21,6 +21,7 @@ public class CutPieceTypeDAO {
 	private final String SELECT_ALL_QUERY = String.format( "SELECT * FROM %s ORDER BY id DESC", TABLE_NAME );
 	private final String DELETE_QUERY = String.format( "DELETE FROM %s WHERE id = :id", TABLE_NAME );
 	private final String INSERT_QUERY = String.format( "INSERT INTO %s (id, title) VALUES (:id, :title) ON DUPLICATE KEY UPDATE title = VALUES(title)", TABLE_NAME );
+	private final String SELECT_BY_TITLE = String.format("SELECT * FROM %s WHERE title = :title", TABLE_NAME);
 
 	public CutPieceTypeDAO(NamedParameterJdbcTemplate namedParameterJdbcTemplate) {
 		this.namedParameterJdbcTemplate = namedParameterJdbcTemplate;
@@ -30,7 +31,7 @@ public class CutPieceTypeDAO {
 	private MapSqlParameterSource prepareInsertQueryParams( CutPieceType cutPieceType ) {
 		MapSqlParameterSource params = new MapSqlParameterSource();
 		params.addValue( "id", cutPieceType.getId() )
-			.addValue( "title", cutPieceType.getTitle() );
+			.addValue( "title", cutPieceType.getType() );
 		return params;
 	}
 
@@ -44,6 +45,16 @@ public class CutPieceTypeDAO {
 				.orElse( new CutPieceType() );
 	}
 
+	// find
+	public CutPieceType findByTitle( String title ) {
+		MapSqlParameterSource params = new MapSqlParameterSource();
+		params.addValue( "title", title );
+		return namedParameterJdbcTemplate.query( SELECT_BY_TITLE, params, new CutPieceTypeRowMapper() )
+				.stream()
+				.findFirst()
+				.orElse( new CutPieceType() );
+	}
+
 	// find all
 	public List<CutPieceType> findAll() {
 		return namedParameterJdbcTemplate.query( SELECT_ALL_QUERY, new CutPieceTypeRowMapper() );

src/main/java/com/utopiaindustries/dao/ctp/CutPieceTypeRowMapper.java

@@ -10,7 +10,7 @@ public class CutPieceTypeRowMapper implements RowMapper<CutPieceType> {
 	public CutPieceType mapRow( ResultSet rs, int rowNum ) throws SQLException {
 		CutPieceType cutPieceType = new CutPieceType();
 		cutPieceType.setId( rs.getLong( "id" ) );
-		cutPieceType.setTitle( rs.getString( "title" ) );
+		cutPieceType.setType( rs.getString( "title" ) );
 		return cutPieceType;
 	}
 }

src/main/java/com/utopiaindustries/dao/ctp/FinishedItemDAO.java

@@ -1,7 +1,6 @@
 package com.utopiaindustries.dao.ctp;
 
 import com.utopiaindustries.model.ctp.FinishedItem;
-import com.utopiaindustries.model.ctp.JobCard;
 import com.utopiaindustries.model.ctp.StitchingOfflineItem;
 import com.utopiaindustries.util.KeyHolderFunctions;
 import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
@@ -22,16 +21,20 @@ public class FinishedItemDAO {
     private final String TABLE_NAME = "cut_to_pack.finished_item";
     private final String SELECT_QUERY = String.format("SELECT * FROM %s WHERE id = :id", TABLE_NAME);
     private final String SELECT_ALL_QUERY = String.format("SELECT * FROM %s ORDER BY id DESC", TABLE_NAME);
-	private final String SELECT_QUERY_BY_BARCODE_QA_STATUS = String.format( "SELECT case when EXISTS ( SELECT * FROM %s WHERE barcode = :barcode AND (qa_status = 'APPROVED' OR qa_status = 'WASHED') ) then true else false End as Result", TABLE_NAME );
+    private final String SELECT_QUERY_BY_BARCODE_QA_STATUS =String.format("SELECT CASE WHEN EXISTS (SELECT 1 FROM %s WHERE barcode = :barcode AND (is_store = TRUE OR is_packed = TRUE)) THEN TRUE ELSE FALSE END AS result", TABLE_NAME);
     private final String SELECT_QUERY_BY_JOB_CARD = String.format("SELECT * FROM %s WHERE job_card_id = :job_card_id", TABLE_NAME);
     private final String DELETE_QUERY = String.format("DELETE FROM %s WHERE id = :id", TABLE_NAME);
-	private final String INSERT_QUERY = String.format( "INSERT INTO %s (id, item_id, sku, barcode, created_at, created_by, job_card_id, is_qa, stitched_item_id, is_segregated, qa_status) VALUES (:id, :item_id, :sku, :barcode, :created_at, :created_by, :job_card_id, :is_qa, :stitched_item_id, :is_segregated, :qa_status) ON DUPLICATE KEY UPDATE item_id = VALUES(item_id), sku = VALUES(sku), barcode = VALUES(barcode), created_at = VALUES(created_at), created_by = VALUES(created_by), job_card_id = VALUES(job_card_id), is_qa = VALUES(is_qa), stitched_item_id = VALUES(stitched_item_id), is_segregated = VALUES(is_segregated), qa_status = VALUES(qa_status)", TABLE_NAME );
+    private final String INSERT_QUERY = String.format("INSERT INTO %s (id, item_id, sku, barcode, created_at, created_by, job_card_id, is_qa, stitched_item_id, is_segregated, qa_status, is_packed, operation_date, is_store) VALUES (:id, :item_id, :sku, :barcode, :created_at, :created_by, :job_card_id, :is_qa, :stitched_item_id, :is_segregated, :qa_status, :is_packed, :operation_date, :is_store) ON DUPLICATE KEY UPDATE item_id = VALUES(item_id), sku = VALUES(sku), barcode = VALUES(barcode), created_at = VALUES(created_at), created_by = VALUES(created_by), job_card_id = VALUES(job_card_id), is_qa = VALUES(is_qa), stitched_item_id = VALUES(stitched_item_id), is_segregated = VALUES(is_segregated), qa_status = VALUES(qa_status), is_packed = VALUES(is_packed), operation_date = VALUES(operation_date), is_store = VALUES(is_store)", TABLE_NAME);
     private final String SELECT_BY_LIMIT = String.format("SELECT * FROM %s ORDER BY id DESC LIMIT :limit", TABLE_NAME);
     private final String SELECT_BY_IDS = String.format("SELECT * FROM %s WHERE id IN (:ids)", TABLE_NAME);
     private final String FIND_TOTAL_COUNT = String.format("SELECT COUNT(*) FROM %s  where job_card_id = :job_card_id And item_id = :item_id", TABLE_NAME);
-	private final String SELECT_BY_TERM = String.format( "SELECT * FROM %s WHERE barcode LIKE :term AND is_segregated = :is_segregated ORDER BY ID DESC", TABLE_NAME );
-	private final String SELECT_BY_STITCHED_ITEM_ID = String.format( "SELECT * FROM %s WHERE stitched_item_id = :stitched_item_id", TABLE_NAME );
+    private final String SELECT_BY_TERM = String.format("SELECT * FROM %s WHERE barcode LIKE :term AND is_qa = :is_qa AND is_packed = FALSE AND is_store = FALSE ORDER BY ID DESC", TABLE_NAME);
+    private final String SELECT_BY_TERM_FOR_PACKAGING = String.format("SELECT * FROM %s WHERE barcode LIKE :term AND is_segregated = :is_segregated AND qa_status = :qa_status AND is_packed = FALSE AND is_store = FALSE ORDER BY ID DESC", TABLE_NAME);
+    private final String SELECT_BY_STITCHED_ITEM_ID = String.format("SELECT * FROM %s WHERE stitched_item_id = :stitched_item_id AND is_packed = FALSE", TABLE_NAME);
     private final String SELECT_BY_STITCHED_ITEM_IDS = String.format("SELECT * FROM %s WHERE stitched_item_id IN (:stitched_item_ids)", TABLE_NAME);
+    private final String COUNT_TOTAL_FINISH_ITEM = String.format("SELECT COUNT(*) FROM %s WHERE job_card_id = :job_card_id AND is_qa = TRUE AND (is_segregated IS TRUE OR is_store = TRUE) ", TABLE_NAME);
+    private final String SELECT_BY_JOB_CARD_AND_DATE = String.format("SELECT * FROM %s WHERE job_card_id = :job_card_id AND (:start_date IS NULL OR :end_date IS NULL OR created_at BETWEEN :start_date AND :end_date)", TABLE_NAME);
+    private final String SELECT_BY_DATE_QA_STATUS = String.format( "SELECT COUNT(*) FROM %s WHERE (:start_date IS NULL OR operation_date >= :start_date) AND operation_date <= :end_date AND qa_status = :qa_status AND id in (:ids) AND is_packed = FALSE AND is_qa = TRUE", TABLE_NAME );
 
     public FinishedItemDAO(NamedParameterJdbcTemplate namedParameterJdbcTemplate) {
         this.namedParameterJdbcTemplate = namedParameterJdbcTemplate;
@@ -50,7 +53,10 @@ public class FinishedItemDAO {
                 .addValue("is_qa", finishedItem.getIsQa())
                 .addValue("stitched_item_id", finishedItem.getStitchedItemId())
                 .addValue("is_segregated", finishedItem.getIsSegregated())
-			.addValue("qa_status", finishedItem.getQaStatus() );
+                .addValue("qa_status", finishedItem.getQaStatus())
+                .addValue("is_packed", finishedItem.isPackaging())
+                .addValue("is_store", finishedItem.isStore())
+                .addValue("operation_date", finishedItem.getOperationDate());
         return params;
     }
 
@@ -111,11 +117,19 @@ public class FinishedItemDAO {
         return namedParameterJdbcTemplate.query(SELECT_BY_IDS, params, new FinishedItemRowMapper());
     }
 
-	public List<FinishedItem> findByTerm( String term , boolean isSegregated ){
+    public List<FinishedItem> findByTerm(String term, boolean isQa) {
+        MapSqlParameterSource params = new MapSqlParameterSource();
+        params.addValue("term", "%" + term + "%");
+        params.addValue("is_qa", isQa);
+        return namedParameterJdbcTemplate.query(SELECT_BY_TERM, params, new FinishedItemRowMapper());
+    }
+
+    public List<FinishedItem> findByTermForPackaging(String term, boolean isSegregated, String qaStatus) {
         MapSqlParameterSource params = new MapSqlParameterSource();
         params.addValue("term", "%" + term + "%");
         params.addValue("is_segregated", isSegregated);
-		return namedParameterJdbcTemplate.query( SELECT_BY_TERM , params, new FinishedItemRowMapper() );
+        params.addValue("qa_status", qaStatus);
+        return namedParameterJdbcTemplate.query(SELECT_BY_TERM_FOR_PACKAGING, params, new FinishedItemRowMapper());
     }
 
     // find By job card Id
@@ -168,4 +182,30 @@ public class FinishedItemDAO {
         }
         return items;
     }
+
+    public Long calculateTotalFinishItem(long jobCardId) {
+        MapSqlParameterSource params = new MapSqlParameterSource();
+        params.addValue("job_card_id", jobCardId);
+        Long count = namedParameterJdbcTemplate.queryForObject(COUNT_TOTAL_FINISH_ITEM, params, Long.class);
+        return count != null ? count : 0;
+    }
+
+    public List<FinishedItem> calculateTotalFinishItem(long jobCardId, String startDate, String endDate) {
+        MapSqlParameterSource params = new MapSqlParameterSource();
+        params.addValue("job_card_id", jobCardId);
+        params.addValue("start_date", startDate);
+        params.addValue("end_date", endDate);
+        return namedParameterJdbcTemplate.query(SELECT_BY_JOB_CARD_AND_DATE, params, new FinishedItemRowMapper());
+    }
+
+    public Long findByOperationDateAndIdsAndQaStatus(String startDate, String endDate, String qaStatus, List<Long> ids){
+        MapSqlParameterSource params = new MapSqlParameterSource();
+        params.addValue( "start_date", startDate );
+        params.addValue( "end_date", endDate );
+        params.addValue( "qa_status", qaStatus );
+        params.addValue( "ids", ids );
+        Long count = namedParameterJdbcTemplate.queryForObject(SELECT_BY_DATE_QA_STATUS, params, Long.class);
+        return count != null ? count : 0;
+    }
+
 }

src/main/java/com/utopiaindustries/dao/ctp/FinishedItemRowMapper.java

@@ -16,12 +16,17 @@ public class FinishedItemRowMapper implements RowMapper<FinishedItem> {
 		if ( rs.getTimestamp( "created_at" ) != null ) {
 			finishedItem.setCreatedAt( rs.getTimestamp( "created_at" ).toLocalDateTime() );
 		}
+		if ( rs.getTimestamp( "operation_date" ) != null ) {
+			finishedItem.setOperationDate( rs.getTimestamp( "operation_date" ).toLocalDateTime() );
+		}
 		finishedItem.setCreatedBy( rs.getString( "created_by" ) );
 		finishedItem.setJobCardId( rs.getLong("job_card_id") );
 		finishedItem.setIsQa( rs.getBoolean("is_qa"));
 		finishedItem.setStitchedItemId( rs.getLong("stitched_item_id" ) );
 		finishedItem.setIsSegregated( rs.getBoolean( "is_segregated") );
 		finishedItem.setQaStatus( rs.getString("qa_status" ) );
+		finishedItem.setPackaging( rs.getBoolean("is_packed" ) );
+		finishedItem.setStore( rs.getBoolean("is_store" ) );
 		return finishedItem;
 	}
 }

src/main/java/com/utopiaindustries/dao/ctp/InventoryAccountDAO.java

@@ -20,13 +20,33 @@ public class InventoryAccountDAO {
 	private final String SELECT_QUERY = String.format( "SELECT * FROM %s WHERE id = :id", TABLE_NAME );
 	private final String SELECT_ALL_QUERY = String.format( "SELECT * FROM %s ORDER BY title DESC", TABLE_NAME );
 	private final String DELETE_QUERY = String.format( "DELETE FROM %s WHERE id = :id", TABLE_NAME );
-	private final String INSERT_QUERY = String.format( "INSERT INTO %s (id, title, parent_entity_type, parent_entity_id, active, created_by, created_at, location_site_id, notes, is_packaging) VALUES (:id, :title, :parent_entity_type, :parent_entity_id, :active, :created_by, :created_at, :location_site_id, :notes, :is_packaging) ON DUPLICATE KEY UPDATE title = VALUES(title), parent_entity_type = VALUES(parent_entity_type), parent_entity_id = VALUES(parent_entity_id), active = VALUES(active), created_by = VALUES(created_by), created_at = VALUES(created_at), location_site_id = VALUES(location_site_id), notes = VALUES(notes), is_packaging = VALUES(is_packaging)", TABLE_NAME );
+    private final String INSERT_QUERY = String.format(
+            "INSERT INTO %s (id, title, parent_entity_type, parent_entity_id, active, created_by, created_at, location_site_id, notes, is_packaging, article_name, shift_minutes, total_machines, efficiency, sam) " +
+                    "VALUES (:id, :title, :parent_entity_type, :parent_entity_id, :active, :created_by, :created_at, :location_site_id, :notes, :is_packaging, :article_name, :shift_minutes, :total_machines, :efficiency, :sam) " +
+                    "ON DUPLICATE KEY UPDATE " +
+                    "title = VALUES(title), " +
+                    "parent_entity_type = VALUES(parent_entity_type), " +
+                    "parent_entity_id = VALUES(parent_entity_id), " +
+                    "active = VALUES(active), " +
+                    "created_by = VALUES(created_by), " +
+                    "created_at = VALUES(created_at), " +
+                    "location_site_id = VALUES(location_site_id), " +
+                    "notes = VALUES(notes), " +
+                    "is_packaging = VALUES(is_packaging), " +
+                    "article_name = VALUES(article_name), " +
+                    "shift_minutes = VALUES(shift_minutes), " +
+                    "efficiency = VALUES(efficiency), " +
+                    "sam = VALUES(sam), " +
+                    "total_machines = VALUES(total_machines)",
+            TABLE_NAME
+    );
 	private final String SELECT_BY_IDS =  String.format( "SELECT * FROM %s WHERE id IN (:ids)", TABLE_NAME );
 	private final String SELECT_BY_IDS_AND_PARENT_ID = String.format( "SELECT * FROM %s WHERE active = TRUE AND id IN (:ids) AND parent_entity_id = :parent_entity_id", TABLE_NAME );
 	private final String SELECT_BY_IDS_AND_PARENT_IDS = String.format( "SELECT * FROM %s WHERE active = TRUE AND id IN (:ids) AND parent_entity_id IN (:parent_entity_ids)", TABLE_NAME );
 	private final String SELECT_BY_IDS_AND_PARENT_ENTITY_TYPE_AND_PARENT_ID_AND_COUNT = String.format( "SELECT * FROM %s WHERE id IN (:ids) AND parent_entity_id = :parent_entity_id AND parent_entity_type = :parent_entity_type LIMIT :limit", TABLE_NAME );
 	private final String SELECT_BY_IDS_PACKAGING_AND_COUNT = String.format( "SELECT * FROM %s WHERE id IN (:ids) AND is_packaging = :is_packaging LIMIT :limit", TABLE_NAME );
 	private final String SELECT_BY_PARENT_TYPE_AND_PARENT_ID = String.format( "SELECT * FROM %s WHERE active = TRUE AND parent_entity_type = :parent_entity_type AND parent_entity_id = :parent_entity_id" , TABLE_NAME );
+	private final String SELECT_BY_IS_PACKAGING_TRUE = String.format( "SELECT * FROM %s WHERE is_packaging IS TRUE", TABLE_NAME );
 
 	public InventoryAccountDAO(NamedParameterJdbcTemplate namedParameterJdbcTemplate) {
 		this.namedParameterJdbcTemplate = namedParameterJdbcTemplate;
@@ -44,6 +64,11 @@ public class InventoryAccountDAO {
 			.addValue( "created_at", inventoryAccount.getCreatedAt() )
 			.addValue( "location_site_id", inventoryAccount.getLocationSiteId() )
 			.addValue( "notes", inventoryAccount.getNotes() )
+			.addValue( "article_name", inventoryAccount.getArticleName() )
+			.addValue( "total_machines", inventoryAccount.getTotalMachines() )
+			.addValue( "shift_minutes", inventoryAccount.getShiftMinutes() )
+			.addValue( "efficiency", inventoryAccount.getEfficiency() )
+			.addValue( "sam", inventoryAccount.getSam() )
 			.addValue("is_packaging", inventoryAccount.getIsPackaging() );
 		return params;
 	}
@@ -144,4 +169,9 @@ public class InventoryAccountDAO {
 		params.addValue("parent_entity_id", parentEntityId );
 		return namedParameterJdbcTemplate.query( SELECT_BY_PARENT_TYPE_AND_PARENT_ID, params, new InventoryAccountRowMapper() );
 	}
+
+	public List<InventoryAccount> getPackagingAccounts(){
+		MapSqlParameterSource params = new MapSqlParameterSource();
+		return namedParameterJdbcTemplate.query( SELECT_BY_IS_PACKAGING_TRUE, params, new InventoryAccountRowMapper() );
+	}
 }

src/main/java/com/utopiaindustries/dao/ctp/InventoryAccountRowMapper.java

@@ -20,6 +20,11 @@ public class InventoryAccountRowMapper implements RowMapper<InventoryAccount> {
 		}
 		inventoryAccount.setLocationSiteId( rs.getInt( "location_site_id" ) );
 		inventoryAccount.setNotes( rs.getString( "notes" ) );
+		inventoryAccount.setArticleName( rs.getString( "article_name" ) );
+		inventoryAccount.setShiftMinutes( rs.getLong( "shift_minutes" ) );
+		inventoryAccount.setTotalMachines( rs.getLong( "total_machines" ) );
+		inventoryAccount.setEfficiency( rs.getBigDecimal( "efficiency" ) );
+		inventoryAccount.setSam( rs.getBigDecimal( "sam" ) );
 		inventoryAccount.setIsPackaging( rs.getBoolean("is_packaging" ) );
 		return inventoryAccount;
 	}

src/main/java/com/utopiaindustries/dao/ctp/InventoryTransactionLegDAO.java

@@ -3,6 +3,7 @@ package com.utopiaindustries.dao.ctp;
 import com.utopiaindustries.model.ctp.InventorySummary;
 import com.utopiaindustries.model.ctp.InventoryTransactionLeg;
 import com.utopiaindustries.util.KeyHolderFunctions;
+import com.utopiaindustries.util.StringUtils;
 import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
 import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
 import org.springframework.jdbc.support.GeneratedKeyHolder;
@@ -21,7 +22,7 @@ public class InventoryTransactionLegDAO {
 	private final String SELECT_QUERY = String.format( "SELECT * FROM %s WHERE id = :id", TABLE_NAME );
 	private final String SELECT_ALL_QUERY = String.format( "SELECT * FROM %s ORDER BY id DESC", TABLE_NAME );
 	private final String DELETE_QUERY = String.format( "DELETE FROM %s WHERE id = :id", TABLE_NAME );
-	private final String INSERT_QUERY = String.format( "INSERT INTO %s (id, transaction_id, item_id, sku, type, quantity, account_id, balance, transaction_leg_datetime, parent_document_type, parent_document_id, parent_document_piece_type) VALUES (:id, :transaction_id, :item_id, :sku, :type, :quantity, :account_id, :balance, :transaction_leg_datetime, :parent_document_type, :parent_document_id, :parent_document_piece_type) ON DUPLICATE KEY UPDATE transaction_id = VALUES(transaction_id), item_id = VALUES(item_id), sku = VALUES(sku), type = VALUES(type), quantity = VALUES(quantity), account_id = VALUES(account_id), balance = VALUES(balance), transaction_leg_datetime = VALUES(transaction_leg_datetime), parent_document_type = VALUES(parent_document_type), parent_document_id = VALUES(parent_document_id), parent_document_piece_type = VALUES(parent_document_piece_type)", TABLE_NAME );
+	private final String INSERT_QUERY = String.format( "INSERT INTO %s (id, transaction_id, item_id, sku, type, quantity, account_id, balance, transaction_leg_datetime, parent_document_type, parent_document_id, parent_document_piece_type, job_card_id) VALUES (:id, :transaction_id, :item_id, :sku, :type, :quantity, :account_id, :balance, :transaction_leg_datetime, :parent_document_type, :parent_document_id, :parent_document_piece_type, :job_card_id) ON DUPLICATE KEY UPDATE transaction_id = VALUES(transaction_id), item_id = VALUES(item_id), sku = VALUES(sku), type = VALUES(type), quantity = VALUES(quantity), account_id = VALUES(account_id), balance = VALUES(balance), transaction_leg_datetime = VALUES(transaction_leg_datetime), parent_document_type = VALUES(parent_document_type), parent_document_id = VALUES(parent_document_id), parent_document_piece_type = VALUES(parent_document_piece_type), job_card_id = VALUES(job_card_id)", TABLE_NAME );
 	private final String SELECT_LAST_ACCOUNT_ID_AND_ITEM_ID = String.format( "SELECT * FROM %s WHERE account_id = :account_id AND item_id = :item_id AND parent_document_type= :parent_document_type AND parent_document_piece_type = :parent_document_piece_type ORDER BY id DESC LIMIT 1", TABLE_NAME );
 	private final String SELECT_BY_ACCOUNT_ID = String.format( "SELECT * FROM %s WHERE account_id = :account_id ORDER BY id DESC" , TABLE_NAME );
 	private final String SELECT_SUMMARY_BY_ACCOUNT_ID = String.format( "SELECT item_id, sku, parent_document_type,parent_document_piece_type," +
@@ -44,11 +45,23 @@ public class InventoryTransactionLegDAO {
 			" WHERE itl.type = :type" +
 			" AND itl.parent_document_type = :parent_document_type"
 			, TABLE_NAME, TABLE_NAME );
+	private final String COUNT_TOTAL_SEGREGATE_ITEMS = String.format("SELECT COUNT(*) FROM %s WHERE parent_document_id IN (:parent_document_id) AND account_id = :account_id", TABLE_NAME);
+	private final String SELECT_FIRST_TRANSACTION_PARENT_TYPE_PARENT_ID = String.format("SELECT * FROM %s WHERE parent_document_id IN (:parent_document_id) AND parent_document_type = :parent_document_type ORDER BY transaction_leg_datetime ASC LIMIT 1", TABLE_NAME);
+	private final String SELECT_GROUP_By_TRANSACTION_PARENT_TYPE_PARENT_ID = String.format("SELECT * FROM %s WHERE parent_document_id IN (:parent_document_id) AND parent_document_type = :parent_document_type GROUP BY account_id", TABLE_NAME);
+	private final String SELECT_TRANSACTIONS_REMAINING = String.format("SELECT parent_document_id as parentIds FROM %s WHERE account_id = :account_id AND parent_document_type = :parent_document_type AND type = 'IN'	AND parent_document_id NOT IN (SELECT parent_document_id FROM %s WHERE account_id = :account_id AND parent_document_type = :parent_document_type AND type = 'OUT')", TABLE_NAME, TABLE_NAME);
+	private final String SELECT_IN_PARENT_ID_BY_TYPE_GROUP = String.format("SELECT parent_document_id as parentIds FROM %s WHERE account_id = :account_id AND parent_document_type = :parent_document_type AND type = 'IN'	GROUP BY parent_document_id", TABLE_NAME);
+	private final String SELECT_OUT_PARENT_ID_BY_TYPE_GROUP = String.format("SELECT parent_document_id as parentIds FROM %s WHERE account_id = :account_id AND parent_document_type = :parent_document_type AND type = 'OUT'	GROUP BY parent_document_id", TABLE_NAME);
+	private final String SELECT_JOB_CARD_DATES = String.format("SELECT * FROM %s WHERE job_card_id = :job_card_id AND (:start_date IS NULL OR :end_date IS NULL OR transaction_leg_datetime BETWEEN :start_date AND :end_date) AND type = :type ", TABLE_NAME);
+	private final String SELECT_JOB_CARD_And_Date_Type_Account_Id = String.format("SELECT * FROM %s WHERE job_card_id = :job_card_id AND (:start_date IS NULL OR :end_date IS NULL OR transaction_leg_datetime BETWEEN :start_date AND :end_date) AND type = :type AND account_id IN (:account_ids)", TABLE_NAME);
 
 	public InventoryTransactionLegDAO(NamedParameterJdbcTemplate namedParameterJdbcTemplate) {
 		this.namedParameterJdbcTemplate = namedParameterJdbcTemplate;
 	}
 
+	public List<InventoryTransactionLeg> findByQuery(String query ){
+		return namedParameterJdbcTemplate.query( query, new InventoryTransactionLegRowMapper() );
+	}
+
 	// prepare query params
 	private MapSqlParameterSource prepareInsertQueryParams( InventoryTransactionLeg inventoryTransactionLeg ) {
 		MapSqlParameterSource params = new MapSqlParameterSource();
@@ -63,7 +76,9 @@ public class InventoryTransactionLegDAO {
 			.addValue( "transaction_leg_datetime", inventoryTransactionLeg.getTransactionLegDateTime() )
 			.addValue( "parent_document_type", inventoryTransactionLeg.getParentDocumentType() )
 			.addValue( "parent_document_id", inventoryTransactionLeg.getParentDocumentId() )
-				.addValue("parent_document_piece_type", inventoryTransactionLeg.getParentDocumentPieceType() );
+			.addValue("parent_document_piece_type", inventoryTransactionLeg.getParentDocumentPieceType() )
+			.addValue("job_card_id", inventoryTransactionLeg.getJobCardId() );
+
 		return params;
 	}
 
@@ -153,4 +168,77 @@ public class InventoryTransactionLegDAO {
 		params.addValue("parent_document_type", parentType );
 		return namedParameterJdbcTemplate.query( SELECT_LAST_LEG_BY_TYPE_AND_PARENT_ID , params, new InventoryTransactionLegRowMapper() );
 	}
+
+	public Long CalculateTotalGradingItems(List<Long> finishItemIds, Integer accountId) {
+		MapSqlParameterSource params = new MapSqlParameterSource();
+		params.addValue("parent_document_id", finishItemIds);
+		params.addValue("account_id", accountId);
+
+		Long count = namedParameterJdbcTemplate.queryForObject(COUNT_TOTAL_SEGREGATE_ITEMS, params, Long.class);
+		return count != null ? count : 0;
+	}
+
+	public InventoryTransactionLeg getFirstStitchBundleTime(List<Long> parentsIds, String parentType) {
+		MapSqlParameterSource params = new MapSqlParameterSource();
+		params.addValue("parent_document_id", parentsIds);
+		params.addValue("parent_document_type", parentType);
+
+		return namedParameterJdbcTemplate.query(SELECT_FIRST_TRANSACTION_PARENT_TYPE_PARENT_ID, params,new InventoryTransactionLegRowMapper())
+				.stream()
+				.findFirst()
+				.orElse( new InventoryTransactionLeg() );
+	}
+
+	public List<InventoryTransactionLeg> getTransactionByParentIdAndType(List<Long> parentIds , String parentType){
+		if ( parentIds == null || parentIds.isEmpty() ){
+			return new ArrayList<>();
+		}
+		MapSqlParameterSource params = new MapSqlParameterSource();
+		params.addValue("parent_document_id", parentIds );
+		params.addValue("parent_document_type", parentType );
+		return namedParameterJdbcTemplate.query( SELECT_GROUP_By_TRANSACTION_PARENT_TYPE_PARENT_ID , params, new InventoryTransactionLegRowMapper() );
+	}
+
+	public List<InventoryTransactionLeg> getTransactionByJobCardAndDatesAndType(long jobCardID, String startDate, String endDate, String type){
+		MapSqlParameterSource params = new MapSqlParameterSource();
+		params.addValue("job_card_id", jobCardID );
+		params.addValue("start_date", startDate );
+		params.addValue("end_date", endDate );
+		params.addValue("type", type );
+		System.out.println("Start Date: " + startDate);
+		System.out.println("End Date: " + endDate);
+
+		System.out.println("Params: " + params.getValues());
+		return namedParameterJdbcTemplate.query( SELECT_JOB_CARD_DATES , params, new InventoryTransactionLegRowMapper() );
+	}
+
+	public List<InventoryTransactionLeg> getTransactionByJobCardAndDatesAndTypeAndAccountID(long jobCardID, String startDate, String endDate, String type, List<Integer> accountId){
+		MapSqlParameterSource params = new MapSqlParameterSource();
+		params.addValue("job_card_id", jobCardID );
+		params.addValue("start_date", startDate );
+		params.addValue("end_date", endDate );
+		params.addValue("type", type );
+		params.addValue("account_ids", accountId );
+		return namedParameterJdbcTemplate.query( SELECT_JOB_CARD_And_Date_Type_Account_Id , params, new InventoryTransactionLegRowMapper() );
+	}
+
+	public List<Long> findRemainingByParentTypeAndAccountID(String parentType, Integer accountId){
+		MapSqlParameterSource params = new MapSqlParameterSource();
+		params.addValue("account_id", accountId );
+		params.addValue("parent_document_type", parentType );
+		return namedParameterJdbcTemplate.queryForList( SELECT_TRANSACTIONS_REMAINING , params, Long.class );
+	}
+
+	public List<Long> getInParentIdByDate(String parentType, Integer accountId){
+		MapSqlParameterSource params = new MapSqlParameterSource();
+		params.addValue("account_id", accountId );
+		params.addValue("parent_document_type", parentType );
+		return namedParameterJdbcTemplate.queryForList( SELECT_IN_PARENT_ID_BY_TYPE_GROUP , params, Long.class );
+	}
+	public List<Long> getOutParentIdByDate(String parentType, Integer accountId){
+		MapSqlParameterSource params = new MapSqlParameterSource();
+		params.addValue("account_id", accountId );
+		params.addValue("parent_document_type", parentType );
+		return namedParameterJdbcTemplate.queryForList( SELECT_OUT_PARENT_ID_BY_TYPE_GROUP , params, Long.class );
+	}
 }

src/main/java/com/utopiaindustries/dao/ctp/InventoryTransactionLegRowMapper.java

@@ -23,6 +23,7 @@ public class InventoryTransactionLegRowMapper implements RowMapper<InventoryTran
 		inventoryTransactionLeg.setParentDocumentType( rs.getString( "parent_document_type" ) );
 		inventoryTransactionLeg.setParentDocumentId( rs.getLong( "parent_document_id" ) );
 		inventoryTransactionLeg.setParentDocumentPieceType( rs.getString("parent_document_piece_type"));
+		inventoryTransactionLeg.setJobCardId( rs.getLong("job_card_id"));
 		return inventoryTransactionLeg;
 	}
 }

src/main/java/com/utopiaindustries/dao/ctp/JobCardDAO.java

@@ -21,13 +21,12 @@ public class JobCardDAO {
 	private final String TABLE_NAME = "cut_to_pack.job_card";
 	private final String SELECT_QUERY = String.format( "SELECT * FROM %s WHERE id = :id", TABLE_NAME );
 	private final String SELECT_ALL_QUERY = String.format( "SELECT * FROM %s ORDER BY id DESC", TABLE_NAME );
-	private final String SELECT_ALL_QUERY_WITH_LIMIT = String.format( "SELECT * FROM %s ORDER BY id DESC limit :limit", TABLE_NAME );
+	private final String SELECT_ALL_BY_PO_ID = String.format( "SELECT * FROM %s WHERE purchase_order_id = :purchase_order_id", TABLE_NAME );
 	private final String DELETE_QUERY = String.format( "DELETE FROM %s WHERE id = :id", TABLE_NAME );
-	private final String INSERT_QUERY = String.format( "INSERT INTO %s (id, code, job_order_id, created_at, created_by, status, inventory_status, customer, lot_number, purchase_order_id, location_site_id, description) VALUES (:id, :code, :job_order_id, :created_at, :created_by, :status, :inventory_status, :customer, :lot_number, :purchase_order_id, :location_site_id, :description) ON DUPLICATE KEY UPDATE code = VALUES(code), job_order_id = VALUES(job_order_id), created_at = VALUES(created_at), created_by = VALUES(created_by), status = VALUES(status), inventory_status = VALUES(inventory_status), customer = VALUES(customer), lot_number = VALUES(lot_number), purchase_order_id = VALUES(purchase_order_id), location_site_id = VALUES(location_site_id), description = VALUES(description)", TABLE_NAME );
+	private final String INSERT_QUERY = String.format( "INSERT INTO %s (id, code, job_order_id, created_at, created_by, status, inventory_status, customer, lot_number, purchase_order_id, location_site_id, description, poQuantity, articleName) VALUES (:id, :code, :job_order_id, :created_at, :created_by, :status, :inventory_status, :customer, :lot_number, :purchase_order_id, :location_site_id, :description, :poQuantity, :articleName) ON DUPLICATE KEY UPDATE code = VALUES(code), job_order_id = VALUES(job_order_id), created_at = VALUES(created_at), created_by = VALUES(created_by), status = VALUES(status), inventory_status = VALUES(inventory_status), customer = VALUES(customer), lot_number = VALUES(lot_number), purchase_order_id = VALUES(purchase_order_id), location_site_id = VALUES(location_site_id), description = VALUES(description), poQuantity = VALUES(poQuantity), articleName = VALUES(articleName) ", TABLE_NAME );
 	private final String SELECT_BY_LIKE_CODE_AND_INV_STATUS_AND_STATUS = String.format( "SELECT * FROM %s WHERE code like :code AND status = :status AND inventory_status = :inventory_status", TABLE_NAME );
 	private final String SELECT_BY_LIKE_CODE = String.format( "SELECT * FROM %s WHERE code like :code", TABLE_NAME );
-	private final String SELECT_BY_LIMIT = String.format( "SELECT * FROM %s WHERE created_by = :created_by ORDER BY id DESC limit :limit", TABLE_NAME );
-
+	private final String SELECT_BY_LIMIT = String.format( "SELECT * FROM %s WHERE created_by = :created_by ORDER BY id ASC limit :limit", TABLE_NAME );
 
 	// prepare query params
 	private MapSqlParameterSource prepareInsertQueryParams( JobCard jobCard ) {
@@ -40,6 +39,8 @@ public class JobCardDAO {
 			.addValue("status", jobCard.getStatus() )
 			.addValue("inventory_status", jobCard.getInventoryStatus() )
 			.addValue("customer", jobCard.getCustomer() )
+			.addValue("poQuantity", jobCard.getPoQuantity() )
+			.addValue("articleName", jobCard.getArticleName() )
 			.addValue("lot_number", jobCard.getLotNumber() )
 			.addValue("purchase_order_id", jobCard.getPurchaseOrderId() )
 			.addValue("location_site_id", jobCard.getLocationSiteId() )
@@ -113,9 +114,9 @@ public class JobCardDAO {
 		return namedParameterJdbcTemplate.query( query, new JobCardRowMapper() );
 	}
 
-	public List<JobCard> findByAllWithLimit(Long limit){
+	public List<JobCard> findByPoId(long poId){
 		MapSqlParameterSource params = new MapSqlParameterSource();
-		params.addValue("limit", limit.intValue());
-		return namedParameterJdbcTemplate.query( SELECT_ALL_QUERY_WITH_LIMIT, params, new JobCardRowMapper() );
+		params.addValue("purchase_order_id", poId);
+		return namedParameterJdbcTemplate.query( SELECT_ALL_BY_PO_ID, params, new JobCardRowMapper() );
 	}
 }

src/main/java/com/utopiaindustries/dao/ctp/JobCardItemDAO.java

@@ -10,7 +10,6 @@ import org.springframework.stereotype.Repository;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Map;
 
 @Repository
 public class JobCardItemDAO {
@@ -22,9 +21,12 @@ public class JobCardItemDAO {
 	private final String SELECT_ALL_QUERY = String.format( "SELECT * FROM %s ORDER BY id DESC", TABLE_NAME );
 	private final String DELETE_QUERY = String.format( "DELETE FROM %s WHERE id = :id", TABLE_NAME );
 	private final String SELECT_BY_CARD_ID = String.format( "SELECT * FROM %s WHERE job_card_id = :card_id", TABLE_NAME );
-	private final String INSERT_QUERY = String.format( "INSERT INTO %s (id, job_card_id, item_id, sku, expected_production, actual_production, total_production, account_id, length, width, gsm, wt_ply, ply) VALUES (:id, :job_card_id, :item_id, :sku, :expected_production, :actual_production, :total_production, :account_id, :length, :width, :gsm, :wt_ply, :ply) ON DUPLICATE KEY UPDATE job_card_id = VALUES(job_card_id), item_id = VALUES(item_id), sku = VALUES(sku), expected_production = VALUES(expected_production), actual_production = VALUES(actual_production), total_production = VALUES(total_production), account_id = VALUES(account_id), length = VALUES(length), width = VALUES(width),  gsm = VALUES(gsm),  wt_ply = VALUES(wt_ply),  ply = VALUES(ply) ", TABLE_NAME );
+	private final String SELECT_BY_CARD_ID_AND_ITEM_ID = String.format( "SELECT * FROM %s WHERE job_card_id = :card_id AND item_id = :item_id ", TABLE_NAME );
+	private final String INSERT_QUERY = String.format( "INSERT INTO %s (id, job_card_id, item_id, sku, expected_production, actual_production, total_production, account_id, length, width, gsm, wt_ply, ply, is_complete) VALUES (:id, :job_card_id, :item_id, :sku, :expected_production, :actual_production, :total_production, :account_id, :length, :width, :gsm, :wt_ply, :ply, :is_complete) ON DUPLICATE KEY UPDATE job_card_id = VALUES(job_card_id), item_id = VALUES(item_id), sku = VALUES(sku), expected_production = VALUES(expected_production), actual_production = VALUES(actual_production), total_production = VALUES(total_production), account_id = VALUES(account_id), length = VALUES(length), width = VALUES(width),  gsm = VALUES(gsm),  wt_ply = VALUES(wt_ply),  ply = VALUES(ply), is_complete =VALUES(is_complete) ", TABLE_NAME );
 	private final String SELECT_BY_IDS = String.format( "SELECT * FROM %s WHERE id IN (:ids)", TABLE_NAME );
-	private final String SELECT_BY_JOB_CARD_AND_ACCOUNT_IDS = String.format( "SELECT * FROM %s WHERE job_card_id = :job_card_id AND actual_production = :actual_production AND account_id IN (:account_ids)", TABLE_NAME );
+	private final String SELECT_BY_JOB_CARD_AND_ACCOUNT_IDS = String.format( "SELECT * FROM %s WHERE job_card_id = :job_card_id AND account_id IN (:account_ids) AND is_complete = FALSE ", TABLE_NAME );
+	private final String SELECT_ALL_ACTIVE_ITEM = String.format("SELECT CASE WHEN MIN(is_complete) = TRUE THEN TRUE ELSE FALSE END FROM  %s WHERE job_card_id = :job_card_id AND id IN (:id)", TABLE_NAME);
+	private final String SELECT_BY_JOB_CARD_IDS = String.format( "SELECT * FROM %s WHERE job_card_id IN (:job_card_id)", TABLE_NAME );
 
 	public JobCardItemDAO(NamedParameterJdbcTemplate namedParameterJdbcTemplate) {
 		this.namedParameterJdbcTemplate = namedParameterJdbcTemplate;
@@ -45,7 +47,9 @@ public class JobCardItemDAO {
 			.addValue("width", jobCardItem.getWidth() )
 			.addValue("gsm", jobCardItem.getGsm() )
 			.addValue("wt_ply", jobCardItem.getWtPly() )
-			.addValue("ply", jobCardItem.getPly() );
+			.addValue("ply", jobCardItem.getPly() )
+			.addValue("is_complete", jobCardItem.isComplete() );
+
 		return params;
 	}
 
@@ -95,18 +99,41 @@ public class JobCardItemDAO {
 		return namedParameterJdbcTemplate.query(SELECT_BY_CARD_ID, params, new JobCardItemRowMapper() );
 	}
 
+	public JobCardItem findByCardIdAndItemId( long cardId,long itemItem ){
+		MapSqlParameterSource params = new MapSqlParameterSource();
+		params.addValue( "card_id", cardId );
+		params.addValue("item_id",itemItem);
+		return namedParameterJdbcTemplate.query(SELECT_BY_CARD_ID_AND_ITEM_ID, params, new JobCardItemRowMapper() ).stream()
+				.findFirst()
+				.orElse( new JobCardItem() );
+	}
+
 	public List<JobCardItem> findByIds( List<Long> ids ){
 		MapSqlParameterSource params = new MapSqlParameterSource();
 		params.addValue( "ids", ids );
 		return namedParameterJdbcTemplate.query( SELECT_BY_IDS, params, new JobCardItemRowMapper() );
 	}
 
-	public List<JobCardItem> findByJobCardAndAccountIdsAndIsReceived( Long jobCardId, Long actualProduction, List<Long> accountIds ){
+	public List<JobCardItem> findByJobCardAndAccountIdsAndIsReceived( Long jobCardId, List<Long> accountIds ){
 		if( accountIds == null || accountIds.isEmpty() ) return new ArrayList<>();
 		MapSqlParameterSource params = new MapSqlParameterSource();
 		params.addValue( "account_ids", accountIds );
 		params.addValue("job_card_id", jobCardId );
-		params.addValue("actual_production", actualProduction );
 		return namedParameterJdbcTemplate.query( SELECT_BY_JOB_CARD_AND_ACCOUNT_IDS , params, new JobCardItemRowMapper() );
 	}
+
+	public boolean checkAllItemsComplete( Long jobCardId, List<Long> itemsId ){
+		if( itemsId == null || itemsId.isEmpty() ) return false;
+		MapSqlParameterSource params = new MapSqlParameterSource();
+		params.addValue( "id", itemsId );
+		params.addValue("job_card_id", jobCardId );
+		Boolean allComplete = namedParameterJdbcTemplate.queryForObject(SELECT_ALL_ACTIVE_ITEM, params, Boolean.class);
+		return Boolean.TRUE.equals(allComplete);
+	}
+
+	public List<JobCardItem> findByJobCardIds(List<Long> ids){
+		MapSqlParameterSource params = new MapSqlParameterSource();
+		params.addValue("job_card_id", ids);
+		return namedParameterJdbcTemplate.query( SELECT_BY_JOB_CARD_IDS, params, new JobCardItemRowMapper() );
+	}
 }

src/main/java/com/utopiaindustries/dao/ctp/JobCardItemRowMapper.java

@@ -22,6 +22,7 @@ public class JobCardItemRowMapper implements RowMapper<JobCardItem> {
 		jobCardItem.setGsm( rs.getString("gsm" ) );
 		jobCardItem.setWtPly( rs.getString("wt_ply" ) );
 		jobCardItem.setPly( rs.getString("ply" ) );
+		jobCardItem.setComplete( rs.getBoolean("is_complete" ) );
 		return jobCardItem;
 	}
 }

src/main/java/com/utopiaindustries/dao/ctp/JobCardRowMapper.java

@@ -20,9 +20,11 @@ public class JobCardRowMapper implements RowMapper<JobCard> {
 		jobCard.setInventoryStatus( rs.getString("inventory_status"));
 		jobCard.setCustomer( rs.getString("customer") );
 		jobCard.setLotNumber( rs.getString("lot_number") );
-		jobCard.setPurchaseOrderId( rs.getLong("purchase_order_id") );
+		jobCard.setPurchaseOrderId( rs.getString("purchase_order_id") );
 		jobCard.setLocationSiteId( rs.getLong("location_site_id" ) );
 		jobCard.setDescription( rs.getString("description" ) );
+		jobCard.setPoQuantity( rs.getInt("poQuantity" ) );
+		jobCard.setArticleName( rs.getString("articleName" ) );
 		return jobCard;
 	}
 }

src/main/java/com/utopiaindustries/dao/ctp/MasterBundleDAO.java

@@ -20,10 +20,12 @@ public class MasterBundleDAO {
 	private final String SELECT_QUERY = String.format( "SELECT * FROM %s WHERE id = :id", TABLE_NAME );
 	private final String SELECT_ALL_QUERY = String.format( "SELECT * FROM %s ORDER BY id DESC", TABLE_NAME );
 	private final String DELETE_QUERY = String.format( "DELETE FROM %s WHERE id = :id", TABLE_NAME );
-	private final String INSERT_QUERY = String.format( "INSERT INTO %s (id, barcode,item_id, sku, created_by, created_at, job_card_id, is_received) VALUES (:id, :barcode, :item_id, :sku, :created_by, :created_at, :job_card_id, :is_received) ON DUPLICATE KEY UPDATE barcode = VALUES(barcode), item_id = VALUES(item_id), sku = VALUES(sku), created_by = VALUES(created_by), created_at = VALUES(created_at), job_card_id = VALUES(job_card_id),  is_received = VALUES(is_received)", TABLE_NAME );
+	private final String INSERT_QUERY = String.format( "INSERT INTO %s (id, barcode,item_id, sku, created_by, created_at, job_card_id, account_id, is_received) VALUES (:id, :barcode, :item_id, :sku, :created_by, :created_at, :job_card_id, :account_id, :is_received) ON DUPLICATE KEY UPDATE barcode = VALUES(barcode), item_id = VALUES(item_id), sku = VALUES(sku), created_by = VALUES(created_by), created_at = VALUES(created_at), job_card_id = VALUES(job_card_id),  is_received = VALUES(is_received), account_id = VALUES(account_id) ", TABLE_NAME );
 	private final String SELECT_BY_LIMIT = String.format( "SELECT * FROM %s ORDER BY id DESC LIMIT :limit", TABLE_NAME );
 	private final String SELECT_BY_TERM_AND_RECEIVED = String.format( "SELECT * FROM %s WHERE is_received = :is_received AND ( id LIKE :id OR barcode LIKE :barcode ) ", TABLE_NAME );
 	private final String SELECT_BY_IDS = String.format( "SELECT * FROM %s WHERE id IN (:ids)", TABLE_NAME );
+	private final String SELECT_BY_IDS_AND_RECIEVE = String.format( "SELECT id FROM %s WHERE id IN (:ids) AND is_received = true", TABLE_NAME );
+
 
 
 	public MasterBundleDAO(NamedParameterJdbcTemplate namedParameterJdbcTemplate) {
@@ -37,6 +39,7 @@ public class MasterBundleDAO {
 			.addValue( "barcode", masterBundle.getBarcode() )
 			.addValue( "item_id", masterBundle.getItemId() )
 			.addValue( "sku", masterBundle.getSku() )
+			.addValue( "account_id", masterBundle.getAccountId() )
 			.addValue( "created_by", masterBundle.getCreatedBy() )
 			.addValue( "created_at", masterBundle.getCreatedAt() )
 			.addValue( "job_card_id", masterBundle.getJobCardId() )
@@ -54,6 +57,13 @@ public class MasterBundleDAO {
 				.orElse( new MasterBundle() );
 	}
 
+	// find all
+	public List<Long> findByIdAndReceiveIsTrue(List<Long> ids) {
+		MapSqlParameterSource params = new MapSqlParameterSource();
+		params.addValue( "ids", ids );
+		return namedParameterJdbcTemplate.query(SELECT_BY_IDS_AND_RECIEVE, params, (rs, rowNum) -> rs.getLong("id"));
+	}
+
 	// find all
 	public List<MasterBundle> findAll() {
 		return namedParameterJdbcTemplate.query( SELECT_ALL_QUERY, new MasterBundleRowMapper() );

src/main/java/com/utopiaindustries/dao/ctp/MasterBundleRowMapper.java

@@ -14,6 +14,7 @@ public class MasterBundleRowMapper implements RowMapper<MasterBundle> {
 		masterBundle.setCreatedBy( rs.getString( "created_by" ) );
 		masterBundle.setItemId( rs.getLong("item_id" ));
 		masterBundle.setSku( rs.getString("sku" ) );
+		masterBundle.setAccountId(rs.getLong("account_id"));
 		if ( rs.getTimestamp( "created_at" ) != null ) {
 			masterBundle.setCreatedAt( rs.getTimestamp( "created_at" ).toLocalDateTime() );
 		}

src/main/java/com/utopiaindustries/dao/ctp/PackagingItemsDAO.java

@@ -0,0 +1,110 @@
+package com.utopiaindustries.dao.ctp;
+
+import com.utopiaindustries.model.ctp.FinishedItem;
+import com.utopiaindustries.model.ctp.PackagingItems;
+import com.utopiaindustries.util.KeyHolderFunctions;
+import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
+import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
+import org.springframework.jdbc.support.GeneratedKeyHolder;
+import org.springframework.jdbc.support.KeyHolder;
+import org.springframework.stereotype.Repository;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Repository
+public class PackagingItemsDAO {
+
+    private final NamedParameterJdbcTemplate namedParameterJdbcTemplate;
+
+    private static final String TABLE_NAME = "packaging_items";
+
+    private static final String SELECT_BY_ID = String.format("SELECT * FROM %s WHERE id = :id", TABLE_NAME);
+    private static final String SELECT_ALL = String.format("SELECT * FROM %s ORDER BY id DESC", TABLE_NAME);
+    private static final String DELETE_BY_ID = String.format("DELETE FROM %s WHERE id = :id", TABLE_NAME);
+    private static final String SELECT_BY_JOB_CARD_ID = String.format("SELECT * FROM %s WHERE job_card_id = :job_card_id", TABLE_NAME);
+
+    private static final String INSERT_QUERY = String.format(
+            "INSERT INTO %s (" +
+                    "id, item_id, sku, barcode, job_card_id, created_at, created_by, " +
+                    "is_qa, finish_item_id, is_segregated, account_id, qa_status, bundle_id, account_title" +
+                    ") VALUES (" +
+                    ":id, :item_id, :sku, :barcode, :job_card_id, :created_at, :created_by, " +
+                    ":is_qa, :finish_item_id, :is_segregated, :account_id, :qa_status, :bundle_id, :account_title" +
+                    ") ON DUPLICATE KEY UPDATE " +
+                    "item_id = VALUES(item_id), sku = VALUES(sku), barcode = VALUES(barcode), " +
+                    "job_card_id = VALUES(job_card_id), created_at = VALUES(created_at), created_by = VALUES(created_by), " +
+                    "is_qa = VALUES(is_qa), finish_item_id = VALUES(finish_item_id), " +
+                    "is_segregated = VALUES(is_segregated), account_id = VALUES(account_id), " +
+                    "qa_status = VALUES(qa_status), bundle_id = VALUES(bundle_id), account_title = VALUES(account_title)",
+            TABLE_NAME
+    );
+    private final String SELECT_BY_DATE_AND_IDs = String.format( "SELECT COUNT(*) FROM %s WHERE (:start_date IS NULL OR  created_at >=:start_date) AND created_at <= :end_date AND id IN (:ids)", TABLE_NAME );
+
+    public PackagingItemsDAO(NamedParameterJdbcTemplate namedParameterJdbcTemplate) {
+        this.namedParameterJdbcTemplate = namedParameterJdbcTemplate;
+    }
+
+    private MapSqlParameterSource prepareParams(PackagingItems item) {
+        return new MapSqlParameterSource()
+                .addValue("id", item.getId())
+                .addValue("item_id", item.getItemId())
+                .addValue("sku", item.getSku())
+                .addValue("barcode", item.getBarcode())
+                .addValue("job_card_id", item.getJobCardId())
+                .addValue("created_at", item.getCreatedAt())
+                .addValue("created_by", item.getCreatedBy())
+                .addValue("is_qa", item.getIsQa())
+                .addValue("finish_item_id", item.getFinishedItemId())
+                .addValue("is_segregated", item.getIsSegregated())
+                .addValue("account_id", item.getAccountId())
+                .addValue("qa_status", item.getQaStatus())
+                .addValue("bundle_id", item.getBundleId())
+                .addValue("account_title", item.getAccountTitle());
+    }
+
+    public PackagingItems find(long id) {
+        MapSqlParameterSource params = new MapSqlParameterSource("id", id);
+        return namedParameterJdbcTemplate.query(SELECT_BY_ID, params, new PackagingItemsRowMapper())
+                .stream().findFirst().orElse(new PackagingItems());
+    }
+
+    public List<PackagingItems> findAll() {
+        return namedParameterJdbcTemplate.query(SELECT_ALL, new PackagingItemsRowMapper());
+    }
+
+    public long save(PackagingItems item) {
+        KeyHolder keyHolder = new GeneratedKeyHolder();
+        MapSqlParameterSource params = prepareParams(item);
+        namedParameterJdbcTemplate.update(INSERT_QUERY, params, keyHolder);
+        return KeyHolderFunctions.getKey(item.getId(), keyHolder);
+    }
+
+    public int[] saveAll(List<PackagingItems> items) {
+        List<MapSqlParameterSource> batchParams = new ArrayList<>();
+        for (PackagingItems item : items) {
+            batchParams.add(prepareParams(item));
+        }
+        return namedParameterJdbcTemplate.batchUpdate(INSERT_QUERY, batchParams.toArray(new MapSqlParameterSource[0]));
+    }
+
+    public boolean delete(long id) {
+        MapSqlParameterSource params = new MapSqlParameterSource("id", id);
+        return namedParameterJdbcTemplate.update(DELETE_BY_ID, params) > 0;
+    }
+
+    public List<PackagingItems> findByJobCardId(long jobCardId) {
+        MapSqlParameterSource params = new MapSqlParameterSource("job_card_id", jobCardId);
+        return namedParameterJdbcTemplate.query(SELECT_BY_JOB_CARD_ID, params, new PackagingItemsRowMapper());
+    }
+
+    public Long findByDateAndIds(String startDate, String endDate,List<Long> ids){
+        MapSqlParameterSource params = new MapSqlParameterSource();
+        params.addValue( "start_date", startDate );
+        params.addValue( "end_date", endDate );
+        params.addValue( "ids", ids );
+        Long count = namedParameterJdbcTemplate.queryForObject(SELECT_BY_DATE_AND_IDs, params, Long.class);
+        return count != null ? count : 0;
+    }
+}
+

src/main/java/com/utopiaindustries/dao/ctp/PackagingItemsRowMapper.java

@@ -0,0 +1,29 @@
+package com.utopiaindustries.dao.ctp;
+
+import com.utopiaindustries.model.ctp.PackagingItems;
+import org.springframework.jdbc.core.RowMapper;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+public class PackagingItemsRowMapper implements RowMapper<PackagingItems> {
+    @Override
+    public PackagingItems mapRow(ResultSet rs, int rowNum) throws SQLException {
+        PackagingItems item = new PackagingItems();
+        item.setId(rs.getLong("id"));
+        item.setItemId(rs.getLong("item_id"));
+        item.setSku(rs.getString("sku"));
+        item.setBarcode(rs.getString("barcode"));
+        item.setJobCardId(rs.getLong("job_card_id"));
+        item.setCreatedAt(rs.getTimestamp("created_at") != null ? rs.getTimestamp("created_at").toLocalDateTime() : null);
+        item.setCreatedBy(rs.getString("created_by"));
+        item.setIsQa(rs.getBoolean("is_qa"));
+        item.setFinishedItemId(rs.getLong("finish_item_id"));
+        item.setIsSegregated(rs.getBoolean("is_segregated"));
+        item.setAccountId(rs.getLong("account_id"));
+        item.setQaStatus(rs.getString("qa_status"));
+        item.setBundleId(rs.getLong("bundle_id"));
+        item.setAccountTitle(rs.getString("account_title"));
+        return item;
+    }
+}

src/main/java/com/utopiaindustries/dao/ctp/PurchaseOrderCTPDao.java

@@ -0,0 +1,124 @@
+package com.utopiaindustries.dao.ctp;
+
+import com.utopiaindustries.dao.uind.PurchaseOrderRowMapper;
+import com.utopiaindustries.model.ctp.JobCard;
+import com.utopiaindustries.model.ctp.PurchaseOrderCTP;
+import com.utopiaindustries.model.uind.PurchaseOrder;
+import com.utopiaindustries.util.KeyHolderFunctions;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
+import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
+import org.springframework.jdbc.support.GeneratedKeyHolder;
+import org.springframework.jdbc.support.KeyHolder;
+import org.springframework.stereotype.Repository;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Repository
+public class PurchaseOrderCTPDao {
+
+    @Autowired
+    private NamedParameterJdbcTemplate namedParameterJdbcTemplate;
+
+    private final String TABLE_NAME = "cut_to_pack.purchase_order";
+    private final String SELECT_QUERY = String.format( "SELECT * FROM %s WHERE id = :id", TABLE_NAME );
+    private final String SELECT_ALL_QUERY = String.format( "SELECT * FROM %s ", TABLE_NAME );
+    private final String SELECT_BY_PO_CODE = String.format( "SELECT * FROM %s WHERE purchase_order_code = :purchase_order_code", TABLE_NAME );
+    private final String DELETE_QUERY = String.format( "DELETE FROM %s WHERE id = :id", TABLE_NAME );
+    private final String INSERT_QUERY = String.format(
+            "INSERT INTO %s (id, purchase_order_code, purchase_order_quantity, purchase_order_quantity_required, article_name, created_by, status) " +
+                    "VALUES (:id, :purchase_order_code, :purchase_order_quantity, :purchase_order_quantity_required, :article_name, :created_by, :status) " +
+                    "ON DUPLICATE KEY UPDATE " +
+                    "purchase_order_code = VALUES(purchase_order_code), " +
+                    "purchase_order_quantity = VALUES(purchase_order_quantity), " +
+                    "purchase_order_quantity_required = VALUES(purchase_order_quantity_required), " +
+                    "article_name = VALUES(article_name), " +
+                    "created_by = VALUES(created_by), " +
+                    "status = VALUES(status)",
+            TABLE_NAME);
+    private final String SELECT_BY_LIMIT = String.format( "SELECT * FROM %s WHERE created_by = :created_by ORDER BY id ASC limit :limit", TABLE_NAME );
+    private final String SELECT_BY_TERM = String.format( "SELECT * FROM %s WHERE purchase_order_code LIKE :term limit 100 offset 0", TABLE_NAME );
+
+
+    // prepare query params
+    private MapSqlParameterSource prepareInsertQueryParams(PurchaseOrderCTP purchaseOrderCTP) {
+        MapSqlParameterSource params = new MapSqlParameterSource();
+        params.addValue("id", purchaseOrderCTP.getId())
+                .addValue("purchase_order_code", purchaseOrderCTP.getPurchaseOrderCode())
+                .addValue("purchase_order_quantity", purchaseOrderCTP.getPurchaseOrderQuantity())
+                .addValue("purchase_order_quantity_required", purchaseOrderCTP.getPurchaseOrderQuantityRequired())
+                .addValue("article_name", purchaseOrderCTP.getArticleName())
+                .addValue("created_by", purchaseOrderCTP.getCreatedBy())
+                .addValue("status", purchaseOrderCTP.getStatus());
+        return params;
+    }
+
+
+    // find
+    public PurchaseOrderCTP find(long id ) {
+        MapSqlParameterSource params = new MapSqlParameterSource();
+        params.addValue( "id", id );
+        return namedParameterJdbcTemplate.query( SELECT_QUERY, params, new PurchaseOrderCTPRowMapper() )
+                .stream()
+                .findFirst()
+                .orElse( new PurchaseOrderCTP() );
+    }
+
+
+    // find all
+    public List<PurchaseOrderCTP> findAll() {
+        return namedParameterJdbcTemplate.query( SELECT_ALL_QUERY, new PurchaseOrderCTPRowMapper() );
+    }
+
+    // save
+    public long save( PurchaseOrderCTP PurchaseOrderCTP) {
+        KeyHolder keyHolder = new GeneratedKeyHolder();
+        MapSqlParameterSource params = prepareInsertQueryParams(PurchaseOrderCTP);
+        namedParameterJdbcTemplate.update( INSERT_QUERY, params, keyHolder );
+        return KeyHolderFunctions.getKey( PurchaseOrderCTP.getId(), keyHolder );
+    }
+
+    // save all
+    public int[] saveAll( List<PurchaseOrderCTP> purchaseOrderCTPS) {
+        List<MapSqlParameterSource> batchArgs = new ArrayList<>();
+        for ( PurchaseOrderCTP PurchaseOrderCTP : purchaseOrderCTPS) {
+            MapSqlParameterSource params = prepareInsertQueryParams(PurchaseOrderCTP);
+            batchArgs.add( params );
+        }
+        return namedParameterJdbcTemplate.batchUpdate( INSERT_QUERY, batchArgs.toArray(new MapSqlParameterSource[purchaseOrderCTPS.size()]) );
+    }
+
+    // delete
+    public boolean delete( long id ) {
+        MapSqlParameterSource params = new MapSqlParameterSource();
+        params.addValue( "id", id );
+        return namedParameterJdbcTemplate.update( DELETE_QUERY, params ) > 0;
+    }
+
+    public List<PurchaseOrderCTP> findByQuery(String query ){
+        return namedParameterJdbcTemplate.query( query, new PurchaseOrderCTPRowMapper() );
+    }
+
+    public List<PurchaseOrderCTP> findByUserAndLimit(String createdBy, Long limit ){
+        MapSqlParameterSource params = new MapSqlParameterSource();
+        params.addValue("limit", limit.intValue() );
+        params.addValue("created_by", createdBy );
+        return namedParameterJdbcTemplate.query( SELECT_BY_LIMIT, params, new PurchaseOrderCTPRowMapper() );
+    }
+
+    public List<PurchaseOrderCTP> findByPoCode(String poCode){
+        MapSqlParameterSource params = new MapSqlParameterSource();
+        params.addValue("purchase_order_code", poCode);
+        return namedParameterJdbcTemplate.query( SELECT_BY_PO_CODE, params, new PurchaseOrderCTPRowMapper() );
+    }
+
+    /*
+     * find by term
+     * */
+    public List<PurchaseOrderCTP> findByTerm(String term ){
+        MapSqlParameterSource params = new MapSqlParameterSource();
+        params.addValue("term", "%" + term + "%" );
+        return namedParameterJdbcTemplate.query( SELECT_BY_TERM, params, new PurchaseOrderCTPRowMapper() );
+    }
+}

src/main/java/com/utopiaindustries/dao/ctp/PurchaseOrderCTPRowMapper.java

@@ -0,0 +1,24 @@
+package com.utopiaindustries.dao.ctp;
+
+import com.utopiaindustries.model.ctp.PurchaseOrderCTP;
+import org.springframework.jdbc.core.RowMapper;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+public class PurchaseOrderCTPRowMapper implements RowMapper<PurchaseOrderCTP> {
+    public PurchaseOrderCTP mapRow(ResultSet rs, int rowNum) throws SQLException {
+        PurchaseOrderCTP PurchaseOrderCTP = new PurchaseOrderCTP();
+        PurchaseOrderCTP.setId(rs.getLong("id"));
+        PurchaseOrderCTP.setPurchaseOrderCode(rs.getString("purchase_order_code"));
+        PurchaseOrderCTP.setPurchaseOrderQuantity(rs.getInt("purchase_order_quantity"));
+        PurchaseOrderCTP.setPurchaseOrderQuantityRequired(rs.getInt("purchase_order_quantity_required"));
+        PurchaseOrderCTP.setArticleName(rs.getString("article_name"));
+        if (rs.getTimestamp("created_at") != null) {
+            PurchaseOrderCTP.setCreatedAt(rs.getTimestamp("created_at").toLocalDateTime());
+        }
+        PurchaseOrderCTP.setCreatedBy(rs.getString("created_by"));
+        PurchaseOrderCTP.setStatus(rs.getString("status"));
+        return PurchaseOrderCTP;
+    }
+}

src/main/java/com/utopiaindustries/dao/ctp/SkuCutPieceRowMapper.java

@@ -0,0 +1,18 @@
+package com.utopiaindustries.dao.ctp;
+
+import com.utopiaindustries.model.ctp.CutPiece;
+import com.utopiaindustries.model.ctp.SkuCutPieces;
+import org.springframework.jdbc.core.RowMapper;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+public class SkuCutPieceRowMapper implements RowMapper<SkuCutPieces> {
+    public SkuCutPieces mapRow(ResultSet rs, int rowNum) throws SQLException {
+        SkuCutPieces skuCutPieces = new SkuCutPieces();
+        skuCutPieces.setId(rs.getLong("id"));
+        skuCutPieces.setSku(rs.getString("sku"));
+        skuCutPieces.setType(rs.getString("title"));
+        return skuCutPieces;
+    }
+}

src/main/java/com/utopiaindustries/dao/ctp/SkuCutPiecesDAO.java

@@ -0,0 +1,96 @@
+package com.utopiaindustries.dao.ctp;
+
+import com.utopiaindustries.model.ctp.CutPieceType;
+import com.utopiaindustries.model.ctp.SkuCutPieces;
+import com.utopiaindustries.util.KeyHolderFunctions;
+import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
+import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
+import org.springframework.jdbc.support.GeneratedKeyHolder;
+import org.springframework.jdbc.support.KeyHolder;
+import org.springframework.stereotype.Repository;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Repository
+public class SkuCutPiecesDAO {
+    private final NamedParameterJdbcTemplate namedParameterJdbcTemplate;
+
+    private final String TABLE_NAME = "cut_to_pack.sku_cut_piece";
+    private final String SELECT_QUERY = String.format( "SELECT * FROM %s WHERE id = :id", TABLE_NAME );
+    private final String SELECT_ALL_QUERY = String.format( "SELECT * FROM %s ORDER BY id DESC", TABLE_NAME );
+    private final String DELETE_QUERY = String.format( "DELETE FROM %s WHERE id = :id", TABLE_NAME );
+    private final String INSERT_QUERY = String.format("INSERT INTO %s (sku, title) VALUES (:sku, :title) ON DUPLICATE KEY UPDATE sku = VALUES(sku), title = VALUES(title)", TABLE_NAME);
+    private final String FIND_BY_SKU = String.format( "SELECT * FROM %s WHERE sku = :sku", TABLE_NAME );
+    private final String CHECK_EXISTENCE_QUERY = String.format("SELECT COUNT(*) FROM %s WHERE title = :title AND sku = :sku", TABLE_NAME);
+
+    public SkuCutPiecesDAO(NamedParameterJdbcTemplate namedParameterJdbcTemplate) {
+        this.namedParameterJdbcTemplate = namedParameterJdbcTemplate;
+    }
+
+    // prepare query params
+    private MapSqlParameterSource prepareInsertQueryParams(SkuCutPieces skuCutPieces ) {
+        MapSqlParameterSource params = new MapSqlParameterSource();
+        params.addValue( "id", skuCutPieces.getId() )
+                .addValue( "sku", skuCutPieces.getSku())
+                .addValue("title",skuCutPieces.getType());
+        return params;
+    }
+
+    // find
+    public SkuCutPieces find( long id ) {
+        MapSqlParameterSource params = new MapSqlParameterSource();
+        params.addValue( "id", id );
+        return namedParameterJdbcTemplate.query( SELECT_QUERY, params, new SkuCutPieceRowMapper() )
+                .stream()
+                .findFirst()
+                .orElse( new SkuCutPieces() );
+    }
+
+    public boolean doesExist(String type, String sku) {
+        MapSqlParameterSource params = new MapSqlParameterSource();
+        params.addValue("title", type);
+        params.addValue("sku", sku);
+        Long count = namedParameterJdbcTemplate.queryForObject(CHECK_EXISTENCE_QUERY, params, Long.class);
+        return count > 0;
+    }
+
+
+
+    //find by sku
+    public List<SkuCutPieces> findBySku(String sku) {
+        MapSqlParameterSource params = new MapSqlParameterSource();
+        params.addValue("sku", sku);
+        return namedParameterJdbcTemplate.query(FIND_BY_SKU, params, new SkuCutPieceRowMapper());
+    }
+
+    // find all
+    public List<CutPieceType> findAll() {
+        return namedParameterJdbcTemplate.query( SELECT_ALL_QUERY, new CutPieceTypeRowMapper() );
+    }
+
+    // save
+    public long save( SkuCutPieces skuCutPieces ) {
+        KeyHolder keyHolder = new GeneratedKeyHolder();
+        MapSqlParameterSource params = prepareInsertQueryParams( skuCutPieces );
+        namedParameterJdbcTemplate.update( INSERT_QUERY, params, keyHolder );
+        return KeyHolderFunctions.getKey( skuCutPieces.getId(), keyHolder );
+    }
+
+    // save all
+    public int[] saveAll( List<SkuCutPieces> skuCutPieces ) {
+        List<MapSqlParameterSource> batchArgs = new ArrayList<>();
+        for ( SkuCutPieces cutPieceType: skuCutPieces ) {
+            MapSqlParameterSource params = prepareInsertQueryParams( cutPieceType );
+            batchArgs.add( params );
+        }
+        return namedParameterJdbcTemplate.batchUpdate( INSERT_QUERY, batchArgs.toArray(new MapSqlParameterSource[skuCutPieces.size()]) );
+    }
+
+    // delete
+    public boolean delete( long id ) {
+        MapSqlParameterSource params = new MapSqlParameterSource();
+        params.addValue( "id", id );
+        return namedParameterJdbcTemplate.update( DELETE_QUERY, params ) > 0;
+    }
+}

src/main/java/com/utopiaindustries/dao/ctp/StitchingOfflineItemDAO.java

@@ -1,5 +1,7 @@
 package com.utopiaindustries.dao.ctp;
 
+import com.utopiaindustries.model.ctp.FinishedItem;
+import com.utopiaindustries.model.ctp.InventoryTransactionLeg;
 import com.utopiaindustries.model.ctp.StitchingOfflineItem;
 import com.utopiaindustries.util.KeyHolderFunctions;
 import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
@@ -22,12 +24,17 @@ public class StitchingOfflineItemDAO {
     private final String SELECT_ALL_QUERY = String.format( "SELECT * FROM %s ORDER BY id DESC", TABLE_NAME );
     private final String SELECT_QUERY_BY_JOB_CARD = String.format( "SELECT * FROM %s WHERE job_card_id = :job_card_id", TABLE_NAME );
     private final String DELETE_QUERY = String.format( "DELETE FROM %s WHERE id = :id", TABLE_NAME );
-    private final String INSERT_QUERY = String.format( "INSERT INTO %s (id, item_id, sku, barcode, created_at, created_by, job_card_id, is_qa, qa_remarks, qa_status) VALUES (:id, :item_id, :sku, :barcode, :created_at, :created_by, :job_card_id, :is_qa, :qa_remarks, :qa_status) ON DUPLICATE KEY UPDATE item_id = VALUES(item_id), sku = VALUES(sku), barcode = VALUES(barcode), created_at = VALUES(created_at), created_by = VALUES(created_by), job_card_id = VALUES(job_card_id), is_qa = VALUES(is_qa), qa_remarks = VALUES(qa_remarks), qa_status = VALUES(qa_status)", TABLE_NAME );
+    private final String INSERT_QUERY = String.format( "INSERT INTO %s (id, item_id, sku, barcode, created_at, created_by, job_card_id, is_qa, qa_remarks, qa_status,bundle_id, qc_done_at) VALUES (:id, :item_id, :sku, :barcode, :created_at, :created_by, :job_card_id, :is_qa, :qa_remarks, :qa_status, :bundle_id, :qc_done_at) ON DUPLICATE KEY UPDATE item_id = VALUES(item_id), sku = VALUES(sku), barcode = VALUES(barcode), created_at = VALUES(created_at), created_by = VALUES(created_by), job_card_id = VALUES(job_card_id), is_qa = VALUES(is_qa), qa_remarks = VALUES(qa_remarks), qa_status = VALUES(qa_status), bundle_id = VALUES(bundle_id), qc_done_at = VALUES(qc_done_at)", TABLE_NAME );
     private final String SELECT_BY_LIMIT = String.format("SELECT * FROM %s ORDER BY id DESC LIMIT :limit", TABLE_NAME );
     private final String FIND_TOTAL_COUNT = String.format("SELECT COUNT(*) FROM %s  where job_card_id = :job_card_id And item_id = :item_id", TABLE_NAME );
     private final String SELECT_BY_IDS = String.format( "SELECT * FROM %s WHERE id IN (:ids)", TABLE_NAME );
     private final String SELECT_BY_TERM = String.format( "SELECT * FROM %s WHERE barcode LIKE :term ORDER BY ID DESC", TABLE_NAME );
     private final String SELECT_BY_MASTER_ID = String.format( "SELECT * FROM %s WHERE job_card_id = :job_card_id", TABLE_NAME );
+    private final String COUNT_TOTAL_QA_ITEMS= String.format("SELECT COUNT(*) FROM %s WHERE job_card_id = :job_card_id AND is_qa IS TRUE",TABLE_NAME);
+    private final String SELECT_BY_TIME_AND_CARD_ID= String.format("SELECT * FROM %s WHERE job_card_id = :job_card_id ORDER BY created_at DESC LIMIT 1;",TABLE_NAME);
+    private final String SELECT_BY_JOB_CARD_AND_DATE = String.format( "SELECT * FROM %s WHERE job_card_id = :job_card_id AND (:start_date IS NULL OR :end_date IS NULL OR created_at BETWEEN :start_date AND :end_date)", TABLE_NAME );
+    private final String SELECT_BY_DATE_QA_STATUS = String.format( "SELECT COUNT(*) FROM %s WHERE (:start_date IS NULL OR qc_done_at >= :start_date) AND qc_done_at <= :end_date AND qa_status = :qa_status AND id IN (:ids)", TABLE_NAME );
+    private final String SELECT_BY_DATE_QA_STATUS_APPROVED= String.format( "SELECT COUNT(*) FROM %s WHERE (:start_date IS NULL OR qc_done_at >= :start_date) AND qc_done_at <= :end_date AND qa_status = :qa_status", TABLE_NAME );
 
     public StitchingOfflineItemDAO(NamedParameterJdbcTemplate namedParameterJdbcTemplate) {
         this.namedParameterJdbcTemplate = namedParameterJdbcTemplate;
@@ -40,11 +47,13 @@ public class StitchingOfflineItemDAO {
                 .addValue( "item_id", stitchingOfflineItem.getItemId() )
                 .addValue( "sku", stitchingOfflineItem.getSku() )
                 .addValue( "barcode", stitchingOfflineItem.getBarcode() )
+                .addValue("bundle_id",stitchingOfflineItem.getBundleId())
                 .addValue( "created_at", stitchingOfflineItem.getCreatedAt() )
                 .addValue( "created_by", stitchingOfflineItem.getCreatedBy() )
                 .addValue("job_card_id", stitchingOfflineItem.getJobCardId() )
                 .addValue("is_qa", stitchingOfflineItem.getIsQa() )
                 .addValue("qa_remarks", stitchingOfflineItem.getQaRemarks() )
+                .addValue("qc_done_at", stitchingOfflineItem.getQcDoneAt() )
                 .addValue("qa_status", stitchingOfflineItem.getQaStatus() );
         return params;
     }
@@ -140,4 +149,46 @@ public class StitchingOfflineItemDAO {
         return totalCounts;
     }
 
+    public Long CalculateTotalQA( long jobCardId ){
+        MapSqlParameterSource params = new MapSqlParameterSource();
+        params.addValue("job_card_id", jobCardId );
+        Long count = namedParameterJdbcTemplate.queryForObject(COUNT_TOTAL_QA_ITEMS, params, Long.class);
+        return count != null ? count : 0;
+    }
+
+    public StitchingOfflineItem getLastStitchItemByCardIdAndTime(long jobCardId) {
+        MapSqlParameterSource params = new MapSqlParameterSource();
+        params.addValue("job_card_id", jobCardId);
+
+        return namedParameterJdbcTemplate.query(SELECT_BY_TIME_AND_CARD_ID, params,new StitchingOfflineItemRowMapper())
+                .stream()
+                .findFirst()
+                .orElse( new StitchingOfflineItem() );
+    }
+
+    public List<StitchingOfflineItem> findByJobCardIdAndDate(long jobCardId, String startDate, String endDate){
+        MapSqlParameterSource params = new MapSqlParameterSource();
+        params.addValue( "job_card_id", jobCardId );
+        params.addValue( "start_date", startDate );
+        params.addValue( "end_date", endDate );
+        return namedParameterJdbcTemplate.query( SELECT_BY_JOB_CARD_AND_DATE , params, new StitchingOfflineItemRowMapper() );
+    }
+
+    public Long findByQCOperationDateAndIds(String startDate, String endDate, String qaStatus, List<Long> ids){
+        MapSqlParameterSource params = new MapSqlParameterSource();
+        params.addValue( "start_date", startDate );
+        params.addValue( "end_date", endDate );
+        params.addValue( "qa_status", qaStatus );
+        params.addValue( "ids", ids);
+        Long count = namedParameterJdbcTemplate.queryForObject(SELECT_BY_DATE_QA_STATUS, params, Long.class);
+        return count != null ? count : 0;
+    }
+    public Long findByQCOperationDateAndApproved(String startDate, String endDate, String qaStatus){
+        MapSqlParameterSource params = new MapSqlParameterSource();
+        params.addValue( "start_date", startDate );
+        params.addValue( "end_date", endDate );
+        params.addValue( "qa_status", qaStatus );
+        Long count = namedParameterJdbcTemplate.queryForObject(SELECT_BY_DATE_QA_STATUS_APPROVED, params, Long.class);
+        return count != null ? count : 0;
+    }
 }

src/main/java/com/utopiaindustries/dao/ctp/StitchingOfflineItemRowMapper.java

@@ -15,9 +15,13 @@ public class StitchingOfflineItemRowMapper implements RowMapper<StitchingOffline
         stitchingOfflineItem.setItemId( rs.getLong( "item_id" ) );
         stitchingOfflineItem.setSku( rs.getString( "sku" ) );
         stitchingOfflineItem.setBarcode( rs.getString( "barcode" ) );
+        stitchingOfflineItem.setBundleId(rs.getLong("bundle_id"));
         if ( rs.getTimestamp( "created_at" ) != null ) {
             stitchingOfflineItem.setCreatedAt( rs.getTimestamp( "created_at" ).toLocalDateTime() );
         }
+        if ( rs.getTimestamp( "qc_done_at" ) != null ) {
+            stitchingOfflineItem.setQcDoneAt( rs.getTimestamp( "qc_done_at" ).toLocalDateTime() );
+        }
         stitchingOfflineItem.setCreatedBy( rs.getString( "created_by" ) );
         stitchingOfflineItem.setJobCardId( rs.getLong("job_card_id") );
         stitchingOfflineItem.setIsQa( rs.getBoolean("is_qa"));

src/main/java/com/utopiaindustries/dao/ctp/StoreItemDao.java

@@ -0,0 +1,131 @@
+package com.utopiaindustries.dao.ctp;
+
+import com.utopiaindustries.model.ctp.StoreItem;
+import com.utopiaindustries.util.KeyHolderFunctions;
+import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
+import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
+import org.springframework.jdbc.support.GeneratedKeyHolder;
+import org.springframework.jdbc.support.KeyHolder;
+import org.springframework.stereotype.Repository;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@Repository
+public class StoreItemDao {
+
+    private final NamedParameterJdbcTemplate namedParameterJdbcTemplate;
+
+    private static final String TABLE_NAME = "store_items";
+
+    private static final String SELECT_BY_ID = String.format("SELECT * FROM %s WHERE id = :id", TABLE_NAME);
+    private static final String SELECT_ALL = String.format("SELECT * FROM %s ORDER BY id DESC", TABLE_NAME);
+    private static final String DELETE_BY_ID = String.format("DELETE FROM %s WHERE id = :id", TABLE_NAME);
+    private static final String SELECT_BY_JOB_CARD_ID = String.format("SELECT * FROM %s WHERE job_card_id = :job_card_id", TABLE_NAME);
+    private final String COUNT_TOTAL_FINISH_ITEM = String.format("SELECT COUNT(*) FROM %s WHERE job_card_id = :job_card_id", TABLE_NAME);
+
+    private static final String INSERT_QUERY = String.format(
+            "INSERT INTO %s (" +
+                    "id, item_id, sku, barcode, job_card_id, created_at, created_by, " +
+                    "finish_item_id, account_id, bundle_id, reject_reason" +
+                    ") VALUES (" +
+                    ":id, :item_id, :sku, :barcode, :job_card_id, :created_at, :created_by, " +
+                    ":finish_item_id, :account_id, :bundle_id, :reject_reason" +
+                    ") ON DUPLICATE KEY UPDATE " +
+                    "item_id = VALUES(item_id), sku = VALUES(sku), barcode = VALUES(barcode), " +
+                    "job_card_id = VALUES(job_card_id), created_at = VALUES(created_at), created_by = VALUES(created_by), " +
+                    "finish_item_id = VALUES(finish_item_id), account_id = VALUES(account_id), bundle_id = VALUES(bundle_id), reject_reason = VALUES(reject_reason)",
+            TABLE_NAME
+    );
+    String SELECT_BY_JOB_CARD_GROUP_REJECT_REASON =  String.format("SELECT reject_reason, COUNT(*) AS total FROM %s WHERE job_card_id IN (:job_card_id) GROUP BY reject_reason", TABLE_NAME);
+
+    private static final String SELECT_BY_DATE_AND_IDs = String.format("SELECT COUNT(*) FROM %s WHERE (:start_date IS NULL OR created_at >= :start_date) AND created_at <= :end_date AND id IN (:ids)", TABLE_NAME);
+
+    public StoreItemDao(NamedParameterJdbcTemplate namedParameterJdbcTemplate) {
+        this.namedParameterJdbcTemplate = namedParameterJdbcTemplate;
+    }
+
+    private MapSqlParameterSource prepareParams(StoreItem item) {
+        return new MapSqlParameterSource()
+                .addValue("id", item.getId())
+                .addValue("item_id", item.getItemId())
+                .addValue("sku", item.getSku())
+                .addValue("barcode", item.getBarcode())
+                .addValue("job_card_id", item.getJobCardId())
+                .addValue("created_at", item.getCreatedAt())
+                .addValue("created_by", item.getCreatedBy())
+                .addValue("finish_item_id", item.getFinishedItemId())
+                .addValue("account_id", item.getAccountId())
+                .addValue("bundle_id", item.getBundleId())
+                .addValue("reject_reason", item.getRejectedReason());
+    }
+
+    public StoreItem find(long id) {
+        MapSqlParameterSource params = new MapSqlParameterSource("id", id);
+        return namedParameterJdbcTemplate.query(SELECT_BY_ID, params, new StoreItemRowMapper())
+                .stream().findFirst().orElse(new StoreItem());
+    }
+
+    public List<StoreItem> findAll() {
+        return namedParameterJdbcTemplate.query(SELECT_ALL, new StoreItemRowMapper());
+    }
+
+    public long save(StoreItem item) {
+        KeyHolder keyHolder = new GeneratedKeyHolder();
+        MapSqlParameterSource params = prepareParams(item);
+        namedParameterJdbcTemplate.update(INSERT_QUERY, params, keyHolder);
+        return KeyHolderFunctions.getKey(item.getId(), keyHolder);
+    }
+
+    public int[] saveAll(List<StoreItem> items) {
+        List<MapSqlParameterSource> batchParams = new ArrayList<>();
+        for (StoreItem item : items) {
+            batchParams.add(prepareParams(item));
+        }
+        return namedParameterJdbcTemplate.batchUpdate(INSERT_QUERY, batchParams.toArray(new MapSqlParameterSource[0]));
+    }
+
+    public boolean delete(long id) {
+        MapSqlParameterSource params = new MapSqlParameterSource("id", id);
+        return namedParameterJdbcTemplate.update(DELETE_BY_ID, params) > 0;
+    }
+
+    public List<StoreItem> findByJobCardId(long jobCardId) {
+        MapSqlParameterSource params = new MapSqlParameterSource("job_card_id", jobCardId);
+        return namedParameterJdbcTemplate.query(SELECT_BY_JOB_CARD_ID, params, new StoreItemRowMapper());
+    }
+
+    public Long calculateTotalRejectItemByJobCardId(long jobCardId) {
+        MapSqlParameterSource params = new MapSqlParameterSource();
+        params.addValue("job_card_id", jobCardId);
+        Long count = namedParameterJdbcTemplate.queryForObject(COUNT_TOTAL_FINISH_ITEM, params, Long.class);
+        return count != null ? count : 0;
+    }
+
+    public Long findByDateAndIds(String startDate, String endDate, List<Long> ids) {
+        MapSqlParameterSource params = new MapSqlParameterSource();
+        params.addValue("start_date", startDate);
+        params.addValue("end_date", endDate);
+        params.addValue("ids", ids);
+        Long count = namedParameterJdbcTemplate.queryForObject(SELECT_BY_DATE_AND_IDs, params, Long.class);
+        return count != null ? count : 0;
+    }
+
+    public Map<String, Integer> totalCountByJobCardIdsAndGroupByRejectReason(List<Long> jobCardIds) {
+        MapSqlParameterSource params = new MapSqlParameterSource();
+        params.addValue("job_card_id", jobCardIds);
+
+        List<Map<String, Object>> rows = namedParameterJdbcTemplate.queryForList(SELECT_BY_JOB_CARD_GROUP_REJECT_REASON, params);
+
+        Map<String, Integer> result = new HashMap<>();
+        for (Map<String, Object> row : rows) {
+            String reason = (String) row.get("reject_reason");
+            Integer total = ((Number) row.get("total")).intValue();
+            result.put(reason, total);
+        }
+        return result;
+    }
+
+}

src/main/java/com/utopiaindustries/dao/ctp/StoreItemRowMapper.java

@@ -0,0 +1,27 @@
+package com.utopiaindustries.dao.ctp;
+
+import com.utopiaindustries.model.ctp.PackagingItems;
+import com.utopiaindustries.model.ctp.StoreItem;
+import org.springframework.jdbc.core.RowMapper;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+public class StoreItemRowMapper implements RowMapper<StoreItem> {
+    @Override
+    public StoreItem mapRow(ResultSet rs, int rowNum) throws SQLException {
+        StoreItem item = new StoreItem();
+        item.setId(rs.getLong("id"));
+        item.setItemId(rs.getLong("item_id"));
+        item.setSku(rs.getString("sku"));
+        item.setBarcode(rs.getString("barcode"));
+        item.setJobCardId(rs.getLong("job_card_id"));
+        item.setCreatedAt(rs.getTimestamp("created_at") != null ? rs.getTimestamp("created_at").toLocalDateTime() : null);
+        item.setCreatedBy(rs.getString("created_by"));
+        item.setFinishedItemId(rs.getLong("finish_item_id"));
+        item.setAccountId(rs.getLong("account_id"));
+        item.setBundleId(rs.getLong("bundle_id"));
+        item.setRejectedReason(rs.getString("reject_reason"));
+        return item;
+    }
+}

src/main/java/com/utopiaindustries/dao/ctp/SummaryInventoryReportDao.java

@@ -13,7 +13,7 @@ public class SummaryInventoryReportDao {
     private final NamedParameterJdbcTemplate namedParameterJdbcTemplate;
 
     private final String TABLE_NAME = "cut_to_pack.inventory_transaction_leg ";
-    String SELECT_QUERY = "SELECT item_id, account_id, parent_document_id, DATE(transaction_leg_datetime) AS transaction_date, "
+    String SELECT_QUERY = "SELECT job_card_id, item_id, account_id, parent_document_id, DATE(transaction_leg_datetime) AS transaction_date, "
             + "sku, parent_document_type, parent_document_piece_type, "
             + "SUM(CASE WHEN type = 'IN' THEN 1 ELSE 0 END) AS total_in, "
             + "SUM(CASE WHEN type = 'OUT' THEN 1 ELSE 0 END) AS total_out "
@@ -22,7 +22,7 @@ public class SummaryInventoryReportDao {
             + "(:sku IS NULL OR sku = :sku) "
             + "AND (:item_id IS NULL OR item_id = :item_id) "
             + "OR (:start_date IS NULL OR :end_date IS NULL OR transaction_leg_datetime BETWEEN :start_date AND :end_date) "
-            + "GROUP BY DATE(transaction_leg_datetime), sku, parent_document_type, parent_document_piece_type "
+            + "GROUP BY DATE(transaction_leg_datetime), account_id, sku, parent_document_type, parent_document_piece_type "
             + "ORDER BY transaction_date, sku;";
 
     public SummaryInventoryReportDao(NamedParameterJdbcTemplate namedParameterJdbcTemplate) {

src/main/java/com/utopiaindustries/dao/ctp/SummaryInventoryReportRowMapper.java

@@ -15,6 +15,7 @@ public class SummaryInventoryReportRowMapper implements RowMapper<SummaryInvento
         summaryInventoryReport.setAccountId(rs.getString("account_id"));
         summaryInventoryReport.setDate(rs.getString("transaction_date"));
         summaryInventoryReport.setTotalIn(rs.getLong("total_in"));
+        summaryInventoryReport.setJobCardID(rs.getLong("job_card_id"));
         summaryInventoryReport.setTotalOut(rs.getLong("total_out"));
         summaryInventoryReport.setParentDocumentType(rs.getString("parent_document_type"));
         summaryInventoryReport.setParentDocumentPieceType(rs.getString("parent_document_piece_type"));

src/main/java/com/utopiaindustries/dao/ctp/UserDAO.java

@@ -38,7 +38,7 @@ public class UserDAO {
         return namedParameterJdbcTemplate.query( SELECT_BY_USERNAME, params, new UserRowMapper() )
                 .stream()
                 .findAny()
-                .orElse( new User() );
+                .orElse( null );
     }
 
     public List<User> findAll() {

src/main/java/com/utopiaindustries/dao/uind/ItemDAO.java

@@ -42,7 +42,7 @@ public class ItemDAO {
             TABLE_NAME);
     private final String SELECT_BY_IDS = String.format("SELECT * FROM %s WHERE id IN (:ids)", TABLE_NAME);
     private final String SELECT_BY_IDS_AND_ACTIVE = String.format("SELECT * FROM %s WHERE id IN (:ids) AND is_active = 1 ", TABLE_NAME);
-    private final String SELECT_LIKE_TITLE_AND_STATUS_QUERY = String.format("SELECT * FROM %s WHERE is_active = :is_active AND title LIKE :title ORDER BY title ASC", TABLE_NAME);
+    private final String SELECT_LIKE_TITLE_AND_STATUS_QUERY_OR_SKU = String.format("SELECT * FROM %s WHERE is_active = :is_active AND title LIKE :title OR sku LIKE :sku ORDER BY title ASC limit 100 offset 0", TABLE_NAME);
     private final String SELECT_LIKE_TITLE_BY_DEPARTMENT_QUERY =
             String.format("SELECT * FROM %s WHERE department_id = :department_id AND title LIKE :title ORDER BY title ASC", TABLE_NAME);
     private final String SELECT_LIKE_TITLE = String.format("SELECT * FROM %s WHERE title LIKE :item_title", TABLE_NAME);
@@ -232,11 +232,12 @@ public class ItemDAO {
     }
 
     // find all like title (active only)
-    public List<Item> findLikeTitleAndStatus(String title, boolean active) {
+    public List<Item> findLikeTitleAndStatusORSKU(String title, boolean active) {
         MapSqlParameterSource params = new MapSqlParameterSource();
         params.addValue("title", "%" + title + "%");
         params.addValue("is_active", active);
-        return namedParameterJdbcTemplate.query(SELECT_LIKE_TITLE_AND_STATUS_QUERY, params, new ItemRowMapper());
+        params.addValue("sku", "%" + title + "%");
+        return namedParameterJdbcTemplate.query(SELECT_LIKE_TITLE_AND_STATUS_QUERY_OR_SKU, params, new ItemRowMapper());
     }
 
     // find all like title and department

src/main/java/com/utopiaindustries/dao/uind/PurchaseOrderDAO.java

@@ -61,7 +61,7 @@ public class PurchaseOrderDAO {
     private final String SELECT_BY_PO_IDS_AND_ISCOMPLETED = String.format("SELECT * FROM %s WHERE id IN (:id) AND completed = :completed AND management_status = :management_status ORDER BY id DESC", TABLE_NAME);
     private final String SELECT_BY_GENERATED_BY_USER_AND_COMPANY_DETAILS_QUERY = String.format("SELECT * FROM %s WHERE generated_by_user = :generated_by_user AND company_id = :company_id AND function_id = :function_id AND department_id = :department_id AND section_id = :section_id", TABLE_NAME);
 
-    private final String SELECT_BY_TERM = String.format( "SELECT * FROM %s WHERE code LIKE :term", TABLE_NAME );
+    private final String SELECT_BY_TERM = String.format( "SELECT * FROM %s WHERE code LIKE :term limit 100 offset 0", TABLE_NAME );
 
     public PurchaseOrderDAO(@Qualifier("namedParameterJdbcTemplateUind") NamedParameterJdbcTemplate namedParameterJdbcTemplate) {
         this.namedParameterJdbcTemplate = namedParameterJdbcTemplate;
@@ -117,7 +117,7 @@ public class PurchaseOrderDAO {
     }
 
     // find
-    public PurchaseOrder find(long id) {
+    public PurchaseOrder find(String id) {
         MapSqlParameterSource params = new MapSqlParameterSource();
         params.addValue("id", id);
         List<PurchaseOrder> purchaseOrders = namedParameterJdbcTemplate.query(SELECT_QUERY, params, new PurchaseOrderRowMapper());

src/main/java/com/utopiaindustries/model/Roles.java

@@ -9,5 +9,8 @@ public enum Roles {
     ROLE_QUALITY_CONTROL,
     ROLE_FINISHING,
     ROLE_PACKAGING,
-    ROLE_REPORTING
+    ROLE_REPORTING,
+    ROLE_PURCHASE_ORDER,
+    ROLE_INVENTORY_ACCOUNT,
+    ROLE_STORE
 }

src/main/java/com/utopiaindustries/model/ctp/BarcodeStickerSize.java

@@ -6,8 +6,8 @@ public enum BarcodeStickerSize {
     SIZE_2_X_3( 3 * 72, 2 * 72, 10, 10, 6, 6, 50, 50, 125, 125, 14, 9, 7),
     SIZE_4_X_4( 4 * 72, 4 * 72, 8, 8, 8, 8, 200, 100, 250, 250, 14, 9, 7),
     SIZE_1_75_X_3_5( 3.5f * 72, 1.75f * 72, 10, 10, 6, 6, 50, 50, 125, 125, 14, 9, 7),
-    SIZE_4_X_7( 7f * 72, 4f * 72, 10, 10, 6, 6, 50, 50, 125, 125, 14, 9, 7);
-
+    SIZE_4_X_7( 7f * 72, 4f * 72, 200, 10, 40, 6, 50, 40, 125, 125, 14, 9, 7),
+    SIZE_1_X_2( 67.69f, 139.73f ,10 , 10, 20, 6, 60, 60, 125, 125, 4, 9, 7);
 
     private final float width;
     private final float height;

src/main/java/com/utopiaindustries/model/ctp/Bundle.java

@@ -11,6 +11,8 @@ public class Bundle implements InventoryArtifact {
     private long itemId;
     private String sku;
     private BigDecimal wrapQuantity;
+    private BigDecimal production;
+    private BigDecimal currentProduction;
     private String barcode;
     private String type;
     private String createdBy;
@@ -98,6 +100,22 @@ public class Bundle implements InventoryArtifact {
         return masterBundleId;
     }
 
+    public BigDecimal getProduction() {
+        return production;
+    }
+
+    public void setProduction(BigDecimal production) {
+        this.production = production;
+    }
+
+    public BigDecimal getCurrentProduction() {
+        return currentProduction;
+    }
+
+    public void setCurrentProduction(BigDecimal currentProduction) {
+        this.currentProduction = currentProduction;
+    }
+
     public void setMasterBundleId(long masterBundleId) {
         this.masterBundleId = masterBundleId;
     }
@@ -110,6 +128,10 @@ public class Bundle implements InventoryArtifact {
         this.masterBundle = masterBundle;
     }
 
+    public long getBundleId(){
+        return 0;
+    }
+
     @Override
     public String toString() {
         return "Bundle{" +

src/main/java/com/utopiaindustries/model/ctp/BundleWrapper.java

@@ -0,0 +1,16 @@
+package com.utopiaindustries.model.ctp;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class BundleWrapper {
+    private List<Bundle> bundles = new ArrayList<>(); // ✅ Initialize List
+
+    public List<Bundle> getBundles() {
+        return bundles;
+    }
+
+    public void setBundles(List<Bundle> bundles) {
+        this.bundles = bundles;
+    }
+}

src/main/java/com/utopiaindustries/model/ctp/CutPieceType.java

@@ -3,7 +3,7 @@ package com.utopiaindustries.model.ctp;
 public class CutPieceType {
 
     private long id;
-    private String title;
+    private String type;
 
     public long getId() {
         return id;
@@ -13,19 +13,19 @@ public class CutPieceType {
         this.id = id;
     }
 
-    public String getTitle() {
-        return title;
+    public String getType() {
+        return type;
     }
 
-    public void setTitle(String title) {
-        this.title = title;
+    public void setType(String type) {
+        this.type = type;
     }
 
     @Override
     public String toString() {
         return "CutPieceType{" +
                 "id=" + id +
-                ", title='" + title + '\'' +
+                ", title='" + type + '\'' +
                 '}';
     }
 }

src/main/java/com/utopiaindustries/model/ctp/CuttingJobCardItemWrapper.java

@@ -0,0 +1,151 @@
+package com.utopiaindustries.model.ctp;
+
+public class CuttingJobCardItemWrapper {
+    private long jobCardId;
+    private String poName;
+    private String sku;
+    private Long total;
+    private String width;
+    private String length;
+    private String gsm;
+    private String wtPly;
+    private String ply;
+    private String articleName;
+    private boolean isComplete;
+    private String jobCardCode;
+    private String operatorName;
+    private long accountId;
+
+    public long getJobCardId() {
+        return jobCardId;
+    }
+
+    public void setJobCardId(long jobCardId) {
+        this.jobCardId = jobCardId;
+    }
+
+    public String getPoName() {
+        return poName;
+    }
+
+    public void setPoName(String poName) {
+        this.poName = poName;
+    }
+
+    public String getSku() {
+        return sku;
+    }
+
+    public void setSku(String sku) {
+        this.sku = sku;
+    }
+
+    public String getWidth() {
+        return width;
+    }
+
+    public void setWidth(String width) {
+        this.width = width;
+    }
+
+    public String getGsm() {
+        return gsm;
+    }
+
+    public void setGsm(String gsm) {
+        this.gsm = gsm;
+    }
+
+    public String getWtPly() {
+        return wtPly;
+    }
+
+    public void setWtPly(String wtPly) {
+        this.wtPly = wtPly;
+    }
+
+    public String getPly() {
+        return ply;
+    }
+
+    public void setPly(String ply) {
+        this.ply = ply;
+    }
+
+    public String getArticleName() {
+        return articleName;
+    }
+
+    public void setArticleName(String articleName) {
+        this.articleName = articleName;
+    }
+
+    public boolean isComplete() {
+        return isComplete;
+    }
+
+    public void setComplete(boolean complete) {
+        isComplete = complete;
+    }
+
+    public String getJobCardCode() {
+        return jobCardCode;
+    }
+
+    public void setJobCardCode(String jobCardCode) {
+        this.jobCardCode = jobCardCode;
+    }
+
+
+    public String getLength() {
+        return length;
+    }
+
+    public void setLength(String length) {
+        this.length = length;
+    }
+
+    public String getOperatorName() {
+        return operatorName;
+    }
+
+    public void setOperatorName(String operatorName) {
+        this.operatorName = operatorName;
+    }
+
+    public long getAccountId() {
+        return accountId;
+    }
+
+    public void setAccountId(long accountId) {
+        this.accountId = accountId;
+    }
+
+    public Long getTotal() {
+        return total;
+    }
+
+    public void setTotal(Long total) {
+        this.total = total;
+    }
+
+    @Override
+    public String toString() {
+        return "CuttingJobCardItemWrapper{" +
+                "jobCardId=" + jobCardId +
+                ", poName='" + poName + '\'' +
+                ", sku='" + sku + '\'' +
+                ", total=" + total +
+                ", width='" + width + '\'' +
+                ", length='" + length + '\'' +
+                ", gsm='" + gsm + '\'' +
+                ", wtPly='" + wtPly + '\'' +
+                ", ply='" + ply + '\'' +
+                ", articleName='" + articleName + '\'' +
+                ", isComplete=" + isComplete +
+                ", jobCardCode='" + jobCardCode + '\'' +
+                ", operatorName='" + operatorName + '\'' +
+                ", accountId=" + accountId +
+                '}';
+    }
+}

src/main/java/com/utopiaindustries/model/ctp/FinishedItem.java

@@ -2,6 +2,7 @@ package com.utopiaindustries.model.ctp;
 
 import org.springframework.format.annotation.DateTimeFormat;
 
+import java.math.BigDecimal;
 import java.time.LocalDateTime;
 
 public class FinishedItem implements InventoryArtifact {
@@ -22,7 +23,11 @@ public class FinishedItem implements InventoryArtifact {
     private JobCard jobCard;
     private long accountId;
     private String qaStatus;
+    private boolean isPackaging;
+    private boolean isStore;
 
+    @DateTimeFormat( pattern = "yyyy-MM-dd HH:mm:ss" )
+    private LocalDateTime operationDate;
 
     public long getId() {
         return id;
@@ -141,6 +146,42 @@ public class FinishedItem implements InventoryArtifact {
         this.qaStatus = qaStatus;
     }
 
+    public BigDecimal getWrapQuantity(){
+        return null;
+    }
+
+    public long getMasterBundleId(){
+        return 0;
+    }
+
+    public long getBundleId(){
+        return 0;
+    }
+
+    public boolean isPackaging() {
+        return isPackaging;
+    }
+
+    public void setPackaging(boolean packaging) {
+        isPackaging = packaging;
+    }
+
+    public LocalDateTime getOperationDate() {
+        return operationDate;
+    }
+
+    public void setOperationDate(LocalDateTime operationDate) {
+        this.operationDate = operationDate;
+    }
+
+    public boolean isStore() {
+        return isStore;
+    }
+
+    public void setStore(boolean store) {
+        isStore = store;
+    }
+
     @Override
     public String toString() {
         return "FinishedItem{" +

src/main/java/com/utopiaindustries/model/ctp/FinishedItemWrapper.java

@@ -4,6 +4,10 @@ import java.util.List;
 
 public class FinishedItemWrapper {
 
+    private String qaStatus;
+    private Long accountId;
+    private String rejectReason;
+
     private List<FinishedItem> items;
 
     public List<FinishedItem> getItems() {
@@ -14,6 +18,30 @@ public class FinishedItemWrapper {
         this.items = items;
     }
 
+    public String getQaStatus() {
+        return qaStatus;
+    }
+
+    public void setQaStatus(String qaStatus) {
+        this.qaStatus = qaStatus;
+    }
+
+    public Long getAccountId() {
+        return accountId;
+    }
+
+    public void setAccountId(Long accountId) {
+        this.accountId = accountId;
+    }
+
+    public String getRejectReason() {
+        return rejectReason;
+    }
+
+    public void setRejectReason(String rejectReason) {
+        this.rejectReason = rejectReason;
+    }
+
     @Override
     public String toString() {
         return "FinishedItemWrapper{" +

src/main/java/com/utopiaindustries/model/ctp/InventoryAccount.java

@@ -1,5 +1,6 @@
 package com.utopiaindustries.model.ctp;
 
+import java.math.BigDecimal;
 import java.time.LocalDateTime;
 
 public class InventoryAccount {
@@ -14,6 +15,12 @@ public class InventoryAccount {
     private Integer locationSiteId;
     private String notes;
     private Boolean isPackaging;
+    private String articleName;
+    private long shiftMinutes;
+    private long totalMachines;
+    private BigDecimal efficiency;
+    private BigDecimal sam;
+
     //wrapper
     private String locationTitle;
 
@@ -105,6 +112,45 @@ public class InventoryAccount {
         this.locationTitle = locationTitle;
     }
 
+    public String getArticleName() {
+        return articleName;
+    }
+
+    public void setArticleName(String articleName) {
+        this.articleName = articleName;
+    }
+
+    public long getShiftMinutes() {
+        return shiftMinutes;
+    }
+
+    public void setShiftMinutes(long shiftMinutes) {
+        this.shiftMinutes = shiftMinutes;
+    }
+
+    public long getTotalMachines() {
+        return totalMachines;
+    }
+
+    public void setTotalMachines(long totalMachines) {
+        this.totalMachines = totalMachines;
+    }
+
+    public BigDecimal getEfficiency() {
+        return efficiency;
+    }
+
+    public void setEfficiency(BigDecimal efficiency) {
+        this.efficiency = efficiency;
+    }
+
+    public BigDecimal getSam() {
+        return sam;
+    }
+
+    public void setSam(BigDecimal sam) {
+        this.sam = sam;
+    }
 
     @Override
     public String toString() {
@@ -119,6 +165,10 @@ public class InventoryAccount {
                 ", locationSiteId=" + locationSiteId +
                 ", notes='" + notes + '\'' +
                 ", isPackaging=" + isPackaging +
+                ", articleName='" + articleName + '\'' +
+                ", shiftMinutes=" + shiftMinutes +
+                ", totalMachines=" + totalMachines +
+                ", efficiency=" + efficiency +
                 ", locationTitle='" + locationTitle + '\'' +
                 '}';
     }

src/main/java/com/utopiaindustries/model/ctp/InventoryArtifact.java

@@ -1,11 +1,19 @@
 package com.utopiaindustries.model.ctp;
 
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+
 public interface InventoryArtifact {
 
     long getId();
     long getItemId();
+    long getJobCardId();
     String getSku();
     String getType();
     String getBarcode();
-
+    String getCreatedBy();
+    LocalDateTime getCreatedAt();
+    BigDecimal getWrapQuantity();
+    long getMasterBundleId();
+    long getBundleId();
 }

src/main/java/com/utopiaindustries/model/ctp/InventoryArtifactType.java

@@ -3,5 +3,9 @@ package com.utopiaindustries.model.ctp;
 public enum InventoryArtifactType {
     BUNDLE,
     STITCHING_OFFLINE,
-    FINISHED_ITEM
+    FINISHED_ITEM,
+    STITCH_BUNDLE,
+    PACKAGING,
+    STORED_ITEM,
+
 }

src/main/java/com/utopiaindustries/model/ctp/InventoryTransactionLeg.java

@@ -22,7 +22,7 @@ public class InventoryTransactionLeg {
     private String parentDocumentType;
     private long parentDocumentId;
     private String parentDocumentPieceType;
-
+    private long jobCardId;
     //wrapper
     private InventoryTransaction transaction;
 
@@ -122,6 +122,14 @@ public class InventoryTransactionLeg {
         this.parentDocumentPieceType = parentDocumentPieceType;
     }
 
+    public long getJobCardId() {
+        return jobCardId;
+    }
+
+    public void setJobCardId(long jobCardId) {
+        this.jobCardId = jobCardId;
+    }
+
     public InventoryTransaction getTransaction() {
         return transaction;
     }

src/main/java/com/utopiaindustries/model/ctp/JobCard.java

@@ -24,9 +24,11 @@ public class JobCard {
     private String inventoryStatus;
     private String customer;
     private String lotNumber;
-    private long purchaseOrderId;
+    private String purchaseOrderId;
     private long locationSiteId;
     private String description;
+    private String articleName;
+    private int poQuantity;
     // wrapper
     private List<JobCardItem> items;
     private long toAccountId;
@@ -106,11 +108,11 @@ public class JobCard {
         this.lotNumber = lotNumber;
     }
 
-    public long getPurchaseOrderId() {
+    public String getPurchaseOrderId() {
         return purchaseOrderId;
     }
 
-    public void setPurchaseOrderId(long purchaseOrderId) {
+    public void setPurchaseOrderId(String purchaseOrderId) {
         this.purchaseOrderId = purchaseOrderId;
     }
 
@@ -162,6 +164,22 @@ public class JobCard {
         this.locationTitle = locationTitle;
     }
 
+    public String getArticleName() {
+        return articleName;
+    }
+
+    public void setArticleName(String articleName) {
+        this.articleName = articleName;
+    }
+
+    public int getPoQuantity() {
+        return poQuantity;
+    }
+
+    public void setPoQuantity(int poQuantity) {
+        this.poQuantity = poQuantity;
+    }
+
     @Override
     public String toString() {
         return "JobCard{" +
@@ -174,9 +192,11 @@ public class JobCard {
                 ", inventoryStatus='" + inventoryStatus + '\'' +
                 ", customer='" + customer + '\'' +
                 ", lotNumber='" + lotNumber + '\'' +
-                ", purchaseOrderId=" + purchaseOrderId +
+                ", purchaseOrderId='" + purchaseOrderId + '\'' +
                 ", locationSiteId=" + locationSiteId +
                 ", description='" + description + '\'' +
+                ", articleName='" + articleName + '\'' +
+                ", poQuantity=" + poQuantity +
                 ", items=" + items +
                 ", toAccountId=" + toAccountId +
                 ", purchaseOrderTitle='" + purchaseOrderTitle + '\'' +

src/main/java/com/utopiaindustries/model/ctp/JobCardItem.java

@@ -23,6 +23,7 @@ public class JobCardItem {
     private List<CutPiece> cutPieces;
     private String title;
     private boolean isSelected;
+    private boolean isComplete;
 
     public JobCardItem() {
         this.expectedProduction = BigDecimal.ZERO;
@@ -167,6 +168,14 @@ public class JobCardItem {
         isSelected = selected;
     }
 
+    public boolean isComplete() {
+        return isComplete;
+    }
+
+    public void setComplete(boolean complete) {
+        isComplete = complete;
+    }
+
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;

src/main/java/com/utopiaindustries/model/ctp/JobCardItemWrapper.java

@@ -9,6 +9,8 @@ public class JobCardItemWrapper {
     private long jobCardItemId;
     private List<CutPiece> pieces;
     private BigDecimal actualProduction;
+    private int perBundleQuantity;
+    private boolean cuttingComplete;
 
     public long getJobCardId() {
         return jobCardId;
@@ -42,6 +44,22 @@ public class JobCardItemWrapper {
         this.actualProduction = actualProduction;
     }
 
+    public int getPerBundleQuantity() {
+        return perBundleQuantity;
+    }
+
+    public void setPerBundleQuantity(int perBundleQuantity) {
+        this.perBundleQuantity = perBundleQuantity;
+    }
+
+    public boolean getCuttingComplete() {
+        return cuttingComplete;
+    }
+
+    public void setCuttingComplete(boolean finalReceived) {
+        this.cuttingComplete = finalReceived;
+    }
+
     @Override
     public String toString() {
         return "JobCardItemWrapper{" +

src/main/java/com/utopiaindustries/model/ctp/MasterBundle.java

@@ -1,5 +1,6 @@
 package com.utopiaindustries.model.ctp;
 
+import java.math.BigDecimal;
 import java.time.LocalDateTime;
 import java.util.List;
 
@@ -13,6 +14,8 @@ public class MasterBundle implements InventoryArtifact{
     private LocalDateTime createdAt;
     private boolean isReceived;
     private long jobCardId;
+    private long accountId;
+
     // wrapper
     private List<Bundle> bundles;
     private List<FinishedItem> items;
@@ -94,6 +97,14 @@ public class MasterBundle implements InventoryArtifact{
         this.bundles = bundles;
     }
 
+    public BigDecimal getWrapQuantity(){
+        return null;
+    }
+
+    public long getMasterBundleId(){
+        return 0;
+    }
+
     public List<FinishedItem> getItems() {
         return items;
     }
@@ -102,6 +113,18 @@ public class MasterBundle implements InventoryArtifact{
         this.items = items;
     }
 
+    public long getAccountId() {
+        return accountId;
+    }
+
+    public void setAccountId(long accountId) {
+        this.accountId = accountId;
+    }
+
+    public long getBundleId(){
+        return 0;
+    }
+
     @Override
     public String toString() {
         return "MasterBundle{" +

src/main/java/com/utopiaindustries/model/ctp/POsDetails.java

@@ -0,0 +1,252 @@
+package com.utopiaindustries.model.ctp;
+
+public class POsDetails {
+    //po detail
+    private long poId;
+    private String poNumber;
+    private String articleTitle;
+    private long poQuantity;
+    private long poRequiredQuantity;
+
+    // items detail
+    private long actualCutting;
+    private long balanceToCutting;
+    private long cuttingReceived;
+    private long cuttingOki;
+    private long cuttingReject;
+    private long stitchingIn;
+    private long stitchingWips;
+    private long stitchingOut;
+    private long finishIn;
+    private long finishRej;
+    private long finishQaApproved;
+    private long storeReceived;
+    private long storeWaiting;
+    private long packagingIn;
+    private long packagingOut;
+    private long packagingStock;
+    private long shippedScan;
+    private long shippedNet;
+    private boolean poStatus;
+
+    public long getPoQuantity() {
+        return poQuantity;
+    }
+
+    public void setPoQuantity(long poQuantity) {
+        this.poQuantity = poQuantity;
+    }
+
+    public String getPoNumber() {
+        return poNumber;
+    }
+
+    public void setPoNumber(String poNumber) {
+        this.poNumber = poNumber;
+    }
+
+    public String getArticleTitle() {
+        return articleTitle;
+    }
+
+    public void setArticleTitle(String articleTitle) {
+        this.articleTitle = articleTitle;
+    }
+
+    public long getPoId() {
+        return poId;
+    }
+
+    public void setPoId(long poId) {
+        this.poId = poId;
+    }
+
+    public long getPoRequiredQuantity() {
+        return poRequiredQuantity;
+    }
+
+    public void setPoRequiredQuantity(long poRequiredQuantity) {
+        this.poRequiredQuantity = poRequiredQuantity;
+    }
+
+    public long getActualCutting() {
+        return actualCutting;
+    }
+
+    public void setActualCutting(long actualCutting) {
+        this.actualCutting = actualCutting;
+    }
+
+    public long getBalanceToCutting() {
+        return balanceToCutting;
+    }
+
+    public void setBalanceToCutting(long balanceToCutting) {
+        this.balanceToCutting = balanceToCutting;
+    }
+
+    public long getCuttingReceived() {
+        return cuttingReceived;
+    }
+
+    public void setCuttingReceived(long cuttingReceived) {
+        this.cuttingReceived = cuttingReceived;
+    }
+
+    public long getCuttingOki() {
+        return cuttingOki;
+    }
+
+    public void setCuttingOki(long cuttingOki) {
+        this.cuttingOki = cuttingOki;
+    }
+
+    public long getCuttingReject() {
+        return cuttingReject;
+    }
+
+    public void setCuttingReject(long cuttingReject) {
+        this.cuttingReject = cuttingReject;
+    }
+
+    public long getStitchingIn() {
+        return stitchingIn;
+    }
+
+    public void setStitchingIn(long stitchingIn) {
+        this.stitchingIn = stitchingIn;
+    }
+
+    public long getStitchingWips() {
+        return stitchingWips;
+    }
+
+    public void setStitchingWips(long stitchingWips) {
+        this.stitchingWips = stitchingWips;
+    }
+
+    public long getStitchingOut() {
+        return stitchingOut;
+    }
+
+    public void setStitchingOut(long stitchingOut) {
+        this.stitchingOut = stitchingOut;
+    }
+
+    public long getFinishIn() {
+        return finishIn;
+    }
+
+    public void setFinishIn(long finishIn) {
+        this.finishIn = finishIn;
+    }
+
+    public long getFinishRej() {
+        return finishRej;
+    }
+
+    public void setFinishRej(long finishRej) {
+        this.finishRej = finishRej;
+    }
+
+    public long getFinishQaApproved() {
+        return finishQaApproved;
+    }
+
+    public void setFinishQaApproved(long finishQaApproved) {
+        this.finishQaApproved = finishQaApproved;
+    }
+
+    public long getStoreReceived() {
+        return storeReceived;
+    }
+
+    public void setStoreReceived(long storeReceived) {
+        this.storeReceived = storeReceived;
+    }
+
+    public long getStoreWaiting() {
+        return storeWaiting;
+    }
+
+    public void setStoreWaiting(long storeWaiting) {
+        this.storeWaiting = storeWaiting;
+    }
+
+    public long getPackagingIn() {
+        return packagingIn;
+    }
+
+    public void setPackagingIn(long packagingIn) {
+        this.packagingIn = packagingIn;
+    }
+
+    public long getPackagingOut() {
+        return packagingOut;
+    }
+
+    public void setPackagingOut(long packagingOut) {
+        this.packagingOut = packagingOut;
+    }
+
+    public long getPackagingStock() {
+        return packagingStock;
+    }
+
+    public void setPackagingStock(long packagingStock) {
+        this.packagingStock = packagingStock;
+    }
+
+    public long getShippedScan() {
+        return shippedScan;
+    }
+
+    public void setShippedScan(long shippedScan) {
+        this.shippedScan = shippedScan;
+    }
+
+    public long getShippedNet() {
+        return shippedNet;
+    }
+
+    public void setShippedNet(long shippedNet) {
+        this.shippedNet = shippedNet;
+    }
+
+    public boolean isPoStatus() {
+        return poStatus;
+    }
+
+    public void setPoStatus(boolean poStatus) {
+        this.poStatus = poStatus;
+    }
+
+    @Override
+    public String toString() {
+        return "POsDetails{" +
+                "poId=" + poId +
+                ", poNumber='" + poNumber + '\'' +
+                ", articleTitle='" + articleTitle + '\'' +
+                ", poQuantity=" + poQuantity +
+                ", poRequiredQuantity=" + poRequiredQuantity +
+                ", actualCutting=" + actualCutting +
+                ", balanceToCutting=" + balanceToCutting +
+                ", cuttingReceived=" + cuttingReceived +
+                ", cuttingOki=" + cuttingOki +
+                ", cuttingReject=" + cuttingReject +
+                ", stitchingIn=" + stitchingIn +
+                ", stitchingWips=" + stitchingWips +
+                ", stitchingOut=" + stitchingOut +
+                ", finishIn=" + finishIn +
+                ", finishRej=" + finishRej +
+                ", finishQaApproved=" + finishQaApproved +
+                ", storeReceived=" + storeReceived +
+                ", storeWaiting=" + storeWaiting +
+                ", packagingIn=" + packagingIn +
+                ", packagingOut=" + packagingOut +
+                ", packagingStock=" + packagingStock +
+                ", shippedScan=" + shippedScan +
+                ", shippedNet=" + shippedNet +
+                '}';
+    }
+}

src/main/java/com/utopiaindustries/model/ctp/PackagingItems.java

@@ -0,0 +1,180 @@
+package com.utopiaindustries.model.ctp;
+
+import org.springframework.format.annotation.DateTimeFormat;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+
+public class PackagingItems implements InventoryArtifact {
+    private long id;
+    private long itemId;
+    private String sku;
+    private String barcode;
+    private long jobCardId;
+    @DateTimeFormat( pattern = "yyyy-MM-dd HH:mm:ss" )
+    private LocalDateTime createdAt;
+    private String createdBy;
+    private boolean isQa;
+    private long finishedItemId;
+    private boolean isSegregated;
+    // wrapper
+    private JobCard jobCard;
+    private long accountId;
+    private String qaStatus;
+    private long bundleId;
+    private String accountTitle;
+
+    public long getId() {
+        return id;
+    }
+
+    @Override
+    public String getType() {
+        return "-";
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    public long getItemId() {
+        return itemId;
+    }
+
+    public void setItemId(long itemId) {
+        this.itemId = itemId;
+    }
+
+    public String getSku() {
+        return sku;
+    }
+
+    public void setSku(String sku) {
+        this.sku = sku;
+    }
+
+    public String getBarcode() {
+        return barcode;
+    }
+
+    public void setBarcode(String barcode) {
+        this.barcode = barcode;
+    }
+
+    public LocalDateTime getCreatedAt() {
+        return createdAt;
+    }
+
+    public void setCreatedAt(LocalDateTime createdAt) {
+        this.createdAt = createdAt;
+    }
+
+    public String getCreatedBy() {
+        return createdBy;
+    }
+
+    public void setCreatedBy(String createdBy) {
+        this.createdBy = createdBy;
+    }
+
+    public long getJobCardId() {
+        return jobCardId;
+    }
+
+    public void setJobCardId(long jobCardId) {
+        this.jobCardId = jobCardId;
+    }
+
+    public boolean getIsQa() {
+        return isQa;
+    }
+
+    public void setIsQa(boolean qa) {
+        isQa = qa;
+    }
+
+    public long getFinishedItemId() {
+        return finishedItemId;
+    }
+
+    public void setFinishedItemId(long finishedItemId) {
+        this.finishedItemId = finishedItemId;
+    }
+
+    public JobCard getJobCard() {
+        return jobCard;
+    }
+
+    public void setJobCard(JobCard jobCard) {
+        this.jobCard = jobCard;
+    }
+
+    public boolean getIsSegregated() {
+        return isSegregated;
+    }
+
+    public void setIsSegregated(boolean segregated) {
+        isSegregated = segregated;
+    }
+
+    public long getAccountId() {
+        return accountId;
+    }
+
+    public void setAccountId(long accountId) {
+        this.accountId = accountId;
+    }
+
+    public String getQaStatus() {
+        return qaStatus;
+    }
+
+    public void setQaStatus(String qaStatus) {
+        this.qaStatus = qaStatus;
+    }
+
+    public BigDecimal getWrapQuantity(){
+        return null;
+    }
+
+    public long getMasterBundleId(){
+        return 0;
+    }
+
+    public long getBundleId(){
+        return bundleId;
+    }
+
+    public void setBundleId(long bundleId) {
+        this.bundleId = bundleId;
+    }
+
+    public String getAccountTitle() {
+        return accountTitle;
+    }
+
+    public void setAccountTitle(String accountTitle) {
+        this.accountTitle = accountTitle;
+    }
+
+    @Override
+    public String toString() {
+        return "PackagingItems{" +
+                "id=" + id +
+                ", itemId=" + itemId +
+                ", sku='" + sku + '\'' +
+                ", barcode='" + barcode + '\'' +
+                ", jobCardId=" + jobCardId +
+                ", createdAt=" + createdAt +
+                ", createdBy='" + createdBy + '\'' +
+                ", isQa=" + isQa +
+                ", finishedItemId=" + finishedItemId +
+                ", isSegregated=" + isSegregated +
+                ", jobCard=" + jobCard +
+                ", accountId=" + accountId +
+                ", qaStatus='" + qaStatus + '\'' +
+                ", bundleId=" + bundleId +
+                ", accountTitle='" + accountTitle + '\'' +
+                '}';
+    }
+}

src/main/java/com/utopiaindustries/model/ctp/PurchaseOrderCTP.java

@@ -0,0 +1,84 @@
+package com.utopiaindustries.model.ctp;
+
+import java.time.LocalDateTime;
+
+public class PurchaseOrderCTP {
+
+    public enum Status{
+        DRAFT,
+        POSTED,
+    }
+
+    private long id;
+    private String purchaseOrderCode;
+    private long purchaseOrderQuantity;
+    private long purchaseOrderQuantityRequired;
+    private String articleName;
+    private String createdBy;
+    private LocalDateTime createdAt;
+    private String status;
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    public String getPurchaseOrderCode() {
+        return purchaseOrderCode;
+    }
+
+    public void setPurchaseOrderCode(String purchaseOrderCode) {
+        this.purchaseOrderCode = purchaseOrderCode;
+    }
+
+    public long getPurchaseOrderQuantity() {
+        return purchaseOrderQuantity;
+    }
+
+    public void setPurchaseOrderQuantity(long purchaseOrderQuantity) {
+        this.purchaseOrderQuantity = purchaseOrderQuantity;
+    }
+
+    public long getPurchaseOrderQuantityRequired() {
+        return purchaseOrderQuantityRequired;
+    }
+
+    public void setPurchaseOrderQuantityRequired(long purchaseOrderQuantityRequired) {
+        this.purchaseOrderQuantityRequired = purchaseOrderQuantityRequired;
+    }
+
+    public String getArticleName() {
+        return articleName;
+    }
+
+    public void setArticleName(String articleName) {
+        this.articleName = articleName;
+    }
+
+    public String getCreatedBy() {
+        return createdBy;
+    }
+
+    public void setCreatedBy(String createdBy) {
+        this.createdBy = createdBy;
+    }
+
+    public LocalDateTime getCreatedAt() {
+        return createdAt;
+    }
+
+    public void setCreatedAt(LocalDateTime createdAt) {
+        this.createdAt = createdAt;
+    }
+
+    public String getStatus() {
+        return status;
+    }
+
+    public void setStatus(String status) {
+        this.status = status;
+    }
+}

src/main/java/com/utopiaindustries/model/ctp/SkuCutPieces.java

@@ -0,0 +1,43 @@
+package com.utopiaindustries.model.ctp;
+
+
+public class SkuCutPieces {
+
+    private long id;
+    private String sku;
+    private String type;
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    public String getSku() {
+        return sku;
+    }
+
+    public void setSku(String sku) {
+        this.sku = sku;
+    }
+
+    public String getType() {
+        return type;
+    }
+
+    public void setType(String type) {
+        this.type = type;
+    }
+
+    @Override
+    public String toString() {
+        return "CutPiece{" +
+                "id=" + id +
+                ", sku=" + sku +
+                ", type='" + type +
+                '}';
+    }
+}
+

src/main/java/com/utopiaindustries/model/ctp/StitchedItemWrapper.java

@@ -1,12 +1,20 @@
 package com.utopiaindustries.model.ctp;
 
 import java.util.*;
+
 public class StitchedItemWrapper {
 
-
+    private String qaStatus;
     private List<StitchingOfflineItem> items;
     private Long finishedAccountId;
 
+    public String getQaStatus() {
+        return qaStatus;
+    }
+
+    public void setQaStatus(String qaStatus) {
+        this.qaStatus = qaStatus;
+    }
 
     public List<StitchingOfflineItem> getItems() {
         return items;

src/main/java/com/utopiaindustries/model/ctp/StitchingOfflineItem.java

@@ -2,6 +2,7 @@ package com.utopiaindustries.model.ctp;
 
 import org.springframework.format.annotation.DateTimeFormat;
 
+import java.math.BigDecimal;
 import java.time.LocalDateTime;
 
 public class StitchingOfflineItem implements InventoryArtifact {
@@ -13,10 +14,15 @@ public class StitchingOfflineItem implements InventoryArtifact {
     private long jobCardId;
     @DateTimeFormat( pattern = "yyyy-MM-dd HH:mm:ss" )
     private LocalDateTime createdAt;
+
+    @DateTimeFormat( pattern = "yyyy-MM-dd HH:mm:ss" )
+    private LocalDateTime qcDoneAt;
+
     private String createdBy;
     private boolean isQa;
     private String qaRemarks;
     private String qaStatus;
+    private long bundleId;
 
     @Override
     public String getType() {
@@ -107,6 +113,30 @@ public class StitchingOfflineItem implements InventoryArtifact {
         this.qaStatus = qaStatus;
     }
 
+    public BigDecimal getWrapQuantity(){
+        return null;
+    }
+
+    public long getMasterBundleId(){
+        return 0;
+    }
+
+    public long getBundleId() {
+        return bundleId;
+    }
+
+    public void setBundleId(long bundleId) {
+        this.bundleId = bundleId;
+    }
+
+    public LocalDateTime getQcDoneAt() {
+        return qcDoneAt;
+    }
+
+    public void setQcDoneAt(LocalDateTime qcDoneAt) {
+        this.qcDoneAt = qcDoneAt;
+    }
+
     @Override
     public String toString() {
         return "StitchingOfflineItem{" +

src/main/java/com/utopiaindustries/model/ctp/StoreItem.java

@@ -0,0 +1,151 @@
+package com.utopiaindustries.model.ctp;
+
+import org.springframework.format.annotation.DateTimeFormat;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+
+public class StoreItem implements InventoryArtifact {
+
+    private long id;
+    private long itemId;
+    private String sku;
+    private String barcode;
+    private long jobCardId;
+    @DateTimeFormat( pattern = "yyyy-MM-dd HH:mm:ss" )
+    private LocalDateTime createdAt;
+    private String createdBy;
+    private long finishedItemId;
+    private long bundleId;
+    private long accountId;
+    private String rejectedReason;
+
+
+    @Override
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    @Override
+    public long getItemId() {
+        return itemId;
+    }
+
+    public void setItemId(long itemId) {
+        this.itemId = itemId;
+    }
+
+    @Override
+    public String getSku() {
+        return sku;
+    }
+
+    @Override
+    public String getType() {
+        return "";
+    }
+
+    public void setSku(String sku) {
+        this.sku = sku;
+    }
+
+    @Override
+    public String getBarcode() {
+        return barcode;
+    }
+
+    public void setBarcode(String barcode) {
+        this.barcode = barcode;
+    }
+
+    @Override
+    public long getJobCardId() {
+        return jobCardId;
+    }
+
+    public void setJobCardId(long jobCardId) {
+        this.jobCardId = jobCardId;
+    }
+
+    @Override
+    public LocalDateTime getCreatedAt() {
+        return createdAt;
+    }
+
+    @Override
+    public BigDecimal getWrapQuantity() {
+        return null;
+    }
+
+    @Override
+    public long getMasterBundleId() {
+        return 0;
+    }
+
+    public void setCreatedAt(LocalDateTime createdAt) {
+        this.createdAt = createdAt;
+    }
+
+    @Override
+    public String getCreatedBy() {
+        return createdBy;
+    }
+
+    public void setCreatedBy(String createdBy) {
+        this.createdBy = createdBy;
+    }
+
+    public long getFinishedItemId() {
+        return finishedItemId;
+    }
+
+    public void setFinishedItemId(long finishedItemId) {
+        this.finishedItemId = finishedItemId;
+    }
+
+    @Override
+    public long getBundleId() {
+        return bundleId;
+    }
+
+    public void setBundleId(long bundleId) {
+        this.bundleId = bundleId;
+    }
+
+    public long getAccountId() {
+        return accountId;
+    }
+
+    public void setAccountId(long accountId) {
+        this.accountId = accountId;
+    }
+
+    public String getRejectedReason() {
+        return rejectedReason;
+    }
+
+    public void setRejectedReason(String rejectedReason) {
+        this.rejectedReason = rejectedReason;
+    }
+
+    @Override
+    public String toString() {
+        return "StoreItem{" +
+                "id=" + id +
+                ", itemId=" + itemId +
+                ", sku='" + sku + '\'' +
+                ", barcode='" + barcode + '\'' +
+                ", jobCardId=" + jobCardId +
+                ", createdAt=" + createdAt +
+                ", createdBy='" + createdBy + '\'' +
+                ", finishedItemId=" + finishedItemId +
+                ", bundleId=" + bundleId +
+                ", accountId=" + accountId +
+                ", rejectedReason='" + rejectedReason + '\'' +
+                '}';
+    }
+}

src/main/java/com/utopiaindustries/model/ctp/SummaryInventoryReport.java

@@ -7,6 +7,7 @@ public class SummaryInventoryReport {
     private String Date;
     private long totalIn;
     private long totalOut;
+    private long jobCardID;
     private String parentDocumentType;
     private String parentDocumentId;
     private String accountId;
@@ -91,4 +92,12 @@ public class SummaryInventoryReport {
     public void setAccountId(String accountId) {
         this.accountId = accountId;
     }
+
+    public long getJobCardID() {
+        return jobCardID;
+    }
+
+    public void setJobCardID(long jobCardID) {
+        this.jobCardID = jobCardID;
+    }
 }

src/main/java/com/utopiaindustries/querybuilder/ctp/PurchaseOrderCTPQueryBuilder.java

@@ -0,0 +1,46 @@
+package com.utopiaindustries.querybuilder.ctp;
+
+import com.utopiaindustries.querybuilder.QueryBuilder;
+import com.utopiaindustries.util.CTPDateTimeFormat;
+import com.utopiaindustries.util.StringUtils;
+
+import java.time.LocalDate;
+
+public class PurchaseOrderCTPQueryBuilder {
+    public static String buildQuery(String purchaseOrderCode, String articleName, String createdBy, String startDate, String endDate, Long count ){
+        // format date
+        String formattedDate;
+        String formattedEndDate;
+        String startDate1 = "";
+        String endDate1 = "";
+        String purchaseOrderCode1 = purchaseOrderCode == null ? "" : purchaseOrderCode;
+        String articleName1 = articleName == null ? "" : articleName;
+        if ( ! StringUtils.isNullOrEmpty( startDate ) ) {
+            formattedDate = CTPDateTimeFormat.getMySQLFormattedDateString( startDate, CTPDateTimeFormat.HTML5_DATE_INPUT_FORMAT );
+            formattedEndDate = CTPDateTimeFormat.getMySQLFormattedDateString( endDate, CTPDateTimeFormat.HTML5_DATE_INPUT_FORMAT );
+            startDate1 = String.format( "'%s 00:00:01'", formattedDate );
+            if ( ! StringUtils.isNullOrEmpty( endDate ) ) {
+                endDate1 = String.format("'%s 23:59:59'", formattedEndDate);
+            }
+            else {
+                endDate1 = String.format("'%s 23:59:59'", LocalDate.now() );
+            }
+        }
+
+        return (new QueryBuilder())
+                .setTable("cut_to_pack.purchase_order")
+                .setColumns("*")
+                .where()
+                .columnEquals("created_by", createdBy)
+                .and()
+                .columnLike("purchase_order_code", "%" + purchaseOrderCode1 + "%")
+                .and()
+                .columnLike("article_name", articleName)
+                .and()
+                .columnEqualToOrGreaterThan("created_at", startDate1)
+                .and()
+                .columnEqualToOrLessThan("created_at", endDate1)
+                .limit(count.intValue())
+                .build();
+    }
+}

src/main/java/com/utopiaindustries/querybuilder/ctp/StichedOfflineItemQueryBuilder.java

@@ -8,7 +8,7 @@ import java.time.LocalDate;
 
 public class StichedOfflineItemQueryBuilder {
 
-    public static String buildQuery(String id, String itemId, String sku, String createdStartDate, String createdEndDate, String jobCardId, Long count) {
+    public static String buildQuery(String id, String itemId, String sku, String QaStatus,String createdStartDate, String createdEndDate, Long bundleId, Long count) {
         // format date
         String formattedDate;
         String formattedEndDate;
@@ -24,8 +24,7 @@ public class StichedOfflineItemQueryBuilder {
                 endDate1 = String.format("'%s 23:59:59'", LocalDate.now());
             }
         }
-
-        return ( new QueryBuilder() )
+        QueryBuilder qb = (new QueryBuilder())
                 .setTable("cut_to_pack.stitching_offline_item")
                 .setColumns("*")
                 .where()
@@ -35,15 +34,18 @@ public class StichedOfflineItemQueryBuilder {
                 .and()
                 .columnEquals("item_id", itemId)
                 .and()
-                .columnEquals("job_card_id", jobCardId )
+                .columnEquals("bundle_id", bundleId)
                 .and()
                 .columnEqualToOrGreaterThan("created_at", startDate1)
                 .and()
-                .columnEqualToOrLessThan("created_at", endDate1 )
-                .orderBy("id","DESC")
-                .limit(count)
-                .build();
+                .columnEqualToOrLessThan("created_at", endDate1);
+                if (!StringUtils.isNullOrEmpty(QaStatus)) {
+                    qb.and().columnEquals("qa_status", QaStatus);
+                }
+                qb.orderBy("id", "DESC")
+                        .limit(count);
 
+        return qb.build();
     }
 }
 

src/main/java/com/utopiaindustries/querybuilder/ctp/SummaryInventoryReportQueryBuilder.java

@@ -62,11 +62,42 @@ public class SummaryInventoryReportQueryBuilder {
                 .bracketClose()
                 .bracketClose()
                 .and()
-                .columnBetween("transaction_leg_date",startDate,endDate)
+                .columnBetween("transaction_leg_datetime",startDate,endDate)
                 .groupBy("DATE(transaction_leg_datetime), sku, parent_document_type, parent_document_piece_type")
                 .orderBy("transaction_date,", "sku");
 
         return qb.build();
+    }
 
+    public static String cuttingQueryBuild(long jobCardId,
+                                    List<Long> account,
+                                    String sku,
+                                    String startDate,
+                                    String endDate,
+                                    String type,
+                                    String parentDocumentType) {
+
+        QueryBuilder qb = new QueryBuilder()
+                .setTable(TABLE_NAME)
+                .setColumns("*")
+                .where()
+                .columnIn("account_id",account.toArray(new Long[0]))
+                .and()
+                .columnEqualToOrGreaterThan("transaction_leg_datetime",startDate)
+                .and()
+                .columnEqualToOrLessThan("transaction_leg_datetime",endDate)
+                .and()
+                .columnEquals("type",type)
+                .and()
+                .columnEquals("parent_document_type",parentDocumentType);
+        if (jobCardId != 0){
+            qb.and()
+                    .columnEquals("job_card_id", jobCardId );
+        }
+        if (!StringUtils.isNullOrEmpty(sku)){
+            qb.and()
+                    .columnEquals("sku", sku );
+        }
+        return qb.build();
     }
 }

src/main/java/com/utopiaindustries/restcontroller/BundleRestController.java

@@ -34,4 +34,13 @@ public class BundleRestController {
         return bundleService.findBundlesByMasterId( masterId );
     }
 
+    @GetMapping( "/find-bundle-by-id/{id}" )
+    public Bundle findBundleById( @PathVariable("id") long id ){
+        return bundleService.getBundlesById(id);
+    }
+
+    @GetMapping( "/find-bundle-by-barcode" )
+    public List<Bundle> findByMasterBarcode(@RequestParam String term ){
+        return bundleService.getBundles( term );
+    }
 }

src/main/java/com/utopiaindustries/restcontroller/CutPieceRestController.java

@@ -1,19 +1,42 @@
 package com.utopiaindustries.restcontroller;
 
+import com.utopiaindustries.dao.ctp.CutPieceTypeDAO;
+import com.utopiaindustries.dao.ctp.SkuCutPiecesDAO;
+import com.utopiaindustries.model.ctp.CutPieceType;
+import com.utopiaindustries.model.ctp.SkuCutPieces;
 import com.utopiaindustries.service.JobCardService;
-import org.springframework.web.bind.annotation.PostMapping;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RequestParam;
-import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.ArrayList;
+import java.util.List;
 
 @RestController
 @RequestMapping( "/rest/cut-pieces" )
 public class CutPieceRestController {
 
     private final JobCardService jobCardService;
+    private final SkuCutPiecesDAO skuCutPiecesDAO;
+    private final CutPieceTypeDAO cutPieceTypeDAO;
 
-    public CutPieceRestController(JobCardService jobCardService) {
+    public CutPieceRestController(JobCardService jobCardService, SkuCutPiecesDAO skuCutPiecesDAO, CutPieceTypeDAO cutPieceTypeDAO) {
         this.jobCardService = jobCardService;
+        this.skuCutPiecesDAO = skuCutPiecesDAO;
+        this.cutPieceTypeDAO = cutPieceTypeDAO;
+    }
+
+    @GetMapping
+    public List<CutPieceType> getBySku(@RequestParam("sku") String sku) {
+        try {
+            ArrayList<CutPieceType> cutPieceTypes = new ArrayList<>();
+            List<SkuCutPieces> skuCutPieces =  skuCutPiecesDAO.findBySku(sku);
+            for (SkuCutPieces skuCutPieces1 : skuCutPieces){
+                CutPieceType cutPieceType = cutPieceTypeDAO.findByTitle(skuCutPieces1.getType());
+                cutPieceTypes.add(cutPieceType);
+            }
+            return cutPieceTypes;
+        } catch (Exception e) {
+            throw new RuntimeException("An error occurred while fetching data for SKU: " + sku, e);
+        }
     }
 
     @PostMapping

src/main/java/com/utopiaindustries/restcontroller/FinishedItemRestController.java

@@ -22,6 +22,18 @@ public class FinishedItemRestController {
     @GetMapping("/search")
     public List<FinishedItem> searchFinishedItems(@RequestParam("term") String term,
                                                   @RequestParam("is-segregated") boolean isSegregated) {
-        return finishedItemDAO.findByTerm( term, isSegregated );
+        return finishedItemDAO.findByTerm(term, true);
+    }
+
+    @GetMapping("/search-packaging")
+    public List<FinishedItem> searchFinishedItemsForPackaging(@RequestParam("term") String term,
+                                                              @RequestParam("is-segregated") boolean isSegregated) {
+        return finishedItemDAO.findByTermForPackaging(term, isSegregated, "APPROVED");
+    }
+
+    @GetMapping("/search-store")
+    public List<FinishedItem> searchFinishedItemsForStore(@RequestParam("term") String term,
+                                                              @RequestParam("is-segregated") boolean isSegregated) {
+        return finishedItemDAO.findByTermForPackaging(term, isSegregated,"REJECT");
     }
 }

src/main/java/com/utopiaindustries/restcontroller/ItemRestController.java

@@ -31,7 +31,7 @@ public class ItemRestController {
             items = itemDAO.findBySkuOrTitleAndTypeIdAndActive(term, Arrays.stream(typeIds).collect(Collectors.toList()), "1" );
         } else {
             // else return all results
-            items = itemDAO.findLikeTitleAndStatus(term, true );
+            items = itemDAO.findLikeTitleAndStatusORSKU(term, true );
         }
         return items;
     }

src/main/java/com/utopiaindustries/restcontroller/PurchaseOrderRestController.java

@@ -1,6 +1,8 @@
 package com.utopiaindustries.restcontroller;
 
+import com.utopiaindustries.model.ctp.PurchaseOrderCTP;
 import com.utopiaindustries.model.uind.PurchaseOrder;
+import com.utopiaindustries.service.PurchaseOrderCTPService;
 import com.utopiaindustries.service.PurchaseOrderService;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.RequestMapping;
@@ -14,9 +16,11 @@ import java.util.List;
 public class PurchaseOrderRestController {
 
     private final PurchaseOrderService purchaseOrderService;
+    private final PurchaseOrderCTPService purchaseOrderCTPService;
 
-    public PurchaseOrderRestController(PurchaseOrderService purchaseOrderService) {
+    public PurchaseOrderRestController(PurchaseOrderService purchaseOrderService, PurchaseOrderCTPService purchaseOrderCTPService) {
         this.purchaseOrderService = purchaseOrderService;
+        this.purchaseOrderCTPService = purchaseOrderCTPService;
     }
 
     /*
@@ -26,4 +30,12 @@ public class PurchaseOrderRestController {
     public List<PurchaseOrder> findByTerm(@RequestParam("term") String term ) {
         return purchaseOrderService.findByTerm( term );
     }
+
+    /*
+    *  search by term in ctp purchase order table
+    * */
+    @GetMapping( "/ctp-po-search" )
+    public List<PurchaseOrderCTP> findByTermInCtpPurchaseOrderTable(@RequestParam("term") String term ) {
+        return purchaseOrderCTPService.findByTerm( term );
+    }
 }

src/main/java/com/utopiaindustries/service/BarcodeService.java

@@ -1,10 +1,18 @@
 package com.utopiaindustries.service;
 
 import com.google.zxing.BarcodeFormat;
-import com.utopiaindustries.dao.ctp.BundleDAO;
-import com.utopiaindustries.dao.ctp.FinishedItemDAO;
-import com.utopiaindustries.dao.ctp.MasterBundleDAO;
-import com.utopiaindustries.dao.ctp.StitchingOfflineItemDAO;
+import com.itextpdf.io.font.constants.StandardFonts;
+import com.itextpdf.io.image.ImageData;
+import com.itextpdf.kernel.colors.ColorConstants;
+import com.itextpdf.kernel.font.PdfFont;
+import com.itextpdf.kernel.font.PdfFontFactory;
+import com.itextpdf.kernel.pdf.PdfPage;
+import com.itextpdf.kernel.pdf.canvas.PdfCanvas;
+import com.itextpdf.layout.element.AreaBreak;
+import com.itextpdf.layout.element.Paragraph;
+import com.itextpdf.layout.property.AreaBreakType;
+import com.itextpdf.layout.property.TextAlignment;
+import com.utopiaindustries.dao.ctp.*;
 import com.utopiaindustries.model.ctp.*;
 import com.utopiaindustries.util.BarcodeUtils;
 import com.utopiaindustries.util.StringUtils;
@@ -13,30 +21,77 @@ import com.zebra.sdk.comm.TcpConnection;
 import com.zebra.sdk.graphics.internal.ZebraImage;
 import com.zebra.sdk.printer.ZebraPrinter;
 import com.zebra.sdk.printer.ZebraPrinterFactory;
+import org.apache.pdfbox.pdmodel.PDDocument;
+import org.apache.pdfbox.rendering.PDFRenderer;
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
-
+import com.itextpdf.io.image.ImageDataFactory;
+import com.itextpdf.kernel.pdf.PdfDocument;
+import com.itextpdf.kernel.geom.PageSize;
+import com.itextpdf.kernel.pdf.PdfWriter;
+import com.itextpdf.layout.Document;
+import com.itextpdf.layout.element.Image;
 import javax.imageio.ImageIO;
+import java.awt.image.BufferedImage;
+import java.io.ByteArrayOutputStream;
+import java.net.Socket;
+import java.nio.file.Path;
+import java.nio.file.FileSystems;
+
 import java.awt.*;
 import java.awt.Font;
-import java.awt.image.BufferedImage;
-import java.io.ByteArrayInputStream;
+import java.io.*;
 
+import java.time.format.DateTimeFormatter;
 import java.util.ArrayList;
 import java.util.List;
+import com.google.zxing.EncodeHintType;
+import com.google.zxing.qrcode.QRCodeWriter;
+import com.google.zxing.WriterException;
+import com.google.zxing.common.BitMatrix;
+
+import java.io.ByteArrayInputStream;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.stream.Collectors;
 
 @Service
 public class BarcodeService {
 
+    @Value("${ctp.printer.ipAdd}")
+    private String ipAddress;
+
+    @Value("${ctp.printer.port}")
+    private int port;
+
+    @Value("${ctp.printer.bundleIpAdd}")
+    private String bundleIpAddress;
+
+    @Value("${ctp.printer.bundlePort}")
+    private int bundlePort;
+
+    @Value("${ctp.printer.stitchQRPath}")
+    private String stitchPath;
+
+    @Value("${ctp.printer.bundlePath}")
+    private String bundlePath;
+
     private final BundleDAO bundleDAO;
+    private final JobCardDAO jobCardDAO;
     private final MasterBundleDAO masterBundleDAO;
     private final FinishedItemDAO finishedItemDAO;
     private final StitchingOfflineItemDAO stitchingOfflineItemDAO;
+    private final InventoryAccountDAO inventoryAccountDAO;
+    private final JobCardItemDAO jobCardItemDAO;
 
-    public BarcodeService(BundleDAO bundleDAO, MasterBundleDAO masterBundleDAO, FinishedItemDAO finishedItemDAO, StitchingOfflineItemDAO stitchingOfflineItemDAO) {
+    public BarcodeService(BundleDAO bundleDAO, JobCardDAO jobCardDAO, MasterBundleDAO masterBundleDAO, FinishedItemDAO finishedItemDAO, StitchingOfflineItemDAO stitchingOfflineItemDAO, InventoryAccountDAO inventoryAccountDAO, JobCardItemDAO jobCardItemDAO) {
         this.bundleDAO = bundleDAO;
+        this.jobCardDAO = jobCardDAO;
         this.masterBundleDAO = masterBundleDAO;
         this.finishedItemDAO = finishedItemDAO;
         this.stitchingOfflineItemDAO = stitchingOfflineItemDAO;
+        this.inventoryAccountDAO = inventoryAccountDAO;
+        this.jobCardItemDAO = jobCardItemDAO;
     }
 
     /*
@@ -49,83 +104,356 @@ public class BarcodeService {
         List<? extends InventoryArtifact> list = new ArrayList<>();
         if (StringUtils.compare(artifactType, Bundle.class.getSimpleName())) {
             list = bundleDAO.findByIds(ids);
+            getBarcodeImages(list, stickerSize, artifactType);
         } else if (StringUtils.compare(artifactType, MasterBundle.class.getSimpleName())) {
             list = masterBundleDAO.findByIds(ids);
-        } else if (StringUtils.compare(artifactType, FinishedItem.class.getSimpleName())) {
-            list = stitchingOfflineItemDAO.findByIds(ids);
-        }
-
             getBarcodeImages(list, stickerSize, artifactType);
-
+        } else if (StringUtils.compare(artifactType, FinishedItem.class.getSimpleName())) {
+            String sizeForStitchItem = BarcodeStickerSize.SIZE_1_X_2.name();
+            BarcodeStickerSize stickerSizeForStitchItem = BarcodeStickerSize.getSize(sizeForStitchItem);
+            list = stitchingOfflineItemDAO.findByIds(ids);
+            getBarcodeImagesForStitchItems(list, stickerSizeForStitchItem);
+        }
     }
 
     public void getBarcodeImages(List<? extends InventoryArtifact> artifacts,
                                  BarcodeStickerSize stickerSize,
                                  String artifactType) throws Exception {
-
-        for (InventoryArtifact artifact : artifacts) {
-            // Create a blank BufferedImage (an image with the size of the sticker)
-            BufferedImage stickerImage = new BufferedImage((int) stickerSize.getWidth()*2, (int) stickerSize.getHeight()*2, BufferedImage.TYPE_INT_ARGB);
-            Graphics2D g2d = stickerImage.createGraphics();
-            g2d.scale(2,2);
+        int pageWidth = 900; // A4 Width
+        int pageHeight = 1200; // A4 Height
+        int rows = 3;
+        int cols = 2;
+        int totalStickersPerPage = rows * cols;
+        int totalPages = (int) Math.ceil((double) artifacts.size() / totalStickersPerPage); // Total required pages
+        List<BufferedImage> bufferedImages = new ArrayList<>();
+        for (int page = 0; page < totalPages; page++) {
+            // Create a Blank A4 Page Image
+            BufferedImage a4Image = new BufferedImage(pageWidth, pageHeight, BufferedImage.TYPE_INT_ARGB);
+            Graphics2D g2d = a4Image.createGraphics();
             g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
-
-            // Set background color (white for the sticker)
             g2d.setColor(Color.WHITE);
-            g2d.fillRect(0, 0, (int) stickerSize.getWidth(), (int) stickerSize.getHeight());
+            g2d.fillRect(0, 0, pageWidth, pageHeight);
+            g2d.setColor(Color.BLACK);
 
-            // Set font for SKU and barcode
-            Font font = new Font("Helvetica", Font.BOLD, stickerSize.getTextSize()+10);
-            g2d.setFont(font);
+            Font barcodeFont = new Font("Helvetica", Font.BOLD, stickerSize.getTextSize()+8);
+            Font detailFont = new Font("Helvetica", Font.PLAIN, stickerSize.getTextSize()+3);
 
-            // Add SKU to the image
+            for (int i = 0; i < totalStickersPerPage; i++) {
+                int artifactIndex = page * totalStickersPerPage + i;
+                if (artifactIndex >= artifacts.size()) break;
+                InventoryArtifact artifact = artifacts.get(artifactIndex);
+                int row = i / cols;
+                int col = i % cols;
+
+                int x = col * (pageWidth / cols);
+                int y = row * (pageHeight / rows);
+
+                Font stickerFont = new Font("Helvetica", Font.BOLD, stickerSize.getTextSize() + 10);
+                g2d.setFont(stickerFont);
+                // Draw Sticker Border
+                g2d.drawRect(x, y, pageWidth / cols, pageHeight / rows);
+
+                this.drawCenteredText(g2d, artifactType.equals("Bundle")?"Sub-Bundle":"Master-Bundle", detailFont, x, y, pageWidth, cols, stickerSize.getMarginTop()-20,stickerSize.getMarginLeft()-165);
+
+                // Draw SKU
+                g2d.setFont(barcodeFont);
                 String sku = artifact.getSku();
                 FontMetrics fontMetrics = g2d.getFontMetrics();
                 int textWidth = fontMetrics.stringWidth(sku);
-            int x = (int) ((stickerSize.getWidth() - textWidth) / 2);
-            g2d.setColor(Color.BLACK);
-            g2d.drawString(sku, x, stickerSize.getMarginTop() + fontMetrics.getAscent()+20);
+                g2d.drawString(sku, x + ((pageWidth / cols) - textWidth) / 2, y + fontMetrics.getAscent()+ stickerSize.getMarginTop()+10);
+
+                // Generate Barcode Image
+                g2d.setFont(barcodeFont);
+                byte[] imgBytes = BarcodeUtils.getBarcodeImageByteArray(
+                        artifact.getBarcode(), BarcodeFormat.CODE_128, stickerSize.getImageWidthBarcode(), stickerSize.getImageHeightBarcode());
 
-            // Create the barcode image
-            byte[] imgBytes = BarcodeUtils.getBarcodeImageByteArray(artifact.getBarcode(), BarcodeFormat.CODE_128, stickerSize.getImageWidthBarcode()+500, stickerSize.getImageHeightBarcode()+30);
                 BufferedImage barcodeImage = ImageIO.read(new ByteArrayInputStream(imgBytes));
+                int originalBarcodeWidth = barcodeImage.getWidth();
+                int originalBarcodeHeight = barcodeImage.getHeight();
 
-            // Draw the barcode image on the sticker
-            int barcodeX =(int) (stickerSize.getWidth() - barcodeImage.getWidth()) / 2;
-            int barcodeY = stickerSize.getMarginTop() + fontMetrics.getAscent() + 30; // Add some margin
-            g2d.drawImage(barcodeImage, barcodeX, barcodeY, null);
 
-            // Add the barcode value below the barcode image
-            g2d.drawString(artifact.getBarcode(), (stickerSize.getWidth() - fontMetrics.stringWidth(artifact.getBarcode())) / 2,
-                    barcodeY + barcodeImage.getHeight() + fontMetrics.getAscent());
+                double scaleX = (double)(pageWidth / cols) / originalBarcodeWidth;
+                double scaleY = (double)(pageHeight / rows) / originalBarcodeHeight;
+                double scaleFactor = Math.min(scaleX, scaleY);
 
-            // If artifactType is Bundle, add additional info
-            if (artifactType.equalsIgnoreCase(Bundle.class.getSimpleName())) {
-                String typeText = String.format("%s : %d", artifact.getType(), artifact.getId());
-                g2d.drawString(typeText, (stickerSize.getWidth() - fontMetrics.stringWidth(typeText)) / 2,
-                        barcodeY + barcodeImage.getHeight() + fontMetrics.getAscent() + 45);
+                int scaledWidth = (int)(originalBarcodeWidth * scaleFactor) - 30;
+                int scaledHeight = (int)(originalBarcodeHeight * scaleFactor) - 10;
 
-                g2d.setFont(new Font("Helvetica", Font.BOLD, stickerSize.getTextSize()+20));
-                g2d.drawString(String.valueOf(artifactType.toCharArray()[0]), (stickerSize.getWidth() - fontMetrics.stringWidth(String.valueOf(artifactType.toCharArray()[0]))) / 2,
-                        barcodeY + barcodeImage.getHeight() + fontMetrics.getAscent() + 77);
+                BufferedImage scaledBarcodeImage = new BufferedImage(scaledWidth, scaledHeight, BufferedImage.TYPE_INT_ARGB);
+                Graphics2D g2dBarcode = scaledBarcodeImage.createGraphics();
+                g2dBarcode.drawImage(barcodeImage, 0, 0, scaledWidth, scaledHeight, null);
+                g2dBarcode.dispose();
+
+                int barcodeX = x + ((pageWidth / cols) - scaledBarcodeImage.getWidth()) / 2;
+                int barcodeY = y + fontMetrics.getAscent() + stickerSize.getMarginTop() + 20;
+                g2d.drawImage(scaledBarcodeImage, barcodeX, barcodeY, null);
+
+                //barcode text
+                g2d.setFont(barcodeFont);
+                String barcode = artifact.getBarcode();
+                FontMetrics barcodeFontMatrix = g2d.getFontMetrics();
+                int barcodeText = fontMetrics.stringWidth(barcode);
+                g2d.drawString(barcode, (x + ((pageWidth / cols) - barcodeText) / 2), y + barcodeFontMatrix.getAscent() + stickerSize.getMarginTop() + 120);
+
+                //draw item-id
+                DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd-MM-yyyy hh:mm");
+                this.drawCenteredText(g2d, "Item-ID: "+artifact.getItemId(), detailFont, x, y, pageWidth, cols, stickerSize.getMarginTop() + 150,stickerSize.getMarginLeft());
+                this.drawCenteredText(g2d, "Created-By: "+artifact.getCreatedBy(), detailFont, x, y, pageWidth, cols, stickerSize.getMarginTop() + 170,stickerSize.getMarginLeft());
+                this.drawCenteredText(g2d, "Created-At: "+formatter.format(artifact.getCreatedAt()), detailFont, x, y, pageWidth, cols, stickerSize.getMarginTop() + 190,stickerSize.getMarginLeft());
+
+                //draw job-card details
+                JobCard jobCard = jobCardDAO.find(artifact.getJobCardId());
+
+                this.drawCenteredText(g2d, "Job-Card: " + jobCard.getCode(), detailFont, x, y, pageWidth, cols, stickerSize.getMarginTop() + 210, stickerSize.getMarginLeft() );
+                this.drawCenteredText(g2d, "Purchase-Order: " + jobCard.getPurchaseOrderId(), detailFont, x, y, pageWidth, cols, stickerSize.getMarginTop() + 230, stickerSize.getMarginLeft());
+                this.drawCenteredText(g2d, "Lot-Number: " + jobCard.getLotNumber(), detailFont, x, y, pageWidth, cols, stickerSize.getMarginTop() + 250, stickerSize.getMarginLeft());
+                if((artifactType.equals("Bundle"))){
+                    JobCardItem jobCardItem = jobCardItemDAO.findByCardId(jobCard.getId()).get(0);
+                    InventoryAccount inventoryAccount = inventoryAccountDAO.find(jobCardItem.getAccountId());
+                    this.drawCenteredText(g2d, "Pieces: " + artifact.getWrapQuantity(), detailFont, x, y, pageWidth, cols, stickerSize.getMarginTop() + 270, stickerSize.getMarginLeft());
+                    this.drawCenteredText(g2d, "Cutting-Account: " + inventoryAccount.getTitle() , detailFont, x, y, pageWidth, cols, stickerSize.getMarginTop() + 290, stickerSize.getMarginLeft());
                 }else {
-                // Add first character of artifact type
-                String type = String.valueOf(artifactType.charAt(0));
-                g2d.setFont(new Font("Helvetica", Font.BOLD, stickerSize.getTextSize()+10));
-                g2d.drawString(type, (stickerSize.getWidth() - fontMetrics.stringWidth(type)) / 2,
-                        barcodeY + barcodeImage.getHeight() + fontMetrics.getAscent() + 45);
+                    List<Bundle> bundles = bundleDAO.findByMasterId(artifact.getId());
+                    String concatenatedIds = bundles.stream()
+                            .map(bundle -> String.valueOf(bundle.getId()))
+                            .collect(Collectors.joining("\\"));
+                    int totalWrappedQuantity = bundles.stream()
+                            .mapToInt(e->e.getWrapQuantity().intValue())
+                            .sum();
+                    this.drawCenteredText(g2d, "Total-Pieces: " + totalWrappedQuantity, detailFont, x, y, pageWidth, cols, stickerSize.getMarginTop() + 270, stickerSize.getMarginLeft());
+                    this.drawCenteredText(g2d, "Sub-Bundles: " + concatenatedIds, detailFont, x, y, pageWidth, cols, stickerSize.getMarginTop() + 290, stickerSize.getMarginLeft());
                 }
 
-            // Finalize drawing
+                this.drawCenteredText(g2d, String.valueOf(artifact.getId()), detailFont, x, y, pageWidth, cols, stickerSize.getMarginTop() + 330, 0);
+            }
             g2d.dispose();
-            printLabel(stickerImage);
+            bufferedImages.add(a4Image);
+        }
+        saveA4ImageToPDF(bufferedImages,bundlePath);
+        try {
+            printPDF(bundleIpAddress, bundlePath);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void printPDF(String printerIP, String pdfFilePath) throws Exception {
+        File pdfFile = new File(pdfFilePath);
+        FileInputStream fis = new FileInputStream(pdfFile);
+
+        Socket printerSocket = new Socket(printerIP, port);
+        OutputStream out = printerSocket.getOutputStream();
+
+        byte[] buffer = new byte[1024];
+        int bytesRead;
+        while ((bytesRead = fis.read(buffer)) != -1) {
+            out.write(buffer, 0, bytesRead);
+        }
+        out.flush();
+        out.close();
+        fis.close();
+        printerSocket.close();
+    }
+
+    public void saveA4ImageToPDF(List<BufferedImage> a4Images, String outputFilePath) throws Exception {
+        PdfWriter writer = new PdfWriter(outputFilePath);
+        PdfDocument pdfDoc = new PdfDocument(writer);
+        Document document = new Document(pdfDoc, PageSize.A4);
+        document.setMargins(0, 0, 0, 0);
+
+        for (int i = 0; i < a4Images.size(); i++) {
+            if (i > 0) {
+                document.add(new AreaBreak(AreaBreakType.NEXT_PAGE));
+            }
+            ByteArrayOutputStream baos = new ByteArrayOutputStream();
+            ImageIO.write(a4Images.get(i), "png", baos);
+            byte[] imageBytes = baos.toByteArray();
+            ImageData imageData = ImageDataFactory.create(imageBytes);
+            Image image = new Image(imageData);
+
+            // Scale and position correctly
+            image.scaleToFit(pdfDoc.getDefaultPageSize().getWidth(), pdfDoc.getDefaultPageSize().getHeight());
+            image.setFixedPosition(0, 30);
+            document.add(image);
+        }
+        document.close();
+    }
+
+    private void drawCenteredText(Graphics2D g2d, String text, Font font, int x, int y, int pageWidth, int cols, int marginTop, int marginLeft) {
+        g2d.setFont(font);
+        FontMetrics fontMetrics = g2d.getFontMetrics();
+        int adjustedX = (x + ((pageWidth / cols) ) / 2) - marginLeft;
+        int adjustedY = y + fontMetrics.getAscent() + marginTop;
+        g2d.drawString(text, adjustedX, adjustedY);
+    }
+
+    public void getBarcodeImagesForStitchItems(List<? extends InventoryArtifact> artifacts,
+                                               BarcodeStickerSize stickerSize) throws Exception {
+
+        Path pdfPath = FileSystems.getDefault().getPath(stitchPath);
+        PdfWriter writer = new PdfWriter(pdfPath.toFile());
+        PdfDocument pdfDoc = new PdfDocument(writer);
+        Document document = new Document(pdfDoc);
+        pdfDoc.setDefaultPageSize(new PageSize(stickerSize.getWidth(), stickerSize.getHeight()));
+
+        for (InventoryArtifact artifact : artifacts) {
+            JobCard jobCard = jobCardDAO.find(artifact.getJobCardId());
+
+            PdfPage page = pdfDoc.addNewPage();
+            PdfCanvas canvas = new PdfCanvas(page);
+            canvas.setFillColor(ColorConstants.WHITE);
+            canvas.rectangle(0, 0, stickerSize.getWidth(), stickerSize.getHeight());
+            canvas.fill();
+
+            // Draw QR Code on Left Side
+            byte[] imgBytes = generateQRCodeImageByteArray(artifact.getBarcode(), stickerSize.getImageWidthBarcode(), stickerSize.getImageHeightBarcode());
+            Image qrCodeImage = new Image(ImageDataFactory.create(imgBytes));
+
+            float qrY =stickerSize.getMarginLeft()+50 ;
+            float qrX = stickerSize.getMarginTop();
+
+            qrCodeImage.setFixedPosition(qrX - 16, qrY-35);
+            document.add(qrCodeImage);
+
+            float textX = stickerSize.getMarginLeft() + 40;
+            float textY = stickerSize.getMarginTop() + 40;
+
+            String sku = artifact.getSku();
+            String jobCardCode = jobCard.getCode();
+            String combinedText = sku + " \\ " + jobCardCode + " \\ " + artifact.getBundleId();
+            combinedText = combinedText.replaceAll("\\s+", "");
+
+            int maxLength = 12;
+            int start = 0;
+            int lineCount = 0;
+            List<String> lines = new ArrayList<>();
+
+            while (start < combinedText.length() && lineCount < 5) {
+                int end = Math.min(start + maxLength, combinedText.length());
+                String part = combinedText.substring(start, end);
+
+                if (part.matches(".*[^a-zA-Z0-9 ].*")) {
+                    if(combinedText.length() - start<=17 && combinedText.length() - start>0){
+                        end = Math.min(start + maxLength + 5, combinedText.length());
+                        part = combinedText.substring(start, end);
+                    }else {
+                        end = Math.min(start + maxLength + 3, combinedText.length());
+                        part = combinedText.substring(start, end);
+                    }
+                }
+                part = part.replaceAll("\\s+", "");
+                lines.add(part);
+                start = end;
+                lineCount++;
+            }
+
+
+            float labelWidth = 67.69f;
+            float textBoxWidth = 120f;
+            float textY1 = textY-23;
+            float textXCenter = textX + (labelWidth / 2) - (textBoxWidth / 2)-50;
+
+            for (String line : lines) {
+                Paragraph rotatedText = new Paragraph(line)
+                        .setFontColor(ColorConstants.BLACK)
+                        .setFontSize(stickerSize.getTextSize()+2)
+                        .setTextAlignment(TextAlignment.CENTER)
+                        .setFixedPosition(textXCenter, textY1-13, textBoxWidth);
+
+                document.add(rotatedText);
+                textY1 -= 6;
+            }
+
+            PdfFont font = PdfFontFactory.createFont(StandardFonts.COURIER);
+            String id = String.valueOf(artifact.getId());
+            float textSize = stickerSize.getTextSize() + 6;
+            float charWidth = textSize * 0.6f;
+            float idWidth = id.length() * charWidth;
+            float xCentered = (labelWidth / 2f) - (idWidth / 2f);
+
+            document.add(new Paragraph(id)
+                    .setFont(font)
+                    .setBold()
+                    .setFontColor(ColorConstants.BLACK)
+                    .setFontSize(textSize)
+                    .setFixedPosition(xCentered, textY + 18, 100));
+
+
+            float dottedLine = textY - 65;
+            for(int i= 0 ;i<16;i++){
+                document.add(new Paragraph("|")
+                        .setFontSize(stickerSize.getTextSize())
+                        .setFontColor(ColorConstants.BLACK)
+                        .setBold()
+                        .setRotationAngle(-Math.PI / 2)
+                        .setTextAlignment(TextAlignment.LEFT)
+                        .setFixedPosition(dottedLine,textX+55, 100));
+
+                dottedLine += 7;
+            }
+
+            float dottedLine2 = textY - 65;
+            for(int i= 0 ;i<16;i++){
+                document.add(new Paragraph("|")
+                        .setFontSize(stickerSize.getTextSize())
+                        .setFontColor(ColorConstants.BLACK)
+                        .setBold()
+                        .setRotationAngle(-Math.PI / 2)
+                        .setTextAlignment(TextAlignment.LEFT)
+                        .setFixedPosition(dottedLine2,textX+90, 100));
+
+                dottedLine2 += 7;
+            }
+
+            if (!artifact.equals(artifacts.get(artifacts.size() - 1))) {
+                document.add(new AreaBreak());
+            }
+        }
+
+        if (pdfDoc.getNumberOfPages() > artifacts.size()) {
+            pdfDoc.removePage(pdfDoc.getNumberOfPages());
+        }
+
+        document.close();
+        sendPdfToZebraPrinter(pdfPath.toFile());
+    }
+
+    public void sendPdfToZebraPrinter(File pdfFile) throws Exception {
+        PDDocument pdDocument = PDDocument.load(pdfFile);
+        PDFRenderer renderer = new PDFRenderer(pdDocument);
+        for (int pageIndex = 0; pageIndex < pdDocument.getNumberOfPages(); pageIndex++) {
+            BufferedImage pageImage = renderer.renderImageWithDPI(pageIndex, 320);
+            printLabel(pageImage);
+        }
+        pdDocument.close();
+    }
+
+    public byte[] generateQRCodeImageByteArray(String data, int width, int height) {
+        try {
+            QRCodeWriter qrCodeWriter = new QRCodeWriter();
+            Map<EncodeHintType, Object> hintMap = new HashMap<>();
+            hintMap.put(EncodeHintType.MARGIN, 0);
+            BitMatrix bitMatrix = qrCodeWriter.encode(data, BarcodeFormat.QR_CODE, width, height, hintMap);
+            BufferedImage qrImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
+            qrImage.createGraphics().fillRect(0, 0, width, height);
+
+            for (int x = 0; x < width; x++) {
+                for (int y = 0; y < height; y++) {
+                    qrImage.setRGB(x, y, bitMatrix.get(x, y) ? 0x000000 : 0xFFFFFF); // Black and white
+                }
+            }
+
+            ByteArrayOutputStream baos = new ByteArrayOutputStream();
+            ImageIO.write(qrImage, "PNG", baos);
+            return baos.toByteArray();
+        } catch (WriterException | IOException e) {
+            e.printStackTrace();
+            return new byte[0];
         }
     }
 
     public void printLabel(BufferedImage bufferedImage) throws Exception {
-        String ipAddr = "192.168.90.160";
-        int port = 9100;
-        Connection connection = new TcpConnection( ipAddr, port );
+        Connection connection = new TcpConnection(ipAddress, port);
         connection.open();
         ZebraPrinter printer = ZebraPrinterFactory.getInstance(connection);
         ZebraImage zebraImage = new ZebraImage(bufferedImage);

src/main/java/com/utopiaindustries/service/BundleService.java

@@ -15,9 +15,11 @@ import org.springframework.security.core.Authentication;
 import org.springframework.security.core.context.SecurityContextHolder;
 import org.springframework.stereotype.Service;
 
+import java.math.BigDecimal;
 import java.time.LocalDateTime;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.stream.Collectors;
 
 @Service
 public class BundleService {
@@ -54,6 +56,35 @@ public class BundleService {
         return bundles;
     }
 
+    /*
+     * find bundle by id
+     * */
+    public Bundle getBundlesById( long id){
+        return  bundleDAO.find(id);
+    }
+
+    /*
+    * find bundle by barcode
+    * */
+    public List<Bundle> getBundles( String barcode){
+        List<Bundle> bundles = new ArrayList<>();
+        List<Bundle> fetchBundle = bundleDAO.findByBarcodeLike( barcode );
+        List<Long> ids =  fetchBundle.stream()
+                .map(Bundle::getMasterBundleId)
+                .distinct()
+                .collect(Collectors.toList());
+        if(!ids.isEmpty()){
+            List<Long> masterBundles = masterBundleDAO.findByIdAndReceiveIsTrue(ids);
+            bundles = fetchBundle.stream()
+                    .filter(e -> masterBundles.contains(e.getMasterBundleId())
+                            && e.getWrapQuantity().compareTo(
+                            e.getProduction() != null ? e.getProduction() : BigDecimal.ZERO) != 0)
+                    .collect(Collectors.toList());
+        }
+
+        return bundles;
+    }
+
     /*
     *  find master bundles by params
     * */
@@ -94,13 +125,13 @@ public class BundleService {
     /*
      * find finished Items by params
      * */
-    public List<StitchingOfflineItem> getStitchedOfflineItems(String id, String itemId, String sku, String createdStartDate, String createdEndDate, String jobCardId, Long count ){
+    public List<StitchingOfflineItem> getStitchedOfflineItems(String id, String itemId, String sku,String status, String createdStartDate, String createdEndDate, Long bundleId, Long count ){
         List<StitchingOfflineItem> stitchingOfflineItems = new ArrayList<>();
         if( count == null ){
             count = 100L;
         }
-        if( StringUtils.isAnyNotNullOrEmpty(id, itemId, sku, createdStartDate, createdEndDate, jobCardId ) ){
-            String query = StichedOfflineItemQueryBuilder.buildQuery( id, itemId, sku, createdStartDate, createdEndDate, jobCardId , count );
+        if( StringUtils.isAnyNotNullOrEmpty(id, itemId, sku, createdStartDate, createdEndDate, String.valueOf(bundleId) ) ){
+            String query = StichedOfflineItemQueryBuilder.buildQuery( id, itemId, sku, status,createdStartDate, createdEndDate, bundleId , count );
             System.out.println( query );
             stitchingOfflineItems = stitchingOfflineItemDAO.findByQuery( query );
         } else {
@@ -109,7 +140,6 @@ public class BundleService {
         return stitchingOfflineItems;
     }
 
-
     /*
     *
     * */

src/main/java/com/utopiaindustries/service/DashboardService.java

@@ -0,0 +1,185 @@
+package com.utopiaindustries.service;
+
+import com.utopiaindustries.dao.ctp.*;
+import com.utopiaindustries.model.ctp.*;
+import org.springframework.stereotype.Service;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.time.Duration;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.format.DateTimeFormatter;
+import java.util.*;
+import java.util.stream.Collectors;
+
+@Service
+public class DashboardService {
+
+    private final InventoryTransactionLegDAO inventoryTransactionLegDAO;
+    private final JobCardDAO jobCardDAO;
+    private final FinishedItemDAO finishedItemDAO;
+    private final StitchingOfflineItemDAO stitchingOfflineItemDAO;
+    private final InventoryAccountDAO inventoryAccountDAO;
+    private final PackagingItemsDAO packagingItemsDAO;
+
+
+    public DashboardService(InventoryTransactionLegDAO inventoryTransactionLegDAO, JobCardDAO jobCardDAO, FinishedItemDAO finishedItemDAO, StitchingOfflineItemDAO stitchingOfflineItemDAO, InventoryAccountDAO inventoryAccountDAO, PackagingItemsDAO packagingItemsDAO) {
+        this.inventoryTransactionLegDAO = inventoryTransactionLegDAO;
+        this.jobCardDAO = jobCardDAO;
+        this.finishedItemDAO = finishedItemDAO;
+        this.stitchingOfflineItemDAO = stitchingOfflineItemDAO;
+        this.inventoryAccountDAO = inventoryAccountDAO;
+        this.packagingItemsDAO = packagingItemsDAO;
+    }
+
+    public Map<String, Float> getPhasesProgressDayWise(String lineNo) {
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
+        HashMap<String, Float> progress = new HashMap<>();
+
+        String cuttingAccount = "CUTTING ACCOUNT " + lineNo;
+        String stitchingAccount = "STITCHING ACCOUNT " + lineNo;
+        String finishingAccount = "FINISHING ACCOUNT " + lineNo;
+        String packagingAccount = "A GRADE ACCOUNT " + lineNo;
+
+        LocalDateTime today = LocalDateTime.now().withHour(0).withMinute(0).withSecond(1);
+        String startDate1 = today.format(formatter);
+        String endDate1 = LocalDateTime.now().withHour(23).withMinute(59).withSecond(59).format(formatter);
+        String forPreviousDate = LocalDateTime.now().minusDays(1).withHour(23).withMinute(59).withSecond(59).format(formatter);
+
+        //set inventory accounts
+        List<InventoryAccount> inventoryAccounts = inventoryAccountDAO.findAll();
+        InventoryAccount inventoryAccount = inventoryAccounts.stream()
+                .filter(e -> stitchingAccount.equals(e.getTitle())).findFirst().orElse(new InventoryAccount());
+        Map<String, Integer> inventoryAccountMap = inventoryAccounts.stream()
+                .filter(e -> cuttingAccount.equals(e.getTitle()) ||
+                        stitchingAccount.equals(e.getTitle()) ||
+                        finishingAccount.equals(e.getTitle()) ||
+                        packagingAccount.equals(e.getTitle()))
+                .collect(Collectors.toMap(InventoryAccount::getTitle, e -> (int) e.getId()));
+
+        //get all in remaining transaction stitching
+        List<Long> stitchingItemIds = inventoryTransactionLegDAO.findRemainingByParentTypeAndAccountID("STITCHING_OFFLINE", inventoryAccountMap.get(stitchingAccount));
+
+        //get all out transaction stitching
+        List<Long> stitchingOutIds = inventoryTransactionLegDAO.getOutParentIdByDate("STITCHING_OFFLINE", inventoryAccountMap.get(stitchingAccount));
+
+
+        //get all in transaction finished
+        List<Long> finishing = inventoryTransactionLegDAO.getInParentIdByDate("FINISHED_ITEM", inventoryAccountMap.get(finishingAccount));
+
+        //get all in remaining transaction packaging
+        List<Long> packagingItemIDs = inventoryTransactionLegDAO.findRemainingByParentTypeAndAccountID("PACKAGING", inventoryAccountMap.get(packagingAccount));
+
+        //set stitching related details
+        Long approvedStitchingOfflineItems = 0L;
+        Long remaininfQcAlterPieces = 0L;
+        Long approvedStitchingOfflineItemsThenReject = 0L;
+        long qcReject = 0L;
+        if (stitchingItemIds != null && !stitchingItemIds.isEmpty()) {
+            approvedStitchingOfflineItems = stitchingOfflineItemDAO.findByQCOperationDateAndApproved(startDate1, endDate1, "APPROVED");
+            qcReject = stitchingOfflineItemDAO.findByQCOperationDateAndIds(startDate1, endDate1, "REJECT", stitchingItemIds);
+            remaininfQcAlterPieces = stitchingOfflineItemDAO.findByQCOperationDateAndIds(null, forPreviousDate, "REJECT", stitchingItemIds);
+        }
+        if(stitchingOutIds != null && !stitchingOutIds.isEmpty()) {
+            approvedStitchingOfflineItemsThenReject = stitchingOfflineItemDAO.findByQCOperationDateAndIds(startDate1, endDate1, "REJECT", stitchingOutIds);
+        }
+        //set finishing related details
+        Long alterationPieceFinish = 0L;
+        Long rejectFinishedItem = 0L;
+        Long washFinishedItem = 0L;
+        Long approved = 0L;
+        Long operationNotPerformed = 0L;
+        Long remainingAlterationPieceFinish = 0L;
+        if (finishing != null && !finishing.isEmpty()) {
+            approved = finishedItemDAO.findByOperationDateAndIdsAndQaStatus(startDate1, endDate1, "APPROVED", finishing);
+            operationNotPerformed = finishedItemDAO.findByOperationDateAndIdsAndQaStatus(startDate1, endDate1, "-", finishing);
+            rejectFinishedItem = finishedItemDAO.findByOperationDateAndIdsAndQaStatus(startDate1, endDate1, "REJECT", finishing);
+            washFinishedItem = finishedItemDAO.findByOperationDateAndIdsAndQaStatus(startDate1, endDate1, "WASHED", finishing);
+            alterationPieceFinish = finishedItemDAO.findByOperationDateAndIdsAndQaStatus(startDate1, endDate1, "ALTER", finishing);
+            remainingAlterationPieceFinish = finishedItemDAO.findByOperationDateAndIdsAndQaStatus(null, forPreviousDate, "ALTER", finishing);
+        }
+
+        //set packaging details
+        Long packagingItems = 0L;
+        if (packagingItemIDs != null && !packagingItemIDs.isEmpty()) {
+            packagingItems = packagingItemsDAO.findByDateAndIds(startDate1, endDate1, packagingItemIDs);
+        }
+
+        //set shift wise details and time
+        LocalDateTime statTime = LocalDateTime.now().withHour(9).withMinute(0).withSecond(0).withNano(0);
+        LocalDateTime endTime = statTime.plusMinutes(inventoryAccount.getShiftMinutes());
+        long minutesPassed = 0;
+        if (statTime.isBefore(LocalDateTime.now()) && LocalDateTime.now().isBefore(endTime)) {
+            minutesPassed = Duration.between(statTime, LocalDateTime.now()).toMinutes();
+        }
+
+        //set efficiency
+        long shiftTargetMinutesWise = getTargetShiftWiseOrHourlyWise(Math.max(0, minutesPassed), inventoryAccount);
+        float efficiency;
+        if (shiftTargetMinutesWise == 0) {
+            efficiency = 0f;
+        } else {
+            efficiency = (float) approvedStitchingOfflineItems / shiftTargetMinutesWise;
+        }
+
+        progress.put("Stitching", (float) approvedStitchingOfflineItems + qcReject);
+        progress.put("totalWips", (float) stitchingItemIds.size() - qcReject);
+        progress.put("Alteration", (float) qcReject + approvedStitchingOfflineItemsThenReject);
+
+        progress.put("finishing", (float) approved );
+        progress.put("ALTER", (float) alterationPieceFinish);
+        progress.put("Reject", (float) rejectFinishedItem);
+        progress.put("wash", (float) washFinishedItem);
+        progress.put("finishingValueForBarChart", (float) approved + alterationPieceFinish + rejectFinishedItem + washFinishedItem + packagingItems);
+
+        progress.put("packaging", (float) packagingItems);
+        progress.put("totalPackaging", (float) packagingItemIDs.size());
+        progress.put("remainingFinishAlter", (float) remainingAlterationPieceFinish);
+        progress.put("remainingQCAlter", (float) remaininfQcAlterPieces);
+
+        progress.put("Efficiency", efficiency);
+        return progress;
+    }
+
+    public Map<String, String> getLineDetails(String lineNo) {
+        String stitchingAccount = "STITCHING ACCOUNT " + lineNo;
+        List<InventoryAccount> inventoryAccounts = inventoryAccountDAO.findAll();
+
+        InventoryAccount inventoryAccount = inventoryAccounts.stream()
+                .filter(e -> stitchingAccount.equals(e.getTitle())).findFirst().orElse(new InventoryAccount());
+
+        int shiftTarget = getTargetShiftWiseOrHourlyWise(inventoryAccount.getShiftMinutes(), inventoryAccount);
+        int shiftHourlyTarget = getTargetShiftWiseOrHourlyWise(60, inventoryAccount);
+
+        HashMap<String, String> details = new HashMap<>();
+        details.put("Shift Target", shiftTarget + " Pcs");
+        details.put("articleName", inventoryAccount.getArticleName());
+        details.put("Hourly Target", shiftHourlyTarget + " Pcs");
+        details.put("Total Machine", String.valueOf(inventoryAccount.getTotalMachines()));
+        details.put("Total Worker", String.valueOf(30));
+        details.put("line", "Line " + lineNo);
+        return details;
+    }
+
+    //formula for calculating targets --> machine * shiftTime * Efficiency / SAM
+    private int getTargetShiftWiseOrHourlyWise(long minutes, InventoryAccount inventoryAccount) {
+        if (inventoryAccount == null ||
+                inventoryAccount.getTotalMachines() == 0 ||
+                inventoryAccount.getEfficiency() == null ||
+                inventoryAccount.getSam() == null) {
+            return 0;
+        }
+        BigDecimal totalMachines = BigDecimal.valueOf(inventoryAccount.getTotalMachines());
+        BigDecimal efficiency = inventoryAccount.getEfficiency();
+        BigDecimal sam = inventoryAccount.getSam();
+        BigDecimal totalShiftProductiveTime = totalMachines
+                .multiply(BigDecimal.valueOf(minutes))
+                .multiply(efficiency);
+        if (sam.longValue() != 0) {
+            return totalShiftProductiveTime.divide(sam, 0, RoundingMode.HALF_UP).intValueExact();
+        }
+        return 0;
+    }
+
+}

src/main/java/com/utopiaindustries/service/InventoryAccountService.java

@@ -71,11 +71,7 @@ public class InventoryAccountService {
     }
 
     public List<InventoryAccount> findInventoryAccounts(){
-        List<InventoryAccount> accounts = inventoryAccountDAO.findAll();
-        for( InventoryAccount account : accounts ){
-            account.setLocationTitle( locationSiteDAO.find( account.getLocationSiteId() ).getTitle() );
-        }
-        return accounts;
+        return inventoryAccountDAO.findAll();
     }
 
     public List<InventoryAccount> findInventoryAccountsByFilter(String id, String title, String active, String createdBy, String startDate, String endDate,

src/main/java/com/utopiaindustries/service/InventoryService.java

@@ -2,6 +2,7 @@ package com.utopiaindustries.service;
 
 import com.utopiaindustries.dao.ctp.*;
 import com.utopiaindustries.model.ctp.*;
+import com.utopiaindustries.model.ctp.BundleWrapper;
 import org.springframework.security.core.Authentication;
 import org.springframework.security.core.context.SecurityContextHolder;
 import org.springframework.stereotype.Service;
@@ -18,7 +19,7 @@ import java.util.stream.Collectors;
 public class InventoryService {
 
     private final JobCardItemDAO jobCardItemDAO;
-    private final CutPieceDAO cutPieceDAO;
+    private final StoreItemDao storeItemDao;
     private final BundleDAO bundleDAO;
     private final InventoryTransactionLegDAO inventoryTransactionLegDAO;
     private final InventoryTransactionDAO inventoryTransactionDAO;
@@ -27,10 +28,11 @@ public class InventoryService {
     private final MasterBundleDAO masterBundleDAO;
     private final FinishedItemDAO finishedItemDAO;
     private final StitchingOfflineItemDAO stitchingOfflineItemDAO;
+    private final PackagingItemsDAO packagingItemsDAO;
 
-    public InventoryService( JobCardItemDAO jobCardItemDAO, CutPieceDAO cutPieceDAO, BundleDAO bundleDAO, InventoryTransactionLegDAO inventoryTransactionLegDAO, InventoryTransactionDAO inventoryTransactionDAO, JobCardDAO jobCardDAO, CryptographyService cryptographyService, MasterBundleDAO masterBundleDAO, FinishedItemDAO finishedItemDAO, StitchingOfflineItemDAO stitchingOfflineItemDAO) {
+    public InventoryService(JobCardItemDAO jobCardItemDAO, StoreItemDao storeItemDao, BundleDAO bundleDAO, InventoryTransactionLegDAO inventoryTransactionLegDAO, InventoryTransactionDAO inventoryTransactionDAO, JobCardDAO jobCardDAO, CryptographyService cryptographyService, MasterBundleDAO masterBundleDAO, FinishedItemDAO finishedItemDAO, StitchingOfflineItemDAO stitchingOfflineItemDAO, PackagingItemsDAO packagingItemsDAO) {
         this.jobCardItemDAO = jobCardItemDAO;
-        this.cutPieceDAO = cutPieceDAO;
+        this.storeItemDao = storeItemDao;
         this.bundleDAO = bundleDAO;
         this.inventoryTransactionLegDAO = inventoryTransactionLegDAO;
         this.inventoryTransactionDAO = inventoryTransactionDAO;
@@ -39,6 +41,7 @@ public class InventoryService {
         this.masterBundleDAO = masterBundleDAO;
         this.finishedItemDAO = finishedItemDAO;
         this.stitchingOfflineItemDAO = stitchingOfflineItemDAO;
+        this.packagingItemsDAO = packagingItemsDAO;
     }
 
     private void updateJobCardInventoryStatus(JobCard card) {
@@ -72,6 +75,7 @@ public class InventoryService {
                 .collect(Collectors.toMap(JobCardItemWrapper::getJobCardItemId, JobCardItemWrapper::getActualProduction));
 
         List<JobCardItem> items = jobCardItemDAO.findByIds(jobCardItemWrapperIds);
+
         if (items != null && !items.isEmpty()) {
             // get job card item ids
             List<Long> jobCardItemIds = items.stream()
@@ -79,26 +83,48 @@ public class InventoryService {
                     .collect(Collectors.toList());
 
             // save updated cut pieces
-            List<CutPiece> cutPieces = jobCardItemWrappers.stream( )
-                    .flatMap(  wrapper -> wrapper.getPieces( ).stream( ) )
-                    .collect(  Collectors.toList( ) );
-            cutPieceDAO.saveAll(  cutPieces );
+//            List<CutPiece> cutPieces = jobCardItemWrappers.stream()
+//                    .flatMap(wrapper -> wrapper.getPieces().stream())
+//                    .collect(Collectors.toList());
+//            cutPieceDAO.saveAll(cutPieces);
 
-            Map<Long, List<CutPiece>> piecesMap = cutPieceDAO.findByJobCardItemIds( jobCardItemIds)
-                    .stream( )
-                    .collect( Collectors.groupingBy( CutPiece::getJobCardItemId));
+//            Map<Long, List<CutPiece>> piecesMap = cutPieceDAO.findByJobCardItemIds(jobCardItemIds)
+//                    .stream()
+//                    .collect(Collectors.groupingBy(CutPiece::getJobCardItemId));
 
             for (JobCardItem jobCardItem : items) {
-                // create + save bundles
-                List<Bundle> bundles = createBundles(  jobCardItem, piecesMap.get(  jobCardItem.getId(  ) ) );
+
+                int quantity = jobCardItemWrappers.stream()
+                        .filter(e -> e.getJobCardItemId() == jobCardItem.getId())
+                        .mapToInt(JobCardItemWrapper::getPerBundleQuantity)
+                        .findFirst()
+                        .orElse(0);
+
+                boolean cuttingComplete = jobCardItemWrappers.stream()
+                        .filter(e -> e.getJobCardItemId() == jobCardItem.getId())
+                        .map(JobCardItemWrapper::getCuttingComplete)
+                        .findFirst()
+                        .orElse(false);
+
+                BigDecimal production = jobCardItemWrappers.stream()
+                        .filter(e -> e.getJobCardItemId() == jobCardItem.getId())
+                        .map(JobCardItemWrapper::getActualProduction)
+                        .findFirst()
+                        .orElse(BigDecimal.ZERO);
+
+                List<Bundle> bundles = createBundles(jobCardItem, quantity, jobCardItemIdToActualProdMap.getOrDefault(jobCardItem.getId(), BigDecimal.ZERO));
                 // create transactions
                 createTransactions(bundles, jobCardItem.getAccountId(), InventoryArtifactType.BUNDLE.name());
-                jobCardItem.setActualProduction(  jobCardItemIdToActualProdMap.getOrDefault(  jobCardItem.getId( ) , BigDecimal.ZERO )  );
+                jobCardItem.setActualProduction(jobCardItemIdToActualProdMap.getOrDefault(jobCardItem.getId(), BigDecimal.ZERO).add(jobCardItem.getActualProduction()));
+                jobCardItem.setComplete(cuttingComplete);
+
             }
             // update items with quantity
             jobCardItemDAO.saveAll(items);
             // update job card inv status
+            if (jobCardItemDAO.checkAllItemsComplete(jobCardId, jobCardItemIds)) {
                 updateJobCardInventoryStatus(jobCard);
+            }
         } else {
             throw new RuntimeException("Items Not found in Job Card");
         }
@@ -150,16 +176,19 @@ public class InventoryService {
         inventoryTransactionLeg.setParentDocumentId(artifact.getId());
         inventoryTransactionLeg.setParentDocumentPieceType(artifact.getType());
         inventoryTransactionLeg.setTransactionLegDateTime(LocalDateTime.now());
+        inventoryTransactionLeg.setJobCardId(artifact.getJobCardId());
         // set balance
         BigDecimal initialBalance = calculateBalance(accountId, artifact.getItemId(), parentDocumentType, artifact.getType());
 
         if (transactionType.equalsIgnoreCase(InventoryTransactionLeg.Type.IN.name())) {
             initialBalance = initialBalance.add(inventoryTransactionLeg.getQuantity());
-        }else if(transactionType.equalsIgnoreCase( InventoryTransactionLeg.Type.OUT.name( )) && inventoryTransactionLeg.getQuantity().equals(BigDecimal.ZERO)){
+        } else if (transactionType.equalsIgnoreCase(InventoryTransactionLeg.Type.OUT.name())) {
+            if (inventoryTransactionLeg.getQuantity().equals(BigDecimal.ZERO)) {
                 initialBalance = BigDecimal.ZERO;
             } else {
                 initialBalance = initialBalance.subtract(inventoryTransactionLeg.getQuantity());
             }
+        }
         inventoryTransactionLeg.setBalance(initialBalance);
         inventoryTransactionLeg.setId(inventoryTransactionLegDAO.save(inventoryTransactionLeg));
         return inventoryTransactionLeg;
@@ -179,18 +208,24 @@ public class InventoryService {
 
     // create bundles from cut pieces
     private List<Bundle> createBundles(JobCardItem jobCardItem,
-                                        List<CutPiece> jobCardItemPieces ) {
+                                       int perBundleWrap, BigDecimal value) {
         Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
-        if ( jobCardItemPieces != null && !jobCardItemPieces.isEmpty( )) {
+        if (value != null && !value.equals(BigDecimal.ZERO)) {
             List<Bundle> bundles = new ArrayList<>();
-            // create bundle against every cut piece
-            for ( CutPiece cutPiece : jobCardItemPieces ) {
+            int quantity = value.intValue();
+            int batchSize = perBundleWrap;
+            int iterations = (int) Math.ceil((double) quantity / batchSize);
+
+            for (int i = 0; i < iterations; i++) {
+                int start = i * batchSize + 1; // Start index
+                int end = Math.min((i + 1) * batchSize, quantity); // Last index
+                int perBundleQuantity = end - start + 1;
                 Bundle bundle = new Bundle();
                 bundle.setItemId(jobCardItem.getItemId());
                 bundle.setSku(jobCardItem.getSku());
                 bundle.setJobCardId(jobCardItem.getJobCardId());
-                bundle.setWrapQuantity( cutPiece.getQuantity( ));
-                bundle.setType( cutPiece.getType( ));
+                bundle.setWrapQuantity(BigDecimal.valueOf(perBundleQuantity));
+                bundle.setType("BUNDLE");
                 bundle.setCreatedAt(LocalDateTime.now());
                 bundle.setCreatedBy(authentication.getName());
                 bundles.add(bundle);
@@ -199,7 +234,6 @@ public class InventoryService {
                 // save again after barcode generation
                 bundle.setId(bundleDAO.save(bundle));
             }
-
 //            for ( Map.Entry<JobCardItem, List<CutPiece>> entry : jobCardItemPieces ) {
 //                JobCardItem key = entry.getKey( );
 //                List<CutPiece> value = entry.getValue( );
@@ -243,11 +277,13 @@ public class InventoryService {
                     long fromAccount = lastInvTransaction.getAccountId();
                     createInventoryTransactionLeg(transaction, bundle, fromAccount, InventoryTransactionLeg.Type.OUT.name(), InventoryArtifactType.BUNDLE.name());
                     // IN
-                    createInventoryTransactionLeg( transaction, bundle, toAccount, InventoryTransactionLeg.Type.IN.name( ), InventoryArtifactType.BUNDLE.name( ));
+                    bundle.setType("BUNDLE");
+                    createInventoryTransactionLeg(transaction, bundle, toAccount, InventoryTransactionLeg.Type.IN.name(), InventoryArtifactType.STITCH_BUNDLE.name());
                 }
             }
             // update status
             masterBundle.setIsReceived(true);
+            masterBundle.setAccountId(toAccount);
             masterBundleDAO.save(masterBundle);
         }
     }
@@ -296,73 +332,70 @@ public class InventoryService {
      *  create finished items from master bundles
      * */
     @Transactional(rollbackFor = Exception.class, propagation = Propagation.NESTED)
-    public void createStitchingOfflineItemsFromJobCard( JobCard jobCard) {
-        List<JobCardItem> jobCardItems = jobCard.getItems( );
+    public void createStitchingOfflineItemsFromJobCard(BundleWrapper wrapper) {
         List<JobCardItem> updatedItems = new ArrayList<>();
+        List<Bundle> updateBundles = new ArrayList<>();
+        JobCard jobCard = null;
 
-        // validate items
-        validateItems( jobCardItems);
-        // check whether all bundles are received against finish goods
-        checkAllBundleAreReceived( jobCard.getId( ), jobCardItems);
-        for ( JobCardItem item : jobCardItems) {
-            if(item.getTotalProduction() == null){
-                item.setTotalProduction(BigDecimal.ZERO);
-            }
-            item.setJobCardId(jobCard.getId());
-            // select which has inventory
-            if (  item.getProduction( ).compareTo( BigDecimal.ZERO ) != 0 ) {
-                // production is completed out bundles
-                if (   item.getActualProduction( ).compareTo( item.getTotalProduction( ).add( item.getProduction( ))) == 0) {
-                    // create out transactions of bundles in master bundles
-                    List<Bundle> bundles = bundleDAO.findByItemIdAndCardId( item.getItemId( ), jobCard.getId( ));
-                    if ( bundles != null && !bundles.isEmpty( )) {
-                        // bundle ids
-                        List<Long> bundleIds = bundles.stream( ).map( Bundle::getId).collect( Collectors.toList( ));
-
-                        Map<Long, InventoryTransactionLeg> lastBundleIdInTransactionMap = inventoryTransactionLegDAO
-                                .findLastTransactionByParentIdAndParentType( InventoryTransactionLeg.Type.IN.name( ), bundleIds, InventoryArtifactType.BUNDLE.name( ))
-                                .stream( )
-                                .collect( Collectors.toMap( InventoryTransactionLeg::getParentDocumentId, Function.identity( )));
-                        // create Transaction
+        //switching table transaction in Transaction Table
         InventoryTransaction transaction = createInventoryTransaction("Against Movement from Stitching to Stitched Offline Item");
         inventoryTransactionDAO.save(transaction);
-                        // create transaction legs
-                        for ( Bundle bundle : bundles) {
-                            InventoryTransactionLeg lastInvTransaction = lastBundleIdInTransactionMap.getOrDefault( bundle.getId( ), null);
+
+        //TransactionLeg Transaction
+        List<Long> bundleIds = wrapper.getBundles().stream().map(Bundle::getId).collect(Collectors.toList());
+        Map<Long, InventoryTransactionLeg> lastBundleIdInTransactionMap = inventoryTransactionLegDAO
+                .findLastTransactionByParentIdAndParentType(InventoryTransactionLeg.Type.IN.name(), bundleIds, InventoryArtifactType.STITCH_BUNDLE.name())
+                .stream()
+                .collect(Collectors.toMap(InventoryTransactionLeg::getParentDocumentId, Function.identity()));
+        for (Bundle subBundle : wrapper.getBundles()) {
+            long accountId = masterBundleDAO.find(subBundle.getMasterBundleId()).getAccountId();
+            if (subBundle.getCurrentProduction() != null && subBundle.getCurrentProduction().compareTo(BigDecimal.ZERO) != 0) {
+                Bundle bundle = bundleDAO.find(subBundle.getId());
+                jobCard = jobCardDAO.find(subBundle.getJobCardId());
+                long production = (bundle.getProduction() == null) ? 0 : bundle.getProduction().longValue();
+                long wrapQuantity = bundle.getWrapQuantity().longValue();
+                JobCardItem jobCardItem = jobCardItemDAO.findByCardIdAndItemId(subBundle.getJobCardId(), subBundle.getItemId());
+                BigDecimal previousTotalProduction = jobCardItem.getTotalProduction() == null ? BigDecimal.ZERO : jobCardItem.getTotalProduction();
+
+                InventoryTransactionLeg lastInvTransaction = lastBundleIdInTransactionMap.getOrDefault(subBundle.getId(), null);
+
                 if (lastInvTransaction != null) {
+                    if (wrapQuantity == production + subBundle.getCurrentProduction().longValue()) {
                         // OUT
                         long fromAccount = lastInvTransaction.getAccountId();
-                                createInventoryTransactionLeg( transaction, bundle, fromAccount, InventoryTransactionLeg.Type.OUT.name( ), InventoryArtifactType.BUNDLE.name( ));
+                        createInventoryTransactionLeg(transaction, subBundle, accountId, InventoryTransactionLeg.Type.OUT.name(), InventoryArtifactType.STITCH_BUNDLE.name());
                     }
                 }
-                    }
-                }
-                // create finished items
-                List<StitchingOfflineItem> stitchingOfflineItems = createStitchingOfflineItems( item);
+                // create stitchingOfflineItems items
+                List<StitchingOfflineItem> stitchingOfflineItems = createStitchingOfflineItems(subBundle.getCurrentProduction(), jobCardItem, subBundle.getId());
                 // create IN Transactions of Finished Items into account
-                createTransactions( stitchingOfflineItems, jobCard.getToAccountId( ), InventoryArtifactType.STITCHING_OFFLINE.name( ));
-                item.setTotalProduction( item.getTotalProduction( ).add( item.getProduction( )));
-                item.setJobCardId( jobCard.getId( ));
-                updatedItems.add( item);
+                createTransactions(stitchingOfflineItems, accountId, InventoryArtifactType.STITCHING_OFFLINE.name());
+
+                jobCardItem.setTotalProduction(previousTotalProduction.add(subBundle.getCurrentProduction()));
+                jobCardItem.setJobCardId(jobCard.getId());
+                updatedItems.add(jobCardItem);
+                BigDecimal pro = BigDecimal.valueOf(production + subBundle.getCurrentProduction().longValue());
+                bundle.setProduction(pro);
+                bundleDAO.save(bundle);
             }
         }
-        // save all
         jobCardItemDAO.saveAll(updatedItems);
     }
 
     /*
      *  create finished items
      * */
-    public List<StitchingOfflineItem> createStitchingOfflineItems( JobCardItem jobCardItem) {
+    public List<StitchingOfflineItem> createStitchingOfflineItems(BigDecimal totalItem, JobCardItem jobCardItem, long bundleId) {
         Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
         List<StitchingOfflineItem> items = new ArrayList<>();
         if (jobCardItem != null) {
-            for ( int i = 1; i <= jobCardItem.getProduction( ).intValue( ); i++) {
+            for (int i = 1; i <= totalItem.intValue(); i++) {
                 StitchingOfflineItem stitchingOfflineItem = new StitchingOfflineItem();
                 stitchingOfflineItem.setCreatedAt(LocalDateTime.now());
                 stitchingOfflineItem.setCreatedBy(authentication.getName());
                 stitchingOfflineItem.setItemId(jobCardItem.getItemId());
                 stitchingOfflineItem.setSku(jobCardItem.getSku());
+                stitchingOfflineItem.setBundleId(bundleId);
                 stitchingOfflineItem.setJobCardId(jobCardItem.getJobCardId());
                 stitchingOfflineItem.setIsQa(false);
                 long id = stitchingOfflineItemDAO.save(stitchingOfflineItem);
@@ -431,13 +464,14 @@ public class InventoryService {
      *  generate finished items against stitched items
      * */
     @Transactional(rollbackFor = Exception.class)
-    public void createFinishedItemsAgainstStitchedItems(  StitchedItemWrapper wrapper ) {
+    public void createFinishedItemsAgainstStitchedItems(StitchedItemWrapper wrapper, String qaStatus) {
         if (wrapper.getItems() != null && wrapper.getFinishedAccountId() != 0) {
             Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
 
             List<StitchingOfflineItem> stitchingOfflineItems = wrapper.getItems();
             List<StitchingOfflineItem> updatedStitchedItems = new ArrayList<>();
             List<FinishedItem> finishedItems = new ArrayList<>();
+            List<FinishedItem> finishedItemsForUlter = new ArrayList<>();
 
             List<Long> stitchedItemIds = stitchingOfflineItems.stream()
                     .map(StitchingOfflineItem::getId)
@@ -462,7 +496,7 @@ public class InventoryService {
 
             // generate FI for SI
             for (StitchingOfflineItem stitchingOfflineItem : stitchingOfflineItems) {
-                if ( stitchingOfflineItem.getQaStatus( ).equalsIgnoreCase( "APPROVED" )) {
+                if (qaStatus.equalsIgnoreCase("APPROVED")) {
                     // check finished item is already created
                     FinishedItem preCreatedItem = finishedItemDAO.findByStitchedItem(stitchingOfflineItem.getId());
                     if (preCreatedItem == null) {
@@ -472,9 +506,11 @@ public class InventoryService {
                         finishedItem.setBarcode(stitchingOfflineItem.getBarcode());
                         finishedItem.setCreatedBy(authentication.getName());
                         finishedItem.setCreatedAt(LocalDateTime.now());
+                        finishedItem.setOperationDate(LocalDateTime.now());
+                        finishedItem.setQaStatus("-");
                         finishedItem.setStitchedItemId(stitchingOfflineItem.getId());
                         finishedItem.setJobCardId(stitchingOfflineItem.getJobCardId());
-                        finishedItem.setIsQa( false);
+                        finishedItem.setIsQa(true);
                         finishedItem.setId(finishedItemDAO.save(finishedItem));
                         finishedItems.add(finishedItem);
                         InventoryTransactionLeg lastInvTransaction = lastStitchedIdInTransactionMap.getOrDefault(stitchingOfflineItem.getId(), null);
@@ -485,6 +521,8 @@ public class InventoryService {
                         }
                         // update stitched item
                         stitchingOfflineItem.setIsQa(true);
+                        stitchingOfflineItem.setQaStatus(qaStatus);
+                        updatedStitchedItems.add(stitchingOfflineItem);
                         // if FI is already created
                     } else {
                         // create OUT from stitching account Finished Item
@@ -492,19 +530,33 @@ public class InventoryService {
                         if (lastInvTransaction != null) {
                             // OUT
                             long fromAccount = lastInvTransaction.getAccountId();
-                            createInventoryTransactionLeg( transaction, stitchingOfflineItem, fromAccount, InventoryTransactionLeg.Type.OUT.name( ), InventoryArtifactType.FINISHED_ITEM.name( ));
+                            createInventoryTransactionLeg(transaction, preCreatedItem, fromAccount, InventoryTransactionLeg.Type.OUT.name(), InventoryArtifactType.FINISHED_ITEM.name());
                         }
+                        stitchingOfflineItem.setIsQa(true);
+                        preCreatedItem.setIsQa(true);
+                        finishedItemsForUlter.add(preCreatedItem);
                         // create IN in finishing Account Finished Item
                         finishedItems.add(preCreatedItem);
                     }
+                } else {
+                    FinishedItem preCreatedItem = finishedItemDAO.findByStitchedItem(stitchingOfflineItem.getId());
+                    if (preCreatedItem != null) {
+                        preCreatedItem.setIsQa(false);
+                        finishedItemsForUlter.add(preCreatedItem);
                     }
+                    stitchingOfflineItem.setIsQa(false);
+                }
+                stitchingOfflineItem.setQaStatus(qaStatus);
+                stitchingOfflineItem.setQcDoneAt(LocalDateTime.now());
+                updatedStitchedItems.add(stitchingOfflineItem);
             }
             for (FinishedItem finishedItem : finishedItems) {
                 // IN
                 createInventoryTransactionLeg(transaction, finishedItem, wrapper.getFinishedAccountId(), InventoryTransactionLeg.Type.IN.name(), InventoryArtifactType.FINISHED_ITEM.name());
             }
             // save updated stitched items
-            stitchingOfflineItemDAO.saveAll( wrapper.getItems( ));
+            finishedItemDAO.saveAll(finishedItemsForUlter);
+            stitchingOfflineItemDAO.saveAll(updatedStitchedItems);
         }
     }
 
@@ -513,7 +565,7 @@ public class InventoryService {
      *   segregate finish items
      * */
     @Transactional(rollbackFor = Exception.class, propagation = Propagation.NESTED)
-    public void segregateFinishedItems( FinishedItemWrapper wrapper) {
+    public void segregateFinishedItems(FinishedItemWrapper wrapper, String status) {
         if (wrapper != null && wrapper.getItems() != null) {
 
             List<FinishedItem> items = wrapper.getItems();
@@ -540,19 +592,16 @@ public class InventoryService {
             // create transaction
             InventoryTransaction transaction = createInventoryTransaction("Against Segregation of Finished Items");
 
-
             // create IN and OUT for all approved items
             for (FinishedItem finishedItem : items) {
                 InventoryTransactionLeg lastInvTransaction = lastFinishedItemIdInTransactionMap.getOrDefault(finishedItem.getId(), null);
                 finishedItem.setIsQa(true);
-                /*
-                 *  item is not approved and washed is selected then item remain in Finishing account
-                 * */
+                finishedItem.setOperationDate(LocalDateTime.now());
 
                 /*
                  *  item is approved and alter is selected then finished item will to stitching account
                  * */
-                if ( finishedItem.getQaStatus( ).equalsIgnoreCase( "ALTER")) {
+                if (status.equalsIgnoreCase("ALTER")) {
                     // create OUT and IN transactions for FI
                     if (lastInvTransaction != null) {
                         // OUT
@@ -563,27 +612,154 @@ public class InventoryService {
                         long stitchedItemId = finishedItem.getStitchedItemId();
                         InventoryTransactionLeg lastOutTransaction = lastStitchedItemOutTransactionMap.getOrDefault(stitchedItemId, null);
                         createInventoryTransactionLeg(transaction, finishedItem, lastOutTransaction.getAccountId(), InventoryTransactionLeg.Type.IN.name(), InventoryArtifactType.FINISHED_ITEM.name());
+                        finishedItem.setQaStatus("ALTER");
+                        finishedItem.setIsSegregated(false);
+                        finishedItem.setIsQa(false);
                     }
                 }
 
+                /*
+                 *  item is not approved and washed is selected then item remain in Finishing account
+                 * */
+                if (status.equalsIgnoreCase("WASHED")) {
+                    finishedItem.setIsSegregated(false);
+                    finishedItem.setQaStatus("WASHED");
+                }
+
+                /*
+                 *  item is not approved and B grade is selected then item remain in Finishing account because after
+                 * alteration item will be moved to A grade account for segregation
+                 * */
+                if (status.equalsIgnoreCase("B GRADE")) {
+                    finishedItem.setIsSegregated(false);
+                    finishedItem.setQaStatus("B GRADE");
+                }
+
+                /*
+                 *  item is not approved and C grade is selected then item remain in Finishing account because after
+                 * alteration item will be moved to A grade account for segregation
+                 * */
+                if (status.equalsIgnoreCase("REJECT")) {
+                    finishedItem.setIsSegregated(false);
+                    finishedItem.setQaStatus("REJECT");
+                }
+
                 /*
                  * item is approved and grade is selected then fI is move to grade account
                  */
-                if ( finishedItem.getQaStatus( ).equalsIgnoreCase( "APPROVED") && finishedItem.getAccountId( ) != 0) {
-                    // create OUT and IN transactions for FI
-                    if ( lastInvTransaction != null) {
-                        // OUT
-                        long fromAccount = lastInvTransaction.getAccountId( );
-                        createInventoryTransactionLeg( transaction, finishedItem, fromAccount, InventoryTransactionLeg.Type.OUT.name( ), InventoryArtifactType.FINISHED_ITEM.name( ));
-                        // IN
-                        createInventoryTransactionLeg( transaction, finishedItem, finishedItem.getAccountId( ), InventoryTransactionLeg.Type.IN.name( ), InventoryArtifactType.FINISHED_ITEM.name( ));
-                    }
+                if (status.equalsIgnoreCase("APPROVED")) {
+                    finishedItem.setQaStatus("APPROVED");
                     finishedItem.setIsSegregated(true);
                 }
                 updatedItems.add(finishedItem);
             }
-            finishedItemDAO.saveAll( updatedItems);
             // save finish items
+            finishedItemDAO.saveAll(updatedItems);
+        }
+    }
+
+    /*
+     *   Packaging items
+     * */
+    @Transactional(rollbackFor = Exception.class, propagation = Propagation.NESTED)
+    public void createPackagingItemAndTransaction(FinishedItemWrapper wrapper, long accountId) {
+        if (wrapper != null && wrapper.getItems() != null) {
+
+            List<FinishedItem> items = wrapper.getItems();
+            List<FinishedItem> updatedItems = new ArrayList<>();
+            List<PackagingItems> packagingItems = new ArrayList<>();
+            // finished ids
+            List<Long> finishedItemIds = items.stream().map(FinishedItem::getId)
+                    .collect(Collectors.toList());
+
+            // find parent doc type last IN transaction map
+            Map<Long, InventoryTransactionLeg> lastFinishedItemIdInTransactionMap = inventoryTransactionLegDAO
+                    .findLastTransactionByParentIdAndParentType(InventoryTransactionLeg.Type.IN.name(), finishedItemIds, InventoryArtifactType.FINISHED_ITEM.name())
+                    .stream()
+                    .collect(Collectors.toMap(InventoryTransactionLeg::getParentDocumentId, Function.identity()));
+
+            // create transaction
+            InventoryTransaction transaction = createInventoryTransaction("Against Segregation of Finished Items");
+
+
+            // create IN and OUT for all approved items
+            for (FinishedItem finishedItem : items) {
+                InventoryTransactionLeg lastInvTransaction = lastFinishedItemIdInTransactionMap.getOrDefault(finishedItem.getId(), null);
+                finishedItem.setIsQa(true);
+
+                if (finishedItem.getQaStatus().equalsIgnoreCase("APPROVED") && finishedItem.getIsSegregated()) {
+                    // create OUT and IN transactions for FI
+                    PackagingItems packagingItems1 = (createPackagingItem(finishedItem));
+                    packagingItems1.setId(packagingItemsDAO.save(packagingItems1));
+                    if (lastInvTransaction != null) {
+                        // OUT
+                        long fromAccount = lastInvTransaction.getAccountId();
+                        packagingItems1.setAccountId(fromAccount);
+                        createInventoryTransactionLeg(transaction, finishedItem, fromAccount, InventoryTransactionLeg.Type.OUT.name(), InventoryArtifactType.FINISHED_ITEM.name());
+                        // IN
+                        createInventoryTransactionLeg(transaction, packagingItems1, accountId, InventoryTransactionLeg.Type.IN.name(), InventoryArtifactType.PACKAGING.name());
+                    }
+                    finishedItem.setIsSegregated(true);
+                    finishedItem.setPackaging(true);
+                    packagingItems.add(packagingItems1);
+                }
+                updatedItems.add(finishedItem);
+            }
+            // save finish items
+            finishedItemDAO.saveAll(updatedItems);
+            packagingItemsDAO.saveAll(packagingItems);
+        }
+    }
+
+    /*
+     *   store items
+     * */
+    @Transactional(rollbackFor = Exception.class, propagation = Propagation.NESTED)
+    public void createStoreItemAndTransaction(FinishedItemWrapper wrapper, long toAccount) {
+        if (wrapper != null && wrapper.getItems() != null) {
+
+            List<FinishedItem> items = wrapper.getItems();
+            List<FinishedItem> updatedItems = new ArrayList<>();
+            List<StoreItem> storeItems = new ArrayList<>();
+            // finished ids
+            List<Long> finishedItemIds = items.stream().map(FinishedItem::getId)
+                    .collect(Collectors.toList());
+
+            // find parent doc type last IN transaction map
+            Map<Long, InventoryTransactionLeg> lastFinishedItemIdInTransactionMap = inventoryTransactionLegDAO
+                    .findLastTransactionByParentIdAndParentType(InventoryTransactionLeg.Type.IN.name(), finishedItemIds, InventoryArtifactType.FINISHED_ITEM.name())
+                    .stream()
+                    .collect(Collectors.toMap(InventoryTransactionLeg::getParentDocumentId, Function.identity()));
+
+            // create transaction
+            InventoryTransaction transaction = createInventoryTransaction("Against Segregation of Finished Items");
+
+            // create IN and OUT for all approved items
+            for (FinishedItem finishedItem : items) {
+                InventoryTransactionLeg lastInvTransaction = lastFinishedItemIdInTransactionMap.getOrDefault(finishedItem.getId(), null);
+                finishedItem.setIsQa(true);
+
+                if (finishedItem.getQaStatus().equalsIgnoreCase("REJECT")) {
+                    // create OUT and IN transactions for FI
+                    StoreItem storeItem = (createStoreItems(finishedItem, wrapper.getRejectReason()));
+                    storeItem.setId(storeItemDao.save(storeItem));
+                    if (lastInvTransaction != null) {
+                        // OUT
+                        long fromAccount = lastInvTransaction.getAccountId();
+                        storeItem.setAccountId(fromAccount);
+                        createInventoryTransactionLeg(transaction, finishedItem, fromAccount, InventoryTransactionLeg.Type.OUT.name(), InventoryArtifactType.FINISHED_ITEM.name());
+                        // IN
+                        createInventoryTransactionLeg(transaction, storeItem, toAccount, InventoryTransactionLeg.Type.IN.name(), InventoryArtifactType.STORED_ITEM.name());
+                    }
+                    finishedItem.setIsSegregated(true);
+                    finishedItem.setStore(true);
+                    storeItems.add(storeItem);
+                }
+                updatedItems.add(finishedItem);
+            }
+            // save finish items
+            finishedItemDAO.saveAll(updatedItems);
+            storeItemDao.saveAll(storeItems);
         }
     }
 
@@ -593,4 +769,37 @@ public class InventoryService {
     public List<InventorySummary> findItemSummaryByAccountId(long accountId) {
         return inventoryTransactionLegDAO.findSummaryByAccountId(accountId);
     }
+
+    private PackagingItems createPackagingItem(FinishedItem finishedItem) {
+        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
+        PackagingItems packagingItems = new PackagingItems();
+        packagingItems.setItemId(finishedItem.getItemId());
+        packagingItems.setAccountId(finishedItem.getAccountId());
+        packagingItems.setFinishedItemId(finishedItem.getId());
+        packagingItems.setJobCardId(finishedItem.getJobCardId());
+        packagingItems.setJobCard(finishedItem.getJobCard());
+        packagingItems.setSku(finishedItem.getSku());
+        packagingItems.setBarcode(finishedItem.getBarcode());
+        packagingItems.setCreatedAt(LocalDateTime.now());
+        packagingItems.setCreatedBy(authentication.getName());
+        packagingItems.setIsQa(finishedItem.getIsQa());
+        packagingItems.setIsSegregated(finishedItem.getIsSegregated());
+        packagingItems.setQaStatus(finishedItem.getQaStatus());
+        return packagingItems;
+    }
+
+    private StoreItem createStoreItems(FinishedItem finishedItem, String reason) {
+        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
+        StoreItem storeItem = new StoreItem();
+        storeItem.setItemId(finishedItem.getItemId());
+        storeItem.setAccountId(finishedItem.getAccountId());
+        storeItem.setFinishedItemId(finishedItem.getId());
+        storeItem.setJobCardId(finishedItem.getJobCardId());
+        storeItem.setSku(finishedItem.getSku());
+        storeItem.setBarcode(finishedItem.getBarcode());
+        storeItem.setCreatedAt(LocalDateTime.now());
+        storeItem.setCreatedBy(authentication.getName());
+        storeItem.setRejectedReason(reason);
+        return storeItem;
+    }
 }

src/main/java/com/utopiaindustries/service/JobCardService.java

@@ -7,14 +7,21 @@ import com.utopiaindustries.dao.uind.PurchaseOrderDAO;
 import com.utopiaindustries.model.ctp.*;
 import com.utopiaindustries.model.uind.Item;
 import com.utopiaindustries.querybuilder.ctp.JobCardQueryBuilder;
+import com.utopiaindustries.util.HTMLBuilder;
+import com.utopiaindustries.util.PDFResponseEntityInputStreamResource;
 import com.utopiaindustries.util.StringUtils;
+import com.utopiaindustries.util.URLUtils;
+import org.springframework.core.io.InputStreamResource;
+import org.springframework.http.ResponseEntity;
 import org.springframework.security.core.Authentication;
 import org.springframework.security.core.GrantedAuthority;
 import org.springframework.security.core.context.SecurityContextHolder;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
+import org.springframework.ui.Model;
 
 import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
@@ -35,8 +42,12 @@ public class JobCardService {
     private final UserInventoryAccountDAO userInventoryAccountDAO;
     private final FinishedItemDAO finishedItemDAO;
     private final StitchingOfflineItemDAO stitchingOfflineItemDAO;
+    private final SkuCutPiecesDAO skuCutPiecesDAO;
+    private final HTMLBuilder htmlBuilder;
+    private PDFResponseEntityInputStreamResource pdfGenerator;
 
-    public JobCardService(JobCardDAO jobCardDAO, CutPieceTypeDAO cutPieceTypeDAO, JobCardItemDAO jobCardItemDAO, CutPieceDAO cutPieceDAO, ItemDAO itemDAO, LocationSiteDAO locationSiteDAO, PurchaseOrderDAO purchaseOrderDAO, UserInventoryAccountDAO userInventoryAccountDAO, FinishedItemDAO finishedItemDAO, StitchingOfflineItemDAO stitchingOfflineItemDAO) {
+    public JobCardService(JobCardDAO jobCardDAO, CutPieceTypeDAO cutPieceTypeDAO, JobCardItemDAO jobCardItemDAO, CutPieceDAO cutPieceDAO, ItemDAO itemDAO, LocationSiteDAO locationSiteDAO, PurchaseOrderDAO purchaseOrderDAO, UserInventoryAccountDAO userInventoryAccountDAO, FinishedItemDAO finishedItemDAO, StitchingOfflineItemDAO stitchingOfflineItemDAO, SkuCutPiecesDAO skuCutPiecesDAO, HTMLBuilder htmlBuilder, PDFResponseEntityInputStreamResource pdfGenerator) {
+        this.skuCutPiecesDAO = skuCutPiecesDAO;
         this.jobCardDAO = jobCardDAO;
         this.cutPieceTypeDAO = cutPieceTypeDAO;
         this.jobCardItemDAO = jobCardItemDAO;
@@ -47,6 +58,8 @@ public class JobCardService {
         this.userInventoryAccountDAO = userInventoryAccountDAO;
         this.finishedItemDAO = finishedItemDAO;
         this.stitchingOfflineItemDAO = stitchingOfflineItemDAO;
+        this.htmlBuilder = htmlBuilder;
+        this.pdfGenerator = pdfGenerator;
     }
 
     /*
@@ -136,14 +149,8 @@ public class JobCardService {
             for (JobCardItem item : jobCard.getItems()) {
                 item.setJobCardId(jobCardId);
                 long itemId = jobCardItemDAO.save(item);
-                for (CutPiece cutPiece : item.getCutPieces()) {
-                    cutPiece.setJobCardItemId(itemId);
-                    cutPieces.add(cutPiece);
             }
         }
-            // save all pieces
-            cutPieceDAO.saveAll(cutPieces);
-        }
     }
 
 
@@ -175,7 +182,7 @@ public class JobCardService {
                 .collect( Collectors.toList() );
 
         // get items has account ids and has actual production not filled
-        List<JobCardItem> items = jobCardItemDAO.findByJobCardAndAccountIdsAndIsReceived( id, 0L ,accountIds );
+        List<JobCardItem> items = jobCardItemDAO.findByJobCardAndAccountIdsAndIsReceived( id ,accountIds );
         if (items != null && !items.isEmpty()) {
             // get job card ite ids
             List<Long> jobCardItemIds = items.stream()
@@ -291,4 +298,29 @@ public class JobCardService {
     public Map<Long, Long> totalFinishItem(List<Long> itemIds, long jobCardId ){
         return finishedItemDAO.findTotalFinishedItems( itemIds, jobCardId );
     }
+
+    /**
+     * Print Job card *
+     * **/
+    public ResponseEntity<InputStreamResource> getJobCardReceivingPdf(long id, Model model ) throws Exception {
+        List<JobCardItem> jobCardItems = findJobCardItemByJobCardId(id);
+        List<Long> jobCardItemIds = jobCardItems.stream()
+                .map(JobCardItem::getItemId)
+                .collect(Collectors.toList());
+
+        List<Long> itemIds = jobCardItems.stream()
+                .map(JobCardItem::getId)
+                .collect(Collectors.toList());
+
+        model.addAttribute( "baseUrl", URLUtils.getCurrentBaseUrl() );
+        model.addAttribute( "card", findByID(id));
+        model.addAttribute("jobCardItems", jobCardItems);
+        model.addAttribute("cutPiece", findCutPieceByJobCardItemIds(itemIds));
+        model.addAttribute("totalFinishItem", totalFinishItem(jobCardItemIds, id));
+        model.addAttribute("totalStitchingItem", totalStitchingItem(jobCardItemIds, id));
+        // html str
+        String htmlStr = htmlBuilder.buildHTML( "job-card-view-pdf", model );
+        // return pdf
+        return pdfGenerator.generatePdf( htmlStr, "Job-Card", "inline" );
+    }
 }

src/main/java/com/utopiaindustries/service/PackagingService.java

@@ -0,0 +1,22 @@
+package com.utopiaindustries.service;
+
+import com.utopiaindustries.dao.ctp.PackagingItemsDAO;
+import com.utopiaindustries.model.ctp.FinishedItemWrapper;
+import org.springframework.stereotype.Service;
+
+@Service
+public class PackagingService {
+
+    private final InventoryService inventoryService;
+    private final PackagingItemsDAO packagingItemsDAO;
+
+    public PackagingService(InventoryService inventoryService, PackagingItemsDAO packagingItemsDAO) {
+        this.inventoryService = inventoryService;
+        this.packagingItemsDAO = packagingItemsDAO;
+    }
+
+    public void createPackagingItem(FinishedItemWrapper wrapper){
+        inventoryService.createPackagingItemAndTransaction(wrapper, wrapper.getAccountId());
+    }
+
+}

src/main/java/com/utopiaindustries/service/PurchaseOrderCTPService.java

@@ -0,0 +1,102 @@
+package com.utopiaindustries.service;
+
+import com.utopiaindustries.dao.ctp.JobCardDAO;
+import com.utopiaindustries.dao.ctp.PurchaseOrderCTPDao;
+import com.utopiaindustries.dao.ctp.StoreItemDao;
+import com.utopiaindustries.model.ctp.*;
+import com.utopiaindustries.model.uind.PurchaseOrder;
+import com.utopiaindustries.querybuilder.ctp.JobCardQueryBuilder;
+import com.utopiaindustries.querybuilder.ctp.PurchaseOrderCTPQueryBuilder;
+import com.utopiaindustries.util.StringUtils;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+@Service
+public class PurchaseOrderCTPService {
+
+    private final PurchaseOrderCTPDao purchaseOrderCTPDao;
+    private final JobCardDAO jobCardDAO;
+    private final StoreItemDao storeItemDao;
+
+    public PurchaseOrderCTPService(PurchaseOrderCTPDao purchaseOrderCTPDao, JobCardDAO jobCardDAO, StoreItemDao storeItemDao) {
+        this.purchaseOrderCTPDao = purchaseOrderCTPDao;
+        this.jobCardDAO = jobCardDAO;
+        this.storeItemDao = storeItemDao;
+    }
+
+    /*
+     * search by id
+     * */
+    public PurchaseOrderCTP searchPurchaseOrderById(long id){
+        return purchaseOrderCTPDao.find(id);
+    }
+
+    /*
+     *  create new purchase
+     * */
+    public PurchaseOrderCTP createNewPurchaseOrderCTP() {
+        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
+        PurchaseOrderCTP purchaseOrderCTP = new PurchaseOrderCTP();
+        purchaseOrderCTP.setCreatedBy( authentication.getName() );
+        purchaseOrderCTP.setCreatedAt( LocalDateTime.now() );
+        return purchaseOrderCTP;
+    }
+
+    /*
+     *  save purchase order for ctp
+     * */
+    @Transactional( rollbackFor = Exception.class )
+    public void save(PurchaseOrderCTP purchaseOrderCTP) {
+        purchaseOrderCTPDao.save(purchaseOrderCTP);
+    }
+
+    public List<PurchaseOrderCTP> getAllPurchaseOrderCtp(String purchaseOrderCode, String articleName, String startDate, String endDate, Long limit) {
+        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
+        List<PurchaseOrderCTP> list = new ArrayList<>();
+        String createdBy = authentication.getName();
+        if( limit == null ){
+            limit = 100L;
+        }
+        if(StringUtils.isAnyNotNullOrEmpty(purchaseOrderCode, articleName,startDate,endDate) ){
+            for (GrantedAuthority role : authentication.getAuthorities()){
+                if (role.toString().equals("ROLE_ADMIN")){
+                    createdBy = "";
+                }
+            }
+            String query = PurchaseOrderCTPQueryBuilder.buildQuery(purchaseOrderCode, articleName, createdBy, startDate, endDate, limit );
+                    System.out.println( query );
+            list = purchaseOrderCTPDao.findByQuery( query );
+        }else {
+            list = purchaseOrderCTPDao.findByUserAndLimit( authentication.getName(), limit );
+        }
+        return list;
+    }
+
+    public List<PurchaseOrderCTP> findByTerm(String term ){
+        return purchaseOrderCTPDao.findByTerm( term );
+    }
+
+    public Map<String,Integer> getStoreItemsByPoId(Long poId){
+        Map<String,Integer> totalItems = new HashMap<>();
+        List<JobCard> jobCards = jobCardDAO.findByPoId(poId);
+        List<Long> jobCardIds = jobCards.stream()
+                .map(JobCard::getId)
+                .collect(Collectors.toList());
+        if(!jobCardIds.isEmpty()){
+            return storeItemDao.totalCountByJobCardIdsAndGroupByRejectReason(jobCardIds);
+        }else {
+            return totalItems;
+        }
+    }
+
+}

src/main/java/com/utopiaindustries/service/PurchaseOrderService.java

@@ -1,21 +1,58 @@
 package com.utopiaindustries.service;
 
+import com.utopiaindustries.dao.ctp.StoreItemDao;
 import com.utopiaindustries.dao.uind.PurchaseOrderDAO;
+import com.utopiaindustries.model.ctp.JobCardItem;
+import com.utopiaindustries.model.ctp.POsDetails;
 import com.utopiaindustries.model.uind.PurchaseOrder;
+import com.utopiaindustries.util.HTMLBuilder;
+import com.utopiaindustries.util.PDFResponseEntityInputStreamResource;
+import com.utopiaindustries.util.URLUtils;
+import org.springframework.core.io.InputStreamResource;
+import org.springframework.http.ResponseEntity;
 import org.springframework.stereotype.Service;
+import org.springframework.ui.Model;
 
 import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
 
 @Service
 public class PurchaseOrderService {
 
     private final PurchaseOrderDAO purchaseOrderDAO;
+    private final PurchaseOrderCTPService purchaseOrderCTPService;
+    private final HTMLBuilder htmlBuilder;
+    private PDFResponseEntityInputStreamResource pdfGenerator;
 
-    public PurchaseOrderService(PurchaseOrderDAO purchaseOrderDAO) {
+    public PurchaseOrderService(PurchaseOrderDAO purchaseOrderDAO, PurchaseOrderCTPService purchaseOrderCTPService, HTMLBuilder htmlBuilder, PDFResponseEntityInputStreamResource pdfGenerator) {
         this.purchaseOrderDAO = purchaseOrderDAO;
+        this.purchaseOrderCTPService = purchaseOrderCTPService;
+        this.htmlBuilder = htmlBuilder;
+        this.pdfGenerator = pdfGenerator;
     }
 
     public List<PurchaseOrder> findByTerm( String term ){
         return purchaseOrderDAO.findByTerm( term );
     }
+
+    /**
+     * Print Job card *
+     * **/
+    public ResponseEntity<InputStreamResource> generatePOPdf(POsDetails pOsDetails, Model model, boolean jobCardDetail, boolean storeDetail ) throws Exception {
+        Map<String,Integer> storeItems = purchaseOrderCTPService.getStoreItemsByPoId(pOsDetails.getPoId());
+        model.addAttribute("poDetail",  pOsDetails);
+        model.addAttribute( "baseUrl", URLUtils.getCurrentBaseUrl() );
+
+        if (storeDetail && !storeItems.isEmpty()){
+            model.addAttribute("showStore", true);
+            model.addAttribute("store", storeItems);
+        }else {
+            model.addAttribute("showStore", false);
+        }
+        String htmlStr = htmlBuilder.buildHTML( "po-status-pdf", model );
+        // return pdf
+        return pdfGenerator.generatePdf( htmlStr, "Po-status", "inline" );
+    }
+
 }

src/main/java/com/utopiaindustries/service/ReportingService.java

@@ -0,0 +1,834 @@
+package com.utopiaindustries.service;
+
+
+import com.utopiaindustries.dao.ctp.*;
+import com.utopiaindustries.model.ctp.*;
+import com.utopiaindustries.querybuilder.ctp.SummaryInventoryReportQueryBuilder;
+import com.utopiaindustries.util.CTPDateTimeFormat;
+import com.utopiaindustries.util.StringUtils;
+import org.springframework.stereotype.Service;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.time.Duration;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.*;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+@Service
+public class ReportingService {
+
+    private final JobCardItemDAO jobCardItemDAO;
+    private final BundleDAO bundleDAO;
+    private final InventoryTransactionLegDAO inventoryTransactionLegDAO;
+    private final JobCardDAO jobCardDAO;
+    private final FinishedItemDAO finishedItemDAO;
+    private final StitchingOfflineItemDAO stitchingOfflineItemDAO;
+    private final InventoryAccountDAO inventoryAccountDAO;
+    private final PurchaseOrderCTPDao purchaseOrderCTPDao;
+    private final StoreItemDao storeItemDao;
+    private final PackagingItemsDAO packagingItemsDAO;
+
+    public ReportingService(JobCardItemDAO jobCardItemDAO, BundleDAO bundleDAO, InventoryTransactionLegDAO inventoryTransactionLegDAO, JobCardDAO jobCardDAO, FinishedItemDAO finishedItemDAO, StitchingOfflineItemDAO stitchingOfflineItemDAO, InventoryAccountDAO inventoryAccountDAO, PurchaseOrderCTPDao purchaseOrderCTPDao, StoreItemDao storeItemDao, PackagingItemsDAO packagingItemsDAO) {
+        this.jobCardItemDAO = jobCardItemDAO;
+        this.bundleDAO = bundleDAO;
+        this.inventoryTransactionLegDAO = inventoryTransactionLegDAO;
+        this.jobCardDAO = jobCardDAO;
+        this.finishedItemDAO = finishedItemDAO;
+        this.stitchingOfflineItemDAO = stitchingOfflineItemDAO;
+        this.inventoryAccountDAO = inventoryAccountDAO;
+        this.purchaseOrderCTPDao = purchaseOrderCTPDao;
+        this.storeItemDao = storeItemDao;
+        this.packagingItemsDAO = packagingItemsDAO;
+    }
+
+    public Map<String, Integer> getJobCardProgress(String jobCardID) {
+        if (jobCardID == null) {
+            return new LinkedHashMap<>();
+        } else {
+            Map<String, Integer> totalProgress = new HashMap<>();
+            List<JobCardItem> jobCardItems = jobCardItemDAO.findByCardId(Long.parseLong(jobCardID));
+
+            BigDecimal totalProduction = jobCardItems.stream()
+                    .map(item -> Optional.ofNullable(item.getTotalProduction()).orElse(BigDecimal.ZERO))
+                    .reduce(BigDecimal.ZERO, BigDecimal::add);
+
+            BigDecimal actualProduction = jobCardItems.stream()
+                    .map(item -> Optional.ofNullable(item.getActualProduction()).orElse(BigDecimal.ZERO))
+                    .reduce(BigDecimal.ZERO, BigDecimal::add);
+
+            BigDecimal expectedProduction = jobCardItems.stream()
+                    .map(item -> Optional.ofNullable(item.getExpectedProduction()).orElse(BigDecimal.ZERO))
+                    .reduce(BigDecimal.ZERO, BigDecimal::add);
+
+            // Cutting Progress Calculation
+            if (actualProduction.compareTo(BigDecimal.ZERO) == 0) {
+                totalProgress.put("Cutting Progress", 0);
+            } else if (actualProduction.compareTo(expectedProduction) < 0) {
+                BigDecimal cuttingProgress = actualProduction
+                        .divide(expectedProduction, 4, RoundingMode.HALF_UP)
+                        .multiply(BigDecimal.valueOf(100));
+                totalProgress.put("Cutting Progress", cuttingProgress.intValue());
+            } else {
+                totalProgress.put("Cutting Progress", 100);
+            }
+
+            // Stitching Progress Calculation
+            if (totalProduction.compareTo(BigDecimal.ZERO) == 0) {
+                totalProgress.put("Stitching Progress", 0);
+            } else {
+                BigDecimal stitchingProgress = totalProduction
+                        .divide(actualProduction, 4, RoundingMode.HALF_UP)
+                        .multiply(BigDecimal.valueOf(100));
+                totalProgress.put("Stitching Progress", stitchingProgress.intValue());
+            }
+
+            // QA Progress Calculation
+            Long qaProgressItems = stitchingOfflineItemDAO.CalculateTotalQA(Long.parseLong(jobCardID));
+            if (qaProgressItems == 0) {
+                totalProgress.put("QA Progress", 0);
+            } else {
+                BigDecimal qaProgress = BigDecimal.valueOf(qaProgressItems)
+                        .divide(actualProduction, 4, RoundingMode.HALF_UP)
+                        .multiply(BigDecimal.valueOf(100));
+                totalProgress.put("QA Progress", qaProgress.intValue());
+            }
+
+            // Finishing Progress Calculation
+            Long totalFinishItem = finishedItemDAO.calculateTotalFinishItem(Long.parseLong(jobCardID));
+            if (totalFinishItem == 0) {
+                totalProgress.put("Finishing Progress", 0);
+            } else {
+                BigDecimal finishItemProgress = BigDecimal.valueOf(totalFinishItem)
+                        .divide(actualProduction, 4, RoundingMode.HALF_UP)
+                        .multiply(BigDecimal.valueOf(100));
+                totalProgress.put("Finishing Progress", finishItemProgress.intValue());
+            }
+
+            // Job Card Progress Calculation
+            if (totalProduction.compareTo(BigDecimal.ZERO) == 0 && actualProduction.compareTo(BigDecimal.ZERO) == 0) {
+                totalProgress.put("Job Card Progress", 0);
+            } else {
+                BigDecimal progressPercentage;
+                if (actualProduction.compareTo(expectedProduction) > 0) {
+                    progressPercentage = actualProduction.add(totalProduction)
+                            .add(BigDecimal.valueOf(qaProgressItems))
+                            .add(BigDecimal.valueOf(totalFinishItem))
+                            .divide(actualProduction.multiply(BigDecimal.valueOf(4)), 4, RoundingMode.HALF_UP)
+                            .multiply(BigDecimal.valueOf(100));
+                } else {
+                    progressPercentage = actualProduction.add(totalProduction)
+                            .add(BigDecimal.valueOf(qaProgressItems))
+                            .add(BigDecimal.valueOf(totalFinishItem))
+                            .divide(expectedProduction.multiply(BigDecimal.valueOf(4)), 4, RoundingMode.HALF_UP)
+                            .multiply(BigDecimal.valueOf(100));
+                }
+                totalProgress.put("Job Card Progress", progressPercentage.intValue());
+            }
+
+            // Sorting Map based on Custom Order
+            Map<String, Integer> indexMap = new HashMap<>();
+            indexMap.put("Cutting Progress", 1);
+            indexMap.put("Stitching Progress", 2);
+            indexMap.put("QA Progress", 3);
+            indexMap.put("Finishing Progress", 4);
+            indexMap.put("Job Card Progress", 5);
+
+            return totalProgress.entrySet()
+                    .stream()
+                    .sorted(Comparator.comparingInt(entry -> indexMap.get(entry.getKey())))
+                    .collect(LinkedHashMap::new, (m, v) -> m.put(v.getKey(), v.getValue()), Map::putAll);
+        }
+    }
+
+
+    public Integer getTotalProduction(String jobCardID){
+        if (jobCardID == null){
+            return 0;
+        }else {
+            List<JobCardItem> jobCardItems = jobCardItemDAO.findByCardId(Long.parseLong(jobCardID));
+            BigDecimal actualProduction = jobCardItems.stream()
+                    .map(item -> Optional.ofNullable(item.getActualProduction()).orElse(BigDecimal.ZERO))
+                    .reduce(BigDecimal.ZERO, BigDecimal::add);
+
+            return actualProduction.intValue();
+        }
+    }
+
+    public Map<String, Integer> getCompleteProduction(String jobCardID) {
+        if (jobCardID == null) {
+            return new LinkedHashMap<>();
+        } else {
+            HashMap<String, Integer> totalProgress = new HashMap<>();
+            List<JobCardItem> jobCardItems = jobCardItemDAO.findByCardId(Long.parseLong(jobCardID));
+
+            BigDecimal totalProduction = jobCardItems.stream()
+                    .map(item -> Optional.ofNullable(item.getTotalProduction()).orElse(BigDecimal.ZERO))
+                    .reduce(BigDecimal.ZERO, BigDecimal::add);
+
+            BigDecimal actualProduction = jobCardItems.stream()
+                    .map(item -> Optional.ofNullable(item.getActualProduction()).orElse(BigDecimal.ZERO))
+                    .reduce(BigDecimal.ZERO, BigDecimal::add);
+
+            Long qaProgressItems = stitchingOfflineItemDAO.CalculateTotalQA(Long.parseLong(jobCardID));
+            Long totalFinishItem = finishedItemDAO.calculateTotalFinishItem(Long.parseLong(jobCardID));
+
+            // Get Job card Complete Items
+            Map<String, Integer> jobCardCompleteItems = getSegregateItems(jobCardID);
+            Integer segregateTotalItems = jobCardCompleteItems.values().stream().mapToInt(Integer::intValue).sum();
+
+            // Add values to totalProgress map
+            totalProgress.put("Cutting Progress", actualProduction.intValue());
+            totalProgress.put("Stitching Progress", totalProduction.intValue());
+            totalProgress.put("QA Progress", qaProgressItems.intValue());
+            totalProgress.put("Finishing Progress", totalFinishItem.intValue());
+            totalProgress.put("Job Card Progress", segregateTotalItems);
+
+            //custom order
+            Map<String, Integer> indexMap = new HashMap<>();
+            indexMap.put("Job Card Progress", 1);
+            indexMap.put("Cutting Progress", 2);
+            indexMap.put("Stitching Progress", 3);
+            indexMap.put("Finishing Progress", 4);
+            indexMap.put("QA Progress", 5);
+
+            // Sort the keys based on custom order
+            return totalProgress.entrySet()
+                    .stream()
+                    .sorted(Comparator.comparingInt(entry -> indexMap.get(entry.getKey())))
+                    .collect(LinkedHashMap::new, (m, v) -> m.put(v.getKey(), v.getValue()), Map::putAll);
+        }
+    }
+
+
+    public Map<String,Integer> getSegregateItems(String jobCardID){
+        if (jobCardID == null){
+            return new HashMap<>();
+        }else {
+            HashMap<String,Integer> gradingItems = new HashMap<>();
+            List<FinishedItem> finishedItems = finishedItemDAO.findByJobCardId(Long.parseLong(jobCardID));
+
+            List<FinishedItem> bGradeFinishItemsIds= finishedItems.stream()
+                    .filter(item -> "REJECT".equals(item.getQaStatus())).collect(Collectors.toList());
+
+            List<FinishedItem> cGradeFinishItemsIds= finishedItems.stream()
+                    .filter(item -> "C GRADE".equals(item.getQaStatus())).collect(Collectors.toList());
+
+            List<FinishedItem> aGradeFinishItemsIds= finishedItems.stream()
+                    .filter(item -> "APPROVED".equals(item.getQaStatus())).collect(Collectors.toList());
+
+
+            if (finishedItems.isEmpty()){
+                gradingItems.put("A GRADE",0);
+                gradingItems.put("B GRADE",0);
+                gradingItems.put("C GRADE",0);
+                return gradingItems;
+            }else {
+                gradingItems.put("B GRADE",bGradeFinishItemsIds.size());
+                gradingItems.put("C GRADE",cGradeFinishItemsIds.size());
+                gradingItems.put("A GRADE",aGradeFinishItemsIds.size());
+                return gradingItems;
+            }
+        }
+    }
+
+    public HashMap<String,String> getEachPhaseTotalTime(String jobCardID){
+        if (jobCardID == null){
+            return new HashMap<>();
+        }else {
+            HashMap<String,String> phasesTimes = new HashMap<>();
+            JobCard jobCard = jobCardDAO.find(Long.parseLong(jobCardID));
+            Bundle lastBundle = bundleDAO.findLastBundleByCardId(Long.parseLong(jobCardID));
+
+            //Cutting time
+            StringBuilder cuttingTime = generateTime(jobCard.getCreatedAt(),lastBundle.getCreatedAt());
+            phasesTimes.put("Cutting Total Time",cuttingTime.toString());
+
+            //Stitching time
+            List<Long> bundlesIds = bundleDAO.findByCardId(Long.parseLong(jobCardID)).stream().map(Bundle::getId).collect(Collectors.toList());
+            if (!bundlesIds.isEmpty()){
+                InventoryTransactionLeg inventoryTransactionLeg = inventoryTransactionLegDAO.getFirstStitchBundleTime(bundlesIds,"STITCH_BUNDLE");
+                StitchingOfflineItem lastStitchItem = stitchingOfflineItemDAO.getLastStitchItemByCardIdAndTime(Long.parseLong(jobCardID));
+                StringBuilder stitchingTime = generateTime(inventoryTransactionLeg.getTransactionLegDateTime(),lastStitchItem.getCreatedAt());
+                phasesTimes.put("Stitching Total Time",stitchingTime.toString());
+            }else {
+                phasesTimes.put("Stitching Total Time",null);
+
+            }
+
+            return phasesTimes;
+        }
+    }
+
+    public HashMap<String,String> countPendingItemsOnDifferentPhases(String jobCardID){
+        if (jobCardID == null){
+            return new HashMap<>();
+        }else {
+            HashMap<String,String> phasePending = new HashMap<String,String>();
+            List<JobCardItem> jobCardItems = jobCardItemDAO.findByCardId(Long.parseLong(jobCardID));
+            BigDecimal totalProduction = jobCardItems.stream()
+                    .map(item -> Optional.ofNullable(item.getTotalProduction()).orElse(BigDecimal.ZERO))
+                    .reduce(BigDecimal.ZERO, BigDecimal::add);
+
+            BigDecimal actualProduction = jobCardItems.stream()
+                    .map(item -> Optional.ofNullable(item.getActualProduction()).orElse(BigDecimal.ZERO))
+                    .reduce(BigDecimal.ZERO, BigDecimal::add);
+
+            if(actualProduction.compareTo(totalProduction) == 0) {
+                phasePending.put("Stitching Total Time", null);
+            }else {
+                phasePending.put("Stitching Total Time", "Pending");
+            }
+            return phasePending;
+        }
+    }
+
+    public Map<String, Map<String, Object>> getCuttingDetails(String jobCardID) {
+        if (jobCardID == null) {
+            return Collections.emptyMap();
+        }
+
+        Map<String, Map<String, Object>> cuttingDetails = new HashMap<>();
+        Map<String, InventoryAccount> cuttingAccount = new HashMap<>();
+        Map<String, String> cuttingPersonName = new HashMap<>();
+        Map<String, LocalDate> cuttingDate = new HashMap<>();
+
+        List<Bundle> bundles = bundleDAO.findByCardId(Long.parseLong(jobCardID));
+        if (bundles.isEmpty()) {
+            return cuttingDetails;
+        }
+
+        Map<Long, Bundle> bundleMap = bundles.stream()
+                .collect(Collectors.toMap(Bundle::getId, Function.identity()));
+
+        List<Long> bundleIds = new ArrayList<>(bundleMap.keySet());
+        List<InventoryTransactionLeg> inventoryTransactionLegs = inventoryTransactionLegDAO
+                .getTransactionByParentIdAndType(bundleIds, "BUNDLE");
+
+        for (InventoryTransactionLeg inventoryTransactionLeg : inventoryTransactionLegs) {
+            Integer accountId = inventoryTransactionLeg.getAccountId();
+            InventoryAccount inventoryAccount = inventoryAccountDAO.find(accountId.longValue());
+            if (inventoryAccount != null) {
+                String accountTitle = inventoryAccount.getTitle();
+                cuttingAccount.put(accountTitle, inventoryAccount);
+                Bundle bundle = bundleMap.get(inventoryTransactionLeg.getParentDocumentId());
+                cuttingPersonName.put(accountTitle, (bundle != null) ? bundle.getCreatedBy() : null);
+                cuttingDate.put(accountTitle,(bundle != null) ? bundle.getCreatedAt().toLocalDate() : null);
+            }
+        }
+
+        cuttingDetails.put("accounts", new HashMap<>(cuttingAccount));
+        cuttingDetails.put("personName", new HashMap<>(cuttingPersonName));
+        cuttingDetails.put("date", new HashMap<>(cuttingDate));
+
+        return cuttingDetails;
+    }
+
+    public Map<String, Map<String, Object>> getStitchingDetails(String jobCardID) {
+        if (jobCardID == null) {
+            return Collections.emptyMap();
+        }
+
+        Map<String, Map<String, Object>> stitchingDetails = new HashMap<>();
+        Map<String, InventoryAccount> stitchingAccount = new HashMap<>();
+        Map<String, String> stitchingPersonName = new HashMap<>();
+        Map<String, LocalDate> stitchingDate = new HashMap<>();
+
+        List<StitchingOfflineItem> stitchingOfflineItems = stitchingOfflineItemDAO.findByJobCardId(Long.parseLong(jobCardID));
+        if (stitchingOfflineItems.isEmpty()) {
+            return stitchingDetails;
+        }
+
+        Map<Long, StitchingOfflineItem> stitchingOfflineItemMap = stitchingOfflineItems.stream()
+                .collect(Collectors.toMap(StitchingOfflineItem::getId, Function.identity()));
+
+        List<Long> stitchingItemsArray = new ArrayList<>(stitchingOfflineItemMap.keySet());
+        List<InventoryTransactionLeg> inventoryTransactionLegs = inventoryTransactionLegDAO
+                .getTransactionByParentIdAndType(stitchingItemsArray, "STITCHING_OFFLINE");
+
+        for (InventoryTransactionLeg inventoryTransactionLeg : inventoryTransactionLegs) {
+            Integer accountId = inventoryTransactionLeg.getAccountId();
+            InventoryAccount inventoryAccount = inventoryAccountDAO.find(accountId.longValue());
+            if (inventoryAccount != null) {
+                String accountTitle = inventoryAccount.getTitle();
+                stitchingAccount.put(accountTitle, inventoryAccount);
+                StitchingOfflineItem stitchingOfflineItem = stitchingOfflineItemMap.get(inventoryTransactionLeg.getParentDocumentId());
+                stitchingPersonName.put(accountTitle, (stitchingOfflineItem != null) ? stitchingOfflineItem.getCreatedBy() : null);
+                stitchingDate.put(accountTitle,(stitchingOfflineItem != null) ? stitchingOfflineItem.getCreatedAt().toLocalDate() : null);
+            }
+        }
+
+        stitchingDetails.put("accounts", new HashMap<>(stitchingAccount));
+        stitchingDetails.put("personName", new HashMap<>(stitchingPersonName));
+        stitchingDetails.put("date", new HashMap<>(stitchingDate));
+
+        return stitchingDetails;
+    }
+
+
+    public Map<String, List<?>> getPhasesProgressDayWise(String jobCardID) {
+        if (jobCardID == null) {
+            return Collections.emptyMap();
+        }
+        List<InventoryAccount> inventoryAccounts = inventoryAccountDAO.findByParentEntityTypeAndParentId("PROCESS",6L);
+
+        LocalDateTime startDate = jobCardDAO.find(Long.parseLong(jobCardID)).getCreatedAt();
+        HashMap<String, List<?>> barChartData = new HashMap<>();
+
+        List<InventoryTransactionLeg> inventoryTransactionLegs = inventoryTransactionLegDAO
+                .getTransactionByJobCardAndDatesAndType(Long.parseLong(jobCardID), startDate.toString(), LocalDateTime.now().toString(), "IN");
+
+        //remove quality multiple transaction entry approved/rejects
+        List<InventoryTransactionLeg> filteredTransactions = inventoryTransactionLegs.stream()
+                .collect(Collectors.toMap(
+                        leg -> leg.getAccountId() + "-" + leg.getParentDocumentType() + "-" + leg.getParentDocumentId(),
+                        leg -> leg, // Value
+                        (existing, replacement) -> existing.getTransactionLegDateTime().isBefore(replacement.getTransactionLegDateTime()) ? existing : replacement // Keep Oldest
+                ))
+                .values()
+                .stream()
+                .collect(Collectors.toList());
+
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
+
+        List<String> uniqueDates = inventoryTransactionLegs.stream()
+                .map(leg -> leg.getTransactionLegDateTime().toLocalDate().format(formatter))
+                .distinct()
+                .sorted()
+                .collect(Collectors.toList());
+
+        Map<String, Integer> dateIndexMap = new HashMap<>();
+        for (int i = 0; i < uniqueDates.size(); i++) {
+            dateIndexMap.put(uniqueDates.get(i), i);
+        }
+
+        List<Integer> cuttingList = new ArrayList<>(Collections.nCopies(uniqueDates.size(), 0));
+        List<Integer> stitchingList = new ArrayList<>(Collections.nCopies(uniqueDates.size(), 0));
+        List<Integer> qualityList = new ArrayList<>(Collections.nCopies(uniqueDates.size(), 0));
+        List<Integer> finishItems = new ArrayList<>(Collections.nCopies(uniqueDates.size(), 0));
+
+        for (InventoryTransactionLeg leg : filteredTransactions) {
+            String dateKey = leg.getTransactionLegDateTime().format(formatter);
+            int index = dateIndexMap.get(dateKey);
+            if ("BUNDLE".equals(leg.getParentDocumentType())) {
+                Bundle bundle = bundleDAO.find(leg.getParentDocumentId());
+                cuttingList.set(index, cuttingList.get(index) + bundle.getWrapQuantity().intValue());
+            }
+            else if ("STITCHING_OFFLINE".equals(leg.getParentDocumentType())) {
+                stitchingList.set(index, stitchingList.get(index) + leg.getQuantity().intValue());
+            }
+            else if ("FINISHED_ITEM".equals(leg.getParentDocumentType()) && (leg.getAccountId().equals(7) || leg.getAccountId().equals(12))) {
+                qualityList.set(index, qualityList.get(index) + leg.getQuantity().intValue());
+            }
+            else if ("PACKAGING".equals(leg.getParentDocumentType()) && inventoryAccounts.stream().anyMatch(e -> e.getId() == leg.getAccountId().longValue())) {
+                finishItems.set(index, finishItems.get(index) + leg.getQuantity().intValue());
+            }
+        }
+
+        barChartData.put("dates", uniqueDates);
+        barChartData.put("cutting", cuttingList);
+        barChartData.put("stitching", stitchingList);
+        barChartData.put("quality", qualityList);
+        barChartData.put("finishing", finishItems);
+
+        return barChartData;
+    }
+
+    public List<POsDetails> getAllPOs(String poCode) {
+
+        List<POsDetails> pOsDetailsList = new ArrayList<>();
+        List<PurchaseOrderCTP> purchaseOrderCTPList;
+
+        if (poCode != null && !poCode.isEmpty()) {
+            purchaseOrderCTPList = purchaseOrderCTPDao.findByPoCode(poCode);
+        }else {
+            purchaseOrderCTPList = purchaseOrderCTPDao.findAll();
+        }
+
+
+        for (PurchaseOrderCTP pos : purchaseOrderCTPList) {
+            List<JobCard> jobCards = jobCardDAO.findByPoId(pos.getId());
+            BigDecimal totalProduction = BigDecimal.ZERO;
+            BigDecimal expectedProduction = BigDecimal.ZERO;
+            BigDecimal actualProduction = BigDecimal.ZERO;
+            long stitchingIn = 0L;
+            long stitchingOut = 0L;
+            long finishApprovedItem = 0L;
+            long finishRejectItem = 0L;
+            long storeItems = 0L;
+            long packagingItems = 0L;
+            POsDetails pOsDetails = new POsDetails();
+            for (JobCard jobCard : jobCards) {
+                List<JobCardItem> jobCardItems = jobCardItemDAO.findByCardId(jobCard.getId());
+                expectedProduction = expectedProduction.add(jobCardItems.stream()
+                        .map(item -> Optional.ofNullable(item.getExpectedProduction()).orElse(BigDecimal.ZERO))
+                        .reduce(BigDecimal.ZERO, BigDecimal::add));
+
+                totalProduction = totalProduction.add(jobCardItems.stream()
+                        .map(item -> Optional.ofNullable(item.getTotalProduction()).orElse(BigDecimal.ZERO))
+                        .reduce(BigDecimal.ZERO, BigDecimal::add));
+
+                actualProduction = actualProduction.add(jobCardItems.stream()
+                        .map(item -> Optional.ofNullable(item.getActualProduction()).orElse(BigDecimal.ZERO))
+                        .reduce(BigDecimal.ZERO, BigDecimal::add));
+
+                //stitching detail
+                stitchingIn += Optional.of(stitchingOfflineItemDAO.findByJobCardId(jobCard.getId()).size()).orElse(0);
+                stitchingOut += Optional.ofNullable(stitchingOfflineItemDAO.CalculateTotalQA(jobCard.getId())).orElse(0L);
+
+                //finishItems detail
+                List<FinishedItem>  finishedItems = finishedItemDAO.findByJobCardId(jobCard.getId());
+                finishApprovedItem += finishedItems.stream().filter(e -> e.getQaStatus().equals("APPROVED")).count();
+                finishRejectItem += finishedItems.stream().filter(e -> e.getQaStatus().equals("REJECT")).count();
+
+                //reject store details
+                storeItems += Optional.ofNullable(storeItemDao.calculateTotalRejectItemByJobCardId(jobCard.getId())).orElse(0L);
+
+                //reject packaging details
+                packagingItems += Optional.of(packagingItemsDAO.findByJobCardId(jobCard.getId()).size()).orElse(0);
+
+            }
+            pOsDetails.setPoId(pos.getId());
+            pOsDetails.setPoNumber(pos.getPurchaseOrderCode());
+            pOsDetails.setArticleTitle(pos.getArticleName());
+            pOsDetails.setPoQuantity(pos.getPurchaseOrderQuantity());
+            pOsDetails.setPoRequiredQuantity(pos.getPurchaseOrderQuantityRequired());
+            pOsDetails.setActualCutting(expectedProduction.longValue());
+            pOsDetails.setBalanceToCutting(pos.getPurchaseOrderQuantityRequired() - actualProduction.longValue());
+            pOsDetails.setCuttingReceived(expectedProduction.longValue());
+            pOsDetails.setCuttingOki(actualProduction.intValue());
+            pOsDetails.setCuttingReject(expectedProduction.subtract(actualProduction).intValue());
+            pOsDetails.setStitchingIn(stitchingIn);
+            pOsDetails.setStitchingOut(stitchingOut);
+            pOsDetails.setStitchingWips(stitchingIn - stitchingOut);
+            pOsDetails.setFinishIn(stitchingOut);
+            pOsDetails.setFinishRej(finishRejectItem);
+            pOsDetails.setFinishQaApproved(finishApprovedItem);
+            pOsDetails.setStoreReceived(storeItems);
+            pOsDetails.setStoreWaiting(finishRejectItem - storeItems);
+            pOsDetails.setFinishQaApproved(finishApprovedItem);
+            pOsDetails.setPackagingIn(packagingItems);
+            pOsDetails.setPackagingOut(packagingItems);
+            pOsDetails.setPackagingStock(0);
+            pOsDetails.setShippedScan(packagingItems);
+            pOsDetails.setShippedNet(packagingItems);
+            pOsDetails.setPackagingStock(0);
+            pOsDetails.setPoStatus(false);
+            pOsDetailsList.add(pOsDetails);
+        }
+        return pOsDetailsList;
+    }
+
+    public HashMap<String, Map<String, Integer>> getAllPoJobCards(long poId, String selectDate) {
+        String startDate = selectDate != null && !selectDate.isEmpty() ? selectDate + " 00:00:01": null;
+        String endDate = selectDate != null && !selectDate.isEmpty() ? selectDate + " 23:59:59": null;
+
+        HashMap<String, Map<String, Integer>> poJobCardItemsProgress = new HashMap<>();
+        // Filter JobCards by Purchase Order ID
+        List<JobCard> filterJobCardsByPos = jobCardDAO.findByPoId(poId);
+        List<InventoryAccount> inventoryAccounts = inventoryAccountDAO.getPackagingAccounts();
+        List<Integer> gradingAccounts = inventoryAccounts.stream().map(e-> (int)(e.getId())).collect(Collectors.toList());
+        for (JobCard jobCard : filterJobCardsByPos) {
+            List<Bundle> bundles = bundleDAO.findByCardIdAndDATE(jobCard.getId(),startDate,endDate);
+            List<StitchingOfflineItem> stitchingOfflineItems = stitchingOfflineItemDAO.findByJobCardIdAndDate(jobCard.getId(),startDate,endDate);
+            List<FinishedItem> finishedItems = finishedItemDAO.calculateTotalFinishItem(jobCard.getId(),startDate,endDate);
+
+            //cutting days wise
+            BigDecimal cutting = bundles.stream()
+                    .map(bundle -> Optional.ofNullable(bundle.getWrapQuantity()).orElse(BigDecimal.ZERO))
+                    .reduce(BigDecimal.ZERO, BigDecimal::add);
+
+            //stitching day wise
+            Integer stitching = stitchingOfflineItems.size();
+
+            //total qa
+            Integer qa = finishedItems.size();
+            Map<String, Integer> segregateItems = finishedItems.stream()
+                    .collect(Collectors.groupingBy(
+                            FinishedItem::getQaStatus,
+                            Collectors.collectingAndThen(
+                                    Collectors.counting(),
+                                    Long::intValue
+                            )
+                    ));
+
+            Map<String, Integer> items = getCompleteProduction(String.valueOf(jobCard.getId()));
+            items.put("Cutting Progress",cutting.intValue());
+            items.put("Stitching Progress",stitching);
+            items.put("QA Progress",qa);
+            items.put("A Grade",segregateItems.get("APPROVED") != null ? segregateItems.get("APPROVED") : 0);
+            items.put("B Grade / Reject",segregateItems.get("REJECT") != null ? segregateItems.get("REJECT") : 0);
+
+            // Define sorting order
+            Map<String, Integer> indexMap = new HashMap<>();
+            indexMap.put("Job Card Progress", 1);
+            indexMap.put("Cutting Progress", 2);
+            indexMap.put("Stitching Progress", 3);
+            indexMap.put("QA Progress", 4);
+            indexMap.put("Finishing Progress", 5);
+            indexMap.put("APPROVED", 6);
+            indexMap.put("REJECT", 7);
+
+            // Sort items based on indexMap order
+            Map<String, Integer> sortedItems = items.entrySet()
+                    .stream()
+                    .sorted(Comparator.comparingInt(entry -> indexMap.getOrDefault(entry.getKey(), Integer.MAX_VALUE)))
+                    .collect(Collectors.toMap(
+                            Map.Entry::getKey,
+                            Map.Entry::getValue,
+                            (oldValue, newValue) -> oldValue,
+                            LinkedHashMap::new
+                    ));
+
+            // Add sorted items to the result map
+            poJobCardItemsProgress.put(jobCard.getCode(), sortedItems);
+        }
+
+        return poJobCardItemsProgress;
+    }
+
+    public Map<String, Object> getCuttingTableDetails(String jobCardId, String cuttingTableId, String startDate, String endDate) {
+        Map<String, Object> cuttingDetails = new HashMap<>();
+        long jobCardIdTemp = 0L;
+        String startDate1 = null;
+        String endDate1 = null;
+
+        if (!StringUtils.isNullOrEmpty(startDate)) {
+            String formattedStart = CTPDateTimeFormat.getMySQLFormattedDateString(startDate, CTPDateTimeFormat.HTML5_DATE_INPUT_FORMAT);
+            String formattedEnd = !StringUtils.isNullOrEmpty(endDate)
+                    ? CTPDateTimeFormat.getMySQLFormattedDateString(endDate, CTPDateTimeFormat.HTML5_DATE_INPUT_FORMAT)
+                    : LocalDate.now().toString();
+
+            startDate1 = String.format("'%s 00:00:01'", formattedStart);
+            endDate1 = String.format("'%s 23:59:59'", formattedEnd);
+        }
+
+        List<InventoryAccount> inventoryAccounts = inventoryAccountDAO.findByParentEntityTypeAndParentId("PROCESS", 1L);
+        List<Long> inventoryAccountIds = inventoryAccounts.stream().map(InventoryAccount::getId).collect(Collectors.toList());
+
+        if (!StringUtils.isNullOrEmpty(jobCardId)) {
+            jobCardIdTemp = Long.parseLong(jobCardId);
+        } else if (!StringUtils.isNullOrEmpty(cuttingTableId)) {
+            inventoryAccountIds = List.of(Long.parseLong(cuttingTableId));
+        }
+
+        String query = SummaryInventoryReportQueryBuilder.cuttingQueryBuild(jobCardIdTemp, inventoryAccountIds, null, startDate1, endDate1, "IN","BUNDLE");
+        List<InventoryTransactionLeg> inventoryTransactionLegs = inventoryTransactionLegDAO.findByQuery(query);
+
+        Map<String, Integer> dateWiseProduction = new TreeMap<>();
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd-MM-yyyy");
+
+        Map<LocalDate, List<Long>> dateWiseJobCardIds = inventoryTransactionLegs.stream()
+                .filter(e -> e.getTransactionLegDateTime() != null && e.getJobCardId() != 0)
+                .collect(Collectors.groupingBy(
+                        e -> e.getTransactionLegDateTime().toLocalDate(),
+                        Collectors.mapping(InventoryTransactionLeg::getJobCardId, Collectors.toList())
+                ));
+
+        for (Map.Entry<LocalDate, List<Long>> entry : dateWiseJobCardIds.entrySet()) {
+            List<Long> jobCardIds = entry.getValue();
+            if (!jobCardIds.isEmpty()) {
+                List<JobCardItem> jobCardItems = jobCardItemDAO.findByJobCardIds(jobCardIds);
+                int totalProduction = jobCardItems.stream()
+                        .filter(item -> item.getActualProduction() != null)
+                        .mapToInt(item -> item.getActualProduction().intValue())
+                        .sum();
+                dateWiseProduction.put(entry.getKey().format(formatter), totalProduction);
+            }
+        }
+
+        List<Long> distinctJobCardIds = inventoryTransactionLegs.stream()
+                .map(InventoryTransactionLeg::getJobCardId)
+                .filter(id -> id != 0)
+                .distinct()
+                .collect(Collectors.toList());
+
+        Map<Long, List<CuttingJobCardItemWrapper>> jobCardItemsCuttingDetailsMap = new HashMap<>();
+
+        for (long jobCardIdEntry : distinctJobCardIds) {
+            Long accountId = inventoryTransactionLegs.stream()
+                    .filter(e -> e.getJobCardId() == jobCardIdEntry)
+                    .map(e -> e.getAccountId().longValue())
+                    .findFirst()
+                    .orElse(0L);
+
+            JobCard jobCard = jobCardDAO.find(jobCardIdEntry);
+            Bundle bundle = bundleDAO.findByCardId(jobCardIdEntry).stream().findFirst().orElse(new Bundle());
+
+            List<JobCardItem> jobCardItems = jobCardItemDAO.findByCardId(jobCardIdEntry);
+
+            List<CuttingJobCardItemWrapper> wrappers = jobCardItems.stream().map(item -> {
+                CuttingJobCardItemWrapper wrapper = new CuttingJobCardItemWrapper();
+                wrapper.setArticleName(jobCard.getArticleName());
+                wrapper.setJobCardCode(jobCard.getCode());
+                wrapper.setGsm(item.getGsm());
+                wrapper.setPly(item.getPly());
+                wrapper.setSku(item.getSku());
+                wrapper.setTotal(item.getActualProduction().longValue());
+                wrapper.setWidth(item.getWidth());
+                wrapper.setWtPly(item.getWtPly());
+                wrapper.setComplete(item.isComplete());
+                wrapper.setPoName(jobCard.getPurchaseOrderId());
+                wrapper.setOperatorName(bundle.getCreatedBy());
+                wrapper.setJobCardId(item.getJobCardId());
+                wrapper.setLength(item.getLength());
+                wrapper.setAccountId(accountId);
+                return wrapper;
+            }).collect(Collectors.toList());
+
+            jobCardItemsCuttingDetailsMap.computeIfAbsent(accountId, k -> new ArrayList<>()).addAll(wrappers);
+        }
+
+        cuttingDetails.put("Date Wise Cutting", dateWiseProduction);
+        cuttingDetails.put("accountWiseCutting", jobCardItemsCuttingDetailsMap);
+        cuttingDetails.put("cuttingAccount", inventoryAccounts);
+        return cuttingDetails;
+    }
+
+    public Map<String, Object> getStitchingDetails(String jobCardId, String stitchingLine, String startDate, String endDate) {
+        Map<String, Object> stitchingDetails = new HashMap<>();
+        long jobCardIdTemp = 0L;
+        String startDate1 = null;
+        String endDate1 = null;
+
+        if (!StringUtils.isNullOrEmpty(startDate)) {
+            String formattedStart = CTPDateTimeFormat.getMySQLFormattedDateString(startDate, CTPDateTimeFormat.HTML5_DATE_INPUT_FORMAT);
+            String formattedEnd = !StringUtils.isNullOrEmpty(endDate)
+                    ? CTPDateTimeFormat.getMySQLFormattedDateString(endDate, CTPDateTimeFormat.HTML5_DATE_INPUT_FORMAT)
+                    : LocalDate.now().toString();
+
+            startDate1 = String.format("'%s 00:00:01'", formattedStart);
+            endDate1 = String.format("'%s 23:59:59'", formattedEnd);
+        }
+
+        List<InventoryAccount> inventoryAccounts = inventoryAccountDAO.findByParentEntityTypeAndParentId("PROCESS", 2L);
+        List<Long> inventoryAccountIds = inventoryAccounts.stream().map(InventoryAccount::getId).collect(Collectors.toList());
+
+        if (!StringUtils.isNullOrEmpty(jobCardId)) {
+            jobCardIdTemp = Long.parseLong(jobCardId);
+        } else if (!StringUtils.isNullOrEmpty(stitchingLine)) {
+            inventoryAccountIds = List.of(Long.parseLong(stitchingLine));
+        }
+
+        String query = SummaryInventoryReportQueryBuilder.cuttingQueryBuild(jobCardIdTemp, inventoryAccountIds,null, startDate1, endDate1, "IN","STITCHING_OFFLINE");
+        List<InventoryTransactionLeg> inventoryTransactionLegs = inventoryTransactionLegDAO.findByQuery(query);
+
+        Map<String, Integer> dateWiseProduction = new TreeMap<>();
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd-MM-yyyy");
+
+        Map<LocalDate, List<Long>> dateWiseJobCardIds = inventoryTransactionLegs.stream()
+                .filter(e -> e.getTransactionLegDateTime() != null && e.getJobCardId() != 0)
+                .collect(Collectors.groupingBy(
+                        e -> e.getTransactionLegDateTime().toLocalDate(),
+                        Collectors.mapping(InventoryTransactionLeg::getJobCardId, Collectors.toList())
+                ));
+
+        for (Map.Entry<LocalDate, List<Long>> entry : dateWiseJobCardIds.entrySet()) {
+            LocalDate date = entry.getKey();
+            List<Long> jobCardIds = entry.getValue();
+
+            if (!jobCardIds.isEmpty()) {
+                int totalProduction = inventoryTransactionLegs.stream()
+                        .filter(item -> jobCardIds.contains(item.getJobCardId()) &&
+                                "STITCHING_OFFLINE".equals(item.getParentDocumentType()) && item.getTransactionLegDateTime().toLocalDate().equals(date))
+                        .mapToInt(item -> item.getQuantity().intValue())
+                        .sum();
+
+                dateWiseProduction.put(date.format(formatter), totalProduction);
+            }
+        }
+
+        List<Long> distinctJobCardIds = inventoryTransactionLegs.stream()
+                .map(InventoryTransactionLeg::getJobCardId)
+                .filter(id -> id != 0)
+                .distinct()
+                .collect(Collectors.toList());
+
+        Map<Long, List<CuttingJobCardItemWrapper>> jobCardItemsStitchingDetailsMap = new HashMap<>();
+        Map<String, Integer> totalStitchingBasedOnAccountID = new HashMap<>();
+
+        for (long jobCardIdEntry : distinctJobCardIds) {
+            Long accountId = inventoryTransactionLegs.stream()
+                    .filter(e -> e.getJobCardId() == jobCardIdEntry)
+                    .map(e -> e.getAccountId().longValue())
+                    .findFirst()
+                    .orElse(0L);
+
+            JobCard jobCard = jobCardDAO.find(jobCardIdEntry);
+            List<StitchingOfflineItem> stitchingOfflineItem = stitchingOfflineItemDAO.findByJobCardId(jobCardIdEntry);
+
+            List<JobCardItem> jobCardItems = jobCardItemDAO.findByCardId(jobCardIdEntry);
+
+            List<CuttingJobCardItemWrapper> wrappers = jobCardItems.stream().map(item -> {
+                CuttingJobCardItemWrapper wrapper = new CuttingJobCardItemWrapper();
+                wrapper.setArticleName(jobCard.getArticleName());
+                wrapper.setJobCardId(jobCard.getId());
+                wrapper.setJobCardCode(jobCard.getCode());
+                wrapper.setSku(item.getSku());
+                wrapper.setPoName(jobCard.getPurchaseOrderId());
+                wrapper.setJobCardId(item.getJobCardId());
+                wrapper.setOperatorName(stitchingOfflineItem.get(0).getCreatedBy());
+                wrapper.setAccountId(accountId);
+                return wrapper;
+
+            }).collect(Collectors.toList());
+            totalStitchingBasedOnAccountID.put(jobCard.getId()+stitchingOfflineItem.get(0).getSku(), stitchingOfflineItem.size());
+            jobCardItemsStitchingDetailsMap.computeIfAbsent(accountId, k -> new ArrayList<>()).addAll(wrappers);
+        }
+
+        stitchingDetails.put("totalStitchingBasedOnAccountID", totalStitchingBasedOnAccountID);
+        stitchingDetails.put("jobCardItemsStitchingDetailsMap", jobCardItemsStitchingDetailsMap);
+        stitchingDetails.put("Date Wise Stitching", dateWiseProduction);
+
+        stitchingDetails.put("stitchingAccount", inventoryAccounts);
+        return stitchingDetails;
+    }
+
+    public List<StitchingOfflineItem> stitchingItemsTransactions(String jobCardId, String accountId, String sku, String startDate, String endDate) {
+        List<Long> accountID = new ArrayList<>();
+        String startDate1 = null;
+        String endDate1 = null;
+
+        if (!StringUtils.isNullOrEmpty(startDate) && !StringUtils.isNullOrEmpty(accountId) && !StringUtils.isNullOrEmpty(jobCardId)) {
+            String formattedStart = CTPDateTimeFormat.getMySQLFormattedDateString(startDate, CTPDateTimeFormat.HTML5_DATE_INPUT_FORMAT);
+            String formattedEnd = !StringUtils.isNullOrEmpty(endDate)
+                    ? CTPDateTimeFormat.getMySQLFormattedDateString(endDate, CTPDateTimeFormat.HTML5_DATE_INPUT_FORMAT)
+                    : LocalDate.now().toString();
+
+            startDate1 = String.format("'%s 00:00:01'", formattedStart);
+            endDate1 = String.format("'%s 23:59:59'", formattedEnd);
+            accountID.add(Long.parseLong(accountId));
+        }
+
+
+        String query = SummaryInventoryReportQueryBuilder.cuttingQueryBuild(Long.parseLong(jobCardId), accountID, sku, startDate1, endDate1,"IN","STITCHING_OFFLINE");
+        List<InventoryTransactionLeg> inventoryTransactionLegs = inventoryTransactionLegDAO.findByQuery(query);
+        List<Long> stitchingItemsList = inventoryTransactionLegs.stream()
+                .map(InventoryTransactionLeg::getParentDocumentId)
+                .collect(Collectors.toList());
+        return stitchingOfflineItemDAO.findByIds(stitchingItemsList);
+    }
+
+    private StringBuilder generateTime(LocalDateTime startDate, LocalDateTime endDate){
+        StringBuilder totalTime = new StringBuilder();
+        if(startDate != null && endDate != null){
+            Duration duration = Duration.between(startDate, endDate);
+            if (duration.toDays() > 0) {
+                totalTime.append(String.format("%d days, ", duration.toDays()));
+            }
+
+            if (duration.toHours() % 24 > 0) {
+                totalTime.append(String.format("%d hours, ", duration.toHours() % 24));
+            }
+
+            if (duration.toMinutes() % 60 > 0) {
+                totalTime.append(String.format("%d minutes ", duration.toMinutes() % 60));
+            }
+            return totalTime;
+        }else return totalTime.append("");
+    }
+
+}

src/main/java/com/utopiaindustries/service/StoreService.java

@@ -0,0 +1,19 @@
+package com.utopiaindustries.service;
+
+import com.utopiaindustries.dao.ctp.PackagingItemsDAO;
+import com.utopiaindustries.model.ctp.FinishedItemWrapper;
+import org.springframework.stereotype.Service;
+
+@Service
+public class StoreService {
+
+    private final InventoryService inventoryService;
+
+    public StoreService(InventoryService inventoryService, PackagingItemsDAO packagingItemsDAO) {
+        this.inventoryService = inventoryService;
+    }
+
+    public void createStoreItems(FinishedItemWrapper wrapper ) {
+        inventoryService.createStoreItemAndTransaction(wrapper, wrapper.getAccountId());
+    }
+}

src/main/java/com/utopiaindustries/util/CustomTagWorkerFactory.java

@@ -0,0 +1,16 @@
+package com.utopiaindustries.util;
+
+import com.itextpdf.html2pdf.attach.ITagWorker;
+import com.itextpdf.html2pdf.attach.ProcessorContext;
+import com.itextpdf.html2pdf.attach.impl.DefaultTagWorkerFactory;
+import com.itextpdf.html2pdf.html.TagConstants;
+import com.itextpdf.styledxmlparser.node.IElementNode;
+
+public class CustomTagWorkerFactory extends DefaultTagWorkerFactory {
+    public ITagWorker getCustomTagWorker( IElementNode tag, ProcessorContext context) {
+        if ( TagConstants.HTML.equals(tag.name())) {
+            return new ZeroMarginHtmlTagWorker(tag, context);
+        }
+        return null;
+    }
+}

src/main/java/com/utopiaindustries/util/HTMLBuilder.java

@@ -0,0 +1,90 @@
+package com.utopiaindustries.util;
+
+import com.utopiaindustries.dialect.CTPDialect;
+import org.springframework.stereotype.Component;
+import org.springframework.ui.Model;
+import org.springframework.ui.ModelMap;
+import org.thymeleaf.TemplateEngine;
+import org.thymeleaf.context.Context;
+import org.thymeleaf.templatemode.TemplateMode;
+import org.thymeleaf.templateresolver.ClassLoaderTemplateResolver;
+import org.w3c.tidy.Tidy;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.UnsupportedEncodingException;
+import java.nio.charset.StandardCharsets;
+import java.util.Map;
+
+@Component
+public class HTMLBuilder {
+    private final String UTF_8 = StandardCharsets.UTF_8.displayName();
+
+    public String buildHTML( String templateName, Model model ) throws Exception {
+        // template resolver
+        ClassLoaderTemplateResolver pdfTemplateResolver = createPDFTemplateResolver();
+        // template engine
+        TemplateEngine templateEngine = new TemplateEngine();
+        templateEngine.setTemplateResolver( pdfTemplateResolver );
+        templateEngine.addDialect( new CTPDialect() );
+        // context
+        Context ctx = configureContext( model );
+        // render the template
+        String renderedHTMLContent = templateEngine.process( templateName, ctx );
+        return convertToXhtml( renderedHTMLContent );
+    }
+
+    public String buildHTMLMap( String templateName, ModelMap model ) throws Exception {
+        // template resolver
+        ClassLoaderTemplateResolver pdfTemplateResolver = createPDFTemplateResolver();
+        // template engine
+        TemplateEngine templateEngine = new TemplateEngine();
+        templateEngine.setTemplateResolver( pdfTemplateResolver );
+        templateEngine.addDialect( new CTPDialect() );
+        // context
+        Context ctx = configureContextMap( model );
+        // render the template
+        String renderedHTMLContent = templateEngine.process( templateName, ctx );
+        return convertToXhtml( renderedHTMLContent );
+    }
+
+    private String convertToXhtml( String html ) throws UnsupportedEncodingException {
+        Tidy tidy = new Tidy();
+        tidy.setInputEncoding( UTF_8 );
+        tidy.setOutputEncoding( UTF_8 );
+        tidy.setXHTML( true );
+        ByteArrayInputStream inputStream = new ByteArrayInputStream( html.getBytes( UTF_8 ) );
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        tidy.parseDOM( inputStream, outputStream );
+        return outputStream.toString( UTF_8 );
+    }
+
+    private ClassLoaderTemplateResolver createPDFTemplateResolver() {
+        ClassLoaderTemplateResolver pdfTemplateResolver = new ClassLoaderTemplateResolver();
+        pdfTemplateResolver.setPrefix( "/templates/" );
+        pdfTemplateResolver.setTemplateMode( TemplateMode.HTML );
+        pdfTemplateResolver.setSuffix( ".html" );
+        pdfTemplateResolver.setCharacterEncoding( UTF_8 );
+        pdfTemplateResolver.setOrder( 1 );
+        return pdfTemplateResolver;
+    }
+
+    private Context configureContext( Model model ) {
+        Context ctx = new Context();
+        // adding model attributes to context
+        for ( Map.Entry<String, Object> entry: model.asMap().entrySet() ) {
+            ctx.setVariable( entry.getKey(), entry.getValue() );
+        }
+        return ctx;
+    }
+
+    private Context configureContextMap( ModelMap model ) {
+        Context ctx = new Context();
+        // adding model attributes to context
+        for ( Map.Entry<String, Object> entry: model.entrySet() ) {
+            ctx.setVariable( entry.getKey(), entry.getValue() );
+        }
+        return ctx;
+    }
+}
+

src/main/java/com/utopiaindustries/util/PDFResponseEntityInputStreamResource.java

@@ -0,0 +1,110 @@
+package com.utopiaindustries.util;
+
+import com.itextpdf.html2pdf.ConverterProperties;
+import com.itextpdf.html2pdf.HtmlConverter;
+import com.itextpdf.html2pdf.resolver.font.DefaultFontProvider;
+import com.itextpdf.kernel.geom.PageSize;
+import com.itextpdf.kernel.geom.Rectangle;
+import com.itextpdf.kernel.pdf.PdfDocument;
+import com.itextpdf.kernel.pdf.PdfWriter;
+import com.itextpdf.layout.Document;
+import org.springframework.core.io.InputStreamResource;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Component;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+@Component
+public class PDFResponseEntityInputStreamResource {
+
+    /**
+     * prepare pdf document from html string
+     */
+    private ResponseEntity<InputStreamResource> createPDFResponseEntityInputStreamResource( String htmlStr, String filename, String method ) throws IOException {
+        // output stream
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        // converter properties
+        ConverterProperties properties = new ConverterProperties();
+        properties.setFontProvider( new DefaultFontProvider( false, false, true ) );
+        // pdf document
+        PdfWriter writer = new PdfWriter( outputStream );
+        //temp Code
+/*		PdfDocument temp = new PdfDocument(writer);
+		Rectangle rectangle3x5 = new Rectangle(216, 360);
+		PageSize pageSize =new PageSize( rectangle3x5 );
+		temp.setDefaultPageSize( pageSize);
+		properties.setTagWorkerFactory( new CustomTagWorkerFactory() );*/
+        //temp code end
+        Document document = HtmlConverter.convertToDocument( htmlStr, writer, properties );
+        document.close();
+        // input stream
+        ByteArrayInputStream inputStream = new ByteArrayInputStream( outputStream.toByteArray() );
+        // content disposition header
+        String headerContentDispositionStr = String.format( "%s; filename=%s.pdf", method, filename.replaceAll( ",", "-" ) );
+        // return response
+        return ResponseEntity
+                .ok()
+                .header( HttpHeaders.CONTENT_DISPOSITION, headerContentDispositionStr )
+                .contentType( MediaType.APPLICATION_PDF )
+                .body( new InputStreamResource( inputStream ) );
+    }
+
+    /**
+     * prepare pdf document from html string
+     */
+    private ResponseEntity<InputStreamResource> createPDFResponseEntityInvoiceInputStreamResource( String htmlStr, String filename, String method, long height, long width )
+            throws IOException {
+        // output stream
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        // converter properties
+        ConverterProperties properties = new ConverterProperties();
+        properties.setFontProvider( new DefaultFontProvider( false, true, false ) );
+        // pdf document
+        PdfWriter writer = new PdfWriter( outputStream );
+        //Code for invoice slips
+        PdfDocument temp = new PdfDocument( writer );
+        Rectangle rectangle3x5 = new Rectangle( width, height );
+        PageSize pageSize = new PageSize( rectangle3x5 );
+        temp.setDefaultPageSize( pageSize );
+        properties.setTagWorkerFactory( new CustomTagWorkerFactory() );
+        //temp code end
+        Document document = HtmlConverter.convertToDocument( htmlStr, temp, properties );
+        //document.setFontSize( 200.0f );
+        document.close();
+        // input stream
+        ByteArrayInputStream inputStream = new ByteArrayInputStream( outputStream.toByteArray() );
+        // content disposition header
+        String headerContentDispositionStr = String.format( "%s; filename=%s.pdf", method, filename.replaceAll( ",", "-" ) );
+        // return response
+        return ResponseEntity
+                .ok()
+                .header( HttpHeaders.CONTENT_DISPOSITION, headerContentDispositionStr )
+                .contentType( MediaType.APPLICATION_PDF )
+                .body( new InputStreamResource( inputStream ) );
+    }
+
+    /**
+     * with inline as default content disposition "inline"
+     */
+    public ResponseEntity<InputStreamResource> generatePdf( String htmlStr, String filename ) throws IOException {
+        return this.createPDFResponseEntityInputStreamResource( htmlStr, filename, "inline" );
+    }
+
+    /**
+     * manual content disposition
+     */
+    public ResponseEntity<InputStreamResource> generatePdf( String htmlStr, String filename, String method ) throws IOException {
+        return this.createPDFResponseEntityInputStreamResource( htmlStr, filename, method );
+    }
+
+    /**
+     * manual content disposition
+     */
+    public ResponseEntity<InputStreamResource> generateInvoicePdf( String htmlStr, String filename, String method, long height, long width ) throws IOException {
+        return this.createPDFResponseEntityInvoiceInputStreamResource( htmlStr, filename, method, height, width );
+    }
+}

src/main/java/com/utopiaindustries/util/URLUtils.java

@@ -0,0 +1,16 @@
+package com.utopiaindustries.util;
+
+import org.springframework.web.context.request.RequestContextHolder;
+import org.springframework.web.context.request.ServletRequestAttributes;
+
+import javax.servlet.http.HttpServletRequest;
+
+public class URLUtils {
+
+    public static String getCurrentBaseUrl() {
+        ServletRequestAttributes sra = ( ServletRequestAttributes ) RequestContextHolder.getRequestAttributes();
+        HttpServletRequest req = sra.getRequest();
+        return req.getScheme() + "://" + req.getServerName() + ":" + req.getServerPort() + req.getContextPath();
+    }
+}
+

src/main/java/com/utopiaindustries/util/ZeroMarginHtmlTagWorker.java

@@ -0,0 +1,15 @@
+package com.utopiaindustries.util;
+
+import com.itextpdf.html2pdf.attach.ProcessorContext;
+import com.itextpdf.html2pdf.attach.impl.tags.HtmlTagWorker;
+import com.itextpdf.layout.Document;
+import com.itextpdf.styledxmlparser.node.IElementNode;
+
+public class ZeroMarginHtmlTagWorker extends HtmlTagWorker {
+    public ZeroMarginHtmlTagWorker( IElementNode element, ProcessorContext context) {
+        super(element, context);
+        Document doc = (Document) getElementResult();
+        doc.setMargins(0, 0, 0, 0);
+    }
+}
+

src/main/resources/application-dev.yml

@@ -0,0 +1,34 @@
+spring:
+  uinddatasource:
+    jdbcUrl: jdbc:mysql://utopia-industries-rr.c5qech8o9lgg.us-east-1.rds.amazonaws.com:3306/inventory
+    username: cut-to-pack
+    password: mAzFAivImnTqKJx4KNJ0
+    driverClassName: com.mysql.cj.jdbc.Driver
+    logbackUrl: jdbc:mysql://192.168.90.147:3306/uind_logs?serverTimezone=Asia/Karachi
+    hikari:
+      maximum-pool-size: 5
+      pool-name: UINDMainPool
+      leak-detection-threshold: 2000
+  cosmosdatasource:
+    jdbcUrl: jdbc:mysql://192.168.90.147:3307
+    username: utopia
+    password: Utopia01
+    driverClassName: com.mysql.cj.jdbc.Driver
+    hikari:
+      maximum-pool-size: 5
+      pool-name: UINDCosmosPool
+      leak-detection-threshold: 2000
+  localdatasource:
+    jdbcUrl: jdbc:mysql://localhost:3306/cut_to_pack
+    username: utopia
+    password: Utopia01
+    driverClassName: com.mysql.cj.jdbc.Driver
+    hikari:
+      maximum-pool-size: 5
+      pool-name: CTPPool
+      leak-detection-threshold: 2000
+
+ctp:
+  printer:
+    ipAdd: 192.168.90.160
+    port: 9100