private void CaricaArticoloFrm_Load(object sender, EventArgs e)
        {
            lblEsito.Text = string.Empty;
            Spedizioni sp = new Spedizioni();

            sp.FillUbicazioni(_ds, true);
        }
        private void BTNOK_Click(object sender, EventArgs e)
        {
            if (ddlTipoMovimento.SelectedIndex == -1)
            {
                MessageBox.Show("Selezionare un tipo movimento", "ATTENZIONE", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                return;
            }
            if (string.IsNullOrEmpty(TXTCAUSALE.Text))
            {
                MessageBox.Show("Indicare la causale", "ATTENZIONE", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                return;
            }
            if (numQuta.Value == 0)
            {
                MessageBox.Show("Indicare una quantità", "ATTENZIONE", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                return;
            }

            Spedizioni spedizioni = new Spedizioni();
            string     esito      = spedizioni.Movimenta(_saldo.IDSALDO, numQuta.Value, TXTCAUSALE.Text, (string)ddlTipoMovimento.SelectedItem, _utente);

            if (esito == "COMPLETATA")
            {
                MessageBox.Show("Operazione eseguita con successo", "INFORMAZIONE", MessageBoxButtons.OK, MessageBoxIcon.Information);
                DialogResult = DialogResult.OK;
                Close();
            }
            else
            {
                MessageBox.Show(esito, "ATTENZIONE", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return;
            }
        }
        private void RecuperaArticoloFrm_Load(object sender, EventArgs e)
        {
            Spedizioni spedizioni = new Spedizioni();

            spedizioni.FillMagazz(_ds, _filtro);
            creaGriglia();
        }
Beispiel #4
0
        private void btnCerca_Click(object sender, EventArgs e)
        {
            this.Text = string.Format("SALDI {0} - {1}", txtubicazione.Text, txtarticolo.Text);
            Spedizioni spedizioni = new Spedizioni();

            spedizioni.FillSaldi(_ds, txtubicazione.Text, txtarticolo.Text, chkNascondiSaldiAZero.Checked);
            CreaGriglia();
        }
        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 ActionResult Inserisci(string BarcodeODL, string BarcodeUbicazione, string BarcodeOperatore)
        {
            string risposta = "Barcode vuoto";

            if (!string.IsNullOrEmpty(BarcodeODL) || !string.IsNullOrEmpty(BarcodeUbicazione) || !string.IsNullOrEmpty(BarcodeOperatore))
            {
                Spedizioni spedizioni = new Spedizioni();
                risposta = spedizioni.Inserisci(BarcodeODL, BarcodeUbicazione, BarcodeOperatore);
            }
            return(PartialView("Inserisci", risposta));
        }
        public ActionResult LeggiBarcode(string Barcode)
        {
            string risposta = "Barcode vuoto";

            if (!string.IsNullOrEmpty(Barcode))
            {
                Spedizioni spedizioni = new Spedizioni();
                risposta = spedizioni.LeggiBarcode(Barcode);
            }
            return(PartialView("LeggiBarcode", risposta));
        }
        private void CreaGriglia()
        {
            _ds.SPUBICAZIONI.Clear();
            Spedizioni spedizioni = new Spedizioni();

            spedizioni.FillUbicazioni(_ds, true);

            dgvUbicazioni.DataSource = _ds;
            dgvUbicazioni.DataMember = _ds.SPUBICAZIONI.TableName;

            dgvUbicazioni.Refresh();
        }
        private void leggiFile_click(object sender, EventArgs e)
        {
            try
            {
                btnSimula.Enabled = true;

                _inSimulazione  = true;
                _ds             = new SpedizioniDS();
                lblMessage.Text = string.Empty;
                if (string.IsNullOrEmpty(txtFile.Text))
                {
                    lblMessage.Text = "Selezionare un file";
                    return;
                }

                if (!File.Exists(txtFile.Text))
                {
                    lblMessage.Text = "Il file specificato non esiste";
                    return;
                }

                Spedizioni spedizioni = new Spedizioni();

                string messaggioErrore;

                if (!spedizioni.LeggiFileExcelOpera(_ds, txtFile.Text, _brand, out messaggioErrore))
                {
                    string messaggio = string.Format("Errore nel caricamento del file excel. Errore: {0}", messaggioErrore);
                    MessageBox.Show(messaggio, "ERRORE LETTURA FILE", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }

                if (_ds.SPOPERA.Count == 0)
                {
                    lblMessage.Text = "Il file è vuoto";
                    return;
                }

                dgvExcelCaricato.AutoGenerateColumns = true;
                //                dgvExcelCaricato.DataSource = _ds;

                caricaGriglia();
            }
            catch (Exception ex)
            {
                ExceptionFrm frm = new ExceptionFrm(ex);
                frm.ShowDialog();
            }
            finally
            {
                _inSimulazione = false;
            }
        }
Beispiel #10
0
 private void txtOdl_KeyDown(object sender, KeyEventArgs e)
 {
     if (e.KeyCode == Keys.Enter)
     {
         lblEsito.Text = string.Empty;
         lblOdl.Text   = string.Empty;
         string     barcode    = txtOdl.Text;
         Spedizioni spedizioni = new Spedizioni();
         lblOdl.Text = spedizioni.LeggiBarcode(barcode);
         txtubicazione.Focus();
     }
 }
Beispiel #11
0
        private void btnesegui_Click(object sender, EventArgs e)
        {
            Spedizioni spedizioni = new Spedizioni();
            string     esito      = spedizioni.UbicaDaODL(txtOdl.Text, txtubicazione.Text, _utenteConnesso);

            if (esito == "COMPLETATA")
            {
                txtOdl.Focus();
                txtOdl.Text        = string.Empty;
                txtubicazione.Text = string.Empty;
                lblEsito.ForeColor = Color.Green;
            }
            else
            {
                lblEsito.ForeColor = Color.Red;
            }
            lblEsito.Text = esito;
        }
Beispiel #12
0
        private void btncerca_Click(object sender, EventArgs e)
        {
            DateTime inizio = new DateTime(dtInizio.Value.Year, dtInizio.Value.Month, dtInizio.Value.Day, 0, 0, 0);

            DateTime fine = new DateTime(dtFine.Value.Year, dtFine.Value.Month, dtFine.Value.Day, 23, 59, 59);

            if (inizio > fine)
            {
                return;
            }

            _ds.SPMOVIMENTIEXT.Clear();
            Spedizioni spedizioni = new Spedizioni();

            spedizioni.FillMovimenti(_ds, txtUbicazione.Text.ToUpper(), txtArticolo.Text.ToUpper(), inizio, fine);

            CreaGriglia();
        }
        private void btnSalva_Click(object sender, EventArgs e)
        {
            try
            {
                if (string.IsNullOrEmpty(txtCodiceUbicazione.Text))
                {
                    MessageBox.Show("Inserire il codice dell'ubicazione", "ATTENZIONE", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    return;
                }

                if (string.IsNullOrEmpty(txtDescrizioneUbicazione.Text))
                {
                    MessageBox.Show("Inserire la descrizione dell'ubicazione", "ATTENZIONE", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    return;
                }

                string codice      = txtCodiceUbicazione.Text.ToUpper();
                string descrizione = txtDescrizioneUbicazione.Text.ToUpper();

                Spedizioni spedizioni = new Spedizioni();

                SpedizioniDS ds = new SpedizioniDS();
                spedizioni.FillUbicazioni(ds, false);

                if (_ds.SPUBICAZIONI.Any(x => x.CODICE == codice))
                {
                    MessageBox.Show("Esiste già un'ubicazione con questo codice", "ATTENZIONE", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    return;
                }

                spedizioni.SalvaUbicazione(codice, descrizione, _utenteConnesso);
                CreaGriglia();
                txtCodiceUbicazione.Text      = String.Empty;
                txtDescrizioneUbicazione.Text = string.Empty;
                txtCodiceUbicazione.Focus();
            }
            catch (Exception ex)
            {
                MostraEccezione("Errore nel salvataggio dell'ubicazione", ex);
            }
        }
        private void dgvUbicazioni_CellContentClick(object sender, DataGridViewCellEventArgs e)
        {
            if (e.ColumnIndex < 4 || e.ColumnIndex > 5)
            {
                return;
            }
            if (e.RowIndex < 0)
            {
                return;
            }
            try
            {
                if (e.ColumnIndex == 4)
                {
                    decimal    idUbicazione = (decimal)dgvUbicazioni.Rows[e.RowIndex].Cells[0].Value;
                    Spedizioni spedizioni   = new Spedizioni();
                    spedizioni.CancellaUbicazione(idUbicazione, _utenteConnesso);
                }

                if (e.ColumnIndex == 5)
                {
                    if (ddlStampanti.SelectedIndex == -1)
                    {
                        MessageBox.Show("Selezionare una stampante", "ATTENZIONE", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                        return;
                    }
                    string PrinterName = ddlStampanti.SelectedItem.ToString();
                    string codice      = (string)dgvUbicazioni.Rows[e.RowIndex].Cells[1].Value;
                    string descrizione = (string)dgvUbicazioni.Rows[e.RowIndex].Cells[2].Value;
                    string barcode     = (string)dgvUbicazioni.Rows[e.RowIndex].Cells[3].Value;

                    ZebraHelper.StampaEtichettaUbicazione(PrinterName, codice, descrizione, barcode);
                }
            }
            catch (Exception ex)
            {
                MostraEccezione("Impossibile eseguire l'operazione", ex);
            }
        }
        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;
            }
        }
        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 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 popolaSaldi()
        {
            string[] idmagazzz = new string[] { "0000157776",
                                                "0000103386",
                                                "0000016109",
                                                "0000103385",
                                                "0000045338",
                                                "0000011705",
                                                "0000126789",
                                                "0000045365",
                                                "0000013395",
                                                "0000113760",
                                                "0000164734",
                                                "0000113062",
                                                "0000045640",
                                                "0000013669",
                                                "0000016582",
                                                "0000013640",
                                                "0000016588",
                                                "0000164741",
                                                "0000047401",
                                                "0000080283",
                                                "0000145413",
                                                "0000157569",
                                                "0000053119",
                                                "0000046174",
                                                "0000012785",
                                                "0000061506",
                                                "0000061518",
                                                "0000012736",
                                                "0000016370",
                                                "0000092568",
                                                "0000104587",
                                                "0000118267",
                                                "0000016296",
                                                "0000047417",
                                                "0000015279",
                                                "0000016283",
                                                "0000046892",
                                                "0000016247",
                                                "0000047822",
                                                "0000121909",
                                                "0000014517",
                                                "0000118265",
                                                "0000012692",
                                                "0000013230",
                                                "0000089614",
                                                "0000113045",
                                                "0000076922",
                                                "0000075896",
                                                "0000059950",
                                                "0000013294",
                                                "0000013120",
                                                "0000161675",
                                                "0000011977",
                                                "0000168098",
                                                "0000061382",
                                                "0000047947",
                                                "0000054827",
                                                "0000168287",
                                                "0000012108",
                                                "0000013258",
                                                "0000067819",
                                                "0000067825",
                                                "0000154492",
                                                "0000161676",
                                                "0000031451",
                                                "0000075995",
                                                "0000038289",
                                                "0000038303",
                                                "0000162600",
                                                "0000035371",
                                                "0000053079",
                                                "0000053096",
                                                "0000036423",
                                                "0000103393",
                                                "0000050180",
                                                "0000047981",
                                                "0000047994",
                                                "0000169815",
                                                "0000093648",
                                                "0000167253",
                                                "0000054708",
                                                "0000074479",
                                                "0000044243",
                                                "0000044265",
                                                "0000032166",
                                                "0000169691",
                                                "0000032173",
                                                "0000034058",
                                                "0000138072",
                                                "0000147984",
                                                "0000089019",
                                                "0000111790",
                                                "0000057116",
                                                "0000168105",
                                                "0000154501",
                                                "0000168104",
                                                "0000154502",
                                                "0000168106",
                                                "0000062123",
                                                "0000098270",
                                                "0000110689",
                                                "0000081676",
                                                "0000128605",
                                                "0000081682",
                                                "0000106132",
                                                "0000098252",
                                                "0000123147",
                                                "0000103288",
                                                "0000097409",
                                                "0000121024",
                                                "0000136665",
                                                "0000125838",
                                                "0000122546",
                                                "0000121031",
                                                "0000121882",
                                                "0000129165",
                                                "0000105491",
                                                "0000154513",
                                                "0000105500",
                                                "0000152662",
                                                "0000149980",
                                                "0000110693",
                                                "0000102245",
                                                "0000161677",
                                                "0000106119",
                                                "0000156064",
                                                "0000117183",
                                                "0000123765",
                                                "0000154517",
                                                "0000158592",
                                                "0000156084",
                                                "0000156085",
                                                "0000094811",
                                                "0000044874",
                                                "0000156086",
                                                "0000126786",
                                                "0000070007",
                                                "0000156089",
                                                "0000156090",
                                                "0000156091" };
            Spedizioni spedizioni = new Spedizioni();
            Random     rnd        = new Random(DateTime.Now.Millisecond);

            foreach (string idmagazz in idmagazzz)
            {
                decimal ubicazione = (decimal)rnd.Next(21, 121);  // creates a number between 1 and 12
                decimal bas        = (decimal)Math.Pow(10, rnd.Next(1, 2));
                decimal quantita   = (decimal)rnd.Next(1, 5) * bas;
                spedizioni.SalvaSaldo(ubicazione, idmagazz, quantita, _utenteConnesso);
            }
        }