Beispiel #1
0
        public async Task <string> AddAccount(DataAccountsRequest account)
        {
            if (!await GetIsEmployee())
            {
                throw new Exception("User does not have access to this resource");
            }

            var duplicateAccount = await GetAccountByEmail(account.Email);

            if (duplicateAccount.Count > 0)
            {
                throw new DuplicateNameException($"Account alread exists with email: {account.Email}");
            }

            var accountDto = new AccountsDto()
            {
                CompanyName  = account.CompanyName,
                Email        = account.Email,
                Id           = Guid.NewGuid().ToString(),
                PasswordHash = IntegraTestEncryption.ComputePasswordHash(account.Password)
            };

            await DynamoDbContextProvider.CurrentContext.SaveAsync <AccountsDto>(accountDto);

            return(accountDto.Id);
        }
Beispiel #2
0
        public async Task <AccountsDto> Get(Param parameters)
        {
            PagedList <AccountDto> accountDtos = new PagedList <AccountDto>();

            var queryable = _unitOfWork.Account.GetAll()
                            .Include(x => x.Client)
                            .Include(x => x.Relationship)
                            .Include(x => x.AccountType)
                            .Where(x => x.IsVisible && x.IsActive);

            switch (parameters.SearchBy.ToLower())
            {
            case "firstname":
                queryable = queryable.Where(x => x.FirstName.Contains(parameters.SearchText));
                break;

            case "lastname":
                queryable = queryable.Where(x => x.LastName.Contains(parameters.SearchText));
                break;

            case "note":
                queryable = queryable.Where(x => x.Note.Contains(parameters.SearchText));
                break;

            case "phone":
                queryable = queryable.Where(x => x.Phone.Contains(parameters.SearchText));
                break;

            case "clientname":
                queryable = queryable.Where(x => x.Client.Name.Contains(parameters.SearchText));
                break;
            }

            switch (parameters.SortBy.ToLower())
            {
            case "clientname":
                switch (parameters.SortDirection.ToLower())
                {
                case "desc":
                    queryable = queryable.OrderByDescending(x => x.Client.Name);
                    break;

                case "asc":
                    queryable = queryable.OrderBy(x => x.Client.Name);
                    break;

                default:
                    queryable = queryable.OrderByDescending(x => x.CreatedDate);
                    break;
                }
                break;

            case "name":
                switch (parameters.SortDirection.ToLower())
                {
                case "desc":
                    queryable = queryable.OrderByDescending(x => x.FirstName);
                    break;

                case "asc":
                    queryable = queryable.OrderBy(x => x.FirstName);
                    break;

                default:
                    queryable = queryable.OrderByDescending(x => x.CreatedDate);
                    break;
                }
                break;

            case "address":
                switch (parameters.SortDirection.ToLower())
                {
                case "desc":
                    queryable = queryable.OrderByDescending(x => x.Address1);
                    break;

                case "asc":
                    queryable = queryable.OrderBy(x => x.Address1);
                    break;

                default:
                    queryable = queryable.OrderByDescending(x => x.CreatedDate);
                    break;
                }
                break;

            case "balance":
                switch (parameters.SortDirection.ToLower())
                {
                case "desc":
                    queryable = queryable.OrderByDescending(x => x.Balance);
                    break;

                case "asc":
                    queryable = queryable.OrderBy(x => x.Balance);
                    break;

                default:
                    queryable = queryable.OrderByDescending(x => x.CreatedDate);
                    break;
                }
                break;

            case "note":
                switch (parameters.SortDirection.ToLower())
                {
                case "desc":
                    queryable = queryable.OrderByDescending(x => x.Note);
                    break;

                case "asc":
                    queryable = queryable.OrderBy(x => x.Note);
                    break;

                default:
                    queryable = queryable.OrderByDescending(x => x.CreatedDate);
                    break;
                }
                break;

            case "accounttype":
                switch (parameters.SortDirection.ToLower())
                {
                case "desc":
                    queryable = queryable.OrderByDescending(x => x.AccountType.Description);
                    break;

                case "asc":
                    queryable = queryable.OrderBy(x => x.AccountType.Description);
                    break;

                default:
                    queryable = queryable.OrderByDescending(x => x.CreatedDate);
                    break;
                }
                break;

            case "relationship":
                switch (parameters.SortDirection.ToLower())
                {
                case "desc":
                    queryable = queryable.OrderByDescending(x => x.Relationship.Description);
                    break;

                case "asc":
                    queryable = queryable.OrderBy(x => x.Relationship.Description);
                    break;

                default:
                    queryable = queryable.OrderByDescending(x => x.CreatedDate);
                    break;
                }
                break;
            }


            var pagedAccounts = await PagedList <Account> .CreateAsync(queryable, parameters.PageNumber, parameters.PageSize);

            if (pagedAccounts != null)
            {
                foreach (var account in pagedAccounts)
                {
                    var dto = _mapper.Map <AccountDto>(account);

                    dto.ClientName              = account.Client.Name;
                    dto.AccountTypeDescription  = account.AccountType.Description;
                    dto.RelationshipDescription = account.Relationship.Description;

                    accountDtos.Add(dto);
                }
            }

            AccountsDto accounts = new AccountsDto();

            accounts.Accounts    = accountDtos;
            accounts.CurrentPage = pagedAccounts.CurrentPage;
            accounts.PageSize    = pagedAccounts.PageSize;
            accounts.TotalCount  = pagedAccounts.TotalCount;
            accounts.TotalPages  = pagedAccounts.TotalPages;
            return(accounts);
        }