コード例 #1
0
        /*Returns the total cost of all items in the supplied order.*/
        public double getOrderCost(Order order)
        {
            double totalCost = 0;

            try
            {
                List <OrderLine> orderLines = new OrderLineService().getByOrder(order);            //Throws NoRecordException
                //set order total cost
                foreach (OrderLine orderLine in orderLines)
                {
                    if (orderLine.orderLineType.id == 1) //rent
                    {
                        TimeSpan duration = orderLine.enddate - orderLine.startdate;
                        totalCost += orderLine.dvdInfo.rent_price * duration.Days;
                    }
                    else if (orderLine.orderLineType.id == 2) //buy
                    {
                        totalCost += orderLine.dvdInfo.buy_price;
                    }
                }
            }
            catch (NoRecordException)
            {
            }
            return(Math.Round(totalCost, 2));
        }
コード例 #2
0
        /*Returns a dictionary of (dvd_info_id, number_of_times_bought).*/
        public Dictionary <String, int> getItemsBoughtByCustomer(Customer customer)
        {
            Dictionary <String, int> dvdAmount = new Dictionary <String, int>();

            try
            {
                List <OrderLine> orderLines = new OrderLineService().getByCustomer(customer);

                foreach (OrderLine orderLine in orderLines)
                {
                    if (!dvdAmount.ContainsKey(orderLine.dvdInfo.dvd_info_id))
                    {
                        dvdAmount.Add(orderLine.dvdInfo.dvd_info_id, 1);
                    }
                    else
                    {
                        dvdAmount[orderLine.dvdInfo.dvd_info_id] = dvdAmount[orderLine.dvdInfo.dvd_info_id] + 1;
                    }
                }
            } catch (NoRecordException ex)
            {
                //user has never purchased anything
            }

            return(dvdAmount);
        }
コード例 #3
0
        /*Returns the number of items the user has purchased.*/
        public int getNumberOfOrderLinesForCustomer(Customer customer)
        {
            List <OrderLine> orderLines;

            try
            {
                orderLines = new OrderLineService().getByCustomer(customer);
            }
            catch (NoRecordException ex)
            {
                //user has never purchased anything
                orderLines = new List <OrderLine>();
            }

            return(orderLines.Count);
        }
コード例 #4
0
        /*Converts the customer's shopping cart to an order and returns it*/
        public Order createOrder(Customer user)
        {
            try
            {
                //get all items currently in cart
                List <ShoppingcartItem> cartContent = new ShoppingCartService().getCartContentForCustomer(user);           //Throws NoRecordException

                //create new order for this user
                int   orderID   = new OrderService().addOrderForCustomer(user);       //Throws NoRecordException
                Order thisOrder = new OrderService().getByID(orderID.ToString());

                OrderLineService orderLineService = new OrderLineService();

                //add cart items to newly created order
                foreach (ShoppingcartItem item in cartContent)
                {
                    OrderLine orderline = new OrderLine
                    {
                        order   = new OrderService().getByID(orderID.ToString()),                    //Throws NoRecordException
                        dvdInfo = new DvdInfoService().getByID(item.dvdInfo.dvd_info_id.ToString()), //Throws NoRecordException
                        //dvd_copy_id = copy.dvd_copy_id, //don't add a copy_id yet, only do this when a user has paid (id will be set in admin module)
                        startdate = item.startdate,
                        enddate   = item.enddate,
                        //order_line_type_id is verhuur/verkoop? dan kunnen we dat eigenlijk via join ophalen via dvd_copy tabel
                        orderLineType = new OrderLineTypeService().getByID(item.dvdCopyType.id.ToString())          //Throws NoRecordException
                    };

                    if (orderLineService.add(orderline))
                    {
                        //succes
                    }
                }

                //clear cart
                if (new ShoppingCartService().deleteByCustomer(user))
                {
                    //success
                }

                return(thisOrder);
            }
            catch (NoRecordException)
            {
                return(null);
            }
        }
コード例 #5
0
        /*Returns the number of items currently being rented by the user.*/
        public int getNumberOfActiveRentOrdersCopiesForCustomer(Customer customer)
        {
            int numberOfCurrentlyRentedItems = 0;

            try
            {
                List <OrderLine> orderLines = new OrderLineService().getActiveRentOrderLinesByCustomer(customer);          //Throws NoRecordException
                foreach (OrderLine orderLine in orderLines)
                {
                    numberOfCurrentlyRentedItems++;
                }
            }
            catch (NoRecordException ex)
            {
                //user has no active rent orders
            }
            return(numberOfCurrentlyRentedItems);
        }
コード例 #6
0
        /*Deletes the supplied orderLine from its order. Also deletes the order itself if it no longer contains any orderLines after deleting the supplied one.*/
        public bool deleteItemFromOrder(OrderLine orderLine)
        {
            Order order = orderLine.order;

            if (new OrderLineService().delete(orderLine))
            {
                try
                {
                    List <OrderLine> orderLines = new OrderLineService().getByOrder(order);
                }
                catch (NoRecordException ex)
                {
                    //this order no longer contains any orderlines, delete the entire order
                    new OrderService().delete(order);
                }

                return(true);
            }
            else
            {
                return(false);
            }
        }
コード例 #7
0
        /*Sets the supplied order as paid and assigns a dvd copy to each orderLine (if possible).*/
        public void payOrder(Order selectedOrder)
        {
            //set the order status to PAID
            selectedOrder.orderstatus = new OrderStatusService().getByID("2");          //Throws NoRecordException
            new OrderService().updateOrder(selectedOrder);

            //assign copies to the orderlines
            List <OrderLine> orderLines = new OrderLineService().getByOrder(selectedOrder);            //Throws NoRecordException

            foreach (OrderLine orderLine in orderLines)
            {
                if (orderLine.orderLineType.id == 1) //rent copy
                {
                    DvdInfo thisDVD = orderLine.dvdInfo;

                    //get all unavailable dates starting from TODAY

                    Dictionary <int, List <DateTime> > dicCopyUnavailableDates = new AvailabilityModel().getAllUnavailableDaysPerCopyForDvdInfo(thisDVD, DateTime.Today); //Throws NoRecordException
                    Dictionary <int, int> dicDaysFreeForCopy = new Dictionary <int, int>();                                                                               //contains the number of free days for the dvdCopy (copy-id, freedays)

                    int selectedCopyId = -1;                                                                                                                              //id of the copy that will be assigned to this orderLine

                    //loop over the list of occupied dates per copy, check how many free dates exist around the chosen period, store that amount in dicDaysFreeForCopy
                    foreach (KeyValuePair <int, List <DateTime> > entry in dicCopyUnavailableDates)
                    {
                        //determine how many days the copy will be rented
                        int  rentPeriodDays  = (orderLine.enddate - orderLine.startdate).Days;
                        bool copyIsAvailable = true;

                        for (int i = 0; i <= rentPeriodDays; i++)
                        {
                            //loop over the occupied days, check if the copy is available on all of the requested dates
                            if (entry.Value.Contains(orderLine.startdate.AddDays(i)))
                            {
                                //one of the requested days is not free, this copy can not be used
                                copyIsAvailable = false;
                            }
                        }

                        if (copyIsAvailable)
                        {
                            //we now know this copy has the needed time available, now to determine the size of this free period
                            dicDaysFreeForCopy.Add(entry.Key, 0);

                            //check the amount of free days between start date and the first unavailable date (going backwards)
                            bool unavailableFound = false;
                            int  offset           = 0;
                            do
                            {
                                if (entry.Value.Contains(orderLine.startdate.AddDays(-offset)) || orderLine.startdate.AddDays(-offset) == DateTime.Today)
                                {
                                    //the copy is reserved on this date, break out of loop
                                    unavailableFound = true;
                                }
                                else
                                {
                                    dicDaysFreeForCopy[entry.Key]++;
                                    offset++;
                                }
                            } while (!unavailableFound);

                            //check the amount of free days between end date and the first unavailable date (going forward)
                            unavailableFound = false;
                            offset           = 0;
                            do
                            {
                                if (entry.Value.Contains(orderLine.enddate.AddDays(offset)) || orderLine.enddate.AddDays(offset) >= DateTime.Today.AddDays(14))
                                {
                                    //the copy is reserved on this date, break out of loop
                                    unavailableFound = true;
                                }
                                else
                                {
                                    dicDaysFreeForCopy[entry.Key]++;
                                    offset++;
                                }
                            } while (!unavailableFound);
                        }
                    }

                    int daysFree = 1000;

                    //loop over all copies, select the one with the smallest free window
                    foreach (KeyValuePair <int, int> entryDays in dicDaysFreeForCopy)
                    {
                        if (entryDays.Value < daysFree)
                        {
                            daysFree       = entryDays.Value;
                            selectedCopyId = entryDays.Key;
                        }
                    }

                    //assign the copy if it has been found
                    if (selectedCopyId > 0)
                    {
                        try
                        {
                            orderLine.dvdCopy = new DvdCopyService().getByID(selectedCopyId.ToString());            //Throws NoRecordException || DALException
                        }
                        catch (NoRecordException)
                        {
                            //No dvd's were found
                        }
                        new OrderLineService().updateOrderLine(orderLine);

                        //update the amount_sold field of the dvdInfo record
                        orderLine.dvdInfo.amount_sold = orderLine.dvdInfo.amount_sold + 1;
                        new DvdInfoService().update(orderLine.dvdInfo);                                                             //Throws NoRecordException
                    }
                    else
                    {
                        //no copies with future orderLines are available for this reservation/rent order
                        //get all fully available copies (=copies with no orderLines in the future) to assign to this orderline
                        try
                        {
                            List <DvdCopy> dvdCopies = new DvdCopyService().getAllFullyAvailableCopies(thisDVD, orderLine.startdate);      //Throws NoRecordException || DALException

                            //set the first available copy as the copy for this orderline
                            orderLine.dvdCopy = dvdCopies[0];
                            //update database
                            new OrderLineService().updateOrderLine(orderLine);
                            //update the amount_sold field of the dvdInfo record
                            dvdCopies[0].dvdinfo.amount_sold += 1;
                            new DvdInfoService().update(dvdCopies[0].dvdinfo);
                        }
                        catch (Exception ex)
                        {
                            //no copy can be assigned at this time, this means someone else received the last copy between the time where
                            //this user added the item to his cart and when he payed for the order.
                        }
                    }
                }
                else if (orderLine.orderLineType.id == 2) //sale copy
                {
                    //get all available copies
                    //get this list again for every item so you can add a new, available copy to the order
                    List <DvdCopy> availableCopies = new DvdCopyService().getAllInStockBuyCopiesForDvdInfo(orderLine.dvdInfo);           //Throws NoRecordException || DALException

                    //get the first available copy
                    //set the found copy as the copy for this orderline
                    orderLine.dvdCopy = availableCopies[0];
                    new OrderLineService().updateOrderLine(orderLine);

                    //update the amount_sold field of the dvdInfo record
                    DvdInfo dvdInfo = availableCopies[0].dvdinfo;
                    dvdInfo.amount_sold = dvdInfo.amount_sold + 1;
                    new DvdInfoService().update(dvdInfo);         //Throws NoRecordException

                    //mark the found copy as NOT in_stock
                    availableCopies[0].in_stock = false;
                    if (new DvdCopyService().updateCopy(availableCopies[0]))            //Throws NoRecordException || DALException
                    {
                        //Success, record updated
                    }
                }
            }
        }
コード例 #8
0
        /**Returns a list of recommendations based on the user's order history.
         * 1) Gets all past orders and determines the user's 3 favourite genres.
         * 2) Gets a list of DVDs that have the most matches with the user's favourites.
         * A dvd that contains all 3 favourite genres will rank higher than a dvd that only matches 1 favourite genre.
         * 3) Removes dvds that the user has already rented or bought before.
         * 4) If no dvd's are left (or if the user had no orderlines), a list of DVDs is generated based on the pages the user has visited.
         */
        public List <DvdInfo> getRecommendations(Customer customer, int amount)
        {
            List <DvdInfo>   dvdList = new List <DvdInfo>();
            List <Genre>     genres  = new List <Genre>();
            List <OrderLine> orderLines;

            try
            {
                orderLines = new OrderLineService().getByCustomer(customer);          //Throws NoRecordException
            } catch (Exception error)
            {
                orderLines = new List <OrderLine>();
            }

            orderLinesDvdIds = new List <String>(); //list that contains the DVDids of the orderlines (=movies that the user has rented before)

            GenreService   genreService   = new GenreService();
            DvdInfoService dvdInfoService = new DvdInfoService();

            //customer has at least 1 order, base recommendations on orderLines
            if (orderLines.Count > 0)
            {
                foreach (OrderLine line in orderLines)
                {
                    String dvdID = line.dvdInfo.dvd_info_id;
                    genres.AddRange(genreService.getGenresForDvd(dvdID));            //Throws NoRecordException

                    //fill orderLinesDvdIds
                    if (!orderLinesDvdIds.Contains(dvdID))
                    {
                        orderLinesDvdIds.Add(dvdID);
                    }
                }

                //put genres in a dictionary (genreID, numberOfOccurrances)
                Dictionary <int, int> genreCountMap = new Dictionary <int, int>();
                foreach (Genre genre in genres)
                {
                    if (genreCountMap.ContainsKey(genre.genre_id))
                    {
                        genreCountMap[genre.genre_id]++;
                    }
                    else
                    {
                        genreCountMap.Add(genre.genre_id, 1);
                    }
                }

                //loop over dictionary and find the 3 most occuring genres
                int[] maxGenres = { 0, 0, 0 };
                int[] maxCounts = { 0, 0, 0 };

                foreach (KeyValuePair <int, int> pair in genreCountMap)
                {
                    if (maxCounts[0] < pair.Value)
                    {
                        maxCounts[2] = maxCounts[1];
                        maxCounts[1] = maxCounts[0];
                        maxCounts[0] = pair.Value;

                        maxGenres[2] = maxGenres[1];
                        maxGenres[1] = maxGenres[0];
                        maxGenres[0] = pair.Key;
                    }
                    else if (maxCounts[1] < pair.Value)
                    {
                        maxCounts[2] = maxCounts[1];
                        maxCounts[1] = pair.Value;

                        maxGenres[2] = maxGenres[1];
                        maxGenres[1] = pair.Key;
                    }
                    else if (maxCounts[2] < pair.Value)
                    {
                        maxCounts[2] = pair.Value;

                        maxGenres[2] = pair.Key;
                    }
                }

                //we now have the user's 3 favourite genres in maxGenres, use that info to get the dvds that match those 3 genres the most
                //get max 16 dvds. Index will always show maximum 4, but catalog can show up to 16
                List <String> dvdIds = dvdInfoService.getRecommendations(maxGenres, 16);            //Throws NoRecordException

                List <String> dvdTempIds = new List <String>();

                //only accept dvd's that the user had not watched yet
                foreach (String id in dvdIds)
                {
                    if (!orderLinesDvdIds.Contains(id))
                    {
                        dvdTempIds.Add(id);
                    }
                }

                if (dvdTempIds.Count > 0)
                {
                    foreach (String id in dvdTempIds)
                    {
                        dvdList.Add(dvdInfoService.getByID(id.ToString()));            //Throws NoRecordException
                    }
                }
                else
                {
                    //customer has already bought or rented every suggestion, recommend the movies whose pages the user has viewed most often
                    dvdList = getMostViewedDvdInfos(customer);          //Throws NoRecordException
                }
            }
            else
            {
                //customer has no orderlines, recommend the movies whose pages the user has viewed the most
                dvdList = getMostViewedDvdInfos(customer);              //Throws NoRecordException
            }

            //remove elements until the list size is the requested size (4 for index row, 16 for catalog page)
            //loop deletes a random item until the size is ok so the user gets different recommendations on every visit/refresh
            Random rnd = new Random();

            while (dvdList.Count > amount)
            {
                dvdList.RemoveAt(rnd.Next(dvdList.Count));
            }

            return(dvdList);
        }