public PagedList <Account> GetAccontsByOwner(Guid ownerId, AccountParameters parameters)
{
var accounts = FindByCondition(a => a.OwnerId.Equals(ownerId));
var sortedAccounts = _accountHelper.ApplySort(accounts, parameters.OrderBy);
return(PagedList <Account> .ToPagedList(sortedAccounts, parameters.PageNumber, parameters.PageSize));
}
public async Task <IActionResult> GetAccountsDetails([FromQuery] AccountParameters loginParameters)
{
var getAccountDetailsQuery = new GetAccountDetailsQuery(loginParameters);
var result = await mediator.Send(getAccountDetailsQuery);
return(StatusCode((int)result.Code, result.Value));
}
public ActionResult <IEnumerable <Account> > getAccounts([FromQuery] AccountParameters parameters)
{
try
{
var accounts = _repository.Account.getAccounts(parameters);
var metadata = new
{
accounts.TotalCount,
accounts.PageSize,
accounts.CurrentPage,
accounts.TotalPages,
accounts.HasNext,
accounts.HasPrevious
};
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(metadata));
_logger.LogInfo($"Returned {accounts.TotalCount} owners from database.");
return(Ok(accounts));
}
catch (Exception ex)
{
_logger.LogError($"Something went wrong inside getAccounts action: {ex.Message}");
return(StatusCode(500, "Internal server error"));
}
}
/// <summary>
/// Handler to update login password.
/// </summary>
/// <param name="updateCommand"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task <APIResponse> Handle(UpdateAccountPortionCommand updateCommand,
CancellationToken cancellationToken)
{
try
{
AccountParameters loginParameters = new AccountParameters
{
Password = updateCommand.Request.OldPassword,
UserName = updateCommand.Request.UserName
};
var profile = await repository.AccountRepository.GetAccountDetails(loginParameters);
if (profile == null)
{
return(new APIResponse(HttpStatusCode.NotFound));
}
profile.Password = updateCommand.Request.NewPassword;
profile.UpdatedBy = updateCommand.Request.UpdatedBy;
var profileRequest = mapper.Map(updateCommand.Request, profile);
repository.ProfileRepository.UpdateUserProfile(profileRequest);
await repository.SaveAsync();
return(new APIResponse(HttpStatusCode.NoContent));
}
catch (Exception ex)
{
logger.Error(ex, "Exception in method 'UpdateAccountsPortionHandler()'");
var exMessage = ex.InnerException != null ? ex.InnerException.Message : ex.Message;
return(new APIResponse(exMessage, HttpStatusCode.InternalServerError));
}
}
public ActionResult Query(AccountParameters parameters)
{
using (TestEntities db = new TestEntities())
{
AccountGridListViewModel viewModel = new AccountGridListViewModel
{
Parameters = parameters
};
var query = db.Users.AsQueryable();
if (!string.IsNullOrEmpty(parameters.NotesID))
{
query = query.Where(x => x.Account.Contains(parameters.NotesID));
}
if (!string.IsNullOrEmpty(parameters.DisplayName))
{
query = query.Where(x => x.Name.Contains(parameters.DisplayName));
}
var result = query.Select(x => new UserViewModel()
{
Account = x.Account,
CreatorAccount = x.CreatorAccount,
DateCreated = x.DateCreated,
Email = x.Email,
Name = x.Name
});
viewModel.GridList = result.OrderBy(x => x.Account).ToPagedList(parameters.PageNo, parameters.PageSize);
return(PartialView("_GridList", viewModel));
}
}
public async Task <PagedList <Account> > GetAccountsByOwner(string ownerId, AccountParameters parameters)
{
var condition = FindByCondition(a => a.OwnerId.Equals(ownerId));
return(await PagedList <Account> .ToPagedListAsync(condition,
parameters.PageNumber,
parameters.PageSize));
}
/// <summary>
/// Gets login details by given parameters.
/// </summary>
/// <param name="loginParameters">The login parameters.</param>
/// <returns></returns>
public async Task <Core.Entity.Profile> GetAccountDetails(AccountParameters loginParameters)
{
return(await FindByCondition(profile => profile.UserName.Equals(loginParameters.UserName) &&
profile.Password.Equals(loginParameters.Password))
.Include(ac => ac.Profilepermission)
.Include(cd => cd.Companydistricts)
.FirstOrDefaultAsync());
}
public PagedList <Account> GetAccountsByOwner(Guid ownerId, AccountParameters parameters)
{
var accounts = FindByCondition(a => a.OwnerId.Equals(ownerId));
return(PagedList <Account> .ToPagedList(accounts,
parameters.PageNumber,
parameters.PageSize));
}
public async Task <PagedList <Account> > GetAccountsAsync(AccountParameters accountParameters, bool trackChanges)
{
var accounts = await FindAll(trackChanges)
.Search(accountParameters.SearchTerm)
.Sort(accountParameters.OrderBy)
.ToListAsync();
return(PagedList <Account> .ToPagedList(accounts, accountParameters.PageNumber, accountParameters.PageSize));
}
public AccountParameters GetParameter(int AccountId, int ParamId, string Quarter, int Year)
{
AccountParameters parameter = null;
using (KraContext Context = new KraContext())
{
parameter = (from bs in Context.AccountParameter where bs.AccountID == AccountId && bs.ParamID == ParamId && bs.Quarter == Quarter && bs.Year == Year select bs).FirstOrDefault();
}
return(parameter);
}
public AccountParameters GetParameter(int AccountParamId)
{
AccountParameters parameter = null;
using (KraContext Context = new KraContext())
{
parameter = Context.AccountParameter.Find(AccountParamId);
}
return(parameter);
}
public bool UpdateParameterWeightage(int AccountParamId, int Weightage)
{
using (KraContext Context = new KraContext())
{
AccountParameters Parameter = Context.AccountParameter.Find(AccountParamId);
Parameter.Weightage = Weightage;
Context.SaveChanges();
}
return(true);
}
public PagedList <ShapedEntity> GetAccountsByOwner(Guid ownerId, AccountParameters parameters)
{
var accounts = FindByCondition(a => a.OwnerId.Equals(ownerId));
var sortedAccounts = _sortHelper.ApplySort(accounts, parameters.OrderBy);
var shapedAccounts = _dataShaper.ShapeData(sortedAccounts, parameters.Fields);
return(PagedList <ShapedEntity> .ToPagedList(shapedAccounts,
parameters.PageNumber,
parameters.PageSize));
}
public async Task <IActionResult> GetAccounts([FromQuery] AccountParameters accountParameters)
{
PagedList <Account> accounts = await _repository.Account.GetAccountsAsync(accountParameters, trackChanges : false);
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(accounts.MetaData));
var accountsDTO = _mapper.Map <IEnumerable <AccountDTO> >(accounts);
var links = _accountLinks.TryGenerateLinks(accountsDTO,
accountParameters.Fields, HttpContext);
return(links.HasLinks ? Ok(links.LinkedEntites) : Ok(links.ShapedEntities));
}
private void Details_Click(object sender, RoutedEventArgs e)
{
FrameworkElement fe = sender as FrameworkElement;
if (fe != null)
{
Account a = fe.DataContext as Account;
if (a != null)
{
var parameters = new AccountParameters(a.id);
this.Frame.Navigate(typeof(AccountDetailsPage), parameters);
}
}
}
public IActionResult GetAccountsForOwner(Guid ownerId, [FromQuery] AccountParameters parameters)
{
var accounts = _repository.Account.GetAccontsByOwner(ownerId, parameters);
var metadata = new
{
accounts.TotalCount,
accounts.PageSize,
accounts.CurrentPage,
accounts.TotalPages,
accounts.HasNext,
accounts.HasPrevious
};
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(metadata));
_logger.LogInfo($"Returned {accounts.TotalCount} owners from database.");
return(Ok(accounts));
}
public bool AddAccountParameter(AccountParameters Param)
{
using (KraContext Context = new KraContext())
{
AccountParameters Parameter = (from parameter in Context.AccountParameter where parameter.AccountParamID == Param.AccountParamID select parameter).SingleOrDefault();
if (Parameter != null)
{
Parameter.ParamID = Param.ParamID;
Parameter.Quarter = Param.Quarter;
Context.SaveChanges();
}
else
{
Context.AccountParameter.Add(Param);
Context.SaveChanges();
}
}
return(true);
}
public IActionResult GetAccountsForOwner(Guid ownerId, [FromQuery] AccountParameters parameters)
{
var accounts = _repository.Account.GetAccountsByOwner(ownerId, parameters);
var metadata = new
{
accounts.TotalCount,
accounts.PageSize,
accounts.CurrentPage,
accounts.TotalPages,
accounts.HasNext,
accounts.HasPrevious
};
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(metadata));
_logger.LogInfo($"Returned {accounts.TotalCount} accounts from database.");
var shapedAccounts = accounts.Select(o => o.Entity).ToList();
var mediaType = HttpContext.Request.Headers["AcceptHeaderMediaType"];
if (!mediaType.Contains("hateoas"))
{
return(Ok(shapedAccounts));
}
for (var index = 0; index < accounts.Count(); index++)
{
var accountLinks = CreateLinksForAccount(ownerId, accounts[index].Id, parameters.Fields);
shapedAccounts[index].Add("Links", accountLinks);
}
var accountsWrapper = new LinkCollectionWrapper <Entity>(shapedAccounts);
return(Ok(CreateLinksForAccounts(accountsWrapper)));
}
public PagedList <Account> AccountsByOwner(Guid ownerId, AccountParameters accountParameters)
{
return(PagedList <Account> .ToPagedList(FindByCondition(ac => ac.OwnerId.Equals(ownerId)).ToList().OrderBy(ac => ac.Owner),
accountParameters.PageNumber,
accountParameters.PageSize));
}
/// <summary>
/// Initializes a new instance of the <see cref="GetAccountDetailsQuery"/> class.
/// </summary>
/// <param name="profileParameters">The Profile parameters.</param>
public GetAccountDetailsQuery(AccountParameters loginParameters)
{
AccountParameters = loginParameters;
}
public PagedList <Account> GetAccountsByOwner(Guid ownerId, AccountParameters accountParameters)
{
return(PagedList <Account> .ToPagedList(FindByCondition(a => a.OwnerId.Equals(ownerId)).OrderBy(x => x.DateCreated), accountParameters.PageNumber, accountParameters.PageSize));
}
public PagedList <Account> GetAllOwners(Guid ownerId, AccountParameters ownerParameters)
{
return(PagedList <Account> .ToPagedList(FindAll().Where(ow => ow.OwnerId == ownerId),
ownerParameters.PageNumber,
ownerParameters.PageSize));
}
public PagedList <Account> getAccounts(AccountParameters accountParameters)
{
return(PagedList <Account> .ToPagedList(FindAll().OrderBy(ac => ac.Owner),
accountParameters.PageNumber,
accountParameters.PageSize));
}
