Example #1
0
        public static async Task <bool> DeleteItemAsync(string id, InternalDelivery delivery)
        {
            using (logger.BeginScope(nameof(DeleteItemAsync)))
            {
                logger.LogInformation("id: {Id}", id);

                logger.LogInformation("Start: updating item's TTL in Redis");
                var success = await cache.KeyExpireAsync(id, DateTime.UtcNow.AddDays(7)).ConfigureAwait(continueOnCapturedContext: false);

                logger.LogInformation("End: updating item's TTL in Redis");

                return(success);
            }
        }
        public async Task <IActionResult> Confirm(string id, [FromBody] Confirmation confirmation)
        {
            logger.LogInformation("In Confirm action with id: {Id} and confirmation: {@Confirmation}", id, confirmation.ToLogInfo());

            var delivery = await deliveryRepository.GetAsync(id);

            if (delivery == null)
            {
                logger.LogDebug("Delivery id: {Id} not found", id);
                return(NotFound());
            }

            var confirmedDelivery = new InternalDelivery(delivery.Id,
                                                         delivery.Owner,
                                                         delivery.Pickup,
                                                         confirmation.GeoCoordinates,
                                                         delivery.Deadline,
                                                         delivery.Expedited,
                                                         delivery.ConfirmationRequired,
                                                         delivery.DroneId);

            var internalConfirmation = new InternalConfirmation
            {
                DateTime         = confirmation.DateTime,
                GeoCoordinates   = confirmation.GeoCoordinates,
                ConfirmationType = confirmation.ConfirmationType,
                ConfirmationBlob = confirmation.ConfirmationBlob
            };

            // Adds the delivery complete status event
            await deliveryTrackingRepository.AddAsync(
                new DeliveryTrackingEvent
            {
                DeliveryId = id,
                Stage      = DeliveryStage.Completed
            });

            // sends notifications
            var notifyMeRequests = await notifyMeRequestRepository.GetAllByDeliveryIdAsync(id);

            IEnumerable <Task> notificationTasks = notifyMeRequests.Select(nR => notificationService.SendNotificationsAsync(nR));

            await Task.WhenAll(notificationTasks);

            // logical delivery deletion
            await deliveryRepository.DeleteAsync(id, confirmedDelivery);

            return(Ok());
        }
        public async Task Confirm_DeletesDeliveryLogically()
        {
            // Arrange
            InternalDelivery    confirmedDelivery = null;
            DeliveryStatusEvent completeEvent     = null;

            var deliveryRepository = new Mock <IDeliveryRepository>();

            deliveryRepository.Setup(r => r.GetAsync("deliveryid")).ReturnsAsync(delivery);
            deliveryRepository.Setup(r => r.DeleteAsync("deliveryid", It.IsAny <InternalDelivery>()))
            .Returns(Task.CompletedTask)
            .Callback <string, InternalDelivery>((i, d) => confirmedDelivery = d);

            var deliveryStatusEventRepository = new Mock <IDeliveryStatusEventRepository>();

            deliveryStatusEventRepository.Setup(r => r.AddAsync(It.IsAny <DeliveryStatusEvent>()))
            .Returns(Task.CompletedTask)
            .Callback <DeliveryStatusEvent>(e => completeEvent = e);

            deliveryStatusEventRepository.Setup(r => r.GetByDeliveryIdAsync("deliveryid"))
            .ReturnsAsync(new ReadOnlyCollection <DeliveryStatusEvent>(new List <DeliveryStatusEvent>()
            {
                completeEvent
            }));

            var loggerFactory = new Mock <ILoggerFactory>();

            loggerFactory.Setup(f => f.CreateLogger(It.IsAny <string>())).Returns(new Mock <ILogger>().Object);

            var target = new DeliveriesController(deliveryRepository.Object,
                                                  new Mock <INotifyMeRequestRepository>().Object,
                                                  new Mock <INotificationService>().Object,
                                                  new Mock <IDeliveryHistoryService>().Object,
                                                  deliveryStatusEventRepository.Object,
                                                  loggerFactory.Object);
            var location     = new Location(1, 2, 3);
            var confirmation = new Confirmation(new DateTimeStamp("datetimevalue"),
                                                location,
                                                ConfirmationType.Picture,
                                                "confirmationblob");

            // Act
            var result = await target.Confirm("deliveryid", confirmation) as OkResult;

            // Assert
            Assert.IsNotNull(result);
            deliveryRepository.Verify(r => r.DeleteAsync("deliveryid", confirmedDelivery));
            Assert.AreEqual(location, confirmedDelivery.Dropoff);
        }
        public async Task Patch_UpdatesCache()
        {
            // Arrange
            InternalDelivery updatedDelivery = null;
            var rescheduledDelivery          = new RescheduledDelivery(new Location(2, 2, 2),
                                                                       new Location(3, 3, 3),
                                                                       "newdeadline");

            var deliveryRepository = new Mock <IDeliveryRepository>();

            deliveryRepository.Setup(r => r.GetAsync("deliveryid")).ReturnsAsync(delivery);
            deliveryRepository.Setup(r => r.UpdateAsync("deliveryid", It.IsAny <InternalDelivery>()))
            .Returns(Task.CompletedTask)
            .Callback((string i, InternalDelivery d) => updatedDelivery = d);

            var loggerFactory = new Mock <ILoggerFactory>();

            loggerFactory.Setup(f => f.CreateLogger(It.IsAny <string>())).Returns(new Mock <ILogger>().Object);

            var target = new DeliveriesController(deliveryRepository.Object,
                                                  new Mock <INotifyMeRequestRepository>().Object,
                                                  new Mock <INotificationService>().Object,
                                                  new Mock <IDeliveryHistoryService>().Object,
                                                  new Mock <IDeliveryStatusEventRepository>().Object,
                                                  loggerFactory.Object);

            // Act
            await target.Patch("deliveryid", rescheduledDelivery);

            // Assert
            //unchanged values
            Assert.AreEqual("deliveryid", updatedDelivery.Id);
            Assert.AreEqual("userid", updatedDelivery.Owner.UserId);

            //updated values
            Assert.AreEqual(2, updatedDelivery.Pickup.Altitude);
            Assert.AreEqual(3, updatedDelivery.Dropoff.Altitude);
            Assert.AreEqual("newdeadline", updatedDelivery.Deadline);

            deliveryRepository.VerifyAll();
        }
Example #5
0
 public async Task CancelAsync(InternalDelivery delivery, params DeliveryTrackingEvent[] deliveryTrackingEvents)
 {
     await EventHubSender <DeliveryHistory> .SendMessageAsync(new DeliveryHistory(delivery.Id, delivery, deliveryTrackingEvents), nameof(DeliveryStage.Cancelled), delivery.Id.Substring(0, Constants.PartitionKeyLength)).ConfigureAwait(continueOnCapturedContext: false);
 }
Example #6
0
 public async Task CompleteAsync(InternalDelivery delivery, InternalConfirmation confirmation, params DeliveryTrackingEvent[] deliveryTrackingEvents)
 {
     //TODO: shallowing confirmation (TBD)
     await EventHubSender <DeliveryHistory> .SendMessageAsync(new DeliveryHistory(delivery.Id, delivery, deliveryTrackingEvents), nameof(DeliveryStage.Completed), delivery.Id.Substring(0, Constants.PartitionKeyLength)).ConfigureAwait(continueOnCapturedContext: false);
 }
Example #7
0
 public async Task CancelAsync(InternalDelivery delivery, params DeliveryStatusEvent[] events)
 {
     await EventHubSender <DeliveryHistory> .SendMessageAsync(new DeliveryHistory(delivery.Id, delivery, events), DeliveryEventType.Cancelled.ToString(), delivery.Id.Substring(0, Constants.PartitionKeyLength)).ConfigureAwait(continueOnCapturedContext: false);
 }
        public async Task Confirm_SendsMessageCompleteToDeliveryHistory()
        {
            // Arrange
            InternalDelivery     confirmedDelivery = null;
            InternalConfirmation sentConfirmation  = null;
            DeliveryStatusEvent  completeEvent     = null;

            DeliveryStatusEvent[] allEvents = null;

            var deliveryRepository = new Mock <IDeliveryRepository>();

            deliveryRepository.Setup(r => r.GetAsync("deliveryid")).ReturnsAsync(delivery);

            var notifyMeRequestRepository = new Mock <INotifyMeRequestRepository>();

            notifyMeRequestRepository.Setup(r => r.GetAllByDeliveryIdAsync("deliveryid"))
            .ReturnsAsync(new List <InternalNotifyMeRequest>());

            var deliveryStatusEventRepository = new Mock <IDeliveryStatusEventRepository>();

            deliveryStatusEventRepository.Setup(r => r.AddAsync(It.IsAny <DeliveryStatusEvent>()))
            .Returns(Task.CompletedTask)
            .Callback <DeliveryStatusEvent>(e => completeEvent = e);

            deliveryStatusEventRepository.Setup(r => r.GetByDeliveryIdAsync("deliveryid"))
            .ReturnsAsync(new ReadOnlyCollection <DeliveryStatusEvent>(new List <DeliveryStatusEvent>()
            {
                completeEvent
            }));

            var deliveryHistoryService = new Mock <IDeliveryHistoryService>();

            deliveryHistoryService.Setup(r => r.CompleteAsync(It.IsAny <InternalDelivery>(), It.IsAny <InternalConfirmation>(), It.IsAny <DeliveryStatusEvent[]>()))
            .Returns(Task.CompletedTask)
            .Callback <InternalDelivery, InternalConfirmation, DeliveryStatusEvent[]>((d, c, es) =>
            {
                confirmedDelivery = d;
                sentConfirmation  = c;
                allEvents         = es;
            });

            var loggerFactory = new Mock <ILoggerFactory>();

            loggerFactory.Setup(f => f.CreateLogger(It.IsAny <string>())).Returns(new Mock <ILogger>().Object);

            var target = new DeliveriesController(deliveryRepository.Object,
                                                  notifyMeRequestRepository.Object,
                                                  new Mock <INotificationService>().Object,
                                                  deliveryHistoryService.Object,
                                                  deliveryStatusEventRepository.Object,
                                                  loggerFactory.Object);

            var confirmation = new Confirmation(new DateTimeStamp("datetimevalue"),
                                                new Location(1, 2, 3),
                                                ConfirmationType.Picture,
                                                "confirmationblob");

            // Act
            var result = await target.Confirm("deliveryid", confirmation) as OkResult;

            // Assert
            Assert.IsNotNull(result);
            Assert.AreEqual("datetimevalue", sentConfirmation.DateTime.DateTimeValue);
            Assert.AreEqual(1, sentConfirmation.GeoCoordinates.Altitude);
            Assert.AreEqual(2, sentConfirmation.GeoCoordinates.Latitude);
            Assert.AreEqual(3, sentConfirmation.GeoCoordinates.Longitude);
            Assert.AreEqual(ConfirmationType.Picture, sentConfirmation.ConfirmationType);
            Assert.AreEqual("confirmationblob", sentConfirmation.ConfirmationBlob);
            deliveryHistoryService.Verify(s => s.CompleteAsync(confirmedDelivery, It.IsAny <InternalConfirmation>(), allEvents), Times.Once);
        }
Example #9
0
 public async Task DeleteAsync(string id, InternalDelivery delivery)
 {
     await RedisCache <InternalDelivery> .DeleteItemAsync(id, delivery).ConfigureAwait(continueOnCapturedContext: false);
 }
Example #10
0
 public async Task CreateAsync(InternalDelivery delivery)
 {
     await RedisCache <InternalDelivery> .CreateItemAsync(delivery).ConfigureAwait(continueOnCapturedContext: false);
 }