diff --git a/app/build.gradle b/app/build.gradle index 80bb4cbd..84f2115f 100644 --- a/app/build.gradle +++ b/app/build.gradle @@ -10,8 +10,8 @@ apply plugin: 'com.google.gms.google-services' android { - def appVersionCode = 413 - def appVersionName = '1.39.00' + def appVersionCode = 414 + def appVersionName = '1.39.01' signingConfigs { release { diff --git a/app/src/main/java/it/integry/integrywmsnative/MainApplicationModule.java b/app/src/main/java/it/integry/integrywmsnative/MainApplicationModule.java index a86f047a..e07a6e5d 100644 --- a/app/src/main/java/it/integry/integrywmsnative/MainApplicationModule.java +++ b/app/src/main/java/it/integry/integrywmsnative/MainApplicationModule.java @@ -16,6 +16,7 @@ import it.integry.integrywmsnative.core.context.AppContext; import it.integry.integrywmsnative.core.context.MainContext; import it.integry.integrywmsnative.core.data_recover.ColliDataRecoverService; import it.integry.integrywmsnative.core.data_store.db.AppDatabase; +import it.integry.integrywmsnative.core.ean128.Ean128Service; import it.integry.integrywmsnative.core.menu.MenuRESTConsumer; import it.integry.integrywmsnative.core.menu.MenuService; import it.integry.integrywmsnative.core.rest.consumers.ArticoloRESTConsumer; @@ -43,6 +44,7 @@ import it.integry.integrywmsnative.core.rest.consumers.ProductionLinesRESTConsum import it.integry.integrywmsnative.core.rest.consumers.SystemRESTConsumer; import it.integry.integrywmsnative.core.services.inventario.InventarioService; import it.integry.integrywmsnative.core.settings.SettingsManager; +import it.integry.integrywmsnative.core.sound.SoundAlertService; import it.integry.integrywmsnative.core.update.UpdatesManager; import it.integry.integrywmsnative.gest.contab_doc_interni.rest.DocInterniRESTConsumer; import it.integry.integrywmsnative.gest.prod_fabbisogno_linee_prod.rest.ProdFabbisognoLineeProdRESTConsumer; @@ -102,6 +104,12 @@ public class MainApplicationModule { return colliDataRecoverService; } + @Provides + @Singleton + Ean128Service provideEan128Service() { + return new Ean128Service(); + } + @Provides @Singleton MenuService provideMenuService(MenuRESTConsumer menuRESTConsumer) { @@ -197,8 +205,8 @@ public class MainApplicationModule { @Provides @Singleton - BarcodeRESTConsumer provideBarcodeRESTConsumer() { - return new BarcodeRESTConsumer(); + BarcodeRESTConsumer provideBarcodeRESTConsumer(Ean128Service ean128Service) { + return new BarcodeRESTConsumer(ean128Service); } @Provides @@ -291,4 +299,12 @@ public class MainApplicationModule { return new MagazzinoBufferRESTConsumer(); } + @Provides + @Singleton + SoundAlertService provideSoundAlertService() { + SoundAlertService soundAlertService = new SoundAlertService(mApplication.getApplicationContext()); + soundAlertService.init(); + return soundAlertService; + } + } diff --git a/app/src/main/java/it/integry/integrywmsnative/core/barcode_reader/BarcodeManager.java b/app/src/main/java/it/integry/integrywmsnative/core/barcode_reader/BarcodeManager.java index 24889430..df16aa11 100644 --- a/app/src/main/java/it/integry/integrywmsnative/core/barcode_reader/BarcodeManager.java +++ b/app/src/main/java/it/integry/integrywmsnative/core/barcode_reader/BarcodeManager.java @@ -75,7 +75,7 @@ public class BarcodeManager { var scanMode = sharedPreferences.getString(MainSettingsFragment.KEY_TRIGGER_SCAN_MODE, null); var scanModeSetting = new Pair(BarcodeSetting.P_TRIGGER_SCAN_MODE, scanMode); additionalSettings.add(scanModeSetting); - + BarcodeManager.changeSettings(additionalSettings); }); diff --git a/app/src/main/java/it/integry/integrywmsnative/core/base/Callable.java b/app/src/main/java/it/integry/integrywmsnative/core/base/Callable.java new file mode 100644 index 00000000..2e03ad43 --- /dev/null +++ b/app/src/main/java/it/integry/integrywmsnative/core/base/Callable.java @@ -0,0 +1,5 @@ +package it.integry.integrywmsnative.core.base; + +public interface Callable { + O call(I input); +} diff --git a/app/src/main/java/it/integry/integrywmsnative/core/base/CallableII.java b/app/src/main/java/it/integry/integrywmsnative/core/base/CallableII.java new file mode 100644 index 00000000..18c982a8 --- /dev/null +++ b/app/src/main/java/it/integry/integrywmsnative/core/base/CallableII.java @@ -0,0 +1,5 @@ +package it.integry.integrywmsnative.core.base; + +public interface CallableII { + O call(I input, L input2); +} \ No newline at end of file diff --git a/app/src/main/java/it/integry/integrywmsnative/core/ean128/Ean128AI.java b/app/src/main/java/it/integry/integrywmsnative/core/ean128/Ean128AI.java new file mode 100644 index 00000000..9cd47532 --- /dev/null +++ b/app/src/main/java/it/integry/integrywmsnative/core/ean128/Ean128AI.java @@ -0,0 +1,127 @@ +package it.integry.integrywmsnative.core.ean128; + +public enum Ean128AI { + + + NULL, //Valore nullo (usato solo in logica) + SSCC, //Numero sequenziale del collo n2+n18 + GTIN, //Codice EAN/UCC unità logistica n2+n14 + CONTENT, //Codice EAN/UCC dei prodotti contenuti all'interno di unità log n2+n14 + BATCH_LOT, //Numero del lotto di fabbricazione n2+an.20 + PROD_DATE, //Data di produzione (yymmdd) 0~50 (2000~2050) - 51~99 (1951~1999) n2+n6 + DUE_DATE, //Data di scadenza pagamento fattura n2+n6 + PACK_DATE, //Data di confezionamento n2+n6 + BEST_BEFORE,//Data minima di validità n2+n6 + EXPIRY, //Data massima di validità n2+n6 + VARIANT, //Variante di prodotto - uso interno aziendale n2+n2 + SERIAL, //Numero di serie n2+an.20 + QTY_DATE_BATCH, //Dati supplementari per prodotti farmaceutici n2+an.29 + ADDITIONAL_ID, //Numedi di identificazione supplementare del prodotto n3+an.30 + CUST_PART_NO, //Codice prodotto interno del cliente n3+an.30 + SECONDARY_SERIAL, //Numero di serie secondario n3+an.30 + REF_TO_SOURCE, //Entità di origine o marca auricolare n3+an.30 + VAR_COUNT, //Quantità variabile n2+n.8 + + //Misure commerciali e logistiche FORMATO: n4+n6 + NET_WEIGHT_KG, //Peso netto in Kg + LENGTH_M, //Lunghezza o 1° dimensione, in mt, uso commerciale + WIDTH_M, //Larghezza, diametro o 2° dimensione, in mt, uso commerciale + HEIGHT_M, //Profondità, spessore, altezza o 3° dimensione, in mt, uso commerciale + AREA_M2, //Superficie, in metriquadri, uso commerciale + NET_VOLUME_L, //Volume, in litri, uso commerciale + NET_VOLUME_M3, //Volume, in metricubi, uso commerciale + NET_WEIGHT_LB, //Peso netto, in libbre, uso commerciale + LENGTH_I, //Lunghezza o 1° dimensione, in pollici, uso commerciale + LENGTH_F, //Lunghezza o 1° dimensione, in piedi, uso commerciale + LENGTH_Y, //Lunghezza o 1° dimensione, in yards, uso commerciale + WIDTH_I, //Larghezza, diametro o 2° dimensione, in pollici, uso commerciale + WIDTH_F, //Larghezza, diametro o 2° dimensione, in piedi, uso commerciale + WIDTH_Y, //Larghezza, diametro o 2° dimensione, in yards, uso commerciale + HEIGHT_I, //Profondità, spessore, altezza o 3° dimensione, in pollici, uso commerciale + HEIGHT_F, //Profondità, spessore, altezza o 3° dimensione, in piedi, uso commerciale + HEIGHT_Y, //Profondità, spessore, altezza o 3° dimensione, in yards, uso commerciale + CROSSWEIGHT_KG_LOG, //Peso lordo, in Kg, uso logistico + LENGTH_M_LOG, //Lunghezza o 1° dimensione, in metri, uso logistico + WIDTH_M_LOG, //Larghezza, diametro o 2° dimensione, in metri, uso logistico + HEIGHT_M_LOG, //Profondità, spessore, altezza o 3° dimensione, in metri, uso logistico + AREA_M2_LOG, //Superficie, in metriquadri, uso logistico + VOLUME_L_LOG, //Volume lordo, in litri, uso logistico + VOLUME_M3_LOG, //Volume lordo, in metricubi, uso logistico + CROSSWEIGHT_LB_LOG, //Peso lordo, in libbre, uso logistico + LENGTH_I_LOG, //Lunghezza o 1° dimensione, in pollici, uso logistico + LENGTH_F_LOG, //Lunghezza o 1° dimensione, in piedi, uso logistico + LENGTH_Y_LOG, //Lunghezza o 1° dimensione, in yards, uso logistico + WIDTH_I_LOG, //Larghezza, diametro o 2° dimensione, in pollici, uso logistico + WIDTH_F_LOG, //Larghezza, diametro o 2° dimensione, in piedi, uso logistico + WIDTH_Y_LOG, //Larghezza, diametro o 2° dimensione, in yards, uso logistico + HEIGHT_I_LOG, //Profondità, spessore, altezza o 3° dimensione, in pollici, uso logistico + HEIGHT_F_LOG, //Profondità, spessore, altezza o 3° dimensione, in piedi, uso logistico + HEIGHT_Y_LOG, //Profondità, spessore, altezza o 3° dimensione, in yards, uso logistico + AREA_I2, //Superficie, in pollici quadrati, uso commerciale + AREA_F2, //Superficie, in piedi quadrati, uso commerciale + AREA_Y2, //Superficie, in yards quadrati, uso commerciale + AREA_I2_LOG, //Superficie, in pollici quadrati, uso logistico + AREA_F2_LOG, //Superficie, in piedi quadrati, uso logistico + AREA_Y2_LOG, //Superficie, in yards quadrati, uso logistico + NET_WEIGHT_T, //Peso netto, in once troy, uso commerciale + NET_VOLUME_OZ, //Volume netto, in once (U.S.), uso commerciale + NET_VOLUME_LB, //Volume netto, in quarti di gallone, uso commerciale + NET_VOLUME_G, //Volume netto, in galloni (U.S.), uso commerciale + VOLUME_Q_LOG, //Volume lordo, in quarti di gallone, uso logistico + VOLUME_G_LOG, //Volume lordo, in galloni (U.S.), uso logistico + NET_VOLUME_I3, //Volume netto, in pollici cubi, uso commerciale + NET_VOLUME_F3, //Volume netto, in piedi cubi, uso commerciale + NET_VOLUME_Y3, //Volume netto, in yards cubi, uso commerciale + VOLUME_I3_LOG, //Volume lordo, in pollici cubi, uso logistico + VOLUME_F3_LOG, //Volume lordo, in piedi cubi, uso logistico + VOLUME_Y3_LOG, //Volume lordo, in yards cubi, uso logistico + COUNT, //Quantità prodotti contenuti in un'unità logistica + AMOUNT, //Importo da pagare singola area monetaria + AMOUNT_ISO, //Importo da pagare con codice valuta ISO + PRICE, //Importo da pagare singola unità monetaria (prodotti a peso variabile) + PRICE_ISO, //Importo da pagare con codice valuta ISO (prodotti a peso variabile) + ORDER_NUMBER, //Numero d'ordine d'acquisto cliente + CONSIGNMENT, //Numero di consegna + SHIPMENT_NO, //Numero di spedizione + ROUTE, //Codice di smistamento pacchi + SHIP_TO_LOC, //Codice di locazione EAN/UCC "Spedire a, Consegnare a" + BILL_TO_LOC, //Codice di locazione EAN/UCC "Fatturare a" + PURCHASE_FROM_LOC, //Codice di locazione EAN/UCC "Acquistato da" + SHIP_FOR_LOC, //Codice di locazione EAN/UCC "Sperdire per, Consegnare per, Inoltrare a" + LOC_NO, //Codice di locazione EAN/UCC: identificazione di una locazione fisica + PAY_TO_LOC, //Codice di locazione EAN/UCC di chi emette la fattura + SHIP_TO_POST, //Codice postale "Spedire a, Consegnare a" (nazionale) + SHIP_TO_POST_ISO, //Codice postale "Spedire a, Consegnare a" con codice nazione ISO + ORIGIN, //Paese di origine del prodotto + COUNTRY_INITIAL_PROCESS, //Paese di lavorazione iniziale del prodotto con codice nazionale ISO + COUNTRY_PROCESS, //Paese di lavorazione con codice nazionale ISO + COUNTRY_DISASSEMBLY, //Paese di scomposizione con codice nazionale ISO + COUNTRY_FULL_PROCESS,//Paese di lavorazione completa con codice nazionale ISO + NSN, //Numero di stock NATO + MEAT_CUT, //Carcasse animali e classificazione dei tagli UN/ECE + PROCESSORS, //Numero di approvazione del laboratorio di lavorazione intermedio con codice nazionale ISO + DIMENSIONS, //Prodotti in rotoli - larghezza, lunghezza, diametro interno, senso di svolgimento e giunte + CMT_NO, //Numero sequenziale elettronico per applicazioni di telefonia cellulare + GRAI, //Numero di identificazione per beni a rendere, + GIAI, //Numero di identificazione globale per beni individuali + PRICE_PER_UNIT, //Prezzo per unità di misura + GCTIN, //Identificazione dei componenti di un prodotto + IBAN, //Numero di contocorrente bancario internazionale + PROD_TIME, //Data e ora di produzione + GSRN, //Numedo Globale di Relazione di Servizio + REF_NO, //Numero del bollettino di pagamento + COUPON_1, //Codice esteso per i coupons, UCC + COUPON_2, //Codice esteso per i coupons, UCC + COUPON_3, //Codice esteso per i coupons, UCC + INTERNAL_PART, //Informazioni concordate tra i partners commerciali + INTERNAL_1, //Informazioni interne + INTERNAL_2, //Informazioni interne + INTERNAL_3, //Informazioni interne + INTERNAL_4, //Informazioni interne + INTERNAL_5, //Informazioni interne + INTERNAL_6, //Informazioni interne + INTERNAL_7, //Informazioni interne + INTERNAL_8, //Informazioni interne + INTERNAL_9, //Informazioni interne + +} diff --git a/app/src/main/java/it/integry/integrywmsnative/core/ean128/Ean128AIModel.java b/app/src/main/java/it/integry/integrywmsnative/core/ean128/Ean128AIModel.java new file mode 100644 index 00000000..c7cb5aea --- /dev/null +++ b/app/src/main/java/it/integry/integrywmsnative/core/ean128/Ean128AIModel.java @@ -0,0 +1,40 @@ +package it.integry.integrywmsnative.core.ean128; + +public class Ean128AIModel implements Cloneable { + + + public Ean128AI AI; + + public String code; + + public int dataLength; + + public boolean flagVariableLength; + + public boolean flagOnlyNumeric; + + public int decimalDigits; + + public Ean128AIModel(Ean128AI AI, String code, int dataLength, boolean flagVariableLength, boolean flagOnlyNumeric, int decimalDigits) { + this.AI = AI; + this.code = code; + this.dataLength = dataLength; + this.flagVariableLength = flagVariableLength; + this.flagOnlyNumeric = flagOnlyNumeric; + this.decimalDigits = decimalDigits; + } + + public Ean128AIModel(Ean128AI AI, String code, int dataLength, boolean flagVariableLength, boolean flagOnlyNumeric) { + this.AI = AI; + this.code = code; + this.dataLength = dataLength; + this.flagVariableLength = flagVariableLength; + this.flagOnlyNumeric = flagOnlyNumeric; + } + + protected Object clone() throws CloneNotSupportedException { + return super.clone(); + } + + +} diff --git a/app/src/main/java/it/integry/integrywmsnative/core/ean128/Ean128AIModelBij.java b/app/src/main/java/it/integry/integrywmsnative/core/ean128/Ean128AIModelBij.java new file mode 100644 index 00000000..a4a99183 --- /dev/null +++ b/app/src/main/java/it/integry/integrywmsnative/core/ean128/Ean128AIModelBij.java @@ -0,0 +1,209 @@ +package it.integry.integrywmsnative.core.ean128; + +import java.util.regex.MatchResult; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +public class Ean128AIModelBij { + + private final Ean128AIModel[] _aiModelArray = new Ean128AIModel[]{ + new Ean128AIModel(Ean128AI.SSCC, "^00", 18, false, true), + new Ean128AIModel(Ean128AI.GTIN, "^01", 14, false, true), + new Ean128AIModel(Ean128AI.CONTENT, "^02", 14, false, true), + new Ean128AIModel(Ean128AI.BATCH_LOT, "^10", 20, true, false), + new Ean128AIModel(Ean128AI.PROD_DATE, "^11", 6, false, true), + new Ean128AIModel(Ean128AI.DUE_DATE, "^12", 6, false, true), + new Ean128AIModel(Ean128AI.PACK_DATE, "^13", 6, false, true), + new Ean128AIModel(Ean128AI.BEST_BEFORE, "^15", 6, false, true), + new Ean128AIModel(Ean128AI.EXPIRY, "^17", 6, false, true), + new Ean128AIModel(Ean128AI.VARIANT, "^20", 2, false, true), + new Ean128AIModel(Ean128AI.SERIAL, "^21", 20, true, false), + new Ean128AIModel(Ean128AI.QTY_DATE_BATCH, "^22", 29, true, false), + new Ean128AIModel(Ean128AI.ADDITIONAL_ID, "^240", 30, true, false), + new Ean128AIModel(Ean128AI.CUST_PART_NO, "^241", 30, true, false), + new Ean128AIModel(Ean128AI.SECONDARY_SERIAL, "^250", 30, true, false), + new Ean128AIModel(Ean128AI.REF_TO_SOURCE, "^251", 30, true, false), + new Ean128AIModel(Ean128AI.VAR_COUNT, "^30", 8, true, true), + new Ean128AIModel(Ean128AI.NET_WEIGHT_KG, "^310(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.LENGTH_M, "^311(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.WIDTH_M, "^312(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.HEIGHT_M, "^313(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.AREA_M2, "^314(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.NET_VOLUME_L, "^315(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.NET_VOLUME_M3, "^316(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.NET_WEIGHT_LB, "^320(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.LENGTH_I, "^321(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.LENGTH_F, "^322(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.LENGTH_Y, "^323(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.WIDTH_I, "^324(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.WIDTH_F, "^325(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.WIDTH_Y, "^326(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.HEIGHT_I, "^327(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.HEIGHT_F, "^328(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.HEIGHT_Y, "^329(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.CROSSWEIGHT_KG_LOG, "^330(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.LENGTH_M_LOG, "^331(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.WIDTH_M_LOG, "^332(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.HEIGHT_M_LOG, "^333(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.AREA_M2_LOG, "^334(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.VOLUME_L_LOG, "^335(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.VOLUME_M3_LOG, "^336(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.CROSSWEIGHT_LB_LOG, "^340(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.LENGTH_I_LOG, "^341(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.LENGTH_F_LOG, "^342(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.LENGTH_Y_LOG, "^343(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.WIDTH_I_LOG, "^344(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.WIDTH_F_LOG, "^345(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.WIDTH_Y_LOG, "^346(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.HEIGHT_I_LOG, "^347(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.HEIGHT_F_LOG, "^348(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.HEIGHT_Y_LOG, "^349(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.AREA_I2, "^350(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.AREA_F2, "^351(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.AREA_Y2, "^352(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.AREA_I2_LOG, "^353(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.AREA_F2_LOG, "^354(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.AREA_Y2_LOG, "^355(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.NET_WEIGHT_T, "^356(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.NET_VOLUME_OZ, "^357(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.NET_VOLUME_LB, "^360(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.NET_VOLUME_G, "^361(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.VOLUME_Q_LOG, "^362(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.VOLUME_G_LOG, "^363(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.NET_VOLUME_I3, "^364(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.NET_VOLUME_F3, "^365(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.NET_VOLUME_Y3, "^366(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.VOLUME_I3_LOG, "^367(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.VOLUME_F3_LOG, "^368(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.VOLUME_Y3_LOG, "^369(\\d{1})", 6, false, true), + new Ean128AIModel(Ean128AI.COUNT, "^37", 8, true, true), + new Ean128AIModel(Ean128AI.AMOUNT, "^390(\\d{1})", 15, true, true), + new Ean128AIModel(Ean128AI.AMOUNT_ISO, "^391(\\d{1})", 18, true, true), + new Ean128AIModel(Ean128AI.PRICE, "^392(\\d{1})", 15, true, true), + new Ean128AIModel(Ean128AI.PRICE_ISO, "^393(\\d{1})", 18, true, true), + new Ean128AIModel(Ean128AI.ORDER_NUMBER, "^400", 30, true, false), + new Ean128AIModel(Ean128AI.CONSIGNMENT, "^401", 30, true, false), + new Ean128AIModel(Ean128AI.SHIPMENT_NO, "^402", 17, false, true), + new Ean128AIModel(Ean128AI.ROUTE, "^403", 30, true, false), + new Ean128AIModel(Ean128AI.SHIP_TO_LOC, "^410", 13, false, true), + new Ean128AIModel(Ean128AI.BILL_TO_LOC, "^411", 13, false, true), + new Ean128AIModel(Ean128AI.PURCHASE_FROM_LOC, "^412", 13, false, true), + new Ean128AIModel(Ean128AI.SHIP_FOR_LOC, "^413", 13, false, true), + new Ean128AIModel(Ean128AI.LOC_NO, "^414", 13, false, true), + new Ean128AIModel(Ean128AI.PAY_TO_LOC, "^415", 13, false, true), + new Ean128AIModel(Ean128AI.SHIP_TO_POST, "^420", 20, true, false), + new Ean128AIModel(Ean128AI.SHIP_TO_POST_ISO, "^421", 12, true, false), + new Ean128AIModel(Ean128AI.ORIGIN, "^422", 3, false, true), + new Ean128AIModel(Ean128AI.COUNTRY_INITIAL_PROCESS, "^423", 15, true, true), + new Ean128AIModel(Ean128AI.COUNTRY_PROCESS, "^424", 3, false, true), + new Ean128AIModel(Ean128AI.COUNTRY_DISASSEMBLY, "^425", 3, false, true), + new Ean128AIModel(Ean128AI.COUNTRY_FULL_PROCESS, "^426", 3, false, true), + new Ean128AIModel(Ean128AI.NSN, "^7001", 13, false, true), + new Ean128AIModel(Ean128AI.MEAT_CUT, "^7002", 30, true, false), + new Ean128AIModel(Ean128AI.DIMENSIONS, "^8001", 14, false, true), + new Ean128AIModel(Ean128AI.CMT_NO, "^8002", 20, true, false), + new Ean128AIModel(Ean128AI.GRAI, "^8003", 30, true, false), + new Ean128AIModel(Ean128AI.GIAI, "^8004", 30, true, false), + new Ean128AIModel(Ean128AI.PRICE_PER_UNIT, "^8005", 6, false, true), + new Ean128AIModel(Ean128AI.GCTIN, "^8006", 18, false, false), + new Ean128AIModel(Ean128AI.IBAN, "^8007", 30, true, false), + new Ean128AIModel(Ean128AI.PROD_TIME, "^8008", 12, true, true), + new Ean128AIModel(Ean128AI.GSRN, "^8018", 18, false, true), + new Ean128AIModel(Ean128AI.REF_NO, "^8020", 25, true, false), + new Ean128AIModel(Ean128AI.COUPON_1, "^8100", 6, false, true), + new Ean128AIModel(Ean128AI.COUPON_2, "^8101", 10, false, true), + new Ean128AIModel(Ean128AI.COUPON_3, "^8102", 2, false, true), + new Ean128AIModel(Ean128AI.INTERNAL_PART, "^90", 30, true, false), + new Ean128AIModel(Ean128AI.INTERNAL_1, "^91", 30, true, false), + new Ean128AIModel(Ean128AI.INTERNAL_2, "^92", 30, true, false), + new Ean128AIModel(Ean128AI.INTERNAL_3, "^93", 30, true, false), + new Ean128AIModel(Ean128AI.INTERNAL_4, "^94", 30, true, false), + new Ean128AIModel(Ean128AI.INTERNAL_5, "^95", 30, true, false), + new Ean128AIModel(Ean128AI.INTERNAL_6, "^96", 30, true, false), + new Ean128AIModel(Ean128AI.INTERNAL_7, "^97", 30, true, false), + new Ean128AIModel(Ean128AI.INTERNAL_8, "^98", 30, true, false), + new Ean128AIModel(Ean128AI.INTERNAL_9, "^99", 30, true, false) + }; + + + public int checkAI(String aiToCheck) { + int count = -1; + + if (aiToCheck.length() > 1) { + for (int i = 0; i < _aiModelArray.length; i++) { + final String groupSeparatorCharInHexForRegex = "\\x1D"; + String codePattern = ""; + + if (aiToCheck.charAt(0) == (char) 29) { + codePattern += groupSeparatorCharInHexForRegex; + } + + codePattern += _aiModelArray[i].code; + + + Pattern pattern = Pattern.compile(codePattern, Pattern.CASE_INSENSITIVE); + Matcher matcher = pattern.matcher(aiToCheck); + + + if (matcher.find()) { + count = i; + MatchResult matchResult = matcher.toMatchResult(); + + if (matchResult.groupCount() >= 1) { + String digitsString = matchResult.group(1); + _aiModelArray[i].decimalDigits = Integer.parseInt(digitsString); + } + + break; + } + + } + + } + return count; + } + + + public Ean128AIModel readAI(String aiToSearch) { + + Ean128AIModel barcodeAIModel = null; + + for (Ean128AIModel singleBarcodeAIModel : _aiModelArray) { + final String groupSeparatorCharInHexForRegex = "\\x1D"; + String codePattern = ""; + + if (aiToSearch.charAt(0) == (char) 29) { + codePattern += groupSeparatorCharInHexForRegex; + } + + codePattern += singleBarcodeAIModel.code; + + + Pattern pattern = Pattern.compile(codePattern, Pattern.CASE_INSENSITIVE); + Matcher matcher = pattern.matcher(aiToSearch); + + if (matcher.matches()) { + try { + barcodeAIModel = (Ean128AIModel) singleBarcodeAIModel.clone(); + + MatchResult matchResult = matcher.toMatchResult(); + + if (matchResult.groupCount() > 1) { + String digitsString = matchResult.group(1); + barcodeAIModel.decimalDigits = Integer.parseInt(digitsString); + } + break; + } catch (CloneNotSupportedException e) { + e.printStackTrace(); + } + } + } + + return barcodeAIModel; + } + + public Ean128AIModel getAI(int index) { + return _aiModelArray[index]; + } + +} diff --git a/app/src/main/java/it/integry/integrywmsnative/core/ean128/Ean128ISOValueModel.java b/app/src/main/java/it/integry/integrywmsnative/core/ean128/Ean128ISOValueModel.java new file mode 100644 index 00000000..82aa3688 --- /dev/null +++ b/app/src/main/java/it/integry/integrywmsnative/core/ean128/Ean128ISOValueModel.java @@ -0,0 +1,8 @@ +package it.integry.integrywmsnative.core.ean128; + +public class Ean128ISOValueModel { + + public String ISOCode; + public T Value; + +} diff --git a/app/src/main/java/it/integry/integrywmsnative/core/ean128/Ean128Service.java b/app/src/main/java/it/integry/integrywmsnative/core/ean128/Ean128Service.java new file mode 100644 index 00000000..1a66bafa --- /dev/null +++ b/app/src/main/java/it/integry/integrywmsnative/core/ean128/Ean128Service.java @@ -0,0 +1,330 @@ +package it.integry.integrywmsnative.core.ean128; + +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.util.Date; + +import it.integry.barcode_base_android_library.model.BarcodeScanDTO; +import it.integry.integrywmsnative.core.base.Callable; +import it.integry.integrywmsnative.core.base.CallableII; +import it.integry.integrywmsnative.core.rest.model.Ean128Model; + +public class Ean128Service { + + public Ean128Model decode(BarcodeScanDTO barcodeScanDTO) throws Exception { + byte[] inputEan128ByteArr = barcodeScanDTO.getStringValue().replaceAll("" + ((char) 29), "|").getBytes(); + Ean128AIModelBij ean128AIModelBij = new Ean128AIModelBij(); + + String aiCodeBuffer = ""; + + Ean128Model model = new Ean128Model(); + + for (int i = 0; i < inputEan128ByteArr.length; i++) { + aiCodeBuffer += (char) inputEan128ByteArr[i]; + + if (aiCodeBuffer.startsWith("|")) { + aiCodeBuffer = aiCodeBuffer.substring(1); + } + + if (aiCodeBuffer.length() <= 5) { + int aiIndex = ean128AIModelBij.checkAI(aiCodeBuffer); + + if (aiIndex != -1) { + + Ean128AIModel aiModel = ean128AIModelBij.getAI(aiIndex); + + StringBuilder aiValue = new StringBuilder(); + + if (!aiModel.flagVariableLength) { + + for (int j = (i + 1); j < (i + 1) + aiModel.dataLength; j++) { + aiValue.append((char) inputEan128ByteArr[j]); + } + + //aiValue = barcodeAsString.Substring(i + 1, aiModel.DataLength); + i += aiModel.dataLength; + } else { + String tempBuffer = ""; + + i++; + + while (i < inputEan128ByteArr.length && i < (aiModel.dataLength + i)) { + byte currentChar = inputEan128ByteArr[i]; + + if (currentChar != 29 && currentChar != '|') { //Controllo carattere FNC1 + tempBuffer += (char) currentChar; + } else { + break; + } + + i++; + } + + aiValue = new StringBuilder(tempBuffer.replace("\r", "").replace("\n", "")); + } + + switch (aiModel.AI) { + case SSCC -> { + if (aiValue.length() > 0 && (aiValue.charAt(0) == '0' || aiValue.charAt(0) == '9')) { + aiValue = new StringBuilder(aiValue.substring(1)); + } + model.Sscc = aiValue.toString(); + } + case GTIN -> { + if (aiValue.length() > 0 && (aiValue.charAt(0) == '0' || aiValue.charAt(0) == '9')) { + aiValue = new StringBuilder(aiValue.substring(1)); + } + model.Gtin = aiValue.toString(); + } + case CONTENT -> { + if (aiValue.length() > 0 && (aiValue.charAt(0) == '0' || aiValue.charAt(0) == '9')) { + aiValue = new StringBuilder(aiValue.substring(1)); + } + model.Content = aiValue.toString(); + } + case BATCH_LOT -> model.BatchLot = aiValue.toString(); + case PROD_DATE -> model.ProdDate = convertToDateTime(aiValue.toString()); + case DUE_DATE -> model.DueDate = convertToDateTime(aiValue.toString()); + case PACK_DATE -> model.PackDate = convertToDateTime(aiValue.toString()); + case BEST_BEFORE -> + model.BestBefore = String.valueOf(convertToDateTime(aiValue.toString())); + case EXPIRY -> model.Expiry = String.valueOf(convertToDateTime(aiValue.toString())); + case VARIANT -> model.Variant = aiValue.toString(); + case SERIAL -> model.Serial = aiValue.toString(); + case QTY_DATE_BATCH -> model.QtyDateBatch = aiValue.toString(); + case ADDITIONAL_ID -> model.AdditionalID = aiValue.toString(); + case CUST_PART_NO -> model.CustPartNumber = aiValue.toString(); + case SECONDARY_SERIAL -> model.SecondarySerial = aiValue.toString(); + case REF_TO_SOURCE -> model.RefToSource = aiValue.toString(); + case VAR_COUNT -> model.VarCount = aiValue.toString(); + case NET_WEIGHT_KG -> + model.NetWeightKg = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case LENGTH_M -> + model.LengthM = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case WIDTH_M -> + model.WidthM = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case HEIGHT_M -> + model.HeightM = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case AREA_M2 -> + model.AreaM2 = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case NET_VOLUME_L -> + model.NetVolumeL = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case NET_VOLUME_M3 -> + model.NetVolumeM3 = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case NET_WEIGHT_LB -> + model.NetWeightLb = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case LENGTH_I -> + model.LengthI = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case LENGTH_F -> + model.LengthF = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case LENGTH_Y -> + model.LengthY = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case WIDTH_I -> + model.WidthI = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case WIDTH_F -> + model.WidthF = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case WIDTH_Y -> + model.WidthY = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case HEIGHT_I -> + model.HeightI = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case HEIGHT_F -> + model.HeightF = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case HEIGHT_Y -> + model.HeightY = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case CROSSWEIGHT_KG_LOG -> + model.CrossweightKgLog = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case CROSSWEIGHT_LB_LOG -> + model.CrossweightLbLog = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case LENGTH_M_LOG -> + model.LengthMLog = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case WIDTH_M_LOG -> + model.WidthMLog = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case HEIGHT_M_LOG -> + model.HeigthMLog = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case AREA_M2_LOG -> + model.AreaM2Log = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case VOLUME_L_LOG -> + model.VolumeLLog = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case VOLUME_M3_LOG -> + model.VolumeM3Log = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case LENGTH_I_LOG -> + model.LengthILog = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case LENGTH_F_LOG -> + model.LengthFLog = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case LENGTH_Y_LOG -> + model.LengthYLog = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case WIDTH_I_LOG -> + model.WidthILog = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case WIDTH_F_LOG -> + model.WidthFLog = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case WIDTH_Y_LOG -> + model.WidthYLog = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case HEIGHT_I_LOG -> + model.HeigthILog = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case HEIGHT_F_LOG -> + model.HeigthFLog = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case HEIGHT_Y_LOG -> + model.HeigthYLog = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case AREA_I2 -> + model.AreaI2 = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case AREA_F2 -> + model.AreaF2 = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case AREA_Y2 -> + model.AreaY2 = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case AREA_I2_LOG -> + model.AreaI2Log = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case AREA_F2_LOG -> + model.AreaF2Log = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case AREA_Y2_LOG -> + model.AreaY2Log = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case NET_WEIGHT_T -> + model.NetWeightT = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case NET_VOLUME_OZ -> + model.NetVolumeOz = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case NET_VOLUME_LB -> + model.NetVolumeLb = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case NET_VOLUME_G -> + model.NetVolumeG = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case VOLUME_Q_LOG -> + model.VolumeQLog = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case VOLUME_G_LOG -> + model.VolumeGLog = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case NET_VOLUME_I3 -> + model.NetVolumeI3 = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case NET_VOLUME_F3 -> + model.NetVolumeF3 = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case NET_VOLUME_Y3 -> + model.NetVolumeY3 = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case VOLUME_I3_LOG -> + model.VolumeI3Log = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case VOLUME_F3_LOG -> + model.VolumeF3Log = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case VOLUME_Y3_LOG -> + model.VolumeY3Log = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case COUNT -> model.Count = Integer.parseInt(aiValue.toString()); + case AMOUNT -> + model.Amount = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case AMOUNT_ISO -> + model.AmountISO = convertToIsoValueModel(aiValue.toString(), aiModel.decimalDigits, + Double::parseDouble, + (input, input2) -> String.valueOf(convertToDecimalString(input, input2))); + case PRICE -> + model.Price = convertToDecimalString(aiValue.toString(), aiModel.decimalDigits); + case PRICE_ISO -> + model.PriceISO = convertToIsoValueModel(aiValue.toString(), aiModel.decimalDigits, + Double::parseDouble, + (input, input2) -> String.valueOf(convertToDecimalString(input, input2))); + case ORDER_NUMBER -> model.OrderNumber = aiValue.toString(); + case CONSIGNMENT -> model.Consignment = aiValue.toString(); + case SHIPMENT_NO -> model.ShipmentNo = aiValue.toString(); + case ROUTE -> model.Route = aiValue.toString(); + case SHIP_TO_LOC -> model.ShipToLoc = aiValue.toString(); + case BILL_TO_LOC -> model.BillToLoc = aiValue.toString(); + case PURCHASE_FROM_LOC -> model.PurchaseFromLoc = aiValue.toString(); + case SHIP_FOR_LOC -> model.ShipForLoc = aiValue.toString(); + case LOC_NO -> model.LocationNumber = aiValue.toString(); + case PAY_TO_LOC -> model.PayToLoc = aiValue.toString(); + case SHIP_TO_POST -> model.ShipToPost = aiValue.toString(); + case SHIP_TO_POST_ISO -> + model.ShipToPostISO = convertToIsoValueModel(aiValue.toString(), 0, + new Callable() { + @Override + public String call(String input) { + return input; + } + }, + new CallableII() { + @Override + public String call(String input, Integer input2) { + return input; + } + }); + case ORIGIN -> model.Origin = aiValue.toString(); + case COUNTRY_INITIAL_PROCESS -> + model.ShipToPostISO = convertToIsoValueModel(aiValue.toString(), 0, + input -> input, + (input, input2) -> input); + case COUNTRY_PROCESS -> model.CountryProcess = aiValue.toString(); + case COUNTRY_DISASSEMBLY -> model.CountryDisassembly = aiValue.toString(); + case COUNTRY_FULL_PROCESS -> model.CountryFullProcess = aiValue.toString(); + case NSN -> model.NSN = aiValue.toString(); + case MEAT_CUT -> model.MeatCut = aiValue.toString(); + case DIMENSIONS -> model.Dimensions = aiValue.toString(); + case CMT_NO -> model.CmtNo = aiValue.toString(); + case GRAI -> model.Grai = aiValue.toString(); + case GIAI -> model.Giai = aiValue.toString(); + case PRICE_PER_UNIT -> model.PricePerUnit = aiValue.toString(); + case GCTIN -> model.Gctin = aiValue.toString(); + case IBAN -> model.Iban = aiValue.toString(); + case PROD_TIME -> model.ProdTime = convertToDateTime(aiValue.toString()); + case GSRN -> model.Gsrn = aiValue.toString(); + case REF_NO -> model.RefNo = aiValue.toString(); + case COUPON_1 -> model.Coupon1 = aiValue.toString(); + case COUPON_2 -> model.Coupon2 = aiValue.toString(); + case COUPON_3 -> model.Coupon3 = aiValue.toString(); + case INTERNAL_PART -> model.InternalPart = aiValue.toString(); + case INTERNAL_1 -> model.Internal1 = aiValue.toString(); + case INTERNAL_2 -> model.Internal2 = aiValue.toString(); + case INTERNAL_3 -> model.Internal3 = aiValue.toString(); + case INTERNAL_4 -> model.Internal4 = aiValue.toString(); + case INTERNAL_5 -> model.Internal5 = aiValue.toString(); + case INTERNAL_6 -> model.Internal6 = aiValue.toString(); + case INTERNAL_7 -> model.Internal7 = aiValue.toString(); + case INTERNAL_8 -> model.Internal8 = aiValue.toString(); + case INTERNAL_9 -> model.Internal9 = aiValue.toString(); + default -> { + } + } + + aiCodeBuffer = ""; + } + } else { + throw new Exception(String.format("Il barcode non è un EAN128 valido (%s)", new String(inputEan128ByteArr))); + } + } + + return model; + } + + + private float convertToDecimalString(String sourceString, int numberOfdecimalDigits) { + + int divider = (int) Math.pow(10, numberOfdecimalDigits); + + return Float.parseFloat(sourceString) / divider; + } + + private Ean128ISOValueModel convertToIsoValueModel(String sourceString, int numberOfDecimalDigits, Callable castFunc, CallableII splitFunc) { + String isoCode = sourceString.substring(0, 3); + + T value = castFunc.call(splitFunc.call(sourceString.substring(3), numberOfDecimalDigits)); + + Ean128ISOValueModel isoModel = new Ean128ISOValueModel(); + isoModel.ISOCode = isoCode; + isoModel.Value = value; + + return isoModel; + } + + private Date convertToDateTime(String sourceString) { + int year = Integer.parseInt(sourceString.substring(0, 2)); + + //Se l'anno è minore di 50 indica 2000-2050 altrimenti 1951-1999 + int correctedYear = year <= 50 ? (2000 + year) : (1900 + year); + + int month = Integer.parseInt(sourceString.substring(2, 4)); + int day = Integer.parseInt(sourceString.substring(4, 6)); + + Date d = null; + + try { + SimpleDateFormat formatter = new SimpleDateFormat("dd/MM/yyyy"); + d = formatter.parse(day + "/" + month + "/" + correctedYear); + } catch (ParseException e) { + e.printStackTrace(); + } + + return d; + } + +} diff --git a/app/src/main/java/it/integry/integrywmsnative/core/rest/consumers/BarcodeRESTConsumer.java b/app/src/main/java/it/integry/integrywmsnative/core/rest/consumers/BarcodeRESTConsumer.java index f6e5bacf..51474031 100644 --- a/app/src/main/java/it/integry/integrywmsnative/core/rest/consumers/BarcodeRESTConsumer.java +++ b/app/src/main/java/it/integry/integrywmsnative/core/rest/consumers/BarcodeRESTConsumer.java @@ -3,32 +3,24 @@ package it.integry.integrywmsnative.core.rest.consumers; import javax.inject.Singleton; import it.integry.barcode_base_android_library.model.BarcodeScanDTO; +import it.integry.integrywmsnative.core.ean128.Ean128Service; import it.integry.integrywmsnative.core.expansion.RunnableArgs; -import it.integry.integrywmsnative.core.rest.RESTBuilder; import it.integry.integrywmsnative.core.rest.model.Ean128Model; -import it.integry.integrywmsnative.core.rest.model.ServiceRESTResponse; -import retrofit2.Call; -import retrofit2.Callback; -import retrofit2.Response; @Singleton public class BarcodeRESTConsumer extends _BaseRESTConsumer { + private final Ean128Service ean128Service; + + public BarcodeRESTConsumer(Ean128Service ean128Service) { + this.ean128Service = ean128Service; + } + public void decodeEan128(BarcodeScanDTO barcodeObj, RunnableArgs onComplete, RunnableArgs onFailed) { - - String ean128 = barcodeObj.getStringValue().replaceAll("" + ((char) 29), "|"); - - BarcodeRESTConsumerService barcodeRESTConsumerService = RESTBuilder.getService(BarcodeRESTConsumerService.class); - barcodeRESTConsumerService.decodeEan128(ean128).enqueue(new Callback<>() { - @Override - public void onResponse(Call> call, Response> response) { - analyzeAnswer(response, "DecodeEan128", onComplete, onFailed); - } - - @Override - public void onFailure(Call> call, Throwable t) { - onFailed.run(new Exception(t)); - } - }); + try { + onComplete.run(this.ean128Service.decode(barcodeObj)); + } catch (Exception e){ + onFailed.run(e); + } } } diff --git a/app/src/main/java/it/integry/integrywmsnative/core/rest/model/Ean128Model.java b/app/src/main/java/it/integry/integrywmsnative/core/rest/model/Ean128Model.java index e7d9e757..98bcacec 100644 --- a/app/src/main/java/it/integry/integrywmsnative/core/rest/model/Ean128Model.java +++ b/app/src/main/java/it/integry/integrywmsnative/core/rest/model/Ean128Model.java @@ -1,5 +1,8 @@ package it.integry.integrywmsnative.core.rest.model; +import java.util.Date; + +import it.integry.integrywmsnative.core.ean128.Ean128ISOValueModel; public class Ean128Model { @@ -16,13 +19,13 @@ public class Ean128Model { public String BatchLot; ///Data di produzione (yymmdd) 0~50 (2000~2050) - 51~99 (1951~1999) - public String ProdString; + public Date ProdDate; ///Data di scadenza pagamento fattura - public String DueString; + public Date DueDate; ///Data di confezionamento - public String PackString; + public Date PackDate; ///Data minima di validità public String BestBefore; @@ -37,7 +40,7 @@ public class Ean128Model { public String Serial; ///Dati supplementari per prodotti farmaceutici - public String QtyStringBatch; + public String QtyDateBatch; ///Numedi di identificazione supplementare del prodotto public String AdditionalID; @@ -216,9 +219,15 @@ public class Ean128Model { ///Importo da pagare singola area monetaria public Float Amount; + ///Importo da pagare con codice valuta ISO + public Ean128ISOValueModel AmountISO; + ///Importo da pagare singola unità monetaria (prodotti a peso variabile) public Float Price; + ///Importo da pagare con codice valuta ISO (prodotti a peso variabile) + public Ean128ISOValueModel PriceISO; + ///Numero d'ordine d'acquisto cliente public String OrderNumber; @@ -252,9 +261,15 @@ public class Ean128Model { ///Codice postale "Spedire a, Consegnare a" (nazionale) public String ShipToPost; + ///Codice postale "Spedire a, Consegnare a" con codice nazione ISO + public Ean128ISOValueModel ShipToPostISO; + ///Paese di origine del prodotto public String Origin; + ///Paese di lavorazione iniziale del prodotto con codice nazionale ISO + public Ean128ISOValueModel CountryInitialProcess; + ///Paese di lavorazione con codice nazionale ISO public String CountryProcess; @@ -292,7 +307,7 @@ public class Ean128Model { public String Iban; ///Data e ora di produzione - public String ProdTime; + public Date ProdTime; ///Numedo Globale di Relazione di Servizio public String Gsrn; @@ -313,7 +328,7 @@ public class Ean128Model { public String InternalPart; ///Informazioni interne - public String Internal1; //USED FOR COD_MART + public String Internal1; ///Informazioni interne public String Internal2; @@ -338,5 +353,4 @@ public class Ean128Model { ///Informazioni interne public String Internal9; - -} +} \ No newline at end of file diff --git a/app/src/main/java/it/integry/integrywmsnative/core/rest/model/udc/CreateUDCRequestDTO.java b/app/src/main/java/it/integry/integrywmsnative/core/rest/model/udc/CreateUDCRequestDTO.java index 119da115..f43e56c9 100644 --- a/app/src/main/java/it/integry/integrywmsnative/core/rest/model/udc/CreateUDCRequestDTO.java +++ b/app/src/main/java/it/integry/integrywmsnative/core/rest/model/udc/CreateUDCRequestDTO.java @@ -9,7 +9,7 @@ public class CreateUDCRequestDTO { private String serCollo; private String codAnag; private String codTcol; - + private String barcodeUl; private String annotazioni; private List orders; @@ -60,6 +60,15 @@ public class CreateUDCRequestDTO { return this; } + public String getBarcodeUl() { + return barcodeUl; + } + + public CreateUDCRequestDTO setBarcodeUl(String barcodeUl) { + this.barcodeUl = barcodeUl; + return this; + } + public String getAnnotazioni() { return annotazioni; } diff --git a/app/src/main/java/it/integry/integrywmsnative/core/settings/DBSettingsModel.java b/app/src/main/java/it/integry/integrywmsnative/core/settings/DBSettingsModel.java index 4de94e89..0de59f8e 100644 --- a/app/src/main/java/it/integry/integrywmsnative/core/settings/DBSettingsModel.java +++ b/app/src/main/java/it/integry/integrywmsnative/core/settings/DBSettingsModel.java @@ -72,6 +72,8 @@ public class DBSettingsModel { private boolean flagAllowULRecoverAccettazioneBolla = true; private boolean flagOverflowQuantityWarning = false; private String viewPosizioni; + private boolean flagDeleteRowOnClose = false; + private boolean flagAllowBarcodeFornitore = false; public boolean isFlagSpedizioneEnableFakeGiacenza() { return flagSpedizioneEnableFakeGiacenza; @@ -586,4 +588,22 @@ public class DBSettingsModel { this.viewPosizioni = viewPosizioni; return this; } + + public boolean isFlagDeleteRowOnClose() { + return flagDeleteRowOnClose; + } + + public DBSettingsModel setFlagDeleteRowOnClose(boolean flagDeleteRowOnClose) { + this.flagDeleteRowOnClose = flagDeleteRowOnClose; + return this; + } + + public boolean isFlagAllowBarcodeFornitore() { + return flagAllowBarcodeFornitore; + } + + public DBSettingsModel setFlagAllowBarcodeFornitore(boolean flagAllowBarcodeFornitore) { + this.flagAllowBarcodeFornitore = flagAllowBarcodeFornitore; + return this; + } } diff --git a/app/src/main/java/it/integry/integrywmsnative/core/settings/SettingsManager.java b/app/src/main/java/it/integry/integrywmsnative/core/settings/SettingsManager.java index e7840a70..11193892 100644 --- a/app/src/main/java/it/integry/integrywmsnative/core/settings/SettingsManager.java +++ b/app/src/main/java/it/integry/integrywmsnative/core/settings/SettingsManager.java @@ -242,6 +242,11 @@ public class SettingsManager { .setSection("ACCETTAZIONE") .setKeySection("FLAG_AUTO_OPEN_NEW_UL") .setSetter(dbSettingsModelIstance::setFlagCanAutoOpenNewULAccettazione)); + stbGestSetupReaderList.add(new StbGestSetupReader<>(Boolean.class) + .setGestName("PICKING") + .setSection("ACCETTAZIONE") + .setKeySection("FLAG_DELETE_ROW_ON_CLOSE") + .setSetter(dbSettingsModelIstance::setFlagDeleteRowOnClose)); stbGestSetupReaderList.add(new StbGestSetupReader<>(Boolean.class) .setGestName("PICKING") .setSection("SPEDIZIONE") @@ -488,6 +493,12 @@ public class SettingsManager { .setKeySection("FLAG_OVERFLOW_QUANTITY_WARNING") .setSetter(dbSettingsModelIstance::setFlagOverflowQuantityWarning) .setDefaultValue(false)); + stbGestSetupReaderList.add(new StbGestSetupReader<>(Boolean.class) + .setGestName("PICKING") + .setSection("ACCETTAZIONE") + .setKeySection("FLAG_ALLOW_BARCODE_FORNITORE") + .setSetter(dbSettingsModelIstance::setFlagAllowBarcodeFornitore) + .setDefaultValue(false)); String codMdep = SettingsManager.i().getUserSession().getDepo().getCodMdep(); diff --git a/app/src/main/java/it/integry/integrywmsnative/core/sound/SoundAlertService.java b/app/src/main/java/it/integry/integrywmsnative/core/sound/SoundAlertService.java new file mode 100644 index 00000000..04cb10d8 --- /dev/null +++ b/app/src/main/java/it/integry/integrywmsnative/core/sound/SoundAlertService.java @@ -0,0 +1,40 @@ +package it.integry.integrywmsnative.core.sound; + +import android.content.Context; +import android.media.MediaPlayer; + +import it.integry.integrywmsnative.R; + +import javax.inject.Inject; +import javax.inject.Singleton; + +@Singleton +public class SoundAlertService { + + private final Context mApplicationContext; + + private MediaPlayer successPlayer; + private MediaPlayer warningPlayer; + + public SoundAlertService(Context context) { + this.mApplicationContext = context; + } + + @Inject + public void init() { + successPlayer = MediaPlayer.create(this.mApplicationContext, R.raw.success_sound); + warningPlayer = MediaPlayer.create(this.mApplicationContext, R.raw.warning_sound); + } + + public void success() { + if (successPlayer != null) { + successPlayer.start(); + } + } + + public void warning() { + if (warningPlayer != null) { + warningPlayer.start(); + } + } +} diff --git a/app/src/main/java/it/integry/integrywmsnative/core/utility/UtilityBarcode.java b/app/src/main/java/it/integry/integrywmsnative/core/utility/UtilityBarcode.java index 2d8437da..2d8bec0e 100644 --- a/app/src/main/java/it/integry/integrywmsnative/core/utility/UtilityBarcode.java +++ b/app/src/main/java/it/integry/integrywmsnative/core/utility/UtilityBarcode.java @@ -25,7 +25,7 @@ public class UtilityBarcode { int currentYear = calendar.get(Calendar.YEAR); String fullYear = "20" + UtilityBarcode.getAnnoColloFromULAnonima(barcode); - return fullYear.equalsIgnoreCase("" + currentYear); + return fullYear.equalsIgnoreCase(String.valueOf(currentYear)); } public static boolean isEtichetta128(BarcodeScanDTO barcodeScanDTO) { diff --git a/app/src/main/java/it/integry/integrywmsnative/gest/accettazione_ordini_picking/AccettazioneOrdiniPickingActivity.java b/app/src/main/java/it/integry/integrywmsnative/gest/accettazione_ordini_picking/AccettazioneOrdiniPickingActivity.java index c051a2b8..d726e2d4 100644 --- a/app/src/main/java/it/integry/integrywmsnative/gest/accettazione_ordini_picking/AccettazioneOrdiniPickingActivity.java +++ b/app/src/main/java/it/integry/integrywmsnative/gest/accettazione_ordini_picking/AccettazioneOrdiniPickingActivity.java @@ -713,7 +713,7 @@ public class AccettazioneOrdiniPickingActivity extends BaseActivity implements A this.fabPopupMenu.dismiss(); this.onLoadingStarted(); - this.mViewModel.createNewLU(null, null, false, () -> { + this.mViewModel.createNewLU(null, null, null, false, () -> { this.onLoadingEnded(); }); } @@ -929,6 +929,9 @@ public class AccettazioneOrdiniPickingActivity extends BaseActivity implements A noLUPresent.set(true); this.mBottomSheetFragmentLUContentViewModel.setMtbColt(null); + + this.refreshList(); + if (this.mShouldCloseActivity) super.onBackPressed(); }); } diff --git a/app/src/main/java/it/integry/integrywmsnative/gest/accettazione_ordini_picking/AccettazioneOrdiniPickingModule.java b/app/src/main/java/it/integry/integrywmsnative/gest/accettazione_ordini_picking/AccettazioneOrdiniPickingModule.java index a83b471a..cbd87f03 100644 --- a/app/src/main/java/it/integry/integrywmsnative/gest/accettazione_ordini_picking/AccettazioneOrdiniPickingModule.java +++ b/app/src/main/java/it/integry/integrywmsnative/gest/accettazione_ordini_picking/AccettazioneOrdiniPickingModule.java @@ -2,6 +2,7 @@ package it.integry.integrywmsnative.gest.accettazione_ordini_picking; import dagger.Module; import dagger.Provides; +import it.integry.integrywmsnative.core.ean128.Ean128Service; import it.integry.integrywmsnative.core.rest.consumers.ArticoloRESTConsumer; import it.integry.integrywmsnative.core.rest.consumers.BarcodeRESTConsumer; import it.integry.integrywmsnative.core.rest.consumers.ColliAccettazioneRESTConsumer; @@ -33,14 +34,15 @@ public class AccettazioneOrdiniPickingModule { PrinterRESTConsumer printerRESTConsumer, AccettazioneOrdiniPickingRESTConsumer accettazioneOrdiniPickingRESTConsumer, ColliAccettazioneRESTConsumer colliAccettazioneRESTConsumer, - ColliLavorazioneRESTConsumer colliLavorazioneRESTConsumer) { + ColliLavorazioneRESTConsumer colliLavorazioneRESTConsumer, + Ean128Service ean128Service) { return new AccettazioneOrdiniPickingViewModel(articoloRESTConsumer, barcodeRESTConsumer, colliMagazzinoRESTConsumer, printerRESTConsumer, accettazioneOrdiniPickingRESTConsumer, colliAccettazioneRESTConsumer, - colliLavorazioneRESTConsumer); + colliLavorazioneRESTConsumer, ean128Service); } } diff --git a/app/src/main/java/it/integry/integrywmsnative/gest/accettazione_ordini_picking/AccettazioneOrdiniPickingViewModel.java b/app/src/main/java/it/integry/integrywmsnative/gest/accettazione_ordini_picking/AccettazioneOrdiniPickingViewModel.java index 85095aec..e628e7c5 100644 --- a/app/src/main/java/it/integry/integrywmsnative/gest/accettazione_ordini_picking/AccettazioneOrdiniPickingViewModel.java +++ b/app/src/main/java/it/integry/integrywmsnative/gest/accettazione_ordini_picking/AccettazioneOrdiniPickingViewModel.java @@ -16,6 +16,7 @@ import javax.inject.Inject; import it.integry.barcode_base_android_library.model.BarcodeScanDTO; import it.integry.integrywmsnative.core.CommonConst; +import it.integry.integrywmsnative.core.ean128.Ean128Service; import it.integry.integrywmsnative.core.exception.AlreadyUsedAnonymousLabelException; import it.integry.integrywmsnative.core.exception.InvalidLUMultiGestioneException; import it.integry.integrywmsnative.core.exception.LUScanNotGrantedException; @@ -31,6 +32,7 @@ import it.integry.integrywmsnative.core.model.MtbAart; import it.integry.integrywmsnative.core.model.MtbColr; import it.integry.integrywmsnative.core.model.MtbColt; import it.integry.integrywmsnative.core.model.MtbTCol; +import it.integry.integrywmsnative.core.model.dto.AlreadyRegisteredUDCDTO; import it.integry.integrywmsnative.core.model.dto.PickDataDTO; import it.integry.integrywmsnative.core.model.secondary.GestioneEnum; import it.integry.integrywmsnative.core.rest.consumers.ArticoloRESTConsumer; @@ -40,6 +42,7 @@ import it.integry.integrywmsnative.core.rest.consumers.ColliLavorazioneRESTConsu import it.integry.integrywmsnative.core.rest.consumers.ColliMagazzinoRESTConsumer; import it.integry.integrywmsnative.core.rest.consumers.PrinterRESTConsumer; import it.integry.integrywmsnative.core.rest.consumers.interfaces.ColliCaricoRESTConsumerInterface; +import it.integry.integrywmsnative.core.rest.model.Ean128Model; import it.integry.integrywmsnative.core.rest.model.Ean13PesoModel; import it.integry.integrywmsnative.core.rest.model.VersamentoAutomaticoULResponseDTO; import it.integry.integrywmsnative.core.rest.model.udc.CloseUDCRequestDTO; @@ -55,7 +58,6 @@ import it.integry.integrywmsnative.core.utility.UtilityBarcode; import it.integry.integrywmsnative.core.utility.UtilityBigDecimal; import it.integry.integrywmsnative.core.utility.UtilityDate; import it.integry.integrywmsnative.core.utility.UtilityString; -import it.integry.integrywmsnative.core.model.dto.AlreadyRegisteredUDCDTO; import it.integry.integrywmsnative.gest.accettazione_ordini_elenco.dto.OrdineAccettazioneInevasoDTO; import it.integry.integrywmsnative.gest.accettazione_ordini_elenco.dto.SitArtOrdDTO; import it.integry.integrywmsnative.gest.accettazione_ordini_picking.dto.HistoryMtbAartDTO; @@ -74,6 +76,7 @@ public class AccettazioneOrdiniPickingViewModel { private final AccettazioneOrdiniPickingRESTConsumer mAccettazioneOrdiniPickingRESTConsumer; private final ColliAccettazioneRESTConsumer mColliAccettazioneRESTConsumer; private final ColliLavorazioneRESTConsumer mColliLavorazioneRESTConsumer; + private final Ean128Service mEan128Service; private ColliCaricoRESTConsumerInterface mColliCaricoRESTConsumer; @@ -95,7 +98,8 @@ public class AccettazioneOrdiniPickingViewModel { PrinterRESTConsumer printerRESTConsumer, AccettazioneOrdiniPickingRESTConsumer accettazioneOrdiniPickingRESTConsumer, ColliAccettazioneRESTConsumer colliAccettazioneRESTConsumer, - ColliLavorazioneRESTConsumer colliLavorazioneRESTConsumer) { + ColliLavorazioneRESTConsumer colliLavorazioneRESTConsumer, + Ean128Service ean128Service) { this.mArticoloRESTConsumer = articoloRESTConsumer; this.mBarcodeRESTConsumer = barcodeRESTConsumer; this.mColliMagazzinoRESTConsumer = colliMagazzinoRESTConsumer; @@ -103,6 +107,7 @@ public class AccettazioneOrdiniPickingViewModel { this.mAccettazioneOrdiniPickingRESTConsumer = accettazioneOrdiniPickingRESTConsumer; this.mColliAccettazioneRESTConsumer = colliAccettazioneRESTConsumer; this.mColliLavorazioneRESTConsumer = colliLavorazioneRESTConsumer; + this.mEan128Service = ean128Service; } @@ -209,7 +214,11 @@ public class AccettazioneOrdiniPickingViewModel { //dell'etichetta anonima this.executeEtichettaAnonimaNotOpenedLU(barcodeScanDTO, onComplete); } else { - this.processBarcodeNotOpenedLU(barcodeScanDTO, onComplete); + if (SettingsManager.iDB().isFlagAllowBarcodeFornitore() && UtilityBarcode.isEtichetta128(barcodeScanDTO)) { + this.executeSSCCFornitore(barcodeScanDTO, onComplete); + } else { + this.processBarcodeNotOpenedLU(barcodeScanDTO, null, onComplete); + } } } else { @@ -221,6 +230,18 @@ public class AccettazioneOrdiniPickingViewModel { } } + private void executeSSCCFornitore(BarcodeScanDTO barcodeScanDTO, Runnable onComplete) { + try { + Ean128Model ean128Model = mEan128Service.decode(barcodeScanDTO); + + //Nel caso trovo un SSCC lo aggiungo + this.processBarcodeNotOpenedLU(barcodeScanDTO, ean128Model.Sscc, onComplete); + + } catch (Exception e) { + this.sendError(e); + } + } + private void executeEtichettaAnonimaNotOpenedLU(BarcodeScanDTO barcodeScanDTO, Runnable onComplete) { mColliMagazzinoRESTConsumer.getBySSCC(barcodeScanDTO.getStringValue(), true, false, mtbColt -> { @@ -233,6 +254,7 @@ public class AccettazioneOrdiniPickingViewModel { try { numCollo = UtilityBarcode.getNumColloFromULAnonima(barcodeScanDTO.getStringValue()); this.createNewLU( + null, numCollo, CommonConst.Config.DEFAULT_ANONYMOUS_UL_SERIE, true, onComplete); } catch (Exception ex) { @@ -246,12 +268,17 @@ public class AccettazioneOrdiniPickingViewModel { }, this::sendError); } - private void processBarcodeNotOpenedLU(BarcodeScanDTO barcodeScanDTO, Runnable onComplete) { + private void processBarcodeNotOpenedLU(BarcodeScanDTO barcodeScanDTO, String customSSCC, Runnable onComplete) { this.createNewLU( + customSSCC, null, null, false, - () -> processBarcodeAlreadyOpenedLU(barcodeScanDTO, onComplete)); + () -> { + if(UtilityString.isNullOrEmpty(customSSCC)) + processBarcodeAlreadyOpenedLU(barcodeScanDTO, onComplete); + else onComplete.run(); + }); } private void processBarcodeAlreadyOpenedLU(BarcodeScanDTO barcodeScanDTO, Runnable onComplete) { @@ -260,7 +287,6 @@ public class AccettazioneOrdiniPickingViewModel { //Cerco tramite etichetta ean 128 (che può indicarmi un articolo o una UL) this.executeEtichettaEanPeso(barcodeScanDTO, onComplete); - } else if (UtilityBarcode.isEtichettaPosizione(barcodeScanDTO)) { //Applico filtro per posizione this.executeEtichettaPosizione(barcodeScanDTO, onComplete); @@ -269,7 +295,6 @@ public class AccettazioneOrdiniPickingViewModel { //Cerco tramite etichetta ean 128 (che può indicarmi un articolo o una UL) this.executeEtichettaEan128(barcodeScanDTO, onComplete); - } else { this.loadArticolo(barcodeScanDTO.getStringValue(), null, onComplete); } @@ -367,7 +392,7 @@ public class AccettazioneOrdiniPickingViewModel { } } - public void createNewLU(Integer customNumCollo, String customSerCollo, boolean disablePrint, Runnable onComplete) { + public void createNewLU(String customSSCC, Integer customNumCollo, String customSerCollo, boolean disablePrint, Runnable onComplete) { this.sendOnInfoAggiuntiveRequest((additionalNotes, tCol) -> { final List orders = Stream.of(this.mOrders) @@ -377,8 +402,8 @@ public class AccettazioneOrdiniPickingViewModel { .setDataOrd(UtilityDate.toLocalDate(x.getDataD())) .setNumOrd(x.getNumero()); - if(x.getGestioneEnum() == GestioneEnum.PRODUZIONE) { - if(x.isOrdTrasf()) + if (x.getGestioneEnum() == GestioneEnum.PRODUZIONE) { + if (x.isOrdTrasf()) createUDCRequestOrderDTO.setGestione(GestioneEnum.ACQUISTO.getText()); else createUDCRequestOrderDTO.setGestione(GestioneEnum.LAVORAZIONE.getText()); @@ -396,6 +421,7 @@ public class AccettazioneOrdiniPickingViewModel { .setCodTcol(tCol != null ? tCol.getCodTcol() : null) .setNumCollo(customNumCollo) .setSerCollo(customSerCollo) + .setBarcodeUl(customSSCC) .setOrders(orders); this.mColliCaricoRESTConsumer.createUDC(createUDCRequestDTO, createdUDS -> { @@ -782,11 +808,40 @@ public class AccettazioneOrdiniPickingViewModel { } private void postCloseOperations() { + this.calculateQtaDaEvadere(); this.mCurrentMtbColt = null; this.sendLUClosed(); this.sendOnLoadingEnded(); } + private void calculateQtaDaEvadere() { + if (SettingsManager.iDB().isFlagDeleteRowOnClose()) { + for (PickingObjectDTO pickingObjectDTO : this.mPickingList.getValue()) { + List withdrawMtbColrs = pickingObjectDTO.getWithdrawMtbColrs(); + BigDecimal qtaEvasa = BigDecimal.ZERO; + BigDecimal numCnf = BigDecimal.ZERO; + + if (withdrawMtbColrs.size() > 0) { + qtaEvasa = Stream.of(withdrawMtbColrs) + .map(MtbColr::getQtaCol) + .reduce(BigDecimal.ZERO, BigDecimal::add); + + numCnf = Stream.of(withdrawMtbColrs) + .map(MtbColr::getNumCnf) + .reduce(BigDecimal.ZERO, BigDecimal::add); + } + + BigDecimal qtaDaEvadere = pickingObjectDTO.getSitArtOrdDTO().getQtaDaEvadere(); + pickingObjectDTO.getSitArtOrdDTO().setQtaDaEvadere(qtaDaEvadere.subtract(qtaEvasa)); + + BigDecimal numCnfDaEvadere = pickingObjectDTO.getSitArtOrdDTO().getNumCnfDaEvadere(); + pickingObjectDTO.getSitArtOrdDTO().setNumCnfDaEvadere(numCnfDaEvadere.subtract(numCnf)); + + pickingObjectDTO.setWithdrawMtbColrs(new ArrayList<>()); + } + } + } + private void deleteLU(Runnable onComplete) { DeleteULRequestDTO deleteULRequestDTO = new DeleteULRequestDTO() .setMtbColt(this.mCurrentMtbColt); diff --git a/app/src/main/java/it/integry/integrywmsnative/gest/prod_riposizionamento_da_prod/ProdRiposizionamentoDaProdModule.java b/app/src/main/java/it/integry/integrywmsnative/gest/prod_riposizionamento_da_prod/ProdRiposizionamentoDaProdModule.java index 9741ec07..754a1168 100644 --- a/app/src/main/java/it/integry/integrywmsnative/gest/prod_riposizionamento_da_prod/ProdRiposizionamentoDaProdModule.java +++ b/app/src/main/java/it/integry/integrywmsnative/gest/prod_riposizionamento_da_prod/ProdRiposizionamentoDaProdModule.java @@ -7,13 +7,14 @@ import it.integry.integrywmsnative.core.rest.consumers.ColliMagazzinoRESTConsume import it.integry.integrywmsnative.core.rest.consumers.GiacenzaRESTConsumer; import it.integry.integrywmsnative.core.rest.consumers.MagazzinoAutomaticoRESTConsumer; import it.integry.integrywmsnative.core.rest.consumers.PosizioniRESTConsumer; +import it.integry.integrywmsnative.core.sound.SoundAlertService; @Module(subcomponents = ProdRiposizionamentoDaProdComponent.class) public class ProdRiposizionamentoDaProdModule { @Provides - ProdRiposizionamentoDaProdViewModel providesProdRiposizionamentoDaProdViewModel(GiacenzaRESTConsumer giacenzaRESTConsumer, BarcodeRESTConsumer barcodeRESTConsumer, ColliMagazzinoRESTConsumer colliMagazzinoRESTConsumer) { - return new ProdRiposizionamentoDaProdViewModel(giacenzaRESTConsumer, barcodeRESTConsumer, colliMagazzinoRESTConsumer); + ProdRiposizionamentoDaProdViewModel providesProdRiposizionamentoDaProdViewModel(GiacenzaRESTConsumer giacenzaRESTConsumer, BarcodeRESTConsumer barcodeRESTConsumer, ColliMagazzinoRESTConsumer colliMagazzinoRESTConsumer, SoundAlertService soundAlertService) { + return new ProdRiposizionamentoDaProdViewModel(giacenzaRESTConsumer, barcodeRESTConsumer, colliMagazzinoRESTConsumer, soundAlertService); } } \ No newline at end of file diff --git a/app/src/main/java/it/integry/integrywmsnative/gest/prod_riposizionamento_da_prod/ProdRiposizionamentoDaProdViewModel.java b/app/src/main/java/it/integry/integrywmsnative/gest/prod_riposizionamento_da_prod/ProdRiposizionamentoDaProdViewModel.java index 299f904e..f22dd800 100644 --- a/app/src/main/java/it/integry/integrywmsnative/gest/prod_riposizionamento_da_prod/ProdRiposizionamentoDaProdViewModel.java +++ b/app/src/main/java/it/integry/integrywmsnative/gest/prod_riposizionamento_da_prod/ProdRiposizionamentoDaProdViewModel.java @@ -13,6 +13,8 @@ import java.util.Map; import java.util.Objects; import java.util.stream.Collectors; +import javax.inject.Inject; + import it.integry.barcode_base_android_library.model.BarcodeScanDTO; import it.integry.integrywmsnative.core.exception.NoLUFoundException; import it.integry.integrywmsnative.core.exception.ScannedPositionNotExistException; @@ -25,13 +27,14 @@ import it.integry.integrywmsnative.core.rest.consumers.BarcodeRESTConsumer; import it.integry.integrywmsnative.core.rest.consumers.ColliMagazzinoRESTConsumer; import it.integry.integrywmsnative.core.rest.consumers.GiacenzaRESTConsumer; import it.integry.integrywmsnative.core.settings.SettingsManager; +import it.integry.integrywmsnative.core.sound.SoundAlertService; import it.integry.integrywmsnative.core.utility.UtilityBarcode; import it.integry.integrywmsnative.core.utility.UtilityDate; import it.integry.integrywmsnative.core.utility.UtilityString; import it.integry.integrywmsnative.gest.prod_riposizionamento_da_prod.dto.ArtsInGiacenzaDTO; public class ProdRiposizionamentoDaProdViewModel { - + private final SoundAlertService mSoundAlertService; private final GiacenzaRESTConsumer mGiacenzaRESTConsumer; private final BarcodeRESTConsumer mBarcodeRESTConsumer; private final ColliMagazzinoRESTConsumer mColliMagazzinoRESTConsumer; @@ -40,10 +43,11 @@ public class ProdRiposizionamentoDaProdViewModel { private final MutableLiveData> mMvwSitArtUdcDetInventarioLiveData = new MutableLiveData<>(); private Listener mListener; - public ProdRiposizionamentoDaProdViewModel(GiacenzaRESTConsumer giacenzaRESTConsumer, BarcodeRESTConsumer barcodeRESTConsumer, ColliMagazzinoRESTConsumer colliMagazzinoRESTConsumer) { + public ProdRiposizionamentoDaProdViewModel(GiacenzaRESTConsumer giacenzaRESTConsumer, BarcodeRESTConsumer barcodeRESTConsumer, ColliMagazzinoRESTConsumer colliMagazzinoRESTConsumer, SoundAlertService soundAlertService) { this.mGiacenzaRESTConsumer = giacenzaRESTConsumer; this.mBarcodeRESTConsumer = barcodeRESTConsumer; this.mColliMagazzinoRESTConsumer = colliMagazzinoRESTConsumer; + this.mSoundAlertService = soundAlertService; } public void processBarcodeDTO(BarcodeScanDTO barcodeScanDTO, Runnable onComplete) { @@ -72,6 +76,7 @@ public class ProdRiposizionamentoDaProdViewModel { if (!UtilityString.isNullOrEmpty(ean128Model.Sscc)) { this.executeEtichettaLU(ean128Model.Sscc, false, onBarcodeScanComplete); } else { + this.mSoundAlertService.warning(); this.sendError(new NoLUFoundException()); } @@ -86,6 +91,7 @@ public class ProdRiposizionamentoDaProdViewModel { private void executeEtichettaLU(String sscc, boolean isAnonima, Runnable onComplete) { this.mColliMagazzinoRESTConsumer.getBySSCC(sscc, true, false, mtbColt -> { if (mtbColt == null && !isAnonima) { + this.mSoundAlertService.warning(); this.sendError(new NoLUFoundException()); } else { List mvwSitArtUdcDetInventario = Stream.of(Objects.requireNonNull(itemsInventario.getValue())) @@ -102,10 +108,12 @@ public class ProdRiposizionamentoDaProdViewModel { x.getNumCollo().equals(mtbColt.getNumCollo())); if (isPresent && mtbColt != null) { + this.mSoundAlertService.success(); mtbColt.setDisablePrint(true); onComplete.run(); this.onLUOpened(mtbColt); } else { + this.mSoundAlertService.warning(); this.sendError(new NoLUFoundException()); } } @@ -171,7 +179,10 @@ public class ProdRiposizionamentoDaProdViewModel { this.sendOnDataSaved(); } }, this::sendError); - } else this.sendError(new NoLUFoundException()); + } else { + this.mSoundAlertService.warning(); + this.sendError(new NoLUFoundException()); + } } } diff --git a/app/src/main/java/it/integry/integrywmsnative/gest/rettifica_giacenze/rest/RettificaGiacenzeRESTConsumer.java b/app/src/main/java/it/integry/integrywmsnative/gest/rettifica_giacenze/rest/RettificaGiacenzeRESTConsumer.java index a08054f6..3ed3faa7 100644 --- a/app/src/main/java/it/integry/integrywmsnative/gest/rettifica_giacenze/rest/RettificaGiacenzeRESTConsumer.java +++ b/app/src/main/java/it/integry/integrywmsnative/gest/rettifica_giacenze/rest/RettificaGiacenzeRESTConsumer.java @@ -81,6 +81,8 @@ public class RettificaGiacenzeRESTConsumer extends _BaseRESTConsumer { Response>> response) { analyzeAnswer(response, "searchByCodMartOrBarcode", data -> { + if(data == null) data = new ArrayList<>(); + var listToReturn = Stream.of(data) .map(x -> x.getMtbAart() .setQtaEsistente(x.getQtaEsistente()) diff --git a/app/src/main/java/it/integry/integrywmsnative/gest/spedizione/SpedizioneViewModel.java b/app/src/main/java/it/integry/integrywmsnative/gest/spedizione/SpedizioneViewModel.java index e9e5703f..0e1af15c 100644 --- a/app/src/main/java/it/integry/integrywmsnative/gest/spedizione/SpedizioneViewModel.java +++ b/app/src/main/java/it/integry/integrywmsnative/gest/spedizione/SpedizioneViewModel.java @@ -838,16 +838,16 @@ public class SpedizioneViewModel { .toList(); //Controllo se una delle partite combacia con quella che voglio evadere - if (refMtbColr != null && refMtbColr.getMtbPartitaMag() != null) { - MtbPartitaMag refMtbPartitaMag = refMtbColr.getMtbPartitaMag(); - - Optional matchPartitaMag = Stream.of(availableBatchLots).filter(availableBatchLot -> refMtbPartitaMag.getPartitaMag().equalsIgnoreCase(availableBatchLot.getPartitaMag())).findFirst(); - - if (matchPartitaMag.isPresent()) { - availableBatchLots.clear(); - availableBatchLots.add(refMtbPartitaMag); - } - } +// if (refMtbColr != null && refMtbColr.getMtbPartitaMag() != null) { +// MtbPartitaMag refMtbPartitaMag = refMtbColr.getMtbPartitaMag(); +// +// Optional matchPartitaMag = Stream.of(availableBatchLots).filter(availableBatchLot -> refMtbPartitaMag.getPartitaMag().equalsIgnoreCase(availableBatchLot.getPartitaMag())).findFirst(); +// +// if (matchPartitaMag.isPresent()) { +// availableBatchLots.clear(); +// availableBatchLots.add(refMtbPartitaMag); +// } +// } if (availableBatchLots.size() > 1) { this.sendOnLoadingStarted(); diff --git a/app/src/main/java/it/integry/integrywmsnative/view/dialogs/ask_linea_prod/DialogAskLineaProdViewModel.java b/app/src/main/java/it/integry/integrywmsnative/view/dialogs/ask_linea_prod/DialogAskLineaProdViewModel.java index d19bf5b0..c7510621 100644 --- a/app/src/main/java/it/integry/integrywmsnative/view/dialogs/ask_linea_prod/DialogAskLineaProdViewModel.java +++ b/app/src/main/java/it/integry/integrywmsnative/view/dialogs/ask_linea_prod/DialogAskLineaProdViewModel.java @@ -17,7 +17,7 @@ public class DialogAskLineaProdViewModel { MtbDepoPosizione foundPosizione = UtilityPosizione.getFromCache(data.getStringValue()); - if (!foundPosizione.isFlagLineaProduzione()) { + if (foundPosizione == null || !foundPosizione.isFlagLineaProduzione()) { this.sendError(new InvalidLineaProdBarcodeException(data.getStringValue())); onComplete.run(); return; diff --git a/app/src/main/java/it/integry/integrywmsnative/view/dialogs/choose_batch_lot/DialogChooseBatchLotView.java b/app/src/main/java/it/integry/integrywmsnative/view/dialogs/choose_batch_lot/DialogChooseBatchLotView.java index 005653d7..0f6efd32 100644 --- a/app/src/main/java/it/integry/integrywmsnative/view/dialogs/choose_batch_lot/DialogChooseBatchLotView.java +++ b/app/src/main/java/it/integry/integrywmsnative/view/dialogs/choose_batch_lot/DialogChooseBatchLotView.java @@ -1,20 +1,18 @@ package it.integry.integrywmsnative.view.dialogs.choose_batch_lot; +import android.app.Dialog; import android.content.Context; import android.content.DialogInterface; -import android.graphics.Color; -import android.graphics.drawable.ColorDrawable; import android.os.Bundle; import android.view.LayoutInflater; -import android.view.View; -import android.view.ViewGroup; import androidx.annotation.NonNull; import androidx.annotation.Nullable; import androidx.core.content.ContextCompat; -import androidx.databinding.DataBindingUtil; import androidx.recyclerview.widget.LinearLayoutManager; +import com.google.android.material.dialog.MaterialAlertDialogBuilder; + import java.util.List; import javax.inject.Inject; @@ -52,30 +50,37 @@ public class DialogChooseBatchLotView extends BaseDialogFragment { this.mOnItemSelected = onItemSelected; } - @Nullable + @NonNull @Override - public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) { - this.mContext = getActivity(); + public Dialog onCreateDialog(@Nullable Bundle savedInstanceState) { + this.mContext = requireContext(); - mBindings = DataBindingUtil.inflate(inflater, R.layout.dialog_choose_batch_lot, container, false); + mBindings = DialogChooseBatchLotBinding.inflate(LayoutInflater.from(this.mContext), null, false); + mBindings.setLifecycleOwner(this); MainApplication.appComponent .dialogChooseBatchLotComponent() .create() .inject(this); - mBindings.setView(this); mBindings.setViewmodel(this.mViewModel); - getDialog().setCanceledOnTouchOutside(false); - getDialog().getWindow().setBackgroundDrawable(new ColorDrawable(Color.TRANSPARENT)); + setCancelable(false); - return mBindings.getRoot(); + var alertDialog = new MaterialAlertDialogBuilder(this.mContext) + .setView(mBindings.getRoot()) + .setCancelable(isCancelable()) + .create(); + + alertDialog.setCanceledOnTouchOutside(isCancelable()); + alertDialog.setOnShowListener(this); + alertDialog.setOnDismissListener(this); + return alertDialog; } @Override - public void onStart() { - super.onStart(); + public void onShow(DialogInterface dialogInterface) { + super.onShow(dialogInterface); this.initRecyclerView(); } diff --git a/app/src/main/java/it/integry/integrywmsnative/view/dialogs/scan_or_create_lu/DialogScanOrCreateLUModule.java b/app/src/main/java/it/integry/integrywmsnative/view/dialogs/scan_or_create_lu/DialogScanOrCreateLUModule.java index 1fccde3c..6487b1b3 100644 --- a/app/src/main/java/it/integry/integrywmsnative/view/dialogs/scan_or_create_lu/DialogScanOrCreateLUModule.java +++ b/app/src/main/java/it/integry/integrywmsnative/view/dialogs/scan_or_create_lu/DialogScanOrCreateLUModule.java @@ -4,6 +4,7 @@ import dagger.Module; import dagger.Provides; import it.integry.integrywmsnative.core.rest.consumers.ArticoloRESTConsumer; import it.integry.integrywmsnative.core.rest.consumers.BarcodeRESTConsumer; +import it.integry.integrywmsnative.core.rest.consumers.ColliLavorazioneRESTConsumer; import it.integry.integrywmsnative.core.rest.consumers.ColliMagazzinoRESTConsumer; import it.integry.integrywmsnative.core.rest.consumers.PosizioniRESTConsumer; @@ -11,8 +12,16 @@ import it.integry.integrywmsnative.core.rest.consumers.PosizioniRESTConsumer; public class DialogScanOrCreateLUModule { @Provides - DialogScanOrCreateLUViewModel providesDialogScanOrCreateLUViewModel(PosizioniRESTConsumer posizioniRESTConsumer, BarcodeRESTConsumer barcodeRESTConsumer, ColliMagazzinoRESTConsumer colliMagazzinoRESTConsumer, ArticoloRESTConsumer articoloRESTConsumer) { - return new DialogScanOrCreateLUViewModel(posizioniRESTConsumer, barcodeRESTConsumer, colliMagazzinoRESTConsumer, articoloRESTConsumer); + DialogScanOrCreateLUViewModel providesDialogScanOrCreateLUViewModel( + PosizioniRESTConsumer posizioniRESTConsumer, + BarcodeRESTConsumer barcodeRESTConsumer, + ColliMagazzinoRESTConsumer colliMagazzinoRESTConsumer, + ColliLavorazioneRESTConsumer colliLavorazioneRESTConsumer, + ArticoloRESTConsumer articoloRESTConsumer) { + + return new DialogScanOrCreateLUViewModel(posizioniRESTConsumer, + barcodeRESTConsumer, colliMagazzinoRESTConsumer, + colliLavorazioneRESTConsumer, articoloRESTConsumer); } } diff --git a/app/src/main/java/it/integry/integrywmsnative/view/dialogs/scan_or_create_lu/DialogScanOrCreateLUViewModel.java b/app/src/main/java/it/integry/integrywmsnative/view/dialogs/scan_or_create_lu/DialogScanOrCreateLUViewModel.java index 0c3c77b3..990b2bd1 100644 --- a/app/src/main/java/it/integry/integrywmsnative/view/dialogs/scan_or_create_lu/DialogScanOrCreateLUViewModel.java +++ b/app/src/main/java/it/integry/integrywmsnative/view/dialogs/scan_or_create_lu/DialogScanOrCreateLUViewModel.java @@ -14,8 +14,10 @@ import it.integry.integrywmsnative.core.model.MtbDepoPosizione; import it.integry.integrywmsnative.core.model.secondary.GestioneEnum; import it.integry.integrywmsnative.core.rest.consumers.ArticoloRESTConsumer; import it.integry.integrywmsnative.core.rest.consumers.BarcodeRESTConsumer; +import it.integry.integrywmsnative.core.rest.consumers.ColliLavorazioneRESTConsumer; import it.integry.integrywmsnative.core.rest.consumers.ColliMagazzinoRESTConsumer; import it.integry.integrywmsnative.core.rest.consumers.PosizioniRESTConsumer; +import it.integry.integrywmsnative.core.rest.model.udc.CreateUDCRequestDTO; import it.integry.integrywmsnative.core.settings.SettingsManager; import it.integry.integrywmsnative.core.utility.UtilityBarcode; import it.integry.integrywmsnative.core.utility.UtilityPosizione; @@ -27,6 +29,7 @@ public class DialogScanOrCreateLUViewModel { private final PosizioniRESTConsumer mPosizioniRESTConsumer; private final BarcodeRESTConsumer mBarcodeRESTConsumer; private final ColliMagazzinoRESTConsumer mColliMagazzinoRESTConsumer; + private final ColliLavorazioneRESTConsumer mColliLavorazioneRESTConsumer; private final ArticoloRESTConsumer mArticoloRESTConsumer; private boolean mShouldCheckResiduo = false; @@ -36,10 +39,11 @@ public class DialogScanOrCreateLUViewModel { private Listener mListener; - public DialogScanOrCreateLUViewModel(PosizioniRESTConsumer mPosizioniRESTConsumer, BarcodeRESTConsumer barcodeRESTConsumer, ColliMagazzinoRESTConsumer colliMagazzinoRESTConsumer, ArticoloRESTConsumer articoloRESTConsumer) { + public DialogScanOrCreateLUViewModel(PosizioniRESTConsumer mPosizioniRESTConsumer, BarcodeRESTConsumer barcodeRESTConsumer, ColliMagazzinoRESTConsumer colliMagazzinoRESTConsumer, ColliLavorazioneRESTConsumer mColliLavorazioneRESTConsumer, ArticoloRESTConsumer articoloRESTConsumer) { this.mPosizioniRESTConsumer = mPosizioniRESTConsumer; this.mBarcodeRESTConsumer = barcodeRESTConsumer; this.mColliMagazzinoRESTConsumer = colliMagazzinoRESTConsumer; + this.mColliLavorazioneRESTConsumer = mColliLavorazioneRESTConsumer; this.mArticoloRESTConsumer = articoloRESTConsumer; } @@ -53,7 +57,11 @@ public class DialogScanOrCreateLUViewModel { public void createNewLU() { this.sendOnLoadingStarted(); - this.mColliMagazzinoRESTConsumer.createColloLavorazione(+1, createdMtbColt -> { + + var createUdcRequest = new CreateUDCRequestDTO() + .setCodMdep(SettingsManager.i().getUserSession().getDepo().getCodMdep()); + + this.mColliLavorazioneRESTConsumer.createUDC(createUdcRequest, createdMtbColt -> { this.sendOnLoadingEnded(); this.sendOnLUOpened(createdMtbColt, true); }, this::sendError); diff --git a/app/src/main/res/layout/dialog_choose_batch_lot.xml b/app/src/main/res/layout/dialog_choose_batch_lot.xml index ce2f81ab..2c98b991 100644 --- a/app/src/main/res/layout/dialog_choose_batch_lot.xml +++ b/app/src/main/res/layout/dialog_choose_batch_lot.xml @@ -5,21 +5,10 @@ - - - - - - - - - @@ -28,55 +17,37 @@ android:layout_height="wrap_content" android:layout_gravity="center_horizontal" android:orientation="vertical" - app:cardCornerRadius="12dp" + app:cardCornerRadius="16dp" app:cardElevation="0dp"> + android:orientation="vertical" + android:paddingHorizontal="16dp" + android:paddingVertical="16dp"> - + + + android:layout_marginBottom="16dp" + android:gravity="center_horizontal" + android:text="@string/select_batch_lot" /> - - - - - - - - - - - - - - + android:layout_marginTop="16dp" /> diff --git a/app/src/main/res/raw/success_sound.mp3 b/app/src/main/res/raw/success_sound.mp3 new file mode 100644 index 00000000..2c45524c Binary files /dev/null and b/app/src/main/res/raw/success_sound.mp3 differ diff --git a/app/src/main/res/raw/warning_sound.mp3 b/app/src/main/res/raw/warning_sound.mp3 new file mode 100644 index 00000000..b15e5257 Binary files /dev/null and b/app/src/main/res/raw/warning_sound.mp3 differ diff --git a/build.gradle b/build.gradle index b59726d4..7a03b6b3 100644 --- a/build.gradle +++ b/build.gradle @@ -3,7 +3,7 @@ buildscript { ext { kotlin_version = '1.9.0' - agp_version = '8.2.1' + agp_version = '8.2.2' } repositories {