Beispiel #1
0
        private void btmSearchVarata_Click(object sender, EventArgs e) // New order
        {
            // Check date again, if user change data, and no do search
            if (!OrderUtils.CheckCottageBookDate(Convert.ToInt32(dgSearchTable.CurrentRow.Cells[0].Value), dtpSearchFROM.Text, dtpSearchTO.Text))
            {
                btnSearchHae_Click(sender, e);
                return;
            }

            ConnectionUtils.OpenConnection();
            MySqlCommand command = new MySqlCommand("SELECT toimintaalue_id FROM toimintaalue WHERE nimi Like '" +
                                                    dgSearchTable.CurrentRow.Cells[1].Value.ToString() + "'", ConnectionUtils.connection);
            int toimintaalueid = Convert.ToInt32(command.ExecuteScalar().ToString());
            // Make object to send on Booking window
            Cottage cottage = new Cottage(Convert.ToInt32(dgSearchTable.CurrentRow.Cells[0].Value), toimintaalueid,
                                          dgSearchTable.CurrentRow.Cells[2].Value.ToString(), dgSearchTable.CurrentRow.Cells[3].Value.ToString(),
                                          dgSearchTable.CurrentRow.Cells[4].Value.ToString(), dgSearchTable.CurrentRow.Cells[5].Value.ToString(),
                                          Convert.ToInt32(dgSearchTable.CurrentRow.Cells[6].Value.ToString()), dgSearchTable.CurrentRow.Cells[7].Value.ToString(),
                                          Convert.ToDouble(dgSearchTable.CurrentRow.Cells[8].Value.ToString()));

            ConnectionUtils.CloseConnection();
            NewBook newbook = new NewBook(cottage, dtpSearchFROM.Value.Date, dtpSearchTO.Value.Date);
            Booking booking = new Booking(newbook);

            booking.ShowDialog();
        }
        public ActionResult Create(string str, string returnUrl)
        {
            List <MenuItem> menuItems = db.MenuItems.ToList();

            decimal cost      = 0;
            string  orderlist = "";

            foreach (MenuItem menuItem in menuItems)
            {
                int count = int.Parse(Request["input-" + menuItem.ID]);

                while (count > 0)
                {
                    if (cost > 0)
                    {
                        orderlist += ",";
                    }
                    cost      += menuItem.Price;
                    orderlist += menuItem.ID;
                    count--;
                }
            }

            int order_id = OrderUtils.SaveOrder(User.Identity.Name, orderlist);


            return(RedirectToAction("Confirm", "Order", new { id = order_id }));
        }
        public virtual ActionResult Confirm(OrderConfirmViewModel model)
        {
            var orderUtils = new OrderUtils(_context, CurrentUserId);

            if (!model.OrderConfirmed)
            {
                // Regenerate the model
                model = orderUtils.GetConfirmModel(model.ProductId);
                ModelState.AddModelError("OrderConfirmed", "You must check the confirmation box to activate this license");
                return View(model);
            }

            var createdOrder = orderUtils.CreateOrder(model.ProductId);
            if (createdOrder.OrderStatus == OrderStatus.AwaitingPayment)
                return RedirectToAction(MVC.Products.Pay.Index(createdOrder.Id));

            else if (createdOrder.OrderStatus != OrderStatus.Completed)
                throw new InvalidOperationException(
                    string.Format("Order status of {0} is not supported", createdOrder.OrderStatus.ToString()));

            // Order was completed as it was free
            orderUtils.ActivateOrderedLicenses(createdOrder);
            string LicenseType = orderUtils.GetLicenseDescription(createdOrder.FillPerfectLicenses.First().LicenseType);
           
            return RedirectToAction(
                MVC.Products.FillPerfect.LicenseActivated(
                    (Guid)_context.Users.Find(createdOrder.OrderedForId).FillPerfectKey,
                    createdOrder.FillPerfectLicenses.First().EffectiveDate,
                    createdOrder.FillPerfectLicenses.First().ExpirationDate,
                    LicenseType));
        }
Beispiel #4
0
        public void CombineWithPreviousLyric(Lyric lyric)
        {
            var previousLyric = Lyrics.GetPrevious(lyric);

            if (previousLyric == null)
            {
                throw new ArgumentNullException(nameof(previousLyric));
            }

            changeHandler?.BeginChange();

            // Shifting order that order is larger than current lyric.
            var lyricOrder = previousLyric.Order;

            OrderUtils.ShiftingOrder(Lyrics.Where(x => x.Order > lyricOrder).ToArray(), -1);

            var newLyric = LyricsUtils.CombineLyric(previousLyric, lyric);

            newLyric.Order = lyricOrder;

            // Add created lyric and remove old two.
            beatmap.Add(newLyric);
            beatmap.Remove(previousLyric);
            beatmap.Remove(lyric);

            changeHandler?.EndChange();
        }
Beispiel #5
0
        public void CreateLyric(int?nextToOrder = null)
        {
            var maxOrder = OrderUtils.GetMaxOrderNumber(Lyrics.ToArray());
            var order    = nextToOrder ?? maxOrder;

            if (order < 0 && order > maxOrder + 1)
            {
                throw new ArgumentOutOfRangeException(nameof(order));
            }

            changeHandler?.BeginChange();

            // Shifting order that order is larger than current lyric.
            OrderUtils.ShiftingOrder(Lyrics.Where(x => x.Order > order).ToArray(), 1);

            // Add new lyric to target order.
            var createLyric = new Lyric
            {
                Text  = "New lyric",
                Order = order + 1,
            };

            beatmap.Add(createLyric);

            changeHandler?.EndChange();
        }
Beispiel #6
0
        public virtual ActionResult ProcessPayPal(string token, string payerId)
        {
            var order = _context.Orders
                        .Where(x => x.PayPalToken == token && x.OrderedForId == CurrentUserId)
                        .FirstOrDefault();

            if (order == null || order.OrderStatus != DomainModel.Enums.OrderStatus.AwaitingPayment)
            {
                return(RedirectToAction(MVC.Home.Index()));
            }

            // Perform the payment
            string transactionId = ProcessPaypalTransaction(token, payerId, order.TotalPrice);

            order.PayPalTransactionId = transactionId;
            order.OrderStatus         = OrderStatus.Completed;
            _context.SaveChanges();

            var utils = new OrderUtils(_context, CurrentUserId);

            utils.ActivateOrderedLicenses(order);
            string license = utils.GetLicenseDescription(order.FillPerfectLicenses.First().LicenseType);

            return(RedirectToAction(MVC.Products.FillPerfect.LicenseActivated(
                                        (Guid)_context.Users.Find(order.OrderedForId).FillPerfectKey,
                                        order.FillPerfectLicenses.First().EffectiveDate,
                                        order.FillPerfectLicenses.First().ExpirationDate,
                                        license)));
        }
Beispiel #7
0
        public void TestChangeOrder(int[] orders, int oldOrder, int nowOrder, int[] movingOrders, int[] newOrder)
        {
            try
            {
                var objects = orders?.Select(x => new TestOrderObject {
                    Order = x
                }).ToArray();

                // record order index change step.
                var movingStepResult = new List <int>();

                // This utils only change order property.
                OrderUtils.ChangeOrder(objects, oldOrder, nowOrder, (_, o, _) =>
                {
                    movingStepResult.Add(o);
                });

                // change order result.
                var result = objects?.Select(x => x.Order).ToArray();
                Assert.AreEqual(result, newOrder);

                // should check moving order step also.
                Assert.AreEqual(movingStepResult.ToArray(), movingOrders);
            }
            catch
            {
                Assert.IsNull(newOrder);
            }
        }
        public IActionResult Get(JObject data)
        {
            Order  newOrder = JsonConvert.DeserializeObject <Order>(data.ToString());
            string orderId  = newOrder.orderId;

            return(OrderUtils.UpdateOrder(newOrder, (order) => order.orderId == newOrder.orderId) ?
                   (ActionResult) new OkObjectResult($"Updated order with order ID: {orderId}") :
                   new BadRequestObjectResult("No result found, nothing to update"));
        }
Beispiel #9
0
        public IActionResult Get(JObject data)
        {
            Order order = JsonConvert.DeserializeObject <Order>(data.ToString());

            order.orderId = Guid.NewGuid().ToString();

            return(OrderUtils.WriteOrder(order) ? (ActionResult) new OkObjectResult("Order Added") :
                   new BadRequestObjectResult("Error when adding new order"));
        }
Beispiel #10
0
        public void TestGetMaxOrderNumber(int[] orders, int number)
        {
            var objects = orders.Select(x => new TestOrderObject {
                Order = x
            }).ToArray();
            var result = OrderUtils.GetMaxOrderNumber(objects);

            Assert.AreEqual(result, number);
        }
Beispiel #11
0
        public void TestContainDuplicatedId(int[] orders, bool containDuplicated)
        {
            var objects = orders.Select(x => new TestOrderObject {
                Order = x
            }).ToArray();
            var result = OrderUtils.ContainDuplicatedId(objects);

            Assert.AreEqual(result, containDuplicated);
        }
Beispiel #12
0
        public virtual ActionResult ConfirmFillPerfectOrgOrder()
        {
            var orderUtils = new OrderUtils(_context, CurrentUserId);
            var model = orderUtils.GetFpOrgConfirmModel();
            if (model == null)
                throw new InvalidOperationException("Organization does not have a FP license");

            return View(model);
        }
Beispiel #13
0
        public void ChangeLyricOrder(Lyric lyric, int newIndex)
        {
            var oldOrder = lyric.Order;
            var newOrder = newIndex + 1; // order is start from 1

            OrderUtils.ChangeOrder(Lyrics.ToArray(), oldOrder, newOrder, (switchSinger, oldOrder, newOrder) =>
            {
                // todo : not really sure should call update?
            });
        }
Beispiel #14
0
        public void DeleteLyric(Lyric lyric)
        {
            changeHandler?.BeginChange();

            // Shifting order that order is larger than current lyric.
            OrderUtils.ShiftingOrder(Lyrics.Where(x => x.Order > lyric.Order).ToArray(), -1);
            beatmap.Remove(lyric);

            changeHandler?.EndChange();
        }
        public void GetOrder_Morning_OneOfEach_EntreeSideDrink_Test()
        {
            string[] inputOrder = new string[] { "morning", "2", "1", "3" };

            OrderUtils agent = new OrderUtils();

            string result = agent.GetOrderOutput(inputOrder);

            Assert.AreEqual("eggs,toast,coffee", result);
        }
Beispiel #16
0
        public void TestSorted(int[] orders, int[] actualOrders)
        {
            var objects = orders?.Select(x => new TestOrderObject {
                Order = x
            });
            var orderedArray = OrderUtils.Sorted(objects);
            var result       = orderedArray?.Select(x => x.Order).ToArray();

            Assert.AreEqual(result, actualOrders);
        }
        public void GetOrder_Morning_MultpleOrdersOfEntree_Test()
        {
            string[] inputOrder = new string[] { "morning", "1", "1", "3" };

            OrderUtils agent = new OrderUtils();

            string result = agent.GetOrderOutput(inputOrder);

            Assert.AreEqual("eggs,error", result);
        }
        public void GetOrder_Night_ErrorForMultipleOrdersOfEntree_Test()
        {
            string[] inputOrder = new string[] { "night", "1", "1", "2", "3", "5" };

            OrderUtils agent = new OrderUtils();

            string result = agent.GetOrderOutput(inputOrder);

            Assert.AreEqual("steak,error", result);
        }
        public void GetOrder_Night_InvalidOrder_Test()
        {
            string[] inputOrder = new string[] { "night", "1", "2", "3", "5" };

            OrderUtils agent = new OrderUtils();

            string result = agent.GetOrderOutput(inputOrder);

            Assert.AreEqual("steak,potato,wine,error", result);
        }
        public void GetOrder_Night_MultipleOrdersOfPotato_Test()
        {
            string[] inputOrder = new string[] { "night", "1", "2", "2", "4" };

            OrderUtils agent = new OrderUtils();

            string result = agent.GetOrderOutput(inputOrder);

            Assert.AreEqual("steak,potato(x2),cake", result);
        }
        public void GetOrder_Night_OneOfEach_EntreeSideDrinkDessert_Test()
        {
            string[] inputOrder = new string[] { "night", "1", "2", "3", "4" };

            OrderUtils agent = new OrderUtils();

            string result = agent.GetOrderOutput(inputOrder);

            Assert.AreEqual("steak,potato,wine,cake", result);
        }
        public void GetOrder_Morning_MultipleOrderOfDrink_Test()
        {
            string[] inputOrder = new string[] { "morning", "1", "2", "3", "3", "3" };

            OrderUtils agent = new OrderUtils();

            string result = agent.GetOrderOutput(inputOrder);

            Assert.AreEqual("eggs,toast,coffee(x3)", result);
        }
        public void GetOrder_Morning_GetErrorForDessertOrder_Test()
        {
            string[] inputOrder = new string[] { "morning", "1", "2", "3", "4" };

            OrderUtils agent = new OrderUtils();

            string result = agent.GetOrderOutput(inputOrder);

            Assert.AreEqual("eggs,toast,coffee,error", result);
        }
Beispiel #24
0
        public async Task <List <CBookEntity> > SearchAsync(string searchPath, string searchAuthor, string searchKeyword, IEnumerable <SortableItem> sortables)
        {
            var query = this.dbContext.Set <CBookEntity>()
                        .Where <CBookEntity>(book => StringUtils.IsBlank(searchPath) || book.Path.Contains(searchPath))
                        .Where <CBookEntity>(book => StringUtils.IsBlank(searchAuthor) || book.Author.Contains(searchAuthor))
                        .Where <CBookEntity>(book => StringUtils.IsBlank(searchKeyword) || book.Title.Contains(searchKeyword) || book.Name.Contains(searchKeyword));

            query = OrderUtils.Sort <CBookEntity>(query, sortables);

            return(await query.ToListAsync <CBookEntity>());
        }
Beispiel #25
0
        public IActionResult Get(JObject data)
        {
            Customer     customer    = JsonConvert.DeserializeObject <Customer>(data.ToString());
            List <Order> queryResult = OrderUtils.QueryOrder((order) => {
                return(CustomerUtils.CompareCustomer(order.customer, customer));
            });

            return(queryResult.Count >= 1 ?
                   (ActionResult) new OkObjectResult(JsonConvert.SerializeObject(queryResult, Formatting.Indented)) :
                   new BadRequestObjectResult("No result found"));
        }
Beispiel #26
0
        public virtual ActionResult ConfirmFillPerfectOrgOrder()
        {
            var orderUtils = new OrderUtils(_context, CurrentUserId);
            var model      = orderUtils.GetFpOrgConfirmModel();

            if (model == null)
            {
                throw new InvalidOperationException("Organization does not have a FP license");
            }

            return(View(model));
        }
Beispiel #27
0
        public async Task <List <AVideoEntity> > SearchAsync(string searchPath, string searchProducer, string searchKeyword, IEnumerable <SortableItem> sortables)
        {
            //var Id = new SqlParameter("author", "%" + searchAuthor + "%");

            var query = this.dbContext.Set <AVideoEntity>()
                        .Where <AVideoEntity>(video => StringUtils.IsBlank(searchPath) || video.Path.Contains(searchPath))
                        .Where <AVideoEntity>(video => StringUtils.IsBlank(searchProducer) || video.Producer.Contains(searchProducer))
                        .Where <AVideoEntity>(video => StringUtils.IsBlank(searchKeyword) || video.Title.Contains(searchKeyword) || video.Name.Contains(searchKeyword));

            query = OrderUtils.Sort <AVideoEntity>(query, sortables);

            return(await query.ToListAsync <AVideoEntity>());
        }
Beispiel #28
0
        [TestCase(new[] { 4, 3, 2, 1 }, 1, new[] { 5, 4, 3, 2 })] // Not care order in objects and just doing shifting job.
        public void TestShiftingOrder(int[] orders, int shifting, int[] newOrder)
        {
            var objects = orders?.Select(x => new TestOrderObject {
                Order = x
            }).ToArray();

            OrderUtils.ShiftingOrder(objects, shifting);

            // convert order result.
            var result = objects?.Select(x => x.Order).ToArray();

            Assert.AreEqual(result, newOrder);
        }
        // GET: MenuOrders/Details/5
        public ActionResult Details(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            MenuOrder menuOrder = db.MenuOrders.Find(id);

            if (menuOrder == null)
            {
                return(HttpNotFound());
            }
            return(View(OrderUtils.GetOrderModel(menuOrder)));
        }
Beispiel #30
0
        public virtual ActionResult Confirm(int productId)
        {
            var orderUtils = new OrderUtils(_context, CurrentUserId);
            var model = orderUtils.GetConfirmModel(productId);
            if (model == null)
                throw new InvalidOperationException(
                    string.Format("Product id {0} was not found", productId));

            // Set the effective date to today if the last license expired prior to today
            if (model.LicenseEffectiveDate <= DateTime.Today)
                model.LicenseEffectiveDate = DateTime.Today;

            return View(model);
        }
Beispiel #31
0
        public virtual ActionResult Index(int orderId)
        {
            var order = _context.Orders
                        .Where(x => x.Id == orderId && x.OrderedForId == CurrentUserId)
                        .FirstOrDefault();

            if (order == null || order.OrderStatus != DomainModel.Enums.OrderStatus.AwaitingPayment)
            {
                return(RedirectToAction(MVC.Home.Index()));
            }

            var model = new OrderUtils(_context, CurrentUserId).GetConfirmModel(order.OrderedProducts.First().ProductId);

            model.OrderId = orderId;
            return(View(model));
        }
Beispiel #32
0
        public override bool AddPizza()
        {
            var newPizza = OrderUtils.ChosePizza();

            if (newPizza != null)
            {
                Console.WriteLine("Pizza was added to the order");

                order.Pizzas.Add(newPizza);
                return(true);
            }
            else
            {
                return(false);
            }
        }
Beispiel #33
0
        public virtual ActionResult ConfirmFillPerfectOrgOrder(FillPerfectOrgLicenseConfirmViewModel model)
        {
            var orderUtils = new OrderUtils(_context, CurrentUserId);

            if (!model.OrderConfirmed)
            {
                // Regenerate the model
                model = orderUtils.GetFpOrgConfirmModel();
                ModelState.AddModelError("OrderConfirmed", "You must check the confirmation box to activate this license");
                return(View(model));
            }

            // Regenerate the model for license details
            model = orderUtils.GetFpOrgConfirmModel();

            // Create the order and automatically activate the license
            var order = orderUtils.CreateOrder();

            order.FillPerfectLicenses.Add(new FpUserLicense
            {
                LicenseType    = FillPerfectLicenseType.OrganizationGranted,
                EffectiveDate  = model.ActivatedLicenseExpiratioDate >= model.EffectiveLicenseDate ? model.ActivatedLicenseExpiratioDate : model.EffectiveLicenseDate,
                ExpirationDate = model.ExpirationDate
            });

            // Make sure the user has a FP key
            var user = _context.Users.Find(order.OrderedForId);

            if (user.FillPerfectKey == null)
            {
                user.FillPerfectKey = Guid.NewGuid();
            }

            _context.SaveChanges();

            // Show the user confirmation
            string orgName = _context.Users.Where(x => x.Id == CurrentUserId).Select(x => x.Organization.Name).FirstOrDefault();

            return(RedirectToAction(
                       MVC.Products.FillPerfect.LicenseActivated(
                           (Guid)user.FillPerfectKey,
                           order.FillPerfectLicenses.First().EffectiveDate,
                           order.FillPerfectLicenses.First().ExpirationDate,
                           "License granted by " + orgName)));
        }
Beispiel #34
0
        public virtual ActionResult ConfirmFillPerfectOrgOrder(FillPerfectOrgLicenseConfirmViewModel model)
        {
            var orderUtils = new OrderUtils(_context, CurrentUserId);

            if (!model.OrderConfirmed)
            {
                // Regenerate the model
                model = orderUtils.GetFpOrgConfirmModel();
                ModelState.AddModelError("OrderConfirmed", "You must check the confirmation box to activate this license");
                return View(model);
            }

            // Regenerate the model for license details
            model = orderUtils.GetFpOrgConfirmModel();

            // Create the order and automatically activate the license
            var order = orderUtils.CreateOrder();
            order.FillPerfectLicenses.Add(new FpUserLicense
            {
                LicenseType = FillPerfectLicenseType.OrganizationGranted,
                EffectiveDate = model.ActivatedLicenseExpiratioDate >= model.EffectiveLicenseDate ? model.ActivatedLicenseExpiratioDate : model.EffectiveLicenseDate,
                ExpirationDate = model.ExpirationDate
            });

            // Make sure the user has a FP key
            var user = _context.Users.Find(order.OrderedForId);
            if (user.FillPerfectKey == null)
                user.FillPerfectKey = Guid.NewGuid();

            _context.SaveChanges();

            // Show the user confirmation
            string orgName = _context.Users.Where(x => x.Id == CurrentUserId).Select(x => x.Organization.Name).FirstOrDefault();

            return RedirectToAction(
                MVC.Products.FillPerfect.LicenseActivated(
                    (Guid)user.FillPerfectKey,
                    order.FillPerfectLicenses.First().EffectiveDate,
                    order.FillPerfectLicenses.First().ExpirationDate,
                    "License granted by " + orgName));
        }