Exemple #1
0
        private ICriteria GetDistributorsCriteria(string name, Country country, PriceList priceList,
                                                  Lookup paymentTerm, DistributorStatus?status,
                                                  GridState gridState, Incoterm?saleCondition, Lookup type, CatalogPage page)
        {
            ICriteria crit = GetCriteria();

            ExecutePermissionValidator epv = new ExecutePermissionValidator();

            epv.ClassType     = typeof(Distributor);
            epv.KeyIdentifier = Config.SeeAllDistributors;

            if (PermissionManager.Check(epv) == false)
            {
                IList priceListIds    = PermissionManager.GetPermissionIdentifiers(typeof(PriceList), PermissionAction.Create);
                int[] intPriceListIds = new int[priceListIds.Count];
                for (int i = 0; i < priceListIds.Count; i++)
                {
                    intPriceListIds[i] = Convert.ToInt32(priceListIds[i]);
                }

                ICriteria critDistributor = crit.CreateCriteria("PriceList");
                critDistributor.Add(Expression.In("ID", intPriceListIds));
            }


            if (!string.IsNullOrEmpty(name))
            {
                Disjunction d = new Disjunction();
                d.Add(Expression.InsensitiveLike("Name", name, MatchMode.Anywhere));
                d.Add(Expression.InsensitiveLike("Code", name, MatchMode.Anywhere));
                crit.Add(d);
            }


            if (country != null)
            {
                ICriteria critCountry = crit.CreateCriteria("Country");
                critCountry.Add(Expression.Eq("ID", country.ID));
            }
            if (priceList != null)
            {
                ICriteria critPriceList = crit.CreateCriteria("PriceList");
                critPriceList.Add(Expression.Eq("ID", priceList.ID));
            }
            if (paymentTerm != null)
            {
                crit.Add(Expression.Eq("PaymentTerm", paymentTerm));
            }

            if (status != null)
            {
                crit.Add(Expression.Eq("DistributorStatus", status));
            }
            else
            {
                epv               = new ExecutePermissionValidator();
                epv.ClassType     = typeof(Distributor);
                epv.KeyIdentifier = Config.DistributorInactiveStatus;

                if (PermissionManager.Check(epv) == false)
                {
                    crit.Add(Expression.Eq("DistributorStatus", DistributorStatus.Active));
                }
            }

            if (saleCondition != null)
            {
                crit.Add(Expression.Eq("SaleConditions", saleCondition));
            }

            if (type != null)
            {
                crit.Add(Expression.Eq("Type", type));
            }

            if (page != null)
            {
                crit.CreateCriteria("PriceList").CreateCriteria("CategoryPages").Add(Expression.Eq("ID", page.ID));
            }

            return(crit);
        }
Exemple #2
0
        public bool Remove(GridState gridState, IList <Filters.IFilter> filters, bool isProduct)
        {
            MasterPriceSearchParameters mpsp = FilterHelper.GetSearchFilters(filters);

            return(Remove(gridState, filters, (mpsp.Categories[1] as CatalogPage).ID, isProduct));
        }
Exemple #3
0
        public IList <Distributor> GetDistributors(string name, Country country, PriceList priceList, Lookup paymentTerm, DistributorStatus?status, GridState gridState, out int totalRecords, Incoterm?saleCondition, Lookup type, CatalogPage page)
        {
            int pageNumber = gridState.PageNumber;
            int pageSize   = gridState.PageSize;

            ICriteria crit = GetDistributorsCriteria(name, country, priceList, paymentTerm, status, gridState, saleCondition, type, page);

            crit.SetProjection(Projections.ProjectionList().Add(Projections.Count("ID")));

            totalRecords = crit.UniqueResult <int>();
            if (totalRecords == 0)
            {
                return(new List <Distributor>());
            }

            pageNumber = Utils.AdjustPageNumber(pageNumber, pageSize, totalRecords);

            crit = GetDistributorsCriteria(name, country, priceList, paymentTerm, status, gridState, saleCondition, type, page);

            crit.SetMaxResults(gridState.PageSize);
            if (pageNumber == 1)
            {
                crit.SetFirstResult(0);
            }
            else
            {
                crit.SetFirstResult((pageNumber - 1) * gridState.PageSize);
            }

            string[] sort = gridState.SortField.Split('.');

            ICriteria critSort  = crit;
            string    sortField = gridState.SortField;

            if (!sortField.Contains("TimeStamp") && sort.Length > 1)
            {
                critSort  = crit.CreateCriteria(sort[0], JoinType.LeftOuterJoin);
                sortField = sort[1];
            }

            critSort.AddOrder(new Order(sortField, gridState.SortAscending));

            return(crit.List <Distributor>());
        }
Exemple #4
0
        public IList <CategoryBase> ListSearch(string search, Type type, CategoryBase parent, GridState gridState, out int records)
        {
            ICriteria crit = ListSearchCriteria(search, type, parent);

            crit.SetProjection(Projections.ProjectionList().Add(Projections.Count("ID")));

            records = crit.UniqueResult <int>();
            if (records == 0)
            {
                return(new List <CategoryBase>());
            }

            int pageNumber = gridState.PageNumber;
            int pageSize   = gridState.PageSize;

            pageNumber = Utils.AdjustPageNumber(pageNumber, pageSize, records);

            crit = ListSearchCriteria(search, type, parent);

            crit.SetMaxResults(gridState.PageSize);
            if (pageNumber == 1)
            {
                crit.SetFirstResult(0);
            }
            else
            {
                crit.SetFirstResult((pageNumber - 1) * gridState.PageSize);
            }

            crit.AddOrder(new Order("Type", true));
            crit.AddOrder(new Order("Parent", true));
            crit.AddOrder(new Order("ID", true));

            return(crit.List <CategoryBase>());
        }
Exemple #5
0
        public IList <CatalogPage> ListLevelOnePages(string search, CatalogPage parent, CategoryPageStatus?status, GridState gridState, out int totalRecords)
        {
            ICriteria crit = ListLevelOnePagesCriteria(search, parent, status);

            crit.SetProjection(Projections.ProjectionList().Add(Projections.Count("ID")));

            totalRecords = crit.UniqueResult <int>();
            if (totalRecords == 0)
            {
                return(new List <CatalogPage>());
            }

            int pageNumber = gridState.PageNumber;
            int pageSize   = gridState.PageSize;

            pageNumber = Utils.AdjustPageNumber(pageNumber, pageSize, totalRecords);

            crit = ListLevelOnePagesCriteria(search, parent, status);

            crit.SetMaxResults(gridState.PageSize);
            if (pageNumber == 1)
            {
                crit.SetFirstResult(0);
            }
            else
            {
                crit.SetFirstResult((pageNumber - 1) * gridState.PageSize);
            }

            string[] sort = gridState.SortField.Split('.');

            ICriteria critSort  = crit;
            string    sortField = gridState.SortField;

            if (!sortField.Contains("TimeStamp") && sort.Length > 1)
            {
                critSort  = crit.CreateCriteria(sort[0], JoinType.LeftOuterJoin);
                sortField = sort[1];
            }

            critSort.AddOrder(new Order(sortField, gridState.SortAscending));

            return(crit.List <CatalogPage>());
        }
        public IList <PriceImport> Search(string info, DateTime?fromDate, out int totalRecords, GridState gridState, DateTime?toDate, ImportStatus?status)
        {
            int pageNumber = gridState.PageNumber;
            int pageSize   = gridState.PageSize;

            ICriteria crit = SearchCriteria(info, fromDate, toDate, status);

            crit.SetProjection(Projections.ProjectionList().Add(Projections.Count("Number")));


            totalRecords = crit.UniqueResult <int>();
            if (totalRecords == 0)
            {
                return(new List <PriceImport>());
            }

            pageNumber = Utils.AdjustPageNumber(pageNumber, pageSize, totalRecords);

            crit = SearchCriteria(info, fromDate, toDate, status);

            crit.SetMaxResults(pageSize);
            if (pageNumber == 1)
            {
                crit.SetFirstResult(0);
            }
            else
            {
                crit.SetFirstResult((pageNumber - 1) * pageSize);
            }

            string[]  sort      = gridState.SortField.Split('.');
            ICriteria critSort  = crit;
            string    sortField = gridState.SortField;

            if (!sortField.Contains("TimeStamp") && sort.Length > 1)
            {
                critSort = crit.GetCriteriaByPath(sort[0]);
                if (critSort == null)
                {
                    critSort = crit.CreateCriteria(sort[0]);
                }
                sortField = sort[1];
            }
            critSort.AddOrder(new Order(sortField, gridState.SortAscending));

            return(crit.List <PriceImport>());
        }
        public IList <Distributor> GetDistributors(string name, Country country, PriceList priceList, Lookup paymentTerm, DistributorStatus?status, GridState gridState, out int totalRecords, Lookup saleCondition, Lookup type, CatalogPage page)
        {
            ExecutePermissionValidator epv = new ExecutePermissionValidator();

            epv.ClassType     = typeof(PriceList);
            epv.KeyIdentifier = Config.SeePriceLists;

            bool  CanSeeAll    = PermissionManager.Check(epv);
            IList priceListIds = null;

            if (!CanSeeAll)
            {
                priceListIds = PermissionManager.GetPermissionIdentifiers(typeof(PriceList), PermissionAction.Create);
            }

            epv               = new ExecutePermissionValidator();
            epv.ClassType     = typeof(Distributor);
            epv.KeyIdentifier = Config.DistributorInactiveStatus;
            bool isActive = PermissionManager.Check(epv);

            return(repository.GetDistributors(name, country, priceList, paymentTerm, status, gridState, out totalRecords, saleCondition, type, page, priceListIds, isActive));
        }
Exemple #8
0
        //public void SaveAudit(PriceBase priceBase, HistoryStatus historyStatus)
        //{
        //    SaveAudit(priceBase, historyStatus, null);
        //}

        //public void SaveAudit(PriceBase priceBase, HistoryStatus historyStatus, Guid? userId)
        //{
        //    PriceBaseHistory priceBaseHistory = new PriceBaseHistory();

        //    priceBaseHistory.PriceImport = priceBase.PriceImport;
        //    priceBaseHistory.PriceList = priceBase.PriceList;
        //    priceBaseHistory.PriceListCurrency = priceBase.PriceListCurrency;
        //    priceBaseHistory.PricePurchase = priceBase.PricePurchase;
        //    priceBaseHistory.PricePurchaseCurrency = priceBase.PricePurchaseCurrency;
        //    priceBaseHistory.PriceSuggest = priceBase.PriceSuggest;
        //    priceBaseHistory.PriceSuggestCurrency = priceBase.PriceSuggestCurrency;
        //    priceBaseHistory.Product = priceBase.Product;
        //    priceBaseHistory.Provider = priceBase.Provider;
        //    priceBaseHistory.ProviderCode = priceBase.ProviderCode;
        //    priceBaseHistory.Status = priceBase.Status;
        //    priceBaseHistory.HistoryStatus = historyStatus;
        //    priceBaseHistory.CurrencyRate = priceBase.CurrencyRate;
        //    priceBaseHistory.PricePurchaseCurrencyRate = priceBase.PricePurchaseCurrencyRate;
        //    priceBaseHistory.PriceSuggestCurrencyRate = priceBase.PriceSuggestCurrencyRate;

        //    if (userId.HasValue)
        //    {
        //        priceBaseHistory.TimeStamp.CreatedBy = userId;
        //        priceBaseHistory.TimeStamp.CreatedOn = DateTime.Now;
        //        priceBaseHistory.TimeStamp.ModifiedBy = userId;
        //        priceBaseHistory.TimeStamp.ModifiedOn = DateTime.Now;
        //    }

        //    Save(priceBaseHistory);
        //}

        //public void SaveAudit(IList<PriceBase> lst, HistoryStatus historyStatus)
        //{
        //    foreach (PriceBase priceBase in lst)
        //        SaveAudit(priceBase, historyStatus);
        //}

        public IList <ProductListView> GetByProduct(Product product, GridState gridState, out int totalRecords)
        {
            ICriteria crit = GetByProductCriteria(product);
            //crit.SetProjection(Projections.ProjectionList().Add(Projections.Count("ID")));

            //totalRecords = crit.UniqueResult<int>();
            //if (totalRecords == 0)
            //    return new List<ProductListView>();

            int pageNumber = gridState.PageNumber;
            int pageSize   = gridState.PageSize;

            //crit = GetByProductCriteria(product);

            //crit.SetMaxResults(gridState.PageSize);
            //if (pageNumber == 1)
            //    crit.SetFirstResult(0);
            //else
            //    crit.SetFirstResult((pageNumber - 1) * gridState.PageSize);

            string[] sort = gridState.SortField.Split('.');

            ICriteria critSort  = crit;
            string    sortField = gridState.SortField;

            if (!sortField.Contains("TimeStamp") && sort.Length > 1)
            {
                critSort  = crit.CreateCriteria(sort[0]);
                sortField = sort[1];
            }

            critSort.AddOrder(new Order(sortField, gridState.SortAscending));

            IList <PriceBaseHistory> priceBaseHistoryList = crit.List <PriceBaseHistory>();
            IList <ProductListView>  productListViewList  = new List <ProductListView>();

            totalRecords = priceBaseHistoryList.Count;
            pageNumber   = Utils.AdjustPageNumber(pageNumber, pageSize, totalRecords);

            int count;
            int maxcount;

            if (pageNumber == 1)
            {
                count = 0;
            }
            else
            {
                count = (pageNumber - 1) * gridState.PageSize;
            }
            maxcount = count + pageSize;
            decimal price = -1;

            foreach (PriceBaseHistory pbh in priceBaseHistoryList)
            {
                if (count < maxcount)
                {
                    if (price == pbh.PriceList)
                    {
                        continue;
                    }
                    ProductListView productListView = new ProductListView(pbh);
                    productListViewList.Add(productListView);
                    count++;
                    price = pbh.PriceList;
                }
                else
                {
                    break;
                }
            }


            return(productListViewList);
        }
Exemple #9
0
        //public WorkListItemHistory SaveAudit(WorkListItem workListItem, HistoryStatus historyStatus)
        //{
        //    WorkListItemHistory workListItemHistory = new WorkListItemHistory();

        //    workListItemHistory.Price = workListItem.Price;
        //    workListItemHistory.LastApproved = workListItem.LastApproved;
        //    workListItemHistory.LastPublishItem = workListItem.LastPublishItem;
        //    workListItemHistory.PriceCurrency = workListItem.PriceCurrency;
        //    workListItemHistory.PriceList = workListItem.PriceList;
        //    workListItemHistory.WorkListItemStatus = workListItem.WorkListItemStatus;
        //    workListItemHistory.PriceBase = workListItem.PriceAttribute.PriceBase;
        //    workListItemHistory.CurrencyRate = workListItem.CurrencyRate;
        //    workListItemHistory.HistoryStatus = historyStatus;
        //    workListItemHistory.PricePurchaseCurrencyRate = workListItem.PricePurchaseCurrencyRate;
        //    workListItemHistory.PriceSuggestCurrencyRate = workListItem.PriceSuggestCurrencyRate;

        //    Save(workListItemHistory);

        //    return workListItemHistory;
        //}

        //public void SaveAudit(IList<WorkListItem> wliList, HistoryStatus historyStatus)
        //{
        //    foreach (WorkListItem workListItem in wliList)
        //    {
        //        SaveAudit(workListItem, historyStatus);
        //    }
        //}

        public IList <WorkListItemHistory> GetByProduct(Product product, PriceList priceList, GridState gridState, out int totalRecords)
        {
            ICriteria crit = GetByProductCriteria(product, priceList);

            int pageNumber = gridState.PageNumber;
            int pageSize   = gridState.PageSize;

            crit.AddOrder(new Order("PriceList", true));
            crit.AddOrder(new Order("TimeStamp.CreatedOn", false));

            string[] sort = gridState.SortField.Split('.');

            ICriteria critSort  = crit;
            string    sortField = gridState.SortField;

            if (!sortField.Contains("TimeStamp") && sort.Length > 1)
            {
                critSort  = crit.CreateCriteria(sort[0]);
                sortField = sort[1];
            }

            critSort.AddOrder(new Order(sortField, gridState.SortAscending));

            IList <WorkListItemHistory> workListItemHistoryList = crit.List <WorkListItemHistory>();
            IList <WorkListItemHistory> productListViewList     = new List <WorkListItemHistory>();

            totalRecords = workListItemHistoryList.Count;
            pageNumber   = Utils.AdjustPageNumber(pageNumber, pageSize, totalRecords);

            int count;
            int maxcount;

            if (pageNumber == 1)
            {
                count = 0;
            }
            else
            {
                count = (pageNumber - 1) * gridState.PageSize;
            }
            maxcount = count + pageSize;
            decimal price = -1;

            foreach (WorkListItemHistory wlih in workListItemHistoryList)
            {
                if (count < maxcount)
                {
                    if (price == wlih.Price)
                    {
                        continue;
                    }
                    productListViewList.Add(wlih);
                    count++;
                    price = wlih.Price;
                }
                else
                {
                    break;
                }
            }


            return(productListViewList);
        }
        public IList <PriceCalculationListView> List(string search, CategoryBase[] category, Provider provider, PriceCalculationPriority?priority, GridState gridState, out int totalRecords)
        {
            ICriteria crit = ListCriteria(search, category, provider, priority);

            crit.AddOrder(new Order("Priority", true));
            crit.AddOrder(new Order("Provider", true));
            crit.AddOrder(new Order("CategoryBase", true));
            crit.AddOrder(new Order("TimeStamp.ModifiedOn", false));

            IList <PriceCalculationListView> tmp      = ConvertToView(crit.List <PriceCalculation>());
            IList <PriceCalculationListView> lstFinal = new List <PriceCalculationListView>();

            int pageNumber = gridState.PageNumber;
            int pageSize   = gridState.PageSize;

            pageNumber = Utils.AdjustPageNumber(pageNumber, pageSize, tmp.Count);

            for (int i = (pageNumber - 1) * gridState.PageSize; i < ((pageNumber - 1) * gridState.PageSize) + gridState.PageSize; i++)
            {
                if (i < tmp.Count)
                {
                    lstFinal.Add(tmp[i]);
                }
            }
            totalRecords = tmp.Count;
            if (totalRecords == 0)
            {
                return(new List <PriceCalculationListView>());
            }

            return(lstFinal);
        }
Exemple #11
0
        public IList <Product> GetProductList(string description, Frequency?frequency, DateTime?date, ProductStatus?status, Provider provider, CategoryBase[] category, Selection selection, GridState gridState, out int totalRecords)
        {
            string sortOrder  = gridState.SortAscending ? "ASC" : "DESC";
            int    pageNumber = gridState.PageNumber;
            int    pageSize   = gridState.PageSize;

            IQuery q = ControllerManager.PriceBase.GetProductListQuery("COUNT(DISTINCT P.ID)", description, category, selection, frequency, date, status, provider, 0, 0, string.Empty, string.Empty, gridState.MarkedAll, null);

            totalRecords = Convert.ToInt32(q.UniqueResult());
            pageNumber   = Utils.AdjustPageNumber(pageNumber, pageSize, totalRecords);
            q            = ControllerManager.PriceBase.GetProductListQuery("P", description, category, selection, frequency, date, status, provider, pageNumber, pageSize, gridState.SortField, sortOrder, gridState.MarkedAll, null);

            return(q.List <Product>());
        }
 public IList <QuoteRange> List(GridState gridState, out int totalRecords)
 {
     return(repository.List(gridState, out totalRecords));
 }
Exemple #13
0
 public IList <Quote> List(GridState gridState, string text, Distributor distributor, QuoteStatus?status, out int records, Guid?userId, IList quoteIds)
 {
     return(repository.List(gridState, text, distributor, status, out records, userId, quoteIds));
 }
Exemple #14
0
        public Quote AddItems(GridState gridState, int quoteId, string distributorName, string description, string observations, int vigency, int quoteCondition, int quoteIntroText, string email, string contact, out bool canfinal, List <int> contactids, int currencyId)
        {
            lstRates = ControllerManager.CurrencyRate.GetArray();

            canfinal = true;
            Currency c = ControllerManager.Currency.GetById(currencyId);
            Quote    q = new Quote();

            if (quoteId > 0)
            {
                q = repository.GetById(quoteId);
            }

            Distributor d = ControllerManager.Distributor.GetByName(distributorName);

            q.Distributor  = d;
            q.Condition    = ControllerManager.Lookup.GetById(quoteCondition);
            q.Description  = description;
            q.IntroText    = ControllerManager.Lookup.GetById(quoteIntroText);
            q.Observations = observations;
            q.Status       = QuoteStatus.Draft;
            q.Vigency      = ControllerManager.Lookup.GetById(vigency);
            q.Currency     = c;
            q.CurrencyRate = ControllerManager.CurrencyRate.GetLast(q.Currency);

            List <Contact> temp = new List <Contact>(d.Contacts);

            AddContactNotifications(q, temp, contactids);
            if (!string.IsNullOrEmpty(email.Trim()))
            {
                AddNotifications(q, contact.Trim(), email.Trim());
            }

            if (q.QuoteNotifications.Count == 0 && !string.IsNullOrEmpty(q.Distributor.Email))
            {
                AddNotifications(q, q.Distributor.Contact, q.Distributor.Email);
            }
            else if (q.QuoteNotifications.Count == 0 && !string.IsNullOrEmpty(q.Distributor.AlternativeEmail))
            {
                AddNotifications(q, q.Distributor.Contact, q.Distributor.AlternativeEmail);
            }

            //Si no limpiamos los items antes de agregarlos, se ahorraria tiempo y se podria acomodar por fecha de creación.
            //¿Porque se sacan todos?
            //q.QuoteItems.Clear();

            List <PriceBase> temppblist = ControllerManager.PriceBase.GetPriceBases(string.Empty, null, null, null, null, null, null, false, gridState.Items, false, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null);

            int i = 1;

            foreach (int item in gridState.Items)
            {
                PriceBase pb = temppblist.Find(delegate(PriceBase record)
                {
                    if (record.ID == item)
                    {
                        return(true);
                    }
                    return(false);
                });
                canfinal = canfinal && AddItem(q, pb, string.Empty, i);
                i++;
            }


            //foreach (PriceBase priceBase in temppblist)
            //    canfinal = canfinal && AddItem(q, priceBase, string.Empty);

            repository.Save(q);
            repository.CommitChange();
            q.Number = q.ID.ToString("000000");

            if (quoteId == 0)
            {
                PermissionManager.AddEntityPermision(q.GetType(), q.ID.ToString(), MembershipHelper.GetUser().UserName);
            }

            return(q);
        }