public async Task ImportYesterdayLogs()
{
var yesterdayDate = DateTime.Now.AddDays(-1);
var startDate = new DateTime(yesterdayDate.Year,
yesterdayDate.Month, yesterdayDate.Day, 6, 0, 0);
var endDate = new DateTime(DateTime.Now.Year,
DateTime.Now.Month, DateTime.Now.Day, 6, 0, 0);
Expression <Func <Log, bool> > predicate =
srv =>
srv.DateTimeLogged >= startDate && srv.DateTimeLogged <= endDate &&
srv.Level.Equals("ERROR");
//Get Logs data from database
var logs = (await _queryDispatcher.DispatchAsync(_unitOfWork.GenericRepository <Log>()
.FindBy, predicate))
?.ToList();
if (logs?.Count > 0)
{
//Push the logs into Elastic Search
await _commandDispatcher.DispatchAsync(_unitOfWork.LogElasticRepository <Log>().Bulk, logs);
}
await _commandDispatcher.DispatchAsync(_hubContext.SendMessage, new SignalRMessage()
{
Payload = "Completed Import Yesterday Logs"
});
}
public async Task <bool> Logout(string phoneNumber, string sentCode, string code)
{
return(await _queryDispatcher.DispatchAsync <Logout.Query, bool>(new Logout.Query()
{
UserId = _userProvider.UserId(User)
}));
}
public async Task <IActionResult> GetAsync()
{
var response = await _queryDispatcher
.DispatchAsync(new UserFilesQuery { UserId = UserId });
return(Ok(response));
}
private Task <AuthenticateUserResult> ValidateCredentialsAsync(NetworkCredential credentials, CancellationToken cancellationToken)
{
return(_queryDispatcher.DispatchAsync(new AuthenticateUserQuery
{
UserName = credentials.UserName,
Password = credentials.Password
}, cancellationToken));
}
public async Task <IActionResult> Index()
{
var model = await _queryDispatcher.DispatchAsync <GetAllForAdmin, IEnumerable <PageAdminListModel> >(new GetAllForAdmin
{
SiteId = SiteId
});
return(View(model));
}
public async Task <IActionResult> AdminList(Guid appId)
{
var model = await _queryDispatcher.DispatchAsync <GetModuleTypeAdminListModel, IEnumerable <ModuleTypeAdminListModel> >(new GetModuleTypeAdminListModel
{
AppId = appId
});
return(Ok(model));
}
public async Task <ActionResult <IEnumerable <string> > > Get()
{
var query = new GetAllUserQuestionsQuery()
{
User = "******"
};
var result = await _queryDispatcher.DispatchAsync(query).ConfigureAwait(false);
return(Ok(result));
}
private async Task <IActionResult> RefreshToken(TokenRequestViewModel viewModel)
{
try
{
var refreshTokenResult = await _queryDispatcher.DispatchAsync <GetTokenQuery, GetTokenQueryResult>(new GetTokenQuery
{
ClientId = viewModel.ClientId,
RefreshToken = viewModel.RefreshToken
});
if (refreshTokenResult.Token == null)
{
return(new UnauthorizedResult());
}
var userResult = await _queryDispatcher.DispatchAsync <GetUserByIdQuery, GetUserQueryResult>(new GetUserByIdQuery
{
UserId = refreshTokenResult.Token.UserId
});
if (userResult.User == null)
{
return(new UnauthorizedResult());
}
var newRefreshToken = _tokenService.GenerateRefreshToken(refreshTokenResult.Token.ClientId,
refreshTokenResult.Token.UserId);
await _commandDispatcher.DispatchAsync <RemoveTokenCommand>(new RemoveTokenCommand
{
Id = refreshTokenResult.Token.Id
});
await _commandDispatcher.DispatchAsync <AddTokenCommand>(new AddTokenCommand
{
Token = refreshTokenResult.Token
});
var tokenData = _tokenService.CreateAccessToken(newRefreshToken.UserId);
var response = new TokenResponseViewModel
{
Expiration = tokenData.ExporationTimeInMinutes,
RefreshToken = newRefreshToken.Value,
Token = tokenData.EncodedToken
};
return(Json(response));
}
catch (Exception)
{
return(new UnauthorizedResult());
}
}
public async Task <IActionResult> Get(Guid id)
{
var model = await _queryDispatcher.DispatchAsync <GetMaze, MazeDetailsModel>(new GetMaze { Id = id });
if (model == null)
{
return(NotFound());
}
return(Ok(model));
}
public async Task <RobotState> GetState()
{
var state = await _queryDispatcher.DispatchAsync <RobotStateCritiera, Domain.Models.RobotState>(new RobotStateCritiera());
return(new RobotState
{
X = state?.CurrentPosition?.X,
Y = state?.CurrentPosition?.Y,
Facing = state?.Facing.ToString()
});
}
public async Task <ActionResult <IEnumerable <EmployeeDto> > > SearchAsync([FromQuery] SearchEmployees query)
{
var result = await _queryDispatcher
.DispatchAsync <SearchEmployees, IEnumerable <EmployeeDto> >(query);
if (result is null || !result.Any())
{
return(NotFound());
}
return(Ok(result));
}
public async Task <IActionResult> AdminList(int startIndex, int numberOfUsers)
{
var query = new GetUsersAdminViewModel
{
StartIndex = startIndex,
NumberOfUsers = numberOfUsers
};
var model = await _queryDispatcher.DispatchAsync <GetUsersAdminViewModel, UsersAdminViewModel>(query);
return(Ok(model));
}
private void ClearPageCache(Guid siteId, Guid pageId)
{
var languages = _queryDispatcher.DispatchAsync <GetAllActive, IEnumerable <LanguageInfo> >(new GetAllActive {
SiteId = siteId
}).Result;
foreach (var language in languages)
{
_cacheManager.Remove(string.Format(CacheKeys.PageInfoCacheKey, siteId, pageId, language.Id));
}
_cacheManager.Remove(string.Format(CacheKeys.PageInfoCacheKey, siteId, pageId, Guid.Empty));
}
public async Task<IActionResult> ViewById(Guid id)
{
var model = await _queryDispatcher.DispatchAsync<GetPageInfo, PageInfo>(new GetPageInfo
{
SiteId = SiteId,
PageId = id
});
if (model == null)
return NotFound();
return Ok(model);
}
private async Task <Dictionary <PermissionType, IEnumerable <string> > > GetRoles(Entities.Page page)
{
var roles = new Dictionary <PermissionType, IEnumerable <string> >();
foreach (PermissionType permisisonType in Enum.GetValues(typeof(PermissionType)))
{
var pageRoleIds = page.PagePermissions.Where(x => x.Type == permisisonType).Select(x => x.RoleId);
var pageRoleNames = await _queryDispatcher
.DispatchAsync <GetRoleNamesFromRoleIds, IEnumerable <string> >(new GetRoleNamesFromRoleIds { RoleIds = pageRoleIds });
roles.Add(permisisonType, pageRoleNames);
}
return(roles);
}
public async Task <IActionResult> GetItemCategorySearchResults([FromRoute(Name = "searchInput")] string searchInput)
{
searchInput = searchInput.Trim();
if (string.IsNullOrEmpty(searchInput))
{
return(BadRequest("Search input mustn't be null or empty"));
}
var query = new ItemCategorySearchQuery(searchInput);
var itemCategoryReadModels = await queryDispatcher.DispatchAsync(query, default);
var itemCategoryContracts = itemCategoryContractConverter.ToContract(itemCategoryReadModels);
return(Ok(itemCategoryContracts));
}
public async Task <IEnumerable <BookViewModel> > Get([FromQuery] SearchBookModel model)
{
var result = await queryDispatcher.DispatchAsync <FindBooksQuery, FindBooksQueryResult>(new FindBooksQuery
{ Filter = model.Filter, SortOption = model.SortOption });
return(result.Books);
}
public async Task <ActionResult <IEnumerable <string> > > Get()
{
var query = new GetAllTagsQuery();
var result = await _queryDispatcher.DispatchAsync(query).ConfigureAwait(false);
return(Ok(result));
}
public async Task <IActionResult> Index(Guid pageId, Guid languageId)
{
if (pageId == Guid.Empty)
{
return(NotFound());
}
var pageInfo = await _queryDispatcher.DispatchAsync <GetPageInfo, PageInfo>(new GetPageInfo
{
SiteId = SiteId,
PageId = pageId,
LanguageId = languageId
});
if (pageInfo == null || !_securityService.IsUserAuthorized(User, pageInfo.Page.Roles[PermissionType.View]))
{
return(NotFound());
}
ViewBag.Title = pageInfo.Page.Title;
ViewBag.MetaDescription = pageInfo.Page.MetaDescription;
ViewBag.MetaKeywords = pageInfo.Page.MetaKeywords;
return(View(pageInfo));
}
public async Task <IViewComponentResult> InvokeAsync(ModuleModel model)
{
var content = await _queryDispatcher.DispatchAsync <GetContent, string>(new GetContent
{
ModuleId = model.Id,
LanguageId = _contextService.GetCurrentLanguageInfo().Id
});
if (content == null)
{
var defaultContent = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.";
_commandSender.Send <CreateTextModule, TextModule>(new CreateTextModule
{
SiteId = SiteId,
Id = Guid.NewGuid(),
ModuleId = model.Id,
Content = defaultContent
});
content = defaultContent;
}
return(View("~/Apps/Weapsy.Apps.Text/Views/Shared/Components/TextModule/Default.cshtml", content));
}
public async Task <IActionResult> ListPermissions(CancellationToken cancellationToken)
{
var query = new ListPermissionsQuery();
var projection = await _queryDispatcher.DispatchAsync(query, cancellationToken);
return(StatusCode(200, projection.Permissions));
}
public async Task <IViewComponentResult> InvokeAsync(string name, string viewName = "Default")
{
var viewModel = await _queryDispatcher.DispatchAsync <GetViewModel, MenuViewModel>(new GetViewModel
{
SiteId = SiteId,
Name = name,
LanguageId = _contextService.GetCurrentLanguageInfo().Id
});
var menuItemsToRemove = new List <MenuViewModel.MenuItem>();
foreach (var menuItemViewModel in viewModel.MenuItems)
{
if (!_securityService.IsUserAuthorized(User, menuItemViewModel.ViewRoles))
{
menuItemsToRemove.Add(menuItemViewModel);
}
}
if (menuItemsToRemove.Any())
{
foreach (var menuItemToRemove in menuItemsToRemove)
{
viewModel.MenuItems.Remove(menuItemToRemove);
}
}
return(View(viewName, viewModel));
}
protected Task <TResult> DispatchQueryAsync <TQuery, TResult>(TQuery query)
where TQuery : IQueryProvider
{
Authorize(query);
return(_queryDispatcher.DispatchAsync <TQuery, TResult>(query));
}
public async Task <IActionResult> ListAuthenticatedUserTeamInvitations(CancellationToken cancellationToken)
{
var query = new ListAuthenticatedUserTeamInvitationsQuery();
var projection = await _queryDispatcher.DispatchAsync(query, cancellationToken);
return(StatusCode(200, projection.Invitations));
}
public async Task <GetMe.Result> GetMe()
{
return(await _queryDispatcher.DispatchAsync <GetMe.Query, GetMe.Result>(new GetMe.Query()
{
UserId = _userProvider.UserId(User)
}));
}
public async Task <IActionResult> FindAuthenticatedUser(CancellationToken cancellationToken)
{
var query = new FindAuthenticatedUserQuery();
var projection = await _queryDispatcher.DispatchAsync(query, cancellationToken);
return(StatusCode(200, projection));
}
public async Task <List <Contact> > GetContacts()
{
return(await _queryDispatcher.DispatchAsync <GetContacts.Query, List <Contact> >(new GetContacts.Query()
{
UserId = _userProvider.UserId(User)
}));
}
public async Task <AddVersion> RetrieveAsync(GetAdminModel query)
{
using (var context = _contextFactory.Create())
{
var textModule = await context.TextModules.FirstOrDefaultAsync(x => x.ModuleId == query.ModuleId && x.Status == TextModuleStatus.Active);
if (textModule == null)
{
return(new AddVersion());
}
textModule.TextVersions = await context.TextVersions
.Include(y => y.TextLocalisations)
.Where(x => x.TextModuleId == textModule.Id && x.Status != TextVersionStatus.Deleted)
.ToListAsync();
var version = query.VersionId != Guid.Empty
? textModule.TextVersions.FirstOrDefault(x => x.Id == query.VersionId)
: textModule.TextVersions.FirstOrDefault(x => x.Status == TextVersionStatus.Published);
if (version == null)
{
return(new AddVersion());
}
var result = new AddVersion
{
Id = textModule.Id,
ModuleId = textModule.ModuleId,
Content = version.Content,
Description = version.Description
};
var languages = await _queryDispatcher.DispatchAsync <GetAllActive, IEnumerable <LanguageInfo> >(new GetAllActive { SiteId = query.SiteId });
foreach (var language in languages)
{
var content = string.Empty;
var existingLocalisation = version
.TextLocalisations
.FirstOrDefault(x => x.LanguageId == language.Id);
if (existingLocalisation != null)
{
content = existingLocalisation.Content;
}
result.VersionLocalisations.Add(new AddVersion.VersionLocalisation
{
LanguageId = language.Id,
LanguageName = language.Name,
Content = content
});
}
return(result);
}
}
public async Task <PaginatedResults <GetJobs.Result> > GetJobs([FromQuery] PaginationParams paginationParams)
{
return(await _queryDispatcher.DispatchAsync <GetJobs.Query, PaginatedResults <GetJobs.Result> >(new GetJobs.Query()
{
UserId = _userProvider.UserId(User),
PaginationParams = paginationParams
}));
}
public async Task <IActionResult> CountTeams(CancellationToken cancellationToken)
{
var query = new CountTeamsQuery();
var projection = await _queryDispatcher.DispatchAsync(query, cancellationToken);
return(StatusCode(200, projection));
}
