//Funcion para la consulta del semaforo de disponiblidad de un item dentro de un almacen
//Si es 0 : No hay - Rojo
//Si es 1 : Cantidad Menor a Minimo - Amarillo
//Si es 2 : Cantidad Superior a Minimo - Verde
public static int ConsultaSemaforoDisponibilidad(string codI, string codAlm, uint mes, int ano)
{
int indentificadorEstado = -1;
double disponibilidad = Referencias.ConsultarDisponibilidad(codI, codAlm, ano.ToString(), 0);
int minimoDisponible = Referencias.CalcularMinimoDisponible(codI, mes, ano);
if (disponibilidad == 0)
{
try
{
disponibilidad = Convert.ToDouble(DBFunctions.SingleData("SELECT case when mi.tori_codigo = 'Z' THEN 0 ELSE COALESCE(msal_canttransito,0) END FROM CINVENTARIO CI, mitems mi, msaldoitemalmacen ms WHERE mi.mite_codigo = ms.mite_codigo AND palm_almacen='" + codAlm + "' AND MS.pano_ano=CI.PANO_ANO AND mi.mite_codigo='" + codI + "' ").Trim());
}
catch
{
disponibilidad = 0;
}
if (disponibilidad > 0) // hay transito unicamente
{
indentificadorEstado = 3;
disponibilidad = 0;
}
else
{
indentificadorEstado = 0;
}
}
else if (disponibilidad >= 1 && disponibilidad <= Convert.ToDouble(minimoDisponible))
{
indentificadorEstado = 2;
}
else if (disponibilidad > Convert.ToDouble(minimoDisponible))
{
indentificadorEstado = 1;
}
return(indentificadorEstado);
}
private ArrayList Armar_Inserts(DataSet ds, DataSet ds1)
{
DataTable tabla1 = ds1.Tables[0];
DataTable tabla2 = ds.Tables[0];
ArrayList sqls = new ArrayList();
int cont = 0;
DataSet dsLineas = new DataSet();
DBFunctions.Request(dsLineas, IncludeSchema.NO, "SELECT PLIN_TIPO,PLIN_CODIGO FROM DBXSCHEMA.PLINEAITEM; SELECT MITE_CODIGO FROM MITEMS;");
for (int i = 0; i < ds1.Tables[0].Rows.Count; i++)
{
string sql = "INSERT INTO " + ddltabla.SelectedValue + " VALUES(";
bool validaMitem = true;
//crear dataset para las lineas
for (int j = 0; j < ds1.Tables[0].Columns.Count; j++)
{
if (j != ds1.Tables[0].Columns.Count - 1)
{
if (ddltabla.SelectedValue == "MITEMS" && j == 0)
{
DataRow[] laLinea = dsLineas.Tables[0].Select("PLIN_CODIGO = '" + ds1.Tables[0].Rows[i]["PLIN_CODIGO"] + "'");
string refer = "";
if (laLinea.Length > 0)
{
if (!Referencias.Guardar(ds1.Tables[0].Rows[i]["MITE_CODIGO"].ToString(), ref refer, laLinea[0].ItemArray[0].ToString()))
{
err += "<p style=\"COLOR: red\"> Item Inválido " + ds1.Tables[0].Rows[i]["MITE_CODIGO"].ToString() + " Por favor revise la Fila número " + (i + 2) + " en su archivo Excel</p><br>";
validaMitem = false;
break;
}
else
{
/*if (dsLineas.Tables[1].Select("MITE_CODIGO = '" + refer + "'").Length > 0)
* {
* err += "<p style=\"COLOR: red\"> Item Inválido " + ds1.Tables[0].Rows[i]["MITE_CODIGO"].ToString() + ", Existe en la Base de Datos, Por favor revise su excel en la linea " + (i+2) + "</p><br>";
* }*/
sql += Analizar_Campo(refer, ds.Tables[0].Rows[j][2].ToString(), ds.Tables[0].Rows[j][4].ToString(), ref err, ds1.Tables[0].Columns[j].ColumnName, i, ref cont) + ",";
}
}
else
{
err += "<p style=\"COLOR: red\"> Linea Inválida " + ds1.Tables[0].Rows[i]["PLIN_CODIGO"].ToString() + " Por favor revise la Fila número " + (i + 2) + " en su archivo Excel</p><br>";
validaMitem = false;
break;
}
}
else
{
sql += Analizar_Campo(ds1.Tables[0].Rows[i][j].ToString(), ds.Tables[0].Rows[j][2].ToString(), ds.Tables[0].Rows[j][4].ToString(), ref err, ds1.Tables[0].Columns[j].ColumnName, i, ref cont) + ",";
}
}
else
{
sql += Analizar_Campo(ds1.Tables[0].Rows[i][j].ToString(), ds.Tables[0].Rows[j][2].ToString(), ds.Tables[0].Rows[j][4].ToString(), ref err, ds1.Tables[0].Columns[j].ColumnName, i, ref cont) + ")";
}
}
//if (cont < 1)
//{
// sqls.Add(sql);
// cont = 0;
//}
if (validaMitem)
{
sqls.Add(sql);
}
}
//if (cont == 0)
//return null;
return(sqls);
}
protected bool insertTable(DataTable table1, DataTable table2)
{
if (ddltabla.SelectedValue == "MITEMS")
{
//CAMBIAR REFERENCIA POR MEDIO DE LA LINEA
for (int i = 0; i < table2.Rows.Count; i++)
{
string codItAlma = "";
Referencias.Guardar(table2.Rows[i][0].ToString().Replace('"', ' ').Trim(), ref codItAlma, DBFunctions.SingleData("SELECT plin_tipo FROM plineaitem WHERE plin_codigo='" + table2.Rows[i][2].ToString().Trim() + "'"));
table2.Rows[i][0] = codItAlma;
}
}
//Insert
bool rta = false;
string servidor = ConfigurationManager.AppSettings["Server" + GlobalData.getEMPRESA()];
string database = ConfigurationManager.AppSettings["DataBase" + GlobalData.getEMPRESA()];
string usuario = ConfigurationManager.AppSettings["UID"];
string password = ConfigurationManager.AppSettings["PWD" + GlobalData.getEMPRESA()];
string timeout = ConfigurationManager.AppSettings["ConnectionTimeout"];
string port = ConfigurationManager.AppSettings["DataBasePort"];
AMS.CriptoServiceProvider.Crypto miCripto = new Crypto(AMS.CriptoServiceProvider.Crypto.CryptoProvider.TripleDES);
miCripto.IV = ConfigurationManager.AppSettings["VectorInicialEncriptacion"];
miCripto.Key = ConfigurationManager.AppSettings["ValorConcatClavePrivada"];
string newPwd = miCripto.DescifrarCadena(password);
string connectionString = "Server=" + servidor + ":" + port + ";DataBase=" + database + ";UID=" + usuario + ";PWD=" + newPwd + "";
//IBM.Data.DB2.DB2BulkCopy dbBulkcopy = new IBM.Data.DB2.DB2BulkCopy(connectionString, IBM.Data.DB2.DB2BulkCopyOptions.KeepIdentity);
using (var dbBulkcopy = new IBM.Data.DB2.DB2BulkCopy(connectionString, IBM.Data.DB2.DB2BulkCopyOptions.Default))
{
// my DataTable column names match my SQL Column names, so I simply made this loop. However if your column names don't match, just pass in which datatable name matches the SQL column name in Column Mappings
if (table1.Rows.Count == table2.Columns.Count)
{
foreach (DataColumn col in table2.Columns)
{
dbBulkcopy.ColumnMappings.Add(col.ColumnName, col.ColumnName);
}
dbBulkcopy.BulkCopyTimeout = 600;
dbBulkcopy.DestinationTableName = ddltabla.SelectedValue;
try
{
dbBulkcopy.WriteToServer(table2);
dbBulkcopy.Close();
DBFunctions.closeConnection();
rta = true;
}
catch (Exception z)
{
dbBulkcopy.Close();
DBFunctions.closeConnection();
rta = false;
Utils.MostrarAlerta(Response, "No se ingresó ningún registro debido a que el archivo Excel presenta fallas. \n Por favor revise su archivo o pruebe con el botón Revisar y Subir");
lbError.Text = z.Message;
}
}
}
return(rta);
}
//Funcion que nos permite consultar cual es el disponible de una referencia, revise como parametros de entrada
//el codigo del item a consultar,un mes y un año especifico para realizar la consulta, un entero referencia que guarda el pedido sugerido,
//la funcion retorna un entero indicador del tipo de sugerido que es el item :
//Alta Rotacion : 10
//Media Rotacion : 20
//Estudio Profundo : 30
//Sobre Stock : 40
public static int ConsultarSugerido(DataRow drItem, int mes, int ano, int dia, ref int sugerido, ref double demandaPromedioSalida, DataSet dsParaInven)
{
int frecuenciaPedido = 0;
int mesesDemanda = 0;
double demandaPromedio = 0, cicloReposicion = 0, stockSeguridad = 0, Qactual = 0, Qtransito = 0, Qbackorder = 0, costoPromedio = 0, valorFrontera = 0;
bool indicadorEstudioProfundo = false;
string codI = drItem["mite_codigo"].ToString();
//Traemos el nit del proveedor de este item
string nitProveedor = drItem["mnit_nit"].ToString();
//Ahora determinamos como se van a tomar los acumulados de los items
int mesPivote = mes - 1;
int anoPivote = ano;
double Qminimo = 0, QDisponible = 0, Qmaximo = 0;
//Traemos la cantidadactual,
//la cantidad en transicion y el backorder de clientes
//try { Qactual = Convert.ToDouble(DBFunctions.SingleData("SELECT msal_cantactual - msal_cantasig + msal_unidtrans FROM msaldoitem WHERE mite_codigo='" + codI + "' AND pano_ano=" + ano + "")); }
//catch { }
Qactual = Convert.ToDouble(drItem["qactual"]);
//try { Qtransito = Convert.ToDouble(DBFunctions.SingleData("SELECT msal_unidtrans FROM msaldoitem WHERE mite_codigo='" + codI + "' AND pano_ano=" + ano + "")); }
//catch { }
Qtransito = Convert.ToDouble(drItem["qtrans"]);
//try { Qbackorder = Convert.ToDouble(DBFunctions.SingleData("SELECT msal_unidpendi FROM msaldoitem WHERE mite_codigo='" + codI + "' AND pano_ano=" + ano + "")); }
//catch { }
Qbackorder = Convert.ToDouble(drItem["qbo"]);
Qbackorder = 0; // TEMPOARAL PORQUE ESTA VARIABLE NO ESTA PERFECTAMENTE BALANCEADA CON LOS DATOS DE DPEDIDOITEM
//try { costoPromedio = Convert.ToDouble(DBFunctions.SingleData("SELECT msal_costprom FROM msaldoitem WHERE mite_codigo='" + codI + "' AND pano_ano=" + ano + "")); }
//catch { }
costoPromedio = Convert.ToDouble(drItem["msal_costprom"]);
//try { cicloReposicion = Convert.ToDouble(DBFunctions.SingleData("SELECT mpro_clicrepo FROM mproveedor WHERE mnit_nit='" + nitProveedor + "'")); }
//catch { cicloReposicion = Convert.ToDouble(dsParaInven.Tables[0].Rows[0][8]); }
cicloReposicion = Convert.ToDouble(drItem["mpro_clicrepo"]);
//try { frecuenciaPedido = Convert.ToInt32(DBFunctions.SingleData("SELECT mpro_frecpedimes FROM mproveedor WHERE mnit_nit='" + nitProveedor + "'")); }
//catch { frecuenciaPedido = Convert.ToInt32(dsParaInven.Tables[0].Rows[0][7]); }
frecuenciaPedido = Convert.ToInt32(drItem["mpro_frecpedimes"]);
//try { stockSeguridad = Convert.ToDouble(DBFunctions.SingleData("SELECT mpro_stocksegu FROM mproveedor WHERE mnit_nit='" + nitProveedor + "'")); }
//catch { stockSeguridad = Convert.ToDouble(dsParaInven.Tables[0].Rows[0][9]); }
stockSeguridad = Convert.ToDouble(drItem["mpro_stocksegu"]);
try { valorFrontera = Convert.ToInt32(dsParaInven.Tables[0].Rows[0][19]); }
catch { valorFrontera = 1000000; }
//if (DBFunctions.SingleData("SELECT plin_tipo FROM plineaitem WHERE plin_codigo=(SELECT plin_codigo FROM mitems WHERE mite_codigo='" + codI + "')") != "RN")
if (drItem["plin_tipo"].ToString() != "RN")
{
////////////////////////////////////////////////////////////////////////////////////////
///////////////Manejo de Sugerido Referencias Mazda/////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////
//Debemos cargar los 6 ponderadores
double[] ponderadores = new double[6];
ponderadores[0] = (Convert.ToDouble(dsParaInven.Tables[0].Rows[0][13]) / 100); //Ponderador 1
ponderadores[1] = (Convert.ToDouble(dsParaInven.Tables[0].Rows[0][14]) / 100); //Ponderador 2
ponderadores[2] = (Convert.ToDouble(dsParaInven.Tables[0].Rows[0][15]) / 100); //Ponderador 3
ponderadores[3] = (Convert.ToDouble(dsParaInven.Tables[0].Rows[0][16]) / 100); //Ponderador 4
ponderadores[4] = (Convert.ToDouble(dsParaInven.Tables[0].Rows[0][17]) / 100); //Ponderador 5
ponderadores[5] = (Convert.ToDouble(dsParaInven.Tables[0].Rows[0][18]) / 100); //Ponderador 6
//Con el nit del proveedor ahora traemos el valor del ciclo de reposicion y la frecuencia de pedido, si los valores son nulos en la base de datos traemos los valores por defecto que almacenamos en cinventario
double[] acumuladosMeses = new double[6];
//Ahora determinamos desde que mes tomamos el semestre si desde el actual o el anterior
//Si el acumulado del mes actual es mayor que el del mes anterior el pivote es el mes actual
//Si el acumulado del mes anterior es mayor que el del mes actual el pivote es el mes anterior
if (Convert.ToDouble(drItem["D0"].ToString()) >= Convert.ToDouble(drItem["D1"].ToString()))
{
acumuladosMeses[0] = Convert.ToDouble(drItem["D0"].ToString());
acumuladosMeses[1] = Convert.ToDouble(drItem["D1"].ToString());
acumuladosMeses[2] = Convert.ToDouble(drItem["D2"].ToString());
acumuladosMeses[3] = Convert.ToDouble(drItem["D3"].ToString());
acumuladosMeses[4] = Convert.ToDouble(drItem["D4"].ToString());
acumuladosMeses[5] = Convert.ToDouble(drItem["D5"].ToString());
}
else
{
acumuladosMeses[0] = Convert.ToDouble(drItem["D1"].ToString());
acumuladosMeses[1] = Convert.ToDouble(drItem["D2"].ToString());
acumuladosMeses[2] = Convert.ToDouble(drItem["D3"].ToString());
acumuladosMeses[3] = Convert.ToDouble(drItem["D4"].ToString());
acumuladosMeses[4] = Convert.ToDouble(drItem["D5"].ToString());
acumuladosMeses[5] = Convert.ToDouble(drItem["D6"].ToString());
}
//Ya tenemos el mes de pivote y en que año. Ahora debemos calcular cual es la demanda promedio para los ultimos seis meses desde el mes de pivote
for (int i = 0; i < 6; i++)
{
if (acumuladosMeses[i] > 0)
{
mesesDemanda += 1;
}
demandaPromedio += acumuladosMeses[i] * ponderadores[5 - i];
}
indicadorEstudioProfundo = Referencias.RevisionDemandaMeses(acumuladosMeses, 6);
demandaPromedioSalida = demandaPromedio;
//Ahora calculamos el Qminimo, QDisponible y Qmaximo
if (cicloReposicion < 0 || cicloReposicion > 10)
{
cicloReposicion = 1;
}
if (frecuenciaPedido < 1 || frecuenciaPedido > 15)
{
frecuenciaPedido = 1;
}
Qminimo = demandaPromedio * cicloReposicion;
QDisponible = Qactual + Qtransito - Qbackorder;
Qmaximo = Qminimo + (demandaPromedio / frecuenciaPedido);
if (QDisponible >= Qminimo)
{
sugerido = 0;
return(40); //Sobre Stock
}
else
{
sugerido = (int)Math.Round(Qmaximo - QDisponible);
if (costoPromedio > valorFrontera || indicadorEstudioProfundo)
{
return(30);
}
else if (mesesDemanda >= 4)
{
return(10);
}
else if (mesesDemanda < 4)
{
return(20);
}
}
}
else
{
////////////////////////////////////////////////////////////////////////////////////////
///////////////Manejo de Sugerido Referencias Renault///////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////
if (mesPivote <= 0)
{
mesPivote = 12;
anoPivote = anoPivote - 1;
}
//traemos el acumulado de la demanda de los ultimos seis meses sin contar el mes seleccionado
double acumuladosDemandasMeses = 0;
double[] acumuladosMeses = new double[6];
for (int i = 0; i < 6; i++)
{
double acumMes = 0;
try { acumMes = Convert.ToDouble(DBFunctions.SingleData("SELECT mACU_cantidad FROM mACUMULADOitem WHERE mite_codigo='" + codI + "' AND pano_ano=" + anoPivote + " AND pmes_mes=" + mesPivote + " AND TMOV_TIPOMOVI = 70 ")); }
catch { }
if (acumMes >= 0)
{
acumuladosDemandasMeses += acumMes;
mesesDemanda += 1;
}
acumuladosMeses[i] = acumMes;
mesPivote = mesPivote - 1;
if (mesPivote <= 0)
{
mesPivote = 12;
anoPivote = anoPivote - 1;
}
}
indicadorEstudioProfundo = Referencias.RevisionDemandaMeses(acumuladosMeses, 6);
//Ahora este acumulado lo dividimos en 6(meses) y luego en 22(cantidad dias manejados sofasa)
acumuladosDemandasMeses = acumuladosDemandasMeses / 6;
acumuladosDemandasMeses = acumuladosDemandasMeses / 22;
//Ahora traemos la cantidad acumulada del mes y que año que entraron como parametro
//Si el dia de consulta es mayor a 22 se divide por 22 sino por la cantidad de dias transcurridoas
double cantidadMesActual = 0;
try { cantidadMesActual = Convert.ToDouble(DBFunctions.SingleData("SELECT mACU_cantidad FROM mACUMULADOitem WHERE mite_codigo='" + codI + "' AND pano_ano=" + ano + " AND pmes_mes=" + mes + " AND TMOV_TIPOMOVI = 70 ")); }
catch { }
if (dia > 22)
{
cantidadMesActual = cantidadMesActual / 22;
}
else
{
cantidadMesActual = cantidadMesActual / dia;
}
//Ahora se suma la demandapromedio diara del mes actual con las demanda diaria promedia de los ultimos seis meses
double demandaPromedioDiaria = cantidadMesActual + acumuladosDemandasMeses;
if (frecuenciaPedido == 0)
{
frecuenciaPedido = 1;
}
Qmaximo = demandaPromedioDiaria * ((1 / frecuenciaPedido) + cicloReposicion + stockSeguridad);
Qminimo = Qmaximo;
QDisponible = Qactual + Qtransito - Qbackorder;
if (QDisponible > Qmaximo)
{
sugerido = 0;
return(40); //Sobre Stock
}
else
{
sugerido = (int)Math.Round(Qmaximo - QDisponible);
if (costoPromedio > valorFrontera || indicadorEstudioProfundo)
{
return(30);
}
else if (mesesDemanda >= 4)
{
return(10);
}
else if (mesesDemanda < 4)
{
return(20);
}
}
}
return(0);
}
