/// <summary>
/// Metodo para Crear un registro de ProveedorAlmacen
/// </summary>
/// <param name="info">Valores de la entidad que será creada</param>
public int Crear(ProveedorAlmacenInfo info)
{
try
{
Logger.Info();
Dictionary <string, object> parameters = AuxProveedorAlmacenDAL.ObtenerParametrosCrear(info);
int result = Create("ProveedorAlmacen_Crear", parameters);
return(result);
}
catch (SqlException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (DataException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtiene un proveedor almacen por proveedorid
/// </summary>
/// <param name="ds"></param>
/// <returns></returns>
internal static ProveedorAlmacenInfo ObtenerPorProveedorTipoAlmacen(DataSet ds)
{
try
{
Logger.Info();
DataTable dt = ds.Tables[ConstantesDAL.DtDatos];
ProveedorAlmacenInfo entidad =
(from info in dt.AsEnumerable()
select
new ProveedorAlmacenInfo
{
ProveedorAlmacenId = info.Field <int>("ProveedorAlmacenID"),
ProveedorId = info.Field <int>("ProveedorID"),
Proveedor = new ProveedorInfo
{
ProveedorID = info.Field <int>("ProveedorID")
},
AlmacenId = info.Field <int>("AlmacenID"),
Activo = info.Field <bool>("Activo").BoolAEnum(),
FechaCreacion = info.Field <DateTime>("FechaCreacion"),
UsuarioCreacionID = info.Field <int>("UsuarioCreacionID")
}).First();
return(entidad);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Metodo que obtiene un proveedor almacen por proveedor id
/// </summary>
/// <returns></returns>
internal ProveedorAlmacenInfo ObtenerPorAlmacenID(int almacenID)
{
try
{
Logger.Info();
var parameters = AuxProveedorAlmacenDAL.ObtenerParametrosObtenerPorAlmacenID(almacenID);
var ds = Retrieve("ProveedorAlmacen_ObtenerPorAlmacenID", parameters);
ProveedorAlmacenInfo result = null;
if (ValidateDataSet(ds))
{
result = MapProveedorAlmacenDAL.ObtenerPorAlmacenID(ds);
}
return(result);
}
catch (SqlException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (DataException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtiene un proveedor por id y tipo de almacen
/// </summary>
/// <param name="proveedorInfo"></param>
/// <returns></returns>
public ProveedorAlmacenInfo ObtenerPorProveedorTipoAlmacen(ProveedorAlmacenInfo proveedorInfo)
{
ProveedorAlmacenInfo proveedorAlmacen;
try
{
Logger.Info();
var proveedorAlmacenBl = new ProveedorAlmacenBL();
proveedorAlmacen = proveedorAlmacenBl.ObtenerPorProveedorTipoAlmacen(proveedorInfo);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(proveedorAlmacen);
}
/// <summary>
/// Obtiene parametros para crear
/// </summary>
/// <param name="info">Valores de la entidad</param>
/// <returns></returns>
public static Dictionary <string, object> ObtenerParametrosCrear(ProveedorAlmacenInfo info)
{
try
{
Logger.Info();
var parametros =
new Dictionary <string, object>
{
{ "@ProveedorID", info.Proveedor.ProveedorID },
{ "@AlmacenID", info.Almacen.AlmacenID },
{ "@Activo", info.Activo },
{ "@UsuarioCreacionID", info.UsuarioCreacionID },
};
return(parametros);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Metodo para actualizar un registro de ProveedorAlmacen
/// </summary>
/// <param name="info">Valores de la entidad que se actualizarán</param>
public void Actualizar(ProveedorAlmacenInfo info)
{
try
{
Logger.Info();
Dictionary <string, object> parameters = AuxProveedorAlmacenDAL.ObtenerParametrosActualizar(info);
Update("ProveedorAlmacen_Actualizar", parameters);
}
catch (SqlException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (DataException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Metodo para Guardar/Modificar una entidad Almacen
/// </summary>
/// <param name="info"></param>
internal int Guardar(AlmacenInfo info)
{
try
{
Logger.Info();
var almacenDAL = new AlmacenDAL();
int result = info.AlmacenID;
bool esModificacion = result > 0;
using (var scope = new TransactionScope())
{
if (info.AlmacenID == 0)
{
result = almacenDAL.Crear(info);
}
else
{
almacenDAL.Actualizar(info);
}
if (info.Proveedor != null && info.Proveedor.ProveedorID > 0)
{
var proveedorAlmacenDAL = new ProveedorAlmacenDAL();
var proveedorAlmacen = new ProveedorAlmacenInfo
{
Proveedor = info.Proveedor,
Almacen = new AlmacenInfo
{
AlmacenID = result
}
};
if (esModificacion)
{
ProveedorAlmacenInfo proveedorAlmacenExiste =
proveedorAlmacenDAL.ObtenerPorAlmacenID(result);
if (info.Activo == EstatusEnum.Inactivo)
{
if (proveedorAlmacenExiste != null)
{
proveedorAlmacenExiste.Activo = EstatusEnum.Inactivo;
proveedorAlmacenExiste.UsuarioModificacionID = info.UsuarioModificacionID;
proveedorAlmacenDAL.Actualizar(proveedorAlmacenExiste);
scope.Complete();
return(result);
}
}
if (proveedorAlmacenExiste != null)
{
proveedorAlmacenExiste.UsuarioModificacionID = info.UsuarioModificacionID.HasValue ? info.UsuarioModificacionID.Value : 0;
proveedorAlmacenExiste.Proveedor = info.Proveedor;
proveedorAlmacenDAL.Actualizar(proveedorAlmacenExiste);
scope.Complete();
return(result);
}
}
else
{
proveedorAlmacen.UsuarioCreacionID = info.UsuarioCreacionID;
}
proveedorAlmacenDAL.Crear(proveedorAlmacen);
}
scope.Complete();
}
return(result);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Metodo que valida los datos para guardar
/// </summary>
/// <returns></returns>
private bool ValidaGuardar()
{
bool resultado = true;
string mensaje = string.Empty;
try
{
if (string.IsNullOrWhiteSpace(txtAlmacenID.Text))
{
resultado = false;
mensaje = Properties.Resources.AlmacenEdicion_MsgAlmacenIDRequerida;
txtAlmacenID.Focus();
}
else if (string.IsNullOrWhiteSpace(Contexto.Descripcion))
{
resultado = false;
mensaje = Properties.Resources.AlmacenEdicion_MsgDescripcionRequerida;
txtDescripcion.Focus();
}
else if (string.IsNullOrWhiteSpace(Contexto.CodigoAlmacen))
{
resultado = false;
mensaje = Properties.Resources.AlmacenEdicion_MsgCodigoAlmacenRequerida;
txtCodigoAlmacen.Focus();
}
else if (Contexto.Organizacion == null || Contexto.Organizacion.OrganizacionID == 0)
{
resultado = false;
mensaje = Properties.Resources.AlmacenEdicion_MsgOrganizacionIDRequerida;
skAyudaOrganizacion.AsignarFoco();
}
else if (Contexto.TipoAlmacen.TipoAlmacenID == 0)
{
resultado = false;
mensaje = Properties.Resources.AlmacenEdicion_MsgTipoAlmacenIDRequerida;
cmbTipoAlmacen.Focus();
}
else if (validaProveedor && (Contexto.Proveedor == null || Contexto.Proveedor.ProveedorID == 0))
{
resultado = false;
mensaje = Properties.Resources.AlmacenEdicion_MsgProveedorRequerido;
skAyudaProveedor.AsignarFoco();
}
else if (cmbActivo.SelectedItem == null)
{
resultado = false;
mensaje = Properties.Resources.AlmacenEdicion_MsgActivoRequerida;
cmbActivo.Focus();
}
else if (validaProveedor)
{
if (Contexto.AlmacenID == 0 && Contexto.Proveedor != null && Contexto.Proveedor.ProveedorID > 0)
{
var proveedorAlmacenPL = new ProveedorAlmacenPL();
var proveedorAlmacenInfo = new ProveedorAlmacenInfo
{
Proveedor = Contexto.Proveedor,
Almacen = new AlmacenInfo
{
TipoAlmacenID = Contexto.TipoAlmacen.TipoAlmacenID
},
Activo = EstatusEnum.Activo
};
ProveedorAlmacenInfo proveedorAlmacen =
proveedorAlmacenPL.ObtenerPorProveedorTipoAlmacen(proveedorAlmacenInfo);
if (proveedorAlmacen != null)
{
resultado = false;
mensaje = Properties.Resources.AlmacenEdicion_MsgProveedorAlmacenExistente;
skAyudaProveedor.AsignarFoco();
}
}
}
else
{
int almacenId = Extensor.ValorEntero(txtAlmacenID.Text);
string descripcion = txtDescripcion.Text;
var almacenPL = new AlmacenPL();
AlmacenInfo almacen = almacenPL.ObtenerPorDescripcion(descripcion);
if (almacen == null)
{
return(true);
}
if (almacen.TipoAlmacen.TipoAlmacenID != Contexto.TipoAlmacen.TipoAlmacenID && almacen.Organizacion.OrganizacionID == Contexto.Organizacion.OrganizacionID)
{
bool tieneProductos = almacenPL.ValidarProductosEnAlmacen(almacen);
if (tieneProductos)
{
mensaje = Properties.Resources.AlmacenEdicion_MsgTipoAlmacenCambio;
resultado = false;
}
}
if ((almacenId == 0 || almacenId != almacen.AlmacenID) && almacen.Organizacion.OrganizacionID == Contexto.Organizacion.OrganizacionID)
{
resultado = false;
mensaje = string.Format(
Properties.Resources.AlmacenEdicion_MsgDescripcionExistente, almacen.AlmacenID);
}
}
}
catch (Exception ex)
{
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
if (!string.IsNullOrWhiteSpace(mensaje))
{
SkMessageBox.Show(this, mensaje, MessageBoxButton.OK, MessageImage.Warning);
}
return(resultado);
}
private IList <PolizaInfo> ObtenerPoliza(PolizaContratoModel datosContrato)
{
var polizasContrato = new List <PolizaInfo>();
int folioPedido = datosContrato.Contrato.Folio;
int organizacionID = datosContrato.Contrato.Organizacion.OrganizacionID;
DateTime fechaPedido = datosContrato.Contrato.Fecha;
int miliSegunda = DateTime.Now.Millisecond;
string archivoFolio = ObtenerArchivoFolio(fechaPedido);
OrganizacionInfo organizacion = ObtenerOrganizacionIVA(organizacionID);
var tipoContrato = (TipoContratoEnum)datosContrato.Contrato.TipoContrato.TipoContratoId;
var tipoPolizaEnum = TipoPoliza.PolizaContratoTerceros;
switch (tipoContrato)
{
case TipoContratoEnum.EnTransito:
tipoPolizaEnum = TipoPoliza.PolizaContratoTransito;
break;
}
TipoPolizaInfo tipoPoliza =
TiposPoliza.FirstOrDefault(clave => clave.TipoPolizaID == tipoPolizaEnum.GetHashCode());
if (tipoPoliza == null)
{
throw new ExcepcionServicio(string.Format("{0} {1}", "EL TIPO DE POLIZA",
TipoPoliza.PolizaContratoTerceros));
}
string textoDocumento = tipoPoliza.TextoDocumento;
string tipoMovimiento = tipoPoliza.ClavePoliza;
string postFijoRef3 = tipoPoliza.PostFijoRef3;
var ref3 = new StringBuilder();
ref3.Append("03");
ref3.Append(Convert.ToString(folioPedido).PadLeft(10, ' '));
ref3.Append(new Random(10).Next(10, 20));
ref3.Append(new Random(30).Next(30, 40));
ref3.Append(miliSegunda);
ref3.Append(postFijoRef3);
//string numeroDocumento = ObtenerNumeroReferencia;
string numeroDocumento = ObtenerNumeroReferenciaFolio(datosContrato.AlmacenMovimiento.FolioMovimiento);
var proveedorAlmacenBL = new ProveedorAlmacenBL();
ProveedorAlmacenInfo proveedorAlmacen =
proveedorAlmacenBL.ObtenerPorProveedorId(datosContrato.Contrato.Proveedor);
if (proveedorAlmacen == null)
{
throw new ExcepcionServicio(string.Format("EL PROVEEDOR {0} NO TIENE ALMACEN ASIGNADO",
datosContrato.Contrato.Proveedor.Descripcion));
}
decimal importe = datosContrato.Contrato.Precio * datosContrato.Contrato.Cantidad;
var renglon = 1;
var datos = new DatosPolizaInfo
{
NumeroReferencia = numeroDocumento,
FechaEntrada = datosContrato.Contrato.Fecha,
Folio = datosContrato.Contrato.Folio.ToString(),
Importe =
string.Format("{0}", importe.ToString("F2")),
Renglon = Convert.ToString(renglon),
ImporteIva = "0",
Ref3 = ref3.ToString(),
Cuenta = datosContrato.Contrato.Cuenta.CuentaSAP,
ArchivoFolio = archivoFolio,
DescripcionCosto = datosContrato.Contrato.Cuenta.Descripcion,
PesoOrigen = Math.Round(Convert.ToDecimal(datosContrato.Contrato.Cantidad), 0),
Division = organizacion.Division,
TipoDocumento = textoDocumento,
ClaseDocumento = postFijoRef3,
Concepto = String.Format("{0}-{1} {2} {3} {4} ${5} {6}",
tipoMovimiento,
datosContrato.Contrato.Folio,
datosContrato.Contrato.Cantidad.ToString("N0"),
"KGS", datosContrato.Contrato.Producto.Descripcion,
importe.ToString("N2"), postFijoRef3),
Sociedad = organizacion.Sociedad,
Segmento = string.Format("{0}{1}", PrefijoSegmento, organizacion.Sociedad),
};
PolizaInfo poliza = GeneraRegistroPoliza(datos);
polizasContrato.Add(poliza);
renglon++;
datos = new DatosPolizaInfo
{
NumeroReferencia = numeroDocumento,
FechaEntrada = datosContrato.Contrato.Fecha,
Folio = datosContrato.Contrato.Folio.ToString(),
ClaveProveedor = datosContrato.Contrato.Proveedor.CodigoSAP,
Importe =
string.Format("{0}", (importe * -1).ToString("F2")),
Renglon = Convert.ToString(renglon),
Division = organizacion.Division,
ImporteIva = "0",
Ref3 = ref3.ToString(),
ArchivoFolio = archivoFolio,
DescripcionCosto = datosContrato.Contrato.Proveedor.Descripcion,
PesoOrigen = Math.Round(Convert.ToDecimal(datosContrato.Contrato.Cantidad), 0),
TipoDocumento = textoDocumento,
ClaseDocumento = postFijoRef3,
Concepto = String.Format("{0}-{1} {2} {3} {4} ${5} {6}",
tipoMovimiento,
datosContrato.Contrato.Folio,
datosContrato.Contrato.Cantidad.ToString("N0"),
"KGS", datosContrato.Contrato.Producto.Descripcion,
importe.ToString("N2"), postFijoRef3),
Sociedad = organizacion.Sociedad,
Segmento = string.Format("{0}{1}", PrefijoSegmento, organizacion.Sociedad),
};
poliza = GeneraRegistroPoliza(datos);
polizasContrato.Add(poliza);
return(polizasContrato);
}
private void ObtenerDatosProveedorAlmacen(string filtro)
{
try
{
if (string.IsNullOrEmpty(filtro))
{
skAyudaProveedores.Info = new ProveedorInfo
{
ListaTiposProveedor = new List <TipoProveedorInfo>
{
new TipoProveedorInfo
{
TipoProveedorID = TipoProveedorEnum.ProveedoresDeMateriaPrima.GetHashCode()
},
new TipoProveedorInfo
{
TipoProveedorID = TipoProveedorEnum.ProveedoresFletes.GetHashCode()///Descomentar
}
},
Activo = EstatusEnum.Activo
};
return;
}
if (skAyudaProveedores.Info == null)
{
skAyudaProveedores.Info = new ProveedorInfo
{
ListaTiposProveedor = new List <TipoProveedorInfo>
{
new TipoProveedorInfo
{
TipoProveedorID = TipoProveedorEnum.ProveedoresDeMateriaPrima.GetHashCode()
},
new TipoProveedorInfo
{
TipoProveedorID = TipoProveedorEnum.ProveedoresFletes.GetHashCode()///Descomentar
}
},
Activo = EstatusEnum.Activo
};
return;
}
if (skAyudaProveedores.Info.TipoProveedor.TipoProveedorID !=
TipoProveedorEnum.ProveedoresDeMateriaPrima.GetHashCode() && skAyudaProveedores.Info.TipoProveedor.TipoProveedorID !=
TipoProveedorEnum.ProveedoresFletes.GetHashCode())///Descomentar
{
skAyudaProveedores.Info = new ProveedorInfo
{
ListaTiposProveedor = new List <TipoProveedorInfo>
{
new TipoProveedorInfo
{
TipoProveedorID = TipoProveedorEnum.ProveedoresDeMateriaPrima.GetHashCode()
},
new TipoProveedorInfo
{
TipoProveedorID = TipoProveedorEnum.ProveedoresFletes.GetHashCode()///Descomentar
}
},
Activo = EstatusEnum.Activo
};
skAyudaProveedores.LimpiarCampos();
skAyudaProveedores.AsignarFoco();
SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
Properties.Resources.CrearContrato_MensajeProveedorInvalido,
MessageBoxButton.OK,
MessageImage.Stop);
}
else
{
var proveedorAlmacen = new ProveedorAlmacenInfo();
var proveedorAlmacenPl = new ProveedorAlmacenPL();
var proveedor = new ProveedorInfo();
var proveedorPl = new ProveedorPL();
proveedor = proveedorPl.ObtenerPorCodigoSAP(new ProveedorInfo()
{
CodigoSAP = filtro
});
if (proveedor != null)
{
proveedorAlmacen = proveedorAlmacenPl.ObtenerPorProveedorId(proveedor);
if (proveedorAlmacen != null)
{
skAyudaProveedores.Info = new ProveedorInfo
{
ListaTiposProveedor = new List <TipoProveedorInfo>
{
new TipoProveedorInfo
{
TipoProveedorID = TipoProveedorEnum.ProveedoresDeMateriaPrima.GetHashCode()
},
new TipoProveedorInfo
{
TipoProveedorID = TipoProveedorEnum.ProveedoresFletes.GetHashCode()///Descomentar
}
},
Activo = EstatusEnum.Activo
};
}
else
{
skAyudaProveedores.Info = new ProveedorInfo
{
ListaTiposProveedor = new List <TipoProveedorInfo>
{
new TipoProveedorInfo
{
TipoProveedorID = TipoProveedorEnum.ProveedoresDeMateriaPrima.GetHashCode()
},
new TipoProveedorInfo
{
TipoProveedorID = TipoProveedorEnum.ProveedoresFletes.GetHashCode()///Descomentar
}
},
Activo = EstatusEnum.Activo
};
skAyudaProveedores.LimpiarCampos();
SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
Properties.Resources.CrearContrato_MensajeProveedorSinAlmacen,
MessageBoxButton.OK,
MessageImage.Stop);
}
}
else
{
skAyudaProveedores.Info = new ProveedorInfo
{
ListaTiposProveedor = new List <TipoProveedorInfo>
{
new TipoProveedorInfo
{
TipoProveedorID = TipoProveedorEnum.ProveedoresDeMateriaPrima.GetHashCode()
},
new TipoProveedorInfo
{
TipoProveedorID = TipoProveedorEnum.ProveedoresFletes.GetHashCode()///Descomentar
}
},
Activo = EstatusEnum.Activo
};
skAyudaProveedores.LimpiarCampos();
skAyudaProveedores.AsignarFoco();
SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
Properties.Resources.CrearContrato_MensajeProveedorInvalido,
MessageBoxButton.OK,
MessageImage.Stop);
}
}
}
catch (Exception ex)
{
Logger.Error(ex);
}
}
/// <summary>
///
/// </summary>
/// <returns></returns>
internal static Dictionary <string, object> ObtenerParametrosObtenerPorProveedorTipoAlmacen(ProveedorAlmacenInfo info)
{
try
{
Logger.Info();
var parametros =
new Dictionary <string, object>
{
{ "@ProveedorID", info.Proveedor.ProveedorID },
{ "@TipoAlmacenID", info.Almacen.TipoAlmacenID },
{ "@Activo", info.Activo.GetHashCode() },
};
return(parametros);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
