public async Task <OutputStored <NewCartolineDispaccioIn> > Execute(NewCartolineDispaccioIn cartolinaDispaccio)
{
var result = new OutputStored <NewCartolineDispaccioIn>(cartolinaDispaccio);
const string STORED_NEW_CARTOLINE_DISPACCIO_IN_DEL_TRACCIATURA = "New_Cartoline_Dispaccio_In_Tracciatura";
await context.LoadStoredProc(STORED_NEW_CARTOLINE_DISPACCIO_IN_DEL_TRACCIATURA)
.AddParam("Id_Dispaccio_In", cartolinaDispaccio.IdDispaccioIn)
.AddParam("Code_Racc", cartolinaDispaccio.CodeRacc)
.AddParam("Data_Notifica", cartolinaDispaccio.DataNotifica)
.AddParam("Usr_Tracciatura", cartolinaDispaccio.UsrTracciatura)
.AddParam("CodeTipoConsegna", cartolinaDispaccio.CodiceTipoConsegna)
.AddParam("Identity", out IOutParam <int> Identity)
.AddParam("Data_Tracciatura", out IOutParam <string> Data_Tracciatura, 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.Id = Identity.Value;
result.Entita.DataTracciatura = Convert.ToDateTime(Data_Tracciatura.Value);
}
return(result);
}
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);
}
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);
}
public async Task <OutputStored <DateTime> > Execute(string userApertura, long idDispaccio)
{
var result = new OutputStored <DateTime>(DateTime.MinValue);
var STORED_APERTURA_DISPACCIO = "New_Dispaccio_In_Apertura";
await context.LoadStoredProc(STORED_APERTURA_DISPACCIO)
.AddParam("Usr_Apertura", userApertura)
.AddParam("Id", idDispaccio)
.AddParam("Data_Apertura", out IOutParam <string> Data_Apertura, new ParamExtra()
{
Size = 10
})
.ExecNonQueryAsync();
if (!string.IsNullOrEmpty(Data_Apertura.Value))
{
result.Entita = Convert.ToDateTime(Data_Apertura.Value);
}
else
{
result.Error_msg = new Parameter <string>(string.Format("Si è verificato un errore durante l'apertura del dispaccio {0}", idDispaccio));
}
return(result);
}
public async Task <IEnumerable <NewDettaglioDistinteStoricoDettImmagini> > Get(string codiceRaccomandata)
{
Task <List <NewDettaglioDistinteStoricoDettImmagini> > result = null;
var STORED = "new_dettaglio_distinte_storico_dett_immagini_ar";
await context.LoadStoredProc(STORED)
.AddParam("code_racc", codiceRaccomandata)
.ExecAsync(r => result = r.ToListAsync <NewDettaglioDistinteStoricoDettImmagini>());
return(await result);
}
public async Task <IEnumerable <NewCaricaQuery> > GetAll()
{
Task <List <NewCaricaQuery> > result = null;
var STORED_CARICA_QUERY = "sp_QUERY_MANAGER_caricaQuery";
await context.LoadStoredProc(STORED_CARICA_QUERY)
.ExecAsync(r => result = r.ToListAsync <NewCaricaQuery>());
return(await result);
}
public async Task <NewDammiQuery> Get(int ID_QUERY)
{
Task <List <NewDammiQuery> > result = null;
var STORED_DAMMI_QUERY = "sp_QUERY_MANAGER_dammiQuery";
await context.LoadStoredProc(STORED_DAMMI_QUERY)
.AddParam("ID_QUERY", ID_QUERY)
.ExecAsync(r => result = r.ToListAsync <NewDammiQuery>());
return(result.Result.FirstOrDefault());
}
public async Task <IEnumerable <NewStoricoCartelle.Elenco_Raccomandate_In_Distinta> > Get(string distinta)
{
Task <List <NewStoricoCartelle.Elenco_Raccomandate_In_Distinta> > result = null;
var STORED = "new_dettaglio_distinte_storico_cartelle_2";
await context.LoadStoredProc(STORED)
.AddParam("distinta", distinta)
.ExecAsync(r => result = r.ToListAsync <NewStoricoCartelle.Elenco_Raccomandate_In_Distinta>());
return(await result);
}
public async Task <IEnumerable <NewStoricoCartelle.Raccomandata> > GetAll()
{
Task <List <NewStoricoCartelle.Raccomandata> > result = null;
var STORED = "new_dettaglio_elenco_racc_storico_cartelle";
await context.LoadStoredProc(STORED)
.ExecAsync(r => result = r.ToListAsync <NewStoricoCartelle.Raccomandata>());
return(await result);
}
public async Task <IEnumerable <CodiciSmarriti> > Get(string dataOggi)
{
Task <List <CodiciSmarriti> > result = null;
var STORED_DAMMI_QUERY = "SP_controlla_esiti_scartati";
await context.LoadStoredProc(STORED_DAMMI_QUERY)
.AddParam("dataOggi", dataOggi)
.ExecAsync(r => result = r.ToListAsync <CodiciSmarriti>());
return(await result);
}
public async Task <IEnumerable <NewDispaccioInStored> > Execute(string userTracciatura)
{
Task <List <NewDispaccioInStored> > result = null;
const string STORED_GETALL_DISPACCI = "New_Dispaccio_In_All";
await context.LoadStoredProc(STORED_GETALL_DISPACCI)
.AddParam("Usr_Tracciatura", userTracciatura)
.ExecAsync(r => result = r.ToListAsync <NewDispaccioInStored>());
return(await result);
}
public async Task <NewStoricoCartelle.Dettaglio_Distinta> Get(string codiceDistinta)
{
Task <NewStoricoCartelle.Dettaglio_Distinta> result = null;
var STORED = "new_dettaglio_distinte_storico_cartelle_3";
await context.LoadStoredProc(STORED)
.AddParam("distinta", codiceDistinta)
.ExecAsync(r => result = r.FirstOrDefaultAsync <NewStoricoCartelle.Dettaglio_Distinta>());
return(await result);
}
public async Task <IEnumerable <NewStoricoCartelle.Elenco_Distinte> > Get(DateTime dalGiorno, DateTime alGiorno)
{
Task <List <NewStoricoCartelle.Elenco_Distinte> > result = null;
var STORED = "new_dettaglio_distinte_storico_cartelle";
await context.LoadStoredProc(STORED)
.AddParam("Data_Inizio", string.Format("{0:dd/MM/yyyy}", dalGiorno))
.AddParam("Data_Fine", string.Format("{0:dd/MM/yyyy}", alGiorno))
.ExecAsync(r => result = r.ToListAsync <NewStoricoCartelle.Elenco_Distinte>());
return(await result);
}
public async Task <IEnumerable <NewCartolineDispaccioInFromIdDispaccioStored> > Execute(long idDispaccio)
{
Task <List <NewCartolineDispaccioInFromIdDispaccioStored> > result = null;
const string STORED_NEW_CARTOLINE_DISPACCIO_IN_FROM_ID_DISPACCIO = "New_Cartoline_Dispaccio_In_From_Id_Dispaccio";
try
{
await context.LoadStoredProc(STORED_NEW_CARTOLINE_DISPACCIO_IN_FROM_ID_DISPACCIO)
.AddParam("IdDispaccioIn", idDispaccio)
.ExecAsync(r => result = r.ToListAsync <NewCartolineDispaccioInFromIdDispaccioStored>());
}
catch (Exception e)
{
}
return(await result);
}
public async Task <IEnumerable <NewTempStoricoCartelle> > Get()
{
Task <List <NewTempStoricoCartelle> > result = null;
var STORED = "SP_temp_storico_cartelle";
try
{
await context.LoadStoredProc(STORED)
.ExecAsync(r => result = r.ToListAsync <NewTempStoricoCartelle>());
}
catch (Exception ex)
{
return(null);
}
return(await result);
}
public async Task <IEnumerable <NewCountCodeRacc> > Get(string code_racc)
{
Task <List <NewCountCodeRacc> > result = null;
var STORED = "dbo.SP_count_code_racc_from_new_immagini_pmr";
try
{
await context.LoadStoredProc(STORED)
.AddParam("code_racc", code_racc)
.ExecAsync(r => result = r.ToListAsync <NewCountCodeRacc>());
}
catch (Exception ex)
{
return(null);
}
return(await result);
}
public async Task <OutputStored <NewCartolineDispaccioIn> > Execute(long codeRacc)
{
var result = new OutputStored <NewCartolineDispaccioIn>(new NewCartolineDispaccioIn());
result.Entita.CodeRacc = codeRacc.ToString();
const string STORED_NEW_CARTOLINE_DISPACCIO_IN_TRACCIATURA = "New_Cartoline_Dispaccio_In_Del_Tracciatura";
try
{
await context.LoadStoredProc(STORED_NEW_CARTOLINE_DISPACCIO_IN_TRACCIATURA)
.AddParam("Code_Racc", result.Entita.CodeRacc)
.AddParam("Error_Msg", out result.Error_msg, new ParamExtra()
{
Size = 255
})
.AddParam("Error_Number", out result.Error_Number)
.ExecNonQueryAsync();
}
catch (Exception e)
{
}
return(result);
}
