Exemplo n.º 1
0
        public async Task <ActionResult <MutationResult> > DeleteAsync(string id)
        {
            var mutation = new DeleteAnnouncement {
                Id = id
            };

            return(GetResult(await _mutationsHanlder.Handle(mutation)));
        }
        void Propagate(DeleteAnnouncement request)
        {
            if (!string.IsNullOrEmpty(request.Cooperator))
            {
                var client = new RestClient(request.Cooperator);

                var requestToSend = new RestRequest($"topics/{request.TopicName}/announcements/{request.AnnouncementId}", Method.DELETE);
                requestToSend.RequestFormat = DataFormat.Json;
                requestToSend.AddParameter("SubscriberId", request.SubscriberId);

                client.Execute(requestToSend);
            }
        }
        public void Delete(DeleteAnnouncement request)
        {
            var topicLock = Locks.TakeTopicLock(request.TopicName);

            lock (topicLock)
            {
                if (Locks.TopicsRecoveryLocks.ContainsKey(request.TopicName))
                {
                    throw new Exception($"Topic {request.TopicName} is inconsistent");
                }

                using (var connection = Connections.ConnectToInitializedTopic(request.TopicName))
                {
                    Delete(connection, request);
                }
            }
        }
        void Delete(IDbConnection connection, DeleteAnnouncement request)
        {
            var subscriber   = connection.GetById <Subscriber>(request.SubscriberId);
            var announcement = connection.First(NextAnnouncement.make(connection, subscriber));

            if (announcement.Id != request.AnnouncementId)
            {
                throw new ArgumentException("Invalid announcement");
            }

            connection.UpdateOnly(new Subscriber {
                LastAnnouncementId = announcement.Id
            },
                                  subscription => new { subscription.LastAnnouncementId },
                                  subscription => subscription.Id == subscriber.Id);
            Propagators.ScheduleTopicOperation(request.TopicName, () => Propagate(request));
        }
        public async void DeleteAnnouncement(
            EStatusCode expectedStatus,
            DeleteAnnouncement mutation
            )
        {
            if (expectedStatus != EStatusCode.NotFound)
            {
                EntitiesFactory.NewAnnouncement(id: mutation.Id).Save();
            }

            var result = await MutationsHandler.Handle(mutation);

            Assert.Equal(expectedStatus, result.Status);
            if (expectedStatus == EStatusCode.Success)
            {
                var existsAnnouncement = await MutationsDbContext.Announcements.AnyAsync(a => a.Id == mutation.Id);

                Assert.False(existsAnnouncement);
            }
        }