private void btnCreaOpera_Click(object sender, EventArgs e)
        {
            try
            {
                List <SpedizioniDS.SPOPERARow> righeDaSalvare = _ds.SPOPERA.Where(x => x.VALIDATA && !x.IsIDUBICAZIONENull()).ToList();

                if (righeDaSalvare.Count == 0)
                {
                    MessageBox.Show("NESSUNA RIGA VALIDATA. Non ci sono righe da salvare.", "ATTENZIONE", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    return;
                }

                SpedizioniDS dsSalvataggi = new SpedizioniDS();
                Spedizioni   spedizioni   = new Spedizioni();

                foreach (SpedizioniDS.SPOPERARow rigaDaSalvare in righeDaSalvare)
                {
                    dsSalvataggi.SPSALDI.Clear();
                    spedizioni.FillSaldi(dsSalvataggi, rigaDaSalvare.CODICE, rigaDaSalvare.MODELLO_CODICE, true);
                    SpedizioniDS.MAGAZZRow magazz = spedizioni.GetMagazz(_ds, rigaDaSalvare.MODELLO_CODICE);

                    SpedizioniDS.SPSALDIEXTRow saldo = dsSalvataggi.SPSALDIEXT.Where(x => x.IDUBICAZIONE == rigaDaSalvare.IDUBICAZIONE && x.IDMAGAZZ == magazz.IDMAGAZZ).FirstOrDefault();
                    if (saldo == null)
                    {
                        rigaDaSalvare.NOTE = string.Format("Errore nell'estrazione del saldo. CODICE = {0} MODELLO = {1}", rigaDaSalvare.CODICE, magazz.MODELLO);
                        continue;
                    }

                    if (saldo.QUANTITA < rigaDaSalvare.QTAUBIUTIL)
                    {
                        rigaDaSalvare.NOTE = string.Format("Errore quantità in saldo non sufficiente. CODICE = {0} MODELLO= {1}", rigaDaSalvare.CODICE, magazz.MODELLO);

                        continue;
                    }

                    decimal quantitaUtilizzata = rigaDaSalvare.QTAUBIUTIL;
                    if (saldo.QUANTITA < quantitaUtilizzata)
                    {
                        rigaDaSalvare.NOTE = string.Format("Errore quantità in saldo non sufficiente. CODICE = {0} MODELLO= {1}", rigaDaSalvare.CODICE, magazz.MODELLO);
                        continue;
                    }

                    string causale = string.Format("OPERA {0} - {1}", _brand, rigaDaSalvare.DATA_RICHIESTA.ToShortDateString());
                    rigaDaSalvare.NOTE = spedizioni.Movimenta(dsSalvataggi, saldo.IDSALDO, quantitaUtilizzata, causale, "PRELIEVO", _utenteConnesso);
                }

                if (righeDaSalvare.Count > 0)
                {
                    CreaFileExcelOpera(righeDaSalvare);
                }
            }
            catch (Exception ex)
            {
                ExceptionFrm frm = new ExceptionFrm(ex);
                frm.ShowDialog();
            }
        }
 public SpedizioniDS.MAGAZZRow GetMagazz(SpedizioniDS ds, string modello)
 {
     SpedizioniDS.MAGAZZRow magazz = ds.MAGAZZ.Where(x => x.MODELLO == modello).FirstOrDefault();
     if (magazz == null)
     {
         using (SpedizioniBusiness bSpedizioni = new SpedizioniBusiness())
         {
             bSpedizioni.GetMagazz(ds, modello);
             magazz = ds.MAGAZZ.Where(x => x.MODELLO == modello).FirstOrDefault();
         }
     }
     return(magazz);
 }
        private void button1_Click(object sender, EventArgs e)
        {
            if (nQuantita.Value == 0)
            {
                MessageBox.Show("Indicare LA QUANTITà", "ATTENZIONE", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }

            Spedizioni sp = new Spedizioni();

            lblEsito.Text = String.Empty;

            if (string.IsNullOrEmpty(txtUbicazione.Text))
            {
                MessageBox.Show("Indicare l'ubicazione", "ATTENZIONE", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }
            txtUbicazione.Text = txtUbicazione.Text.ToUpper();
            txtarticolo.Text   = txtarticolo.Text.ToUpper();
            txtCausale.Text    = txtCausale.Text.ToUpper();

            SpedizioniDS.SPUBICAZIONIRow ubicazione = _ds.SPUBICAZIONI.Where(x => x.CODICE == txtUbicazione.Text).FirstOrDefault();
            if (ubicazione == null)
            {
                MessageBox.Show("Ubicazione inesistente", "ATTENZIONE", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }

            if (string.IsNullOrEmpty(txtarticolo.Text))
            {
                MessageBox.Show("Indicare l'articolo", "ATTENZIONE", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }

            sp.FillMagazz(_ds, txtarticolo.Text);
            if (_ds.MAGAZZ.Count == 0)
            {
                MessageBox.Show("Impossibile trovare l'articolo", "ATTENZIONE", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }

            if (_ds.MAGAZZ.Count > 1)
            {
                MessageBox.Show("Più articoli trovati con questa descrizione. Filtrare i dati", "ATTENZIONE", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }

            SpedizioniDS.MAGAZZRow articolo   = _ds.MAGAZZ.Where(x => x.MODELLO == txtarticolo.Text).FirstOrDefault();
            Anagrafica             anagrafica = new Anagrafica();

            AnagraficaDS.MAGAZZRow art = anagrafica.GetMAGAZZ(articolo.IDMAGAZZ);

            if (!sp.Inserimento(ubicazione, art, nQuantita.Value, txtCausale.Text, _utenteConnesso))
            {
                MessageBox.Show("OPERAZIONE FALLITA errore nel salvataggio", "ATTENZIONE", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }

            lblEsito.Text = "OPERAZIONE RIUSCITA";

            nQuantita.Value = 0;
        }
        private void dgvExcelCaricato_CellValidated(object sender, DataGridViewCellEventArgs e)
        {
            if (_inSimulazione)
            {
                return;
            }
            try
            {
                _inSimulazione = true;

                if (e.ColumnIndex < 19 || e.ColumnIndex > 22)
                {
                    return;
                }
                if (dgvExcelCaricato.Rows[e.RowIndex].Cells[19].Value == DBNull.Value)
                {
                    return;
                }
                if (dgvExcelCaricato.Rows[e.RowIndex].Cells[20].Value == DBNull.Value)
                {
                    return;
                }
                if (dgvExcelCaricato.Rows[e.RowIndex].Cells[21].Value == DBNull.Value)
                {
                    return;
                }

                bool validata = (bool)dgvExcelCaricato.Rows[e.RowIndex].Cells[23].Value;

                decimal valoreUbicato    = (decimal)dgvExcelCaricato.Rows[e.RowIndex].Cells[19].Value;
                decimal valoreUtilizzato = (decimal)dgvExcelCaricato.Rows[e.RowIndex].Cells[20].Value;
                decimal valoreResiduo    = (decimal)dgvExcelCaricato.Rows[e.RowIndex].Cells[21].Value;
                decimal sequenzaRiga     = (decimal)dgvExcelCaricato.Rows[e.RowIndex].Cells[22].Value;

                Spedizioni             spedizioni = new Spedizioni();
                string                 modello    = (string)dgvExcelCaricato.Rows[e.RowIndex].Cells[7].Value;
                SpedizioniDS.MAGAZZRow magazz     = spedizioni.GetMagazz(_ds, modello);
                if (magazz == null)
                {
                    return;
                }

                DateTime dataRichiesta = (DateTime)dgvExcelCaricato.Rows[e.RowIndex].Cells[5].Value;

                decimal idUbicazione             = (decimal)dgvExcelCaricato.Rows[e.RowIndex].Cells[17].Value;
                SpedizioniDS.SPSALDIEXTRow saldo = _ds.SPSALDIEXT.Where(x => x.IDMAGAZZ == magazz.IDMAGAZZ && x.IDUBICAZIONE == idUbicazione).FirstOrDefault();
                if (saldo == null)
                {
                    return;
                }

                SpedizioniDS dsAlternativo           = new SpedizioniDS();
                decimal      valoreUtilizzatoVecchio = 0;
                if (e.ColumnIndex == 20)
                {
                    valoreUtilizzatoVecchio = valoreUbicato - valoreResiduo;
                    if (valoreUtilizzatoVecchio == valoreUtilizzato)
                    {
                        return;
                    }

                    if ((valoreUbicato - valoreUtilizzato) >= 0 && !validata)
                    {
                        valoreResiduo   = valoreUbicato - valoreUtilizzato;
                        saldo.QUANTITA += valoreUtilizzatoVecchio - valoreUtilizzato;
                    }
                    else
                    {
                        valoreUtilizzato = valoreUtilizzatoVecchio;
                    }
                }

                if (e.ColumnIndex == 21)
                {
                    decimal valoreResiduoVecchio = valoreUbicato - valoreUtilizzato;
                    if (valoreResiduoVecchio == valoreResiduo)
                    {
                        return;
                    }
                    valoreUtilizzatoVecchio = valoreUtilizzato;
                    if ((valoreUbicato - valoreResiduo) >= 0 && !validata)
                    {
                        valoreUtilizzato = valoreUbicato - valoreResiduo;
                        saldo.QUANTITA  += valoreUtilizzatoVecchio - valoreUtilizzato;
                    }
                    else
                    {
                        valoreResiduo = valoreUbicato - valoreUtilizzato;
                    }
                }

                dgvExcelCaricato.Rows[e.RowIndex].Cells[20].Value = valoreUtilizzato;
                dgvExcelCaricato.Rows[e.RowIndex].Cells[21].Value = valoreResiduo;

                ricalcolaFratelli(dsAlternativo, dataRichiesta, modello, sequenzaRiga, magazz.IDMAGAZZ);
                //         if (valoreUtilizzatoVecchio - valoreUtilizzato < 0)
                //  {

                List <SpedizioniDS.SPOPERARow> altreUbicazioni = _ds.SPOPERA.Where(x => !x.IsIDUBICAZIONENull() && x.IDUBICAZIONE == idUbicazione && x.MODELLO_CODICE == modello && x.DATA_RICHIESTA != dataRichiesta && x.SEQUENZA == 1).ToList();
                if (altreUbicazioni.Count == 0)
                {
                    return;
                }

                foreach (SpedizioniDS.SPOPERARow altraUbicazione in altreUbicazioni)
                {
                    ricalcolaFratelli(dsAlternativo, altraUbicazione.DATA_RICHIESTA, modello, 0, magazz.IDMAGAZZ);
                }

                foreach (SpedizioniDS.SPOPERARow riga in dsAlternativo.SPOPERA)
                {
                    _ds.SPOPERA.ImportRow(riga);
                }

                caricaGriglia();

                //  }
            }
            catch (Exception ex)
            {
                ExceptionFrm frm = new ExceptionFrm(ex);
                frm.ShowDialog();
            }

            finally
            {
                _inSimulazione = false;
            }
        }
        private void btnSimula_Click(object sender, EventArgs e)
        {
            try
            {
                btnSimula.Enabled = false;
                Cursor.Current    = Cursors.WaitCursor;

                _inSimulazione = true;

                if (_ds.SPOPERA.Any(x => x.IsDATA_RICHIESTANull()))
                {
                    MessageBox.Show("Ci sono righe con data richiesta non valorizzata. Impossibile procedere", "ATTENZIONE", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    btnSimula.Enabled = true;
                    return;
                }

                Spedizioni spedizioni = new Spedizioni();
                spedizioni.FillSaldi(_ds, string.Empty, string.Empty, true);
                spedizioni.FillUbicazioni(_ds, false);

                SpedizioniDS dsAlternativo = new SpedizioniDS();

                int totaleRighe = dgvExcelCaricato.Rows.Count;
                for (int indiceRighe = 0; indiceRighe < totaleRighe; indiceRighe++)
                {
                    DataGridViewRow riga              = dgvExcelCaricato.Rows[indiceRighe];
                    string          modello           = (string)riga.Cells[7].Value;
                    decimal         quantitaDaSpedire = (decimal)riga.Cells[9].Value;
                    DateTime        dataRichiesta     = (DateTime)riga.Cells[5].Value;
                    int             righe             = dgvExcelCaricato.Rows.Count;

                    SpedizioniDS.MAGAZZRow magazz = spedizioni.GetMagazz(_ds, modello);
                    if (magazz == null)
                    {
                        continue;
                    }

                    SpedizioniDS.SPSALDIEXTRow saldoPerfetto = _ds.SPSALDIEXT.Where(x => x.QUANTITA == quantitaDaSpedire && x.IDMAGAZZ == magazz.IDMAGAZZ).FirstOrDefault();
                    if (saldoPerfetto != null)
                    {
                        string codiceUbicazione = _ds.SPUBICAZIONI.Where(x => x.IDUBICAZIONE == saldoPerfetto.IDUBICAZIONE).Select(x => x.CODICE).FirstOrDefault();

                        riga.Cells[17].Value = saldoPerfetto.IDUBICAZIONE;
                        riga.Cells[18].Value = codiceUbicazione;
                        riga.Cells[19].Value = saldoPerfetto.QUANTITA;
                        riga.Cells[20].Value = saldoPerfetto.QUANTITA;
                        riga.Cells[21].Value = 0;

                        saldoPerfetto.QUANTITA = 0;
                    }
                    else
                    {
                        bool    primariga         = true;
                        decimal quantitaImpegnata = 0;
                        decimal sequenza          = 0;
                        List <SpedizioniDS.SPSALDIEXTRow> saldi = _ds.SPSALDIEXT.Where(x => x.QUANTITA > 0 && x.IDMAGAZZ == magazz.IDMAGAZZ).OrderBy(x => x.QUANTITA).ToList();

                        //if (saldi == 0)
                        //riga.Cells[24].Value = "Nessun articolo in giacenza";



                        while (quantitaImpegnata < quantitaDaSpedire && saldi.Count > 0)
                        {
                            sequenza++;
                            SpedizioniDS.SPSALDIEXTRow saldo = saldi[0];
                            string  codiceUbicazione         = _ds.SPUBICAZIONI.Where(x => x.IDUBICAZIONE == saldo.IDUBICAZIONE).Select(x => x.CODICE).FirstOrDefault();
                            decimal quantitaNecessaria       = quantitaDaSpedire - quantitaImpegnata;

                            if (!primariga)
                            {
                                SpedizioniDS.SPOPERARow nuovaRiga = dsAlternativo.SPOPERA.NewSPOPERARow();
                                nuovaRiga.BRAND = string.Empty;                        // (string)riga.Cells[0].Value;
                                nuovaRiga.RAGIONE_SOCIALE_RIGA         = string.Empty; //riga.Cells[1].Value == DBNull.Value ? string.Empty : (string)riga.Cells[1].Value;
                                nuovaRiga.STAGIONE_DESCRIZIONE_TESTATA = string.Empty; //(string)riga.Cells[2].Value;
                                nuovaRiga.RIFERIMENTO_TESTATA          = string.Empty; //(string)riga.Cells[3].Value;
                                nuovaRiga.NUMERO_RIGA     = string.Empty;              //(string)riga.Cells[4].Value;
                                nuovaRiga.DATA_RICHIESTA  = (DateTime)riga.Cells[5].Value;
                                nuovaRiga.DATA_CREAZIONE  = (DateTime)riga.Cells[6].Value;
                                nuovaRiga.MODELLO_CODICE  = (string)riga.Cells[7].Value;
                                nuovaRiga.DESMODELLO      = (string)riga.Cells[8].Value;
                                nuovaRiga.QTANOSPE        = (decimal)riga.Cells[9].Value;
                                nuovaRiga.PREZZO_UNITARIO = (decimal)riga.Cells[10].Value;
                                nuovaRiga.QTAACCESI       = (decimal)riga.Cells[11].Value;
                                nuovaRiga.QTAEST          = (decimal)riga.Cells[12].Value;
                                nuovaRiga.QTATOT          = (decimal)riga.Cells[13].Value;
                                nuovaRiga.QTAACCCON       = (decimal)riga.Cells[14].Value;
                                nuovaRiga.QTANOACC        = (decimal)riga.Cells[15].Value;
                                nuovaRiga.QTASPE          = (decimal)riga.Cells[16].Value;

                                nuovaRiga.IDUBICAZIONE = saldo.IDUBICAZIONE;
                                nuovaRiga.CODICE       = codiceUbicazione;
                                nuovaRiga.QTAUBI       = saldo.QUANTITA;
                                nuovaRiga.SEQUENZA     = sequenza;
                                nuovaRiga.VALIDATA     = false;

                                if (quantitaNecessaria > saldo.QUANTITA)
                                {
                                    nuovaRiga.QTAUBIUTIL = saldo.QUANTITA;
                                    quantitaImpegnata   += saldo.QUANTITA;
                                    nuovaRiga.QTAUBIRES  = 0;
                                    saldo.QUANTITA       = 0;
                                }
                                else
                                {
                                    nuovaRiga.QTAUBIUTIL = quantitaNecessaria;
                                    quantitaImpegnata   += quantitaNecessaria;
                                    nuovaRiga.QTAUBIRES  = saldo.QUANTITA - quantitaNecessaria;
                                    saldo.QUANTITA       = saldo.QUANTITA - quantitaNecessaria;
                                }
                                dsAlternativo.SPOPERA.AddSPOPERARow(nuovaRiga);
                                //aggiungi riga
                            }
                            else
                            {
                                primariga            = false;
                                riga.Cells[17].Value = saldo.IDUBICAZIONE;
                                riga.Cells[18].Value = codiceUbicazione;
                                riga.Cells[19].Value = saldo.QUANTITA;

                                if (quantitaNecessaria > saldo.QUANTITA)
                                {
                                    riga.Cells[20].Value = saldo.QUANTITA;
                                    quantitaImpegnata   += saldo.QUANTITA;
                                    riga.Cells[21].Value = 0;
                                    saldo.QUANTITA       = 0;
                                }
                                else
                                {
                                    riga.Cells[20].Value = quantitaNecessaria;
                                    quantitaImpegnata   += quantitaNecessaria;
                                    riga.Cells[21].Value = saldo.QUANTITA - quantitaNecessaria;
                                    saldo.QUANTITA       = saldo.QUANTITA - quantitaNecessaria;
                                }
                            }
                            saldi = _ds.SPSALDIEXT.Where(x => x.QUANTITA > 0 && x.IDMAGAZZ == magazz.IDMAGAZZ).OrderBy(x => x.QUANTITA).ToList();
                        }
                    }
                }
                foreach (SpedizioniDS.SPOPERARow riga in dsAlternativo.SPOPERA)
                {
                    _ds.SPOPERA.ImportRow(riga);
                }

                caricaGriglia();
            }
            catch (Exception ex)
            {
                ExceptionFrm frm = new ExceptionFrm(ex);
                frm.ShowDialog();
                btnSimula.Enabled = true;
            }

            finally
            {
                Cursor.Current = Cursors.Default;
                _inSimulazione = false;
            }
        }