コード例 #1
0
        public async Task <OutputStored <NewDispaccioIn> > Execute(long idDispaccio, string userChiusura)
        {
            var dispaccio = new NewDispaccioIn()
            {
                UsrChiusura = userChiusura,
                Id          = idDispaccio
            };

            var result = new OutputStored <NewDispaccioIn>(dispaccio);

            const string STORED_NEW_DISPACCIO_IN_CHIUSURA = "New_Dispaccio_In_Chiusura";

            await context.LoadStoredProc(STORED_NEW_DISPACCIO_IN_CHIUSURA)
            .AddParam("Usr_Chiusura", result.Entita.UsrChiusura)
            .AddParam("Id", result.Entita.Id)
            .AddParam("Error_Number", out result.Error_Number)
            .AddParam("Error_Msg", out result.Error_msg, new ParamExtra()
            {
                Size = 255
            })
            .AddParam("Data_Chiusura", out IOutParam <string> Data_Chiusura, new ParamExtra()
            {
                Size = 10
            })
            .ExecNonQueryAsync();

            if (string.IsNullOrEmpty(result.Error_msg.Value))
            {
                result.Entita.DataChiusura = Convert.ToDateTime(Data_Chiusura.Value);
            }

            return(result);
        }
コード例 #2
0
        public async Task <OutputStored <NewDispaccioIn> > Execute(NewDispaccioIn nuovoDispaccio)
        {
            var result = new OutputStored <NewDispaccioIn>(nuovoDispaccio);

            const string STORED_NEW_DISPACCIO_IN_ARRIVO = "New_Dispaccio_In_Arrivo";


            await context.LoadStoredProc(STORED_NEW_DISPACCIO_IN_ARRIVO)
            .AddParam("Code_Racc", result.Entita.CodeRacc)
            .AddParam("Mittente", result.Entita.Mittente)
            .AddParam("Usr_Arrivo", result.Entita.UsrArrivo)
            .AddParam("Identity", out IOutParam <long> identity)
            .AddParam("Data_Arrivo", out IOutParam <string> Data_Arrivo, new ParamExtra()
            {
                Size = 10
            })
            .AddParam("Error_Msg", out result.Error_msg, new ParamExtra()
            {
                Size = 255
            })
            .AddParam("Error_Number", out result.Error_Number)
            .ExecNonQueryAsync();

            if (string.IsNullOrEmpty(result.Error_msg.Value))
            {
                result.Entita.DataArrivo = Convert.ToDateTime(Data_Arrivo.Value);
                result.Entita.Id         = identity.Value;
            }

            return(result);
        }
コード例 #3
0
        public async Task <ResultStoredViewModel <DispaccioViewModel> > Nuovo(NewDispaccioIn nuovoDispaccio)
        {
            var dispaccio = await _dispaccioRepository.Nuovo(nuovoDispaccio);

            var result = Traslate(dispaccio);

            return(result);
        }
コード例 #4
0
        private DispaccioViewModel Traslate(NewDispaccioIn dispaccio)
        {
            var result = new DispaccioViewModel()
            {
                CodDispaccio = dispaccio.CodeRacc,
                DataApertura = (dispaccio.DataApertura.HasValue) ? dispaccio.DataApertura.Value.ToShortDateString() : string.Empty,
                DataArrivo   = dispaccio.DataArrivo.ToShortDateString(),
                DataChiusura = (dispaccio.DataChiusura.HasValue) ? dispaccio.DataChiusura.Value.ToShortDateString() : string.Empty,
                Id           = dispaccio.Id.ToString(),
                Mittente     = dispaccio.Mittente
            };

            return(result);
        }
コード例 #5
0
        public async Task <IActionResult> Nuovo([Bind("CodeRacc,Mittente,DataArrivo")] NewDispaccioIn nuovoDispaccio)
        {
            nuovoDispaccio.UsrArrivo = user;

            var result = await ApiClientFactory.Instance.NuovoDispaccio(nuovoDispaccio);

            if (result.Errore())
            {
                TempData["Errore"] = string.Format("Salvataggio dispaccio non andato a buon fine: {0}", result.MessaggioErrore);
            }
            else
            {
                TempData["Conferma"] = string.Format("Dispaccio con id {0}, cod. {1}, inserito con successo", result.Entita.Id, result.Entita.CodDispaccio);
            }

            return(await Index());
        }
コード例 #6
0
        public async Task <IActionResult> Nuovo(NewDispaccioIn nuovoDispaccio)
        {
            if (nuovoDispaccio == null)
            {
                return(NotFound("Errore durante il salvataggio: dispaccio non avvalorato correttamente"));
            }

            var result = await _dispaccioService.Nuovo(nuovoDispaccio);

            if (result == null)
            {
                return(NotFound("Si è verificato un errore durante il salvataggio"));
            }
            //else if (result.Errore())
            //    return NotFound(result.MessaggioErrore);

            return(Ok(result));
        }
コード例 #7
0
        public async Task <ResultStoredViewModel <DispaccioViewModel> > NuovoDispaccio(NewDispaccioIn nuovoDispaccio)
        {
            var requestUrl = CreateRequestUri(string.Format(System.Globalization.CultureInfo.InvariantCulture,
                                                            ControllerDispacci + "Nuovo"));

            return(await PostAsync <DispaccioViewModel, NewDispaccioIn>(requestUrl, nuovoDispaccio));
        }
コード例 #8
0
 async public Task <OutputStored <NewDispaccioIn> > Nuovo(NewDispaccioIn nuovoDispaccio)
 {
     return(await new New_Dispaccio_In_Arrivo(RepositoryContext).Execute(nuovoDispaccio));
 }