public ReportHeaderFormat GetReportInformation(Document document, string template)
        {
            DataSet result = new DataSet();

            // quitamos temporalmente el location del Documento, para q no busque por ese filtro
            Location loc_doc = document.Location;
            document.Location = null;

            //Obtiene los datos del documento a procesar cuando el reporte es de tipo documento
            document = Factory.DaoDocument().Select(new Document { DocID = document.DocID }).First(); //.SelectById(document);
            document.Company = Factory.DaoCompany().SelectById(document.Company);

            document.Location = loc_doc;
            //Convert Object To DataSet


            if (template == WmsSetupValues.HAZMAT_REPORT)
                return ProcessHeaderAndDetailsForHAZMAT(document);
            
            else
            { //DEFAULT

                //Si es Shipment hace un tratamiento especial del document
                if (document.DocType.DocTypeID == SDocType.SalesShipment)
                    return ProcessHeaderAndDetailsForShipment(document);

                else if (document.DocType.DocTypeID == SDocType.CountTask)
                    return ProcessHeaderAndDetailsForCounting(document);

                else
                    return ProcessHeaderAndDetails(document);
            }

        }

        public Document CreateNewDocument(Document data, Boolean autocommit)
        {

            //Start Transaction
            Factory.IsTransactional = true;

            //Asigna el consecutivo obtenido a el documento
            if (string.IsNullOrEmpty(data.DocNumber))
                data.DocNumber = GetNextDocSequence(data.Company, data.DocType).CodeSequence;

            //Informacion del Documento
            Account defaultAccount = WType.GetAccount(new Account { AccountCode = WmsSetupValues.DEFAULT });
            data.Customer = (data.Customer == null) ? defaultAccount : data.Customer;
            data.Vendor = (data.Vendor == null) ? defaultAccount : data.Vendor;

            data.DocStatus = (data.DocStatus == null) ? WType.GetStatus(new Status { StatusID = DocStatus.New }) : data.DocStatus;
            
            if (data.DocConcept == null)
                data.DocConcept = WType.GetDefaultConcept(data.DocType.DocClass);
            
            data.CreationDate = DateTime.Now;
            data.CreatedBy = (data.CreatedBy != null) ? data.CreatedBy : "";
            data.PickMethod = data.DocType.PickMethod;

            //Salva el documento nuevo y lo retorna
            data = Factory.DaoDocument().Save(data);

            if (autocommit)
                Factory.Commit();

            data.DocumentLines = new List<DocumentLine>();
            return data;

        }

        public IList<Document> Select(Document data)
        {

                IList<Document> datos = new List<Document>();
                try
                {
                    datos = GetHsql(data).List<Document>();
                    //if (!Factory.IsTransactional)
                    //    Factory.Commit();
                }
                            
                catch (Exception e)
                {
                    NHibernateHelper.WriteEventLog(WriteLog.GetTechMessage(e));
                }
                return datos;
           
        }

        public Dictionary<int,object[]> GetDocumentSuggestedBins(Document document, Location location, PickMethod pickMethod, short binDirection)
        {
            string result = "";
            string firstBin = "";
            IList<ProductStock> list = Factory.DaoLabel().GetDocumentSuggestedBins(document, location, pickMethod);
            IList<Bin> resultBin = new List<Bin>();
            Dictionary<int, object[]> resultDictionary = new Dictionary<int, object[]>();


            foreach (Product product in list.Select(p => p.Product).Distinct())
            {

                if (list == null || list.Count == 0)
                {
                    if (!resultDictionary.ContainsKey(product.ProductID))
                        resultDictionary.Add(product.ProductID, new object[] { "NO STOCK", WmsSetupValues.MaxBinRank, firstBin });
                }

                IList<ZoneBinRelation> listBin = GetAssignedBinsList(product, location);


                foreach (ProductStock ps in list.Where(f=>f.Product.ProductID == product.ProductID).OrderBy(f => f.Bin.Rank))
                {

                    if (binDirection == BinType.In_Out)
                    {
                        result += ps.Bin.BinCode + " (";

                        if (ps.PackStock + ps.Stock > 0)
                            result += (ps.PackStock + ps.Stock).ToString();

                        result += ")\n";

                        resultBin.Add(ps.Bin);

                        if (string.IsNullOrEmpty(firstBin))
                            firstBin = ps.Bin.BinCode;
                    }
                    else
                    {

                        if (listBin != null && listBin.Any(f => f.Bin.BinID == ps.Bin.BinID && f.BinType != binDirection))
                            continue;

                        if (binDirection == BinType.Exclude_Out && ps.BinType == BinType.Out_Only)
                            continue;

                        if (binDirection == BinType.Exclude_In && ps.BinType == BinType.In_Only)
                            continue;


                        result += ps.Bin.BinCode + " (";

                        if (ps.PackStock + ps.Stock > 0)
                            result += (ps.PackStock + ps.Stock).ToString();

                        result += ")\n";

                        resultBin.Add(ps.Bin);

                        if (string.IsNullOrEmpty(firstBin))
                            firstBin = ps.Bin.BinCode;
                    }

                    if (!resultDictionary.ContainsKey(product.ProductID))
                        resultDictionary.Add(product.ProductID, new object[] { result, resultBin[0].Rank, firstBin });
                }
               
            }

            return resultDictionary;
        }

        public Boolean ValidateReceiptDocumentTrackingOptions(Document data, Node node, Boolean autoThrow)
        {
            //Hace que traiga las lineas in lazy = true
            Factory.IsTransactional = true;

            //Validate company is linked to ERP
            /*
            if (Factory.DaoConfigOptionByCompany()
                        .Select(new ConfigOptionByCompany
                        {
                            ConfigOption = new ConfigOption { Code = "WITHERP" },
                            Company = data.Company,
                        }
                        ).FirstOrDefault().Value == "F")
                return true;
            */

            //Saco los productos del document que requieren track options
            IList<Product> productList;
            if (data.IsFromErp == true)
                productList = Factory.DaoDocumentLine().Select(new DocumentLine { Document = data })
                    .Select(f => f.Product).Where(f => f.ProductTrack != null && f.ProductTrack.Count > 0)
                    .Distinct().ToList();
            else
                productList = Factory.DaoDocumentBalance().PostingBalance(
                    new DocumentBalance { Document = data, Location = data.Location, Node = node })
                    .Select(f => f.Product).ToList();


            if (productList == null || productList.Count == 0)
                return true; //No tiene track option ninguno de los productos


            //Busca si todos los items tienen el track que necesitan.
            string errorMsg = "";
            NodeTrace pattern = null;
            foreach (Product product in productList)
            {
                if (product.ProductTrack == null || product.ProductTrack.Count == 0) //product.ErpTrackOpt == 0 ||
                    continue;

                //Para las que no son unique //LOTES/FECHAS etc.
                foreach (ProductTrackRelation pt in product.ProductTrack.Where(f => f.TrackOption.IsUnique != true && f.TrackOption.DataType.DataTypeID != SDataTypes.ProductQuality))
                {
                    if (Factory.DaoNodeTrace().GetRecordWithoutTrackOption(data, pt, node).Count > 0)
                    {
                        //errorMsg += "Product " + pt.Product.Name + " require " + pt.TrackOption.DisplayName + ".\n";
                        errorMsg += "Some " + pt.TrackOption.DisplayName + " for product " + product.ProductCode + " are missing.\n";
                        continue;
                    }
                }

                //Para productos unique, los labels de tipo 1002 deben tener X hijos de tipo 1005
                foreach (ProductTrackRelation pt in product.ProductTrack.Where(f => f.IsUnique == true))
                {
                    pattern = new NodeTrace
                    {
                        Document = data,
                        Label = new Label { Product = product, LabelType = new DocumentType { DocTypeID = LabelType.ProductLabel } },
                        Node = node
                    };


                    if (Factory.DaoNodeTrace().Select(pattern).Select(f => f.Label).Sum(f => f.CurrQty) > 0)
                    {
                        //errorMsg += "Product " + pt.Product.Name + " require " + pt.TrackOption.DisplayName + ".\n";
                        errorMsg += "Some " + pt.TrackOption.DisplayName + " for product " + product.ProductCode + " are missing.\n";
                        continue;
                    }
                }



            }

            if (!string.IsNullOrEmpty(errorMsg))
                if (autoThrow)
                {
                    Factory.Rollback();
                    throw new Exception(errorMsg + "Please enter data before process.");
                }
                else
                    return false;


            Factory.Commit();
            Factory.IsTransactional = false;
            return true;
        }

 public Label ChangeLabelLocationV2(Label labelSource, Label labelDest, Document document)
 {
     return TranMngr.ChangeLabelLocationV2(labelSource, labelDest, document);
 }

        public IList<Label> GetDocumentLabelAvailable(Document data, Label searchLabel)
        {
            if (data.DocType != null && data.DocType.DocTypeID == SDocType.WarehouseTransferReceipt)
            {
                //Get the posting shipment
                Document shipment;
                try
                {
                    shipment = Factory.DaoDocument().Select(
                        new Document { DocNumber = data.CustPONumber, Company = data.Company }).First();
                }
                catch {
                    return null;   
                }

                return Factory.DaoLabel().GetDocumentLabelAvailableFromTransfer(data, shipment, null);
            }
            else
                return Factory.DaoLabel().GetDocumentLabelAvailable(data, searchLabel); 
        }

 public IList<ProductStock> GetDocumentStock(Document document, bool printed)
 { return Factory.DaoLabel().GetDocumentStock(document, printed); }

 public IList<Product> GetDocumentProduct(Document data, Product product)
 { return DocMngr.GetDocumentProduct(data, product); }

        public void PrintKitAssemblyLabels(Document ssDocument, int qtyType)
        {
            ssDocument.DocumentLines = Factory.DaoDocumentLine().Select(
                new DocumentLine { Document = new Document { DocID = ssDocument.DocID } });

            // el documento debe tener lineas 
            if (ssDocument.DocumentLines == null || ssDocument.DocumentLines.Count == 0)
                return;
            else
                BasicMngr.PrintKitAssemblyLabels(ssDocument, qtyType);
        }

 public Boolean ValidateReceiptDocumentTrackingOptions(Document data, Node node, Boolean autoThrow)
 {
     return BasicMngr.ValidateReceiptDocumentTrackingOptions(data, node, autoThrow);
 }

 public IList<Unit> GetDocumentProductUnit(Document document, Product product)
 {
     return BasicMngr.GetDocumentProductUnit(document, product);
     //return GetProductUnit(product);
 }

 public void ResetInspectionLine(Document document, Label label, string username, bool cancelDocument)
 {
     TranMngr.ResetInspectionLine(document, label, username, cancelDocument);
 }

 public void ConfirmInspectionDocument(Document document, string appPath, string username)
 {
     TranMngr.ConfirmInspectionDocument(document, appPath, username);
 }

 public bool IsTrackRequiredInDocument(Document document, Node node)
 {
     return DocMngr.IsTrackRequiredInDocument(document, node);
 }

 public IList<Document> GetCrossDockSalesOrders(Document data)
 {
     return DocMngr.GetCrossDockSalesOrders(data);
 }

 public Boolean AssociateUserDocument(Document document, IList<SysUser> userList)
 { DocMngr.AssociateUserDocument(document, userList); return true; }

 public void CreateLocationTransfer(Document trfDoc)
 {
     ErpMngr.CreateLocationTransfer(trfDoc);
 }

 public IList<Document> GetPendingDocument(Document document, int daysAgo, int records)
 { return Factory.DaoDocument().SelectPending(document, daysAgo, records); }

 public Document SaveDocument(Document data) { return Factory.DaoDocument().Save(data); }