public void EliminarServicio(EServicio eServicio)
{
List <SqlParameter> parametros = new List <SqlParameter>();
parametros.Add(new SqlParameter("@id", eServicio.Idservicio));
ADatos.EliminarRegistro("Delete from TServicios where IdServicio=@id", parametros);
}
/// <summary>
/// Agrega o modifica un registro de la tabla: Servicios
/// </summary>
/// <param name="p_entServicio">Entidad con los datos a procesar</param>
/// <param name="p_smResult">Estado final de la operacion</param>
public static void Save(EServicio p_entServicio,
StatMsg p_smResult)
{
// No hay errores aun
DBConn l_dbcAccess = null;
try {
// Obtenemos una conexion y abrimos una transaccion
l_dbcAccess = DBRuts.GetConection(Connections.Dat);
l_dbcAccess.BeginTransaction();
// Grabamos la entidad: EServicio
SSav(l_dbcAccess, p_entServicio, p_smResult);
}
catch (Exception l_expData) {
// Error en la operacion Save
p_smResult.BllError(l_expData);
}
finally {
// Si pude abrir la conexion
if (l_dbcAccess != null)
{
// Finalizo la transacción y la cierro
l_dbcAccess.EndTransaction(p_smResult);
l_dbcAccess.Close();
}
}
}
//---------------------------------------------------------------
// Metodos públicos de la clase (no visibles para la UIL)
//---------------------------------------------------------------
#region Metodos internos de validacion
/// <summary>
/// Valida la integridad de una entidad: Servicio
/// </summary>
/// <param name="p_dbcAccess">Conexion a la base de datos</param>
/// <param name="p_entServicio">Entidad con los datos a validar</param>
/// <param name="p_smResult">Estado final de la operacion</param>
internal static void TInt(DBConn p_dbcAccess,
EServicio p_entServicio,
StatMsg p_smResult)
{
// ********
// Validaciones de los campos sin conexion
// ********
if (p_entServicio.Cod.Trim() == "")
{
// El campo [Código] no puede ser vacío
p_smResult.BllWarning("El dato [Código] no puede ser vacío", "");
return;
}
if (p_entServicio.Des.Trim() == "")
{
// El campo [Descripción] no puede ser vacío
p_smResult.BllWarning("El dato [Descripción] no puede ser vacío", "");
return;
}
// ********
// Validaciones de los campos con conexion
// ********
// Llamamos a la funcion fija del usuario
TInt_f(p_dbcAccess, p_entServicio, p_smResult);
if (p_smResult.NOk)
{
return;
}
}
private void Registrar()
{
EServicio servicio = new EServicio
{
Nombre = txtNombre.Text,
CostoManoObra = Convert.ToDecimal(txtCostoBase.EditValue)
};
var servicioArticuloArreglo = new EServicioArticulo[viewArticulo.RowCount];
for (var i = 0; i < viewArticulo.RowCount; i++)
{
EServicioArticulo servicioArticulo = new EServicioArticulo
{
IdArticulo = Convert.ToInt32(viewArticulo.GetRowCellValue(i, "id_articulo")),
Cantidad = Convert.ToInt32(viewArticulo.GetRowCellValue(i, "cantidad"))
};
servicioArticuloArreglo[i] = servicioArticulo;
}
_servicioLogico.Registrar(servicio, servicioArticuloArreglo);
if (_servicioLogico.StringBuilder.Length > 0)
{
XtraMessageBox.Show(_servicioLogico.StringBuilder.ToString());
return;
}
DialogResult = DialogResult.OK;
}
/// <summary>
/// Devuelve una entidad: EServicio
/// </summary>
/// <param name="p_strCod">Código</param>
/// <param name="p_bOnlyActive">Indica si solo se analizan los registros activos</param>
/// <param name="p_smResult">Estado final de la operacion</param>
/// <returns>Entidad: EServicio</returns>
public static EServicio Get(string p_strCod,
bool p_bOnlyActive,
StatMsg p_smResult)
{
// No hay errores aun
DBConn l_dbcAccess = null;
// Ajustamos codigos alineados a derecha
p_strCod = EServicio.FrmtCod(p_strCod);
try {
// Obtenemos una conexion
l_dbcAccess = DBRuts.GetConection(Connections.Dat);
// Pedimos la entidad: EServicio
return(Srch(l_dbcAccess,
p_strCod,
p_bOnlyActive,
p_smResult));
}
catch (Exception l_expData) {
// Error en la operacion Get
p_smResult.BllError(l_expData);
return(null);
}
finally {
// Si pude abrir la conexion -> la cierro
if (l_dbcAccess != null)
{
l_dbcAccess.Close();
}
}
}
//---------------------------------------------------------------
// Metodos públicos de la clase
//---------------------------------------------------------------
#region Metodos publicos de la clase
#endregion
//---------------------------------------------------------------
// Metodos privados de la clase
//---------------------------------------------------------------
#region Metodos del Generador
/// <summary>
/// Agrega o modifica un registro de la tabla: Servicios
/// (Código Fijo)
/// </summary>
/// <param name="p_dbcAccess">Conexion a la base de datos</param>
/// <param name="p_entServicio">Entidad con los datos a procesar</param>
/// <param name="p_smResult">Estado final de la operacion</param>
internal static void Save_f(DBConn p_dbcAccess,
ref EServicio p_entServicio,
StatMsg p_smResult)
{
// *********
// Agregar acá los procesos adicionales
// *********
}
/// <summary>
/// Agrega validacion de integridad a una entidad: Servicio
/// (Código Fijo)
/// </summary>
/// <param name="p_dbcAccess">Conexion a la base de datos</param>
/// <param name="p_entServicio">Entidad con los datos a validar</param>
/// <param name="p_smResult">Estado final de la operacion</param>
internal static void TInt_f(DBConn p_dbcAccess,
EServicio p_entServicio,
StatMsg p_smResult)
{
// *********
// Agregar acá las validaciones adicionales
// *********
}
public void RegistrarServicio(EServicio eServicio)
{
List <SqlParameter> parametros = new List <SqlParameter>();
parametros.Add(new SqlParameter("@nombre", eServicio.Nombre));
parametros.Add(new SqlParameter("@tipo", eServicio.Tipo));
ADatos.EjecutarRegistro("Insert into TServicios values(@nombre,@tipo)", parametros);
}
private bool ValidarServicio(EServicio servicio)
{
StringBuilder.Clear();
if (string.IsNullOrEmpty(servicio.Nombre))
{
StringBuilder.Append("El Nombre del servicio es obligatorio");
}
return(StringBuilder.Length == 0);
}
public void ModificarServicio(EServicio eServicio)
{
List <SqlParameter> parametros = new List <SqlParameter>();
parametros.Add(new SqlParameter("@id", eServicio.Idservicio));
parametros.Add(new SqlParameter("@nombre", eServicio.Nombre));
parametros.Add(new SqlParameter("@tipo", eServicio.Tipo));
ADatos.ModificarRegistro("Update TServicios set Nombre=@nombre,Tipo=@tipo where IdServicio=@id", parametros);
}
private void BtnEliminar_Click(object sender, EventArgs e)
{
EServicio servicio = new EServicio();
servicio.Idservicio = int.Parse(Tbid.Text);
IServicio lservicio = new LServicio();
lservicio.EliminarServicio(servicio);
ListarServicio();
}
private void BtnGuardar_Click(object sender, EventArgs e)
{
EServicio servicio = new EServicio();
servicio.Nombre = Tbnombre.Text;
servicio.Tipo = Cbtipo.SelectedItem.ToString();
IServicio lservicio = new LServicio();
lservicio.RegistrarServicio(servicio);
ListarServicio();
}
private void BtnModificar_Click(object sender, EventArgs e)
{
EServicio servicio = new EServicio();
servicio.Idservicio = int.Parse(Tbid.Text);
servicio.Nombre = Tbnombre.Text;
servicio.Tipo = Cbtipo.SelectedItem.ToString();
IServicio lservicio = new LServicio();
lservicio.ModificarServicio(servicio);
ListarServicio();
}
public void Actualizar(EServicio servicio, EServicioArticulo[] articulos)
{
SqlCommand comando = Metodos.CrearComando();
string sqlQuery = string.Format("UPDATE Servicio SET nombre='{0}',costo_mo={1} WHERE id_servicio={2}",
servicio.Nombre, servicio.CostoManoObra, servicio.Id);
comando.CommandText = sqlQuery;
Metodos.EjecutarComando(comando);
BorrarArticulos(servicio.Id);
foreach (var articulo in articulos)
{
LigarArticulos(servicio.Id, articulo.IdArticulo, articulo.Cantidad);
}
}
public void Insertar(EServicio servicio, EServicioArticulo[] articulos)
{
SqlCommand comando = Metodos.CrearComando();
string sqlQuery = string.Format("INSERT INTO Servicio VALUES ('{0}',{1})",
servicio.Nombre, servicio.CostoManoObra);
comando.CommandText = sqlQuery;
Metodos.EjecutarComando(comando);
int maxId = TraerIdMaximo();
foreach (var articulo in articulos)
{
LigarArticulos(maxId, articulo.IdArticulo, articulo.Cantidad);
}
}
public void Registrar(EServicio servicio, EServicioArticulo[] articulos)
{
if (!ValidarServicio(servicio))
{
return;
}
if (servicio.Id == 0)
{
_serviciosDatos.Insertar(servicio, articulos);
}
else
{
_serviciosDatos.Actualizar(servicio, articulos);
}
}
/// <summary>
/// Borra físicamento un registro de la tabla: Servicios
/// </summary>
/// <param name="p_strCod">Código</param>
/// <param name="p_iFxdVersion">Versión del registro a borrar</param>
/// <param name="p_smResult">Estado final de la operacion</param>
public static void Remove(string p_strCod,
int p_iFxdVersion,
StatMsg p_smResult)
{
// No hay errores aun
DBConn l_dbcAccess = null;
// Ajustamos codigos alineados a derecha
p_strCod = EServicio.FrmtCod(p_strCod);
try {
// Obtenemos una conexion
l_dbcAccess = DBRuts.GetConection(Connections.Dat);
l_dbcAccess.BeginTransaction();
// Procesamos codigo fijo
Remove_f(l_dbcAccess,
p_strCod,
p_iFxdVersion,
p_smResult);
if (p_smResult.NOk)
{
return;
}
// Borramos el registro solicitado
Drop(l_dbcAccess,
p_strCod,
p_iFxdVersion,
p_smResult);
}
catch (Exception l_expData) {
// Error en la operacion Remove
p_smResult.BllError(l_expData);
}
finally {
// Si pude abrir la conexion
if (l_dbcAccess != null)
{
// Finalizo la transacción y la cierro
l_dbcAccess.EndTransaction(p_smResult);
l_dbcAccess.Close();
}
}
}
private void CargarServicio()
{
if (_idServicio == 0)
{
return;
}
EServicio servicio = _servicioLogico.TraerPorId(_idServicio);
txtNombre.Text = servicio.Nombre;
txtCostoBase.EditValue = servicio.CostoManoObra;
DataTable dataTable = _servicioLogico.TraerArticulos(servicio.Id);
foreach (DataRow row in dataTable.Rows)
{
_table.ImportRow(row);
}
gridArticulos.DataSource = _table;
CargarTotales();
}
/// <summary>
/// Actualiza un registro a la tabla a partir de una entidad: EServicio
/// </summary>
/// <param name="p_dbcAccess">Conexion a la base de datos</param>
/// <param name="p_entServicio">Entidad con los datos a procesar</param>
/// <param name="p_smResult">Estado final de la operacion</param>
internal static void Updt(DBConn p_dbcAccess,
EServicio p_entServicio,
StatMsg p_smResult)
{
try {
// Validamos la integridad de la entidad
TInt(p_dbcAccess, p_entServicio, p_smResult);
if (p_smResult.NOk)
{
return;
}
// Actualizamos un registro de la tabla: Servicios
Dal.Servicios.Update(p_dbcAccess,
p_entServicio.Cod,
p_entServicio.Des,
p_entServicio.Explicacion,
p_smResult);
}
catch (Exception l_expData) {
// Error en la operacion Updt
p_smResult.BllError(l_expData);
}
}
/// <summary>
/// Devuelve una entidad: EServicio
/// </summary>
/// <param name="p_dbcAccess">Conexion a la base de datos</param>
/// <param name="p_strCod">Código</param>
/// <param name="p_bOnlyActive">Indica si solo se analizan los registros activos</param>
/// <param name="p_smResult">Estado final de la operacion</param>
/// <returns>Entidad: EServicio</returns>
internal static EServicio Srch(DBConn p_dbcAccess,
string p_strCod,
bool p_bOnlyActive,
StatMsg p_smResult)
{
try {
// Pedimos el registro de la tabla: Servicios
DataSet l_dsTemp = new DataSet();
Dal.Servicios.Search(p_dbcAccess,
p_strCod,
p_bOnlyActive,
ref l_dsTemp, "Temporal",
p_smResult);
if (p_smResult.NOk)
{
return(null);
}
// Constuimos la entidad y la devolvemos (si vino un registro)
EServicio l_entRet = null;
if (l_dsTemp.Tables["Temporal"].Rows.Count == 1)
{
l_entRet = new EServicio(l_dsTemp.Tables["Temporal"].Rows[0]);
}
l_dsTemp.Dispose();
return(l_entRet);
}
catch (Exception l_expData) {
// Error en la operacion Srch
p_smResult.BllError(l_expData);
return(null);
}
}
/// <summary>
/// Agrega o modifica un registro de la tabla: Servicios
/// </summary>
/// <param name="p_dbcAccess">Conexion a la base de datos</param>
/// <param name="p_entServicio">Entidad con los datos a procesar</param>
/// <param name="p_smResult">Estado final de la operacion</param>
internal static void SSav(DBConn p_dbcAccess,
EServicio p_entServicio,
StatMsg p_smResult)
{
try {
// Procesamos codigo fijo
Save_f(p_dbcAccess, ref p_entServicio, p_smResult);
if (p_smResult.NOk)
{
return;
}
// Verificamos la clave a grabar
VKey(p_dbcAccess,
p_entServicio.Cod,
p_smResult);
if (p_smResult.NOk)
{
return;
}
// Si es una entidad nueva
if (p_entServicio.EsNueva)
{
// Es un alta. La clave no debe existir
if (!p_smResult.ICodeEs(BllCodes.KeyDsntFound))
{
// Error. La clave ya existe
p_smResult.BllWarning("El ítem (Servicio) que intenta agregar ya existe en el sistema.", "");
return;
}
// Agregamos el registro
Insr(p_dbcAccess, p_entServicio, p_smResult);
return;
}
// Es un update. La clave debe existir y estar habilitada
if (!p_smResult.ICodeEs(BllCodes.KeyExists))
{
// Error. La clave no existe o no está habilitada
p_smResult.BllWarning("El ítem (Servicio) que intenta modificar no existe en el sistema o no está habilitado.", "");
return;
}
// Debe coincidir el número de version
VVer(p_dbcAccess,
p_entServicio.Cod,
p_entServicio.FxdVersion,
p_smResult);
if (p_smResult.NOk)
{
return;
}
// Actualizamos el registro
Updt(p_dbcAccess, p_entServicio, p_smResult);
}
catch (Exception l_expData) {
// Error en la operacion SSav
p_smResult.BllError(l_expData);
}
}
/// <summary>
/// Habilita/Deshabilita un registro de la tabla: Servicios
/// </summary>
/// <param name="p_bEnable">Tipo de operacion</param>
/// <param name="p_strCod">Código</param>
/// <param name="p_smResult">Estado final de la operacion</param>
public static void Enabled(bool p_bEnable,
string p_strCod,
int p_iFxdVersion,
StatMsg p_smResult)
{
// No hay errores aun
DBConn l_dbcAccess = null;
// Ajustamos codigos alineados a derecha
p_strCod = EServicio.FrmtCod(p_strCod);
try {
// Obtenemos una conexion
l_dbcAccess = DBRuts.GetConection(Connections.Dat);
l_dbcAccess.BeginTransaction();
// Procesamos codigo fijo
Enabled_f(l_dbcAccess,
p_bEnable,
p_strCod,
ref p_iFxdVersion,
p_smResult);
if (p_smResult.NOk)
{
return;
}
// Verificamos la clave a modificar
VKey(l_dbcAccess,
p_strCod,
p_smResult);
if (p_smResult.NOk)
{
return;
}
// El registro tiene que existir
if (p_smResult.ICodeEs(BllCodes.KeyDsntFound))
{
// Error. La clave no existe
p_smResult.BllWarning("El ítem (Servicio) que intenta modificar no existe en el sistema.", "");
return;
}
// Debe coincidir el número de version
VVer(l_dbcAccess,
p_strCod,
p_iFxdVersion,
p_smResult);
if (p_smResult.NOk)
{
return;
}
// Segun el modo
if (p_bEnable)
{
// Hay que habilitar el registro
Dal.Servicios.Recall(l_dbcAccess,
p_strCod,
p_smResult);
}
else
{
// Hay que deshabilitar el registro
Dal.Servicios.Delete(l_dbcAccess,
p_strCod,
p_smResult);
}
}
catch (Exception l_expData) {
// Error en la operacion Enabled
p_smResult.BllError(l_expData);
}
finally {
// Si pude abrir la conexion
if (l_dbcAccess != null)
{
// Finalizo la transacción y la cierro
l_dbcAccess.EndTransaction(p_smResult);
l_dbcAccess.Close();
}
}
}
