public async Task <int> Actualizar(int Idinstructor, string nombre, string apellidos, string titulo)
{
var storeProcedure = "instructor_editar";
try
{
var connection = _factoryConnection.GetConnection();
var resultado = await connection.ExecuteAsync(
storeProcedure,
new
{
_Idinstructor = Idinstructor,
_nombre = nombre,
_apellidos = apellidos,
_grado = titulo
}, commandType : CommandType.StoredProcedure);
_factoryConnection.CloseConnection();
return(resultado);
}
catch (Exception ex)
{
throw new Exception("{No se pudo modificar instructorS } ", ex);
}
finally
{
_factoryConnection.CloseConnection();
}
}
public async Task <IEnumerable <DetalleCompraModel> > Get(Guid Id)
{
IEnumerable <DetalleCompraModel> listDetalleCompra = null;
var storeProcedure = "usp_Get_DetalleCompra";
try
{
var connection = _factoryConnection.GetConnection();
listDetalleCompra = await connection.QueryAsync <DetalleCompraModel>(storeProcedure, new
{
CompraId = Id
}, commandType : CommandType.StoredProcedure);
}
catch (System.Exception e)
{
throw new Exception("Error en la consulta en la Base de datos", e);
}
finally
{
_factoryConnection.CloseConnection();
}
return(listDetalleCompra);
}
public async Task <int> ActualizaGrupoBD2(string consulta, Guid consultaFSID,
string descripcionConsulta, string tipoBD,
string versionBD, string entorno,
DateTime ultimaModificacion, string ultimoUsuario)
{
var storeProcedure = "usp_GrupoBD2_editar";
try
{
var connection = _factoryConnection.GetConnection();
var resultados = await connection.ExecuteAsync(
storeProcedure,
new
{
Consulta = consulta,
ConsultaFSID = consultaFSID,
DescripcionConsulta = descripcionConsulta,
TipoBD = tipoBD,
VersionBD = versionBD,
Entorno = entorno,
UltimaModificacion = ultimaModificacion,
UltimoUsuario = ultimoUsuario
},
commandType : CommandType.StoredProcedure
);
_factoryConnection.CloseConnection();
return(resultados);
}
catch (Exception e)
{
throw new Exception("No se han podido guardar los cambios", e);
}
}
public async Task <int> Create(InstructorModel model)
{
var sp = "sp_Instructor_Create";
int res = 0;
try
{
var conn = factoryConnection.GetConnection();
res = await conn.ExecuteAsync(sp,
new
{
InstructorId = Guid.NewGuid(),
model.Name,
model.LastName,
model.Grade
},
commandType : CommandType.StoredProcedure);
}
catch
{
throw new Exception("No se pudo ingresar");
}
finally
{
factoryConnection.CloseConnection();
}
return(res);
}
public async Task <int> Actualizar(Guid instructorId, string nombre, string apellidos, string grado)
{
int resultado = 0;
var storeProcedure = "usp_instructor_editar";
try
{
var connection = factoryConnection.GetConnection();
resultado = await connection.ExecuteAsync(
storeProcedure,
new
{
InstructorId = instructorId,
Nombre = nombre,
Apellidos = apellidos,
Grado = grado
},
commandType : CommandType.StoredProcedure
);
}
catch (Exception e)
{
throw new Exception("No se pudo editar la data del inistructor", e);
}
finally
{
factoryConnection.CloseConnection();
}
return(resultado);
}
public async Task <int> Actualiza(Guid instructorId, string nombre, string apellidos, string titulo)
{
var storeProcedure = "usp_instructor_editar";
try
{
var connection = _factoryConnection.GetConnection();
var resultados = await connection.ExecuteAsync(
storeProcedure,
new
{
InstructorId = instructorId,
Nombre = nombre,
Apellidos = apellidos,
Titulo = titulo
},
commandType : CommandType.StoredProcedure
);
_factoryConnection.CloseConnection();
return(resultados);
}
catch (Exception e)
{
throw new Exception("No se pudo editar la data del instructor", e);
}
}
public async Task <int> Actualizar(InstructorModel instructor)
{
var storeProcedure = "usp_instructor_editar";
try
{
var connection = _factoryConnection.GetConnection();
var result = await connection.ExecuteAsync(storeProcedure, instructor, commandType : CommandType.StoredProcedure);
_factoryConnection.CloseConnection();
return(result);
}
catch (Exception e)
{
throw new Exception("No se pudo editar el instructor", e);
}
}
public async Task <int> DeleteInstruc(Guid id)
{
var storeProcedure = "usp_instructor_eliminar";
try{
var connection = _factoryConnection.GetConnection();
var result = await connection.ExecuteAsync(
storeProcedure,
new {
InstructorId = id
},
commandType : CommandType.StoredProcedure
);
_factoryConnection.CloseConnection();
return(result);
}catch (Exception e) {
throw new Exception("No se pudo eliminar el instructor", e);
}
}
public async Task <IEnumerable <TurnoModel> > ConsultarTurnos()
{
IEnumerable <TurnoModel> instructorList = null;
var storeProcedure = "PC_V_Turno";
try
{
var connection = _factoryConnection.GetConnection();
instructorList = await connection.QueryAsync <TurnoModel>(storeProcedure, null, commandType : CommandType.StoredProcedure);
}
catch (Exception e)
{
throw new Exception("Error en la consulta de datos", e);
}
finally
{
_factoryConnection.CloseConnection();
}
return(instructorList);
}
public async Task <int> Actualizar(InstructorModel datos)
{
var UserStoredProcedure = "usp_Instructor_Editar";
try
{
var connection = factoryConnection.GetConnection();
var resultado = await connection.ExecuteAsync(UserStoredProcedure, datos, commandType : CommandType.StoredProcedure);
return(resultado);
}
catch (Exception e)
{
throw new Exception("Error en la actualización de instructor desde USp", e);
}
finally
{
factoryConnection.CloseConnection();
}
}
public async Task <IEnumerable <InstructorModel> > obtenerLista()
{
IEnumerable <InstructorModel> instructorList = null;
var storeProcedure = "usp_Obtener_Instructores";
try
{
var connection = factoryConnection.GetConnection();
instructorList = await connection.QueryAsync <InstructorModel>(storeProcedure, null, commandType : CommandType.StoredProcedure);
}
catch (Exception e)
{
throw new Exception("Error en la consulta de datos", e);
}
finally
{
factoryConnection.CloseConnection();
}
return(instructorList);
}
public async Task <PaginacionModel> devolverPaginacion(string storedProcedure, int numeroPagina, int cantidadElementos, IDictionary <string, object> parametrosFiltro, string ordenamientoColumna)
{
PaginacionModel paginacionModel = new PaginacionModel();
// rows
List <IDictionary <string, object> > listaReporte = null;
// parámetros salida
int totalRecords = 0;
int totalPaginas = 0;
try
{
var connection = factoryConnection.GetConnection();
DynamicParameters parametros = new DynamicParameters();
// agregar dinámicamente parámetros de filtro del cliente
foreach (var param in parametrosFiltro)
{
parametros.Add("@" + param.Key, param.Value);
}
// Parámetros de entrada
parametros.Add("@NumeroPagina", numeroPagina);
parametros.Add("@CantidadElementos", cantidadElementos);
parametros.Add("@Ordenamiento", ordenamientoColumna);
// Parámetros de salida
parametros.Add("@TotalRecords", totalRecords, DbType.Int32, ParameterDirection.Output);
parametros.Add("@TotalPaginas", totalPaginas, DbType.Int32, ParameterDirection.Output);
var result = await connection.QueryAsync(storedProcedure, parametros, commandType : CommandType.StoredProcedure);
// hacer query de linq que convierta a IDictionary las rows
listaReporte = result.Select(x => (IDictionary <string, object>)x).ToList();
// agregar parámetros de salida
paginacionModel.ListaRecords = listaReporte;
paginacionModel.NumeroPaginas = parametros.Get <int>("@TotalPaginas");
paginacionModel.TotalRecords = parametros.Get <int>("@TotalRecords");
}
catch (Exception e)
{
throw new Exception("No se pudo ejecutar el stored procedure", e);
}
finally
{
factoryConnection.CloseConnection();
}
return(paginacionModel);
}
public async Task <IEnumerable <InstructorModel> > ObtainList()
{
IEnumerable <InstructorModel> instructorList = null;
var storeProcedure = "usp_Obtain_Instructors";
try
{
var connection = _factoryConnection.GetConnection();
instructorList = await connection.QueryAsync <InstructorModel>(storeProcedure, null, commandType : CommandType.StoredProcedure);
}
catch (Exception ex)
{
throw new Exception("Someting wrong, an error ocurred in the data", ex);
}
finally
{
_factoryConnection.CloseConexion();
}
return(instructorList);
}
public async Task <PaginacionModel> DevolverPaginancion(
string storeProcedure,
int numeroPagina,
int cantidadElementos,
IDictionary <string, object> parametrosFiltro,
string ordenamientoColumna)
{
PaginacionModel paginacionModel = new PaginacionModel();
List <IDictionary <string, object> > ListaReporte = null;
int totalRecords = 0;
int totalPaginas = 0;
try
{
var connection = _factoryConnection.GetConnection();
DynamicParameters parametros = new DynamicParameters();
foreach (var param in parametrosFiltro)
{
parametros.Add("@" + param.Key, param.Value);
}
parametros.Add("@NumeroPagina", numeroPagina);
parametros.Add("@CantidadElementos", cantidadElementos);
parametros.Add("@Ordenamiento", ordenamientoColumna);
parametros.Add("@TotalRecords", totalRecords, DbType.Int32, ParameterDirection.Output);
parametros.Add("@TotalPaginas", totalPaginas, DbType.Int32, ParameterDirection.Output);
var result = await connection.QueryAsync(storeProcedure, parametros, commandType : CommandType.StoredProcedure);
ListaReporte = result.Select(x => (IDictionary <string, object>)x).ToList();
paginacionModel.ListaRecords = ListaReporte;
paginacionModel.NumeroPaginas = parametros.Get <int>("@TotalPaginas");
paginacionModel.TotalRecords = parametros.Get <int>("@TotalRecords");
}
catch (System.Exception)
{
throw new Exception("No se pudo ejecutar el procedimiento almacenado");
} finally{
_factoryConnection.CloseConnection();
}
return(paginacionModel);
}
public async Task <int> DeleteTeacher(Guid id)
{
string storeProcedure = "sp_Delete_Teacher";
try
{
var connection = _factoryConnection.GetConnection();
return(await connection.ExecuteAsync(
storeProcedure,
new { TeacherId = id },
commandType : CommandType.StoredProcedure
));
}
catch (Exception e)
{
throw new Exception("No se pudo eliminar el instructor ", e);
}
finally
{
_factoryConnection.CloseConnection();
}
}
public async Task <int> Delete(Guid Id)
{
var storeProcedure = "usp_Delete_Proveedor";
try
{
var connection = _factoryConnection.GetConnection();
var resultado = await connection.ExecuteAsync(storeProcedure, new
{
ProveedorId = Id
}
, commandType : CommandType.StoredProcedure);
_factoryConnection.CloseConnection();
return(resultado);
}
catch (System.Exception e)
{
throw new Exception("Error en la base de datos", e);
}
}
public async Task <int> Actualiza(Guid id, string nombre, string apellido, string grado)
{
var storeProcedure = "usp_Instructor_Editar";
try{
var connection = _factoryConnection.GetConnection();
var resultado = await connection.ExecuteAsync(
storeProcedure,
new {
InstructorId = id,
Nombre = nombre,
Apellidos = apellido,
Grado = grado
},
commandType : CommandType.StoredProcedure
);
_factoryConnection.CloseConnection();
return(resultado);
}catch (Exception ex) {
throw new Exception("" + ex);
}
}
public Task <int> Delete(Guid id)
{
var storeProcedure = "usp_Instructor_Delete";
try
{
var connection = _factoryConnection.GetConnection();
var resultado = connection.ExecuteAsync(
storeProcedure,
new
{
InstructorId = id
},
commandType: CommandType.StoredProcedure
);
_factoryConnection.CloseConnection();
return(resultado);
}
catch (Exception ex)
{
throw new Exception("error delete data", ex);
}
}
public async Task <int> Nuevo(ClienteModel cliente)
{
var sp = "ClientesObtener";
try
{
var connexion = factoryConnection.GetConnection();
var resultado = await connexion.ExecuteAsync(sp, new
{
Apellido = cliente.Apellido,
Nombre = cliente.Nombre
}, commandType : System.Data.CommandType.StoredProcedure);
return(resultado);
}
catch (Exception ex)
{
throw new Exception("Error al insertar el registro", ex);
}
finally
{
factoryConnection.CloseConnection();
}
}
public async Task <Pagination> GetPagination(
string storeProcedure,
int pagNum,
int numRecords,
IDictionary <string, object> filters,
string columnOrder)
{
Pagination pagination = new Pagination();
int totalRecords = 0;
int totalPages = 0;
try
{
var connection = _connection.GetConnection();
DynamicParameters parameters = new DynamicParameters();
foreach (var param in filters)
{
parameters.Add($"@{param.Key}", param.Value);
}
parameters.Add("@PagNum", pagNum);
parameters.Add("@NumRecords", numRecords);
parameters.Add("@ColumnOrder", columnOrder);
parameters.Add("@TotalRecords", totalRecords, DbType.Int32, ParameterDirection.Output);
parameters.Add("@TotalPages", totalPages, DbType.Int32, ParameterDirection.Output);
var result = await connection.QueryAsync(storeProcedure, parameters,
commandType : CommandType.StoredProcedure);
pagination.RecordsList = result.Select(r => (IDictionary <string, object>)r).ToList();
pagination.TotalRecords = parameters.Get <int>("@TotalRecords");
pagination.PagNum = parameters.Get <int>("@TotalPages");
}
catch (Exception e)
{
throw new Exception("No se pudo ejecutar el procedimiento almacenado ", e);
}
finally
{
_connection.CloseConnection();
}
return(pagination);
}
public async Task <PaginationModel> returnPagination(string storeProcedure, int numberPage, int quantityElements, IDictionary <string, object> parameterFilter, string sortedColumn)
{
PaginationModel paginationModel = new PaginationModel();
List <IDictionary <string, object> > listReport = null;
int totalRecords = 0;
int totalPages = 0;
try
{
var connection = _factoryConnection.GetConnection();
DynamicParameters parameters = new DynamicParameters();
foreach (var param in parameterFilter)
{
parameters.Add("@" + param.Key, param.Value);
}
//Parameter In
parameters.Add("@NumberPage", numberPage);
parameters.Add("@QuantityElements", quantityElements);
parameters.Add("@Sorted", sortedColumn);
//
//Parameter Out
parameters.Add("@TotalRecords", totalRecords, DbType.Int32, ParameterDirection.Output);
parameters.Add("@TotalPages", totalPages, DbType.Int32, ParameterDirection.Output);
var result = await connection.QueryAsync(storeProcedure, parameters, commandType : CommandType.StoredProcedure);
listReport = result.Select(x => (IDictionary <string, object>)x).ToList();
paginationModel.ListRecords = listReport;
paginationModel.NumberPages = parameters.Get <int>("@TotalPages");
paginationModel.TotalRecords = parameters.Get <int>("@TotalRecords");
}
catch (Exception ex)
{
throw new Exception("Someting wrong, dont execute store procedure", ex);
}
finally
{
_factoryConnection.CloseConexion();
}
return(paginationModel);
}
public async Task <PaginationModel> GetPagination(string storedProcedure, int pageNo,
int qty, IDictionary <string, object> filters, string ordering)
{
PaginationModel paginacionModel = new PaginationModel();
List <IDictionary <string, object> > listaReporte = null;
int totalRecords = 0;
int totalPaginas = 0;
try
{
var connection = factoryConnection.GetConnection();
DynamicParameters parametros = new DynamicParameters();
foreach (var param in filters)
{
parametros.Add("@" + param.Key, param.Value);
}
parametros.Add("@PageNo", pageNo);
parametros.Add("@Qty", qty);
parametros.Add("@Ordering", ordering);
parametros.Add("@RecordCount", totalRecords, DbType.Int32, ParameterDirection.Output);
parametros.Add("@PagesCount", totalPaginas, DbType.Int32, ParameterDirection.Output);
var result = await connection.QueryAsync(storedProcedure, parametros, commandType : CommandType.StoredProcedure);
listaReporte = result.Select(x => (IDictionary <string, object>)x).ToList();
paginacionModel.RecordList = listaReporte;
paginacionModel.PagesCount = parametros.Get <int>("@PagesCount");
paginacionModel.RecordCount = parametros.Get <int>("@RecordCount");
}
catch (Exception e)
{
throw new Exception("No se pudo ejecutar el procedimiento almacenado", e);
}
finally
{
factoryConnection.CloseConnection();
}
return(paginacionModel);
}
public async Task <PaginacionModel> devolverPaginacion(string nombreProcedimientoAlmacenado, int numeroPagina, int cantidadElementos, IDictionary <string, object> parametrosFiltro, string ordenamiento)
{
PaginacionModel paginacionModel = new PaginacionModel();
try
{
var cnx = factoryConnection.GetConnection();
// * Parametros
DynamicParameters parameteros = new DynamicParameters();
// ? Parametros de entrada
// ! Filtros
foreach (var param in parametrosFiltro)
{
parameteros.Add("@" + param.Key, param.Value);
}
parameteros.Add("@NumeroPagina", numeroPagina);
parameteros.Add("@CantidadElementos", cantidadElementos);
parameteros.Add("@Ordenamiento", ordenamiento);
// ? Parametros de Salida
parameteros.Add("@TotalRegistros", null, DbType.Int32, ParameterDirection.Output);
parameteros.Add("@CantidadPaginas", null, DbType.Int32, ParameterDirection.Output);
var resultado = await cnx.QueryAsync(nombreProcedimientoAlmacenado, parameteros, commandType : CommandType.StoredProcedure);
paginacionModel.ListaRegistros = resultado.Select(x => (IDictionary <string, object>)x).ToList();
paginacionModel.TotalRegistros = parameteros.Get <int>("TotalRegistros");
paginacionModel.CantidadPaginas = parameteros.Get <int>("CantidadPaginas");
return(paginacionModel);
}
catch (Exception e)
{
throw new Exception("No se puedo ejecutar el procedimiento almacenado", e);
}
finally
{
factoryConnection.CloseConnection();
}
}