Пример #1
0
        public string CopiaProcesso(decimal idProcessoStandard, decimal idArticolo, decimal idImpianto, string utente)
        {
            string descrizione = "€#@#[]";

            using (ArticoloBusiness bArticolo = new ArticoloBusiness())
            {
                bArticolo.FillProcessi(_ds, -1, true);
                bArticolo.FillFasiProcesso(_ds, -1, true);
                ArticoloDS.PROCESSIRow processoStandard = _ds.PROCESSI.Where(x => x.IDPROCESSO == idProcessoStandard).FirstOrDefault();
                decimal idcolore = ElementiVuoti.ColoreVuoto;

                if (!processoStandard.IsIDCOLORENull())
                {
                    idcolore = processoStandard.IDCOLORE;
                }

                if (processoStandard == null)
                {
                    return("Errore durante la copia. Processo standard non trovato.");
                }
                string nuovaDescrizione = processoStandard.DESCRIZIONE;

                CreaNuovoProcesso(idArticolo, idImpianto, idcolore, descrizione, utente);
                _ds.PROCESSI.Clear();

                bArticolo.FillProcessi(_ds, idArticolo, true);
                bArticolo.FillFasiProcesso(_ds, idArticolo, true);


                ArticoloDS.PROCESSIRow processo = _ds.PROCESSI.Where(x => x.DESCRIZIONE == descrizione).FirstOrDefault();
                if (processo != null)
                {
                    processo.DESCRIZIONE = nuovaDescrizione;

                    List <ArticoloDS.FASIPROCESSORow> fasiStandard = _ds.FASIPROCESSO.Where(x => x.IDPROCESSO == idProcessoStandard).ToList();
                    foreach (ArticoloDS.FASIPROCESSORow faseStandard in fasiStandard)
                    {
                        ArticoloDS.FASIPROCESSORow fase = _ds.FASIPROCESSO.NewFASIPROCESSORow();
                        fase.CANCELLATO       = SiNo.No;
                        fase.CORRENTE         = faseStandard.CORRENTE;
                        fase.DURATA           = faseStandard.DURATA;
                        fase.DATAMODIFICA     = DateTime.Now;
                        fase.IDPROCESSO       = processo.IDPROCESSO;
                        fase.IDVASCA          = faseStandard.IDVASCA;
                        fase.SEQUENZA         = faseStandard.SEQUENZA;
                        fase.SPESSOREMASSIMO  = faseStandard.SPESSOREMASSIMO;
                        fase.SPESSORENOMINALE = faseStandard.SPESSORENOMINALE;
                        fase.SPESSOREMINIMO   = faseStandard.SPESSOREMINIMO;

                        fase.UTENTEMODIFICA = utente;
                        _ds.FASIPROCESSO.AddFASIPROCESSORow(fase);
                    }

                    bArticolo.UpdateTable(_ds.FASIPROCESSO.TableName, _ds);
                    bArticolo.UpdateTable(_ds.PROCESSI.TableName, _ds);
                    return("Salvataggio riuscito");
                }
                return("Errore durante la copia. Impossibile creare un nuovo processo.");
            }
        }
Пример #2
0
        public string SalvaProcesso(decimal idArticolo, decimal idImpianto, decimal idProcesso, decimal idTelaio, string descrizione, string vascheJSON, string utente)
        {
            string messaggio = string.Empty;
            bool   esito     = true;

            SalvaProcessoJson[] vasche = JSonSerializer.Deserialize <SalvaProcessoJson[]>(vascheJSON);
            foreach (SalvaProcessoJson vasca in vasche)
            {
                decimal aux;
                if (string.IsNullOrEmpty(vasca.Durata))
                {
                    esito = false;
                }
            }

            if (!esito)
            {
                messaggio = "Valorizzare la durata delle vasche";
                return(messaggio);
            }

            ArticoloDS.PROCESSIRow processo;

            using (ArticoloBusiness bArticolo = new ArticoloBusiness())
            {
                bArticolo.FillProcessi(_ds, idArticolo, true);
                bArticolo.FillFasiProcesso(_ds, idArticolo, true);

                processo = _ds.PROCESSI.Where(x => x.IDPROCESSO == idProcesso).FirstOrDefault();
                if (processo != null)
                {
                    processo.DESCRIZIONE = descrizione;

                    processo.IDTELAIO = idTelaio;
                    if (idTelaio == ElementiVuoti.TelaioVuoto)
                    {
                        processo.SetIDTELAIONull();
                    }

                    List <ArticoloDS.FASIPROCESSORow> fasi = _ds.FASIPROCESSO.Where(x => x.IDPROCESSO == idProcesso).ToList();
                    List <decimal> idFaseProcesso          = vasche.Select(x => x.IdFaseProcesso).ToList();

                    foreach (ArticoloDS.FASIPROCESSORow faseDaCancellare in fasi.Where(x => !idFaseProcesso.Contains(x.IDFASEPROCESSO)))
                    {
                        faseDaCancellare.CANCELLATO     = SiNo.Si;
                        faseDaCancellare.DATAMODIFICA   = DateTime.Now;
                        faseDaCancellare.UTENTEMODIFICA = utente;
                    }

                    for (int i = 0; i < vasche.Length; i++)
                    {
                        SalvaProcessoJson vasca            = vasche[i];
                        decimal           corrente         = decimal.Parse(vasca.Corrente.Replace(".", ","));
                        decimal           spessoreMinimo   = decimal.Parse(vasca.SpessoreMinimo.Replace(".", ","));
                        decimal           spessoreMassimo  = decimal.Parse(vasca.SpessoreMassimo.Replace(".", ","));
                        decimal           spessoreNominale = decimal.Parse(vasca.SpessoreNominale.Replace(".", ","));

                        ArticoloDS.FASIPROCESSORow fase = fasi.Where(x => x.IDFASEPROCESSO == vasca.IdFaseProcesso).FirstOrDefault();
                        if (fase == null)
                        {
                            fase                  = _ds.FASIPROCESSO.NewFASIPROCESSORow();
                            fase.CANCELLATO       = SiNo.No;
                            fase.CORRENTE         = corrente;
                            fase.SPESSOREMASSIMO  = spessoreMassimo;
                            fase.SPESSORENOMINALE = spessoreNominale;
                            fase.SPESSOREMINIMO   = spessoreMinimo;
                            fase.DURATA           = vasca.Durata;
                            fase.DATAMODIFICA     = DateTime.Now;
                            fase.IDPROCESSO       = idProcesso;
                            fase.IDVASCA          = vasca.IdVasca;
                            fase.SEQUENZA         = i;
                            fase.UTENTEMODIFICA   = utente;
                            _ds.FASIPROCESSO.AddFASIPROCESSORow(fase);
                        }
                        else
                        {
                            fase.CORRENTE         = corrente;
                            fase.DURATA           = vasca.Durata;
                            fase.SPESSOREMASSIMO  = spessoreMassimo;
                            fase.SPESSORENOMINALE = spessoreNominale;
                            fase.SPESSOREMINIMO   = spessoreMinimo;
                            fase.DATAMODIFICA     = DateTime.Now;
                            fase.SEQUENZA         = i;
                            fase.UTENTEMODIFICA   = utente;
                        }
                    }

                    bArticolo.UpdateTable(_ds.FASIPROCESSO.TableName, _ds);
                    bArticolo.UpdateTable(_ds.PROCESSI.TableName, _ds);
                    messaggio = "Salvataggio riuscito";
                }
            }

            return(messaggio);
        }