private void EnviarABandaTransportadora(PickingArgumento argumento)
        {
            if (argumento.ManejaLineaDePicking)
            {
                var servicio = new BandaAtoxAriumWS.BandaAtoxAriumSoapClient();

                foreach (var encabezado in argumento.Encabezados)
                {
                    var resultado = "";
                    if (encabezado.BOX_QTY > 0)
                    {
                        int idDeInduccion = servicio.RegistroEncabezado(encabezado.LINE_DOC, encabezado.BOX_QTY, ref resultado);
                        if (resultado == "OK")
                        {
                            var operacionDeInduccion = ColocaIdDeIndcuccionATareaDeLineaDePicking(encabezado.LINE_DOC, idDeInduccion);
                            if (operacionDeInduccion.Resultado == ResultadoOperacionTipo.Error)
                            {
                                throw new Exception(operacionDeInduccion.Mensaje);
                            }
                            if (argumento.EsConsolidado)
                            {
                                return;
                            }
                        }
                    }
                }
            }
        }
Пример #2
0
        public void AjustarPrioridadVehiculos()
        {
            BuildData();
            var argumento = new PickingArgumento()
            {
                Vehiculos      = Vehiculos,
                PrioridadNueva = 22,
                Vehiculo       = Vehiculos[7]
            };

            using (var sw = File.CreateText("D:\\CSV\\vehiculosSinOrdenar.csv"))
            {
                foreach (var r in Vehiculos)
                {
                    sw.WriteLine(r.VEHICLE_CODE + "," + r.VEHICLE + "," + r.PRIORITY);
                }
            }

            var resultado = DemandaDeDespachoServicio.AjustarPrioridadVehiculos(argumento);

            using (var sw = File.CreateText("D:\\CSV\\vehiculosOrdenados.csv"))
            {
                foreach (var r in resultado)
                {
                    sw.WriteLine(r.VEHICLE_CODE + "," + r.VEHICLE + "," + r.PRIORITY);
                }
            }

            Assert.IsTrue(resultado.Count > 0);
        }
        public IList <VehiculoManifiesto> ProcesarDemandaParaVehiculos(ref PickingArgumento argumento)
        {
            if (argumento.Encabezados == null || argumento.Vehiculos == null)
            {
                return(argumento.Vehiculos);
            }
            var pedidosOrdenados = argumento.PrioridadOrden == PrioridadVehiculos.Volumen
                ? argumento.Encabezados.OrderByDescending(e => e.ORDER_VOLUME).ThenByDescending(e => e.ORDER_WEIGHT).ToList()
                : argumento.Encabezados.OrderByDescending(e => e.ORDER_WEIGHT).ThenByDescending(e => e.ORDER_VOLUME).ToList();

            foreach (var vehiculo in from v in argumento.Vehiculos
                     orderby v.PRIORITY ascending
                     select v)
            {
                vehiculo.Ordenes.Clear();
                if (pedidosOrdenados.Count <= 0)
                {
                    continue;
                }
                var pesoDisponible    = vehiculo.ORIGINAL_AVAILABLE_WEIGHT;
                var volumenDisponible = vehiculo.ORIGINAL_AVAILABLE_VOLUME;

                vehiculo.USED_WEIGHT = vehiculo.ORIGINAL_USED_WEIGHT;
                vehiculo.USED_VOLUME = vehiculo.ORIGINAL_USED_VOLUME;

                foreach (var pedido in pedidosOrdenados)
                {
                    if (pesoDisponible < pedido.ORDER_WEIGHT || volumenDisponible < pedido.ORDER_VOLUME)
                    {
                        continue;
                    }
                    pesoDisponible    -= pedido.ORDER_WEIGHT;
                    volumenDisponible -= pedido.ORDER_VOLUME;

                    vehiculo.USED_WEIGHT += pedido.ORDER_WEIGHT;
                    vehiculo.USED_VOLUME += pedido.ORDER_VOLUME;

                    vehiculo.Ordenes.Add(pedido);
                }

                vehiculo.AVAILABLE_WEIGHT = pesoDisponible;
                vehiculo.AVAILABLE_VOLUME = volumenDisponible;

                pedidosOrdenados.RemoveAll(p => vehiculo.Ordenes.Contains(p));
            }

            foreach (var v in from veh in argumento.Vehiculos
                     where veh.IS_OWN == (int)Tipos.TipoDeVehiculo.SinVehiculo
                     select veh)
            {
                v.Ordenes = pedidosOrdenados;
            }

            argumento.Encabezados = pedidosOrdenados;
            return(argumento.Vehiculos);
        }
Пример #4
0
        public Operacion CrearManifiestoDeCargaDesdeDemandaDeDespacho(PickingArgumento argumento, VehiculoManifiesto vehiculo)
        {
            try
            {
                var listadoEncabezado = argumento.Encabezados.Select(x =>
                                                                     new ManifiestoDetalle()
                {
                    PICKING_DEMAND_HEADER_ID = x.PICKING_DEMAND_HEADER_ID,
                    WAVE_PICKING_ID          = x.WAVE_PICKING_ID
                }).ToList()
                ;
                var serializer    = new XmlSerializer(typeof(List <ManifiestoDetalle>));
                var xmlDocumentos = new StringWriter();
                var xmlWriter     = new XmlTextWriter(xmlDocumentos)
                {
                    Formatting = Formatting.Indented
                };
                serializer.Serialize(xmlWriter, listadoEncabezado);
                var xml = xmlDocumentos.ToString();

                DbParameter[] parameters =
                {
                    new OAParameter
                    {
                        ParameterName = "@VEHICLE_CODE",
                        Value         = vehiculo.VEHICLE_CODE
                    },
                    new OAParameter
                    {
                        ParameterName = "@LOGIN",
                        Value         = argumento.Login
                    }
                    ,
                    new OAParameter
                    {
                        ParameterName = "@XML",
                        Value         = xml
                    }
                };
                return(BaseDeDatosServicio.ExecuteQuery <Operacion>(BaseDeDatosServicio.Esquema + ".OP_WMS_SP_CREATE_MANIFEST_FROM_PICKING_DEMAND", CommandType.StoredProcedure, false, parameters).FirstOrDefault());
            }
            catch (Exception e)
            {
                return(new Operacion
                {
                    Resultado = ResultadoOperacionTipo.Error,
                    Mensaje = e.Message,
                    Codigo = -1
                });
            }
        }
        private Poliza CrearPoliza(PickingArgumento argumento, OrdenDeVentaEncabezado encabezado)
        {
            var operacionPoliza = CrearPolizaDeDespachoDeUnaOrdenDeVenta(encabezado, argumento.Login, argumento.TipoDespacho);

            if (operacionPoliza.Resultado == ResultadoOperacionTipo.Error)
            {
                throw new Exception("Error. No se pudo crear la poliza de despacho " + encabezado.SALES_ORDER_ID + ": " + operacionPoliza.Mensaje);
            }

            var poliza = new Poliza {
                CODIGO_POLIZA = operacionPoliza.DbData
            };

            return(poliza);
        }
 public IList <ReportePicking> ObtenerReportePicking(PickingArgumento argumento)
 {
     DbParameter[] parameters =
     {
         new OAParameter
         {
             ParameterName = "@START_DATE",
             Value         = argumento.FechaInicial
         },
         new OAParameter
         {
             ParameterName = "@END_DATE",
             Value         = argumento.FechaFinal
         }
     };
     return(BaseDeDatosServicio.ExecuteQuery <ReportePicking>(BaseDeDatosServicio.Esquema + ".OP_WMS_SP_GET_PICKING_REPORT", CommandType.StoredProcedure, true, parameters).ToList());
 }
        public IList <VehiculoManifiesto> AjustarPrioridadVehiculos(PickingArgumento argumento)
        {
            var vehiculos      = argumento.Vehiculos;
            var vehiculo       = argumento.Vehiculo;
            var prioridadNueva = argumento.PrioridadNueva;

            if (prioridadNueva == vehiculo.PRIORITY)
            {
                return(vehiculos.OrderBy(v => v.PRIORITY).ToList());
            }
            if (prioridadNueva < vehiculo.PRIORITY) // PRIORIDAD NUEVA ES MENOR A LA ACTUAL
            {
                foreach (var v in from veh in vehiculos
                         where veh.PRIORITY >= argumento.PrioridadNueva && veh.PRIORITY < vehiculo.PRIORITY          // ACTUALIZA LOS QUE TIENEN LA PRIORIDAD MENOR A LA PRIORIDAD ACTUAL
                         select veh)
                {
                    v.PRIORITY++;
                }

                foreach (var v in from veh in vehiculos
                         where veh.VEHICLE_CODE == vehiculo.VEHICLE_CODE          // ACTUALIZA EL REGISTRO MODIFICANDOSE
                         select veh)
                {
                    v.PRIORITY = prioridadNueva;
                }
            }
            else // PRIORIDAD NUEVA ES MAYOR A LA ACTUAL
            {
                foreach (var v in from veh in vehiculos
                         where veh.PRIORITY > vehiculo.PRIORITY && veh.PRIORITY <= argumento.PrioridadNueva          // ACTUALIZA AQUELLOS CUYA PRIORIDAD SEA MENOR A LA NUEVA Y MAYOR A LA VIEJA
                         select veh)
                {
                    v.PRIORITY--;
                }

                foreach (var v in from veh in vehiculos
                         where veh.VEHICLE_CODE == vehiculo.VEHICLE_CODE          // ACTUALIZA EL REGISTRO MODIFICANDOSE
                         select veh)
                {
                    v.PRIORITY = prioridadNueva;
                }
            }

            return(vehiculos.OrderBy(v => v.PRIORITY).ToList());
        }
Пример #8
0
        public void ProcesarDemandaParaVehiculos()
        {
            BuildData();
            Vehiculos.ToList().ForEach(x =>
            {
            });
            var argumento = new PickingArgumento
            {
                Encabezados    = Ordenes,
                Vehiculos      = Vehiculos,
                PrioridadOrden = PrioridadVehiculos.Peso
            };

            var resultado = DemandaDeDespachoServicio.ProcesarDemandaParaVehiculos(ref argumento);

            using (var sw = File.CreateText("D:\\CSV\\resultado.csv"))
            {
                foreach (var res in resultado)
                {
                    sw.WriteLine(res.VEHICLE + "," + res.MAX_WEIGHT + "," + res.MAX_VOLUME + "," + res.AVAILABLE_WEIGHT + "," + res.AVAILABLE_VOLUME);
                    foreach (var orden in res.Ordenes)
                    {
                        sw.WriteLine(",,,,," + orden.SALES_ORDER_ID + "," + orden.ORDER_WEIGHT + "," + orden.ORDER_VOLUME);
                    }
                    decimal totalVolumen = 0;
                    decimal totalPeso    = 0;

                    res.Ordenes.ToList().ForEach(r => { totalVolumen += r.ORDER_VOLUME; totalPeso += r.ORDER_WEIGHT; });

                    sw.WriteLine(",,,,,,,," + totalPeso + "," + totalVolumen);
                }
            }

            using (var sw = File.CreateText("D:\\CSV\\ordenesSinVehiculo.csv"))
            {
                foreach (var o in argumento.Encabezados)
                {
                    sw.WriteLine(o.SALES_ORDER_ID + "," + o.ORDER_WEIGHT + "," + o.ORDER_VOLUME);
                }
            }

            Assert.IsTrue(resultado != null);
        }
        void _vista_UsuarioDeseaGrabarOrdenes(object sender, PickingArgumento e)
        {
            var op = PickingServicio.GrabarOrdenes(e.Encabezados);

            if (op.Resultado == ResultadoOperacionTipo.Exito)
            {
                var listaOperadores = new List <string>();

                foreach (var itemPicking in from itemPicking in e.Encabezados let exite = listaOperadores.Any(itemOperador => itemPicking.CODE_USER.Equals(itemOperador)) where !exite select itemPicking)
                {
                    listaOperadores.Add(itemPicking.CODE_USER);
                }

                _vista.TerminoDeGRabar("cpTerminoDeGrabarLimpiarData", listaOperadores, sender);
            }
            else
            {
                _vista.EstablecerError(op.Mensaje, sender);
            }
        }
        public IList <InventarioParaPickingPorEstado> ObtenerInvnentarioPraPickingPorEstado(PickingArgumento argumento)
        {
            DbParameter[] parameters =
            {
                new OAParameter
                {
                    ParameterName = "@XML",
                    Value         = argumento.Xml
                },
                new OAParameter
                {
                    ParameterName = "@CODE_WAREHOUSE",
                    Value         = argumento.CodigoBodega
                },
                new OAParameter
                {
                    ParameterName = "@PROJECT_ID",
                    Value         = argumento.Proyecto.ID
                }
            };

            return(BaseDeDatosServicio.ExecuteQuery <InventarioParaPickingPorEstado>(BaseDeDatosServicio.Esquema + ".OP_WMS_SP_GET_INVENTORY_FOR_PICKING_BY_STATUS_MATERIAL", CommandType.StoredProcedure, parameters).ToList());
        }
        private int CrearDocumentoDemandaDespacho(PickingArgumento argumento, OrdenDeVentaEncabezado encabezado, int wavePickingId, IList <Picking> pickings)
        {
            var tipoDespacho = Enums.GetStringValue(TipoDemandaDespacho.OrdenVenta);

            if (argumento.TipoDespacho == TipoFuenteDemandaDespacho.SolicitudTrasladoErp ||
                argumento.TipoDespacho == TipoFuenteDemandaDespacho.SolicitudTrasladoWms)
            {
                tipoDespacho = Enums.GetStringValue(TipoDemandaDespacho.SolicitudTraslado);
            }

            var demandaHeader = new DemandaDespachoHeader
            {
                IS_FROM_SONDA      = encabezado.IS_FROM_SONDA,
                IS_FROM_ERP        = encabezado.IS_FROM_ERP,
                LAST_UPDATE_BY     = argumento.Login,
                CLIENT_CODE        = encabezado.CLIENT_ID,
                CUSTOMER_NAME      = encabezado.CUSTOMER_NAME,
                CODE_SELLER        = encabezado.CODE_SELLER,
                CODE_ROUTE         = encabezado.CODE_ROUTE,
                CODE_WAREHOUSE     = argumento.Bodega,
                DOC_NUM            = encabezado.SALES_ORDER_ID,
                DOC_NUM_SEQUENCE   = encabezado.DOC_NUM,
                LAST_UPDATE        = DateTime.Now,
                SERIAL_NUMBER      = encabezado.DOC_SERIE,
                TOTAL_AMOUNT       = encabezado.TOTAL_AMOUNT,
                WAVE_PICKING_ID    = wavePickingId,
                IS_COMPLETED       = encabezado.IS_COMPLETED,
                EXTERNAL_SOURCE_ID = encabezado.EXTERNAL_SOURCE_ID,
                DOC_ENTRY          = encabezado.DOC_ENTRY,
                IS_CONSOLIDATED    = argumento.EsConsolidado ? 1 : 0,
                PRIORITY           = encabezado.Prioridad,
                CLIENT_OWNER       = encabezado.CLIENT_OWNER,
                MASTER_ID_SELLER   = encabezado.MASTER_ID_SELLER,
                SELLER_OWNER       = encabezado.SELLER_OWNER,
                OWNER            = encabezado.OWNER,
                SOURCE_TYPE      = Enums.GetStringValue(argumento.TipoDespacho),
                DEMAND_TYPE      = tipoDespacho,
                WAREHOUSE_FROM   = encabezado.WAREHOUSE_FROM,
                WAREHOUSE_TO     = encabezado.WAREHOUSE_TO,
                DELIVERY_DATE    = encabezado.DELIVERY_DATE.GetValueOrDefault().Date,
                ADDRESS_CUSTOMER = encabezado.ADDRESS_CUSTOMER,
                STATE_CODE       = encabezado.STATE_CODE,
                DISCOUNT         = encabezado.DISCOUNT,
                TYPE_DEMAND_CODE = encabezado.TYPE_DEMAND_CODE,
                TYPE_DEMAND_NAME = encabezado.TYPE_DEMAND_NAME
            };

            var op = CrearDemandaDespachoEncabezado(demandaHeader);

            if (op.Resultado == ResultadoOperacionTipo.Error)
            {
                throw new Exception("Error. No se pudo guardar la demanda de despacho de la orden de venta " +
                                    encabezado.SALES_ORDER_ID + ": " + op.Mensaje);
            }
            var pickingDocumentHeader = Convert.ToInt32(op.DbData);
            var demandaDetalle        = encabezado.Detalles.Select(x => new DemandaDespachoDetalle
            {
                ERP_OBJECT_TYPE          = x.ERP_OBJECT_TYPE,
                LINE_NUM                 = x.LINE_SEQ,
                MATERIAL_ID              = x.SKU,
                PRICE                    = x.PRICE,
                PICKING_DEMAND_HEADER_ID = Convert.ToInt32(op.DbData),
                QTY = Convert.ToInt32(x.QTY),
                MASTER_ID_MATERIAL = x.MASTER_ID_MATERIAL,
                MATERIAL_OWNER     = x.MATERIAL_OWNER,
                SOURCE_TYPE        = Enums.GetStringValue(argumento.TipoDespacho),
                TONE          = x.TONE,
                CALIBER       = x.CALIBER,
                DISCOUNT      = x.DISCOUNT,
                DISCOUNT_TYPE = x.DISCOUNT_TYPE,
                IS_BONUS      = x.IS_BONUS
            }).ToList();

            op = CrearDemandaDespachoDetalle(demandaDetalle, pickings);
            if (op.Resultado == ResultadoOperacionTipo.Error)
            {
                throw new Exception(
                          "Error. No se pudo guardar el detalle de la demanda de despacho de la orden de venta " +
                          encabezado.SALES_ORDER_ID + ": " + op.Mensaje);
            }
            return(pickingDocumentHeader);
        }
        public Operacion CrearPickingDeOrdenDeVenta(ref PickingArgumento argumento)
        {
            var wavePickingId = 0;

            try
            {
                var tipoDespacho = Enums.GetStringValue(TipoDemandaDespacho.OrdenVenta);
                if (argumento.TipoDespacho == TipoFuenteDemandaDespacho.SolicitudTrasladoErp ||
                    argumento.TipoDespacho == TipoFuenteDemandaDespacho.SolicitudTrasladoWms)
                {
                    tipoDespacho = Enums.GetStringValue(TipoDemandaDespacho.SolicitudTraslado);
                }

                var serializer    = new XmlSerializer(typeof(List <OrdenDeVentaEncabezado>));
                var xmlDocumentos = new StringWriter();
                var xmlWriter     = new XmlTextWriter(xmlDocumentos)
                {
                    Formatting = Formatting.Indented
                };
                serializer.Serialize(xmlWriter, argumento.Encabezados.ToList());
                var documentos = xmlDocumentos.ToString();

                var source = argumento.TipoDespacho == TipoFuenteDemandaDespacho.OrdenDeEntrega ? "DO - ERP" : Enums.GetStringValue(argumento.TipoDespacho);

                DbParameter[] parameters =
                {
                    new OAParameter
                    {
                        ParameterName = "@LOGIN",
                        Value         = argumento.Login
                    },
                    new OAParameter
                    {
                        ParameterName = "@LOCATION_TARGET",
                        Value         = argumento.Ubicacion.LOCATION_SPOT
                    },
                    new OAParameter
                    {
                        ParameterName = "@IS_CONSOLIDATED",
                        Value         = argumento.EsConsolidado ? 1 : 0
                    },
                    new OAParameter
                    {
                        ParameterName = "@SOURCE",
                        Value         = source,
                    }
                    ,
                    new OAParameter
                    {
                        ParameterName = "@CODE_WAREHOUSE",
                        Value         = argumento.Bodega,
                    }

                    ,
                    new OAParameter
                    {
                        ParameterName = "@DEMAND_TYPE",
                        Value         = tipoDespacho,
                    }
                    ,
                    new OAParameter
                    {
                        ParameterName = "@IN_PICKING_LINE",
                        Value         = argumento.ManejaLineaDePicking ? (int)SiNo.Si : (int)SiNo.No,
                    }
                    ,
                    new OAParameter
                    {
                        ParameterName = "@LINE_ID",
                        Value         = argumento.LineaDePicking,
                    }
                    ,
                    new OAParameter
                    {
                        ParameterName = "@DEMAND",
                        Value         = documentos,
                    }
                    ,
                    new OAParameter
                    {
                        ParameterName = "@IS_FOR_DELIVERY_IMMEDIATE",
                        Value         = argumento.EsDemandaParaEntregaInmediata,
                    }
                    ,
                    new OAParameter
                    {
                        ParameterName = "@PRIORITY",
                        Value         = argumento.PrioridadDeTarea,
                    }
                    ,
                    new OAParameter
                    {
                        ParameterName = "@PROJECT_ID",
                        Value         = argumento.Proyecto.ID == Guid.Empty ? (Guid?)null :  argumento.Proyecto.ID,
                    }
                    ,
                    new OAParameter
                    {
                        ParameterName = "@ORDER_NUMBER",
                        Value         = argumento.NumeroOrden,
                    }
                };
                var resultado = BaseDeDatosServicio.ExecuteQuery <OrdenDeVentaEncabezado>(BaseDeDatosServicio.Esquema + ".OP_WMS_SP_CREATE_DEMAND"
                                                                                          , CommandType.StoredProcedure, false, parameters);
                if (resultado.Count <= 0)
                {
                    throw new Exception("Error inesperado, no se generó el picking.");
                }

                foreach (var encabezado in argumento.Encabezados)
                {
                    var encabezadoResultado = resultado.FirstOrDefault(x => x.ID == encabezado.ID);
                    if (encabezadoResultado == null)
                    {
                        throw new Exception("No se encontró pedido en resultado.");
                    }
                    encabezado.WAVE_PICKING_ID          = encabezadoResultado.WAVE_PICKING_ID;
                    encabezado.PICKING_DEMAND_HEADER_ID = encabezadoResultado.PICKING_DEMAND_HEADER_ID;
                    encabezado.LINE_DOC = encabezadoResultado.LINE_DOC;
                    encabezado.BOX_QTY  = encabezadoResultado.BOX_QTY;
                    wavePickingId       = encabezadoResultado.WAVE_PICKING_ID;
                }
#if !DEBUG
                EnviarABandaTransportadora(argumento);
#endif
            }
            catch (Exception ex)
            {
                return(new Operacion
                {
                    Codigo = -1,
                    Mensaje = ex.Message,
                    Resultado = Tipos.ResultadoOperacionTipo.Error
                });
            }
            return(new Operacion
            {
                Codigo = 0,
                Mensaje = "Proceso Exitoso",
                Resultado = ResultadoOperacionTipo.Exito,
                DbData = wavePickingId.ToString()
            });
        }
        private Operacion CrearPickingDeOrdenDeVenta(OrdenDeVentaEncabezado encabezadoOrden, Poliza poliza
                                                     , int wavePickingId, out IList <Picking> pickings, PickingArgumento argumento)
        {
            try
            {
                string transferRequestId = string.Empty;
                if (argumento.TipoDespacho == TipoFuenteDemandaDespacho.SolicitudTrasladoErp || argumento.TipoDespacho == TipoFuenteDemandaDespacho.SolicitudTrasladoWms)
                {
                    transferRequestId = encabezadoOrden.SALES_ORDER_ID.ToString();
                }

                pickings = (from detalle in encabezadoOrden.Detalles
                            group detalle by detalle.SKU
                            into g
                            select new Picking
                {
                    TASK_OWNER = argumento.Login,
                    TASK_ASSIGNEDTO = argumento.ManejaLineaDePicking ? argumento.LineaDePicking : "",            //Si es de linea se lo asigna si no se queda vacio para la asignación posterior
                    QUANTITY_ASSIGNED = g.Sum(x => x.QTY),
                    CODIGO_POLIZA_TARGET = poliza.CODIGO_POLIZA,
                    MATERIAL_ID = g.Key,
                    BARCODE_ID = g.Max(x => x.BARCODE_ID),
                    ALTERNATE_BARCODE = g.Max(x => x.ALTERNATE_BARCODE),
                    MATERIAL_NAME = g.Max(x => x.DESCRIPTION_SKU),
                    CLIENT_OWNER = g.Max(x => x.MATERIAL_OWNER),
                    CLIENT_NAME = g.Max(x => x.MATERIAL_OWNER),
                    CODE_WAREHOUSE_SOURCE = argumento.Bodega,
                    TONE = g.Max(x => x.TONE),
                    CALIBER = g.Max(x => x.CALIBER),
                    IN_PICKING_LINE = argumento.ManejaLineaDePicking ? (int)SiNo.Si : (int)SiNo.No
                }).ToList();

                Operacion op = new Operacion();
                if (!argumento.EsConsolidado)
                {
                    wavePickingId = 0;
                }

                foreach (var picking in pickings)
                {
                    DbParameter[] parameters =
                    {
                        new OAParameter
                        {
                            ParameterName = "@TASK_OWNER",
                            Value         = picking.TASK_OWNER
                        },
                        new OAParameter
                        {
                            ParameterName = "@TASK_ASSIGNEDTO",
                            Value         = picking.TASK_ASSIGNEDTO
                        },
                        new OAParameter
                        {
                            ParameterName = "@QUANTITY_ASSIGNED",
                            Value         = picking.QUANTITY_ASSIGNED
                        },
                        new OAParameter
                        {
                            ParameterName = "@CODIGO_POLIZA_TARGET",
                            Value         = encabezadoOrden.SALES_ORDER_ID + "-" + Enums.GetStringValue(argumento.TipoDespacho).Replace(" ", "") + '-' + encabezadoOrden.SOURCE_NAME
                        },
                        new OAParameter
                        {
                            ParameterName = "@MATERIAL_ID",
                            Value         = picking.MATERIAL_ID
                        },
                        new OAParameter
                        {
                            ParameterName = "@BARCODE_ID",
                            Value         = picking.BARCODE_ID
                        },
                        new OAParameter
                        {
                            ParameterName = "@ALTERNATE_BARCODE",
                            Value         = picking.ALTERNATE_BARCODE
                        },
                        new OAParameter
                        {
                            ParameterName = "@MATERIAL_NAME",
                            Value         = picking.MATERIAL_NAME
                        },
                        new OAParameter
                        {
                            ParameterName = "@CLIENT_OWNER",
                            Value         = picking.CLIENT_OWNER
                        },
                        new OAParameter
                        {
                            ParameterName = "@CLIENT_NAME",
                            Value         = picking.CLIENT_NAME
                        },
                        new OAParameter
                        {
                            ParameterName = "@IS_FROM_SONDA",
                            Value         = encabezadoOrden.IS_FROM_SONDA
                        },
                        new OAParameter
                        {
                            ParameterName = "@CODE_WAREHOUSE",
                            Value         = picking.CODE_WAREHOUSE_SOURCE
                        },
                        new OAParameter
                        {
                            ParameterName = "@IS_FROM_ERP",
                            Value         = encabezadoOrden.IS_FROM_ERP
                        }
                        ,
                        new OAParameter
                        {
                            ParameterName = "@WAVE_PICKING_ID",
                            Value         = wavePickingId
                        },
                        new OAParameter
                        {
                            ParameterName = "@DOC_ID_TARGET",
                            Value         = picking.CODIGO_POLIZA_TARGET
                        },
                        new OAParameter
                        {
                            ParameterName = "@LOCATION_SPOT_TARGET",
                            Value         = argumento.Ubicacion.LOCATION_SPOT
                        }
                        ,
                        new OAParameter
                        {
                            ParameterName = "@IS_CONSOLIDATED",
                            Value         = argumento.EsConsolidado
                        },
                        new OAParameter
                        {
                            ParameterName = "@SOURCE_TYPE",
                            Value         = Enums.GetStringValue(argumento.TipoDespacho)
                        }
                        ,
                        new OAParameter
                        {
                            ParameterName = "@TRANSFER_REQUEST_ID",
                            Value         = transferRequestId == string.Empty ? null : transferRequestId
                        }
                        ,
                        new OAParameter
                        {
                            ParameterName = "@TONE",
                            Value         = picking.TONE == string.Empty ? null : picking.TONE
                        }
                        ,
                        new OAParameter
                        {
                            ParameterName = "@CALIBER",
                            Value         = picking.CALIBER == string.Empty ? null : picking.CALIBER
                        },
                        new OAParameter
                        {
                            ParameterName = "@IN_PICKING_LINE",
                            Value         = picking.IN_PICKING_LINE
                        }
                    };

                    op = BaseDeDatosServicio.ExecuteQuery <Operacion>
                             (BaseDeDatosServicio.Esquema + ".OP_WMS_SP_INSERT_TASKS_GENERAL_PICKING_DEMAND", CommandType.StoredProcedure, false, parameters)[0];

                    if (op.Resultado == ResultadoOperacionTipo.Error)
                    {
                        throw new Exception(op.Mensaje);
                    }
                    else
                    {
                        wavePickingId = Convert.ToInt32(op.DbData.Split('|')[0]);
                        int QTY_MP = Convert.ToInt32(op.DbData.Split('|')?[1]);
                        picking.WAS_IMPLODED    = QTY_MP > 0 ? 1 : 0;
                        picking.QTY_IMPLODED    = QTY_MP;
                        picking.WAVE_PICKING_ID = wavePickingId;
                    }
                }
                return(op);
            }
            catch (Exception ex)
            {
                pickings = null;
                throw new Exception("Error. No se pudo Insertar Picking de la orden de venta " +
                                    encabezadoOrden.SALES_ORDER_ID + ": " + ex.Message);
            }
        }