public async Task <TotalEarningForCustomerInMonth> CalculateAndSaveCustomerEarningsForMonthAsync(int customerId, Month month)
{
var customer = await _customerReadRepository.GetAsync(customerId);
var result = await _customerOperation.CalculateCustomerEarningsForMonthAsync(customer, month);
await _totalEarningWriteRepository.AddAsync(result);
return(result);
}
public async virtual Task <IEnumerable <T> > GetAsync()
{
var result = await _ReadRepo.GetAsync();
if (result != null)
{
return(result);
}
return(result);
}
public async Task <IActionResult> Get(string id)
{
var company = await _readRepository.GetAsync(id);
if (company == null)
{
return(NotFound());
}
return(Ok(company));
}
public async Task <IActionResult> Get(string id)
{
var product = await _readRepository.GetAsync(id);
if (product == null)
{
return(NotFound());
}
return(Ok(product));
}
public async Task <IActionResult> Get(string id)
{
var seller = await _readRepository.GetAsync(id);
if (seller == null)
{
return(NotFound());
}
return(Ok(UserFactory.CreateUserDTOFromUser(seller)));
}
public void Can_save_entity_by_id_twice()
{
var expected = config.ReadModel.GetTestEntityA();
readRepository.InsertAsync(expected).Wait();
var loaded = (ITestEntityA)readRepository.GetAsync(expected.GetType(), expected.Id).Result;
loaded.Value.Should().Be(expected.Value);
loaded.Value = "test2";
readRepository.UpdateAsync(loaded).Wait();
loaded = (ITestEntityA)readRepository.GetAsync(expected.GetType(), expected.Id).Result;
loaded.Value.Should().Be("test2");
}
public async Task <IActionResult> SetPassword(
[FromForm] string code,
[FromForm] string userId,
[FromForm] string password,
[FromForm] string confirmPassword)
{
if (password.Length < 8 || password != confirmPassword)
{
return(BadRequest());
}
var validation = (await _readEmailValidationRepository.FindAsync(x => x.ValidationCode == code && x.UserId == userId)).SingleOrDefault();
if (validation == null)
{
return(BadRequest());
}
var user = await _readUserRepository.GetAsync(userId);
user.CreatePasswordHashAndSalt(password);
user.IsActive = true;
try
{
await _writeUserRepository.UpdateAsync(user);
}
catch
{
return(BadRequest());
}
await _writeEmailValidationRepository.DeleteManyAsync(x => x.UserId == user.Id);
return(Ok());
}
public static Task <IEnumerable <TEntity> > GetAllAsync <TEntity>(
this IReadRepository <TEntity> repository)
where TEntity : class, IEntity
{
Contract.Requires(repository != null);
Contract.Ensures(Contract.Result <Task <IEnumerable <TEntity> > >() != null);
return(repository.GetAsync(query => query, CancellationToken.None));
}
public async Task <TotalEarningForCustomerInMonth> CalculateAndSaveCustomerEarningsForMonthAsync(int customerId, Month month)
{
var customer = await _customerReadRepository.GetAsync(customerId);
var earnings = customer.Earnings.Where(x => x.MonthInYear == month).Sum(s => s.Value);
var result = new TotalEarningForCustomerInMonth
{
CustomerId = customer.Id,
Month = month,
Name = customer.Name,
TotalEarning = earnings
};
await _totalEarningWriteRepository.AddAsync(result);
return(result);
}
public async Task UpdateByIdAsync <TReadModel, TKey>(TKey id, Action <TReadModel> action)
where TReadModel : class, IReadModel <TKey>, new()
{
var readModel = await readRepository.GetAsync <TReadModel>(id).ConfigureAwait(false);
action(readModel);
await readRepository.UpdateAsync(readModel).ConfigureAwait(false);
}
public static Task <IEnumerable <TEntity> > FindByAsync <TEntity>(
this IReadRepository <TEntity> repository,
Expression <Func <TEntity, bool> > predicate)
where TEntity : class, IEntity
{
Contract.Requires(repository != null);
Contract.Requires(predicate != null);
Contract.Ensures(Contract.Result <Task <IEnumerable <TEntity> > >() != null);
return(repository.GetAsync(query => query.Where(predicate), CancellationToken.None));
}
public static Task <TResult> GetAsync <TEntity, TResult>(
this IReadRepository <TEntity> repository,
Func <IQueryable <TEntity>, TResult> queryShaper)
where TEntity : class, IEntity
{
Contract.Requires(repository != null);
Contract.Requires(queryShaper != null);
Contract.Ensures(Contract.Result <Task <TResult> >() != null);
return(repository.GetAsync(queryShaper, CancellationToken.None));
}
public async Task <IActionResult> GetPageAsync(string searchText, int skip, int take)
{
if (skip < 0 || take < 1)
{
var badMessage = string.Empty;
if (skip < 0)
{
badMessage += BadSkipMessage;
}
if (take < 1)
{
badMessage += BadTakeMessage;
}
return(BadRequest(badMessage));
}
var page = await Repository.GetAsync(searchText, skip, take).ConfigureAwait(false);
var links = PageLinksBuilder.Build(page, Request);
Response.Headers.Add(LinkHeaderValue, links);
return(Ok(page.Items));
}
public static async Task <TEntity> GetSingleAsync <TEntity>(
this IReadRepository <TEntity> repository,
Expression <Func <TEntity, bool> > predicate,
CancellationToken cancellationToken)
where TEntity : class, IEntity
{
Contract.Requires(repository != null);
Contract.Requires(predicate != null);
Contract.Ensures(Contract.Result <Task <TEntity> >() != null);
var items = await repository.GetAsync(query => query.Where(predicate), cancellationToken);
return(items.SingleOrDefault());
}
public async Task <IActionResult> Token([FromForm] string grant_type, [FromForm] string email, [FromForm] string password, [FromForm] string refresh_token)
{
object userResponse = null;
if (grant_type == "refresh_token")
{
var userId = GetUserIdFromRefreshToken(refresh_token);
if (userId == null)
{
return(BadRequest());
}
var user = await _readRepository.GetAsync(userId);
userResponse = new { IdToken = GetIdToken(user), RefreshToken = GetRefreshToken(user) };
}
if (grant_type == "token")
{
var user = (await _readRepository.FindAsync(x => x.Email == email)).SingleOrDefault();
if (user == null)
{
return(BadRequest());
}
var passwordHash = GetPasswordHash(password, user.PasswordSalt);
for (int i = 0; i < passwordHash.Length; i++)
{
if (passwordHash[i] != user.PasswordHash[i])
{
return(BadRequest());
}
}
userResponse = new { IdToken = GetIdToken(user), RefreshToken = GetRefreshToken(user) };
}
return(Ok(userResponse));
}
public async Task <IEnumerable <Product> > GetAll()
{
return(await repository.GetAsync());
}
