public void Escrever_arquivo_de_saida()
{
var arquivoService = new ArquivoService();
var rotaService = new RotaService();
var queue = arquivoService.LerArquivoDeEntrada("entrada_rotas_teste.txt");
var veiculos = new List <Veiculo>()
{
new Veiculo(1, 7),
new Veiculo(2, 8),
new Veiculo(3, 10),
};
var rotas = rotaService.ObterRotas(queue, veiculos);
var linhas = rotaService.EscreverRelatorio(arquivoService, "saida_teste.txt", rotas).ToArray();
Assert.IsNotNull(linhas);
Assert.AreEqual(linhas[0], "3");
Assert.AreEqual(linhas[1], "1 19.57");
Assert.AreEqual(linhas[2], "2 73.75");
Assert.AreEqual(linhas[3], "3 20.70");
Assert.AreEqual(linhas[4], "");
Assert.AreEqual(linhas[5], "1 9.14");
Assert.AreEqual(linhas[6], "2 14.87");
Assert.AreEqual(linhas[7], "3 22.70");
Assert.AreEqual(linhas[8], "");
Assert.AreEqual(linhas[9], "1 8.00");
Assert.AreEqual(linhas[10], "2 10.87");
Assert.AreEqual(linhas[11], "3 29.00");
Assert.AreEqual(linhas[12], "");
}
public void Obter_lista_de_trechos()
{
var arquivoService = new ArquivoService();
var rotaService = new RotaService();
var queue = arquivoService.LerArquivoDeEntrada("entrada_trechos_teste.txt");
var veiculo = new Veiculo(1, 7);
var roteiro = new Roteiro(veiculo);
var trechos = rotaService.ObterTrechos(queue, roteiro).ToArray();
Assert.AreEqual(trechos.Count(), 8);
Assert.AreEqual(trechos[0].Cidade, "119");
Assert.AreEqual(trechos[0].Quilometragem, 47);
Assert.AreEqual(trechos[1].Cidade, "8");
Assert.AreEqual(trechos[1].Quilometragem, 230);
Assert.AreEqual(trechos[2].Cidade, "107");
Assert.AreEqual(trechos[2].Quilometragem, 48);
Assert.AreEqual(trechos[3].Cidade, "10");
Assert.AreEqual(trechos[3].Quilometragem, 65);
Assert.AreEqual(trechos[4].Cidade, "9");
Assert.AreEqual(trechos[4].Quilometragem, 197);
Assert.AreEqual(trechos[5].Cidade, "35");
Assert.AreEqual(trechos[5].Quilometragem, 236);
Assert.AreEqual(trechos[6].Cidade, "129");
Assert.AreEqual(trechos[6].Quilometragem, 142);
Assert.AreEqual(trechos[7].Cidade, "0");
Assert.AreEqual(trechos[7].Quilometragem, 71);
}
static void Main(string[] args)
{
string json = ArquivoService.LerArquivo("input.json");
List <UsoElevador> usoElevadors = ArquivoService.ConverterArquivo(json);
elevadorService = new ElevadorService(usoElevadors);
List <int> andaresMenosUtilizados = elevadorService.andarMenosUtilizado();
List <char> elevadoreMaisFrequentados = elevadorService.elevadorMaisFrequentado();
List <char> elevadoreMenosFrequentados = elevadorService.elevadorMenosFrequentado();
float percentualDeUsoElevadorA = elevadorService.percentualDeUsoElevadorA();
float percentualDeUsoElevadorB = elevadorService.percentualDeUsoElevadorB();
float percentualDeUsoElevadorC = elevadorService.percentualDeUsoElevadorC();
float percentualDeUsoElevadorD = elevadorService.percentualDeUsoElevadorD();
float percentualDeUsoElevadorE = elevadorService.percentualDeUsoElevadorE();
List <char> periodoMaiorFluxoElevadorMaisFrequentado = elevadorService.periodoMaiorFluxoElevadorMaisFrequentado();
List <char> periodoMaiorUtilizacaoConjuntoElevadores = elevadorService.periodoMaiorUtilizacaoConjuntoElevadores();
List <char> periodoMenorFluxoElevadorMenosFrequentado = elevadorService.periodoMenorFluxoElevadorMenosFrequentado();
ImprimirResultado("andares menos utilizados:", andaresMenosUtilizados);
ImprimirResultado("elevadores mais frequentados:", elevadoreMaisFrequentados);
ImprimirResultado("elevadores menos frequentados:", elevadoreMenosFrequentados);
ImprimirResultado("percentual de uso elevador A:", percentualDeUsoElevadorA);
ImprimirResultado("percentual de uso elevador B:", percentualDeUsoElevadorB);
ImprimirResultado("percentual de uso elevador C:", percentualDeUsoElevadorC);
ImprimirResultado("percentual de uso elevador D:", percentualDeUsoElevadorD);
ImprimirResultado("percentual de uso elevador E:", percentualDeUsoElevadorE);
ImprimirResultado("periodo maior fluxo elevador mais Frequentado:", periodoMaiorFluxoElevadorMaisFrequentado);
ImprimirResultado("periodo maior utilizacao conjunto elevadores:", periodoMaiorUtilizacaoConjuntoElevadores);
ImprimirResultado("periodo menor fluxo elevador menos frequentado:", periodoMenorFluxoElevadorMenosFrequentado);
}
static async Task Main(string[] args)
{
ArquivoService service = new ArquivoService();
string fileName = string.Empty;
string layoutKey = string.Empty;
if (args != null && args.Length == 1)
{
Console.WriteLine("Escolha o layout: \n1 - Claro\n2 - OI\n3 - IPCORP\n4 - TalkTelecom\n5- TalkBot");
layoutKey = Console.ReadKey().KeyChar.ToString();
}
if (args != null && args.Length > 1)
{
layoutKey = args[1];
}
Layout layout = Layout.Undefined;
switch (layoutKey)
{
case "1":
layout = Layout.Claro;
break;
case "2":
layout = Layout.OI;
break;
case "3":
layout = Layout.IPCORP;
break;
case "4":
layout = Layout.TALK;
break;
case "5":
layout = Layout.TablkBot;
break;
default:
Console.Write("Layout inválido!");
break;
}
bool showDetail = true;
if (args != null && args.Length > 0)
{
fileName = args[0];
}
if (layout != Layout.Undefined)
{
await service.ReadFile(fileName, showDetail, layout);
}
}
public void Ler_arquivo_de_entrada()
{
var arquivoService = new ArquivoService();
var queue = arquivoService.LerArquivoDeEntrada("entrada_veiculos_teste.txt");
Assert.IsNotNull(queue);
Assert.AreEqual(queue.Count(), 5);
}
private void SalvarArquivo(object sender, RoutedEventArgs e)
{
Atualizar(null, null);
ArquivoService service = new ArquivoService();
service.SalvarTexto(pessoas);
}
public void Calcular_combustivel_gasto_nas_rotas()
{
var arquivoService = new ArquivoService();
var rotaService = new RotaService();
var rotasECombustivel = rotaService.LerRelatorioComCombustivel(arquivoService, "entrada_rotas_com_combustivel_teste.txt");
var rotas = rotasECombustivel.Item1.ToArray();
var combustivel = rotasECombustivel.Item2;
Assert.AreEqual(rotas.Count(), 3);
Assert.AreEqual(combustivel - rotas[0].ConsumoMedio, 55.98, 0.1);
Assert.AreEqual(combustivel - rotas[0].ConsumoMedio - rotas[1].ConsumoMedio, 9.26, 0.1);
}
public void Obter_lista_de_veiculos()
{
var arquivoService = new ArquivoService();
var rotaService = new RotaService();
var queue = arquivoService.LerArquivoDeEntrada("entrada_veiculos_teste.txt");
var veiculos = rotaService.ObterVeiculos(queue).ToArray();
Assert.AreEqual(veiculos.Count(), 3);
Assert.AreEqual(veiculos[0].Codigo, 1);
Assert.AreEqual(veiculos[0].QuilometroPorLitro, 7);
Assert.AreEqual(veiculos[1].Codigo, 2);
Assert.AreEqual(veiculos[1].QuilometroPorLitro, 8);
Assert.AreEqual(veiculos[2].Codigo, 3);
Assert.AreEqual(veiculos[2].QuilometroPorLitro, 10);
}
private void Importar(object sender, RoutedEventArgs e)
{
string caminho = "";
OpenFileDialog openFileDialog = new OpenFileDialog();
openFileDialog.Filter = "Text files (*.txt)|*.txt|All files (*.*)|*.*";
if (openFileDialog.ShowDialog() == true)
{
caminho = openFileDialog.FileName;
}
ArquivoService arquivoService = new ArquivoService();
arquivoService.ImportarTexto(caminho);
}
// GET: Vestidos/Delete/5
public async Task <IActionResult> Delete(int?id)
{
if (id == null)
{
return(NotFound());
}
var vestido = await _unitOfWork.Vestidos.FirstOrDefaultAsync(m => m.VestidoID == id);
ArquivoService.RemoverArquivo(vestido.UrlVestido, CaminhoConstantes.VESTIDOS);
if (vestido == null)
{
return(NotFound());
}
return(View(vestido));
}
public void Escrever_arquivo_de_saida_com_combustivel()
{
var arquivoService = new ArquivoService();
var rotaService = new RotaService();
var rotasECombustivel = rotaService.LerRelatorioComCombustivel(arquivoService, "entrada_rotas_com_combustivel_teste.txt");
var rotas = rotasECombustivel.Item1;
var combustivel = rotasECombustivel.Item2;
var linhas = rotaService.EscreverRelatorioDeCombustivel(arquivoService, "saida_combustivel_teste.txt", rotas, combustivel).ToArray();
Assert.IsNotNull(linhas);
Assert.AreEqual(linhas[0], "0");
Assert.AreEqual(linhas[1], "");
Assert.AreEqual(linhas[2], "55.98");
Assert.AreEqual(linhas[3], "9.26");
Assert.AreEqual(linhas[4], "0");
Assert.AreEqual(linhas[5], "");
}
public async Task <IActionResult> Create(VestidoViewModel vestidoViewModel, IFormFile imagemVestido)
{
if (ModelState.IsValid)
{
if (imagemVestido == null || imagemVestido.Length == 0)
{
return(Content("file not selected"));
}
if (ArquivoService.AdicionarArquivo(imagemVestido, CaminhoConstantes.VESTIDOS))
{
Vestido vestido = _mapper.Map <Vestido>(vestidoViewModel);
_unitOfWork.Vestidos.Add(vestido);
await _unitOfWork.SaveAsync();
}
return(RedirectToAction(nameof(Index)));
}
return(View());
}
public async Task <IActionResult> Edit(int id, VestidoViewModel vestidoViewModel, IFormFile imagemVestido)
{
if (id != vestidoViewModel.VestidoID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
if (imagemVestido == null || imagemVestido.Length == 0)
{
return(Content("file not selected"));
}
ArquivoService.RemoverArquivo(_unitOfWork.Vestidos.GetById(vestidoViewModel.VestidoID).UrlVestido, CaminhoConstantes.VESTIDOS);
if (ArquivoService.AdicionarArquivo(imagemVestido, CaminhoConstantes.VESTIDOS))
{
Vestido vestido = _mapper.Map <Vestido>(vestidoViewModel);
_unitOfWork.Vestidos.Update(vestido);
await _unitOfWork.SaveAsync();
}
}
catch (DbUpdateConcurrencyException)
{
if (!VestidoExists(vestidoViewModel.VestidoID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(vestidoViewModel));
}
public void Obter_lista_de_rotas()
{
var arquivoService = new ArquivoService();
var rotaService = new RotaService();
var queue = arquivoService.LerArquivoDeEntrada("entrada_rotas_teste.txt");
var veiculos = new List <Veiculo>()
{
new Veiculo(1, 7),
new Veiculo(2, 8),
new Veiculo(3, 10),
};
var rotas = rotaService.ObterRotas(queue, veiculos);
Assert.AreEqual(rotas.Count(), 3);
Assert.AreEqual(rotas[0].Dia, 1);
Assert.AreEqual(rotas[0].Roteiros.Count, 3);
Assert.AreEqual(rotas[0].Roteiros[0].ConsumoMedio, 19.57142857, 0.1);
Assert.AreEqual(rotas[1].Dia, 2);
Assert.AreEqual(rotas[1].Roteiros.Count, 3);
Assert.AreEqual(rotas[2].Dia, 3);
Assert.AreEqual(rotas[2].Roteiros.Count, 3);
}
//private readonly ArquivoService _arquivoService;
public ArquivoController(ArquivoContext context)
{
_context = context;
//_arquivoService = arquivoService;
ArquivoService arquivoService = new ArquivoService();
//List<ArquivoModel> arquivoModel = arquivoService.GetArquivos();
//arquivoModel(item => _context.Arquivos.Add(item).SaveChanges());
if (_context.Arquivos.Count() == 0)
{
// _context.Arquivos.Add(new ArquivoModel { Nome = "Item1" });
foreach (ArquivoModel arquivo in arquivoService.GetArquivosFisico())
{
_context.Arquivos.Add(arquivo);
_context.SaveChanges();
}
//_context.Arquivos.Add(_arquivoService());
//_context.SaveChanges();
}
}
public ImportacaoService()
{
_contexto = new Contexto();
_usuarioService = new ArquivoService();
}
static void Main(string[] args)
{
var arquivoService = new ArquivoService();
var rotaService = new RotaService();
var rotas = rotaService.LerRelatorio(arquivoService, "entrada_func_a.txt");
foreach (var rota in rotas)
{
Console.WriteLine("+-------------+");
Console.WriteLine($"| ROTA DIA {rota.Dia} | ");
Console.WriteLine("+-------------+");
foreach (var roteiro in rota.Roteiros)
{
//CARRO A: 35 km CIDADE A, 80 km CIDADE B, 22 km VOLTAR
var mensagem = $"CARRO {roteiro.Veiculo.Codigo}: ";
foreach (var trecho in roteiro.Trechos)
{
if (trecho.Cidade.Equals("0"))
{
mensagem = mensagem + $"{trecho.Quilometragem} km VOLTAR ";
}
else
{
mensagem = mensagem + $"{trecho.Quilometragem} km CIDADE {trecho.Cidade}, ";
}
}
Console.WriteLine(mensagem);
Console.WriteLine("");
}
}
Console.WriteLine("+ --------------------------------------------------+");
Console.WriteLine("Pressione qualquer tecla para gerar arquivo de saída.");
Console.WriteLine("+ --------------------------------------------------+");
Console.ReadKey();
rotaService.EscreverRelatorio(arquivoService, "saida_func_a.txt", rotas);
Console.WriteLine("+ ------------------------+");
Console.WriteLine("Arquivo gerado com sucesso!");
Console.WriteLine("+ ------------------------+");
Console.WriteLine("+ -----------------------------------------------------------+");
Console.WriteLine("Pressione qualquer tecla para exibir relatório de combustivel.");
Console.WriteLine("+ -----------------------------------------------------------+");
Console.ReadKey();
var rotasECombustivel = rotaService.LerRelatorioComCombustivel(arquivoService, "entrada_func_b.txt");
var restante = rotasECombustivel.Item2;
foreach (var rota in rotasECombustivel.Item1)
{
restante -= rota.ConsumoMedio;
if (restante > 0)
{
Console.WriteLine($"ROTA DIA {rota.Dia}: COMBUSTIVEL RESTANTE: {restante} litros");
}
else
{
Console.WriteLine($"ROTA DIA {rota.Dia}: SEM COMBUSTÌVEL SUFICIENTE");
}
}
Console.WriteLine("+ --------------------------------------------------+");
Console.WriteLine("Pressione qualquer tecla para exibir relatório de combustivel.");
Console.WriteLine("+ --------------------------------------------------+");
Console.ReadKey();
rotaService.EscreverRelatorioDeCombustivel(arquivoService, "saida_func_b.txt",
rotasECombustivel.Item1, rotasECombustivel.Item2);
Console.WriteLine("+ ------------------------+");
Console.WriteLine("Arquivo gerado com sucesso!");
Console.WriteLine("+ ------------------------+");
Console.ReadKey();
}
protected override void Execute(IPluginExecutionContext context, IOrganizationServiceFactory serviceFactory, IOrganizationService adminService, IOrganizationService userService)
{
switch (Util.Utilitario.ConverterEnum <Domain.Enum.Plugin.MessageName>(context.MessageName))
{
#region Create
case Domain.Enum.Plugin.MessageName.Create:
var entidade = (Entity)context.InputParameters["Target"];
var solicitacaoBeneficio = entidade.Parse <Domain.Model.SolicitacaoBeneficio>(context.OrganizationName, context.IsExecutingOffline);
new SharepointServices(context.OrganizationName, context.IsExecutingOffline, adminService)
.CriarDiretorio <Domain.Model.SolicitacaoBeneficio>(solicitacaoBeneficio.Nome, solicitacaoBeneficio.ID.Value);
break;
#endregion
#region Update
case Domain.Enum.Plugin.MessageName.Update:
if (context.Depth > 1)
{
return;
}
if (context.PreEntityImages.Contains("imagem") && context.PreEntityImages["imagem"] is Entity)
{
var ServiceSolicitacaoBeneficio = new SolicitacaoBeneficioService(context.OrganizationName, context.IsExecutingOffline, adminService);
var entityMerge = context.PostEntityImages["imagem"];
var solicMerge = entityMerge.Parse <Domain.Model.SolicitacaoBeneficio>(context.OrganizationName, context.IsExecutingOffline, adminService);
ServiceSolicitacaoBeneficio.CriarSolicitacaoComProdutosCancelados(solicMerge);
if (solicMerge.TipoPriceProtection.HasValue && solicMerge.TipoPriceProtection == (int)Domain.Enum.SolicitacaoBeneficio.TipoPriceProtection.Autorizacao)
{
if (solicMerge.StatusCalculoPriceProtection.HasValue && solicMerge.StatusCalculoPriceProtection == (int)Domain.Enum.SolicitacaoBeneficio.StatusCalculoPriceProtection.Calcular)
{
// Instanciando objetos utilizados para buscas
var ServiceProdSolicitacao = new ProdutosdaSolicitacaoService(context.OrganizationName, context.IsExecutingOffline, adminService);
var ServiceProd = new ProdutoService(context.OrganizationName, context.IsExecutingOffline, adminService);
var ServiceSellout = new SellOutService(context.OrganizationName, context.IsExecutingOffline);
var ServiceFatura = new FaturaService(context.OrganizationName, context.IsExecutingOffline);
var ServiceConta = new ContaService(context.OrganizationName, context.IsExecutingOffline);
var ServiceUnidade = new UnidadeNegocioService(context.OrganizationName, context.IsExecutingOffline);
var ServiceFamilia = new FamiliaComercialService(context.OrganizationName, context.IsExecutingOffline);
var ServiceEstabelecimento = new EstabelecimentoService(context.OrganizationName, context.IsExecutingOffline);
var ServiceArquivo = new ArquivoService(context.OrganizationName, context.IsExecutingOffline);
//trocar status para calculando
solicMerge.StatusCalculoPriceProtection = (int)Domain.Enum.SolicitacaoBeneficio.StatusCalculoPriceProtection.Calculando;
ServiceSolicitacaoBeneficio.Persistir(solicMerge);
// Obtendo dados para busca de quantidade de itens vendidos no Sellout
var lstProdSolic = ServiceProdSolicitacao.ListarPorSolicitacaoAtivos(solicMerge.ID.Value);
if (lstProdSolic.Count > 0)
{
var lstTmpFilter = lstProdSolic.Select(c => (Guid)c.Produto.Id).ToList();
var lstObjProd = ServiceProd.ListarProduto(lstTmpFilter);
var listFilterSelloutWS = lstObjProd.Select(c => c.Codigo).ToList();
var listFilterFatura = lstObjProd.Select(c => c.ID).ToList();
var strListFilter = String.Join("','", listFilterSelloutWS);
DateTime dataIni = (DateTime)solicMerge.DataCriacao;
dataIni = dataIni.AddMonths(-1);
DateTime dataFim = new DateTime(dataIni.Year, dataIni.Month, DateTime.DaysInMonth(dataIni.Year, dataIni.Month), 23, 59, 59);
dataIni = dataIni.AddMonths(-2);
dataIni = new DateTime(dataIni.Year, dataIni.Month, 1, 0, 0, 0);
//Lista de total de unidades reportadas pelo sellout nos ultimos 90 dias, divididos por 2, para os produtos solicitados.
var listValueSellout = ServiceSellout.listarContagemVenda(dataIni, dataFim, solicMerge.Canal.Id, strListFilter);
//TODO - Determinar data referencia dos 6 meses para as faturas
var listProdFaturas = ServiceFatura.listarContagemVendaPrice(solicMerge.Canal.Id, listFilterFatura, lstObjProd);
//Ajuste de valor de quantidade
foreach (var ajusteValuesTmp in listValueSellout)
{
var prodTmp = lstObjProd.Find(x => x.Codigo == ajusteValuesTmp.CodigoProdutoERP);
if (prodTmp != null)
{
var prodSolicTmp = lstProdSolic.Find(x => x.Produto.Id == prodTmp.ID);
if (prodSolicTmp != null)
{
if (prodSolicTmp.QuantidadeAjustada.HasValue)
{
ajusteValuesTmp.TotalUnidades = (decimal)prodSolicTmp.QuantidadeAjustada;
}
else
{
if (ajusteValuesTmp.TotalUnidades > prodSolicTmp.QuantidadeSolicitada)
{
ajusteValuesTmp.TotalUnidades = (decimal)prodSolicTmp.QuantidadeSolicitada;
}
}
}
}
}
//Busca de preços atuais
var listPrecoProduto = new List <PrecoProduto>();
foreach (var objSolicProd in lstProdSolic)
{
PrecoProduto precoProduto = new PrecoProduto(context.OrganizationName, context.IsExecutingOffline);
Product objProd = lstObjProd.Find(x => x.ID == objSolicProd.Produto.Id);
precoProduto.CodigoProduto = objProd.Codigo;
precoProduto.ProdutoId = objProd.ID.Value;
precoProduto.Produto = objProd;
var contaObjTmp = ServiceConta.BuscaConta(solicMerge.Canal.Id);
List <ProdutoPortfolio> lstProdutoPortifolio = ServiceProd.ProdutosPortfolio(contaObjTmp, contaObjTmp.Classificacao.Id, solicMerge.UnidadedeNegocio.Id);
ProdutoPortfolio produtoPortfolioTmp = lstProdutoPortifolio.Find(x => x.Produto.Id == objProd.ID.Value);
Estabelecimento estTmp = ServiceEstabelecimento.BuscaEstabelecimento(objSolicProd.Estabelecimento.Id);
precoProduto.codEstabelecimento = (int)estTmp.Codigo;
var unidadeTmp = ServiceUnidade.BuscaUnidadeNegocio(solicMerge.UnidadedeNegocio.Id);
precoProduto.codUnidade = unidadeTmp.ChaveIntegracao;
var famComTmp = ServiceFamilia.ObterPor(objProd.FamiliaComercial.Id);
precoProduto.codFamiliaComl = famComTmp.Codigo;
precoProduto.tipoPortofolio = produtoPortfolioTmp.PortfolioTipo;
precoProduto.ContaId = solicMerge.Canal.Id;
precoProduto.ValorProduto = 0;
precoProduto.Quantidade = (int)objSolicProd.QuantidadeSolicitada;
listPrecoProduto.Add(precoProduto);
}
listPrecoProduto = ServiceProd.ListarPor(listPrecoProduto);
MSG0138 msg0138 = new MSG0138(context.OrganizationName, context.IsExecutingOffline);
List <ValorProdutoICMSViewModel> lstPrecoProdICMS = msg0138.Enviar(lstObjProd, lstProdSolic, listPrecoProduto, solicMerge);
List <ProdutoFaturaViewModel> lstProdFatGenerate = new List <ProdutoFaturaViewModel>();
List <string> errorNoSellout = new List <string>();
foreach (var objProdSolic in lstProdSolic)
{
Product objProd = lstObjProd.Find(x => x.ID == objProdSolic.Produto.Id);
QtdProdutoSellout objQtdSellout = listValueSellout.Find(x => x.CodigoProdutoERP == objProd.Codigo);
if (objQtdSellout == null || objQtdSellout.TotalUnidades <= 0)
{
string strError = "Produto: " + objProd.Codigo + " " + objProd.Nome + " | Nenhuma entrada de sellout para o produto";
errorNoSellout.Add(strError);
}
}
string urlSharepoint = string.Empty;
var retUrlSharepoint = ServiceArquivo.ObterUrlArquivo(solicMerge.ID.ToString(), context.OrganizationName, out urlSharepoint);
if (errorNoSellout.Count == 0)
{
foreach (var objProdSolic in lstProdSolic)
{
Product objProd = lstObjProd.Find(x => x.ID == objProdSolic.Produto.Id);
QtdProdutoSellout objQtdSellout = listValueSellout.Find(x => x.CodigoProdutoERP == objProd.Codigo);
objProdSolic.QuantidadeAprovada = 0;
objProdSolic.ValorTotalAprovado = 0;
objProdSolic.ValorTotal = 0;
PrecoProduto objPrecoProd = listPrecoProduto.Find(x => x.Produto.ID == objProdSolic.Produto.Id);
ValorProdutoICMSViewModel objValProdICMS = lstPrecoProdICMS.Find(x => x.CodigoProduto == objProd.Codigo);
var lstProdFatLocal = listProdFaturas.Where(x => x.CodigoProduto == objProd.Codigo).OrderByDescending(x => x.DataEmissaoFatura).ToList();
foreach (var objProdFaturas in lstProdFatLocal)
{
if (objQtdSellout.TotalUnidades == 0)
{
objProdFaturas.QtdCalculo = 0;
}
else if (objProdFaturas.QtdFatura >= objQtdSellout.TotalUnidades)
{
objProdFaturas.QtdCalculo = objQtdSellout.TotalUnidades;
}
else
{
objProdFaturas.QtdCalculo = objProdFaturas.QtdFatura;
}
objProdFaturas.SaldoDiferenca = objProdFaturas.PrecoFatura - objValProdICMS.PrecoLiquido;
if (objProdFaturas.SaldoDiferenca > 0)
{
objProdFaturas.ValorIPIProduto = objProd.PercentualIPI;
objProdFaturas.PrecoCalculoAtual = objValProdICMS.PrecoLiquido;
objProdFaturas.TotalDiferenca = objProdFaturas.SaldoDiferenca * objProdFaturas.QtdCalculo;
objProdFaturas.TotalComIPI = objProdFaturas.TotalDiferenca + (objProdFaturas.TotalDiferenca * (objProd.PercentualIPI / 100));
objProdSolic.QuantidadeAprovada += objProdFaturas.QtdCalculo;
if (objProdFaturas.QtdFatura >= objQtdSellout.TotalUnidades)
{
objQtdSellout.TotalUnidades = 0;
}
else
{
objQtdSellout.TotalUnidades -= objProdFaturas.QtdFatura;
}
if (objProdSolic.ValorTotalAprovado.HasValue)
{
objProdSolic.ValorTotalAprovado += objProdFaturas.TotalComIPI;
}
else
{
objProdSolic.ValorTotalAprovado = objProdFaturas.TotalComIPI;
}
if (objProdSolic.ValorTotal.HasValue)
{
objProdSolic.ValorTotal += objProdFaturas.TotalComIPI;
}
else
{
objProdSolic.ValorTotal = objProdFaturas.TotalComIPI;
}
}
else if (objProdFaturas.SaldoDiferenca <= 0)
{
objProdFaturas.ValorIPIProduto = objProd.PercentualIPI;
objProdFaturas.PrecoCalculoAtual = objValProdICMS.PrecoLiquido;
}
lstProdFatGenerate.Add(objProdFaturas);
}
if (objProdSolic.QuantidadeAprovada > 0 && objProdSolic.ValorTotalAprovado > 0)
{
var dateTime = DateTime.Now;
ServiceArquivo.CriarExcelRecalculo(lstProdFatGenerate, dateTime.ToString("dd/MM/yyyy"), urlSharepoint, NameFileTable, context.OrganizationName, context.IsExecutingOffline);
ServiceProdSolicitacao.Persistir(objProdSolic);
}
else if (lstProdFatLocal.Count > 0 && objProdSolic.ValorTotalAprovado <= 0)
{
string strError = "Produto: " + objProd.Codigo + " " + objProd.Nome + " | Nenhuma entrada nas Faturas do Canal com diferença positiva de preço para o Produto";
errorNoSellout.Add(strError);
}
else
{
string strError = "Produto: " + objProd.Codigo + " " + objProd.Nome + " | Nenhuma entrada nas Faturas do Canal para o Produto";
errorNoSellout.Add(strError);
}
}
if (errorNoSellout.Count == 0)
{
solicMerge.StatusCalculoPriceProtection = (int)Domain.Enum.SolicitacaoBeneficio.StatusCalculoPriceProtection.Calculado;
ServiceSolicitacaoBeneficio.Persistir(solicMerge);
}
else
{
ServiceArquivo.CriarArquivosErros(errorNoSellout, urlSharepoint, NameFileLog);
solicMerge.StatusCalculoPriceProtection = (int)Domain.Enum.SolicitacaoBeneficio.StatusCalculoPriceProtection.ErroCalcular;
ServiceSolicitacaoBeneficio.Persistir(solicMerge);
}
}
else
{
ServiceArquivo.CriarArquivosErros(errorNoSellout, urlSharepoint, NameFileLog);
solicMerge.StatusCalculoPriceProtection = (int)Domain.Enum.SolicitacaoBeneficio.StatusCalculoPriceProtection.ErroCalcular;
ServiceSolicitacaoBeneficio.Persistir(solicMerge);
}
}
else
{
solicMerge.StatusCalculoPriceProtection = (int)Domain.Enum.SolicitacaoBeneficio.StatusCalculoPriceProtection.Calculado;
ServiceSolicitacaoBeneficio.Persistir(solicMerge);
}
}
}
}
break;
#endregion
}
}
