Ejemplo n.º 1
0
        public async Task Create_ExceedsShipmentsRemaining_ReturnsError()
        {
            movementId[0] = Guid.NewGuid();

            var remainingshipment = new RemainingShipmentsData
            {
                ShipmentsRemaining         = 100,
                ActiveLoadsPermitted       = 20,
                ActiveLoadsRemainingByDate = 20
            };

            var model = new CreateMovementsViewModel
            {
                Day            = 6,
                Month          = 2,
                Year           = 2019,
                Quantity       = "1",
                NumberToCreate = remainingshipment.ShipmentsRemaining + 1,
                PackagingTypes = CheckBoxCollectionViewModel.CreateFromEnum <PackagingType>()
            };

            model.PackagingTypes.PossibleValues.First(y => y.Value == "1").Selected = true;
            model.Units = ShipmentQuantityUnits.Kilograms;

            A.CallTo(
                () => mediator.SendAsync(A <GetRemainingShipments> .That.Matches(p => p.NotificationId == notificationId)))
            .Returns(remainingshipment);

            var result = await controller.Index(notificationId, model) as ViewResult;

            Assert.NotNull(result);
            Assert.False(result.ViewData.ModelState.IsValid);
            Assert.True(result.ViewData.ModelState.Keys.Any(k => k == NumberToCreateDisplayName));
        }
Ejemplo n.º 2
0
        public async Task <ActionResult> Index(Guid notificationId, bool overrideRule = false)
        {
            ViewBag.NotificationId = notificationId;

            var ruleSummary = await mediator.SendAsync(new GetMovementRulesSummary(notificationId));

            if (!ruleSummary.IsSuccess && !overrideRule)
            {
                return(GetRuleErrorView(ruleSummary));
            }

            var shipmentInfo = await mediator.SendAsync(new GetShipmentInfo(notificationId));

            var model = new CreateMovementsViewModel(shipmentInfo);

            model.OverrideRule = overrideRule;
            if (TempData["TempMovement"] != null)
            {
                var tempMovement = (TempMovement)TempData["TempMovement"];
                model.NumberToCreate = tempMovement.NumberToCreate;
                model.Quantity       = tempMovement.Quantity.ToString();
                model.Units          = tempMovement.ShipmentQuantityUnits;
                model.PackagingTypes.SetSelectedValues(tempMovement.PackagingTypes);
            }

            return(View("Index", model));
        }
Ejemplo n.º 3
0
        public async Task Create_ReturnsWhoAreyourCarrier()
        {
            var packagingTypes = CheckBoxCollectionViewModel.CreateFromEnum <PackagingType>();

            movementId[0] = new Guid("AF1839A1-DA40-430B-9DFE-D79194175DFD");

            var remainingshipment = new RemainingShipmentsData
            {
                ShipmentsRemaining         = 400,
                ActiveLoadsPermitted       = 300,
                ActiveLoadsRemainingByDate = 100
            };

            var model = new CreateMovementsViewModel
            {
                Day            = 6,
                Month          = 2,
                Year           = 2019,
                Quantity       = "1",
                NumberToCreate = 1,
                PackagingTypes = packagingTypes
            };

            model.PackagingTypes.PossibleValues.First(y => y.Value == "1").Selected = true;
            model.Units = ShipmentQuantityUnits.Kilograms;

            A.CallTo(
                () => mediator.SendAsync(A <GetRemainingShipments> .That.Matches(p => p.NotificationId == notificationId)))
            .Returns(remainingshipment);

            A.CallTo(
                () => mediator.SendAsync(A <GetWorkingDaysUntil> .That.Matches(p => p.NotificationId == notificationId)))
            .Returns(6);

            A.CallTo(() => mediator.SendAsync(A <CreateMovements> .That.Matches(p => p.NotificationId == notificationId)))
            .Returns(movementId);

            var result = await controller.Index(notificationId, model) as RedirectToRouteResult;

            Assert.NotNull(result);
            Assert.Equal("WhoAreYourCarriers", result.RouteValues["action"]);
        }
Ejemplo n.º 4
0
        public async Task <ActionResult> Index(Guid notificationId, CreateMovementsViewModel model)
        {
            ViewBag.NotificationId = notificationId;

            if (!ModelState.IsValid)
            {
                return(View(model));
            }

            var proposedMovementDate =
                await mediator.SendAsync(new IsProposedMovementDateValid(notificationId, model.ShipmentDate.Value));

            if (proposedMovementDate.IsOutOfRange)
            {
                ModelState.AddModelError("Day",
                                         "The actual date of shipment cannot be more than 30 calendar days in the future. Please enter a different date.");
            }

            if (proposedMovementDate.IsOutsideConsentPeriod)
            {
                ModelState.AddModelError("Day",
                                         "The actual date of shipment cannot be outside of the consent validity period. Please enter a different date.");
            }

            var hasExceededTotalQuantity = await mediator.SendAsync(new HasExceededConsentedQuantity(notificationId,
                                                                                                     Convert.ToDecimal(model.Quantity) * model.NumberToCreate.Value, model.Units.Value));

            if (hasExceededTotalQuantity)
            {
                ModelState.AddModelError("Quantity", CreateMovementsViewModelResources.HasExceededTotalQuantity);
            }

            var remainingShipmentsData = await mediator.SendAsync(new GetRemainingShipments(notificationId, model.ShipmentDate));

            if (model.NumberToCreate > remainingShipmentsData.ShipmentsRemaining)
            {
                ModelState.AddModelError("NumberToCreate",
                                         string.Format("You cannot create {0} shipments as there are only {1} remaining", model.NumberToCreate, remainingShipmentsData.ShipmentsRemaining));
            }
            else if (model.NumberToCreate > remainingShipmentsData.ActiveLoadsPermitted)
            {
                ModelState.AddModelError("NumberToCreate",
                                         string.Format(
                                             "You can't generate more than {0} prenotifications on {1}, as this will exceed your permitted active loads.",
                                             remainingShipmentsData.ActiveLoadsPermitted,
                                             model.ShipmentDate.Value.ToString("dd/MM/yyyy", CultureInfo.InvariantCulture)));
            }
            else if (model.NumberToCreate > remainingShipmentsData.ActiveLoadsRemainingByDate)
            {
                ModelState.AddModelError("NumberToCreate",
                                         string.Format("You already have {0} prenotifications for {1} and you are only permitted to prenotify {2} shipments. {3} shipment will exceed your limit on that date.",
                                                       remainingShipmentsData.ActiveLoadsPermitted - remainingShipmentsData.ActiveLoadsRemainingByDate,
                                                       model.ShipmentDate.Value.ToString("dd/MM/yyyy", CultureInfo.InvariantCulture),
                                                       remainingShipmentsData.ActiveLoadsPermitted,
                                                       model.NumberToCreate));
            }

            if (!ModelState.IsValid)
            {
                return(View(model));
            }

            var workingDaysUntilShipment =
                await
                mediator.SendAsync(new GetWorkingDaysUntil(notificationId, model.ShipmentDate.GetValueOrDefault()));

            if (workingDaysUntilShipment < 4)
            {
                var tempMovement = new TempMovement(model.NumberToCreate.Value,
                                                    model.ShipmentDate.Value,
                                                    Convert.ToDecimal(model.Quantity),
                                                    model.Units.Value,
                                                    model.SelectedPackagingTypes);

                TempData["TempMovement"] = tempMovement;

                return(RedirectToAction("ThreeWorkingDaysWarning", "Create", new { rejectRules = model.OverrideRule }));
            }

            var newMovementIds = await mediator.SendAsync(new CreateMovements(
                                                              notificationId,
                                                              model.NumberToCreate.Value,
                                                              model.ShipmentDate.Value,
                                                              Convert.ToDecimal(model.Quantity),
                                                              model.Units.Value,
                                                              model.SelectedPackagingTypes));

            return(RedirectToAction("WhoAreYourCarriers", newMovementIds.ToRouteValueDictionary("newMovementIds")));
        }