public ContratoDeRemuneracaoBD ConverterDe(IContratoDeRemuneracao contrato)
{
ContratoDeRemuneracaoBD contratoConvertido = new ContratoDeRemuneracaoBD(TipoDeContratoDeRemuneracaoBancoDeDados.Padrao);
if (!(contrato is ContratoDeRemuneracao))
{
throw new ArgumentException();
}
var contratoPadrao = contrato as ContratoDeRemuneracao;
contratoConvertido.Id = contrato.Id;
contratoConvertido.Nome = contrato.NomePrincipal;
contratoConvertido.Deleted = contrato.Deleted;
if (contrato.Favorecimento != null)
{
contratoConvertido.Favorecimento = TipoDeFavorecimentoBD.Get(contrato.Favorecimento.Tipo.Id).ConverteDe(contrato.Favorecimento, contrato.Id, Definicoes.ID_VINCULO_FAVORECIMENTO_CONTRATO);
}
if (contrato.Regras != null)
{
contratoConvertido.Regras = contrato.Regras.Select(reg => TipoDeRegraBD.Get(reg.Tipo.Id).ConverteDe(reg));
}
contratoConvertido.Vigencia = contratoPadrao.Vigencia;
return(contratoConvertido);
}
public async Task <IActionResult> PutAsync([FromBody] JObject ContratoJson, int id)
{
IContratoDeRemuneracao Contrato = ConverteJsonParaContrato(ContratoJson.ToString());
try
{
await _gerenciadorDeRequisicoesDeContrato.AtualizarContratoAsync(Contrato, id);
}
catch (UserException e)
{
EncapsuladorDeResposta <bool> encapsuladorDeResposta = new EncapsuladorDeResposta <bool>(false);
encapsuladorDeResposta.Success = false;
encapsuladorDeResposta.ExceptionMessage = e.Message;
return(Ok(encapsuladorDeResposta));
}
catch (Exception ex)
{
BadRequest(ex);
}
EncapsuladorDeResposta <bool> enc = new EncapsuladorDeResposta <bool>(true);
enc.Success = true;
return(Ok(enc));
}
public void Deve_Carregar_Lista_De_Regras_Para_Contratos_Retornados()
{
//Arrange
Mock <IContratoDeRemuneracao> contrato1 = ContratoMock(1, 2, 3);
IEnumerable <IContratoDeRemuneracao> contratos = new List <IContratoDeRemuneracao>()
{
contrato1.Object
};
Mock <IRepositorioDeContratoDeRemuneracao> contratoRepositorio = new Mock <IRepositorioDeContratoDeRemuneracao>();
contratoRepositorio.Setup(cont => cont.ListarVigentesEm(It.IsAny <Competencia[]>())).ReturnsAsync(contratos);
Mock <IRegraDeRemuneracao> regra1 = new Mock <IRegraDeRemuneracao>();
Mock <IRegraDeRemuneracao> regra2 = new Mock <IRegraDeRemuneracao>();
Mock <IRegraDeRemuneracao> regra3 = new Mock <IRegraDeRemuneracao>();
Mock <IRepositorioDeRegras> regraRepositorio = new Mock <IRepositorioDeRegras>();
//regraRepositorio.Setup(reg => reg.ObterAsync(new int[] { 1 })).ReturnsAsync(new IRegraDeRemuneracao[] { regra1.Object });
//regraRepositorio.Setup(reg => reg.ObterAsync(new int[] { 2 })).ReturnsAsync(new IRegraDeRemuneracao[] { regra2.Object });
//regraRepositorio.Setup(reg => reg.ObterAsync(new int[] { 3 })).ReturnsAsync(new IRegraDeRemuneracao[] { regra3.Object });
DescobridorDeContratos descobridor = null;// new DescobridorDeContratos(contratoRepositorio.Object, regraRepositorio.Object);
//Act
var task = descobridor.DescobrirContratosDeRemuneracaoAsync(new Competencia[] { new Mock <Competencia>().Object });
task.Wait();
var result = task.Result;
//Assert
IContratoDeRemuneracao contrato = result.ToArray()[0];
Assert.AreEqual(regra1.Object, contrato.Regras.ToArray()[0]);
Assert.AreEqual(regra2.Object, contrato.Regras.ToArray()[1]);
Assert.AreEqual(regra3.Object, contrato.Regras.ToArray()[2]);
}
private async Task VerificaSeRegraEstaNaVigenciaDoContrato(RegraDeRemuneracaoBD regra)
{
IContratoDeRemuneracao contratoDaRegra = (await _repositorioDeContratos.ObterAsync(new int[] { regra.IdContrato })).First();
PeriodoSimples vigenciaDoContrato = new PeriodoSimples(contratoDaRegra.Vigencia.Inicio.Date, contratoDaRegra.Vigencia.Fim.Date.AddDays(1));
PeriodoSimples vigenciaDaRegra = new PeriodoSimples(regra.Vigencia.Inicio.Date, regra.Vigencia.Fim.Date);
if (!vigenciaDoContrato.Contem(vigenciaDaRegra))
{
throw new UserException("A vigência da regra deve estar dentro da vigência do contrato");
}
}
public async Task <int> InserirAsync(IContratoDeRemuneracao modelo)
{
var tipo = TipoDeContratoDeRemuneracaoBancoDeDados.Parse(modelo.Tipo.Name);
ContratoDeRemuneracaoBD contratoBD = tipo.ConverteDe(modelo);
using (var context = _fabricaDeContextos.CriaContextoDe <RemuneracaoContext>(TipoDeConexao.Remuneracao))
{
EntityEntry <ContratoDeRemuneracaoBD> contratoInserido = await context.AddAsync(contratoBD);
await context.SaveChangesAsync();
return(contratoInserido.Entity.Id);
}
}
private async Task VerificaSeJaExisteRegraComMesmoTipoNoContrato(RegraDeRemuneracaoBD regra)
{
IContratoDeRemuneracao contratoDaRegra = (await _repositorioDeContratos.ObterAsync(new int[] { regra.IdContrato })).First();
using (var context = _fabricaDeContextos.CriaContextoDe <RemuneracaoContext>(TipoDeConexao.Remuneracao))
{
var existeRegra = await context.Regras.Where(r => !r.Deleted && r.IdContrato == regra.IdContrato && r.Tipo == regra.Tipo && r.Vigencia.IntersectaIntervaloFechado(regra.Vigencia) && r.Id != regra.Id).ToListAsync();
if (existeRegra.Count() > 0)
{
throw new UserException("Não foi possível inserir esta regra. Este contrato já possui uma regra do mesmo tipo nesta vigência, tente alterar a vigência da regra.");
}
}
}
public async Task <int> UpdateAsync(IContratoDeRemuneracao modelo, int id)
{
var tipo = TipoDeContratoDeRemuneracaoBancoDeDados.Parse(modelo.Tipo.Name);
ContratoDeRemuneracaoBD contratoBD = tipo.ConverteDe(modelo);
contratoBD.Id = id;
using (var context = _fabricaDeContextos.CriaContextoDe <RemuneracaoContext>(TipoDeConexao.Remuneracao))
{
context.Contratos.Update(contratoBD);
await context.SaveChangesAsync();
return(contratoBD.Id);
}
}
public async Task VerificaSeExisteRegraForaDaNovaVigenciaDoContrato(IContratoDeRemuneracao contrato, int id)
{
IEnumerable <ParametrosDeRegraDeRemuneracao> regras = await ListaRegras(id);
PeriodoSimples vigenciaDoContrato = new PeriodoSimples(contrato.Vigencia.Inicio.Date, contrato.Vigencia.Fim.Date.AddDays(1));
foreach (ParametrosDeRegraDeRemuneracao regra in regras)
{
PeriodoSimples vigenciaDaRegra = new PeriodoSimples(regra.Vigencia.Inicio.Date, regra.Vigencia.Fim.Date);
if (!vigenciaDoContrato.Contem(vigenciaDaRegra))
{
throw new UserException("Existem regras com vigência fora da nova vigência do contrato, favor alterá-las antes de alterar o contrato");
}
}
}
public async Task <IActionResult> GetObtemAsync(int id)
{
//context = await ConfiguraGerenciador(context, _gerenciadorDeRequisicoesDeContrato);
IContratoDeRemuneracao Contrato = null;
try
{
Contrato = await _gerenciadorDeRequisicoesDeContrato.RequisicaoObtemContratoAsync(id);
}
catch (Exception ex)
{
return(BadRequest(ex));
}
return(Ok(Contrato));
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var jsonObject = JObject.Load(reader);
var mee = nameof(IContratoDeRemuneracao.Tipo);
var bii = nameof(IContratoDeRemuneracao.Vigencia);
var jobjTipo = jsonObject[mee];
var jobjVigencia = jsonObject[nameof(IContratoDeRemuneracao.Vigencia)];
string idTipo = jobjTipo.Value <string>();
PeriodoSimples vigencia = (PeriodoSimples)serializer.ContractResolver.ResolveContract(typeof(PeriodoSimples)).Converter.ReadJson(jobjVigencia.CreateReader(), typeof(PeriodoSimples), null, serializer);
IContratoDeRemuneracao contrato = TipoDeContrato.Get <TipoDeContrato>(idTipo).CriarContrato(vigencia);
serializer.Populate(jsonObject.CreateReader(), contrato);
return(contrato);
}
private static Task <IEnumerable <IContratoDeRemuneracao> > ConverteContratosDoBDParaDominioAsync(ContratoDeRemuneracaoBD[] contratosBD)
{
ConcurrentQueue <IContratoDeRemuneracao> queueContratos = new ConcurrentQueue <IContratoDeRemuneracao>();
var task = Task.Factory.StartNew <IEnumerable <IContratoDeRemuneracao> >(() =>
{
Parallel.ForEach(contratosBD, cont =>
{
IContratoDeRemuneracao contrato = cont.ConvertePara();
queueContratos.Enqueue(contrato);
});
return(queueContratos);
});
return(task);
}
public async Task <IActionResult> PostAsync([FromBody] JObject ContratoJson)
{
//context = await ConfiguraGerenciador(context, _gerenciadorDeRequisicoesDeContrato);
int id = 0;
IContratoDeRemuneracao Contrato = ConverteJsonParaContrato(ContratoJson.ToString());
try
{
id = await _gerenciadorDeRequisicoesDeContrato.SalvaContratoAsync(Contrato);
}
catch (Exception ex)
{
BadRequest(ex);
}
return(Ok(id));
}
