diff --git a/GMW/GMW.suo b/GMW/GMW.suo
index d25f9e99..ea2bfcb4 100644
Binary files a/GMW/GMW.suo and b/GMW/GMW.suo differ
diff --git a/GMW/GMW/bin/GMW.dll b/GMW/GMW/bin/GMW.dll
index d1b862ba..424716d5 100644
Binary files a/GMW/GMW/bin/GMW.dll and b/GMW/GMW/bin/GMW.dll differ
diff --git a/GMW/GMW/bin/GMW_data.dll b/GMW/GMW/bin/GMW_data.dll
index 394b8188..db05fac7 100644
Binary files a/GMW/GMW/bin/GMW_data.dll and b/GMW/GMW/bin/GMW_data.dll differ
diff --git a/GMW/GMW/obj/Debug/GMW.dll b/GMW/GMW/obj/Debug/GMW.dll
index d1b862ba..424716d5 100644
Binary files a/GMW/GMW/obj/Debug/GMW.dll and b/GMW/GMW/obj/Debug/GMW.dll differ
diff --git a/GMW/GMW/obj/Debug/ResolveAssemblyReference.cache b/GMW/GMW/obj/Debug/ResolveAssemblyReference.cache
index 98493307..d3d867bb 100644
Binary files a/GMW/GMW/obj/Debug/ResolveAssemblyReference.cache and b/GMW/GMW/obj/Debug/ResolveAssemblyReference.cache differ
diff --git a/GMW/GMW_data/GMW_data.csproj b/GMW/GMW_data/GMW_data.csproj
index 7db1e899..f4c68e9f 100644
--- a/GMW/GMW_data/GMW_data.csproj
+++ b/GMW/GMW_data/GMW_data.csproj
@@ -82,6 +82,7 @@
+
diff --git a/GMW/GMW_data/MagClass.cs b/GMW/GMW_data/MagClass.cs
index ac14d5c6..d286dd5a 100644
--- a/GMW/GMW_data/MagClass.cs
+++ b/GMW/GMW_data/MagClass.cs
@@ -14,7 +14,6 @@ namespace GMW_data
#region area table adapters
// variabile di tipo table adapter
-
public DS_magazzinoTableAdapters.AnagMagTableAdapter taAnagMag;
public DS_magazzinoTableAdapters.BlocchiTableAdapter taBlocchi;
public DS_magazzinoTableAdapters.CelleTableAdapter taCelle;
diff --git a/GMW/GMW_data/TermClass.cs b/GMW/GMW_data/TermClass.cs
new file mode 100644
index 00000000..94ca91c5
--- /dev/null
+++ b/GMW/GMW_data/TermClass.cs
@@ -0,0 +1,869 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using SteamWare;
+
+namespace GMW_data
+{
+ ///
+ /// classe gestione operazioni con terminalino
+ ///
+ public class TermClass
+ {
+ #region area table adapters
+
+ // variabile di tipo table adapter
+ #if false
+ public DS_magazzinoTableAdapters.AnagMagTableAdapter taAnagMag;
+ public DS_magazzinoTableAdapters.BlocchiTableAdapter taBlocchi;
+ public DS_magazzinoTableAdapters.CelleTableAdapter taCelle;
+ public DS_magazzinoTableAdapters.TipoCellaTableAdapter taTipoCella;
+ public DS_magazzinoTableAdapters.ElencoCartelliniTableAdapter taCartellini;
+ public DS_magazzinoTableAdapters.PosizioneUdcCorrenteTableAdapter taPosUdcCorr;
+ public DS_magazzinoTableAdapters.PosizioneUdcStoricoTableAdapter taPosUdcStorico;
+ public DS_magazzinoTableAdapters.V_MagazziniOverviewTableAdapter taMagOverw;
+ public DS_magazzinoTableAdapters.V_DettMagPartTableAdapter taDettMagPart;
+ public DS_magazzinoTableAdapters.v_UdcDetailTableAdapter taDettUDC;
+ public DS_magazzinoTableAdapters.ElencoListePrelievoTableAdapter taElencoListePrelievo;
+ public DS_magazzinoTableAdapters.ElencoCartelliniTableAdapter taElencoCartellini;
+ public DS_magazzinoTableAdapters.RigheListePrelievoTableAdapter taRigheListePrelievo;
+ public DS_magazzinoTableAdapters.TipoListaPrelievoTableAdapter taTipoListaPrelievo;
+ public DS_magazzinoTableAdapters.V_ParticolariOverviewTableAdapter taVParticolariOverwiew;
+ public DS_magazzinoTableAdapters.v_particolariEsponenteFiguraTableAdapter taPartExpFig;
+ #endif
+
+
+ ///
+ /// init dei table adapters
+ ///
+ protected void initTA()
+ {
+ // istanzio oggetto
+ #if false
+ taAnagMag = new GMW_data.DS_magazzinoTableAdapters.AnagMagTableAdapter();
+ taBlocchi = new GMW_data.DS_magazzinoTableAdapters.BlocchiTableAdapter();
+ taCelle = new GMW_data.DS_magazzinoTableAdapters.CelleTableAdapter();
+ taTipoCella = new GMW_data.DS_magazzinoTableAdapters.TipoCellaTableAdapter();
+ taCartellini = new GMW_data.DS_magazzinoTableAdapters.ElencoCartelliniTableAdapter();
+ taPosUdcCorr = new GMW_data.DS_magazzinoTableAdapters.PosizioneUdcCorrenteTableAdapter();
+ taPosUdcStorico = new GMW_data.DS_magazzinoTableAdapters.PosizioneUdcStoricoTableAdapter();
+ taMagOverw = new GMW_data.DS_magazzinoTableAdapters.V_MagazziniOverviewTableAdapter();
+ taDettMagPart = new GMW_data.DS_magazzinoTableAdapters.V_DettMagPartTableAdapter();
+ taDettUDC = new GMW_data.DS_magazzinoTableAdapters.v_UdcDetailTableAdapter();
+ taElencoListePrelievo = new GMW_data.DS_magazzinoTableAdapters.ElencoListePrelievoTableAdapter();
+ taElencoCartellini = new GMW_data.DS_magazzinoTableAdapters.ElencoCartelliniTableAdapter();
+ taRigheListePrelievo = new GMW_data.DS_magazzinoTableAdapters.RigheListePrelievoTableAdapter();
+ taTipoListaPrelievo = new GMW_data.DS_magazzinoTableAdapters.TipoListaPrelievoTableAdapter();
+ taVParticolariOverwiew = new GMW_data.DS_magazzinoTableAdapters.V_ParticolariOverviewTableAdapter();
+ taPartExpFig = new GMW_data.DS_magazzinoTableAdapters.v_particolariEsponenteFiguraTableAdapter();
+ #endif
+ }
+ ///
+ /// effettua setup dei connection strings da web.config delal singola applicazione
+ ///
+ protected virtual void setupConnectionStringBase()
+ {
+ // connections del db
+ #if false
+ taAnagMag.Connection.ConnectionString = memLayer.ML.confReadString("GMWConnectionString");
+ taBlocchi.Connection.ConnectionString = memLayer.ML.confReadString("GMWConnectionString");
+ taCelle.Connection.ConnectionString = memLayer.ML.confReadString("GMWConnectionString");
+ taTipoCella.Connection.ConnectionString = memLayer.ML.confReadString("GMWConnectionString");
+ taCartellini.Connection.ConnectionString = memLayer.ML.confReadString("GMWConnectionString");
+ taPosUdcCorr.Connection.ConnectionString = memLayer.ML.confReadString("GMWConnectionString");
+ taPosUdcStorico.Connection.ConnectionString = memLayer.ML.confReadString("GMWConnectionString");
+ taMagOverw.Connection.ConnectionString = memLayer.ML.confReadString("GMWConnectionString");
+ taDettMagPart.Connection.ConnectionString = memLayer.ML.confReadString("GMWConnectionString");
+ taDettUDC.Connection.ConnectionString = memLayer.ML.confReadString("GMWConnectionString");
+ taElencoListePrelievo.Connection.ConnectionString = memLayer.ML.confReadString("GMWConnectionString");
+ taElencoCartellini.Connection.ConnectionString = memLayer.ML.confReadString("GMWConnectionString");
+ taRigheListePrelievo.Connection.ConnectionString = memLayer.ML.confReadString("GMWConnectionString");
+ taTipoListaPrelievo.Connection.ConnectionString = memLayer.ML.confReadString("GMWConnectionString");
+ taVParticolariOverwiew.Connection.ConnectionString = memLayer.ML.confReadString("GMWConnectionString");
+ taPartExpFig.Connection.ConnectionString = memLayer.ML.confReadString("GMWConnectionString");
+ #endif
+ }
+
+ #endregion
+
+ #region Inizializzazione
+
+ protected TermClass()
+ {
+ initTA();
+ setupConnectionStringBase();
+ }
+
+ ///
+ /// oggetto static per fare chiamate sul magazzino
+ ///
+ public static TermClass termin = new TermClass();
+
+ #endregion
+
+ #region metodi protected
+
+#if false
+ ///
+ /// aggiunge le righe liste di prelievo necessarie a soddisfare la richiesta in logica FIFO dato un elenco di cartellini, la qta totale da allocare e la lista attuale
+ ///
+ ///
+ ///
+ ///
+ private void allocaRigheListaPrelievo(decimal QtaTot, string codListaAttuale, DS_magazzino.ElencoCartelliniDataTable tabellaElencoCartellini)
+ {
+ //ricavo il valore UDC della riga del più vecchio
+ string udcAttuale;
+ bool qtaOk = false;
+ bool dataFinished = false;
+ int progrUdc = 0;
+ int numUdcDisponibili = tabellaElencoCartellini.Rows.Count;
+ // contiene la quantità della riga attuale
+ decimal qtaRiga;
+ // somma progressiva della qta allocata - calcolo da db!
+ decimal qtaAllocata = taElencoListePrelievo.getByCodLista(codListaAttuale)[0].Prelevato;
+ //ciclo WHILE per lo riempimento FIFO con UDC secondo richiesta a partire da elenco fornito
+ while (!qtaOk && !dataFinished)
+ {
+ /*
+ * crea una riga in righelistaprelievo passando come valori
+ * il codlista attuale ricavato da sopr
+ * l'UDC dal primo della tabella getOlderUDC
+ *
+ *
+ * recupero quantità dalla riga corrente;
+ *
+ * imposto proposto a 1;
+ * imposto prelevato 0;
+ * taRighelistePreliveo.Insert;
+ *
+ * qtaAllocata = qtaAllocata + Qta di questa riga (riuso il valore della colonna QTA
+ * tabella[contatore]; contatore++;
+ * qtaOk = (qtaAllocata >= qtaRichiesta)
+ * dataFinished = (contatore >= numRighe);
+ *
+ * */
+ // ricavo la riga più vecchia
+ qtaRiga = tabellaElencoCartellini[progrUdc].Qta;
+ udcAttuale = tabellaElencoCartellini[progrUdc].UDC;
+ // eseguo query di insert
+ taRigheListePrelievo.Insert(codListaAttuale, udcAttuale, qtaRiga, true, false);
+
+ //incremento qta allocata
+ qtaAllocata = (qtaAllocata + qtaRiga);
+ //incremento contatore
+ progrUdc++;
+
+ // verifico le condizioni, false se non cambia nulla true se cambia e si esce dal while
+ qtaOk = (qtaAllocata >= QtaTot);
+ dataFinished = (progrUdc >= numUdcDisponibili);
+ }
+ }
+#endif
+
+ #endregion
+
+ #region Metodi esposti
+
+#if false
+ ///
+ /// effettua lo spostamento di un UDC tra 2 posizioni indicate
+ ///
+ /// Codice company/sito
+ /// Codice UDC
+ /// Cella di origine
+ /// Cella di destinazione
+ /// esito comando
+ public bool spostaUDC(string CodCS, string UDC, int IdxCellaFrom, int IdxCellaTo)
+ {
+ bool answ = false;
+ try
+ {
+ taPosUdcCorr.stp_spostaUdc(CodCS, UDC, IdxCellaFrom, IdxCellaTo);
+ // cerco nuova posizione...
+ if (taPosUdcCorr.getByCellaUdc(UDC, IdxCellaTo).Rows.Count > 0)
+ {
+ answ = true;
+ }
+ }
+ catch
+ { }
+ return answ;
+ }
+ ///
+ /// effettua lo scaricamento di un UDC (x spedizione)
+ ///
+ /// Codice company/sito
+ /// Codice UDC
+ /// Cella di origine
+ /// Codice posizione UDC finale
+ /// esito comando
+ public bool scaricaUDC(string CodCS, string UDC, int IdxCellaFrom, int IdxPosizUdc)
+ {
+ bool answ = false;
+ try
+ {
+ taPosUdcCorr.stp_scaricaUdc(CodCS, UDC, IdxCellaFrom, IdxPosizUdc);
+ answ = true;
+ }
+ catch
+ { }
+ return answ;
+ }
+ ///
+ /// rettifica la qta di un UDC
+ ///
+ /// Codice soggetto/operatore
+ /// Codice UDC
+ /// Nuova quantita associata
+ /// esito comando
+ public bool rettificaQtaUDC(string CodSoggetto, string UDC, decimal qta)
+ {
+ bool answ = false;
+ try
+ {
+ int fatti = 0;
+ fatti = taCartellini.updateQty(UDC, CodSoggetto, "U", "UDC_QTY", qta).Rows.Count;
+ if (fatti > 0)
+ {
+ answ = true;
+ }
+ }
+ catch
+ { }
+ return answ;
+ }
+ ///
+ /// Crea una lista di prelievo andando a prenotare gli UDC del particolare richiesto in logica FIFO
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ public string creaListaPrelievo(string CodCS, string TipoListaPrelievo, string Particolare, string Esponente, string Figura, decimal QtaTot, string CodImballo)
+ {
+ /*
+ * - ordini gli UDC per data dal + vecchio (data fusione? direi di si!)
+ *
+ * - prenda 1 ad 1 gli UDC, e crei dall'UDC un record in RigheListePrelievo con
+ * - CodLista (dal record appena generato)
+ * - UDC (il + vecchio trovato)
+ * - QTA (dell'UDC)
+ * - Proposto = 1 (vero)
+ * - Prelevato = 0 (falso)
+ * - questo loop di prelievo va eseguito fino a quanto la somam delle qty sia maggiore o uguale alla qty richiesta, o fino a quando siano finiti gli UDC
+ *
+ * - potrebbe esser cambiato approccio e si potrebbe fare una query ceh seleziona i + vecchi UDC in numero corretto fin dall'inizio da includere facendo una cosa del tipo
+ * - calcolo media qty degli UDC papabili x le condizioni dette prima
+ * - dato il totale ottengo quanti UDC mi servono arrotondando x eccesso (se ho 200 richiesti, media 70, CEIL(200/70) = 3)
+ * - faccio un SELECT TOP n (qui 3) * FROM ElencoCartellini WHERE ...
+ * - e questa select la uso x farci un INSERT INTO in RigheListePrelievo
+ *
+ * - terminati questi step si aggiorna la lista di prelievo emttendo come qty quella data dalla somma degli UDC davvero proposti
+ *
+ * - la stored deve restituire il codice della lista di prelievo e passarla qui, che a sua volta passerà al chiamante il codice della lista
+ * */
+
+ string answ = "K";
+
+ // variabile di tipo datetime per data corrente
+ DateTime adesso = DateTime.Now;
+
+ // dati che mi servono...
+ int idxPosizione = 20; // !!! Verificare parametrico - me lo faccio passare... // !!!FARE!!!
+
+ // non la valorizzo qui ma calcolo ... se non fa verificare
+ string RagioneSociale = "";
+
+ // ricavo da session...
+ string codSoggetto = "";
+ try
+ {
+ codSoggetto = DataProxy.obj.taSogg2Oper.getBuUserDominio(user_std.UtSn.utente, user_std.UtSn.dominio)[0].CodSoggetto;
+ }
+ catch (Exception e)
+ {
+ logger.lg.scriviLog(string.Format("Non sono riuscito a recuperare il codice soggetto per l'utente loggato: {0}", user_std.UtSn.userNameAD), tipoLog.ERROR);
+ }
+ // proseguo SOLO se ho trovato cod soggetto...
+ if (codSoggetto != "")
+ {
+ // li ricavo da db successivamente
+ string disegnoGrezzo = "";
+ string descParticolare = "";
+ string codCliente = "";
+
+
+ // ricavo codCliente
+ try
+ {
+ codCliente = DataProxy.obj.taAnagParticolari.getByParticolare(Particolare)[0].CodCliente;
+ }
+ catch { }
+
+ // ricavo disegnoGrezzo
+ try
+ {
+ disegnoGrezzo = DataProxy.obj.taAnagParticolari.getByParticolare(Particolare)[0].DisegnoGrezzo;
+ }
+ catch { }
+
+ try
+ {
+ descParticolare = DataProxy.obj.taAnagParticolari.getByParticolare(Particolare)[0].DescParticolare;
+ }
+ catch { }
+
+ // dato codcliente ricavo la ragione sociale
+ try
+ {
+ RagioneSociale = DataProxy.obj.taAnagClienti.getRagioneSocialeByCodCliente(codCliente)[0].RagSociale;
+ }
+ catch { }
+
+
+ string codListaAttuale = "";
+ try
+ {
+ // eseguo soltanto la query (meglio con try catch così se non c'è non dà errore...)
+ DS_magazzino.ElencoListePrelievoDataTable tabellaElencoListe = taElencoListePrelievo.InsertQuery(string.Format("{0:yy}", adesso), string.Format("{0:MM}", adesso), idxPosizione, memLayer.ML.confReadString("CodCS"), codCliente, RagioneSociale, codSoggetto, Particolare, descParticolare, disegnoGrezzo, Esponente, Figura, CodImballo, QtaTot);
+
+ // ricavo prima (e unica) riga dalla select
+ DS_magazzino.ElencoListePrelievoRow rigaElencoListe = tabellaElencoListe[0];
+
+ // ricavo valore del CodLista attuale appena inserito
+ codListaAttuale = rigaElencoListe.CodLista;
+ }
+ catch
+ { }
+ if (codListaAttuale != "")
+ {
+ answ = codListaAttuale;
+ // stored per ricavare il più vecchio in ordine ASC per Data Fusione - TABELLA
+ //DS_magazzino.ElencoCartelliniDataTable tabellaElencoCartellini = taElencoCartellini.getOlderUDC(Esponente, Particolare, idxPosizione);
+ DS_magazzino.ElencoCartelliniDataTable tabellaElencoCartellini = taElencoCartellini.getUdcUnusedOlder(codListaAttuale);
+ allocaRigheListaPrelievo(QtaTot, codListaAttuale, tabellaElencoCartellini);
+ }
+ }
+ return answ;
+ }
+ ///
+ /// indica come attivata in carico di una lista di prelievo
+ ///
+ /// Codice company/sito
+ /// codice della lista di prelievo
+ /// cod operatore carrellista
+ ///
+ public esitoOperazione attivaListaPrelievo(string CodCS, string CodLista, string CodSoggetto)
+ {
+ // da chiamare quando clicco e inizio lista prelievo .... vedi sopra
+ esitoOperazione answ = esitoOperazione.errore;
+
+ try
+ {
+ // la query recupera la lista in base al CodLista
+ DS_magazzino.ElencoListePrelievoDataTable tabella = taElencoListePrelievo.getByCodLista(CodLista);
+ DS_magazzino.ElencoListePrelievoRow riga = tabella[0];
+
+ // se la lista esiste...
+ if (tabella.Rows.Count > 0)
+ {
+ // se la lista è ancora non completata
+ if (riga.CodStatoLista == (int)statoLista.bozza)
+ {
+ taElencoListePrelievo.updateStato(CodSoggetto, CodLista, (int)statoLista.generata);
+ answ = esitoOperazione.ok;
+ }
+ // se è già completata o iniziata dà errore
+ else
+ {
+ answ = esitoOperazione.errore_readOnly;
+ }
+ }
+ // se la lista non esiste dai errore
+ else
+ {
+ answ = esitoOperazione.errore;
+ }
+ }
+ catch
+ { }
+ return answ;
+ }
+ ///
+ /// indica presa in carico di una lista di prelievo
+ ///
+ /// Codice company/sito
+ /// codice della lista di prelievo
+ /// cod operatore carrellista
+ ///
+ public esitoOperazione iniziaListaPrelievo(string CodCS, string CodLista, string CodSoggetto)
+ {
+ // da chiamare quando clicco e inizio lista prelievo .... vedi sopra
+ esitoOperazione answ = esitoOperazione.errore;
+
+ try
+ {
+ // la query recupera la lista in base al CodLista
+ DS_magazzino.ElencoListePrelievoDataTable tabella = taElencoListePrelievo.getByCodLista(CodLista);
+ DS_magazzino.ElencoListePrelievoRow riga = tabella[0];
+
+ // se la lista esiste...
+ if (tabella.Rows.Count > 0)
+ {
+ // se la lista è ancora non completata
+ if (riga.CodStatoLista == (int)statoLista.generata)
+ {
+ taElencoListePrelievo.updateStato(CodSoggetto, CodLista, (int)statoLista.iniziata);
+ answ = esitoOperazione.ok;
+ }
+ // se è già completata o iniziata dà errore
+ else
+ {
+ answ = esitoOperazione.errore_readOnly;
+ }
+ }
+ // se la lista non esiste dai errore
+ else
+ {
+ answ = esitoOperazione.errore;
+ }
+ }
+ catch
+ { }
+ return answ;
+ }
+ ///
+ /// indica come completata (da aprte del magazziniere) una lista di prelievo
+ ///
+ /// Codice company/sito
+ /// codice della lista di prelievo
+ /// cod operatore carrellista
+ ///
+ public esitoOperazione completaListaPrelievo(string CodCS, string CodLista, string CodSoggetto)
+ {
+ // da chiamare quando clicco e inizio lista prelievo .... vedi sopra
+ esitoOperazione answ = esitoOperazione.errore;
+
+ try
+ {
+ // la query recupera la lista in base al CodLista
+ DS_magazzino.ElencoListePrelievoDataTable tabella = taElencoListePrelievo.getByCodLista(CodLista);
+ DS_magazzino.ElencoListePrelievoRow riga = tabella[0];
+
+ // se la lista esiste...
+ if (tabella.Rows.Count > 0)
+ {
+ // se la lista è ancora non completata
+ if (riga.CodStatoLista == (int)statoLista.iniziata)
+ {
+ // ricavo il codtipolista
+ string codTipoListaAttuale = riga.CodTipoLista;
+
+ //leggo da tipoLista prelievo alcuni dati (es codcella di destinazione)
+ DS_magazzino.TipoListaPrelievoDataTable tabellaTipoLista = taTipoListaPrelievo.getByCodTipoLista(codTipoListaAttuale);
+ DS_magazzino.TipoListaPrelievoRow rigaTipoLista = tabellaTipoLista[0];
+
+ // leggo da righe lista prelievo il dato udc che mi serve
+ DS_magazzino.RigheListePrelievoDataTable tabellaRigheListaPrelievo = taRigheListePrelievo.getByCodLista(CodLista);
+ DS_magazzino.RigheListePrelievoRow rigaListaPrelievo = tabellaRigheListaPrelievo[0];
+
+ // leggo il codice della cella...
+ string codCellaDestAttuale = rigaTipoLista.CodCella;
+ // lo trasformo x avere la cella di destinazione...
+ int idxCellaTo = taCelle.getByCodCella(codCellaDestAttuale)[0].IdxCella;
+
+ // sposto ("metto a terra") gli UDC
+ foreach (DS_magazzino.RigheListePrelievoRow row in tabellaRigheListaPrelievo.Rows)
+ {
+ // ricavo il codice UDC...
+ string UDC = row.UDC;
+ // mi serve per posizione udc corrente
+ DS_magazzino.PosizioneUdcCorrenteRow rigaUdcCorrente = taPosUdcCorr.getByUDC(UDC)[0];
+ // il secondo idx che mi serve
+ int idxCellaFrom = rigaUdcCorrente.IdxCella;
+ // sposto UDC
+ spostaUDC(CodCS, UDC, idxCellaFrom, idxCellaTo);
+ }
+
+ taElencoListePrelievo.updateStato(CodSoggetto, CodLista, (int)statoLista.completata);
+ answ = esitoOperazione.ok;
+ }
+ // se è già completata o NON iniziata dà errore
+ else
+ {
+ answ = esitoOperazione.errore_readOnly;
+ }
+ }
+ // se la lista non esiste dai errore
+ else
+ {
+ answ = esitoOperazione.errore;
+ }
+ }
+ catch
+ { }
+ return answ;
+ }
+ ///
+ /// Effettua lo scaricamento della lista di prelievo indicata, ovvero
+ /// - toglie dalle posizioni di magazzino tutti gli UDC indicati come prelevati (liberando tali posizioni)
+ /// - assegna tutti gli UDC prelevati alla cella indicata per il tipo di lista di prelievo interessata
+ /// - elimina eventuali righe di prelievo della lista per UDC non effettivamente prelevate
+ /// - chiude la lista di prelievo (completata = 1)
+ ///
+ /// Codice company/sito
+ /// codice della lista di prelievo
+ /// cod operatore carrellista
+ /// esito comando
+ public esitoOperazione scaricaListaPrelievo(string CodCS, string CodLista, string CodSoggetto)
+ {
+ /*
+ * Questa funzione serve ALLA FINE delle operazioni di prelievo, x chiudere la lista di prelievo
+ * - controllo se la lista esiste, ed è ancora NON completata
+ * - se risulta già completata errore xché è "readOnly" la lista essendo già completata (vedere l'enum in fondo al codice)
+ * - se la lista è ok
+ * - leggo da tipoLista prelievo alcuni dati (es codcella di destinazione)
+ * - sposto TUTTI gli UDC delle righeListaPrelievo, da posizione attuale a posizione indicata da tipo lista
+ * (quindi da codCella --> IdxCella --> spostamento
+ * indico la lista come completata = 1 (true)
+ * */
+
+ esitoOperazione answ = esitoOperazione.errore;
+ int trovate = 0;
+ DS_magazzino.ElencoListePrelievoDataTable tabella;
+ DS_magazzino.ElencoListePrelievoRow riga;
+ try
+ {
+ tabella = taElencoListePrelievo.getByCodLista(CodLista);
+ riga = tabella[0];
+ trovate = tabella.Rows.Count;
+
+ // se la lista esiste...
+ if (trovate > 0)
+ {
+ // se la lista è completata
+ if (riga.CodStatoLista == (int)statoLista.completata)
+ {
+ // ricavo il codtipolista
+ string codTipoListaAttuale = riga.CodTipoLista;
+
+ //leggo da tipoLista prelievo alcuni dati (es codcella di destinazione)
+ DS_magazzino.TipoListaPrelievoDataTable tabellaTipoLista = taTipoListaPrelievo.getByCodTipoLista(codTipoListaAttuale);
+ DS_magazzino.TipoListaPrelievoRow rigaTipoLista = tabellaTipoLista[0];
+
+ // leggo da righe lista prelievo il dato udc che mi serve
+ DS_magazzino.RigheListePrelievoDataTable tabellaRigheListaPrelievo = taRigheListePrelievo.getByCodLista(CodLista);
+ DS_magazzino.RigheListePrelievoRow rigaListaPrelievo = tabellaRigheListaPrelievo[0];
+
+ // leggo il codice della cella...
+ int idxPosizUdc = rigaTipoLista.IdxPosizioneFinal;
+
+ // scarico i vari UDC dal magazzino (come posizione corrente)
+ foreach (DS_magazzino.RigheListePrelievoRow row in tabellaRigheListaPrelievo.Rows)
+ {
+ // ricavo il codice UDC...
+ string UDC = row.UDC;
+ // mi serve per posizione udc corrente
+ DS_magazzino.PosizioneUdcCorrenteRow rigaUdcCorrente = taPosUdcCorr.getByUDC(UDC)[0];
+ // il secondo idx che mi serve
+ int idxCellaFrom = rigaUdcCorrente.IdxCella;
+ // sposto UDC
+ scaricaUDC(CodCS, UDC, idxCellaFrom, idxPosizUdc);
+ }
+ // segna come scaricata la lista prelievo
+ taElencoListePrelievo.updateStato(CodSoggetto, CodLista, (int)statoLista.scaricata);
+ // restituisce ok
+ answ = esitoOperazione.ok;
+ // ora eseguo stored x copiare in altra tabella (quella per AS...)
+ taElencoListePrelievo.stp_LP_exportToAs400(CodLista);
+ }
+ // se è già completata dà errore
+ else
+ {
+ answ = esitoOperazione.errore_readOnly;
+ }
+ }
+ // se la lista non esiste dai errore
+ else
+ {
+ answ = esitoOperazione.errore;
+ }
+ }
+ catch
+ { }
+ return answ;
+ }
+ ///
+ /// Verifica la corrispondenza dati tra RigheListePrelievo ed ElencoCartellini
+ ///
+ ///
+ ///
+ ///
+ public bool verificaDatiUdc(string CodLista, string UDC)
+ {
+ bool answ = false;
+
+ try
+ {
+ DS_magazzino.ElencoListePrelievoDataTable tabellaElenco = taElencoListePrelievo.getByCodLista(CodLista);
+ DS_magazzino.ElencoListePrelievoRow rigaElenco = tabellaElenco[0];
+
+ DS_magazzino.ElencoCartelliniDataTable tabellaUDC = taElencoCartellini.getDetailsUdcByUdc(UDC);
+ DS_magazzino.ElencoCartelliniRow rigaUDC = tabellaUDC[0];
+
+ // ricavo dati da confrontare - da Lista ricavo particolare/esponente/figura
+ string particolareLista = rigaElenco.Particolare;
+ string esponenteLista = rigaElenco.Esponente;
+ string figuraLista = rigaElenco.Figura;
+ string codImballoLista = rigaElenco.CodImballo;
+
+ //stessi dati da UDC
+ string particolareUDC = rigaUDC.Particolare;
+ string esponenteUDC = rigaUDC.Esponente;
+ string figuraUDC = rigaUDC.Figura;
+ string codImballoUDC = rigaUDC.CodImballo;
+
+ // condizioni di uguaglianza...
+ bool particolareOk = false;
+ bool esponenteOk = false;
+ bool figuraOk = false;
+ bool codImballoOk = false;
+ // verifico le condizioni 1 ad 1...
+ particolareOk = (particolareLista == particolareUDC);
+ if (esponenteLista == "*")
+ {
+ esponenteOk = true;
+ }
+ else
+ {
+ esponenteOk = (esponenteLista == esponenteUDC);
+ }
+ if (figuraLista == "*")
+ {
+ figuraOk = true;
+ }
+ else
+ {
+ figuraOk = (figuraLista == figuraUDC);
+ }
+ if (codImballoLista == "*")
+ {
+ codImballoOk = true;
+ }
+ else
+ {
+ codImballoOk = (codImballoLista == codImballoUDC);
+ }
+
+ // verifica finale del risultato uguaglianza...
+ answ = (particolareOk && esponenteOk && figuraOk && codImballoOk);
+ }
+ catch
+ {
+ answ = false;
+ }
+
+ return answ;
+ }
+ ///
+ /// Conferma che un dato UDC è stato prelevato per soddisfare la lista di prelievo ed aggiorna o aggiunge riga in RigheListePrelievo
+ ///
+ /// codice della lista di prelievo
+ /// Codice UDC
+ /// esito comando
+ public esitoOperazione confermaUdcPrelevatoPerLista(string CodLista, string UDC)
+ {
+ esitoOperazione answ = esitoOperazione.errore;
+
+ // verifico che i dati corrispondano con il metodo relativo (vedi sopra)
+ bool datiUdcOk = verificaDatiUdc(CodLista, UDC);
+
+ if (datiUdcOk)
+ {
+ // richiamo stored di upsert e dò risposta positiva
+ taRigheListePrelievo.upsertPrelevato(CodLista, UDC);
+ answ = esitoOperazione.ok;
+
+ }
+ else
+ {
+ // altrimenti dò errore mismatch e non proseguo
+ return answ = esitoOperazione.errore_mismatch;
+ }
+
+ return answ;
+ }
+ ///
+ /// annulla il prelievo di un UDC, aggiornando RigheListePrelievo (solo preventivato...)
+ ///
+ /// codice della lista di prelievo
+ /// Codice UDC
+ /// esito comando
+ public esitoOperazione annullaUdcPrelevatoPerLista(string CodLista, string UDC)
+ {
+ esitoOperazione answ = esitoOperazione.errore;
+
+ /*
+ * Questa funzione va chiamata da web o da terminalino ogni volta che si fa un annullamento di avvenuto prelievo, ovvero il carrellista ha ANNULLATO un prelievo di un UDC associato ad una lista
+ *
+ * - in primis controllo: esiste questa riga di prelievo udc/lista?
+ * - se i dati non corrispondono esco e mando falso --> vedere l'enum in fondo al codice ed
+ * usare esitoOperazione.errore_mismatch
+ * - se i dati corrispondono allora
+ * - cerco riga e tolgo check come prelevato
+ * - se tutto ok passo esito ok
+ *
+ * */
+ try
+ {
+ // ricavo dati
+ DS_magazzino.RigheListePrelievoDataTable tabella = taRigheListePrelievo.getByCodLista(CodLista);
+ DS_magazzino.RigheListePrelievoRow riga = tabella[0];
+
+ // se i dati esistono procedo - eseguo stored che setta non prelevato = false per la riga selezionata
+ if (tabella.Rows.Count > 0)
+ {
+ taRigheListePrelievo.setAnnullaUdcPrelevato(CodLista, UDC);
+ answ = esitoOperazione.ok;
+ }
+
+ else
+ {
+ answ = esitoOperazione.errore_mismatch;
+ }
+ }
+ catch
+ { }
+ return answ;
+ }
+ ///
+ /// Rigenera una Lista di prelievo togliendo gli UDC non ancora prelevati rimettendo in logica FIFO gli UDC "liberi" disponibili
+ ///
+ /// codice della lista di prelievo
+ /// esito comando
+ public esitoOperazione scambiaUdcPerLista(string CodLista)
+ {
+ esitoOperazione answ = esitoOperazione.errore;
+
+ /*
+ * Questa funzione va chiamata da web o da terminalino ogni volta che si fa una richiesta di cambio per un UDC già prelevato, ovvero un altro carrellista prelevato un UDC associato alla mia lista corrente - rigenera UDC da prelevare
+ * */
+ try
+ {
+ // ricavo dati
+ DS_magazzino.ElencoListePrelievoRow riga = taElencoListePrelievo.getByCodLista(CodLista)[0];
+ // svuoto PRIMA gli UDC non prelevati
+ taRigheListePrelievo.stp_RigheListePrelievo_eliminaNonPrelevate(CodLista);
+ // rigenero righe UDC da prelevare
+ DS_magazzino.ElencoCartelliniDataTable tabellaElencoCartellini = taElencoCartellini.getUdcUnusedOlder(CodLista);
+ allocaRigheListaPrelievo(riga.QtaTot, CodLista, tabellaElencoCartellini);
+ }
+ catch
+ { }
+ return answ;
+ }
+#endif
+ ///
+ /// Verifica il login utente andando a controllare il CodSoggetto da RilPro e salvando in sessione un oggetto user_std x l'utente corrispondente al cod soggetto secondo la tab soggetti2utente
+ ///
+ ///
+ /// tipo di errore codificato
+ public esitoLoginTerm doUserLogin(string CodSoggetto)
+ {
+ esitoLoginTerm answ = esitoLoginTerm.errore;
+ try
+ {
+ answ = esitoLoginTerm.ok; //!!! FARE!!! vero controllo e user forced login!
+ }
+ catch
+ {
+ // !!! FARE logging tentativo connesisone con IP provenienza
+ }
+ return answ;
+ }
+ ///
+ /// verifica il codice barcode letto e restituisce il tipo di valore corrisponente
+ ///
+ ///
+ ///
+ public tipoCodiceBarcode riconosciBarcode(string barcodeIN)
+ {
+ tipoCodiceBarcode answ = tipoCodiceBarcode.ND;
+ switch (barcodeIN.Substring(0,1))
+ {
+ case "O":
+ answ = tipoCodiceBarcode.Operatore;
+ break;
+ case "K":
+ answ = tipoCodiceBarcode.ListaPrelievo;
+ break;
+ case "P":
+ answ = tipoCodiceBarcode.Particolare;
+ break;
+ case "U":
+ answ = tipoCodiceBarcode.UDC;
+ break;
+ default:
+ break;
+ }
+ return answ;
+ }
+
+ #endregion
+ }
+}
+///
+/// definisce i tipi di codice che il barcode può leggere
+///
+public enum tipoCodiceBarcode
+{
+ ///
+ /// Tipo non riconosciuto
+ ///
+ ND,
+ ///
+ /// [O] - il barcode rappresenta un codice operatore
+ ///
+ Operatore,
+ ///
+ /// [K] - il barcode rappresenta una lista di prelievo
+ ///
+ ListaPrelievo,
+ ///
+ /// [U] - il barcode rappresenta un UDC
+ ///
+ UDC,
+ ///
+ /// [P] - il barcode rappresenta un particolare
+ ///
+ Particolare
+
+}
+///
+/// elenco degli esiti per una sessione di login da terminalino
+///
+public enum esitoLoginTerm
+{
+ ///
+ /// tutto ok, come true
+ ///
+ ok,
+ ///
+ /// non è andata, errore generico
+ ///
+ errore,
+ ///
+ /// errore x mancanza record in tab operatori di RilPro x CodSoggetto
+ ///
+ errore_noCodSogg,
+ ///
+ /// errore mancanza username corrisponende all'operatore il cui cod soggetto è stato passato
+ ///
+ errore_noUser
+}
\ No newline at end of file
diff --git a/GMW/GMW_data/bin/Debug/GMW_data.dll b/GMW/GMW_data/bin/Debug/GMW_data.dll
index 394b8188..db05fac7 100644
Binary files a/GMW/GMW_data/bin/Debug/GMW_data.dll and b/GMW/GMW_data/bin/Debug/GMW_data.dll differ
diff --git a/GMW/GMW_data/obj/Debug/GMW_data.dll b/GMW/GMW_data/obj/Debug/GMW_data.dll
index 394b8188..db05fac7 100644
Binary files a/GMW/GMW_data/obj/Debug/GMW_data.dll and b/GMW/GMW_data/obj/Debug/GMW_data.dll differ