public async Task <T> AddAsync(T entity)
{
_dbContext.Set <T>().Add(entity);
await _dbContext.SaveChangesAsync();
return(entity);
}
public async Task CreateAsync(Vehicle vehicleToAdd)
{
Stopwatch timespan = Stopwatch.StartNew();
SiccoAppConfiguration.SuspendExecutionStrategy = true;
DbContextTransaction tran = db.Database.BeginTransaction();
try
{
db.Vehicles.Add(vehicleToAdd);
//await db.SaveChangesAsync();
//Asignacion automatica del vehiculo al primer contrato que encuentre del Contratista (MAL, solo para pruebas)
//db.VehiclesContracts.Add(CreateVehicleContract(vehicleToAdd));
await db.SaveChangesAsync();
tran.Commit();
timespan.Stop();
log.TraceApi("SQL Database", "VehicleRepository.CreateAsync", timespan.Elapsed, "vehicleToAdd={0}", vehicleToAdd);
}
catch (Exception e)
{
tran.Rollback();
log.Error(e, "Error in VehicleRepository.CreateAsync(employeeToAdd={0})", vehicleToAdd);
throw;
}
SiccoAppConfiguration.SuspendExecutionStrategy = false;
}
/// <summary>
/// Cuando una Presetacion la toma un Auditor para su revision
/// </summary>
/// <param name="presentation"></param>
/// <returns></returns>
#warning "Falta tomar el Id del Usuario logueado"
public async Task TakeToAudit(Presentation presentation)
{
Stopwatch timespan = Stopwatch.StartNew();
SiccoAppConfiguration.SuspendExecutionStrategy = true;
DbContextTransaction tran = db.Database.BeginTransaction();
try
{
if (presentation.PresentationStatus != PresentationStatus.Pending)
{
throw new Exception("No se puede tomar Presentaciones que no estan PENDIENTES");
}
//actualizacion de Presentation
presentation.TakenDate = DateTime.UtcNow;
//presentation.TakenFor = 999;
presentation.PresentationStatus = PresentationStatus.Processing;
//actualizacion de Requerimientos
var requirement = await db.Requirements.FindAsync(presentation.RequirementID);
requirement.RequirementStatus = RequirementStatus.Processing;
//creacion de el historico de accionesde Presentation
PresentationAction presentationAction = new PresentationAction
{
PresentationID = presentation.PresentationID,
PresentationDate = DateTime.UtcNow,
ActionForID = presentation.TakenForID,
PresentationActionType = PresentationActionType.Taken
};
db.PresentationActions.Add(presentationAction);
db.Entry(presentation).State = EntityState.Modified;
await db.SaveChangesAsync();
tran.Commit();
timespan.Stop();
log.TraceApi("SQL Database", "PresentationRepository.TakeToAudit", timespan.Elapsed, "presentation={0}", presentation);
}
catch (Exception e)
{
tran.Rollback();
log.Error(e, "Error in PresentationRepository.TakeToAudit(presentation={0})", presentation);
throw;
}
SiccoAppConfiguration.SuspendExecutionStrategy = false;
}
public async Task CreateAsync(CustomerAuditor customerAuditorToAdd)
{
Stopwatch timespan = Stopwatch.StartNew();
try
{
db.CustomerAuditors.Add(customerAuditorToAdd);
await db.SaveChangesAsync();
//Seteamos el Rol
SetRole(customerAuditorToAdd.UserId);
timespan.Stop();
log.TraceApi("SQL Database", "CustomerAuditorRespository.CreateAsync", timespan.Elapsed, "customerAuditorToAdd={0}", customerAuditorToAdd);
}
catch (DbEntityValidationException e)
{
foreach (var eve in e.EntityValidationErrors)
{
//Console.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:", eve.Entry.Entity.GetType().Name, eve.Entry.State);
log.Error(e, "Entity of type \"{0}\" in state \"{1}\" has the following validation errors:", eve.Entry.Entity.GetType().Name, eve.Entry.State);
foreach (var ve in eve.ValidationErrors)
{
//Console.WriteLine("- Property: \"{0}\", Error: \"{1}\"", ve.PropertyName, ve.ErrorMessage);
log.Error(e, "- Property: \"{0}\", Error: \"{1}\"", ve.PropertyName, ve.ErrorMessage);
}
}
throw;
}
catch (Exception e)
{
log.Error(e, "Error in CustomerAuditorRespository.CreateAsync(customerAuditorToAdd={0})", customerAuditorToAdd);
throw;
}
}
public async Task CreateAsync(DocumentationBusinessType documentToAdd)
{
Stopwatch timespan = Stopwatch.StartNew();
try
{
db.DocumentationBusinessTypes.Add(documentToAdd);
await db.SaveChangesAsync();
timespan.Stop();
log.TraceApi("SQL Database", "DocumentationBusinessTypeRepository.CreateAsync", timespan.Elapsed, "documentToAdd={0}", documentToAdd);
}
catch (Exception e)
{
log.Error(e, "Error in DocumentationBusinessTypeRepository.CreateAsync(documentToAdd={0})", documentToAdd);
throw;
}
}
public async Task CreateAsync(BusinessTypeTemplate businessTypeTemplateToAdd)
{
Stopwatch timespan = Stopwatch.StartNew();
try
{
db.BusinessTypeTemplates.Add(businessTypeTemplateToAdd);
await db.SaveChangesAsync();
timespan.Stop();
log.TraceApi("SQL Database", "BusinessTypeTemplateRepository.CreateAsync", timespan.Elapsed, "businessTypeTemplateToAdd={0}", businessTypeTemplateToAdd);
}
catch (Exception e)
{
log.Error(e, "Error in BusinessTypeTemplateRepository.CreateAsync(businessTypeTemplateToAdd={0})", businessTypeTemplateToAdd);
throw;
}
}
public async Task CreateAsync(EmailAccount emailAccountToAdd)
{
Stopwatch timespan = Stopwatch.StartNew();
try
{
db.EmailAccounts.Add(emailAccountToAdd);
await db.SaveChangesAsync();
timespan.Stop();
log.TraceApi("SQL Database", "EmailAccountRepository.CreateAsync", timespan.Elapsed, "emailAccountToAdd={0}", emailAccountToAdd);
}
catch (Exception e)
{
log.Error(e, "Error in EmailAccountRepository.CreateAsync(emailAccountToAdd={0})", emailAccountToAdd);
throw;
}
}
public async Task UpdateAsync(Contract contractToSave)
{
Stopwatch timespan = Stopwatch.StartNew();
try
{
db.Entry(contractToSave).State = EntityState.Modified;
await db.SaveChangesAsync();
timespan.Stop();
log.TraceApi("SQL Database", "ContractRepository.UpdateAsync", timespan.Elapsed, "contractToSave={0}", contractToSave);
}
catch (Exception e)
{
log.Error(e, "Error in ContractRepository.UpdateAsync(vehicleToSave={0})", contractToSave);
throw;
}
}
public async Task CreateAsync(Customer customerToAdd)
{
Stopwatch timespan = Stopwatch.StartNew();
try
{
db.Customers.Add(customerToAdd);
await db.SaveChangesAsync();
await GenerateDocumentationMatrix(customerToAdd.CustomerID, true);
timespan.Stop();
log.TraceApi("SQL Database", "CustomerRepository.CreateAsync", timespan.Elapsed, "customerToAdd={0}", customerToAdd);
}
catch (Exception e)
{
log.Error(e, "Error in CustomerRepository.CreateAsync(customerToAdd={0})", customerToAdd);
throw;
}
}
public async Task CreateAsync(Requirement requirementToAdd)
{
Stopwatch timespan = Stopwatch.StartNew();
try
{
db.Requirements.Add(requirementToAdd);
await db.SaveChangesAsync();
timespan.Stop();
log.TraceApi("SQL Database", "RequirementRepository.CreateAsync", timespan.Elapsed, "requirementToAdd={0}", requirementToAdd);
}
catch (Exception e)
{
log.Error(e, "Error in RequirementRepository.CreateAsync(requirementToAdd={0})", requirementToAdd);
throw;
}
SiccoAppConfiguration.SuspendExecutionStrategy = false;
}
//https://msdn.microsoft.com/en-us/data/dn307226
public async Task CreateAsync(Contractor contractorToAdd)
{
Stopwatch timespan = Stopwatch.StartNew();
//Se suspende momentaneamente la estrategia de Azure (reintentos), porque la misma no
//soporta manejo de transacciones por parte del usuario
SiccoAppConfiguration.SuspendExecutionStrategy = true;
DbContextTransaction tran = db.Database.BeginTransaction();
try
{
db.Contractors.Add(contractorToAdd);
//await db.SaveChangesAsync();
var contract = CreateContract(contractorToAdd);
db.Contracts.Add(contract);
await db.SaveChangesAsync();
tran.Commit();
await GenerateContractorRequirements(contractorToAdd.ContractorID, contract.ContractID);
timespan.Stop();
log.TraceApi("SQL Database", "ContractorRepository.CreateAsync", timespan.Elapsed, "customerToAdd={0}", contractorToAdd);
}
catch (Exception e)
{
tran.Rollback();
log.Error(e, "Error in ContractorRepository.CreateAsync(contractorToAdd={0})", contractorToAdd);
throw;
}
SiccoAppConfiguration.SuspendExecutionStrategy = false;
}