public ArquivoModel SelecionarPorId(ArquivoModel entidade)
{
try
{
ArquivoModel entidadeRet = null;
SqlDataReader reader = null;
string[] parameters = { COLUNA_ID };
object[] values = { entidade.Id };
reader = _context.ExecuteProcedureWithReturn(PROCEDURE_SELECIONAR_ID, parameters, values);
if (reader.Read())
{
entidadeRet = ReaderEmObjeto(reader);
}
reader.Close();
return(entidadeRet);
}
catch (Exception ex)
{
throw new Exception("Classe: ArquivoRep, Metodo: ListarTodos Mensagem: " + ex.Message, ex);
}
}
public ActionResult Adicionar(ArquivoViewModel viewModel)
{
try
{
var entidade = _entidadeBusiness.SelecionarPorLogin(User.Identity.Name);
foreach (var file in viewModel.Files)
{
if (file.ContentLength > 0)
{
ArquivoModel arq = new ArquivoModel();
arq.Titulo = Path.GetFileNameWithoutExtension(file.FileName);
arq.Tipo = Path.GetExtension(file.FileName);
arq.Id = _arqEntBusiness.DefinirProximoId();
arq.Caminho = Path.Combine(Server.MapPath(ArquivoViewModel.CaminhoUpload), arq.Id + arq.Tipo);
arq.Descricao = viewModel.Descricao;
_arqEntBusiness.InserirArquivo(arq, entidade.Id);
file.SaveAs(arq.Caminho);
}
}
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
ViewBag.Mensagem = "Erro ao subir imagens";
return(View(viewModel));
}
}
public async Task <ActionResult <ArquivoModel> > PostArquivo(ArquivoModel item)
{
_context.Arquivos.Add(item);
await _context.SaveChangesAsync();
return(CreatedAtAction(nameof(GetArquivo), new { id = item.Id }, item));
}
public List <ArquivoModel> GetArquivosFisico()
{
string localOrigem = @"C:\Users\Douglas\Desktop\Versionamento\PacoteVersao";
string localDestino = @"C:\Users\Douglas\Desktop\Versionamento\Dev";
//List<string> arquivosOrigem = Directory.GetFiles(localOrigem).ToList();
List <string> arquivosDestino = Directory.GetFiles(localDestino).ToList();
List <ArquivoModel> arquivoList = new List <ArquivoModel>();
ComparadorService comparador = new ComparadorService();
foreach (string arquivo in arquivosDestino)
{
ArquivoModel arquivoModel = new ArquivoModel();
//arquivoModel.Id=1;
arquivoModel.Nome = arquivo;
arquivoModel.Tamanho = this.GetArquivoTamanho(arquivo);
arquivoModel.DateCreate = this.GetArquivoDateCreate(arquivo);
arquivoModel.DateUpdate = this.GetArquivoDateUpdate(arquivo);
if (this.isExistArquivo(arquivo, localOrigem) != null)
{
arquivoModel.Status = comparador.isEquals(arquivo, this.isExistArquivo(arquivo, localOrigem));
}
else
{
arquivoModel.Status = false;
}
arquivoList.Add(arquivoModel);
}
return(arquivoList);
}
public async Task <IActionResult> Post(ArquivoModel entity)
{
//ArquivoModel arquivoModel = new ArquivoModel()
//{
// Descricao = entity.Descricao
//};
return(Ok(await _context.AddAsync(entity)));
}
public ActionResult RestaurarBackup(ArquivoModel model)
{
//Se não tiver login, encaminhar para a tela de login
if (string.IsNullOrWhiteSpace(SessaoUsuario.SessaoLogin.Identificacao))
{
return(RedirectToAction("Login", "Usuario"));
}
if (!SessaoUsuario.SessaoLogin.Administrador)
{
ViewBag.MensagemErro = "Para restaurar um backup é necessário " +
$"logar com um usuário administrador.";
return(View("SemPermissao"));
}
//Validar a model recebida
if (!ModelState.IsValid)
{
return(View(model));
}
//Converter para DTO
RequisicaoArquivoDto requisicaoDto = new RequisicaoArquivoDto
{
Identificacao = SessaoUsuario.SessaoLogin.Identificacao,
IdUsuario = SessaoUsuario.SessaoLogin.IdUsuario
};
string mensagemErro = "";
if (!model.ConverterModelParaDto(ref requisicaoDto, ref mensagemErro))
{
ModelState.AddModelError("", $"Erro ao converter para Dto: {mensagemErro}");
return(View(model));
}
//Preparar requisição e retorno
RetornoDto retorno = new RetornoDto();
//Consumir o serviço
RecursosBdBll recursosBll = new RecursosBdBll();
recursosBll.RestaurarBackup(requisicaoDto, ref retorno);
//Verificar o retorno
if (retorno.Retorno == false)
{
//Se houver erro, exibir na tela de inclusão
ModelState.AddModelError("", retorno.Mensagem);
return(View(model));
}
TempData["Retorno"] = "BACKUPRESTAURADO";
//Retornar para inicio
return(RedirectToAction("Inicio", "Usuario"));
}
public HttpResponseMessage Executar([FromBody] ArquivoModel arquivo)
{
var caminho = System.Web.Hosting.HostingEnvironment.ApplicationPhysicalPath;
Minificador.Executar(new string[] {
"/o=" + Path.Combine(caminho, arquivo.Origem),
"/d=" + Path.Combine(caminho, arquivo.Destino)
});
return(new HttpResponseMessage(HttpStatusCode.OK));
}
private ArquivoModel ReaderEmObjeto(SqlDataReader reader)
{
var entidade = new ArquivoModel();
entidade.Id = Convert.ToInt32(reader[COLUNA_ID]);
entidade.Titulo = reader[COLUNA_TITULO].ToString();
entidade.Descricao = reader[COLUNA_DESCRICAO].ToString();
entidade.Caminho = reader[COLUNA_CAMINHO].ToString();
entidade.Tipo = reader[COLUNA_TIPO].ToString();
return(entidade);
}
public async Task <IActionResult> PutArquivo(long id, ArquivoModel item)
{
if (id != item.Id)
{
return(BadRequest());
}
_context.Entry(item).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(NoContent());
}
public void InserirArquivo(ArquivoModel entidade, int entidadeId)
{
try
{
using (UnitOfWorkAdo unit = new UnitOfWorkAdo(_connectionString))
{
unit.ArquivosVoluntarios.Inserir(entidade, entidadeId);
}
}
catch (Exception ex)
{
throw ex;
}
}
public HttpResponseMessage Executar([FromBody] ArquivoModel arquivo)
{
if (arquivo.Origem == "origem")
{
Console.WriteLine("É igual");
MessageBox.Show("É igual");
}
else
{
//Console.WriteLine();
MessageBox.Show("É Diferente");
}
return(new HttpResponseMessage(HttpStatusCode.OK));
}
public ArquivoModel SelecionarArquivoPorId(int projetoId)
{
try
{
using (UnitOfWorkAdo unit = new UnitOfWorkAdo(_connectionString))
{
ArquivoModel entidade = new ArquivoModel();
entidade.Id = projetoId;
return(unit.ArquivosVoluntarios.SelecionarPorId(entidade));
}
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Restaura um backup
/// </summary>
/// <returns></returns>
public ActionResult RestaurarBackup()
{
// Se não tiver login, encaminhar para a tela de login
if (string.IsNullOrWhiteSpace(SessaoUsuario.SessaoLogin.Identificacao))
{
return(RedirectToAction("Login", "Usuario"));
}
if (!SessaoUsuario.SessaoLogin.Administrador)
{
ViewBag.MensagemErro = "Para restaurar um backup é necessário " +
$"logar com um usuário administrador.";
return(View("SemPermissao"));
}
ArquivoModel model = new ArquivoModel();
return(View(model));
}
public void Inserir(ArquivoModel entidade, int entidadeId)
{
try
{
string[] parameters =
{
COLUNA_TITULO, COLUNA_DESCRICAO, COLUNA_CAMINHO, COLUNA_VOLUNTARIO_ID, COLUNA_TIPO, COLUNA_ID
};
object[] values =
{
entidade.Titulo, entidade.Descricao, entidade.Caminho, entidadeId, entidade.Tipo, entidade.Id
};
_context.ExecuteProcedureNoReturn(PROCEDURE_SALVAR, parameters, values);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Import OFX Files with merge
/// </summary>
/// <param name="OfxFiles"></param>
/// <returns></returns>
public List <Transaction> ImportWithMerge(List <string> OfxFiles)
{
var transacoes = new List <Transaction>();
if (OfxFiles.Count > 0)
{
foreach (var item in OfxFiles)
{
string[] lines = System.IO.File.ReadAllLines(item);
ArquivoModel ofx = this._parseOFXContent.ToObject <ArquivoModel>(lines);
Guid identificacaoArquivo = Guid.NewGuid();
foreach (var current in ofx.STMTTRN)
{
var currentMapped = Mapper.Map <TransactionViewModel, Transaction>(current);
var qtdLocal = transacoes.Where(x => x.Date == currentMapped.Date && x.Name == currentMapped.Name && x.Type == currentMapped.Type && x.Amount == currentMapped.Amount && x.IdFile != identificacaoArquivo.ToString()).Count();
var qtd = _extratoRepository.GetAll().Where(x => x.Date == currentMapped.Date && x.Name == currentMapped.Name && x.Type == currentMapped.Type && x.Amount == currentMapped.Amount && x.IdFile != identificacaoArquivo.ToString()).Count();
// Save only data that is not repeated in files
if (qtd == 0 && qtdLocal == 0)
{
currentMapped.IdFile = identificacaoArquivo.ToString();
transacoes.Add(currentMapped);
this._extratoRepository.Add(currentMapped);
}
}
}
}
this._extratoRepository.Save();
return(transacoes);
}
public ActionResult ValidaArquivoCEF(ArquivoModel model)
{
try
{
int quantArq = Request.Files.Count;
for (int i = 0; i < quantArq; i++)
{
model.Arquivo = Request.Files[i];
model.Nome = Request.Files[i].FileName;
}
ValidaArquivoCAIXA valida = new ValidaArquivoCAIXA();
if (model.Tipo.Equals("REM"))
{
model.Validacao += valida.lerRemessaCnab240(model.Arquivo.InputStream);
}
if (model.Tipo.Equals("RET"))
{
model.Validacao += valida.lerRemessaCnab240(model.Arquivo.InputStream);
}
model.Data = DateTime.Now;
var repo = new ArquivoRepositorio();
repo.Add(new Arquivo {
Data = model.Data, Nome = model.Nome, Tipo = model.Tipo, Validacao = model.Validacao.Substring(0, 40), Responsavel = User.Identity.Name
});
TempData["TextoValidacao"] = model.Validacao;
return(View("Index", model));
}
catch (Exception erro)
{
throw erro;
}
}
public FileResult Download(int id)
{
try
{
string contentType = "";
ArquivoModel arquivo = _arqEntBusiness.SelecionarArquivoPorId(id);
if (".pdf".Equals(arquivo.Tipo))
{
contentType = "application/pdf";
}
if (".jpg".Equals(arquivo.Tipo) || ".gif".Equals(arquivo.Tipo) || ".png".Equals(arquivo.Tipo))
{
contentType = "application/image";
}
return(File(Path.Combine(Server.MapPath(ArquivoViewModel.CaminhoUpload), arquivo.Id + arquivo.Tipo), contentType,
arquivo.Titulo + arquivo.Tipo));
}
catch (Exception)
{
return(null);
}
}
public async Task <IActionResult> Post(ArquivoModel entity)
{
return(Ok(await _context.AddAsync(entity)));
}
