Example #1
0
        public async Task <Member> FindBySsn(string ssn)
        {
            if (ssn == null)
            {
                throw new ArgumentNullException($"Ssn cannot be null.");
            }

            if (MemberUtils.ValidateSsn(ssn) == false)
            {
                throw new ArgumentException("Ssn is invalid.");
            }

            var memberMap = await _access.FindBySsn(ssn);

            if (memberMap == null)
            {
                throw new NullReferenceException("Member map cannot be null.");
            }

            var member = _mapper.Unmap(memberMap);

            if (member == null)
            {
                throw new NullReferenceException("Member cannot be null.");
            }

            return(member);
        }
Example #2
0
        public void ValidateEmptySsnShouldReturnFalse()
        {
            var ssn    = string.Empty;
            var result = MemberUtils.ValidateSsn(ssn);

            Assert.IsFalse(result);
        }
Example #3
0
        public void ValidateNullSsnShouldReturnFalse()
        {
            string ssn    = null;
            var    result = MemberUtils.ValidateSsn(ssn);

            Assert.IsFalse(result);
        }
Example #4
0
        public void ValidateInvalidSsnShouldReturnFalse()
        {
            var ssn    = GenerateInvalidSsn();
            var result = MemberUtils.ValidateSsn(ssn);

            Assert.IsFalse(result);
        }
        // TODO handle cases when it fails to insert data into db
        public async Task <RentAttemptModel> RentBooks(string ssn, IEnumerable <string> isbns)
        {
            if (!MemberUtils.ValidateSsn(ssn))
            {
                throw new ArgumentException("Invalid isbn");
            }

            if (isbns == null || !isbns.Any())
            {
                throw new ArgumentException("Isbn list cannot be empty when renting books");
            }

            var member = await _memberRepository.FindBySsn(ssn);

            var role = await _memberRepository.GetRoleName(member);

            if (!Roles.CanRent(role))
            {
                return(RentAttemptModel.WhenUserIsInWrongRole());
            }

            var order = new Order()
            {
                MemberId = ssn,
                Created  = DateTime.UtcNow
            };

            var orderId = await _orderRepository.InsertAsyncWithIdReturn(order);

            foreach (var isbn in isbns)
            {
                var book = await _bookRepository.GetByIsbnAsync(isbn);

                if (!book.Loanable)
                {
                    return(RentAttemptModel.WhenOneOfTheBooksIsNotLoanable());
                }

                var availableCopies = (await _bookCopyRepository.GetByIsbnAsync(isbn))
                                      .Where(x => x.Available).ToList();
                if (availableCopies.Count == 0)
                {
                    return(RentAttemptModel.WhenOneOfTheBooksDoesntHaveCopiesAvailable());
                }

                var chosenCopy = availableCopies[0];
                chosenCopy.Available = false;

                var orderLine = BookRentUtils.CreateOrderLineModel(orderId, chosenCopy.Id);
                await _orderLineRepository.InsertAsync(orderLine);

                await _bookCopyRepository.UpdateAsync(chosenCopy);
            }
            return(RentAttemptModel.WhenSuccesful());
        }