// GET: MovieLists
public IActionResult Index()
{
var applicationContext = _movieset.GetAll()
.Where(x => x.UserID == _currentuserid.GetCurrentUserId(_httpContextAccessor));
return(View(applicationContext.ToList()));
}
public async Task <ActionResult <UserDto> > Get()
{
long userId = _currentUserService.GetCurrentUserId();
var user = await _userService.Get(userId);
if (user == null)
{
return(NotFound());
}
return(_mapper.Map <UserDto>(user));
}
public void UpdateModifiedByModifiedDate(ModificationInfo entity)
{
var userId = _currentUserService.GetCurrentUserId();
entity.ModifiedBy = userId;
entity.ModificationDate = DateTime.Now;
}
public async Task <List <DashboardDto> > Handle(GetFavoriteDashboardsQuery request, CancellationToken cancellationToken)
{
var currentUserId = currentUserService.GetCurrentUserId();
var applicationDashboards = await(from app in context.Applications
join dashboard in context.Dashboards
on app.Id equals dashboard.ApplicationId
where app.UserId == currentUserId && dashboard.IsFavorite
select dashboard)
.AsNoTracking()
.ToListAsync();
var result = new List <DashboardDto>();
foreach (var item in applicationDashboards)
{
result.Add(new DashboardDto
{
ApplicationId = item.ApplicationId,
Id = item.Id,
CreatedDate = item.CreatedDate,
Name = item.Name,
IsFavorite = item.IsFavorite
});
}
return(mapper.Map <List <DashboardDto> >(applicationDashboards));
}
public async Task <Guid> Handle(CreateWidgetCommand request, CancellationToken cancellationToken)
{
var currentUserId = currentUserService.GetCurrentUserId();
var application = await context.Applications
.FirstOrDefaultAsync(app => app.Id == request.ApplicationId && app.UserId == currentUserId);
if (application == null)
{
throw new EntityNotFoundException(nameof(Application), request.ApplicationId);
}
var widgetHandlerFactory = new WidgetsHandlerFactory();
var widgetHandler = widgetHandlerFactory.Make(request.WidgetType);
var widget = new Widget(request.Name, application.Id)
{
Type = request.WidgetType.ToString(),
Data = widgetHandler.GetDefaultJson()
};
await context.Widgets.AddAsync(widget);
await context.SaveChangesAsync();
return(widget.Id);
}
public async Task <List <WidgetDetailsVm <T> > > Handle(GetWidgetsQuery <T> request, CancellationToken cancellationToken)
{
var currentUserId = currentUserService.GetCurrentUserId();
var dbWidgets = await(from application in context.Applications
join widget in context.Widgets
on application.Id equals widget.ApplicationId
where request.WidgetsIds.Contains(widget.Id) && application.UserId == currentUserId
select widget)
.AsNoTracking()
.ToListAsync();
var widgetHandlerFactory = new WidgetsHandlerFactory();
var result = new List <WidgetDetailsVm <T> >();
foreach (var dbWidget in dbWidgets)
{
var widgetHandler = widgetHandlerFactory.Make(dbWidget.Type);
var widgetData = new WidgetDetailsVm <T>
{
WidgetData = (T)widgetHandler.FromJson(dbWidget.Data),
Widget = mapper.Map <WidgetDto>(dbWidget)
};
result.Add(widgetData);
}
return(result);
}
public async Task <Unit> Handle(UpdateWidgetCommand <T> request, CancellationToken cancellationToken)
{
var currentUserId = currentUserService.GetCurrentUserId();
var dbWidget = await(from widget in context.Widgets
join application in context.Applications
on widget.ApplicationId equals application.Id
where widget.Id == request.Id && application.UserId == currentUserId
select widget).FirstOrDefaultAsync();
if (dbWidget == null)
{
throw new EntityNotFoundException(nameof(Widget), request.Id);
}
var widgetHandlerFactory = new WidgetsHandlerFactory();
var widgetHandler = widgetHandlerFactory.Make(dbWidget.Type);
dbWidget.Name = request.Name;
dbWidget.Data = widgetHandler.GetJson(request.WidgetData);
context.Widgets.Update(dbWidget);
await context.SaveChangesAsync();
return(Unit.Value);
}
public JsonResult ApplyForTournament(GroupTeamViewModel groupTeam)
{
JsonResult result = null;
try
{
var userId = _currentUserService.GetCurrentUserId();
if (userId == ANONYM)
{
result = Json(ViewModelResources.NoRights);
}
else
{
var tournamentRequest = new TournamentRequest {
TeamId = groupTeam.TeamId,
UserId = userId,
GroupId = groupTeam.GroupId
};
_requestService.Create(tournamentRequest);
result = Json(ViewModelResources.SuccessRequest);
}
}
catch (ArgumentException ex)
{
result = Json(ex.Message);
}
return(result);
}
public async Task <Guid> Handle(EditQuestionCommand request, CancellationToken cancellationToken)
{
var employerId = _currentUserService.GetCurrentUserId();
var question = await _store.Questions.Where(x => x.EmployerId == employerId).WithIdAsync(request.Id);
var questionOptions = await _store.Options.Where(x => x.QuestionId == question.Id).ToListAsync();
await _store.DeleteEntitiesAsync(questionOptions);
question.Text = request.Text;
question.QuestionTag = request.QuestionTag;
var options = _mapper.Map <List <Option> >(request.Options);
foreach (var option in options)
{
option.QuestionId = question.Id;
}
await _store.AddEntitiesAsync(options);
await _store.SaveChangesAsync();
return(request.Id);
}
public async Task <bool> Handle(FavoriteDashboardCommand request, CancellationToken cancellationToken)
{
var currentUserId = currentUserService.GetCurrentUserId();
var dbDashboard = await(from application in context.Applications
join dashboard in context.Dashboards
on application.Id equals dashboard.ApplicationId
where dashboard.Id == request.DashboardId && application.UserId == currentUserId
select dashboard)
.Include(x => x.DashboardWidgets)
.ThenInclude(dw => dw.Widget)
.FirstOrDefaultAsync();
if (dbDashboard == null)
{
throw new EntityNotFoundException(nameof(Dashboard), request.DashboardId);
}
dbDashboard.IsFavorite = request.IsFavorite;
context.Update(dbDashboard);
await context.SaveChangesAsync();
return(dbDashboard.IsFavorite);
}
public async Task <Guid> Handle(CreateApplicationCommand request, CancellationToken cancellationToken)
{
var currentUserId = currentUserService.GetCurrentUserId();
var application = await createApplicationService.CreateAsync(request.ApplicationName, currentUserId);
return(application.Id);
}
public async Task <short> Handle(AddTestResultCommand request, CancellationToken cancellationToken)
{
var selectedVacancy = _store.Vacancies.FirstOrDefault(v => v.Id == request.VacancyId);
Guid studentId = _currentUserService.GetCurrentUserId();
if (selectedVacancy == null)
{
throw new Exception("Vacancy doe not exist.");
}
var questionIds = request.Answers.Select(ans => ans.Id).ToList();
var questionOptionDict = await _store.Questions
.Include(q => q.Options)
.Where(q => questionIds.Contains(q.Id))
.Select(q => new KeyValuePair <Guid, List <Guid> >
(
q.Id,
q.Options.Where(op => op.IsCorrect).Select(op => op.Id).ToList()
))
.ToDictionaryAsync(x => x.Key, x => x.Value);
int correctOptionCount = questionOptionDict.Sum(q => q.Value.Count());
int correctUserAnswersCount = request
.Answers.Sum(ans => ans.ChoosedOptions.Intersect(questionOptionDict[ans.Id]).Count());
short score = (short)Math.Round(((double)correctUserAnswersCount / correctOptionCount) * 100.0, 0);
short priority = (short)(_store.StudentVacancies
.Where(x => x.StudentId == studentId && x.Vacancy.CampaignId == selectedVacancy.CampaignId)
.Count() + 1);
var newStudentVacancy = new StudentVacancy
{
StudentId = _currentUserService.GetCurrentUserId(),
VacancyId = request.VacancyId,
Score = score,
Priority = priority
};
await _store.AddEntityAsync(newStudentVacancy);
await _store.SaveChangesAsync();
return(score);
}
public async Task <IEnumerable <BillDto> > GetBillsAsync(int pageSize, int pageIndex)
{
Guid currentUserId = currentUserService.GetCurrentUserId();
var result = await this.sender.Send(new SearchBillsQuery(currentUserId, pageSize, pageIndex));
return(result.Value);
}
private ICollection <AuthOperation> GetAllUserOperations()
{
var userId = _userService.GetCurrentUserId();
return(_getOperationsQuery.Execute(new FindByUserIdCriteria {
UserId = userId
}));
}
public async Task <PagedResult <QuestionViewModel> > Handle(GetEmployerQuestionQuery request, CancellationToken cancellationToken)
{
var employerId = _currentUserService.GetCurrentUserId();
return(await _store.Questions
.Where(x => x.EmployerId == employerId)
.ApplyQueryAsync <Question, QuestionViewModel>(request, _mapper.ConfigurationProvider));
}
public override async Task <ActionResult <Project> > Post([FromBody] Project item)
{
if (!ModelState.IsValid)
{
return(BadRequest("Blad walidacji"));
}
var userId = _currentUserService.GetCurrentUserId();
ModificationService.UpdateModifiedByModifiedDate(item);
var project = await _projectService.CreateNewProject(userId, item);
return(Ok(project));
}
public async Task <PagedResult <CampaignViewModel> > Handle(GetAdminCampaignsQuery request, CancellationToken cancellationToken)
{
var adminId = _currentUserService.GetCurrentUserId();
return(await _store.Campaigns
.AsNoTracking()
.Where(x => x.AdminId == adminId)
.ApplyQueryAsync <Campaign, CampaignViewModel>(request, _mapper.ConfigurationProvider));
}
public async Task Process(TRequest request, CancellationToken cancellationToken)
{
_logger.LogInformation($"Received request: Type: {typeof(TRequest).Name} Request: {request}");
var requestName = typeof(TRequest).Name;
var userId = _currentUserService.GetCurrentUserId();
var userName = await _identityService.GetUserNameFromIdAsync(userId);
_logger.LogInformation($"Received request: Type: {typeof(TRequest).Name} Request: {request} UserId: {userId} UserName: {userName}");
}
public async Task <List <ApplicationDto> > Handle(ListApplicationsQuery request, CancellationToken cancellationToken)
{
var currentUserId = currentUserService.GetCurrentUserId();
var applications = await context.Applications
.Where(a => a.UserId == currentUserId)
.AsNoTracking()
.ToListAsync();
return(mapper.Map <List <ApplicationDto> >(applications));
}
public async Task Process(TRequest request, CancellationToken cancellationToken)
{
var requestName = typeof(TRequest).Name;
var currentUser = await _identityService.GetCurrentUser();
var currentUserId = _currentUserService.GetCurrentUserId();
_logger.LogInformation("CleanTesting Request: {Name} {@UserId} {@UserName} {@Request}",
requestName, currentUserId, currentUser.UserName, request);
}
//public DbSet<ModTitle> ModTitles { get; set; }
//public DbSet<Dependency> Dependencies { get; set; }
//public DbSet<DependencyType> DependencyTypes { get; set; }
//public DbSet<DependencyComparisonType> DependencyComparisonTypes { get; set; }
public override async Task <int> SaveChangesAsync(CancellationToken cancellationToken = new CancellationToken())
{
foreach (var entry in ChangeTracker.Entries <AuditableEntity>())
{
// TODO: I'm not a fan of the fact that our EF code is responsible for setting these, rather than a default value or a database trigger.
switch (entry.State)
{
case EntityState.Added:
entry.Entity.AddedBy = _currentUserService.GetCurrentUserId();
entry.Entity.AddedDate = _dateTimeService.GetCurrentTime();
break;
case EntityState.Modified:
entry.Entity.LastModifiedBy = _currentUserService.GetCurrentUserId();
entry.Entity.LastModified = _dateTimeService.GetCurrentTime();
break;
}
}
return(await base.SaveChangesAsync(cancellationToken));
}
public async Task <PagedResult <VacancyViewModel> > Handle(GetEmployerVacanciesQuery request, CancellationToken cancellationToken)
{
var employerId = _currentUserService.GetCurrentUserId();
var vacancies = await _store.Vacancies
.Include(x => x.Campaign)
.Include(x => x.Employer)
.Where(x => x.EmployerId == employerId)
.ApplyQueryAsync <Vacancy, VacancyViewModel>(request, _mapper.ConfigurationProvider);
return(vacancies);
}
public async Task <List <string> > Handle(GetQuestionTagsQuery request, CancellationToken cancellationToken)
{
var employerId = _currentUserService.GetCurrentUserId();
var employerTags = await _store.Questions
.Where(x => x.EmployerId == employerId)
.Select(x => x.QuestionTag)
.ToListAsync();
employerTags.AddRange(_defaultTags);
return(employerTags.Distinct().ToList());
}
public bool CheckUserId(int?id, IHttpContextAccessor httpContextAccessor)
{
if (id == null)
{
throw new ArgumentNullException("Null");
}
var userid = currentUserService.GetCurrentUserId(httpContextAccessor);
MovieSet movieSet = repoMovieSet.GetSingle(id);
return(userid.Equals(movieSet.UserID));
}
public async Task <Guid> Handle(CreateVacancyCommand request, CancellationToken cancellationToken)
{
var vacancy = _mapper.Map <Vacancy>(request);
var employerId = _currentUserService.GetCurrentUserId();
vacancy.DateCreated = DateTime.Now;
vacancy.EmployerId = employerId;
await _store.AddEntityAsync(vacancy, saveChanges : true);
return(vacancy.Id);
}
/// <summary>
/// Gets current user mail.
/// </summary>
/// <returns>User email.</returns>
private string GetUserMail()
{
var userId = _currentUserService.GetCurrentUserId();
var currentUser = new User {
Email = string.Empty
};
if (userId != ANONYM)
{
currentUser = _userService.GetUser(userId);
}
return(currentUser.Email);
}
/// <summary>
/// Change status of the feedback
/// </summary>
/// <param name="feedback">id for reply.</param>
/// <param name="newStatusCode">Information about mail (body, receiver)</param>
private void ChangeFeedbackStatus(Feedback feedback, FeedbackStatusEnum newStatusCode)
{
feedback.Status = newStatusCode;
if (ShouldChangeLastUpdateInfo(newStatusCode))
{
int userId = _currentUserService.GetCurrentUserId();
User user = _userService.GetUser(userId);
feedback.UpdateDate = TimeProvider.Current.UtcNow;
feedback.AdminName = user.PersonName;
}
_feedbackRepository.Update(feedback);
_feedbackRepository.UnitOfWork.Commit();
}
public async Task <Guid> Handle(CreateCampaignCommand request, CancellationToken cancellationToken)
{
var campaign = new Campaign()
{
Name = request.Name,
StartDate = request.StartDate,
EndDate = request.EndDate,
AdminId = _currentUserService.GetCurrentUserId()
};
var addedEntity = await _store.AddEntityAsync(campaign, saveChanges : true);
return(addedEntity.Id);
}
public async Task<Unit> Handle(UpdateDashboardCommand request, CancellationToken cancellationToken)
{
var currentUserId = currentUserService.GetCurrentUserId();
var dbDashboard = await GetDashboard(request.DashboardId, request.ApplicationId, currentUserId);
if (dbDashboard == null)
throw new EntityNotFoundException(nameof(Dashboard), request.DashboardId);
// Validate and remove the Widgets that don't belong to this dashboard
request.DashboardWidgets = await ValidateWidgets(request.DashboardWidgets, request.ApplicationId);
// Remove DashboardWidgets that are not present (removed)
dbDashboard.DashboardWidgets = dbDashboard.DashboardWidgets
.Where(oldWidget => request.DashboardWidgets.Exists(newWidget => newWidget.Id == oldWidget.Id)).ToList();
foreach (var dashboardWidget in request.DashboardWidgets)
{
if (dashboardWidget.Id == null || !dbDashboard.DashboardWidgets.Exists(x => x.Id == dashboardWidget.Id))
{
// Insert DashboardWidget
dbDashboard.DashboardWidgets.Add(new DashboardWidget
{
Height = dashboardWidget.Height,
Width = dashboardWidget.Width,
X = dashboardWidget.X,
Y = dashboardWidget.Y,
WidgetId = dashboardWidget.WidgetId,
DashboardId = dbDashboard.Id,
});
}
else
{
// Update DashboardWidget
var dbWidget = dbDashboard.DashboardWidgets.FirstOrDefault(x => x.Id == dashboardWidget.Id);
dbWidget.Height = dashboardWidget.Height;
dbWidget.Width = dashboardWidget.Width;
dbWidget.X = dashboardWidget.X;
dbWidget.Y = dashboardWidget.Y;
}
}
context.Dashboards.Update(dbDashboard);
await context.SaveChangesAsync();
return Unit.Value;
}
public async Task <List <WidgetDto> > Handle(GetWidgetForApplicationQuery request, CancellationToken cancellationToken)
{
var currentUserId = currentUserService.GetCurrentUserId();
var application = await context.Applications
.Where(application => application.Id == request.ApplicationId && application.UserId == currentUserId)
.Include(application => application.Widgets)
.FirstOrDefaultAsync();
if (application == null)
{
throw new EntityNotFoundException(nameof(Application), request.ApplicationId);
}
return(mapper.Map <List <WidgetDto> >(application.Widgets));
}