Exemple #1
0
        public void MarkRead(MarkReadDto dto)
        {
            var subscriptionHandler = this.subscriptionHandlerFactory.GetProvider(dto.StreamType);

            subscriptionHandler.MarkRead(dto.DisplayedItems);
            subscriptionHandler.AddEventViewed(dto.Id);
        }
Exemple #2
0
        public void Mark(int id, [FromBody] MarkReadDto dto)
        {
            var r = store.Get(id);

            readStatusStore.Save(new ReadStatus
            {
                MessageId = id,
                UserId    = dto.User,
                Read      = dto.Read
            });
        }
Exemple #3
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="read"></param>
        /// <param name="user"></param>

        public void Mark(MarkReadDto dto, int messageId)
        {
            var client = new HttpClient();
            var url    = host + "Mark/" + messageId;

            client.DefaultRequestHeaders.Add("signature", Md5(url + appKey));
            var httpContent = GetContent(client, dto);
            var response    = client.PutAsync(url, httpContent).Result;

            if (response.StatusCode == System.Net.HttpStatusCode.OK)
            {
                return;
            }

            throw new Exception("Mark error " + response.Content.ReadAsStringAsync().Result);
        }
        public void T003_Marking_As_Read_Must_Create_An_Event_Viewed_With_Id_Of_That_Rss()
        {
            // assert
            var mockSubscriptionHandler = this.moqer.GetMock<ISubscriptionHandler>();

            this.mockSubscriptionHandlerFactory
                .Setup(s => s.GetProvider(It.IsAny<StreamType>()))
                .Returns(mockSubscriptionHandler.Object);

            var markReadDto = new MarkReadDto { StreamType = StreamType.Rss, Id = 3345, DisplayedItems = "0" };

            // act
            this.sut.MarkRead(markReadDto);

            // assert
            mockSubscriptionHandler.Verify(v => v.AddEventViewed(It.Is<long>(p => p == 3345)));
        }
        public void T001_Marking_Rss_As_Read_Must_Mark_It_Via_Repository()
        {
            // assert
            var mockSubscriptionHandler = this.moqer.GetMock<ISubscriptionHandler>();

            this.mockSubscriptionHandlerFactory
                .Setup(s => s.GetProvider(It.IsAny<StreamType>()))
                .Returns(mockSubscriptionHandler.Object);

            var markReadDto = new MarkReadDto { StreamType = StreamType.Rss, Id = 0, DisplayedItems = "0" };

            // act
            this.sut.MarkRead(markReadDto);

            // assert
            mockSubscriptionHandler.Verify(v => v.MarkRead(It.IsAny<string>()), Times.Once);
        }
        public void T002_Marking_As_Read_Must_Fetch_Handler_For_Proper_Stream_Type()
        {
            // assert
            var mockSubscriptionHandler = this.moqer.GetMock<ISubscriptionHandler>();

            this.mockSubscriptionHandlerFactory
                .Setup(s => s.GetProvider(It.IsAny<StreamType>()))
                .Returns(mockSubscriptionHandler.Object);

            var markReadDto = new MarkReadDto { StreamType = StreamType.Rss, Id = 0, DisplayedItems = "0" };

            // act
            this.sut.MarkRead(markReadDto);

            // assert
            this.mockSubscriptionHandlerFactory
                .Verify(v => v.GetProvider(It.Is<StreamType>(p => p == StreamType.Rss)),
                Times.Once);
        }
        public void T003_Marking_As_Read_Must_Create_An_Event_Viewed_With_Id_Of_That_Rss()
        {
            // assert
            var mockSubscriptionHandler = this.moqer.GetMock <ISubscriptionHandler>();

            this.mockSubscriptionHandlerFactory
            .Setup(s => s.GetProvider(It.IsAny <StreamType>()))
            .Returns(mockSubscriptionHandler.Object);

            var markReadDto = new MarkReadDto {
                StreamType = StreamType.Rss, Id = 3345, DisplayedItems = "0"
            };

            // act
            this.sut.MarkRead(markReadDto);

            // assert
            mockSubscriptionHandler.Verify(v => v.AddEventViewed(It.Is <long>(p => p == 3345)));
        }
        public void T001_Marking_Rss_As_Read_Must_Mark_It_Via_Repository()
        {
            // assert
            var mockSubscriptionHandler = this.moqer.GetMock <ISubscriptionHandler>();

            this.mockSubscriptionHandlerFactory
            .Setup(s => s.GetProvider(It.IsAny <StreamType>()))
            .Returns(mockSubscriptionHandler.Object);

            var markReadDto = new MarkReadDto {
                StreamType = StreamType.Rss, Id = 0, DisplayedItems = "0"
            };

            // act
            this.sut.MarkRead(markReadDto);

            // assert
            mockSubscriptionHandler.Verify(v => v.MarkRead(It.IsAny <string>()), Times.Once);
        }
        public async Task <ActionResult> MarkRead(MarkReadDto markReadDto)
        {
            var user = await _unitOfWork.UserRepository.GetUserByUsernameAsync(User.GetUsername());

            var volumes = await _unitOfWork.SeriesRepository.GetVolumes(markReadDto.SeriesId);

            user.Progresses ??= new List <AppUserProgress>();
            foreach (var volume in volumes)
            {
                foreach (var chapter in volume.Chapters)
                {
                    var userProgress = user.Progresses.SingleOrDefault(x => x.ChapterId == chapter.Id && x.AppUserId == user.Id);
                    if (userProgress == null) // I need to get all chapters and generate new user progresses for them?
                    {
                        user.Progresses.Add(new AppUserProgress
                        {
                            PagesRead = chapter.Pages,
                            VolumeId  = volume.Id,
                            SeriesId  = markReadDto.SeriesId,
                            ChapterId = chapter.Id
                        });
                    }
                    else
                    {
                        userProgress.PagesRead = chapter.Pages;
                        userProgress.SeriesId  = markReadDto.SeriesId;
                        userProgress.VolumeId  = volume.Id;
                    }
                }
            }

            _unitOfWork.UserRepository.Update(user);

            if (await _unitOfWork.Complete())
            {
                return(Ok());
            }


            return(BadRequest("There was an issue saving progress"));
        }
        public void T002_Marking_As_Read_Must_Fetch_Handler_For_Proper_Stream_Type()
        {
            // assert
            var mockSubscriptionHandler = this.moqer.GetMock <ISubscriptionHandler>();

            this.mockSubscriptionHandlerFactory
            .Setup(s => s.GetProvider(It.IsAny <StreamType>()))
            .Returns(mockSubscriptionHandler.Object);

            var markReadDto = new MarkReadDto {
                StreamType = StreamType.Rss, Id = 0, DisplayedItems = "0"
            };

            // act
            this.sut.MarkRead(markReadDto);

            // assert
            this.mockSubscriptionHandlerFactory
            .Verify(v => v.GetProvider(It.Is <StreamType>(p => p == StreamType.Rss)),
                    Times.Once);
        }
Exemple #11
0
        public void Marking_As_Read_Must_Call_Mark_Read_On_Handler()
        {
            // arrange
            var stub = new MarkReadDto
            {
                DisplayedItems = string.Empty,
                Id             = 0,
                StreamType     = StreamType.Person
            };

            var mockHandler = new Mock <ISubscriptionHandler>();

            this.mockSubscriptionHandlerFactory
            .Setup(s => s.GetProvider(It.IsAny <StreamType>()))
            .Returns(mockHandler.Object);

            // act
            this.sut.MarkRead(stub);

            // assert
            mockHandler
            .Verify(v => v.MarkRead(It.IsAny <string>()),
                    Times.Once);
        }
 public ActionResult MarkReadWithEvent(MarkReadDto dto)
 {
     this.rssSubscriptionService.MarkRead(dto);
     return new HttpStatusCodeResult(HttpStatusCode.OK);
 }
 public void MarkRead(MarkReadDto dto)
 {
     var subscriptionHandler = this.subscriptionHandlerFactory.GetProvider(dto.StreamType);
     subscriptionHandler.MarkRead(dto.DisplayedItems);
     subscriptionHandler.AddEventViewed(dto.Id);
 }
Exemple #14
0
 public ActionResult MarkReadWithEvent(MarkReadDto dto)
 {
     this.rssSubscriptionService.MarkRead(dto);
     return(new HttpStatusCodeResult(HttpStatusCode.OK));
 }