samuele
22d2e8bc83
update sql terminalino e web vanno x gestione spostamenti in magazzino git-svn-id: https://keyhammer.ath.cx/svn/GMW/trunk@441 365432ac-a1b5-4ffd-bb28-6d3099d32164
1759 lines
80 KiB
C#
1759 lines
80 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using SteamWare;
|
|
|
|
namespace GMW_data
|
|
{
|
|
/// <summary>
|
|
/// classe gestione operazioni sul magazzino
|
|
/// </summary>
|
|
public class MagClass
|
|
{
|
|
#region area table adapters
|
|
|
|
// variabile di tipo table adapter
|
|
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.RigheListePrelievoTableAdapter taRigheListePrelievo;
|
|
public DS_magazzinoTableAdapters.TipoListaPrelievoTableAdapter taTipoListaPrelievo;
|
|
public DS_magazzinoTableAdapters.V_ParticolariOverviewTableAdapter taVParticolariOverwiew;
|
|
public DS_magazzinoTableAdapters.v_particolariEsponenteFiguraTableAdapter taPartExpFig;
|
|
public DS_magazzinoTableAdapters.V_statoCelleCapienzaAssegnatiTableAdapter taStatoCelle;
|
|
public DS_magazzinoTableAdapters.RapQualTableAdapter taRapQual;
|
|
public DS_magazzinoTableAdapters.v_RapQualSuntoTableAdapter taRQ_sunto;
|
|
public DS_magazzinoTableAdapters.AnagLegheTableAdapter taAnagLeghe;
|
|
public DS_magazzinoTableAdapters.v_posizioniDelibereTableAdapter taPosizDelib;
|
|
public DS_magazzinoTableAdapters.AnagParticolariTableAdapter taAnagPart;
|
|
public DS_magazzinoTableAdapters.AnagPosizioniTableAdapter taAnagPos;
|
|
|
|
|
|
/// <summary>
|
|
/// init dei table adapters
|
|
/// </summary>
|
|
protected void initTA()
|
|
{
|
|
// istanzio oggetto
|
|
|
|
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();
|
|
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();
|
|
taStatoCelle = new GMW_data.DS_magazzinoTableAdapters.V_statoCelleCapienzaAssegnatiTableAdapter();
|
|
taRapQual = new GMW_data.DS_magazzinoTableAdapters.RapQualTableAdapter();
|
|
taRQ_sunto = new GMW_data.DS_magazzinoTableAdapters.v_RapQualSuntoTableAdapter();
|
|
taAnagLeghe = new GMW_data.DS_magazzinoTableAdapters.AnagLegheTableAdapter();
|
|
taPosizDelib = new GMW_data.DS_magazzinoTableAdapters.v_posizioniDelibereTableAdapter();
|
|
taAnagPart = new GMW_data.DS_magazzinoTableAdapters.AnagParticolariTableAdapter();
|
|
taAnagPos = new GMW_data.DS_magazzinoTableAdapters.AnagPosizioniTableAdapter();
|
|
}
|
|
/// <summary>
|
|
/// effettua setup dei connection strings da web.config delal singola applicazione
|
|
/// </summary>
|
|
protected virtual void setupConnectionStringBase()
|
|
{
|
|
string connString = memLayer.ML.confReadString("GMWConnectionString");
|
|
// connections del db
|
|
taAnagMag.Connection.ConnectionString = connString;
|
|
taBlocchi.Connection.ConnectionString = connString;
|
|
taCelle.Connection.ConnectionString = connString;
|
|
taTipoCella.Connection.ConnectionString = connString;
|
|
taCartellini.Connection.ConnectionString = connString;
|
|
taPosUdcCorr.Connection.ConnectionString = connString;
|
|
taPosUdcStorico.Connection.ConnectionString = connString;
|
|
taMagOverw.Connection.ConnectionString = connString;
|
|
taDettMagPart.Connection.ConnectionString = connString;
|
|
taDettUDC.Connection.ConnectionString = connString;
|
|
taElencoListePrelievo.Connection.ConnectionString = connString;
|
|
taRigheListePrelievo.Connection.ConnectionString = connString;
|
|
taTipoListaPrelievo.Connection.ConnectionString = connString;
|
|
taVParticolariOverwiew.Connection.ConnectionString = connString;
|
|
taPartExpFig.Connection.ConnectionString = connString;
|
|
taStatoCelle.Connection.ConnectionString = connString;
|
|
taRapQual.Connection.ConnectionString = connString;
|
|
taRQ_sunto.Connection.ConnectionString = connString;
|
|
taAnagLeghe.Connection.ConnectionString = connString;
|
|
taPosizDelib.Connection.ConnectionString = connString;
|
|
taAnagPart.Connection.ConnectionString = connString;
|
|
taAnagPos.Connection.ConnectionString = connString;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Inizializzazione
|
|
|
|
protected MagClass()
|
|
{
|
|
initTA();
|
|
setupConnectionStringBase();
|
|
}
|
|
|
|
/// <summary>
|
|
/// oggetto static per fare chiamate sul magazzino
|
|
/// </summary>
|
|
public static MagClass magazzino = new MagClass();
|
|
|
|
#endregion
|
|
|
|
#region metodi protected
|
|
|
|
/// <summary>
|
|
/// 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
|
|
/// </summary>
|
|
/// <param name="QtaTot"></param>
|
|
/// <param name="codListaAttuale"></param>
|
|
/// <param name="tabellaElencoCartellini"></param>
|
|
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);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Metodi esposti
|
|
|
|
#region operazioni su UDC
|
|
|
|
/// <summary>
|
|
/// effettua lo spostamento di un UDC tra 2 posizioni indicate
|
|
/// </summary>
|
|
/// <param name="CodCS">Codice company/sito</param>
|
|
/// <param name="UDC">Codice UDC</param>
|
|
/// <param name="IdxCellaTo">Cella di destinazione</param>
|
|
/// <param name="resetRLP">indica se sia richiesto resettare le Righe Liste Prelievo con lo spostsamento</param>
|
|
/// <returns>esito comando</returns>
|
|
public bool spostaUDC(string CodCS, string UDC, int IdxCellaTo, bool resetRLP)
|
|
{
|
|
bool answ = false;
|
|
try
|
|
{
|
|
taPosUdcCorr.stp_spostaUdc(CodCS, UDC, IdxCellaTo, resetRLP);
|
|
// cerco nuova posizione...
|
|
if (taPosUdcCorr.getByCellaUdc(UDC, IdxCellaTo).Rows.Count > 0)
|
|
{
|
|
answ = true;
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Errore durante spostamento cella: {0}", e), tipoLog.EXCEPTION);
|
|
}
|
|
// solo se ha fatto spostamento posizione corrente verifico se fare spostamento in posizione LOGICA magazzino
|
|
if (answ)
|
|
{
|
|
try
|
|
{
|
|
// verifico tipo cella e se ci sia da fare spostamento in mag logico/contabile
|
|
int idxTipoCella = taCelle.getByIdxCella(IdxCellaTo)[0].IdxTipoCella;
|
|
bool needSetMag = taTipoCella.getByIdx(idxTipoCella)[0].SetMag;
|
|
if (needSetMag)
|
|
{
|
|
// cambio (eventualmente) la posizione "logica" dato lo spostamento (il codice magazzino...)
|
|
int idxBlocco = taCelle.getByIdxCella(IdxCellaTo)[0].IdxBlocco;
|
|
int idxPosizione = Convert.ToInt32(taBlocchi.getByIdx(idxBlocco)[0].CodMag);
|
|
taCartellini.updateIdxPosizione(UDC, idxPosizione);
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Errore durante indicazione posizione UDC: {0}", e), tipoLog.EXCEPTION);
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// effettua lo scaricamento di un UDC (x spedizione)
|
|
/// </summary>
|
|
/// <param name="UDC">Codice UDC</param>
|
|
/// <param name="IdxCellaFrom">Cella di origine</param>
|
|
/// <param name="IdxPosizUdc">Codice posizione UDC finale</param>
|
|
/// <returns>esito comando</returns>
|
|
public bool scaricaUDC(string UDC, int IdxPosizUdc)
|
|
{
|
|
bool answ = false;
|
|
try
|
|
{
|
|
taPosUdcCorr.stp_scaricaUdc(UDC, IdxPosizUdc);
|
|
answ = true;
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// rettifica la qta di un UDC
|
|
/// </summary>
|
|
/// <param name="CodSoggetto">Codice soggetto/operatore</param>
|
|
/// <param name="UDC">Codice UDC</param>
|
|
/// <param name="qta">Nuova quantita associata</param>
|
|
/// <returns>esito comando</returns>
|
|
public bool rettificaQtaUDC(string UDC, decimal qta)
|
|
{
|
|
string CodSoggetto = CodSoggCurrUser;
|
|
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;
|
|
}
|
|
/// <summary>
|
|
/// verifica se l'UDC indicato sia valido, ovvero esistente
|
|
/// </summary>
|
|
/// <param name="UDC"></param>
|
|
/// <returns></returns>
|
|
public bool checkUDC(string UDC)
|
|
{
|
|
bool answ = false;
|
|
try
|
|
{
|
|
answ = (taCartellini.getDetailsUdcByUdc(UDC).Rows.Count > 0);
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// effettua lo scaricamento (da db e da AS400) degli UDC di MP/WIP
|
|
/// </summary>
|
|
/// <param name="UDC"></param>
|
|
/// <returns></returns>
|
|
public bool scaricaUdcMpWip(string UDC)
|
|
{
|
|
// inizializzo
|
|
bool answ = false;
|
|
int idxCellaFrom = 0;
|
|
int idxPosizUdcCorr = 0;
|
|
int idxPosizUdcDest = 0;
|
|
// calcolo posizione UDC corrente (se c'è...)
|
|
try
|
|
{
|
|
// mi serve per posizione udc corrente
|
|
DS_magazzino.PosizioneUdcCorrenteRow rigaUdcCorrente = taPosUdcCorr.getByUDC(UDC)[0];
|
|
// il secondo idx che mi serve
|
|
idxCellaFrom = rigaUdcCorrente.IdxCella;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Errore in fase di recupero cella per l'UDC {0}: {1}{2}", UDC, Environment.NewLine, e), tipoLog.EXCEPTION);
|
|
}
|
|
// ora calcolo gli altri dati dalla rica ElencoCartellini dell'UDC
|
|
try
|
|
{
|
|
// calcolo posizione destinazione da state machine...
|
|
idxPosizUdcCorr = taCartellini.getDetailsUdcByUdc(UDC)[0].IdxPosizione;
|
|
idxPosizUdcDest = StateMachine.SM.getIdxPostizioneTo("UDC_CONS", idxPosizUdcCorr);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Errore in fase di recupero dati posizioni from/to per l'UDC {0}: {1}{2}", UDC, Environment.NewLine, e), tipoLog.EXCEPTION);
|
|
}
|
|
// ora provo ad eseguire!
|
|
try
|
|
{
|
|
if (idxPosizUdcDest != 0) // solo se c'è una posizione da cui poter fare lo scaricamento...
|
|
{
|
|
// sposto UDC
|
|
answ = scaricaUDC(UDC, idxPosizUdcDest);
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Errore in fase di scaricamneto dell'UDC {0}: {1}{2}", UDC, Environment.NewLine, e), tipoLog.EXCEPTION);
|
|
}
|
|
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// riattiva un UDC (se permesso) da una posizione consumata ad una valida
|
|
/// </summary>
|
|
/// <param name="UDC"></param>
|
|
/// <param name="CodSoggetto"></param>
|
|
/// <returns></returns>
|
|
public bool riattivaUdc(string UDC, string CodSoggetto)
|
|
{
|
|
// init
|
|
bool answ = false;
|
|
try
|
|
{
|
|
// salvo dati cartellino PRE
|
|
DS_Applicazione.ElencoCartelliniRow rigaUdcPre = DataProxy.obj.taCartellini.stp_getByUdc(UDC)[0];
|
|
GMW_data.DataProxy.obj.taCartellini.stp_riattivaUdc(UDC, CodSoggetto);
|
|
// salvo dati cartellino POST
|
|
DS_Applicazione.ElencoCartelliniRow rigaUdcPost = DataProxy.obj.taCartellini.stp_getByUdc(UDC)[0];
|
|
answ = true;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Eccezione: {0}{1}", Environment.NewLine, e), tipoLog.EXCEPTION);
|
|
}
|
|
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// sblocca un UDC (se permesso)
|
|
/// </summary>
|
|
/// <param name="UDC"></param>
|
|
/// <param name="CodSoggetto"></param>
|
|
/// <returns></returns>
|
|
public bool sbloccaUdc(string UDC, string CodSoggetto)
|
|
{
|
|
// init
|
|
bool answ = false;
|
|
try
|
|
{
|
|
GMW_data.DataProxy.obj.taCartellini.stp_sbloccaUdc(UDC, CodSoggetto);
|
|
answ = true;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Eccezione: {0}{1}", Environment.NewLine, e), tipoLog.EXCEPTION);
|
|
}
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// controlla se l'udc della qualità indicato ha benestare qualità ("S")
|
|
/// </summary>
|
|
/// <param name="UDC"></param>
|
|
/// <returns></returns>
|
|
public bool udcMpHasBenesQual(string UDC)
|
|
{
|
|
bool answ = false;
|
|
try
|
|
{
|
|
DS_magazzino.RapQualRow rigaRapQual = taRapQual.getByUdc(UDC)[0];
|
|
if (rigaRapQual.BenesQual == "S")
|
|
{
|
|
answ = true;
|
|
}
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// controlla se l'udc deaal qualità indicato è già stato consumato
|
|
/// </summary>
|
|
/// <param name="UDC"></param>
|
|
/// <returns></returns>
|
|
public bool udcMpIsConsumabile(string UDC)
|
|
{
|
|
bool answ = false;
|
|
try
|
|
{
|
|
DS_magazzino.ElencoCartelliniRow rigaUDC = taCartellini.getByUdc(UDC)[0];
|
|
if (rigaUDC.IdxPosizione > 0)
|
|
{
|
|
answ = true;
|
|
}
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// fornisce il codice UDC calcolato
|
|
/// </summary>
|
|
/// <param name="codCS"></param>
|
|
/// <param name="flusso"></param>
|
|
/// <param name="anno">2 cifre</param>
|
|
/// <param name="numUDC"></param>
|
|
/// <returns></returns>
|
|
public string getComposizioneUDC(string codCS, string flusso, string anno, int numUDC)
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
answ = string.Format("U{0}{1}{2}{3}", codCS, flusso, anno, numUDC.ToString().PadLeft(6, '0'));
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// Fornisce un nuovo codice UDC tipo completo (con pezzi e cod magazzino) a partire dalla richiesta e salva i dati
|
|
/// </summary>
|
|
/// <param name="CodBilancia">codice anagrafico della bilanca che effettua la richiesta (codice della pesa)</param>
|
|
/// <param name="CodCliente">codice anagrafico del cliente</param>
|
|
/// <param name="Particolare">codice del particolare (articolo) - da anagrafica!</param>
|
|
/// <param name="CodImpianto">Codice dell'impianto</param>
|
|
/// <param name="CodStampo">Codice dello stampo</param>
|
|
/// <param name="Esponente">codice dell'esponente dello stampo</param>
|
|
/// <param name="Figura">Codice figura</param>
|
|
/// <param name="DataRif">Data di rif per la dichiarazione</param>
|
|
/// <param name="TurnoRif">Turno di rif per la dichiarazione</param>
|
|
/// <param name="CodImballo">codice dell'imballo (tipo cassone) - string LIBERO (non facciamo controlli in input)</param>
|
|
/// <param name="CodSoggetto">codice dell'operatore</param>
|
|
/// <param name="UDC_Parent">codice dell'UDC parent (UDC della tara)</param>
|
|
/// <param name="tara">peso in kg (0 se non noto) da associare all'UDC come tara del contenitore</param>
|
|
/// <param name="CodTipoDichiarazione">tipo di dichiarazione (vedere relativa anagrafica consentita, es U=uomo, M=macchina...)</param>
|
|
/// <param name="Quantita">numero pezzi associati all'UDC</param>
|
|
/// <param name="PesoTot">Peso totale rilevato</param>
|
|
/// <param name="PesoCad">Peso unitario rilevato</param>
|
|
/// <param name="CodStato">Codice dello stato del pezzo (da anagrafica: sabbiato, ...)</param>
|
|
/// <param name="CodMag">Codice del magazzino in cui inserire l'UDC</param>
|
|
/// <param name="toAS400">TRUE = genera movimento AS400, FALSE = NON genera movimento di magazzino</param>
|
|
/// <param name="defIdxPosiz">posizione in cui creare UDC</param>
|
|
/// <param name="codEvento">cod evento da associare al movimento mag</param>
|
|
/// <param name="note">note (opzionali)</param>
|
|
/// <param name="UDC">cod UDC pre-calcolato, se "" verrà calcolato dalla query</param>
|
|
/// <param name="anno">anno in cui intestare i cartellini, trimma a 2 cifre DX</param>
|
|
/// <returns>UDC del nuovo cartellino per FINITI</returns>
|
|
public string creaUdc(string CodBilancia, string CodCliente, string Particolare, string CodImpianto, string CodStampo, string Esponente, string Figura, string UDC_Parent, double Tara, string CodImballo, string CodTipoDichiarazione, string CodSoggetto, int Quantita, float PesoTot, float PesoCad, DateTime DataRif, int TurnoRif, string CodStato, int CodMag, bool toAS400, string defIdxPosiz, string codEvento, string note, string UDC, int anno)
|
|
{
|
|
// trim fix
|
|
string CodBilanciaTrim = CodBilancia.Trim();
|
|
string CodClienteTrim = CodCliente.Trim();
|
|
string ParticolareTrim = Particolare.Trim();
|
|
string CodImpiantoTrim = CodImpianto.Trim();
|
|
string CodStampoTrim = CodStampo.Trim();
|
|
string EsponenteTrim = Esponente.Trim();
|
|
string FiguraTrim = Figura.Trim();
|
|
string UDC_ParentTrim = UDC_Parent.Trim();
|
|
string CodImballoTrim = CodImballo.Trim();
|
|
string CodTipoDichiarazioneTrim = CodTipoDichiarazione.Trim();
|
|
string CodSoggettoTrim = CodSoggetto.Trim();
|
|
string CodStatoTrim = CodStato.Trim();
|
|
string defIdxPosizTrim = defIdxPosiz.Trim();
|
|
string codEventoTrim = codEvento.Trim();
|
|
string noteTrim = note.Trim();
|
|
string annoTrim = anno.ToString();
|
|
if (annoTrim.Length > 2)
|
|
{
|
|
annoTrim = annoTrim.Substring(2, 2);
|
|
}
|
|
// determino se cancellare udcTara
|
|
bool doDeleteUdcTara = false; // memLayer.ML.confReadBool("doDeleteUdcTara");
|
|
// ricavo cod company...
|
|
string CodCS = "ND";
|
|
string answ = "NA";
|
|
try
|
|
{
|
|
CodCS = DataProxy.obj.taAnagBil.stp_getByCodBilancia(CodBilanciaTrim)[0].CodCS;
|
|
}
|
|
catch
|
|
{
|
|
CodCS = memLayer.ML.confReadString("CodCS");
|
|
}
|
|
int IdxPosizione = 0;
|
|
if (CodMag > 0)
|
|
{
|
|
IdxPosizione = CodMag;
|
|
}
|
|
else
|
|
{
|
|
IdxPosizione = memLayer.ML.confReadInt(defIdxPosizTrim);
|
|
}
|
|
// loggo tutto!
|
|
if (memLayer.ML.confReadInt("_logLevel") > 5)
|
|
{
|
|
try
|
|
{
|
|
logger.lg.scriviLog(string.Format("NUOVO cartellino da postazione: {0} | {1} | {2} | {3} | {4} | {5} | {6} | {7} | {8} | {9} | {10} | {11} | {12} | {13} | {14} | {15} | {16} | {17} | {18} | {19} | {20} | {21} | {22} | {23}", CodCS, CodBilanciaTrim, annoTrim, CodClienteTrim, ParticolareTrim, CodImpiantoTrim, CodStampoTrim, EsponenteTrim, FiguraTrim, DataRif, TurnoRif, CodImballoTrim, CodSoggettoTrim, Tara, IdxPosizione, CodTipoDichiarazioneTrim, codEventoTrim, Quantita, PesoTot, PesoCad, CodStatoTrim, UDC_ParentTrim, toAS400, noteTrim), tipoLog.INFO);
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
// creo nuovo cartellino!
|
|
DS_Applicazione.ElencoCartelliniDataTable tabUdc;
|
|
// controllo se UDC già definito o meno...
|
|
if (UDC != "")
|
|
{
|
|
// insert nuovo UDC con codice impostato
|
|
tabUdc = DataProxy.obj.taCartellini.stp_insNewFull_fixUDC(UDC, CodCS, CodBilanciaTrim, annoTrim, CodClienteTrim, ParticolareTrim, CodImpiantoTrim, CodStampoTrim, EsponenteTrim, FiguraTrim, DataRif, TurnoRif, CodImballoTrim, CodSoggettoTrim, Tara, IdxPosizione, CodTipoDichiarazioneTrim, codEventoTrim, Quantita, PesoTot, PesoCad, CodStatoTrim, UDC_ParentTrim, doDeleteUdcTara, noteTrim);
|
|
answ = UDC;
|
|
}
|
|
else
|
|
{
|
|
// insert con calcolo UDC
|
|
tabUdc = DataProxy.obj.taCartellini.stp_insNewFull(CodCS, CodBilanciaTrim, annoTrim, CodClienteTrim, ParticolareTrim, CodImpiantoTrim, CodStampoTrim, EsponenteTrim, FiguraTrim, DataRif, TurnoRif, CodImballoTrim, CodSoggettoTrim, Tara, IdxPosizione, CodTipoDichiarazioneTrim, codEventoTrim, Quantita, PesoTot, PesoCad, CodStatoTrim, UDC_ParentTrim, doDeleteUdcTara, noteTrim);
|
|
}
|
|
try
|
|
{
|
|
// leggo la riga
|
|
answ = tabUdc[0].UDC;
|
|
// salvo associazione parent-child tra UDC!
|
|
DataProxy.obj.taRelazUDC.Insert(UDC_ParentTrim, answ);
|
|
}
|
|
catch
|
|
{ }
|
|
// se NON richiesto di generare movimento a magazzino crea rettifica in tab batch
|
|
if (!toAS400)
|
|
{
|
|
DataProxy.obj.taCartellini.stp_rettMovAs400(ParticolareTrim, answ, IdxPosizione.ToString(), Quantita, "UDC_NOQTY");
|
|
}
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// associa udc all'UDCParent
|
|
/// </summary>
|
|
/// <param name="codUdc"></param>
|
|
/// <param name="codParent"></param>
|
|
/// <returns></returns>
|
|
public bool associaUdcParent(string codUdc, string codParent)
|
|
{
|
|
bool answ = false;
|
|
try
|
|
{
|
|
DataProxy.obj.taCartellini.stp_UDC_associaParent(codUdc, codParent);
|
|
answ = true;
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// effettua la stampa di un dato UDC
|
|
/// </summary>
|
|
/// <param name="UDC">Codice UDC</param>
|
|
/// <param name="printer">stampante specifica (da postazioen o std da webconfig, a cura dell'utente</param>
|
|
/// <returns></returns>
|
|
public bool stampaUdc(string UDC, string printer, tipoCartellino tipoCart)
|
|
{
|
|
bool answ = false;
|
|
// controllo se esista UDC
|
|
if (checkUDC(UDC))
|
|
{
|
|
answ = reportPrinter.obj.stampaCartellino(tipoCart, UDC, printer);
|
|
}
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// restituisce particolare da UDC
|
|
/// </summary>
|
|
/// <param name="UDC"></param>
|
|
/// <returns></returns>
|
|
public string getParticolareByUDC(string UDC)
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
answ = (taCartellini.getDetailsUdcByUdc(UDC)[0].Particolare);
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
#endregion
|
|
|
|
#region procedure di verifica e traduzione dati da anagrafiche
|
|
|
|
/// <summary>
|
|
/// Verifica la corrispondenza dati tra RigheListePrelievo ed ElencoCartellini
|
|
/// </summary>
|
|
/// <param name="CodLista"></param>
|
|
/// <param name="UDC"></param>
|
|
/// <returns></returns>
|
|
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 = taCartellini.getDetailsUdcByUdc(UDC);
|
|
DS_magazzino.ElencoCartelliniRow rigaUDC = tabellaUDC[0];
|
|
|
|
// ricavo dati da confrontare - da Lista ricavo particolare/esponente/figura
|
|
string particolareLista = rigaElenco.Particolare.Trim();
|
|
string esponenteLista = rigaElenco.Esponente.Trim();
|
|
string figuraLista = rigaElenco.Figura.Trim();
|
|
string codImballoLista = rigaElenco.CodImballo.Trim();
|
|
|
|
//stessi dati da UDC
|
|
string particolareUDC = rigaUDC.Particolare.Trim();
|
|
string esponenteUDC = rigaUDC.Esponente.Trim();
|
|
string figuraUDC = rigaUDC.Figura.Trim();
|
|
string codImballoUDC = rigaUDC.CodImballo.Trim();
|
|
|
|
// 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;
|
|
}
|
|
/// <summary>
|
|
/// restituisce codice soggetto dell'user corrente
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public string CodSoggCurrUser
|
|
{
|
|
get
|
|
{
|
|
// ricavo da session...
|
|
string codSoggetto = "";
|
|
try
|
|
{
|
|
codSoggetto = DataProxy.obj.taSogg2Oper.getByUserDominio(user_std.UtSn.utente, user_std.UtSn.dominio)[0].CodSoggetto;
|
|
// salvo in sessione...
|
|
memLayer.ML.setSessionVal("CodSoggetto", codSoggetto);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Non sono riuscito a recuperare il codice soggetto per l'utente loggato: {0}, errore {1}{2}", user_std.UtSn.userNameAD, Environment.NewLine, e), tipoLog.ERROR);
|
|
}
|
|
return codSoggetto;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// restituisce l'IdxCella dato il CodCella
|
|
/// </summary>
|
|
/// <param name="CodCS">Codice company/sito</param>
|
|
/// <param name="CodCella"></param>
|
|
/// <returns></returns>
|
|
public int IdxCellaByCodCella(string CodCS, string CodCella)
|
|
{
|
|
int answ = 0;
|
|
try
|
|
{
|
|
answ = taCelle.getByCodCella(CodCella)[0].IdxCella; // NON controllo il CodCS...
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// restituisce il CodCella dato l'IdxCella
|
|
/// </summary>
|
|
/// <param name="CodCS">Codice company/sito</param>
|
|
/// <param name="IdxCella"></param>
|
|
/// <returns></returns>
|
|
public string CodCellaByIdxCella(string CodCS, int IdxCella)
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
answ = taCelle.getByIdxCella(IdxCella)[0].CodCella; // NON controllo il CodCS...
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// verifica se la cella indicata sia attiva
|
|
/// </summary>
|
|
/// <param name="CodCS">Codice company/sito</param>
|
|
/// <param name="IdxCella"></param>
|
|
/// <returns></returns>
|
|
public bool cellaAttiva(string CodCS, int IdxCella)
|
|
{
|
|
bool answ = false;
|
|
try
|
|
{
|
|
answ = taCelle.getByIdxCella(IdxCella)[0].Attiva; // NON controllo il CodCS...
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// verifica se la cella indicata sia piena
|
|
/// </summary>
|
|
/// <param name="CodCS">Codice company/sito</param>
|
|
/// <param name="IdxCella"></param>
|
|
/// <returns></returns>
|
|
public bool cellaPiena(string CodCS, int IdxCella)
|
|
{
|
|
bool answ = false;
|
|
try
|
|
{
|
|
answ = taCelle.getByIdxCella(IdxCella)[0].Piena; // NON controllo il CodCS...
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// restituisce cod UDC associato ad una cella
|
|
/// </summary>
|
|
/// <param name="CodCS">Codice company/sito</param>
|
|
/// <param name="IdxCella"></param>
|
|
/// <returns></returns>
|
|
public string udcInCella(string CodCS, int IdxCella)
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
answ = taPosUdcCorr.getByIdxCella(IdxCella)[0].UDC;
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// verifica la cella indicata sia valida, ovvero esistente
|
|
/// </summary>
|
|
/// <param name="CodCella"></param>
|
|
/// <returns></returns>
|
|
public bool checkCella(string CodCella)
|
|
{
|
|
bool answ = false;
|
|
try
|
|
{
|
|
answ = (taCelle.getByCodCella(CodCella).Rows.Count > 0);
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// verifica se il particolare indicato sia valido, ovvero esistente
|
|
/// </summary>
|
|
/// <param name="CodCS">Codice company/sito</param>
|
|
/// <param name="Particolare"></param>
|
|
/// <returns></returns>
|
|
public bool checkParticolare(string CodCS, string Particolare)
|
|
{
|
|
bool answ = false;
|
|
try
|
|
{
|
|
answ = (taVParticolariOverwiew.getByParticolareFull(Particolare, CodCS).Rows.Count > 0);
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// restituisce il num di UDC che corrispondono alla richiesta indicata
|
|
/// </summary>
|
|
/// <param name="CodCS"></param>
|
|
/// <param name="Particolare"></param>
|
|
/// <param name="codEsponente"></param>
|
|
/// <param name="codFigura"></param>
|
|
/// <param name="codImballo"></param>
|
|
/// <param name="codTipoLista"></param>
|
|
/// <returns></returns>
|
|
public int numUdcDaPart(string CodCS, string Particolare, string codEsponente, string codFigura, string codImballo, string codTipoLista)
|
|
{
|
|
int answ = 0;
|
|
try
|
|
{
|
|
answ = taVParticolariOverwiew.getByDatiListaPrelievo(Particolare, CodCS, codEsponente, codFigura, codImballo, codTipoLista)[0].NumUDC;
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// verifica se l'UDC sia riattivabile, ovvero
|
|
/// - sia permesso da web.config
|
|
/// - l'UDC sia in un mag che permette riattivazione
|
|
/// </summary>
|
|
/// <param name="UDC"></param>
|
|
/// <returns></returns>
|
|
public bool udcIsRiattivabile(string UDC)
|
|
{
|
|
bool answ = false;
|
|
// se permesso da web config controllo
|
|
if (memLayer.ML.confReadBool("riattUdcPermessa"))
|
|
{
|
|
try
|
|
{
|
|
// recupero posizione attuale
|
|
int idxPosizione = taCartellini.getDetailsUdcByUdc(UDC)[0].IdxPosizione;
|
|
// verifico se riattivabile
|
|
answ = taAnagPos.getByIdxPosizione(idxPosizione)[0].IsRiattivaEnabled;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Errore nella riattivazione dell'UDC {0}:{1}{2}", UDC, Environment.NewLine, e), tipoLog.EXCEPTION);
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region liste di prelievo
|
|
|
|
/// <summary>
|
|
/// Crea una lista di prelievo andando a prenotare gli UDC del particolare richiesto in logica FIFO
|
|
/// </summary>
|
|
/// <param name="CodCS"></param>
|
|
/// <param name="TipoListaPrelievo"></param>
|
|
/// <param name="Particolare"></param>
|
|
/// <param name="Esponente"></param>
|
|
/// <param name="Figura"></param>
|
|
/// <param name="QtaTot"></param>
|
|
/// <param name="CodImballo"></param>
|
|
/// <param name="Destinatario"></param>
|
|
/// <param name="DestinatarioDescrizione"></param>
|
|
/// <returns></returns>
|
|
public string creaListaPrelievo(string CodCS, string TipoListaPrelievo, string Particolare, string Esponente, string Figura, decimal QtaTot, string CodImballo, string Destinatario, string DestinatarioDescrizione)
|
|
{
|
|
/*
|
|
* - 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;
|
|
// non la valorizzo qui ma calcolo ... se non fa verificare
|
|
string RagioneSociale = "";
|
|
|
|
// ricavo da session...
|
|
string codSoggetto = CodSoggCurrUser;
|
|
// 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), TipoListaPrelievo, memLayer.ML.confReadString("CodCS"), codCliente, RagioneSociale, codSoggetto, Particolare, descParticolare, disegnoGrezzo, Esponente, Figura, CodImballo, QtaTot, Destinatario, DestinatarioDescrizione);
|
|
|
|
// ricavo prima (e unica) riga dalla select
|
|
DS_magazzino.ElencoListePrelievoRow rigaElencoListe = tabellaElencoListe[0];
|
|
|
|
// ricavo valore del CodLista attuale appena inserito
|
|
codListaAttuale = rigaElencoListe.CodLista;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Eccezione creazione lista prelievo: {0}{1}", Environment.NewLine, e), tipoLog.ERROR);
|
|
}
|
|
if (codListaAttuale != "")
|
|
{
|
|
answ = codListaAttuale;
|
|
DS_magazzino.ElencoCartelliniDataTable tabellaElencoCartellini = taCartellini.getUdcUnusedOlder(codListaAttuale);
|
|
allocaRigheListaPrelievo(QtaTot, codListaAttuale, tabellaElencoCartellini);
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// Crea una lista di prelievo andando a prenotare gli UDC del particolare richiesto in logica FIFO
|
|
/// </summary>
|
|
/// <param name="CodCS"></param>
|
|
/// <param name="TipoListaPrelievo"></param>
|
|
/// <param name="Particolare"></param>
|
|
/// <param name="Esponente"></param>
|
|
/// <param name="Figura"></param>
|
|
/// <param name="QtaTot"></param>
|
|
/// <param name="CodImballo"></param>
|
|
/// <param name="Destinatario"></param>
|
|
/// <param name="DestinatarioDescrizione"></param>
|
|
/// <returns></returns>
|
|
public string creaListaPrelievoSmart(string CodCS, string TipoListaPrelievo, string Particolare, string Esponente, string Figura, decimal QtaTot, string CodImballo, string Destinatario, string DestinatarioDescrizione)
|
|
{
|
|
string answ = "K";
|
|
|
|
// variabile di tipo datetime per data corrente
|
|
DateTime adesso = DateTime.Now;
|
|
// non la valorizzo qui ma calcolo ... se non fa verificare
|
|
string RagioneSociale = "";
|
|
|
|
// ricavo da session...
|
|
string codSoggetto = CodSoggCurrUser;
|
|
// 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), TipoListaPrelievo, memLayer.ML.confReadString("CodCS"), codCliente, RagioneSociale, codSoggetto, Particolare, descParticolare, disegnoGrezzo, Esponente, Figura, CodImballo, QtaTot, Destinatario, DestinatarioDescrizione);
|
|
|
|
// ricavo prima (e unica) riga dalla select
|
|
DS_magazzino.ElencoListePrelievoRow rigaElencoListe = tabellaElencoListe[0];
|
|
|
|
// ricavo valore del CodLista attuale appena inserito
|
|
codListaAttuale = rigaElencoListe.CodLista;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Eccezione creazione lista prelievo: {0}{1}", Environment.NewLine, e), tipoLog.ERROR);
|
|
}
|
|
if (codListaAttuale != "")
|
|
{
|
|
answ = codListaAttuale;
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// indica come attivata in carico di una lista di prelievo
|
|
/// </summary>
|
|
/// <param name="CodCS">Codice company/sito</param>
|
|
/// <param name="CodLista">codice della lista di prelievo</param>
|
|
/// <param name="CodSoggetto">cod operatore carrellista</param>
|
|
/// <returns></returns>
|
|
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;
|
|
}
|
|
/// <summary>
|
|
/// indica presa in carico di una lista di prelievo
|
|
/// </summary>
|
|
/// <param name="CodCS">Codice company/sito</param>
|
|
/// <param name="CodLista">codice della lista di prelievo</param>
|
|
/// <param name="CodSoggetto">cod operatore carrellista</param>
|
|
/// <returns></returns>
|
|
public esitoOperazione iniziaListaPrelievo(string CodCS, string CodLista, string CodSoggetto)
|
|
{
|
|
memLayer.ML.setSessionVal("activeTask", string.Format("Lista Prelievo {0}", CodLista));
|
|
memLayer.ML.setSessionVal("CodListaAttiva", CodLista, true);
|
|
// 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;
|
|
}
|
|
/// <summary>
|
|
/// indica come completata (da parte del magazziniere) una lista di prelievo
|
|
/// </summary>
|
|
/// <param name="CodCS">Codice company/sito</param>
|
|
/// <param name="CodLista">codice della lista di prelievo</param>
|
|
/// <param name="CodSoggetto">cod operatore carrellista</param>
|
|
/// <returns></returns>
|
|
public esitoOperazione completaListaPrelievo(string CodCS, string CodLista, string CodSoggetto)
|
|
{
|
|
memLayer.ML.emptySessionVal("CodListaAttiva");
|
|
memLayer.ML.emptySessionVal("activeTask");
|
|
// 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)
|
|
{
|
|
// controllo se ALMENO un UDC sia stsato prelevato
|
|
int numUdcPrelevati = taRigheListePrelievo.getByCodListaPrelevate(CodLista).Rows.Count;
|
|
if (numUdcPrelevati > 0)
|
|
{
|
|
// 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.getByCodListaPrelevate(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;
|
|
// sposto UDC
|
|
spostaUDC(CodCS, _UDC, idxCellaTo, false);
|
|
// dopo aver spostato UDC sistemo eventuali Righe di Prelievo x lo stesso UDC pending...
|
|
taRigheListePrelievo.stp_RLP_sbloccaNonPrelevate(CodLista, _UDC);
|
|
}
|
|
// libero le righe non prelevate...
|
|
taRigheListePrelievo.stp_RLP_eliminaNonPrelevate(CodLista);
|
|
// aggiorno stato lista
|
|
taElencoListePrelievo.updateStato(CodSoggetto, CodLista, (int)statoLista.completata);
|
|
answ = esitoOperazione.ok;
|
|
}
|
|
else //nessun UDC prelevato
|
|
{
|
|
answ = esitoOperazione.errore_noUdc;
|
|
}
|
|
}
|
|
// 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;
|
|
}
|
|
/// <summary>
|
|
/// 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)
|
|
/// </summary>
|
|
/// <param name="CodCS">Codice company/sito</param>
|
|
/// <param name="CodLista">codice della lista di prelievo</param>
|
|
/// <param name="CodSoggetto">cod operatore carrellista</param>
|
|
/// <returns>esito comando</returns>
|
|
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)
|
|
* */
|
|
// setup eventuali valori x rettifica
|
|
bool fatto = false;
|
|
|
|
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.getByCodListaPrelevate(CodLista);
|
|
DS_magazzino.RigheListePrelievoRow rigaListaPrelievo = tabellaRigheListaPrelievo[0];
|
|
|
|
// leggo il codice della cella...
|
|
string CodEvento = rigaTipoLista.CodEvento;
|
|
// posizione corrente dell'UDC
|
|
int idxPosizUdcCorr = 0;
|
|
// posizioen di destinazione per UDC corrente
|
|
int idxPosizUdcDest = 0;
|
|
// cella di provenienza
|
|
int idxCellaFrom = 0;
|
|
// cella di destinazione
|
|
int idxCellaTo = 0;
|
|
// 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
|
|
idxCellaFrom = rigaUdcCorrente.IdxCella;
|
|
// calcolo posizione destinazione da state machine...
|
|
idxPosizUdcCorr = taCartellini.getDetailsUdcByUdc(UDC)[0].IdxPosizione;
|
|
idxPosizUdcDest = StateMachine.SM.getIdxPostizioneTo(CodEvento, idxPosizUdcCorr);
|
|
// a questo punto mi calcolo se c'è una cella di destinazione associata
|
|
try
|
|
{
|
|
idxCellaTo = MagClass.magazzino.taCelle.getByCodMag(CodCS, idxPosizUdcDest.ToString())[0].IdxCella;
|
|
}
|
|
catch
|
|
{
|
|
idxCellaTo = 0;
|
|
}
|
|
// sposto UDC, e così facendo genero movimenti batch x AS400
|
|
fatto = scaricaUDC(UDC, idxPosizUdcDest);
|
|
// sposto nella PRIMA cella di destinazione associata l'UDC
|
|
if (idxCellaTo > 0)
|
|
{
|
|
spostaUDC(CodCS, UDC, idxCellaTo, false);
|
|
}
|
|
if (fatto)
|
|
{
|
|
// dopo aver scaricato UDC sistemo eventuali Righe di Prelievo x lo stesso pending...
|
|
magazzino.taRigheListePrelievo.stp_RLP_sbloccaNonPrelevate(CodLista, UDC);
|
|
}
|
|
}
|
|
// 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...) - SOLO SE NON E' prelievo fusi...
|
|
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;
|
|
}
|
|
/// <summary>
|
|
/// resetta (riporta in bozza) una lista di prelievo, spostando gli UDC alla posizione standard precedente
|
|
/// </summary>
|
|
/// <param name="CodCS">Codice company/sito</param>
|
|
/// <param name="CodLista">codice della lista di prelievo</param>
|
|
/// <param name="CodSoggetto">cod operatore carrellista</param>
|
|
/// <returns></returns>
|
|
public esitoOperazione resetListaPrelievo(string CodCS, string CodLista, string CodSoggetto)
|
|
{
|
|
memLayer.ML.emptySessionVal("CodListaAttiva");
|
|
memLayer.ML.emptySessionVal("activeTask");
|
|
// da chiamare quando clicco e inizio lista prelievo .... vedi sopra
|
|
esitoOperazione answ = esitoOperazione.errore;
|
|
// posizione corrente dell'UDC
|
|
int idxPosizUdcCorr = 0;
|
|
int idxPosizioneTo = 0;
|
|
int idxCellaTo = 0;
|
|
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)
|
|
{
|
|
// ricontrollo che la lista sia completata
|
|
if (riga.CodStatoLista >= (int)statoLista.completata)
|
|
{
|
|
// calcolo tipo lista di prelievo
|
|
string codTipoListaAttuale = riga.CodTipoLista;
|
|
// dal tipo lista determino l'evento
|
|
string codEvento = taTipoListaPrelievo.getByCodTipoLista(codTipoListaAttuale)[0].CodEvento;
|
|
// leggo da righe lista prelievo il dato udc che mi serve
|
|
DS_magazzino.RigheListePrelievoDataTable tabellaRigheListaPrelievo = taRigheListePrelievo.getByCodListaPrelevate(CodLista);
|
|
DS_magazzino.RigheListePrelievoRow rigaListaPrelievo = tabellaRigheListaPrelievo[0];
|
|
// sposto ("metto a terra") gli UDC
|
|
string _UDC = "";
|
|
foreach (DS_magazzino.RigheListePrelievoRow row in tabellaRigheListaPrelievo.Rows)
|
|
{
|
|
// ricavo il codice UDC...
|
|
_UDC = row.UDC;
|
|
// posizione corrente
|
|
idxPosizUdcCorr = taCartellini.getDetailsUdcByUdc(_UDC)[0].IdxPosizione;
|
|
// calcolo posizione destinazione da state machine...
|
|
idxPosizioneTo = StateMachine.SM.taTTPE.getByEventoPosizione(codEvento, idxPosizUdcCorr)[0].IdxPosizioneTo;
|
|
// lo trasformo x avere la cella di destinazione...
|
|
if (idxPosizUdcCorr < 0)
|
|
{
|
|
// se parto da cella negativa (consumato) calcolo destinazione da cella TO...
|
|
idxCellaTo = taCelle.getFirstByPosizione(idxPosizioneTo.ToString())[0].IdxCella;
|
|
}
|
|
else
|
|
{
|
|
// altrimenti uso la posizione corrente (NON faccio vero spostamento...
|
|
idxCellaTo = taCelle.getFirstByPosizione(idxPosizUdcCorr.ToString())[0].IdxCella;
|
|
}
|
|
// sposto UDC
|
|
spostaUDC(CodCS, _UDC, idxCellaTo, false);
|
|
}
|
|
// indico le righe come NON prelevate...
|
|
taRigheListePrelievo.stp_RLP_resetPrelevate(CodLista);
|
|
// aggiorno stato lista che torna a BOZZA
|
|
taElencoListePrelievo.updateStato(CodSoggetto, CodLista, (int)statoLista.bozza);
|
|
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 (Exception e)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Errore in reset lista prelievo: {0}", e), tipoLog.EXCEPTION);
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Conferma che un dato UDC è stato prelevato per soddisfare la lista di prelievo ed aggiorna o aggiunge riga in RigheListePrelievo
|
|
/// </summary>
|
|
/// <param name="CodLista">codice della lista di prelievo</param>
|
|
/// <param name="UDC">Codice UDC</param>
|
|
/// <returns>esito comando</returns>
|
|
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
|
|
taRigheListePrelievo.upsertPrelevato(CodLista, UDC);
|
|
// ...dò risposta positiva
|
|
answ = esitoOperazione.ok;
|
|
|
|
}
|
|
else
|
|
{
|
|
// altrimenti dò errore mismatch e non proseguo
|
|
return answ = esitoOperazione.errore_mismatch;
|
|
}
|
|
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// annulla il prelievo di un UDC, aggiornando RigheListePrelievo (solo preventivato...)
|
|
/// </summary>
|
|
/// <param name="CodLista">codice della lista di prelievo</param>
|
|
/// <param name="UDC">Codice UDC</param>
|
|
/// <returns>esito comando</returns>
|
|
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;
|
|
}
|
|
/// <summary>
|
|
/// Rigenera una Lista di prelievo togliendo gli UDC non ancora prelevati rimettendo in logica FIFO gli UDC "liberi" disponibili
|
|
/// </summary>
|
|
/// <param name="CodLista">codice della lista di prelievo</param>
|
|
/// <returns>esito comando</returns>
|
|
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 = taCartellini.getUdcUnusedOlder(CodLista);
|
|
allocaRigheListaPrelievo(riga.QtaTot, CodLista, tabellaElencoCartellini);
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// Aggiunge UN SOLO UDC in logica FIFO tra gli UDC "liberi" disponibili
|
|
/// </summary>
|
|
/// <param name="CodLista">codice della lista di prelievo</param>
|
|
/// <returns>esito comando</returns>
|
|
public esitoOperazione addUdcPerLista(string CodLista)
|
|
{
|
|
esitoOperazione answ = esitoOperazione.errore;
|
|
try
|
|
{
|
|
// ricavo dati
|
|
DS_magazzino.ElencoListePrelievoRow riga = taElencoListePrelievo.getByCodLista(CodLista)[0];
|
|
// rigenero righe UDC da prelevare
|
|
DS_magazzino.ElencoCartelliniDataTable tabellaElencoCartellini = new DS_magazzino.ElencoCartelliniDataTable();
|
|
// aggiungo l'UDC + vecchio (se c'è)
|
|
try
|
|
{
|
|
tabellaElencoCartellini.ImportRow(taCartellini.getUdcUnusedOlder(CodLista)[0]);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
logger.lg.scriviLog(String.Format("Errore in aggiunta UDC a lista prelievo: {0}", e), tipoLog.EXCEPTION);
|
|
}
|
|
allocaRigheListaPrelievo(riga.QtaTot, CodLista, tabellaElencoCartellini);
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// vero/falso che l'utent eha una lista di prelievo attiva
|
|
/// </summary>
|
|
public bool userHasActiveLP
|
|
{
|
|
get
|
|
{
|
|
bool answ = false;
|
|
try
|
|
{
|
|
answ = (MagClass.magazzino.taElencoListePrelievo.getByCodSogg(CodSoggCurrUser).Rows.Count > 0);
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// codice della lista di prelievo attiva
|
|
/// </summary>
|
|
public string codListaAttivaUtente
|
|
{
|
|
get
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
answ = MagClass.magazzino.taElencoListePrelievo.getByCodSogg(CodSoggCurrUser)[0].CodLista;
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
}
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="CodLista"></param>
|
|
/// <returns></returns>
|
|
public bool listaPrelevabile(string CodLista)
|
|
{
|
|
bool answ = false;
|
|
try
|
|
{
|
|
answ = (MagClass.magazzino.taElencoListePrelievo.getByCodLista(CodLista).Select("CodStatoLista = 1").Length > 0); // filtro su stato = 1 (può esser presa in carico)
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region area rapporti qualità
|
|
|
|
/// <summary>
|
|
/// Crea gli UDC da associare ai cartellini dei rapporti qualità deliberati, li associa e se richiesto lancia stampa
|
|
/// </summary>
|
|
/// <param name="numRapQual">identificativo rapp qualità</param>
|
|
/// <param name="doPrint">true/false se stampare</param>
|
|
/// <returns></returns>
|
|
public bool creaUdcDaRappQualita(int numRapQual, string note, bool doPrint, string printerName)
|
|
{
|
|
bool answ = false;
|
|
string codStato = "";
|
|
// ottengo elenco righe dei cartellini del rapp qualità indicato SENZA righe UDC
|
|
DS_magazzino.RapQualDataTable tabRapQual = taRapQual.getByNumRapQualNoUdc(numRapQual);
|
|
// per prima cosa verifico che ci sia il rapporto di qualità in esame e che abbia righe da associare ad UDC
|
|
if (tabRapQual.Rows.Count > 0)
|
|
{
|
|
string UDC = "";
|
|
foreach (DS_magazzino.RapQualRow rqRow in tabRapQual)
|
|
{
|
|
// se non ha già un UDC... e se NON E' stato già scaricato...
|
|
if (rqRow.UDC == "" && rqRow.LegaScaric.ToUpper() == "N")
|
|
{
|
|
answ = true;
|
|
// controllo se sia con benestare, se "N" imposto con stato Non accettata (da web.config) altrimenti con stato MP ok...
|
|
if (rqRow.BenesQual == "N")
|
|
{
|
|
codStato = memLayer.ML.confReadString("CodStatoMP-NA");
|
|
}
|
|
else
|
|
{
|
|
codStato = memLayer.ML.confReadString("CodStatoMP");
|
|
}
|
|
// per ogni riga creo un UDC
|
|
DS_Applicazione.ElencoCartelliniDataTable tabCartellini = DataProxy.obj.taCartellini.stp_insNewFull(memLayer.ML.confReadString("CodCS"), memLayer.ML.confReadString("BilanciaMP"), string.Format("{0:yy}", DateTime.Now), rqRow.CodFor, rqRow.CodLega, "", "", "", "", DateTime.Now, 0, memLayer.ML.confReadString("CodImballoMP"), CodSoggCurrUser, 0, memLayer.ML.confReadInt("IdxPosizMP"), "M", "UDC_MP", rqRow.Qta, Convert.ToDouble(rqRow.Qta), 1, codStato, rqRow.ProgUDC, false, note); // UDC_MP HARD CODED!!!
|
|
try
|
|
{
|
|
UDC = tabCartellini[0].UDC;
|
|
// lo associo!
|
|
taRapQual.stp_associaUDC(rqRow.ProgUDC, UDC);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Non sono riuscito a creare associazione UDC / rapp qual: UDC creato: {0}, progRappQual: {1}, eccezione: {2}", UDC, rqRow.ProgUDC, e), tipoLog.EXCEPTION);
|
|
}
|
|
try
|
|
{
|
|
if (rqRow.BenesQual == "N")
|
|
{
|
|
// se non c'è benestare cambio posizione ad un altra cella, la prima (terra) del cod blocco MP - N.C.
|
|
int idxPosizTo = taCelle.getByCodMag(memLayer.ML.confReadString("CodCS"), memLayer.ML.confReadString("CodMagMP_NA"))[0].IdxCella;
|
|
magazzino.spostaUDC(memLayer.ML.confReadString("CodCS"), UDC, idxPosizTo, true);
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Non sono riuscito a spostare UDC non conforme: UDC creato: {0}, progRappQual: {1}, eccezione: {2}", UDC, rqRow.ProgUDC, e), tipoLog.EXCEPTION);
|
|
}
|
|
}
|
|
}
|
|
|
|
// se devo stampare lancio stampa...
|
|
if (doPrint)
|
|
{
|
|
stampaUdcDaRappQualita(numRapQual, printerName);
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// aggiorna le note di un RDQ
|
|
/// </summary>
|
|
/// <param name="note"></param>
|
|
/// <returns></returns>
|
|
public bool updateNoteRDQ(int numRapQual, string note)
|
|
{
|
|
bool answ = false;
|
|
try
|
|
{
|
|
DataProxy.obj.taRQN.stp_UDC_updateNoteByRQ(numRapQual, note);
|
|
answ = true;
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// effettua la (ri)stampa di TUTTI gli UDC dato un rapporto di qualità
|
|
/// </summary>
|
|
/// <param name="numRapQual">identificativo rapp qualità</param>
|
|
/// <returns></returns>
|
|
public bool stampaUdcDaRappQualita(int numRapQual, string printerName)
|
|
{
|
|
bool answ = false;
|
|
// ottengo elenco righe dei cartellini del rapp qualità indicato SENZA righe UDC
|
|
DS_magazzino.RapQualDataTable tabRapQual = taRapQual.getByNumRapQual(numRapQual);
|
|
// per prima cosa verifico che ci sia il rapporto di qualità in esame e che abbia righe da associare ad UDC
|
|
if (tabRapQual.Rows.Count > 0)
|
|
{
|
|
answ = true;
|
|
foreach (DS_magazzino.RapQualRow rqRow in tabRapQual)
|
|
{
|
|
answ = reportPrinter.obj.stampaCartellino(tipoCartellino.cartMP, rqRow.UDC, printerName);
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
public enum esitoOperazione
|
|
{
|
|
ok, // tutto ok, come true
|
|
errore, // non è andata, errore generico
|
|
errore_mismatch, // errore x mancanza corrispondenza tra dati (particolare-esponente-figura di lista ed UDC, ad esempio)
|
|
errore_readOnly, // errore xché ild ato è read only o bloccato (es lista di prelievo già completata, NON posso riprenderla in carico)
|
|
errore_posUDC, // errore perché UDC è in una posizione che non consente l'operazione indicata
|
|
errore_noUdc
|
|
}
|
|
|
|
public enum statoLista
|
|
{
|
|
bozza = 0,
|
|
generata,
|
|
iniziata,
|
|
completata,
|
|
scaricata
|
|
} |