private static ResultadoTransaccion Usuario1AgregarHouseBL(PaperlessUsuario1HousesBL housebl, SqlConnection connparam, SqlTransaction tranparam)
{
resTransaccion = new ResultadoTransaccion();
Int64 IdHouse = 0;
try {
objParams = SqlHelperParameterCache.GetSpParameterSet(connparam, "SP_N_PAPERLESS_USUARIO1_HOUSESBL");
objParams[0].Value = housebl.IdAsignacion;
objParams[1].Value = housebl.Index;
objParams[2].Value = housebl.HouseBL;
objParams[3].Value = housebl.Freehand;
if (housebl.Cliente != null) objParams[4].Value = housebl.Cliente.Id;
else objParams[4].Value = 0;
if (housebl.TipoCliente != null) objParams[5].Value = housebl.TipoCliente.Id;
else objParams[5].Value = 0;
/*descomentar despues */
/* objParams[6].Value = housebl.ShippingInstruction;
objParams[7].Value = housebl.Puerto;
*/
SqlCommand command = new SqlCommand("SP_N_PAPERLESS_USUARIO1_HOUSESBL", connparam);
command.Parameters.AddRange(objParams);
command.Transaction = tranparam;
command.CommandType = CommandType.StoredProcedure;
IdHouse = Convert.ToInt64(command.ExecuteScalar());
resTransaccion.Estado = Enums.EstadoTransaccion.Aceptada;
resTransaccion.ObjetoTransaccion = IdHouse;
} catch (Exception ex) {
resTransaccion.Estado = Enums.EstadoTransaccion.Rechazada;
resTransaccion.Descripcion = ex.Message;
Log.EscribirLog(ex.Message);
}
return resTransaccion;
}
private static ResultadoTransaccion Usuario1MarcaHouseRuteado(PaperlessUsuario1HousesBL house, SqlConnection connparam, SqlTransaction tranparam)
{
resTransaccion = new ResultadoTransaccion();
try {
objParams = SqlHelperParameterCache.GetSpParameterSet(connparam, "SP_U_PAPERLESS_USUARIO1_HOUSESBL");
objParams[0].Value = house.Ruteado;
objParams[1].Value = house.Id;
SqlCommand command = new SqlCommand("SP_U_PAPERLESS_USUARIO1_HOUSESBL", connparam);
command.Parameters.AddRange(objParams);
command.CommandType = CommandType.StoredProcedure;
command.Transaction = tranparam;
command.ExecuteNonQuery();
resTransaccion.Estado = Enums.EstadoTransaccion.Aceptada;
} catch (Exception ex) {
resTransaccion.Estado = Enums.EstadoTransaccion.Rechazada;
resTransaccion.Descripcion = ex.Message;
Log.EscribirLog(ex.Message);
}
return resTransaccion;
}
public static IList<PaperlessUsuario1HousesBL> Usuario1ObtenerHousesBL(Int64 IdAsignacion)
{
PaperlessUsuario1HousesBL house = null;
IList<PaperlessUsuario1HousesBL> houses = new List<PaperlessUsuario1HousesBL>();
try {
//Abrir Conexion
conn = BaseDatos.NuevaConexion();
objParams = SqlHelperParameterCache.GetSpParameterSet(conn, "SP_C_PAPERLESS_USUARIO1_HOUSEBL");
objParams[0].Value = IdAsignacion;
SqlCommand command = new SqlCommand("SP_C_PAPERLESS_USUARIO1_HOUSEBL", conn);
command.Parameters.AddRange(objParams);
command.CommandType = CommandType.StoredProcedure;
dreader = command.ExecuteReader();
while (dreader.Read()) {
house = new PaperlessUsuario1HousesBL();
house.Id = Convert.ToInt64(dreader["Id"]);
house.IdAsignacion = Convert.ToInt64(dreader["IdAsignacion"]);
house.Index = Convert.ToInt16(dreader["IndexHouse"]);
house.HouseBL = dreader["HouseBL"].ToString();
house.Freehand = Convert.ToBoolean(dreader["Freehand"].ToString());
if (dreader["Ruteado"] is DBNull)
house.Ruteado = false;
else
house.Ruteado = Convert.ToBoolean(dreader["Ruteado"]);
if (dreader["IdCliente"] is DBNull)
house.Cliente = null;
else
house.Cliente = Clientes.clsClienteMasterADO.ObtenerClienteMasterPorId(Convert.ToInt64(dreader["IdCliente"]));
if (dreader["IdTipoCliente"] is DBNull)
house.TipoCliente = null;
else
house.TipoCliente = new PaperlessTipoCliente() { Id = Convert.ToInt16(dreader["IdTipoCliente"].ToString()), Nombre = dreader["TipoCliente"].ToString() };
if (dreader["EmbarcadorContactado"] is DBNull)
house.EmbarcadorContactado = false;
else
house.EmbarcadorContactado = Convert.ToBoolean(dreader["EmbarcadorContactado"]);
if (dreader["ReciboAperturaEmbarcador"] is DBNull)
house.ReciboAperturaEmbarcador = false;
else
house.ReciboAperturaEmbarcador = Convert.ToBoolean(dreader["ReciboAperturaEmbarcador"]);
if (dreader["FechaReciboAperturaEmbarcador"] is DBNull)
house.FechaReciboAperturaEmbarcador = null;
else
house.FechaReciboAperturaEmbarcador = Convert.ToDateTime(dreader["FechaReciboAperturaEmbarcador"]);
if (dreader["TipoReciboAperturaEmbarcador"] is DBNull)
house.TipoReciboAperturaEmbarcador = Enums.PaperlessTipoReciboAperturaEmbarcador.NoDefinido;
else
house.TipoReciboAperturaEmbarcador =
(Enums.PaperlessTipoReciboAperturaEmbarcador)
Convert.ToInt16(dreader["TipoReciboAperturaEmbarcador"]);
if (dreader["RecargoCollect"] is DBNull)
house.ExcepcionRecargoCollect = null;
else
house.ExcepcionRecargoCollect = new PaperlessExcepcion() {
RecargoCollect = Convert.ToBoolean(dreader["RecargoCollect"]),
Id = Convert.ToInt64(dreader["IdExcepcion"])
};
try {
if (dreader["Observacion"] is DBNull)
house.Observacion = "";
else
house.Observacion = dreader["Observacion"].ToString();
if (dreader["PaperlessTipoRecibo"] is DBNull) {
if (house.Cliente != null && house.Cliente.Cuenta != null)
house.Cliente.Cuenta.TipoReciboAperturaEmbarcador = Enums.PaperlessTipoReciboAperturaEmbarcador.NoDefinido;
} else if (house.Cliente != null && house.Cliente.Cuenta != null) {
//LogicaNegocios.Clientes.clsCuentas.BuscarCuentaPorId(house.Cliente);
house.Cliente.Cuenta.TipoReciboAperturaEmbarcador = (Enums.PaperlessTipoReciboAperturaEmbarcador)Convert.ToInt16(dreader["PaperlessTipoRecibo"]);
}
if (dreader["Shippinginstruction"] is DBNull)
house.ShippingInstruction = "";
else
house.ShippingInstruction = dreader["Shippinginstruction"].ToString();
if (dreader["puerto"] is DBNull)
house.Puerto = "";
else
house.Puerto = dreader["puerto"].ToString();
} catch (Exception ex) {
Log.EscribirLog(ex.Message);
}
houses.Add(house);
}
} catch (Exception ex) {
Base.Log.Log.EscribirLog(ex.Message);
} finally {
conn.Close();
}
return houses;
}
public static ResultadoTransaccion Usuario2ActualizaHouseBL(PaperlessUsuario1HousesBL house, SqlConnection connparam, SqlTransaction tranparam)
{
resTransaccion = new ResultadoTransaccion();
try {
objParams = SqlHelperParameterCache.GetSpParameterSet(connparam, "SP_U_USUARIO2_HOUSESBL");
objParams[0].Value = house.EmbarcadorContactado;
objParams[1].Value = house.ReciboAperturaEmbarcador;
objParams[2].Value = house.FechaReciboAperturaEmbarcador;
objParams[3].Value = house.TipoReciboAperturaEmbarcador;
objParams[4].Value = house.Id;
objParams[5].Value = house.Observacion;
SqlCommand command = new SqlCommand("SP_U_USUARIO2_HOUSESBL", connparam);
command.Parameters.AddRange(objParams);
command.CommandType = CommandType.StoredProcedure;
command.Transaction = tranparam;
command.ExecuteNonQuery();
resTransaccion.Estado = Enums.EstadoTransaccion.Aceptada;
} catch (Exception ex) {
resTransaccion.Estado = Enums.EstadoTransaccion.Rechazada;
resTransaccion.Descripcion = ex.Message;
Log.EscribirLog(ex.Message);
}
return resTransaccion;
}
public static ResultadoTransaccion Usuario1GuardaHousesBLDesdeExcepcion(PaperlessUsuario1HousesBL houses, PaperlessUsuario1HouseBLInfo info, PaperlessPasosEstado paso)
{
return AccesoDatos.Paperless.clsPaperlessADO.Usuario1GuardaHousesBLDesdeExcepcion(houses, info, paso);
}
public static ResultadoTransaccion Usuario1GuardaHousesBLDesdeExcepcion(PaperlessUsuario1HousesBL h,
PaperlessUsuario1HouseBLInfo info,
PaperlessPasosEstado paso)
{
ResultadoTransaccion resultado = new ResultadoTransaccion();
conn = Base.BaseDatos.BaseDatos.NuevaConexion();
SqlTransaction transaction = conn.BeginTransaction();
bool esupdate = false;
IList<PaperlessUsuario1HousesBL> houses = new List<PaperlessUsuario1HousesBL>();
houses.Add(h);
try {
//Eliminar Info anterior
//resultado = Usuario1EliminarHousesBLFull(houses[0].IdAsignacion, conn, transaction);
//if (resultado.Estado == Enums.EstadoTransaccion.Rechazada)
// throw new Exception(resultado.Descripcion);
//Registrar houses
foreach (var house in houses) {
if (house.IsNew) {
if (house.Cliente != null && house.Cliente.IsNew) {
resultado = Clientes.clsClienteMasterADO.GuardarClienteMaster(house.Cliente, conn, transaction);
if (resultado.Estado == Enums.EstadoTransaccion.Rechazada)
throw new Exception(resultado.Descripcion);
else {
house.Cliente.Id = Convert.ToInt64(resultado.ObjetoTransaccion);
}
}
resultado = Usuario1AgregarHouseBL(house, conn, transaction);
if (resultado.Estado == Enums.EstadoTransaccion.Rechazada)
throw new Exception(resultado.Descripcion);
else {
house.Id = Convert.ToInt64(resultado.ObjetoTransaccion);
}
//verificar si tiene recargo collect
if (house.ExcepcionRecargoCollect != null) {
house.ExcepcionRecargoCollect.IdAsignacion = house.IdAsignacion;
house.ExcepcionRecargoCollect.HouseBL.Id = house.Id;
resultado = Usuario1MarcaIngresoExcepcion(house.ExcepcionRecargoCollect, conn, transaction);
}
if (resultado.Estado == Enums.EstadoTransaccion.Rechazada)
throw new Exception(resultado.Descripcion);
} else {
if (house.Cliente != null && house.Cliente.IsNew) {
resultado = Clientes.clsClienteMasterADO.GuardarClienteMaster(house.Cliente, conn, transaction);
if (resultado.Estado == Enums.EstadoTransaccion.Rechazada)
throw new Exception(resultado.Descripcion);
else {
house.Cliente.Id = Convert.ToInt64(resultado.ObjetoTransaccion);
}
}
resultado = Usuario1ActualizaPaso1(house, conn, transaction);
if (resultado.Estado == Enums.EstadoTransaccion.Rechazada)
throw new Exception(resultado.Descripcion);
esupdate = true;
if (house.ExcepcionRecargoCollect != null)
resultado = Usuario1ActualizaExcepcion(house.ExcepcionRecargoCollect, conn, transaction);
if (resultado.Estado == Enums.EstadoTransaccion.Rechazada)
throw new Exception(resultado.Descripcion);
}
}
//cambiar estado paso
resultado = Usuario1CambiarEstadoPaso(paso, conn, transaction);
if (resultado.Estado == Enums.EstadoTransaccion.Rechazada)
throw new Exception(resultado.Descripcion);
transaction.Commit();
resultado.Estado = Enums.EstadoTransaccion.Aceptada;
} catch (Exception ex) {
transaction.Rollback();
resultado.Estado = Enums.EstadoTransaccion.Rechazada;
resultado.Descripcion = ex.Message;
} finally {
conn.Close();
}
return resultado;
}
public PaperlessExcepcion()
{
HouseBL = new PaperlessUsuario1HousesBL();
}
private void CargarPaso1HousesBL()
{
IList<PaperlessUsuario1HousesBL> housesnew = new List<PaperlessUsuario1HousesBL>();
IList<PaperlessUsuario1HousesBL> houses =
LogicaNegocios.Paperless.Paperless.Usuario1ObtenerHousesBL(PaperlessAsignacionActual.Id);
if (houses == null || houses.Count == 0)
{
//generar items para houses
for (int i = 1; i <= int.Parse(txtP1CantHouses.Text); i++)
{
PaperlessUsuario1HousesBL house = new PaperlessUsuario1HousesBL();
house.Index = i;
house.IdAsignacion = PaperlessAsignacionActual.Id;
house.Freehand = false;
house.HouseBL = "";
house.ExcepcionRecargoCollect = new PaperlessExcepcion() { RecargoCollect = false };
housesnew.Add(house);
}
}
else
{
housesnew = houses;
}
if (int.Parse(txtP1CantHouses.Text) > housesnew.Count)
{
for (int i = housesnew.Count + 1; i <= int.Parse(txtP1CantHouses.Text); i++)
{
PaperlessUsuario1HousesBL house = new PaperlessUsuario1HousesBL();
house.Index = i;
house.IdAsignacion = PaperlessAsignacionActual.Id;
house.Freehand = false;
house.HouseBL = "";
house.ExcepcionRecargoCollect = new PaperlessExcepcion() { RecargoCollect = false };
housesnew.Add(house);
}
}
grdP1DigitarHousesBL.DataSource = housesnew;
grdP1DigitarHousesBL.RefreshDataSource();
//Cargar Info Houses BL
PaperlessUsuario1HouseBLInfo info =
LogicaNegocios.Paperless.Paperless.Usuario1ObtenerHousesBLInfo(PaperlessAsignacionActual.Id);
if (info != null)
{
txtP1CantHouses.Text = info.CantHouses.ToString();
txtP1NumConsolidado.Text = info.NumConsolidado.ToString();
//txtP1NumHouse.Text = info.NumHouse.ToString();
//ddlP1Cliente.SelectedItem = info.Cliente;
//txtP1Cliente.Text = info.Cliente.ToString();
}
PaperlessAsignacionActual.DataUsuario1.Paso1HousesBL = housesnew;
PaperlessAsignacionActual.DataUsuario1.Paso1HousesBLInfo = info;
}
private void GeneraDummy(PaperlessUsuario1HousesBL house, int i)
{
var item = new IntegracionNetShip();
item.HouseBl = "hblsDummy" + i;
item.Rut = i.ToString();
item.Cliente = "ClienteDummy";
item.TipoCliente = "Directo";
item.Ruteado = true;
item.ShippingInstruction = "";
item.Puerto = "";
return;
}
private bool ValidaTipoReciboAperturaEmbarcador(PaperlessUsuario1HousesBL houses)
{
if (houses.Cliente != null && houses.Cliente.Cuenta != null) {
var cta = houses.Cliente.Cuenta;
if (cta.TipoReciboAperturaEmbarcador != Enums.PaperlessTipoReciboAperturaEmbarcador.NoDefinido)
if (houses.TipoReciboAperturaEmbarcador != cta.TipoReciboAperturaEmbarcador) {
return true;
}
}
return false;
}
private void AgregarDetalle_Click(object sender, EventArgs e)
{
IList<PaperlessExcepcion> excepciones = (IList<PaperlessExcepcion>)grdExcepciones.DataSource;
var item = new PaperlessExcepcion() { RecargoCollect = false, IdUsuarioUltimaModificacion = Base.Usuario.UsuarioConectado.Usuario.Id };
IList<PaperlessUsuario1HousesBL> listhouses = (IList<PaperlessUsuario1HousesBL>)grdP1DigitarHousesBL.DataSource;
//emulamos la excepcion como un house a mostrar
PaperlessUsuario1HousesBL house = new PaperlessUsuario1HousesBL();
house.Index = excepciones.Count + 1;
house.IdAsignacion = PaperlessAsignacionActual.Id;
item.IdAsignacion = PaperlessAsignacionActual.Id;
house.Freehand = false;
var pasoexcepcion = Obtiene_Excepcion();
if (pasoexcepcion != null) {
house.HouseBL = pasoexcepcion.HouseBL.HouseBL;// (excObtiene_Excepcionepciones.Count + 1).ToString();
}
house.Id = listhouses[0].Id;
house.ExcepcionRecargoCollect = new PaperlessExcepcion() { HouseBL = house, RecargoCollect = false, IdAsignacion = PaperlessAsignacionActual.Id };
house.TipoCliente = new PaperlessTipoCliente { Id = 1 };
item.HouseBL = house;
excepciones.Add(item);
PaperlessPasosEstado paso = ObtenerPasoSeleccionado();
Entidades.GlobalObject.ResultadoTransaccion resultado = LogicaNegocios.Paperless.Paperless.Usuario1IngresarExcepxiones(excepciones, paso);
grdExcepciones.DataSource = excepciones;
grdExcepciones.RefreshDataSource();
}
private void TxtActualizarNetShip_Click_1(object sender, EventArgs e)
{
_mensajemostrado = false;
IList<PaperlessUsuario1HousesBL> housesnew = new List<PaperlessUsuario1HousesBL>();
IList<PaperlessUsuario1HousesBL> houses =
LogicaNegocios.Paperless.Paperless.Usuario1ObtenerHousesBL(PaperlessAsignacionActual.Id);
if (houses == null || houses.Count == 0) {
for (int i = 1; i <= int.Parse(txtP1CantHouses.Text); i++) {
PaperlessUsuario1HousesBL house = new PaperlessUsuario1HousesBL();
house.Index = i;
house.IdAsignacion = PaperlessAsignacionActual.Id;
house.Freehand = false;
house.ExcepcionRecargoCollect = new PaperlessExcepcion() { RecargoCollect = false };
//house = IntegracionNetShip(house, i, "sp_SCC_HouseBLs");
house = IntegracionNetShip(house, i, "sp_SCC_HouseBLs" + "_" + DdlEmpresa.SelectedText);
housesnew.Add(house);
}
} else {
housesnew = houses;
}
if (int.Parse(txtP1CantHouses.Text) > housesnew.Count) {
for (int i = housesnew.Count + 1; i <= int.Parse(txtP1CantHouses.Text); i++) {
PaperlessUsuario1HousesBL house = new PaperlessUsuario1HousesBL();
house.Index = i;
house.IdAsignacion = PaperlessAsignacionActual.Id;
house.Freehand = false;
house.HouseBL = "";
house.ExcepcionRecargoCollect = new PaperlessExcepcion() { RecargoCollect = false };
housesnew.Add(house);
}
}
grdP1DigitarHousesBL.DataSource = housesnew;
grdP1DigitarHousesBL.RefreshDataSource();
//Cargar Info Houses BL
PaperlessUsuario1HouseBLInfo info =
LogicaNegocios.Paperless.Paperless.Usuario1ObtenerHousesBLInfo(PaperlessAsignacionActual.Id);
if (info != null) {
txtP1CantHouses.Text = PaperlessAsignacionActual.NumHousesBL.ToString();
txtP1NumConsolidado.Text = info.NumConsolidado;
}
PaperlessAsignacionActual.DataUsuario1.Paso1HousesBL = housesnew;
PaperlessAsignacionActual.DataUsuario1.Paso1HousesBLInfo = info;
//if (info != null)
// GuardaRegLogCarga(PaperlessAsignacionActual.Id32, (info.CantHouses - _regError).ToString(), "", "Registros OK: " + (info.CantHouses - _regError));
//GuardaRegLogCarga(PaperlessAsignacionActual.Id32, "", _regError.ToString(), "Reglas Procesadas :" + _regError);
}
private void TxtActualizarNetShipClick(object sender, EventArgs e)
{
if (IsBrasil) {
if (DdlEmpresa.SelectedItem != null && !string.IsNullOrEmpty(DdlEmpresa.SelectedItem.ToString())) {
_mensajemostrado = false;
IList<PaperlessUsuario1HousesBL> housesnew = new List<PaperlessUsuario1HousesBL>();
IList<PaperlessUsuario1HousesBL> houses = LogicaNegocios.Paperless.Paperless.Usuario1ObtenerHousesBL(PaperlessAsignacionActual.Id);
if (houses == null || houses.Count == 0) {
for (int i = 1; i <= int.Parse(txtP1CantHouses.Text); i++) {
PaperlessUsuario1HousesBL house = new PaperlessUsuario1HousesBL();
house.Index = i;
house.IdAsignacion = PaperlessAsignacionActual.Id;
house.Freehand = false;
house.ExcepcionRecargoCollect = new PaperlessExcepcion() { RecargoCollect = false };
house = IntegracionNetShip(house, i, "sp_SCC_HouseBLs" + "_" + DdlEmpresa.Properties.Items[DdlEmpresa.SelectedIndex].ToString());
housesnew.Add(house);
}
} else {
housesnew = houses;
}
if (int.Parse(txtP1CantHouses.Text) > housesnew.Count) {
for (int i = housesnew.Count + 1; i <= int.Parse(txtP1CantHouses.Text); i++) {
PaperlessUsuario1HousesBL house = new PaperlessUsuario1HousesBL();
house.Index = i;
house.IdAsignacion = PaperlessAsignacionActual.Id;
house.Freehand = false;
house.HouseBL = "";
house.ExcepcionRecargoCollect = new PaperlessExcepcion() { RecargoCollect = false };
housesnew.Add(house);
}
}
grdP1DigitarHousesBL.DataSource = housesnew;
grdP1DigitarHousesBL.RefreshDataSource();
//Cargar Info Houses BL
PaperlessUsuario1HouseBLInfo info =
LogicaNegocios.Paperless.Paperless.Usuario1ObtenerHousesBLInfo(PaperlessAsignacionActual.Id);
if (info != null) {
txtP1CantHouses.Text = PaperlessAsignacionActual.NumHousesBL.ToString();
txtP1NumConsolidado.Text = info.NumConsolidado;
}
PaperlessAsignacionActual.DataUsuario1.Paso1HousesBL = housesnew;
PaperlessAsignacionActual.DataUsuario1.Paso1HousesBLInfo = info;
GuardaRegLogCarga(PaperlessAsignacionActual.Id32, reglasAplicadas.ToString(), reglasConError.ToString(), "Resumen Reglas Aplicadas:" + reglasAplicadas + " Error :" + reglasConError, (Int32)PaperlessTipoErrorLog.PaperlessTipoError.Resumen);
}
} else {
_mensajemostrado = false;
IList<PaperlessUsuario1HousesBL> housesnew = new List<PaperlessUsuario1HousesBL>();
IList<PaperlessUsuario1HousesBL> houses = LogicaNegocios.Paperless.Paperless.Usuario1ObtenerHousesBL(PaperlessAsignacionActual.Id);
if (houses == null || houses.Count == 0) {
for (int i = 1; i <= int.Parse(txtP1CantHouses.Text); i++) {
PaperlessUsuario1HousesBL house = new PaperlessUsuario1HousesBL();
house.Index = i;
house.IdAsignacion = PaperlessAsignacionActual.Id;
house.Freehand = false;
house.ExcepcionRecargoCollect = new PaperlessExcepcion() { RecargoCollect = false };
//house = IntegracionNetShip(house, i, "sp_SCC_HouseBLs");
house = IntegracionNetShip(house, i, "sp_SCC_HouseBLs" + "_" + DdlEmpresa.Properties.Items[DdlEmpresa.SelectedIndex].ToString());
housesnew.Add(house);
}
} else {
housesnew = houses;
}
if (int.Parse(txtP1CantHouses.Text) > housesnew.Count) {
for (int i = housesnew.Count + 1; i <= int.Parse(txtP1CantHouses.Text); i++) {
PaperlessUsuario1HousesBL house = new PaperlessUsuario1HousesBL();
house.Index = i;
house.IdAsignacion = PaperlessAsignacionActual.Id;
house.Freehand = false;
house.HouseBL = "";
house.ExcepcionRecargoCollect = new PaperlessExcepcion() { RecargoCollect = false };
housesnew.Add(house);
}
}
grdP1DigitarHousesBL.DataSource = housesnew;
grdP1DigitarHousesBL.RefreshDataSource();
//Cargar Info Houses BL
PaperlessUsuario1HouseBLInfo info =
LogicaNegocios.Paperless.Paperless.Usuario1ObtenerHousesBLInfo(PaperlessAsignacionActual.Id);
if (info != null) {
txtP1CantHouses.Text = PaperlessAsignacionActual.NumHousesBL.ToString();
txtP1NumConsolidado.Text = info.NumConsolidado;
}
PaperlessAsignacionActual.DataUsuario1.Paso1HousesBL = housesnew;
PaperlessAsignacionActual.DataUsuario1.Paso1HousesBLInfo = info;
GuardaRegLogCarga(PaperlessAsignacionActual.Id32, reglasAplicadas.ToString(), reglasConError.ToString(), "Resumen Reglas Aplicadas:" + reglasAplicadas + " Error :" + reglasConError, (Int32)PaperlessTipoErrorLog.PaperlessTipoError.Resumen);
}
}
private PaperlessTipoCliente ObtieneTipodeCliente(PaperlessUsuario1HousesBL house)
{
clsCuenta cuenta = new clsCuenta();
PaperlessTipoCliente ptc = new PaperlessTipoCliente();
if (house.Cliente != null) {
var transaccion = LogicaNegocios.Clientes.clsCuentas.BuscarCuentaPorId(house.Cliente.Id);
if (transaccion != null) {
cuenta = (clsCuenta)transaccion.ObjetoTransaccion;
if (cuenta != null && cuenta.ClienteMaster.ClienteMasterTipoCliente != null) {
if (cuenta.ClienteMaster.ClienteMasterTipoCliente.Count.Equals(0) ||
cuenta.ClienteMaster.ClienteMasterTipoCliente.Count > 1) {
house.TipoCliente = null;
} else {
ptc.Nombre = cuenta.ClienteMaster.ClienteMasterTipoCliente[0].Nombre;
ptc.Id = cuenta.ClienteMaster.ClienteMasterTipoCliente[0].Id;
house.TipoCliente = ptc;
}
}
}
}
return house.TipoCliente;
}
private PaperlessUsuario1HousesBL IntegracionNetShip(PaperlessUsuario1HousesBL house, int i, string storeProcedureName)
{
try {
Int32 regVarios = Convert.ToInt32(System.Configuration.ConfigurationSettings.AppSettings.Get("regVarios"));
if (netShips == null || netShips.Equals(0))
netShips = LogicaNegocios.Integracion.Integracion.ObtenerHousesBlDesdeNetShip(PaperlessAsignacionActual.NumMaster, storeProcedureName);
//clsClienteMaster clienteNuevo = null;
//-debe enviar un mensaje cuando la cantidad de hoses BL sea distinta
if (_mensajemostrado != true)
if (Convert.ToInt32(txtP1CantHouses.Text) != netShips.Count) {
MessageBox.Show(@"La cantidad de Hbls :" + txtP1CantHouses.Text + @" ingresadas es distinta a la de NetShip :"
+ netShips.Count, @"Paperless", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);//@" ,Favor modifique el valor de la asignacion para no ver este mensaje"
GuardaRegLogCarga(PaperlessAsignacionActual.Id32, txtP1CantHouses.Text, netShips.Count.ToString(),
@"Existe una diferencia entre los valores de hbls", (Int32)PaperlessTipoErrorLog.PaperlessTipoError.DifValoresBls);
reglasAplicadas++;
_mensajemostrado = true;
}
if (netShips.Count > 0) {
try {
house.HouseBL = netShips[i - 1].HouseBl;//-Número BL
var rut = netShips[i - 1].Rut; //-Rut del Cliente.
var shippingInstruction = netShips[i - 1].ShippingInstruction;
if (shippingInstruction != null)
house.ShippingInstruction = shippingInstruction;
var port = netShips[i - 1].Puerto;
if (port != null)
house.Puerto = port;
if (rut != null && !string.IsNullOrEmpty(rut)) {
var cliente = netShips[i - 1].Cliente;
//-Si el Rut existe el sistema debe buscar en la base de datos y cargarlo con la información
//que existe en el sistema para que este cliente se muestre en la pantalla de ingreso de Bls
house.Cliente = LogicaNegocios.Clientes.clsClientesMaster.ObtenerClienteMasterPorRut(rut);
#region si el rut no existe debe crear un nuevo cliente, pero de tipo paperless con la información que actualmente está enviando NetShip
if (cliente != null && house.Cliente == null && !string.IsNullOrEmpty(cliente)) {
house.Cliente = CargaClientePaperlessNuevo(cliente, rut);
GuardaRegLogCarga(PaperlessAsignacionActual.Id32, "", rut, " Se creo el Cliente " + house.Cliente.Id32 + " con Rut :" + rut, (Int32)PaperlessTipoErrorLog.PaperlessTipoError.RutNoExiste);
reglasAplicadas++;
}
#endregion
} else//-colocar el "varios" cuando el cliente no esté creado en el sistema,-si no viene rut , registro debe ser varios.
{
house.Cliente = LogicaNegocios.Clientes.clsClientesMaster.ObtenerClienteMasterPorId(regVarios);
GuardaRegLogCarga(PaperlessAsignacionActual.Id32, "", "", "No viene Rut desde NetShip", (Int32)PaperlessTipoErrorLog.PaperlessTipoError.RegVarios);
reglasAplicadas++;
}
house.Ruteado = netShips[i - 1].Ruteado;//-Indicar si es Ruteado o no
var consolidada = netShips[i - 1].Consolidada;
if (consolidada != null)
txtP1NumConsolidado.Text = consolidada;//- Número Consolidado
else {
GuardaRegLogCarga(PaperlessAsignacionActual.Id32, "", "", "No viene Numero de Consolidada", (Int32)PaperlessTipoErrorLog.PaperlessTipoError.SinNumeroConsolidada);
reglasAplicadas++;
}
#region-va a prevalecer el tipo de cliente que tenga paperless, al momento de la carga.
PaperlessTipoCliente ptc = ObtieneTipodeCliente(house);//-Tipo de Cliente
#region Agrega Tipo Cliente de la integracion si desde el ClienteMaster retorna null
if (ptc == null) {
ptc = new PaperlessTipoCliente();
if (netShips[i - 1].TipoCliente.Equals("Directo")) {
ptc.Nombre = "Directo";
ptc.Id = 2;
} else {
ptc.Nombre = "Embarcador";
ptc.Id = 1;
}
}
GuardaRegLogCarga(PaperlessAsignacionActual.Id32, "", ptc.Nombre, " Tipo de Cliente NetShip", (Int32)PaperlessTipoErrorLog.PaperlessTipoError.DobleDefinicionPpValorNetShip);
reglasConError++;
house.TipoCliente = ptc;
#endregion
#endregion
} catch (Exception ex) {
Log.EscribirLog(ex.Message);
}
} else {
GuardaRegLogCarga(PaperlessAsignacionActual.Id32, PaperlessAsignacionActual.NumMaster, "", "No se encontro Numero Master", (Int32)PaperlessTipoErrorLog.PaperlessTipoError.SinNumeroMaster);
reglasAplicadas++;
}
} catch (Exception ex) {
Base.Log.Log.EscribirLog(ex.Message);
}
return house;
}