public async Task <IHttpActionResult> NuovaAtto(AttiFormUpdateModel attoModel)
{
try
{
if (string.IsNullOrEmpty(attoModel.NAtto))
{
return(BadRequest("Imposta il numero di atto"));
}
if (string.IsNullOrEmpty(attoModel.Oggetto))
{
return(BadRequest("Imposta l'oggetto"));
}
if (attoModel.Data_chiusura <= attoModel.Data_apertura)
{
return(BadRequest("Impossibile settare una data di chiusura inferiore alla data di apertura"));
}
var session = await GetSession();
var persona = await _logicPersone.GetPersona(session);
var atto = Mapper.Map <AttiFormUpdateModel, ATTI>(attoModel);
var nuovoAtto = await _logic.NuovoAtto(atto, persona);
return(Created(new Uri(Request.RequestUri.ToString()), Mapper.Map <ATTI, AttiDto>(nuovoAtto)));
}
catch (Exception e)
{
Log.Error("NuovaAtto", e);
return(ErrorHandler(e));
}
}
public async Task <IHttpActionResult> ModificaAtto(AttiFormUpdateModel attoModel)
{
try
{
var attoInDb = await _logic.GetAtto(attoModel.UIDAtto);
if (attoInDb == null)
{
return(NotFound());
}
if (attoModel.Data_chiusura <= attoModel.Data_apertura)
{
return(BadRequest("Impossibile settare una data di chiusura inferiore alla data di apertura"));
}
var session = await GetSession();
var persona = await _logicPersone.GetPersona(session);
await _logic.SalvaAtto(attoInDb, attoModel, persona);
return(Ok(Mapper.Map <ATTI, AttiDto>(attoInDb)));
}
catch (Exception e)
{
Log.Error("ModificaAtto", e);
return(ErrorHandler(e));
}
}
public async Task <ATTI> SalvaAtto(ATTI attoInDb, AttiFormUpdateModel attoModel, PersonaDto currentUser)
{
try
{
attoInDb.UIDPersonaModifica = currentUser.UID_persona;
attoInDb.DataModifica = DateTime.Now;
Mapper.Map(attoModel, attoInDb);
if (!attoModel.Data_chiusura.HasValue)
{
attoInDb.Data_chiusura = null;
}
await _unitOfWork.CompleteAsync();
if (attoModel.DocAtto_Stream != null)
{
var path = ByteArrayToFile(attoModel.DocAtto_Stream);
attoInDb.Path_Testo_Atto = Path.Combine(AppSettingsConfiguration.PrefissoCompatibilitaDocumenti, path);
await _unitOfWork.CompleteAsync();
}
return(attoInDb);
}
catch (Exception e)
{
Log.Error("Salva Atto", e);
throw e;
}
}
public async Task <ATTI> NuovoAtto(AttiFormUpdateModel attoModel, PersonaDto currentUser)
{
try
{
var atto = Mapper.Map <AttiFormUpdateModel, ATTI>(attoModel);
atto.UIDAtto = Guid.NewGuid();
atto.Eliminato = false;
atto.UIDPersonaCreazione = currentUser.UID_persona;
atto.DataCreazione = DateTime.Now;
atto.OrdinePresentazione = false;
atto.OrdineVotazione = false;
atto.Priorita = await _unitOfWork.Atti.PrioritaAtto(atto.UIDSeduta.Value);
_unitOfWork.Atti.Add(atto);
await _unitOfWork.CompleteAsync();
if (attoModel.DocAtto_Stream != null)
{
var path = ByteArrayToFile(attoModel.DocAtto_Stream);
atto.Path_Testo_Atto = path;
await _unitOfWork.CompleteAsync();
}
return(atto);
}
catch (Exception e)
{
Log.Error("Nuovo Atto", e);
throw e;
}
}
public async Task <AttiDto> Modifica(AttiFormUpdateModel atto)
{
try
{
var requestUrl = $"{apiUrl}/atti/modifica";
if (atto.DocAtto != null)
{
using var memoryStream = new MemoryStream();
await atto.DocAtto.InputStream.CopyToAsync(memoryStream);
atto.DocAtto_Stream = memoryStream.ToArray();
}
var body = JsonConvert.SerializeObject(atto);
var result = JsonConvert.DeserializeObject <AttiDto>(await Put(requestUrl, body, _token));
return(result);
}
catch (UnauthorizedAccessException ex)
{
Log.Error("ModificaAtto", ex);
throw ex;
}
catch (Exception ex)
{
Log.Error("ModificaAtto", ex);
throw ex;
}
}
public async Task <ActionResult> SalvaAtto(AttiFormUpdateModel atto)
{
try
{
if (atto.DocAtto != null)
{
if (atto.DocAtto.ContentType != "application/pdf")
{
throw new InvalidOperationException("I file devono essere in formato PDF");
}
}
AttiDto attoSalvato = null;
if (atto.UIDAtto == Guid.Empty)
{
attoSalvato = await ApiGateway.SalvaAtto(atto);
}
else
{
attoSalvato = await ApiGateway.ModificaAtto(atto);
}
return(Json(new ClientJsonResponse <AttiDto>
{
entity = attoSalvato,
url = Url.Action("RiepilogoAtti", "Atti", new
{
id = atto.UIDSeduta
})
}, JsonRequestBehavior.AllowGet));
}
catch (Exception e)
{
Console.WriteLine(e);
return(Json(new ErrorResponse {
message = e.Message
}, JsonRequestBehavior.AllowGet));
}
}
public async Task <ATTI> SalvaAtto(ATTI attoInDb, AttiFormUpdateModel attoModel, PersonaDto currentUser)
{
try
{
attoInDb.UIDPersonaModifica = currentUser.UID_persona;
attoInDb.DataModifica = DateTime.Now;
Mapper.Map(attoModel, attoInDb);
await _unitOfWork.CompleteAsync();
if (attoModel.DocAtto_Stream != null)
{
var path = ByteArrayToFile(attoModel.DocAtto_Stream, DocTypeEnum.ATTO);
attoInDb.Path_Testo_Atto = path;
await _unitOfWork.CompleteAsync();
}
return(attoInDb);
}
catch (Exception e)
{
Log.Error("Salva Atto", e);
throw e;
}
}
