/// <summary>
/// Lê o arquivo XML, faz o parse, salva os dados lidos, e retorna a lista de alunos salvos.
/// </summary>
/// <param name="path">Path do arquivo XML</param>
/// <returns>Lista de alunos importados</returns>
/// <exception cref="CPFNaoInformadoException">CPF do aluno não informado.</exception>
/// <exception cref="CPFFormatoIncorretoException">CPF fora do padrão (Formato Inválido)</exception>
/// <exception cref="NomeNaoInformadoException">Nome do aluno não informado.</exception>
/// <exception cref="EnderecoNaoInformadoException">Endereço do aluno não informado.</exception>
/// <exception cref="InvalidOperationException">Erro ao ler o arquivo.</exception>
public ICollection <Aluno> Importar(string path, string nomeArquivo)
{
XmlSerializer serializer = new XmlSerializer(typeof(AlunoListXML));
FileStream fileStream = new FileStream(path, FileMode.Open);
AlunoListXML alunosList;
//Tenta ler o arquivo e salvar. Qualquer exceção, fecha o arquivo e lança a exceção.
try
{
alunosList = (AlunoListXML)serializer.Deserialize(fileStream);
return(SaveAlunos(alunosList));
}
finally
{
//Fecha e exclui o arquivo
fileStream.Close();
//Insere um registro na tabela Importacoes para manter o histórico de Importações.
Importacao imp = new Importacao
{
DataHora = DateTime.Now,
NomeArquivo = nomeArquivo,
Arquivo = File.ReadAllBytes(path) //Lê os bytes do arquivo e salva, para possibilitar posterior download
};
_importacaoRepositoy.Save(imp);
File.Delete(path);
}
}
public string GetDeviceCode(string CodDispositivo)
{
string PRetorno = "";
claLatLong objclaLatLong = new claLatLong();
List <claLatLong> lstLatLong = objclaLatLong.CarregarDados(CodDispositivo);
if (lstLatLong.Count > 0)
{
foreach (claLatLong objLstLatLong in lstLatLong)
{
Importacao objImportacao = new Importacao();
List <Importacao> lstImportacao = objImportacao.CarregarDados(objLstLatLong.Latitude.ToString(), objLstLatLong.Longitude.ToString());
if (lstImportacao.Count > 0)
{
foreach (Importacao objLstImportacao in lstImportacao)
{
PRetorno += "Lat:" + objLstImportacao.Latitude.ToString() + "," + "Long:" + objLstImportacao.Longitude.ToString() + "/";
}
}
}
}
else
{
PRetorno = "0";
}
return(PRetorno);
}
public ImportacaoViewModel ImportarAssociados(Guid cicloId, Guid votacaoId, byte[] conteudoArquivo, string arquivo, string cpfUsuario)
{
var ciclo = BuscarEntidade(cicloId);
var votacao = ciclo.Votacoes.SingleOrDefault(v => v.Id == votacaoId);
IsNotNull(votacao, "Votação", 'a');
string relativePath = $@"{PATH_IMPORTACOES}{votacaoId.ToString()}/Associados";
string absolutePath = @FileSystemHelpers.GetAbsolutePath(relativePath);
if (!Directory.Exists(absolutePath))
{
Directory.CreateDirectory(absolutePath);
}
string fullFileName = @FileSystemHelpers.GetAbsolutePath(FileSystemHelpers.GetRelativeFileName(absolutePath, arquivo));
File.WriteAllBytes(fullFileName, conteudoArquivo);
var importacao = new Importacao(votacao, Path.Combine(relativePath, arquivo), cpfUsuario);
votacao.AdicionarImportacao(importacao);
base.Atualizar(ciclo);
return(_mapper.Map <ImportacaoViewModel>(importacao));
}
public Importacao RecuperarPorId(CodigoPadraoDTO dto)
{
var registro = _db.Importacao.Include("Carros").Select(x => new {
x.Carros,
x.DataImportacao,
x.Descricao,
x.Id,
x.Observacao,
x.TipoImportacao
}).FirstOrDefault(x => x.Id == dto.Id);
if (registro == null)
{
throw new Exception("Registro " + dto.Id + " não encontrado! ");
}
var importacao = new Importacao()
{
Carros = registro.Carros,
DataImportacao = registro.DataImportacao,
Descricao = registro.Descricao,
Id = registro.Id,
Observacao = registro.Observacao,
TipoImportacao = registro.TipoImportacao
};
return(importacao);
}
public static List <Movimentacao> MontaExtrato(decimal saldo, Importacao importacao)
{
Extract extratoBancario = OFXParser.OFXParser.GetExtract(importacao.NomeArquivo);
if (extratoBancario != null)
{
List <Movimentacao> movimentacoes = new List <Movimentacao>();
var saldoAtual = saldo;
foreach (var transacao in extratoBancario.Transactions)
{
saldoAtual = saldoAtual + Convert.ToDecimal(transacao.TransactionValue);
movimentacoes.Add(new Movimentacao()
{
Id = Guid.NewGuid(),
DataMovimento = transacao.Date,
Descricao = transacao.Description,
Valor = Convert.ToDecimal(transacao.TransactionValue),
SaldoAtual = saldoAtual,
Importacao = importacao
});
}
return(movimentacoes);
}
return(null);
}
public async Task <IActionResult> PostMovimentacao(IFormFile file)
{
try
{
if (file != null)
{
var filePath = UploadFiles.Upload(file);
Importacao importacao = new Importacao();
importacao.Id = Guid.NewGuid();
importacao.DataImportacao = DateTime.Now;
importacao.NomeArquivo = filePath;
importacao.Movimentacoes = Extrato.MontaExtrato(await _movimentacaoRepository.GetSaldo(), importacao);
_importacaoRepository.Add(importacao);
if (await _importacaoRepository.SaveChangesAsync())
{
return(Ok(await _movimentacaoRepository.Get()));
}
}
return(BadRequest());
}
catch (Exception)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, "Falha no upload do arquivo."));
}
}
public async Task <Importacao> ImportarEleitores(int eleicaoId, int usuarioId, Stream file, string nomeArquivo, string contentType)
{
var eleicao = _unitOfWork.EleicaoRepository.BuscarPeloId(eleicaoId);
if (eleicao == null)
{
throw new NotFoundException("Eleição não encontrada.");
}
var usuario = _unitOfWork.UsuarioRepository.BuscarPeloId(usuarioId);
if (usuario == null)
{
throw new CustomException("Usuário inválido!");
}
var arquivo = await _arquivoAppService.SalvarArquivo(
file, DependencyFileType.Importacao, eleicao.Id,
usuario.Email, usuario.Nome, Guid.NewGuid().ToString().Replace("-", "") + Path.GetExtension(nomeArquivo), contentType);
ValidaFormatoPlanilha(arquivo.Path);
var importacao = new Importacao(arquivo, eleicao);
importacao = _unitOfWork.ImportacaoRepository.Adicionar(importacao);
_unitOfWork.Commit();
return(importacao);
}
public ImportacaoHelper(
Importacao importacao,
IEnumerable <dynamic> registros)
{
Importacao = importacao;
Registros = registros;
}
public async Task <List <string> > Handle(CreateImportacoesRequest request, CancellationToken cancellationToken)
{
var mensagemsErro = new List <string>();
if (request.Arquivo == null)
{
mensagemsErro.Add("O Arquivo deve ser informado.");
return(mensagemsErro);
}
ExcelPackage.LicenseContext = LicenseContext.NonCommercial;
var produtos = new List <Produto>();
var importacao = new Importacao(Guid.NewGuid(), DateTime.Now);
using (var package = new ExcelPackage(request.Arquivo.OpenReadStream()))
{
foreach (var worksheet in package.Workbook.Worksheets)
{
//loop all rows
for (var row = 2; row <= worksheet.Dimension.End.Row; row++)
{
//loop all columns in a row
var produto =
GetProdutoByRow(worksheet, row);
var erros = produto.Valida(row);
if (erros.Count != 0)
{
mensagemsErro.AddRange(erros);
}
if (erros.Count != 0)
{
continue;
}
produto.Importacao = importacao;
importacao.QuantidadeProdutosImportados++;
produtos.Add(produto);
}
}
}
if (mensagemsErro.Count != 0)
{
_domainValidation.AddError("Erros foram encontrados!");
mensagemsErro.Add("Nenhum produto foi importado, corrija a planilha e tente novamente.");
}
importacao.Produtos = produtos;
_importacaoRepository.Store(importacao);
await _unityOfWork.SaveChangesIfDomainIsValid();
return(mensagemsErro);
}
protected override void ProcessarDados(Importacao importacao, DataTable dataTable)
{
var associados = AdicionarAssociados(dataTable);
var inconsistencias = RetornarInconsistenciasDadosDuplicados(associados.Select(a => a.Cpf), ColunasArquivo.CPF).ToList();
inconsistencias.AddRange(associados.Where(a => a.Cpf.Length != 11)
.Select((a, i) => new Inconsistencia(ColunasArquivo.CPF, i + LINHA_INICIAL_ARQUIVO + 1, $"CPF deve possuir 11 dígitos: {a.Cpf}")));
if (!FinalizarImportacaoComErro(importacao, inconsistencias))
{
int linha = LINHA_INICIAL_ARQUIVO + 1;
foreach (var associadoViewModel in associados)
{
var usuario = new Usuario(
associadoViewModel.Cpf,
associadoViewModel.Matricula,
associadoViewModel.Nome,
associadoViewModel.Cargo,
associadoViewModel.Area,
importacao.Votacao.Ciclo.Empresa);
var usuarioAtualizado = _unitOfWork.UsuarioRepository.BuscarPeloCPF(associadoViewModel.Cpf);
if (usuarioAtualizado == null)
{
usuarioAtualizado = usuario;
}
else
{
usuarioAtualizado.AtualizarDados(usuario);
}
var grupo = importacao.Votacao.Ciclo.BuscarGrupoPeloNome(associadoViewModel.GrupoNome);
if (grupo == null)
{
inconsistencias.Add(new Inconsistencia(ColunasArquivo.Grupo, linha, $"Grupo não encontrado: {associadoViewModel.GrupoNome}."));
}
else
{
var associado = new Associado(usuarioAtualizado, grupo, associadoViewModel.Aplausogramas, associadoViewModel.CentroCusto);
var associadoExistente = importacao.Votacao.Ciclo.BuscarAssociadoPeloCPF(associadoViewModel.Cpf);
if (associadoExistente == null)
{
importacao.Votacao.Ciclo.AdicionarAssociado(associado);
}
else
{
associadoExistente.AtualizarDados(associado);
}
}
NotificarProgresso(linha - LINHA_INICIAL_ARQUIVO, associados.Count, importacao.CPFUsuarioImportacao);
linha++;
}
if (!FinalizarImportacaoComErro(importacao, inconsistencias))
{
FinalizarImportacaoComSucesso(importacao);
}
}
}
public void InserirImportacao(Importacao importacao)
{
try
{
Repository.Insert(importacao);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
private async Task IncluirDados(IEnumerable <ProdutoExcel> dados)
{
var produtos = _mapper.Map <List <Produto> >(dados);
var importacao = new Importacao
{
DtImportacao = DateTime.Now,
Produtos = produtos,
};
_importacaoRepository.Inserir(importacao);
await _uow.Commit();
}
public async Task <Unit> Handle(ExecuteImportacaoETLCommand request, CancellationToken cancellationToken)
{
var cultureInfo = new CultureInfo("pt-BR");
CultureInfo.DefaultThreadCurrentCulture = cultureInfo;
CultureInfo.DefaultThreadCurrentUICulture = cultureInfo;
var anoEleicao = request.AnoEleicao ?? DateTime.Now.Year;
var politicosUrl = string.Format(_configuration.PoliticosUrl, anoEleicao);
var politicosNomeArquivos = _configuration.PoliticosNomeArquivos.Select(_ => string.Format(_, anoEleicao).ToUpper());
var result = await new Process()
.Extract(() => new HttpStreamSource(_httpClientFactory.CreateClient(), politicosUrl))
.TransformDescompressStream()
.TransformToList(_ => _.Value)
.Where(_ => politicosNomeArquivos.Contains(_.Value.Name.ToUpper()))
.Transform(_ => _.Value.Stream)
.TransformCsvToDynamic(";")
.Transform(_ => {
var strDataHoraGeracao = $"{_.Value.FirstOrDefault().DT_GERACAO} {_.Value.FirstOrDefault().HH_GERACAO}";
var dataHoraGeracao = DateTime.ParseExact(strDataHoraGeracao, "dd/MM/yyyy HH:mm:ss", cultureInfo);
var parent = _.GetParent <StreamDescompressed>();
var importacao = new Importacao(dataHoraGeracao, politicosUrl, parent.Value.Name);
return(new ImportacaoHelper(importacao, _.Value));
})
.TransformToList(_ => new List <dynamic>(_.Value.Registros))
.Where(_ => _.Value.CD_CARGO == "6" && (_.Value.CD_SIT_TOT_TURNO == "2" || _.Value.CD_SIT_TOT_TURNO == "3"))
.AsParallel()
.WithDegreeOfParallelism(4)
.Transform(_ => {
var actualPolitico = _importacaoRepository.FindByCPF(Convert.ToInt64(_.Value.NR_CPF_CANDIDATO));
var importacao = _.GetParent <ImportacaoHelper>().Value.Importacao;
if (actualPolitico == null)
{
importacao.AddNewPolitico(_.Value);
}
else
{
importacao.AddIfHasChangePolitico(_.Value, actualPolitico);
}
return(importacao);
})
.Execute();
var importacoes = result.Select(_ => _.Value).Distinct();
await _importacaoRepository.AddRangeAsync(importacoes, cancellationToken);
await _importacaoRepository.UnityOfWork.SaveChangesAsync(cancellationToken);
return(new Unit());
}
public HttpResponseMessage Salvar(Importacao importacao)
{
try
{
var retorno = _servImportacao.Salvar(importacao, null);
return(Request.CreateResponse(HttpStatusCode.OK, new { Content = retorno, Mensagem = "Registro salvo com sucesso!" }));
}
catch (System.Exception e)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, new { Mensagem = e.Message }));
}
}
public List <Importacao> UploadFile(Stream fileStream)
{
List <Importacao> importacoes = new List <Importacao>();
IExcelDataReader reader;
try
{
reader = ExcelReaderFactory.CreateOpenXmlReader(fileStream);
}
catch (Exception)
{
reader = ExcelReaderFactory.CreateBinaryReader(fileStream);
}
var count = 0;
while (reader.Read())
{
if (count > 0)
{
if (reader[1] != null && !string.IsNullOrEmpty(reader[1].ToString()))
{
importacoes.Add(new Importacao
{
data_entrega = DateTime.Parse(reader[1].ToString()),
descricao = reader[2].ToString(),
quantidade = int.Parse(reader[3].ToString()),
valor_unitario = decimal.Parse(reader[4].ToString())
});
}
else
{
break;
}
}
count++;
}
foreach (var importacao in importacoes)
{
var import = new Importacao();
import.data_entrega = importacao.data_entrega;
import.descricao = importacao.descricao;
import.quantidade = importacao.quantidade;
import.valor_unitario = importacao.valor_unitario;
_repository.Insert(import);
}
return(importacoes);
}
public string IndiceFire(double ValorIndice)
{
string PRetorno = "";
Importacao objImportacao = new Importacao();
List <Importacao> lstImportacao = objImportacao.CarregarDadosPorIndice(ValorIndice.ToString());
if (lstImportacao.Count > 0)
{
foreach (Importacao objLstImportacao in lstImportacao)
{
PRetorno += "Indice:" + objLstImportacao.Brilho.ToString() + "," + "Lat:" + objLstImportacao.Latitude.ToString() + "," + "Long:" + objLstImportacao.Longitude.ToString() + "/";
}
}
else
{
PRetorno = "0";
}
return(PRetorno);
}
static void Main(string[] args)
{
//Mapper.Initialize(config =>
//{
// config.CreateMap<Group, Groups>();
// config.CreateMap<PlannerPlan, PlannerPlans>();
// config.CreateMap<PlannerBucket, PlannerBuckets>();
// config.CreateMap<PlannerTask, PlannerTasks>();
// config.CreateMap<PlannerChecklistItem, PlannerChecklistItems>();
// config.CreateMap<User, Users>();
//});
#if (SERVICO)
ServiceBase[] ServicesToRun;
ServicesToRun = new ServiceBase[] { new PlannerBIService() };
ServiceBase.Run(ServicesToRun);
#else
var importacao = new Importacao();
importacao.Executar().Wait();
#endif
}
public async Task <ActionResult> EnviarProdutos(HttpPostedFileBase postedFile)
{
var importacao = new Importacao();
context.Importacao.Add(importacao);
await context.SaveChangesAsync();
using (System.IO.StreamReader reader = new System.IO.StreamReader(postedFile.InputStream))
{
while (!reader.EndOfStream)
{
var result = reader.ReadLine();
var produtoSplited = result.Split(';');
var produto = new Produto(importacao.idImportacao, Convert.ToInt32(produtoSplited[0]), produtoSplited[1], produtoSplited[2]);
context.Produto.Add(produto);
}
}
await context.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public List <Importacao> PesquisarImportacao(PesquisaDTO dto)
{
var registros = _db.Importacao.Include("Carros").Where(x => x.Descricao.ToUpper().Contains(dto.ValorPesquisa.ToUpper())).OrderByDescending(x => x.Id).Skip((dto.Page - 1) * dto.Limit).Take(dto.Limit);
var listImportacao = new List <Importacao>();
foreach (var item in registros)
{
var importacao = new Importacao()
{
Carros = item.Carros,
DataImportacao = item.DataImportacao,
Descricao = item.Descricao,
Id = item.Id,
Observacao = item.Observacao
};
listImportacao.Add(importacao);
}
return(listImportacao);
}
public List <Importacao> Listar(QueryPaginacaoDTO dto)
{
var registros = _db.Importacao.Include("Carros").OrderByDescending(x => x.Id).Skip((dto.Page - 1) * dto.Limit).Take(dto.Limit);
var listImportacao = new List <Importacao>();
foreach (var item in registros)
{
var importacao = new Importacao()
{
Carros = item.Carros,
DataImportacao = item.DataImportacao,
Descricao = item.Descricao,
Id = item.Id,
Observacao = item.Observacao
};
listImportacao.Add(importacao);
}
return(listImportacao);
}
public void Insert(Importacao importacao)
{
try
{
OpenConnection();
using (var cmd = new SqlCommand("", con))
{
cmd.CommandText = "UP_IMPORTACAO_INSERT";
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add(new SqlParameter("@NOME_ARQUIVO", SqlDbType.VarChar)).Value = Convert.ToString(importacao.NomeArquivo);
cmd.Parameters.Add(new SqlParameter("@CAMINHO_ARQUIVO", SqlDbType.VarChar)).Value = Convert.ToString(importacao.CaminhoArquivo);
cmd.Parameters.Add(new SqlParameter("@SEGURADORA_ID", SqlDbType.Int)).Value = Convert.ToInt32(importacao.SeguradoraId);
cmd.Parameters.Add(new SqlParameter("@ANTECIPACAO", SqlDbType.Bit)).Value = Convert.ToInt32(importacao.Antecipacao);
cmd.ExecuteNonQuery();
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
finally { CloseConnection(); }
}
public HttpResponseMessage DonwloadImportacao(int codigo)
{
HttpResponseMessage result = null;
try {
Importacao imp = _importacaoService.Find(codigo);
if (imp == null)
{
return(new HttpResponseMessage(HttpStatusCode.NotFound));
}
var localFilePath = HttpContext.Current.Server.MapPath("~/App_Data") + imp.NomeArquivo;
byte[] arq = imp.Arquivo.ToArray();
File.WriteAllBytes(localFilePath, arq);
// Serve the file to the client
result = Request.CreateResponse(HttpStatusCode.OK);
result.Content = new StreamContent(new FileStream(localFilePath, FileMode.Open, FileAccess.Read));
result.Content.Headers.ContentDisposition = new System.Net.Http.Headers.ContentDispositionHeaderValue("attachment")
{
FileName = imp.NomeArquivo
};
result.Content.Headers.Add("Access-Control-Expose-Headers", "x-filename"); //Sem ele, o header 'x-filename' não aparece
result.Content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/xml");
result.Content.Headers.Add("x-filename", imp.NomeArquivo);
return(result);
} catch (EntidadeNaoEncontradaException <int, Importacao> e)
{
result = Request.CreateErrorResponse(HttpStatusCode.NotFound, e);
return(result);
} catch (Exception e)
{
result = Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e);
return(result);
}
}
public List <Importacao> RecuperarImportacoesComparacao(CodigoPadraoDTO dto)
{
var registros = _db.Importacao.Where(x => x.Id != dto.Id).OrderByDescending(x => x.Id);
var listImportacao = new List <Importacao>();
foreach (var item in registros)
{
var importacao = new Importacao()
{
Carros = item.Carros,
DataImportacao = item.DataImportacao,
Descricao = item.Descricao,
Id = item.Id,
Observacao = item.Observacao,
TipoImportacao = item.TipoImportacao
};
listImportacao.Add(importacao);
}
return(listImportacao);
}
protected void ButtonImportar_Click(object sender, EventArgs e)
{
//if (FileUploadImportacao.HasFile)
//{
// try
// {
// // executar upload
// string filename = Path.GetFileName(FileUploadImportacao.FileName);
// FileUploadImportacao.SaveAs(Server.MapPath("~/uploads/") + filename);
XmlDocument oDoc = new XmlDocument();
oDoc.Load(Server.MapPath("~/uploads/") + "importacao.xml");
// importar xml
Importacao.Importar(oDoc);
//}
//catch (Exception ex)
//{
// // tratar erro
// throw ex;
//}
//}
}
public Importacao Inserir(Importacao importacao) => _dbSet.Add(importacao).Entity;
protected void Button1_Click(object sender, EventArgs e)
{
if (FileUpload1.HasFile)
{
string FileName = Path.GetFileName(FileUpload1.PostedFile.FileName);
string Extension = Path.GetExtension(FileUpload1.PostedFile.FileName);
string FilePath = Server.MapPath("~/PlanilhasImportadas/" + FileName);
FileUpload1.SaveAs(FilePath);
// DataTable dt = excel_to_dt(FilePath, Extension, "1");
DataTable dt2 = GetDataTableFromExcel(FilePath, true);
// fazer duplo check na tabela temp (conferir se todos tem ids)
// insert em massa na tabela cliente.
// criar lote inserindo na tabela lote.
Importacao ob = new Importacao();
ob.id_responsavel = Convert.ToInt32(id);
string lote = ob.manutencao("gerar_lote");
// tirar os duplicados e inserir na tabela temp.
ImportacaoLista impLista = new ImportacaoLista();
int qtdTotal = dt2.Rows.Count;
int qtdAtual = 0;
int qtd_linha_vazia = 0;
foreach (DataRow dr in dt2.Rows)
{
Importacao imp = new Importacao();
qtdAtual++;
imp.id = null;
string _nb = dr[0].ToString();
imp.nb = dr[0].ToString();
imp.cidade = dr[1].ToString();
imp.requerente = dr[2].ToString();
string strDer = dr[3].ToString();
// LINHAS EM BRANCO 'GetDataTableFromExcel' ESTÁ
// ENTENDO COMO LINHA DE DADOS MAS ESTÁ TOTALMENTE EM BRANCO, NESSE CASO ESTOU PULANDO ESSAS LINHAS...
// SE TODAS A PROP DO OBJ FOREM DIFERENTE DE VAZIO.. ENTÃO VALIDA
if (imp.nb != "" || imp.cidade != "" || imp.requerente != "")
{
//******************************************************
//-------------------
//------------------- VALIDAÇÕES
//-------------------
//******************************************************
bool nb_valido = validaNB(_nb);
if (!nb_valido)
{
ob.manutencao("para_importacao");
string tbl = @"<table id='tbl - result' class='minimalistBlack'>";
tbl += "<tr><td>NB inconsistente: </td><td> " + _nb + "</td></tr></table>";
result_import.Text = tbl;
return;
}
DateTime der;
if (DateTime.TryParse(strDer, out der))
{
imp.der = der;
}
else
{
ob.manutencao("para_importacao");
string tbl = @"<table id='tbl - result' class='minimalistBlack'>";
tbl += "<tr><td>Data inconsistente: </td><td> " + strDer + "</td></tr></table>";
result_import.Text = tbl;
return;
}
imp.lote = Convert.ToInt32(lote);
impLista.Add(imp);
imp.manutencao("inserir");
}
else
{
qtd_linha_vazia++;
if (qtd_linha_vazia > 3)
{
qtd_linha_vazia = 0;
break;
}
}
}
string html = ob.manutencao("segunda_etapa");
result_import.Text = html;
//obj preenchido
}
}
public void IncluirImportacao(Importacao importacao)
{
_contratante.AdicionarImportacao(importacao);
}
public async Task <IActionResult> Insert(IFormFile file)
{
if (file == null || file.Length == 0)
{
return(RedirectToAction(""));
}
using (var memoryStream = new MemoryStream())
{
await file.CopyToAsync(memoryStream).ConfigureAwait(false);
using (var package = new ExcelPackage(memoryStream))
{
try
{
for (int i = 1; i <= package.Workbook.Worksheets.Count; i++)
{
var totalRows = package.Workbook.Worksheets[i].Dimension?.Rows;
var totalCollumns = package.Workbook.Worksheets[i].Dimension?.Columns;
for (int j = 2; j <= totalRows.Value; j++)
{
DateTime dataEntrega;
if (DateTime.TryParse(package.Workbook.Worksheets[i].Cells[j, 1].Value.ToString(), out dataEntrega))
{
if (dataEntrega < DateTime.Today)
{
throw new Exception("Data inválida menor que a atual: " + dataEntrega.ToString("dd/MM/yyyy"));
}
}
else
{
throw new Exception("Data inválida: " + package.Workbook.Worksheets[i].Cells[j, 1].Value.ToString());
}
if (package.Workbook.Worksheets[i].Cells[j, 2].Value.ToString().Trim().Length > 50)
{
throw new Exception("Quantidade de caracteres do campo Descrição maior que 50");
}
if (Convert.ToInt32(package.Workbook.Worksheets[i].Cells[j, 3].Value.ToString()) < 0)
{
throw new Exception("O campo Quantidade deve ser maior que zeros");
}
if (Convert.ToDecimal(package.Workbook.Worksheets[i].Cells[j, 4].Value.ToString()) < 0)
{
throw new Exception("O campo Valor Unitário deve ser maior que zeros");
}
}
for (int j = 2; j <= totalRows.Value; j++)
{
importacao = new Importacao();
importacao.DataEntrega = Convert.ToDateTime(package.Workbook.Worksheets[i].Cells[j, 1].Value.ToString());
importacao.NomeProduto = package.Workbook.Worksheets[i].Cells[j, 2].Value.ToString().Trim();
importacao.Quantidade = Convert.ToInt32(package.Workbook.Worksheets[i].Cells[j, 3].Value.ToString());
importacao.ValorUnitario = Math.Round(Convert.ToDecimal(package.Workbook.Worksheets[i].Cells[j, 4].Value.ToString()), 2);
service.Post <ImportacaoValidator>(importacao);
}
}
}
catch (Exception ex)
{
throw new Exception("Erro ao importar tabela: " + ex.Message);
}
return(Content(importacao.NomeProduto));
}
}
}
public async Task <dynamic> ImportarExcel(IFormFile file)
{
if (file == null || file.Length == 0)
{
throw new Exception("Arquivo não encontrado");
}
var _listaErros = new List <string> {
};
using (var memoryStream = new MemoryStream())
{
await file.CopyToAsync(memoryStream).ConfigureAwait(false);
using (var package = new ExcelPackage(memoryStream))
{
for (int i = 1; i <= package.Workbook.Worksheets.Count; i++)
{
var totalRows = package.Workbook.Worksheets[i].Dimension?.Rows;
var totalCollumns = package.Workbook.Worksheets[i].Dimension?.Columns;
if (totalRows == 1)
{
_listaErros.Add("O Arquivo está vazio, preencha para continuar");
}
using (var context = this._context)
{
for (int row = 2; row <= totalRows.Value; row++)
{
Importacao importacao = new Importacao();
for (int col = 1; col <= totalCollumns.Value; col++)
{
var infoLogDefault = $"(ln:{row}; col:{col}) ";
var valueField = package.Workbook.Worksheets[i].Cells[row, col].Text.ToString();
if (string.IsNullOrEmpty(valueField))
{
_listaErros.Add(infoLogDefault + "Campo sem valor (Preencha todos os campos)");
return(_listaErros.ToArray());
}
if (col == 1)
{
var dateFieldString = package.Workbook.Worksheets[i].Cells[row, col].Text.ToString();
DateTime dateField = Convert.ToDateTime(dateFieldString);
DateTime currentDate = DateTime.Now;
if (dateField <= currentDate)
{
_listaErros.Add(infoLogDefault + "campo data de entrega não pode ser menor ou igual que o dia atual.");
}
importacao.DataEntrega = dateField;
}
if (col == 2)
{
var description = package.Workbook.Worksheets[i].Cells[row, col].Text.ToString();
if (description.Length > 50)
{
_listaErros.Add(infoLogDefault + "Campo descrição deve ter no máximo de 50 caráteres. ");
}
importacao.NomeProduto = description;
}
if (col == 3)
{
var quantity = int.Parse(package.Workbook.Worksheets[i].Cells[row, col].Text);
if (quantity <= 0)
{
_listaErros.Add(infoLogDefault + "Campo quantidade tem que ser maior que zero. ");
}
importacao.Quantidade = quantity;
}
if (col == 4)
{
var value = decimal.Parse(package.Workbook.Worksheets[i].Cells[row, col].Text);
value = Decimal.Round(value, 2);
if (value <= 0)
{
_listaErros.Add(infoLogDefault + "Campo valor unitário deve ser maior que zero");
}
importacao.ValorUnitario = value;
}
}
try
{
context.Importacao.Add(importacao);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
if (_listaErros.ToArray().Length == 0)
{
await context.SaveChangesAsync();
}
}
}
}
}
return(_listaErros.ToArray());
}
public FichaPreCadastro(Importacao compartilhamento)
{
Importacao = compartilhamento;
}