public IHttpActionResult EditarContrato(int contratoId, [FromBody] ContratoDto contrato)
{
try
{
if (contrato.ContratoId != contratoId)
{
return(Conflict());
}
var contratoEditado = _contratoProcesso.EditarContrato(contrato);
if (contratoEditado)
{
return(NoContent());
}
else
{
return(NotFound());
}
}
catch (RegraNegocioException e)
{
return(Content(HttpStatusCode.PreconditionFailed, e.Serializar()));
}
catch (Exception e)
{
return(InternalServerError(e));
}
}
public async Task <IActionResult> PutContrato(int id, ContratoDto contrato)
{
var contrato2 = new Contrato
{
Numerocontrato = contrato.Numerocontrato,
FuncionarioId = int.Parse(contrato.FuncionarioId)
};
if (id != contrato2.Id)
{
return(BadRequest());
}
_context.Entry(contrato2).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ContratoExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public SolicitadorDeManutencaoTeste()
{
_dto = new SolicitacaoDeManutencaoDto
{
SubsidiariaId = "XPTO-ABC",
SolicitanteId = 1,
NomeDoSolicitante = "Ricardo José",
TipoDeSolicitacaoDeManutencao = TipoDeSolicitacaoDeManutencao.Jardinagem.GetHashCode(),
Justificativa = "Grama Alta",
NumeroDoContrato = "2135",
InicioDesejadoParaManutencao = DateTime.Now.AddMonths(2)
};
_contratoDto = new ContratoDto
{
Numero = _dto.NumeroDoContrato,
NomeDaTerceirizada = "Grama SA",
GestorDoContrato = "Edivaldo Pereira",
CnpjDaTerceirizada = "00000000000000",
DataFinalDaVigencia = DateTime.Now.AddMonths(1)
};
_solicitacaoDeManutencaoRepositorio = Substitute.For <ISolicitacaoDeManutencaoRepositorio>();
var subsidiariaRepositorio = Substitute.For <ISubsidiariaRepositorio>();
_subsidiaria = FluentBuilder <Subsidiaria> .New().Build();
subsidiariaRepositorio.ObterPorId(_dto.SubsidiariaId).Returns(_subsidiaria);
_canceladorDeSolicitacoesDeManutencaoPendentes = Substitute.For <ICanceladorDeSolicitacoesDeManutencaoPendentes>();
_buscadorDeContrato = Substitute.For <IBuscadorDeContrato>();
_buscadorDeContrato.Buscar(_dto.NumeroDoContrato).Returns(_contratoDto);
_solicitador = new SolicitadorDeManutencao(_solicitacaoDeManutencaoRepositorio, subsidiariaRepositorio, _buscadorDeContrato, _canceladorDeSolicitacoesDeManutencaoPendentes);
}
public async Task <IActionResult> RegistrarContrato(ContratoDto contratoDto)
{
Contrato contrato = new Contrato();
await using var transaction = await _dataContext.Database.BeginTransactionAsync();
try
{
usuarioId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
valorPciId = User.FindFirst(ClaimTypes.Role).Value;
if (!string.IsNullOrEmpty(valorPciId))
{
pciId = int.Parse(valorPciId);
}
if (contratoDto != null)
{
var cdp = await _cdpRepo.ObtenerCDPPorCompromiso(contratoDto.Crp);
#region Mapear datos Contrato
contrato.NumeroContrato = contratoDto.NumeroContrato;
contrato.TipoContratoId = contratoDto.TipoContratoId;
contrato.Crp = contratoDto.Crp;
contrato.FechaRegistro = cdp.Fecha;
contrato.FechaExpedicionPoliza = contratoDto.FechaExpedicionPoliza;
contrato.FechaInicio = contratoDto.FechaInicio;
contrato.FechaFinal = contratoDto.FechaFinal;
contrato.EsPagoMensual = contratoDto.EsPagoMensual;
contrato.ValorPagoMensual = contratoDto.EsPagoMensual ? contratoDto.ValorPagoMensual : 0;
contrato.Supervisor1Id = contratoDto.Supervisor1Id;
contrato.Supervisor2Id = contratoDto.Supervisor2Id.HasValue ? contratoDto.Supervisor2Id.Value : null;
contrato.UsuarioIdRegistro = usuarioId;
contrato.PciId = pciId;
contrato.FechaInsercion = _generalInterface.ObtenerFechaHoraActual();
#endregion Mapear datos Contrato
//Registrar Parametro liquidación Contrato
_dataContext.Contrato.Add(contrato);
await _dataContext.SaveChangesAsync();
await transaction.CommitAsync();
return(Ok(contrato.ContratoId));
}
}
catch (Exception)
{
throw;
}
throw new Exception($"No se pudo registrar el tercero");
}
public static Contrato Converter(this ContratoDto dto)
{
return(dto == null ? null : new Contrato()
{
ContratoId = dto.ContratoId,
DataInicioVigencia = dto.DataInicioVigencia,
DataFimVigencia = dto.DataFimVigencia,
VolumeDisponivel = dto.VolumeDisponivel,
Ativo = dto.Ativo
});
}
public static Contrato CriarEntidade(this ContratoDto dto)
{
return(new Contrato()
{
ContratoId = dto.ContratoId,
VolumeDisponivel = dto.VolumeDisponivel,
DataInicioVigencia = dto.DataInicioVigencia,
DataFimVigencia = dto.DataFimVigencia,
Ativo = dto.Ativo
});
}
public async Task <ActionResult <Contrato> > PostContrato(ContratoDto contrato)
{
var contrato2 = new Contrato
{
Numerocontrato = contrato.Numerocontrato,
FuncionarioId = int.Parse(contrato.FuncionarioId)
};
_context.Contrato.Add(contrato2);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetContrato", new { id = contrato2.Id }, contrato2));
}
public ActionResult Save(ContratoDto model)
{
if (ModelState.IsValid)
{
var Contrato = new Contrato();
_Contrato.Save(model);
return(RedirectToAction("List"));
}
else
{
return(RedirectToAction("Create", model));
}
}
public IHttpActionResult InserirContrato([FromBody] ContratoDto contrato)
{
try
{
var contratoId = _contratoProcesso.InserirContrato(contrato);
return(Created(Request.RequestUri + contratoId.ToString(), contratoId));
}
catch (RegraNegocioException e)
{
return(Content(HttpStatusCode.PreconditionFailed, e.Serializar()));
}
catch (Exception e)
{
return(InternalServerError(e));
}
}
public IHttpActionResult InserirContrato([FromBody] ContratoDto contratoDto)
{
try
{
_contratoProcesso.InserirContrato(contratoDto);
return(Ok());
}
catch (ExcecaoRegraNegocio e)
{
return(BadRequest(e.Message));
}
catch (Exception e)
{
return(InternalServerError(e));
}
}
public void InserirContrato(ContratoDto contratoDto)
{
var contrato = contratoDto.CriarEntidade();
if (contrato.VolumeDisponivel < 1)
{
throw new ExcecaoRegraNegocio(ExcecaoRegraNegocio.VOLUME_INVALIDO);
}
if (contrato.DataFimVigencia < DateTime.Now)
{
throw new ExcecaoRegraNegocio(ExcecaoRegraNegocio.DATA_INVALIDA);
}
_contratoRepositorio.InserirContrato(contrato);
}
public int InserirContrato(ContratoDto contratoDto)
{
var contrato = contratoDto.Converter();
if (contrato.DataInicioVigencia.Date > DateTime.Now.Date)
{
throw new RegraNegocioException(TipoRegraNegocio.DataInicioVigenciaInvalida);
}
else if (contrato.DataFimVigencia < DateTime.Now.Date)
{
throw new RegraNegocioException(TipoRegraNegocio.DataFimVigenciaInvalida);
}
else if (contrato.VolumeDisponivel < 1)
{
throw new RegraNegocioException(TipoRegraNegocio.VolumeDisponivelInvalido);
}
return(_contratoRepositorio.InserirContrato(contrato));
}
public async Task <IActionResult> ActualizarContrato(ContratoDto contratoDto)
{
await using var transaction = await _dataContext.Database.BeginTransactionAsync();
try
{
var contratoBD = await _repo.ObtenerContratoBase(contratoDto.ContratoId);
#region Mapear datos Contrato
contratoBD.NumeroContrato = contratoDto.NumeroContrato;
contratoBD.TipoContratoId = contratoDto.TipoContratoId;
contratoBD.Crp = contratoDto.Crp;
contratoBD.FechaExpedicionPoliza = contratoDto.FechaExpedicionPoliza;
contratoBD.FechaInicio = contratoDto.FechaInicio;
contratoBD.FechaFinal = contratoDto.FechaFinal;
contratoBD.EsPagoMensual = contratoDto.EsPagoMensual;
contratoBD.ValorPagoMensual = contratoDto.EsPagoMensual ? contratoDto.ValorPagoMensual : 0;
contratoBD.Supervisor1Id = contratoDto.Supervisor1Id;
contratoBD.Supervisor2Id = contratoDto.Supervisor2Id;
contratoBD.UsuarioIdModificacion = usuarioId;
contratoBD.FechaModificacion = _generalInterface.ObtenerFechaHoraActual();
#endregion Mapear datos Contrato
await _dataContext.SaveChangesAsync();
await transaction.CommitAsync();
return(NoContent());
}
catch (Exception)
{
throw;
}
}
public bool EditarContrato(ContratoDto contratoDto)
{
var contrato = contratoDto.Converter();
if (contrato.DataInicioVigencia.Date > DateTime.Now.Date)
{
throw new RegraNegocioException(TipoRegraNegocio.DataInicioVigenciaInvalida);
}
else if (contrato.DataFimVigencia < DateTime.Now.Date)
{
throw new RegraNegocioException(TipoRegraNegocio.DataFimVigenciaInvalida);
}
else if (contrato.VolumeDisponivel < 1)
{
throw new RegraNegocioException(TipoRegraNegocio.VolumeDisponivelInvalido);
}
var contratoAtual = _contratoRepositorio.ObterContrato(contrato.ContratoId);
if (contratoAtual == null)
{
return(false);
}
var pedidos = _pedidoRepositorio.ObterPedidos(contrato.ContratoId);
var volumePedidosPendentes = pedidos.Where(p => !p.Atendido).Sum(p => p.Volume);
if (contrato.VolumeDisponivel < volumePedidosPendentes)
{
throw new RegraNegocioException(TipoRegraNegocio.VolumeDisponivelInvalidoEdicao);
}
_contratoRepositorio.EditarContrato(contrato);
return(true);
}
public async Task <IActionResult> POST(ContratoDto contratoDto)
{
if (ModelState.IsValid)
{
var contrato = new Contrato {
Id = contratoDto.Id,
Nombre = contratoDto.Nombre,
Tipo = contratoDto.Tipo,
AdminContratoId = contratoDto.AdminContrato,
EntidadId = contratoDto.Entidad,
ObjetoDeContrato = contratoDto.ObjetoDeContrato,
Numero = contratoDto.Numero,
TerminoDePago = contratoDto.TerminoDePago,
Cliente = contratoDto.Cliente,
Estado = Estado.Circulando
};
if (contratoDto.FechaDeRecepcion != null)
{
contrato.FechaDeRecepcion = contratoDto.FechaDeRecepcion;
}
else
{
contrato.FechaDeRecepcion = DateTime.Now;
}
if (contratoDto.FechaDeVenOferta != null)
{
contrato.FechaDeVenOferta = contratoDto.FechaDeVenOferta;
}
else
{
contrato.FechaDeVenOferta = DateTime.Now.AddDays(20);
}
context.Contratos.Add(contrato);
context.SaveChanges();
if (contratoDto.Montos != null)
{
foreach (var item in contratoDto.Montos)
{
var monto = new Monto {
Cantidad = item.Cantidad,
Moneda = item.Moneda,
ContratoId = contrato.Id
};
context.Montos.Add(monto);
}
context.SaveChanges();
}
foreach (var item in contratoDto.FormasDePago)
{
var contratoId_FormaPagoId = new ContratoId_FormaPagoId {
ContratoId = contrato.Id,
FormaDePago = item
};
context.ContratoId_FormaPagoId.Add(contratoId_FormaPagoId);
context.SaveChanges();
}
// Subir el Fichero del Contrato
// var uploads = Path.Combine (_hostingEnvironment.WebRootPath, "uploadContratos");
// if (file != null) {
// var filePath = Path.Combine (uploads, file.FileName);
// using (var fileStream = new FileStream (filePath, FileMode.Create)) {
// await file.CopyToAsync (fileStream);
// }
// contrato.FilePath=filePath;
// }
// Agregar Departamentos de los Dictaminadores
if (contratoDto.Departamentos != null)
{
foreach (var item in contratoDto.Departamentos)
{
var contratoId_DepartamentoId = new ContratoId_DepartamentoId {
ContratoId = contrato.Id,
DepartamentoId = item
};
context.ContratoId_DepartamentoId.Add(contratoId_DepartamentoId);
context.SaveChanges();
}
}
//Agregar Especialistas externos como Dictaminador/es del contrato
if (contratoDto.EspecialistasExternos != null)
{
foreach (var item in contratoDto.EspecialistasExternos)
{
var espExternoId_ContratoId = new EspExternoId_ContratoId {
ContratoId = contrato.Id,
EspecialistaExternoId = item
};
context.EspExternoId_ContratoId.Add(espExternoId_ContratoId);
context.SaveChanges();
}
}
var HistoricoEstadoContrato = new HistoricoEstadoContrato {
ContratoId = contrato.Id,
Estado = Estado.Circulando,
Fecha = DateTime.Now,
Usuario = contratoDto.Usuario,
};
context.Add(HistoricoEstadoContrato);
context.SaveChanges();
return(new CreatedAtRouteResult("GetContrato", new { id = contrato.Id }));
}
return(BadRequest(ModelState));
}
public async Task Delete([FromBody] ContratoDto contrato)
{
await _contratoService.DeleteAsync(contrato);
}
public async Task Put([FromBody] ContratoDto contrato)
{
await _contratoService.UpdateAsync(contrato);
}
/// <summary>
/// Salva um objeto<T>
/// </summary>
public virtual void Save(ContratoDto model)
{
_unitOfWork.GetRepository <ContratoDto>().Add(model);
}
/// <summary>
/// Salva e retorna o objeto<T> salvo
/// </summary>
public virtual ContratoDto SaveGetItem(ContratoDto model)
{
_unitOfWork.GetRepository <ContratoDto>().Add(model);
return(model);
}
/// <summary>
/// Salva a edição de um objeto<T>
/// </summary>
public virtual void Update(ContratoDto model)
{
_unitOfWork.GetRepository <ContratoDto>().Update(model);
}
