public Response Crear(TipoCertificado tipoCertificado)
{
try
{
var respuesta = Existe(tipoCertificado);
if (!respuesta.IsSuccess)
{
tipoCertificado.Nombre = tipoCertificado.Nombre.TrimStart().TrimEnd().ToUpper();
tipoCertificado.Descripcion = tipoCertificado.Descripcion.TrimStart().TrimEnd().ToUpper();
db.Add(tipoCertificado);
db.SaveChanges();
return(new Response
{
IsSuccess = true,
Message = "Ok",
});
}
else
{
return(new Response
{
IsSuccess = false,
Message = "Existe un tipo de certificado con igual nombre...",
});
}
}
catch (Exception ex)
{
return(new Response
{
IsSuccess = false,
Message = ex.Message,
});
}
}
public Response Editar(TipoCertificado tipoCertificado)
{
try
{
var respuestaTipoCertificado = db.TipoCertificado.Where(x => x.IdTipoCertificado == tipoCertificado.IdTipoCertificado).FirstOrDefault();
if (tipoCertificado.Nombre == respuestaTipoCertificado.Nombre && tipoCertificado.Descripcion == respuestaTipoCertificado.Descripcion)
{
return(new Response
{
IsSuccess = true,
Message = "ok",
});
}
if (tipoCertificado.Nombre.ToUpper().TrimStart().TrimEnd() == respuestaTipoCertificado.Nombre.ToUpper().TrimStart().TrimEnd())
{
respuestaTipoCertificado.Descripcion = tipoCertificado.Descripcion;
db.TipoCertificado.Update(respuestaTipoCertificado);
db.SaveChanges();
return(new Response
{
IsSuccess = true,
Message = "Ok",
Resultado = tipoCertificado,
});
}
var respuesta = Existe(tipoCertificado);
if (respuesta.IsSuccess)
{
return(new Response
{
IsSuccess = false,
Message = "Existe un tipo de certificado con igual nombre",
});
}
respuestaTipoCertificado.Nombre = tipoCertificado.Nombre;
respuestaTipoCertificado.Descripcion = tipoCertificado.Descripcion;
db.TipoCertificado.Update(respuestaTipoCertificado);
db.SaveChanges();
return(new Response
{
IsSuccess = true,
Message = "Ok...",
});
}
catch (Exception ex)
{
return(new Response
{
IsSuccess = false,
Message = ex.Message,
});
}
}
private async Task Actualizar(TipoCertificado TipoCertificado)
{
var tipocertificado = db.TipoCertificado.Find(TipoCertificado.IdTipoCertificado);
tipocertificado.Nombre = TipoCertificado.Nombre;
tipocertificado.Descripcion = TipoCertificado.Descripcion;
db.TipoCertificado.Update(tipocertificado);
await db.SaveChangesAsync();
}
/// <summary>
/// Realiza la edición de los datos de un certificado
/// </summary>
/// <param name="id_emisor">Id de Emisor</param>
/// <param name="id_sucursal">Id de Sucursar</param>
/// <param name="tipo_certificado">Tipo de Certificado</param>
/// <param name="estatus">Estatus</param>
/// <param name="contrasena">Contraseña de apertura del certificado</param>
/// <param name="iv_contrasena"></param>
/// <param name="key_contrasena"></param>
/// <param name="contrasena_revocacion">Contraseña de revocación del certificado</param>
/// <param name="iv_contrasena_revocacion"></param>
/// <param name="key_contrasena_revocacion"></param>
/// <param name="id_usuario">Id de usuario</param>
/// <returns></returns>
public RetornoOperacion EditaCertificado(int id_emisor, int id_sucursal, TipoCertificado tipo_certificado,
Estatus estatus, string contrasena, string iv_contrasena, string key_contrasena, string contrasena_revocacion, string iv_contrasena_revocacion, string key_contrasena_revocacion, int id_usuario)
{
//Definiendo objeto de retorno
RetornoOperacion resultado = new RetornoOperacion();
//Ejecutando el SP
resultado = editaCertificado(id_emisor, id_sucursal, tipo_certificado, estatus, contrasena, iv_contrasena, key_contrasena, contrasena_revocacion, iv_contrasena_revocacion, key_contrasena_revocacion, id_usuario, this._habilitar);
//Devolviendo resultado
return(resultado);
}
/// <summary>
/// Realiza la edición de los datos de un certificado
/// </summary>
/// <param name="id_emisor">Id de Emisor</param>
/// <param name="id_sucursal">Id de Sucursar</param>
/// <param name="tipo_certificado">Tipo de Certificado</param>
/// <param name="estatus">Estatus</param>
/// <param name="contrasena">Contraseña de apertura del certificado</param>
/// <param name="iv_contrasena"></param>
/// <param name="key_contrasena"></param>
/// <param name="contrasena_revocacion">Contraseña de revocación del certificado</param>
/// <param name="iv_contrasena_revocacion"></param>
/// <param name="key_contrasena_revocacion"></param>
/// <param name="id_usuario">Id de usuario</param>
/// <param name="habilitar">Habilitar</param>
/// <returns></returns>
private RetornoOperacion editaCertificado(int id_emisor, int id_sucursal, TipoCertificado tipo_certificado,
Estatus estatus, string contrasena, string iv_contrasena, string key_contrasena,
string contrasena_revocacion, string iv_contrasena_revocacion, string key_contrasena_revocacion,
int id_usuario, bool habilitar)
{
//Inicializando parametros
object[] param = { 2, this._id_certificado_digital, id_emisor, id_sucursal, (byte)tipo_certificado, (byte)estatus,
contrasena, iv_contrasena, key_contrasena, contrasena_revocacion, iv_contrasena_revocacion, key_contrasena_revocacion,
id_usuario, habilitar, "", "" };
//Ejecutando el SP
return(CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoObjeto(nombre_procedimiento, param));
}
public async Task <Response> PostTipoCertificado([FromBody] TipoCertificado TipoCertificado)
{
try
{
var respuesta = Existe(TipoCertificado);
if (!respuesta.IsSuccess)
{
db.TipoCertificado.Add(TipoCertificado);
await db.SaveChangesAsync();
return(new Response
{
IsSuccess = true,
Message = Mensaje.Satisfactorio
});
}
if (!ModelState.IsValid)
{
return(new Response
{
IsSuccess = false,
Message = ""
});
}
return(new Response
{
IsSuccess = false,
Message = Mensaje.ExisteRegistro
});
}
catch (Exception ex)
{
await GuardarLogService.SaveLogEntry(new LogEntryTranfer
{
ApplicationName = Convert.ToString(Aplicacion.SwTH),
ExceptionTrace = ex,
Message = Mensaje.Excepcion,
LogCategoryParametre = Convert.ToString(LogCategoryParameter.Critical),
LogLevelShortName = Convert.ToString(LogLevelParameter.ERR),
UserName = "",
});
return(new Response
{
IsSuccess = false,
Message = Mensaje.Error,
});
}
}
public async Task <IActionResult> Create(TipoCertificado tipoCertificado)
{
if (!ModelState.IsValid)
{
InicializarMensaje(null);
return(View(tipoCertificado));
}
Response response = new Response();
try
{
response = await apiServicio.InsertarAsync(tipoCertificado,
new Uri(WebApp.BaseAddress),
"api/TipoCertificado/InsertarTipoCertificado");
if (response.IsSuccess)
{
var responseLog = await GuardarLogService.SaveLogEntry(new LogEntryTranfer
{
ApplicationName = Convert.ToString(Aplicacion.WebAppTh),
ExceptionTrace = null,
Message = "Se ha creado un tipo de Certificado",
UserName = "******",
LogCategoryParametre = Convert.ToString(LogCategoryParameter.Create),
LogLevelShortName = Convert.ToString(LogLevelParameter.ADV),
EntityID = string.Format("{0} {1}", "tipo certificado:", tipoCertificado.IdTipoCertificado),
});
return(RedirectToAction("Index"));
}
ViewData["Error"] = response.Message;
return(View(tipoCertificado));
}
catch (Exception ex)
{
await GuardarLogService.SaveLogEntry(new LogEntryTranfer
{
ApplicationName = Convert.ToString(Aplicacion.WebAppTh),
Message = "Creando Tipo Certificado",
ExceptionTrace = ex.Message,
LogCategoryParametre = Convert.ToString(LogCategoryParameter.Create),
LogLevelShortName = Convert.ToString(LogLevelParameter.ERR),
UserName = "******"
});
return(BadRequest());
}
}
public static X509Certificate2 RetornaCertificadoArquivo(string file, TipoCertificado Tipo, string senha = "")
{
//Create X509Certificate2 object from .cer file.
byte[] rawData;
if (Tipo == TipoCertificado.file)
{
rawData = FileHelper.ReadFile(file);
}
else
{
rawData = FileHelper.ReadFileURL(file);
}
X509Certificate2 x509 = new X509Certificate2(rawData, senha);
return(x509);
}
public async Task <IActionResult> Edit(string id, TipoCertificado tipoCertificado)
{
Response response = new Response();
try
{
if (!string.IsNullOrEmpty(id))
{
response = await apiServicio.EditarAsync(id, tipoCertificado, new Uri(WebApp.BaseAddress),
"/api/TipoCertificado");
if (response.IsSuccess)
{
await GuardarLogService.SaveLogEntry(new LogEntryTranfer
{
ApplicationName = Convert.ToString(Aplicacion.WebAppTh),
EntityID = string.Format("{0} : {1}", "Sistema", id),
LogCategoryParametre = Convert.ToString(LogCategoryParameter.Edit),
LogLevelShortName = Convert.ToString(LogLevelParameter.ADV),
Message = "Se ha actualizado un registro sistema",
UserName = "******"
});
return(RedirectToAction("Index"));
}
ViewData["Error"] = response.Message;
return(View(tipoCertificado));
}
return(BadRequest());
}
catch (Exception ex)
{
await GuardarLogService.SaveLogEntry(new LogEntryTranfer
{
ApplicationName = Convert.ToString(Aplicacion.WebAppTh),
Message = "Editando un tipo de certificado",
ExceptionTrace = ex,
LogCategoryParametre = Convert.ToString(LogCategoryParameter.Edit),
LogLevelShortName = Convert.ToString(LogLevelParameter.ERR),
UserName = "******"
});
return(BadRequest());
}
}
public Response Existe(TipoCertificado tipoCertificado)
{
var respuestaTipoCertificado = db.TipoCertificado.Where(p => p.Nombre.ToUpper() == tipoCertificado.Nombre.TrimStart().TrimEnd().ToUpper()).FirstOrDefault();
if (respuestaTipoCertificado != null)
{
return(new Response
{
IsSuccess = true,
Message = "Existe un tipo de certificado de igual nombre",
Resultado = null,
});
}
return(new Response
{
IsSuccess = false,
Message = "No existe tipo de certificado...",
Resultado = db.TipoCertificado.Where(p => p.IdTipoCertificado == tipoCertificado.IdTipoCertificado).FirstOrDefault(),
});
}
private Response Existe(TipoCertificado TipoCertificado)
{
var bdd = TipoCertificado.Nombre;
var TipoCertificadorespuesta = db.TipoCertificado.Where(p => p.Nombre == bdd).FirstOrDefault();
if (TipoCertificadorespuesta != null)
{
return(new Response
{
IsSuccess = true,
Message = Mensaje.ExisteRegistro,
Resultado = TipoCertificadorespuesta,
});
}
return(new Response
{
IsSuccess = false,
Resultado = TipoCertificadorespuesta,
});
}
private ConfiguracaoCertificado GetCertificateForConfig(string serialNumber, string password = "", TipoCertificado certificateType = TipoCertificado.A1Repositorio)
{
return(new ConfiguracaoCertificado()
{
TipoCertificado = certificateType,
Serial = serialNumber,
//Senha = password
});
}
/// <summary>
/// Obtiene el Certificado de Sello Digital activo del Emisor y/o sucursal
/// </summary>
/// <param name="id_emisor">Id de Emisor</param>
/// <param name="id_sucursal">Id de Sucursal</param>
/// <param name="tipo_certificado">Tipo de Certificado a buscar</param>
/// <returns></returns>
public static CertificadoDigital RecuperaCertificadoEmisorSucursal(int id_emisor, int id_sucursal, TipoCertificado tipo_certificado)
{
//Declarando objeto de retorno
CertificadoDigital cer = new CertificadoDigital();
//Inicializando parametros
object[] param = { 4, 0, id_emisor, id_sucursal, (byte)tipo_certificado, 0, "", "", "", "", "", "", 0, true, "", "" };
//Ejecutando el SP
using (DataSet ds = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoDataSet(nombre_procedimiento, param))
{
//Si existe el origen de datos
if (Validacion.ValidaOrigenDatos(ds, "Table"))
{
//Para cada regitrso
foreach (DataRow r in ds.Tables["Table"].Rows)
{
cer = new CertificadoDigital(Convert.ToInt32(r["Id"]));
}
}
return(cer);
}
}
/// <summary>
/// Inserta un nuevo registro Certificado
/// </summary>
/// <param name="id_emisor">Id de Emisor al que pertenece</param>
/// <param name="id_sucursal">Id de sucursal del emisor</param>
/// <param name="tipo_certificado"></param>
/// <param name="contrasena"></param>
/// <param name="contrasena_revocacion"></param>
/// <param name="id_usuario"></param>
/// <returns></returns>
public static RetornoOperacion InsertaCertificado(int id_emisor, int id_sucursal, TipoCertificado tipo_certificado,
string contrasena, string contrasena_revocacion, int id_usuario)
{
//Declaramos llaves de encriptación aleatorias
string key_contrasena = Cadena.CadenaAleatoria(10),
key_contrasena_revocacion = Cadena.CadenaAleatoria(10);
//Encriptando contraseñas
string contrasenaEnc = Convert.ToBase64String(Encriptacion.EncriptaCadenaAES(contrasena, key_contrasena));
string contrasenaEncRev = Convert.ToBase64String(Encriptacion.EncriptaCadenaAES(contrasena_revocacion, key_contrasena_revocacion));
//Inicializando parametros
object[] param = { 1, 0, id_emisor, id_sucursal, (byte)tipo_certificado, (byte)Estatus.Vigente, contrasenaEnc,
"", key_contrasena, contrasenaEncRev, "", key_contrasena_revocacion,
id_usuario, true, "", "" };
//Ejecutando el SP
return(CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoObjeto(nombre_procedimiento, param));
}
public async Task <Response> PutTipoCertificado([FromRoute] int id, [FromBody] TipoCertificado TipoCertificado)
{
try
{
if (!ModelState.IsValid)
{
return(new Response
{
IsSuccess = false,
Message = Mensaje.ModeloInvalido
});
}
var existe = Existe(TipoCertificado);
var TipoCertificadoActualizar = (TipoCertificado)existe.Resultado;
if (existe.IsSuccess)
{
if (TipoCertificadoActualizar.IdTipoCertificado == TipoCertificado.IdTipoCertificado)
{
if (TipoCertificado.Nombre == TipoCertificadoActualizar.Nombre &&
TipoCertificado.Descripcion == TipoCertificadoActualizar.Descripcion)
{
return(new Response
{
IsSuccess = true,
Message = Mensaje.ExisteRegistro,
});
}
await Actualizar(TipoCertificado);
return(new Response
{
IsSuccess = true,
Message = Mensaje.Satisfactorio,
});
}
return(new Response
{
IsSuccess = false,
Message = Mensaje.ExisteRegistro,
});
}
await Actualizar(TipoCertificado);
return(new Response
{
IsSuccess = true,
Message = Mensaje.Satisfactorio,
});
}
catch (Exception ex)
{
await GuardarLogService.SaveLogEntry(new LogEntryTranfer
{
ApplicationName = Convert.ToString(Aplicacion.SwTH),
ExceptionTrace = ex,
Message = Mensaje.Excepcion,
LogCategoryParametre = Convert.ToString(LogCategoryParameter.Critical),
LogLevelShortName = Convert.ToString(LogLevelParameter.ERR),
UserName = "",
});
return(new Response
{
IsSuccess = true,
Message = Mensaje.Excepcion,
});
}
}
