public async Task <ApiResponse> Handle(CreateProjectCommand request, CancellationToken cancellationToken)
{
var project = new ProjectDuration()
{
Id = new Guid(),
Name = request.Request.ProjectName,
Duration = "0"
};
#region Update postgresql database
try
{
await ProjectRepository.AddAsync(project);
await ProjectRepository.SaveChangesAsync();
}
catch (Exception ex)
{
throw ex;
}
#endregion
return(new ApiResponse(200, false, new List <string>()));
}
public async Task <IActionResult> Save(
[Bind("ProjectTitle, ProjectDescription, Active, Open, Deadline")]
ProjectCreateViewModel viewModel)
{
if (ModelState.IsValid)
{
Project project = new Project
{
ProjectTitle = viewModel.ProjectTitle,
ProjectDescription = viewModel.ProjectDescription,
Active = viewModel.Active,
Open = viewModel.Open,
Deadline = viewModel.Deadline,
DateCreated = DateTime.Now
};
await _repository.AddAsync(project, User);
//TempData["success"] = string.Format("Prosjektet: - {0} - har blitt opprettet", project.ProjectTitle);
return(RedirectToAction("Index", "Project")); // Bytt denne ut til å hente egne prosjekter
}
// If we get here, something went wrong
return(View(viewModel));
}
public async Task CreateAsync(Guid id, Guid userId, string name)
{
var project = new Project(id, userId, name);
await _projectRepository.AddAsync(project);
}
public async Task<IResultModel> Add(ProjectAddModel model)
{
var entity = _mapper.Map<ProjectEntity>(model);
var result = await _repository.AddAsync(entity);
return ResultModel.Result(result);
}
public async Task CanIncrementUsageAsync()
{
var messageBus = GetService <IMessageBus>();
var countdown = new AsyncCountdownEvent(2);
await messageBus.SubscribeAsync <PlanOverage>(po => {
_logger.LogInformation("Plan Overage for {organization} (Hourly: {IsHourly})", po.OrganizationId, po.IsHourly);
countdown.Signal();
});
var organization = await _organizationRepository.AddAsync(new Organization { Name = "Test", MaxEventsPerMonth = 750, PlanId = _plans.SmallPlan.Id }, o => o.ImmediateConsistency());
var project = await _projectRepository.AddAsync(new Project { Name = "Test", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = SystemClock.UtcNow.Ticks }, o => o.ImmediateConsistency());
Assert.InRange(organization.GetHourlyEventLimit(_plans), 1, 750);
int totalToIncrement = organization.GetHourlyEventLimit(_plans) - 1;
Assert.False(await _usageService.IncrementUsageAsync(organization, project, totalToIncrement));
organization = await _organizationRepository.GetByIdAsync(organization.Id);
await countdown.WaitAsync(TimeSpan.FromMilliseconds(150));
Assert.Equal(2, countdown.CurrentCount);
var organizationUsage = await _usageService.GetUsageAsync(organization);
var projectUsage = await _usageService.GetUsageAsync(organization, project);
Assert.Equal(totalToIncrement, organizationUsage.HourlyTotal);
Assert.Equal(totalToIncrement, projectUsage.HourlyTotal);
Assert.Equal(totalToIncrement, organizationUsage.MonthlyTotal);
Assert.Equal(totalToIncrement, projectUsage.MonthlyTotal);
Assert.Equal(0, organizationUsage.HourlyBlocked);
Assert.Equal(0, projectUsage.HourlyBlocked);
Assert.Equal(0, organizationUsage.MonthlyBlocked);
Assert.Equal(0, projectUsage.MonthlyBlocked);
Assert.True(await _usageService.IncrementUsageAsync(organization, project, 2));
await countdown.WaitAsync(TimeSpan.FromMilliseconds(150));
Assert.Equal(1, countdown.CurrentCount);
organizationUsage = await _usageService.GetUsageAsync(organization);
projectUsage = await _usageService.GetUsageAsync(organization, project);
Assert.Equal(totalToIncrement + 2, organizationUsage.HourlyTotal);
Assert.Equal(totalToIncrement + 2, projectUsage.HourlyTotal);
Assert.Equal(totalToIncrement + 2, organizationUsage.MonthlyTotal);
Assert.Equal(totalToIncrement + 2, projectUsage.MonthlyTotal);
Assert.Equal(1, organizationUsage.HourlyBlocked);
Assert.Equal(1, projectUsage.HourlyBlocked);
Assert.Equal(1, organizationUsage.MonthlyBlocked);
Assert.Equal(1, projectUsage.MonthlyBlocked);
organization = await _organizationRepository.AddAsync(new Organization { Name = "Test", MaxEventsPerMonth = 750, PlanId = _plans.SmallPlan.Id }, o => o.ImmediateConsistency());
project = await _projectRepository.AddAsync(new Project { Name = "Test", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = SystemClock.UtcNow.Ticks }, o => o.ImmediateConsistency());
await _cache.RemoveAllAsync();
totalToIncrement = organization.GetHourlyEventLimit(_plans) + 20;
Assert.True(await _usageService.IncrementUsageAsync(organization, project, totalToIncrement));
await countdown.WaitAsync(TimeSpan.FromMilliseconds(150));
Assert.Equal(0, countdown.CurrentCount);
organizationUsage = await _usageService.GetUsageAsync(organization);
projectUsage = await _usageService.GetUsageAsync(organization, project);
Assert.Equal(totalToIncrement, organizationUsage.HourlyTotal);
Assert.Equal(totalToIncrement, projectUsage.HourlyTotal);
Assert.Equal(totalToIncrement, organizationUsage.MonthlyTotal);
Assert.Equal(totalToIncrement, projectUsage.MonthlyTotal);
Assert.Equal(20, organizationUsage.HourlyBlocked);
Assert.Equal(20, projectUsage.HourlyBlocked);
Assert.Equal(20, organizationUsage.MonthlyBlocked);
Assert.Equal(20, projectUsage.MonthlyBlocked);
}
public async Task CanIncrementUsageAsync()
{
var messageBus = GetService <IMessageBus>();
var countdown = new AsyncCountdownEvent(2);
await messageBus.SubscribeAsync <PlanOverage>(po => {
_logger.Info($"Plan Overage for {po.OrganizationId} (Hourly: {po.IsHourly})");
countdown.Signal();
});
var o = await _organizationRepository.AddAsync(new Organization { Name = "Test", MaxEventsPerMonth = 750, PlanId = BillingManager.SmallPlan.Id });
var project = await _projectRepository.AddAsync(new Project { Name = "Test", OrganizationId = o.Id, NextSummaryEndOfDayTicks = SystemClock.UtcNow.Ticks }, opt => opt.Cache());
await _configuration.Client.RefreshAsync(Indices.All);
Assert.InRange(o.GetHourlyEventLimit(), 1, 750);
int totalToIncrement = o.GetHourlyEventLimit() - 1;
Assert.False(await _usageService.IncrementUsageAsync(o.Id, project.Id, false, totalToIncrement));
await _configuration.Client.RefreshAsync(Indices.All);
o = await _organizationRepository.GetByIdAsync(o.Id);
await countdown.WaitAsync(TimeSpan.FromMilliseconds(150));
Assert.Equal(2, countdown.CurrentCount);
Assert.Equal(totalToIncrement, await _cache.GetAsync <long>(GetHourlyTotalCacheKey(o.Id), 0));
Assert.Equal(totalToIncrement, await _cache.GetAsync <long>(GetHourlyTotalCacheKey(o.Id, project.Id), 0));
Assert.Equal(totalToIncrement, await _cache.GetAsync <long>(GetMonthlyTotalCacheKey(o.Id), 0));
Assert.Equal(totalToIncrement, await _cache.GetAsync <long>(GetMonthlyTotalCacheKey(o.Id, project.Id), 0));
Assert.Equal(0, await _cache.GetAsync <long>(GetHourlyBlockedCacheKey(o.Id), 0));
Assert.Equal(0, await _cache.GetAsync <long>(GetHourlyBlockedCacheKey(o.Id, project.Id), 0));
Assert.Equal(0, await _cache.GetAsync <long>(GetMonthlyBlockedCacheKey(o.Id), 0));
Assert.Equal(0, await _cache.GetAsync <long>(GetMonthlyBlockedCacheKey(o.Id, project.Id), 0));
Assert.True(await _usageService.IncrementUsageAsync(o.Id, project.Id, false, 2));
await _configuration.Client.RefreshAsync(Indices.All);
o = await _organizationRepository.GetByIdAsync(o.Id);
await countdown.WaitAsync(TimeSpan.FromMilliseconds(150));
Assert.Equal(1, countdown.CurrentCount);
Assert.Equal(totalToIncrement + 2, await _cache.GetAsync <long>(GetHourlyTotalCacheKey(o.Id), 0));
Assert.Equal(totalToIncrement + 2, await _cache.GetAsync <long>(GetHourlyTotalCacheKey(o.Id, project.Id), 0));
Assert.Equal(totalToIncrement + 2, await _cache.GetAsync <long>(GetMonthlyTotalCacheKey(o.Id), 0));
Assert.Equal(totalToIncrement + 2, await _cache.GetAsync <long>(GetMonthlyTotalCacheKey(o.Id, project.Id), 0));
Assert.Equal(1, await _cache.GetAsync <long>(GetHourlyBlockedCacheKey(o.Id), 0));
Assert.Equal(1, await _cache.GetAsync <long>(GetHourlyBlockedCacheKey(o.Id, project.Id), 0));
Assert.Equal(1, await _cache.GetAsync <long>(GetMonthlyBlockedCacheKey(o.Id), 0));
Assert.Equal(1, await _cache.GetAsync <long>(GetMonthlyBlockedCacheKey(o.Id, project.Id), 0));
o = await _organizationRepository.AddAsync(new Organization { Name = "Test", MaxEventsPerMonth = 750, PlanId = BillingManager.SmallPlan.Id });
project = await _projectRepository.AddAsync(new Project { Name = "Test", OrganizationId = o.Id, NextSummaryEndOfDayTicks = SystemClock.UtcNow.Ticks }, opt => opt.Cache());
await _configuration.Client.RefreshAsync(Indices.All);
await _cache.RemoveAllAsync();
totalToIncrement = o.GetHourlyEventLimit() + 20;
Assert.True(await _usageService.IncrementUsageAsync(o.Id, project.Id, false, totalToIncrement));
await countdown.WaitAsync(TimeSpan.FromMilliseconds(150));
Assert.Equal(0, countdown.CurrentCount);
Assert.Equal(totalToIncrement, await _cache.GetAsync <long>(GetHourlyTotalCacheKey(o.Id), 0));
Assert.Equal(totalToIncrement, await _cache.GetAsync <long>(GetHourlyTotalCacheKey(o.Id, project.Id), 0));
Assert.Equal(totalToIncrement, await _cache.GetAsync <long>(GetMonthlyTotalCacheKey(o.Id), 0));
Assert.Equal(totalToIncrement, await _cache.GetAsync <long>(GetMonthlyTotalCacheKey(o.Id, project.Id), 0));
Assert.Equal(20, await _cache.GetAsync <long>(GetHourlyBlockedCacheKey(o.Id), 0));
Assert.Equal(20, await _cache.GetAsync <long>(GetHourlyBlockedCacheKey(o.Id, project.Id), 0));
Assert.Equal(20, await _cache.GetAsync <long>(GetMonthlyBlockedCacheKey(o.Id), 0));
Assert.Equal(20, await _cache.GetAsync <long>(GetMonthlyBlockedCacheKey(o.Id, project.Id), 0));
}
public async Task Handle(CreateProjectCommand request, CancellationToken cancellationToken)
{
await _projectRepository.AddAsync(request.Project);
await _projectRepository.UnitOfWork.SaveEntitiesAsync(cancellationToken);
}