public async Task <Object []> EliminarTipoArchivo(int id_tipo_archivo)
{
Object [] response = new Object [2];
try {
TipoArchivo fileTypeToDelete = await AppDbContext.tiposArchivo.Where(ta =>
ta.id_tipo_archivo == id_tipo_archivo).FirstOrDefaultAsync();
List <Descarga> descargas = await AppDbContext.descargas.Where(d =>
d.id_tipo_archivo == fileTypeToDelete.id_tipo_archivo).ToListAsync();
foreach (Descarga descarga in descargas)
{
await EliminarDescarga(descarga.id_descarga);
}
AppDbContext.tiposArchivo.Remove(fileTypeToDelete);
await AppDbContext.SaveChangesAsync();
response[0] = true;
}
catch (Exception exception) {
response[1] = (exception.InnerException != null) ?
exception.InnerException.Message : exception.Message;
}
return(response);
}
protected void btnGuardarDatos_Click(object sender, EventArgs e)
{
if (ValidarDatos())
{
TipoArchivo tipoArchivo = App.TipoArchivo;
tipoArchivo.IdTipoArchivo = App.Consultas.ObtieneTipoArchivoNumeroMaximo() + 1;
tipoArchivo.Descripcion = this.txtDescripcion.Text;
tipoArchivo.FormatoFecha = this.txtFormatoFecha.Text;
tipoArchivo.FormatoMoneda = this.txtFormatoMoneda.Text;
tipoArchivo.Separador = this.cboSeparador.SelectedValue.ToString();
tipoArchivo.Usuario = ((SeguridadCB.Public.Usuario)HttpContext.Current.Session["Usuario"]).IdUsuario;
tipoArchivo.Status = "ACTIVO";
tipoArchivo.FAlta = DateTime.Now;
if (tipoArchivo.Guardar())
{
this.grvTipoArchivo.DataSource = App.Consultas.ObtieneListaTipoArchivo();
this.grvTipoArchivo.DataBind();
Limpiar();
}
}
else
{
//ScriptManager.RegisterStartupScript(this.uppPrincipal,
// uppPrincipal.GetType(),
// Guid.NewGuid().ToString(),
// "alert('" + LimpiarTexto(mensaje.ToString()) + "')",
// true);
ScriptManager.RegisterStartupScript(this, this.GetType(), Guid.NewGuid().ToString(), "alert('" + LimpiarTexto(mensaje.ToString()) + "')", true);
}
}
public bool transferirInterfaceContable(EXACTUS_CABECERA_SIS contrato, TipoArchivo tipoArchivo)
{
var exactusCabecera = new dInterfaceContable().getExactusCabecera(contrato, tipoArchivo);
var interfaceContable = new dInterfaceContable();
var response = true;
try
{
foreach (var item in exactusCabecera)
{
if (interfaceContable.createCabeceraInRemoteExactus(item))
{
interfaceContable.createDetalleInRemote(item);
interfaceContable.actualizarEstadoTransferido(item);
}
else
{
response = false;
break;
}
}
return(response);
}
catch (Exception ex)
{
throw(new Exception(ex.Message));
}
}
public TipoArchivoValidacion(TipoArchivo grupoTipoArchivo)
{
if (grupoTipoArchivo == TipoArchivo.Imagen)
{
tipoValidos = new string[] { "image/jpeg", "image/png", "image/gif" };
}
}
private string ObtenerXslPorTipoArchivo(TipoArchivo tipodoc)
{
switch (tipodoc)
{
case TipoArchivo.FAC:
return("sunat_archivos/sfs/VALI/commons/xsl/validation/2.X/ValidaExprRegFactura-2.0.1.xsl");
case TipoArchivo.RES:
return("sunat_archivos/sfs/VALI/commons/xsl/validation/2.X/ValidaExprRegSummary-1.1.0.xsl");
case TipoArchivo.NCR:
return("sunat_archivos/sfs/VALI/commons/xsl/validation/2.X/ValidaExprRegNC-2.0.1.xsl");
case TipoArchivo.NDB:
return("sunat_archivos/sfs/VALI/commons/xsl/validation/2.X/ValidaExprRegND-2.0.1.xsl");
case TipoArchivo.GRM:
return("sunat_archivos/sfs/VALI/commons/xsl/validation/2.X/ValidaExprRegGuiaRemitente-2.0.1.xsl");
case TipoArchivo.RET:
return("sunat_archivos/sfs/VALI/commons/xsl/validation/1.X/ValidaExprRegRetencion-1.0.3.xsl");
}
return(null);
}
//Si solo se da el nombre, se supone que es la base de datos en Access
public Tabla(string Nombre)
{
_Nombre = Nombre;
Tipo = "Tabla";
_tipoArchivo = TipoArchivo.BD;
LeerDeBaseDeDatos();
Modelo.Agregar(this);
}
public Tabla(string Nombre, string Archivo, TipoArchivo tipoarch)
{
_Nombre = Nombre;
Tipo = "Aux";
_tipoArchivo = tipoarch;
LeerDeArchivo(Archivo);
Modelo.Agregar(this);
}
public Archivo(string nombre, bool protegido, string direccion, string usuario, string contenido, TipoArchivo tipo)
{
this.nombre = nombre;
this.protegido = protegido;
this.direccion = direccion;
this.usuario = usuario;
this.contenido = contenido;
this.tipo = tipo;
}
protected void cboTipoArchivo_SelectedIndexChanged(object sender, EventArgs e)
{
//if (cboTipoArchivo.)
//{
TipoArchivo ta = App.Consultas.ObtieneTipoArchivoPorId(Convert.ToInt32(cboTipoArchivo.SelectedValue.ToString()));
this.txtDescripcionTipoArchivo.Text = GenerarDescripcionTipoArchivo(ta);
//}
}
public static bool ExisteArchivo(TipoArchivo tipo, string archivo)
{
string firma = Lib.Security.Cryptography.CalcularMD5(archivo);
using (var db = new SMPorresEntities())
{
return(db.CabecerasArchivos.Any(ca => ca.Hash == firma));
}
}
/// <summary>
/// Permite la consulta de los ajustes existentes en la base de datos
/// </summary>
/// <param name="objEntidad">Entidad que contienen los datos a llenar en los parametros del procedimiento almacenado</param>
/// <returns>Lista de datos</returns>
public List <TipoArchivo> consultar(TipoArchivo objEntidad)
{
TipoArchivoAD objConsultor = new TipoArchivoAD();
List <TipoArchivo> lista = new List <TipoArchivo>();
lista = objConsultor.consultar(objEntidad);
Error = objConsultor.Error;
return(lista);
}
public async Task <TipoArchivo> ObtenerPorTipo(TiposArchivo tipo)
{
int idTipoArchivo = (int)tipo;
TipoArchivo tipoArchivo = await _contexto.TiposArchivo
.Where(tipoArchivo => tipoArchivo.Id == idTipoArchivo)
.FirstOrDefaultAsync();
return(tipoArchivo);
}
private string GenerarDescripcionTipoArchivo(TipoArchivo ta)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("Descripcion: \"" + ta.Descripcion + "\"");
sb.AppendLine("Formato Fecha: \"" + ta.FormatoFecha + "\"");
sb.AppendLine("Formato Moneda: \"" + ta.FormatoMoneda + "\"");
sb.AppendLine("Separador: \"" + ta.Separador + "\"");
return(sb.ToString());
}
/// <summary>
/// Permite operar un registro especifico
/// </summary>
/// <param name="objEntidad">Datos del registro a operar</param>
/// <returns>Registros afectados</returns>
public int actualizar(TipoArchivo objEntidad)
{
objEntidad.pOperacion = TiposConsultas.ACTUALIZAR;
int cuenta = -1;
TipoArchivoAD objConsultor = new TipoArchivoAD();
cuenta = objConsultor.ejecutarNoConsulta(objEntidad);
Error = objConsultor.Error;
return(cuenta);
}
/// <summary>
/// Esta funcion es la encargada de llenar los datos y ejecutar un procedimiento almacenado
/// </summary>
/// <param name="objEntidad">Entidad que contienen los datos a llenar en los parametros del procedimiento almacenado</param>
/// <returns>Conjuntos de datos de respuesta de la ejecución del procedimiento almacenado</returns>
protected DataSet ejecutarConsulta(TipoArchivo objEntidad)
{
ConectorBD objConexionDB = ConectorBD.obtenerInstancia();
SqlDataAdapter adaptador;
DataSet datos = null;
SqlConnection conexion = null;
try
{
conexion = objConexionDB.abrirConexion();
Error = conexion.State.ToString();
adaptador = new SqlDataAdapter("pa_Ban_Tipo_Archivo", conexion);
adaptador.SelectCommand.CommandType = CommandType.StoredProcedure;
adaptador.SelectCommand.Parameters.Add(new SqlParameter("@pOperacion", SqlDbType.VarChar));
adaptador.SelectCommand.Parameters["@pOperacion"].Value = objEntidad.pOperacion;
adaptador.SelectCommand.Parameters.Add(new SqlParameter("@pOid", SqlDbType.VarChar));
if (!String.IsNullOrEmpty(objEntidad.pOid))
{
adaptador.SelectCommand.Parameters["@pOid"].Value = objEntidad.pOid;
}
else
{
adaptador.SelectCommand.Parameters["@pOid"].Value = DBNull.Value;
}
adaptador.SelectCommand.Parameters.Add(new SqlParameter("@pNombre", SqlDbType.VarChar));
if (!String.IsNullOrEmpty(objEntidad.pNombre))
{
adaptador.SelectCommand.Parameters["@pNombre"].Value = objEntidad.pNombre;
}
else
{
adaptador.SelectCommand.Parameters["@pNombre"].Value = DBNull.Value;
}
datos = new DataSet();
adaptador.Fill(datos, "tabla");
adaptador.Dispose();
}
catch (SqlException ex)
{
Error = ex.Message;
Registrador.Error(ex.Message);
}
finally
{
if (conexion.State != ConnectionState.Closed)
{
conexion.Close();
}
}
return(datos);
}
public static string CrearUrlArchivo(TipoArchivo tipoArchivo, int codigoArchivo)
{
string urlArchivo = string.Empty;
if (tipoArchivo != TipoArchivo.SinTipoArchivo && codigoArchivo > 0)
{
urlArchivo = URL.UrlBase + "Archivos/BuscarArchivo/" + codigoArchivo + "/" + (int)tipoArchivo;
}
return(urlArchivo);
}
public ActionResult ValidarCPE([Required] TipoArchivo tipodoc, [Required] string nombrearchivo, [Required] byte[] archivo)
{
try
{
var resp = Validar(tipodoc, nombrearchivo, archivo);
return(Ok(resp));
}
catch (Exception e)
{
throw e;
}
}
public static CabeceraArchivo Insertar(SMPorresEntities db, TipoArchivo tipo, string archivo)
{
var ca = new CabeceraArchivo();
ca.Id = db.CabecerasArchivos.Any() ? db.CabecerasArchivos.Max(t => t.Id) + 1 : 1;
ca.IdTipoArchivo = (int)tipo;
ca.NombreArchivo = System.IO.Path.GetFileName(archivo);
ca.IdUsuario = Lib.Session.CurrentUser.Id;
ca.Hash = Lib.Security.Cryptography.CalcularMD5(archivo);
ca.Fecha = Lib.Configuration.CurrentDate;
db.CabecerasArchivos.Add(ca);
return(ca);
}
/// <summary>
/// Permite operar un registro especifico
/// </summary>
/// <param name="objEntidad">Datos del registro a operar</param>
/// <returns>Registros afectados</returns>
public int ejecutarNoConsulta(TipoArchivo objEntidad)
{
int cuenta = -1;
DataSet datos = ejecutarConsulta(objEntidad);
try
{
cuenta = Convertidor.aEntero32(datos.Tables["tabla"].Rows[0]["Cuenta"]);
}
catch (Exception ex)
{
Registrador.Warn(ex.Message);
}
return(cuenta);
}
protected void btnDelete_Click(object sender, ImageClickEventArgs e)
{
ImageButton imgButton = (sender as ImageButton);
GridViewRow row = imgButton.Parent.Parent as GridViewRow;
Label lblReferencia = (Label)row.FindControl("lblGVIdTipoArchivo");
TipoArchivo tipoArchivo = App.Consultas.ObtieneTipoArchivoPorId(Convert.ToInt32(lblReferencia.Text.Trim()));
tipoArchivo.Status = "INACTIVO";
if (tipoArchivo.Actualizar())
{
this.grvTipoArchivo.DataSource = App.Consultas.ObtieneListaTipoArchivo();
this.grvTipoArchivo.DataBind();
Limpiar();
}
}
public string ValidarTipoArchivo(TipoArchivo tipo)
{
string tipoArchivo = string.Empty;
switch (tipo)
{
case TipoArchivo.Txt:
tipoArchivo = "txt";
break;
case TipoArchivo.Json:
tipoArchivo = "Json";
break;
}
return(tipoArchivo);
}
public string BuscarArchivo(string nombreArchivo, TipoArchivo tipo)
{
string extecion = _validadorTipoArchivo.ValidarTipoArchivo(tipo);
string archivo;
if (string.IsNullOrWhiteSpace(nombreArchivo))
{
archivo = Path.GetFullPath("Eventos" + "." + extecion);
}
else
{
archivo = Path.GetFullPath(nombreArchivo + "." + extecion);
}
return(archivo);
}
public async Task <Object []> CrearTipoArchivo(TipoArchivo tipoArchivo)
{
Object [] response = new Object [2];
try {
await AppDbContext.tiposArchivo.AddAsync(tipoArchivo);
await AppDbContext.SaveChangesAsync();
response[0] = true;
}
catch (Exception exception) {
response[1] = (exception.InnerException != null) ?
exception.InnerException.Message : exception.Message;
}
return(response);
}
public void AsignarTipoFormato(TipoArchivo tipoArchivo)
{
switch (tipoArchivo)
{
case TipoArchivo.BMP:
_aplicarFormato = new FormatoBMP();
break;
case TipoArchivo.JPGE:
_aplicarFormato = new FormatoJPGE();
break;
case TipoArchivo.PNG:
_aplicarFormato = new FormatoPNG();
break;
}
}
/// <summary>
/// Permite la consulta de los ajustes existentes en la base de datos
/// </summary>
/// <param name="objEntidad">Entidad que contienen los datos a llenar en los parametros del procedimiento almacenado</param>
/// <returns>Lista de datos</returns>
public List <TipoArchivo> consultar(TipoArchivo objEntidad)
{
objEntidad.pOperacion = TiposConsultas.CONSULTAR;
DataSet datos = ejecutarConsulta(objEntidad);
List <TipoArchivo> lista = new List <TipoArchivo>();
TipoArchivo objEntidad2 = null;
foreach (DataRow fila in datos.Tables["tabla"].Rows)
{
objEntidad2 = new TipoArchivo();
objEntidad2.pOid = Convertidor.aCadena(fila[TipoArchivoDEF.Oid]);
objEntidad2.pNombre = Convertidor.aCadena(fila[TipoArchivoDEF.Nombre]);
lista.Add(objEntidad2);
}
return(lista);
}
public async Task <Object []> ActualizarTipoArchivo(TipoArchivo tipoArchivo)
{
Object [] response = new Object [2];
try {
TipoArchivo fileTypeToUpdate = await AppDbContext.tiposArchivo.Where(ta =>
ta.id_tipo_archivo == tipoArchivo.id_tipo_archivo).FirstOrDefaultAsync();
fileTypeToUpdate.nombre_tipo_archivo = tipoArchivo.nombre_tipo_archivo;
AppDbContext.tiposArchivo.Update(fileTypeToUpdate);
await AppDbContext.SaveChangesAsync();
response[0] = true;
}
catch (Exception exception) {
response[1] = (exception.InnerException != null) ?
exception.InnerException.Message : exception.Message;
}
return(response);
}
public async Task <ActionResult> Subir([FromForm] ArchivoVm documentacionVm)
{
if (documentacionVm.Descripcion is null || documentacionVm.Descripcion.Length == 0)
{
return(StatusCode(500, "La descripción está vacía"));
}
if (documentacionVm.Archivo is null)
{
return(StatusCode(500, "No se ha seleccionado ningún archivo"));
}
Siniestro siniestro = await _repositorioSiniestros.ObtenerPorId(documentacionVm.IdSiniestro);
string rutaPdf = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot/documentacion", documentacionVm.Archivo.FileName);
rutaPdf = rutaPdf.Replace("\\", "/");
TipoArchivo tipoArchivo = await _repositorioTiposArchivos.ObtenerPorTipo(TiposArchivo.Documentacion);
Archivo documentacion = new Archivo()
{
Descripcion = documentacionVm.Descripcion,
Siniestro = siniestro,
UrlArchivo = rutaPdf,
TipoArchivo = tipoArchivo
};
using (var stream = System.IO.File.Create(rutaPdf))
await documentacionVm.Archivo.CopyToAsync(stream);
try
{
await _repositorioDocumentaciones.Guardar(documentacion);
}
catch (Exception)
{
return(StatusCode(500, "Ha habido un error al crear la documentación"));
}
return(Ok(true));
}
public static string NombreArchivo(TipoArchivo Tipo)
{
var Archivo = "";
switch (Tipo)
{
case TipoArchivo.Auditoria:
Archivo = "Auditoria_" + DateTime.Now.ToString().Replace("/", "").Replace("-", "").Replace(":", "").Replace(" ", "");
break;
case TipoArchivo.Reporte:
Archivo = "Reporte" + DateTime.Now.ToString().Replace("/", "").Replace("-", "").Replace(":", "").Replace(" ", "");
break;
default:
Archivo = "Archivo" + DateTime.Now.ToString().Replace("/", "").Replace("-", "").Replace(":", "").Replace(" ", "");
break;
}
return(Archivo);
}
public IEnumerable <T> Leer(TipoArchivo tipoArchivo)
{
ILecturaStrategy <T> lector = null;
switch (tipoArchivo)
{
case TipoArchivo.Excel:
lector = new LecturaExcel <T>();
break;
case TipoArchivo.Txt:
lector = new LecturaTxt <T>();
break;
default:
break;
}
return(lector.LeerArchivo(_archivo));
}
public ActionResult ValidarCPEIntegracion([Required] TipoArchivo tipodoc, [Required] string nombrearchivo, [Required] byte[] archivo)
{
try
{
var validar = _configuration[$"OpcionesIntegracion:{tipodoc}"] == "1";
if (validar)
{
var resp = Validar(tipodoc, nombrearchivo, archivo);
return(Ok(resp));
}
return(Ok(new ResponseValidation
{
Success = true
}));
}
catch (Exception e)
{
throw e;
}
}
