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/rest/consumers/BarcodeRESTConsumer.java b/app/src/main/java/it/integry/integrywmsnative/core/rest/consumers/BarcodeRESTConsumer.java index f6e5bacf..ea97f448 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 @@ -4,31 +4,17 @@ import javax.inject.Singleton; import it.integry.barcode_base_android_library.model.BarcodeScanDTO; 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; +import it.integry.integrywmsnative.core.utility.BarcodeEan128.UtilityBarcodeEan128; @Singleton public class BarcodeRESTConsumer extends _BaseRESTConsumer { 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(UtilityBarcodeEan128.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..e5bbf592 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.utility.BarcodeEan128.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 76f8fb41..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 @@ -73,6 +73,7 @@ public class DBSettingsModel { private boolean flagOverflowQuantityWarning = false; private String viewPosizioni; private boolean flagDeleteRowOnClose = false; + private boolean flagAllowBarcodeFornitore = false; public boolean isFlagSpedizioneEnableFakeGiacenza() { return flagSpedizioneEnableFakeGiacenza; @@ -596,4 +597,13 @@ public class DBSettingsModel { 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 bfbba78f..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 @@ -493,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/utility/BarcodeEan128/Ean128AI.java b/app/src/main/java/it/integry/integrywmsnative/core/utility/BarcodeEan128/Ean128AI.java new file mode 100644 index 00000000..88766729 --- /dev/null +++ b/app/src/main/java/it/integry/integrywmsnative/core/utility/BarcodeEan128/Ean128AI.java @@ -0,0 +1,127 @@ +package it.integry.integrywmsnative.core.utility.BarcodeEan128; + +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/utility/BarcodeEan128/Ean128AIModel.java b/app/src/main/java/it/integry/integrywmsnative/core/utility/BarcodeEan128/Ean128AIModel.java new file mode 100644 index 00000000..18f018c7 --- /dev/null +++ b/app/src/main/java/it/integry/integrywmsnative/core/utility/BarcodeEan128/Ean128AIModel.java @@ -0,0 +1,40 @@ +package it.integry.integrywmsnative.core.utility.BarcodeEan128; + +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/utility/BarcodeEan128/Ean128AIModelBij.java b/app/src/main/java/it/integry/integrywmsnative/core/utility/BarcodeEan128/Ean128AIModelBij.java new file mode 100644 index 00000000..544b4306 --- /dev/null +++ b/app/src/main/java/it/integry/integrywmsnative/core/utility/BarcodeEan128/Ean128AIModelBij.java @@ -0,0 +1,209 @@ +package it.integry.integrywmsnative.core.utility.BarcodeEan128; + +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/utility/BarcodeEan128/Ean128ISOValueModel.java b/app/src/main/java/it/integry/integrywmsnative/core/utility/BarcodeEan128/Ean128ISOValueModel.java new file mode 100644 index 00000000..cad0fd63 --- /dev/null +++ b/app/src/main/java/it/integry/integrywmsnative/core/utility/BarcodeEan128/Ean128ISOValueModel.java @@ -0,0 +1,8 @@ +package it.integry.integrywmsnative.core.utility.BarcodeEan128; + +public class Ean128ISOValueModel { + + public String ISOCode; + public T Value; + +} diff --git a/app/src/main/java/it/integry/integrywmsnative/core/utility/BarcodeEan128/UtilityBarcodeEan128.java b/app/src/main/java/it/integry/integrywmsnative/core/utility/BarcodeEan128/UtilityBarcodeEan128.java new file mode 100644 index 00000000..e367ae55 --- /dev/null +++ b/app/src/main/java/it/integry/integrywmsnative/core/utility/BarcodeEan128/UtilityBarcodeEan128.java @@ -0,0 +1,333 @@ +package it.integry.integrywmsnative.core.utility.BarcodeEan128; + +import android.annotation.SuppressLint; + +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 UtilityBarcodeEan128 { + public static Ean128Model decode(BarcodeScanDTO barcodeScanDTO){ + byte[] inputEan128ByteArr = barcodeScanDTO.getStringValue().replaceAll("" + ((char) 29), "|").getBytes(); + Ean128AIModelBij ean128AIModelBij = new Ean128AIModelBij(); + + String aiCodeBuffer = ""; + + //char[] charList = barcodeAsString.ToCharArray(); + + 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); + + String aiValue = ""; + + if (!aiModel.flagVariableLength) { + + for (int j = (i + 1); j < (i + 1) + aiModel.dataLength; j++) { + aiValue += (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 = tempBuffer.replace("\r", "").replace("\n", ""); + } + + switch (aiModel.AI) { + case SSCC -> { + if (aiValue.length() > 0 && (aiValue.charAt(0) == '0' || aiValue.charAt(0) == '9')) { + aiValue = aiValue.substring(1); + } + model.Sscc = aiValue; + } + case GTIN -> { + if (aiValue.length() > 0 && (aiValue.charAt(0) == '0' || aiValue.charAt(0) == '9')) { + aiValue = aiValue.substring(1); + } + model.Gtin = aiValue; + } + case CONTENT -> { + if (aiValue.length() > 0 && (aiValue.charAt(0) == '0' || aiValue.charAt(0) == '9')) { + aiValue = aiValue.substring(1); + } + model.Content = aiValue; + } + case BATCH_LOT -> model.BatchLot = aiValue; + case PROD_DATE -> model.ProdDate = convertToDateTime(aiValue); + case DUE_DATE -> model.DueDate = convertToDateTime(aiValue); + case PACK_DATE -> model.PackDate = convertToDateTime(aiValue); + case BEST_BEFORE -> model.BestBefore = String.valueOf(convertToDateTime(aiValue)); + case EXPIRY -> model.Expiry = String.valueOf(convertToDateTime(aiValue)); + case VARIANT -> model.Variant = aiValue; + case SERIAL -> model.Serial = aiValue; + case QTY_DATE_BATCH -> model.QtyDateBatch = aiValue; + case ADDITIONAL_ID -> model.AdditionalID = aiValue; + case CUST_PART_NO -> model.CustPartNumber = aiValue; + case SECONDARY_SERIAL -> model.SecondarySerial = aiValue; + case REF_TO_SOURCE -> model.RefToSource = aiValue; + case VAR_COUNT -> model.VarCount = aiValue; + case NET_WEIGHT_KG -> + model.NetWeightKg = convertToDecimalString(aiValue, aiModel.decimalDigits); + case LENGTH_M -> + model.LengthM = convertToDecimalString(aiValue, aiModel.decimalDigits); + case WIDTH_M -> + model.WidthM = convertToDecimalString(aiValue, aiModel.decimalDigits); + case HEIGHT_M -> + model.HeightM = convertToDecimalString(aiValue, aiModel.decimalDigits); + case AREA_M2 -> + model.AreaM2 = convertToDecimalString(aiValue, aiModel.decimalDigits); + case NET_VOLUME_L -> + model.NetVolumeL = convertToDecimalString(aiValue, aiModel.decimalDigits); + case NET_VOLUME_M3 -> + model.NetVolumeM3 = convertToDecimalString(aiValue, aiModel.decimalDigits); + case NET_WEIGHT_LB -> + model.NetWeightLb = convertToDecimalString(aiValue, aiModel.decimalDigits); + case LENGTH_I -> + model.LengthI = convertToDecimalString(aiValue, aiModel.decimalDigits); + case LENGTH_F -> + model.LengthF = convertToDecimalString(aiValue, aiModel.decimalDigits); + case LENGTH_Y -> + model.LengthY = convertToDecimalString(aiValue, aiModel.decimalDigits); + case WIDTH_I -> + model.WidthI = convertToDecimalString(aiValue, aiModel.decimalDigits); + case WIDTH_F -> + model.WidthF = convertToDecimalString(aiValue, aiModel.decimalDigits); + case WIDTH_Y -> + model.WidthY = convertToDecimalString(aiValue, aiModel.decimalDigits); + case HEIGHT_I -> + model.HeightI = convertToDecimalString(aiValue, aiModel.decimalDigits); + case HEIGHT_F -> + model.HeightF = convertToDecimalString(aiValue, aiModel.decimalDigits); + case HEIGHT_Y -> + model.HeightY = convertToDecimalString(aiValue, aiModel.decimalDigits); + case CROSSWEIGHT_KG_LOG -> + model.CrossweightKgLog = convertToDecimalString(aiValue, aiModel.decimalDigits); + case CROSSWEIGHT_LB_LOG -> + model.CrossweightLbLog = convertToDecimalString(aiValue, aiModel.decimalDigits); + case LENGTH_M_LOG -> + model.LengthMLog = convertToDecimalString(aiValue, aiModel.decimalDigits); + case WIDTH_M_LOG -> + model.WidthMLog = convertToDecimalString(aiValue, aiModel.decimalDigits); + case HEIGHT_M_LOG -> + model.HeigthMLog = convertToDecimalString(aiValue, aiModel.decimalDigits); + case AREA_M2_LOG -> + model.AreaM2Log = convertToDecimalString(aiValue, aiModel.decimalDigits); + case VOLUME_L_LOG -> + model.VolumeLLog = convertToDecimalString(aiValue, aiModel.decimalDigits); + case VOLUME_M3_LOG -> + model.VolumeM3Log = convertToDecimalString(aiValue, aiModel.decimalDigits); + case LENGTH_I_LOG -> + model.LengthILog = convertToDecimalString(aiValue, aiModel.decimalDigits); + case LENGTH_F_LOG -> + model.LengthFLog = convertToDecimalString(aiValue, aiModel.decimalDigits); + case LENGTH_Y_LOG -> + model.LengthYLog = convertToDecimalString(aiValue, aiModel.decimalDigits); + case WIDTH_I_LOG -> + model.WidthILog = convertToDecimalString(aiValue, aiModel.decimalDigits); + case WIDTH_F_LOG -> + model.WidthFLog = convertToDecimalString(aiValue, aiModel.decimalDigits); + case WIDTH_Y_LOG -> + model.WidthYLog = convertToDecimalString(aiValue, aiModel.decimalDigits); + case HEIGHT_I_LOG -> + model.HeigthILog = convertToDecimalString(aiValue, aiModel.decimalDigits); + case HEIGHT_F_LOG -> + model.HeigthFLog = convertToDecimalString(aiValue, aiModel.decimalDigits); + case HEIGHT_Y_LOG -> + model.HeigthYLog = convertToDecimalString(aiValue, aiModel.decimalDigits); + case AREA_I2 -> + model.AreaI2 = convertToDecimalString(aiValue, aiModel.decimalDigits); + case AREA_F2 -> + model.AreaF2 = convertToDecimalString(aiValue, aiModel.decimalDigits); + case AREA_Y2 -> + model.AreaY2 = convertToDecimalString(aiValue, aiModel.decimalDigits); + case AREA_I2_LOG -> + model.AreaI2Log = convertToDecimalString(aiValue, aiModel.decimalDigits); + case AREA_F2_LOG -> + model.AreaF2Log = convertToDecimalString(aiValue, aiModel.decimalDigits); + case AREA_Y2_LOG -> + model.AreaY2Log = convertToDecimalString(aiValue, aiModel.decimalDigits); + case NET_WEIGHT_T -> + model.NetWeightT = convertToDecimalString(aiValue, aiModel.decimalDigits); + case NET_VOLUME_OZ -> + model.NetVolumeOz = convertToDecimalString(aiValue, aiModel.decimalDigits); + case NET_VOLUME_LB -> + model.NetVolumeLb = convertToDecimalString(aiValue, aiModel.decimalDigits); + case NET_VOLUME_G -> + model.NetVolumeG = convertToDecimalString(aiValue, aiModel.decimalDigits); + case VOLUME_Q_LOG -> + model.VolumeQLog = convertToDecimalString(aiValue, aiModel.decimalDigits); + case VOLUME_G_LOG -> + model.VolumeGLog = convertToDecimalString(aiValue, aiModel.decimalDigits); + case NET_VOLUME_I3 -> + model.NetVolumeI3 = convertToDecimalString(aiValue, aiModel.decimalDigits); + case NET_VOLUME_F3 -> + model.NetVolumeF3 = convertToDecimalString(aiValue, aiModel.decimalDigits); + case NET_VOLUME_Y3 -> + model.NetVolumeY3 = convertToDecimalString(aiValue, aiModel.decimalDigits); + case VOLUME_I3_LOG -> + model.VolumeI3Log = convertToDecimalString(aiValue, aiModel.decimalDigits); + case VOLUME_F3_LOG -> + model.VolumeF3Log = convertToDecimalString(aiValue, aiModel.decimalDigits); + case VOLUME_Y3_LOG -> + model.VolumeY3Log = convertToDecimalString(aiValue, aiModel.decimalDigits); + case COUNT -> model.Count = Integer.parseInt(aiValue); + case AMOUNT -> + model.Amount = convertToDecimalString(aiValue, aiModel.decimalDigits); + case AMOUNT_ISO -> + model.AmountISO = convertToIsoValueModel(aiValue, aiModel.decimalDigits, + Double::parseDouble, + (input, input2) -> String.valueOf(convertToDecimalString(input, input2))); + case PRICE -> + model.Price = convertToDecimalString(aiValue, aiModel.decimalDigits); + case PRICE_ISO -> + model.PriceISO = convertToIsoValueModel(aiValue, aiModel.decimalDigits, + Double::parseDouble, + (input, input2) -> String.valueOf(convertToDecimalString(input, input2))); + case ORDER_NUMBER -> model.OrderNumber = aiValue; + case CONSIGNMENT -> model.Consignment = aiValue; + case SHIPMENT_NO -> model.ShipmentNo = aiValue; + case ROUTE -> model.Route = aiValue; + case SHIP_TO_LOC -> model.ShipToLoc = aiValue; + case BILL_TO_LOC -> model.BillToLoc = aiValue; + case PURCHASE_FROM_LOC -> model.PurchaseFromLoc = aiValue; + case SHIP_FOR_LOC -> model.ShipForLoc = aiValue; + case LOC_NO -> model.LocationNumber = aiValue; + case PAY_TO_LOC -> model.PayToLoc = aiValue; + case SHIP_TO_POST -> model.ShipToPost = aiValue; + case SHIP_TO_POST_ISO -> + model.ShipToPostISO = convertToIsoValueModel(aiValue, 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; + case COUNTRY_INITIAL_PROCESS -> + model.ShipToPostISO = convertToIsoValueModel(aiValue, 0, + input -> input, + (input, input2) -> input); + case COUNTRY_PROCESS -> model.CountryProcess = aiValue; + case COUNTRY_DISASSEMBLY -> model.CountryDisassembly = aiValue; + case COUNTRY_FULL_PROCESS -> model.CountryFullProcess = aiValue; + case NSN -> model.NSN = aiValue; + case MEAT_CUT -> model.MeatCut = aiValue; + case DIMENSIONS -> model.Dimensions = aiValue; + case CMT_NO -> model.CmtNo = aiValue; + case GRAI -> model.Grai = aiValue; + case GIAI -> model.Giai = aiValue; + case PRICE_PER_UNIT -> model.PricePerUnit = aiValue; + case GCTIN -> model.Gctin = aiValue; + case IBAN -> model.Iban = aiValue; + case PROD_TIME -> model.ProdTime = convertToDateTime(aiValue); + case GSRN -> model.Gsrn = aiValue; + case REF_NO -> model.RefNo = aiValue; + case COUPON_1 -> model.Coupon1 = aiValue; + case COUPON_2 -> model.Coupon2 = aiValue; + case COUPON_3 -> model.Coupon3 = aiValue; + case INTERNAL_PART -> model.InternalPart = aiValue; + case INTERNAL_1 -> model.Internal1 = aiValue; + case INTERNAL_2 -> model.Internal2 = aiValue; + case INTERNAL_3 -> model.Internal3 = aiValue; + case INTERNAL_4 -> model.Internal4 = aiValue; + case INTERNAL_5 -> model.Internal5 = aiValue; + case INTERNAL_6 -> model.Internal6 = aiValue; + case INTERNAL_7 -> model.Internal7 = aiValue; + case INTERNAL_8 -> model.Internal8 = aiValue; + case INTERNAL_9 -> model.Internal9 = aiValue; + default -> { + } + } + + aiCodeBuffer = ""; + } + } else { + throw new Exception(String.format("Il barcode non è un EAN128 valido (%s)", new String(inputEan128ByteArr))); + } + } + + return model; + } + + + private static float convertToDecimalString(String sourceString, int numberOfdecimalDigits) { + + int divider = (int) Math.pow(10, numberOfdecimalDigits); + + return Float.parseFloat(sourceString) / divider; + } + + private static 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 static 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 { + @SuppressLint("SimpleDateFormat") 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/gest/accettazione_ordini_picking/AccettazioneOrdiniPickingViewModel.java b/app/src/main/java/it/integry/integrywmsnative/gest/accettazione_ordini_picking/AccettazioneOrdiniPickingViewModel.java index 128259c9..46914200 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 @@ -40,6 +40,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; @@ -51,6 +52,7 @@ import it.integry.integrywmsnative.core.rest.model.uds.DeleteULRequestDTO; import it.integry.integrywmsnative.core.rest.model.uds.InsertUDCRowRequestDTO; import it.integry.integrywmsnative.core.rest.model.uds.PrintULRequestDTO; import it.integry.integrywmsnative.core.settings.SettingsManager; +import it.integry.integrywmsnative.core.utility.BarcodeEan128.UtilityBarcodeEan128; import it.integry.integrywmsnative.core.utility.UtilityBarcode; import it.integry.integrywmsnative.core.utility.UtilityBigDecimal; import it.integry.integrywmsnative.core.utility.UtilityDate; @@ -209,7 +211,11 @@ public class AccettazioneOrdiniPickingViewModel { //dell'etichetta anonima this.executeEtichettaAnonimaNotOpenedLU(barcodeScanDTO, onComplete); } else { - this.processBarcodeNotOpenedLU(barcodeScanDTO, onComplete); + if (SettingsManager.iDB().isFlagAllowBarcodeFornitore() && UtilityBarcode.isEtichetta128(barcodeScanDTO)){ + this.executeBarcodeFornitore(barcodeScanDTO); + }else{ + this.processBarcodeNotOpenedLU(barcodeScanDTO, onComplete); + } } } else { @@ -221,6 +227,17 @@ public class AccettazioneOrdiniPickingViewModel { } } + private void executeBarcodeFornitore(BarcodeScanDTO barcodeScanDTO) { + try{ + Ean128Model ean128Model = UtilityBarcodeEan128.decode(barcodeScanDTO); + + String barcodeProd = null; + if (!UtilityString.isNullOrEmpty(ean128Model.Sscc)) barcodeProd = ean128Model.Sscc; + }catch (Exception e){ + this.sendError(e); + } + } + private void executeEtichettaAnonimaNotOpenedLU(BarcodeScanDTO barcodeScanDTO, Runnable onComplete) { mColliMagazzinoRESTConsumer.getBySSCC(barcodeScanDTO.getStringValue(), true, false, mtbColt -> { @@ -260,7 +277,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 +285,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); }