Example #1
0
        public IEnumerable <DebtDetailResponseDto> GetAll(DebtFilterDto debtFilterDto)
        {
            var userId = Convert.ToInt32(_httpContextAccessor.HttpContext.User.FindFirst(ClaimTypes.NameIdentifier)?.Value);

            var unfilteredDebts = _context.Debts
                                  .Where(debt => debt.GiverId == userId || debt.TakerId == userId);

            switch (debtFilterDto.RoleInDebt)
            {
            case Constants.Debts.UserRole.GIVER:
                unfilteredDebts = unfilteredDebts
                                  .Where(debt => debt.GiverId == userId);
                break;

            case Constants.Debts.UserRole.TAKER:
                unfilteredDebts = unfilteredDebts
                                  .Where(debt => debt.TakerId == userId);
                break;

            default:
                unfilteredDebts = unfilteredDebts
                                  .Where(debt => debt.GiverId == userId || debt.TakerId == userId);
                break;
            }

            var userDebts = unfilteredDebts
                            .Include(debt => debt.Giver)
                            .Include(debt => debt.Taker)
                            .Select(debt => _debtDtoMapper.MapToDebtDetailResponseDto(debt));

            return(userDebts);
        }
Example #2
0
        public void Should_Get_All()
        {
            IQueryable <Debt> debts = new List <Debt>
            {
                new Debt {
                    Id = 1, Sum = 15, TakerId = currentUser.Id
                },
                new Debt {
                    Id = 2, Sum = 20, GiverId = currentUser.Id
                }
            }.AsQueryable();

            var mockSet = new Mock <DbSet <Debt> >();

            mockSet.As <IQueryable <Debt> >().Setup(m => m.Provider).Returns(debts.Provider);
            mockSet.As <IQueryable <Debt> >().Setup(m => m.Expression).Returns(debts.Expression);
            mockSet.As <IQueryable <Debt> >().Setup(m => m.ElementType).Returns(debts.ElementType);
            mockSet.As <IQueryable <Debt> >().Setup(m => m.GetEnumerator()).Returns(debts.GetEnumerator());

            var mockContext = new Mock <DatabaseContext>();

            mockContext.Setup(c => c.Debts).Returns(mockSet.Object);

            var service  = new DebtsService(mockContext.Object, iMapper, mockAccessor.Object, new DebtDtoMapper(iMapper));
            var noFilter = new DebtFilterDto {
                RoleInDebt = null
            };

            var actual = service.GetAll(noFilter);

            Assert.Equal(2, actual.Count());
            mockContext.Verify(m => m.Debts);
            Assert.Equal(debts.First(d => d.Id == 1).Sum, actual.First(d => d.Id == 1).Sum);
            Assert.Equal(debts.First(d => d.Id == 2).Sum, actual.First(d => d.Id == 2).Sum);
        }
Example #3
0
 public IActionResult GetAll([FromQuery] DebtFilterDto debtFilterDto)
 {
     return(Ok(_debtsService.GetAll(debtFilterDto)));
 }