public MonitoQuery(
IMapper mapper,
IReadRepository <RequestPersistenceModel> requestRepository
)
{
Field <ListGraphType <RequestGraphType> >(
"requests",
resolve: context =>
requestRepository
.FindAll()
.ProjectTo <MinimalRequestApplicationModel>(mapper.ConfigurationProvider)
);
Field <RequestGraphType>(
"request",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <IdGraphType> >()
{
Name = "id"
}
),
resolve: context => {
var id = context.GetArgument <int>("id");
return(requestRepository
.FindAll(x => x.ID == id)
.ProjectTo <MinimalRequestApplicationModel>(mapper.ConfigurationProvider)
.FirstOrDefault());
}
);
}
public PagedResult <PostHomeViewModel> GetAllPaging(string keyword, int page, int pageSize)
{
// get all post
var posts = _postRepository.FindAll(s => s.Status == 1);
var users = _userRepository.FindAll();
// filter post with keywork
if (!string.IsNullOrEmpty(keyword))
{
posts = posts.Where(x => x.Title.Contains(keyword));
}
// oder post by CreateDate and pagination
var postsPagination = posts.OrderByDescending(x => x.CreateDate)
.Skip((page - 1) * pageSize)
.Take(pageSize);
// get user info with post
var postsWithUserInfor = from p in postsPagination
join u in users
on p.UserId equals u.Id
select new PostHomeViewModel
{
Id = p.Id,
Title = p.Title,
Description = p.Description,
Thumbnail = p.Thumbnail,
CreateDate = p.CreateDate,
Alias = p.Alias,
ViewCount = p.ViewCount,
ImageAvatar = u.Avatar,
UserName = u.UserName,
DateCreateAgo = DateFormat.GetPrettyDateAgo(p.CreateDate)
};
// total post
int totalRow = posts.Count();
// get pagecount for all post
var pageCount = (double)totalRow / pageSize;
var paginationSet = new PagedResult <PostHomeViewModel>()
{
Results = postsWithUserInfor.ToList(),
CurrentPage = page,
RowCount = totalRow,
PageSize = pageSize,
PageCount = (int)Math.Ceiling(pageCount)
};
return(paginationSet);
}
public IList <PermissionViewModel> userRoles(int userId, string businessRoleId)
{
//lay tat ca cac rolesname cua user va business
var listuserRoles = from g in userRoleRepository.FindAll(s => s.UserId == userId)
join p in roleRepository.FindAll(s => s.BusinessRoleId == businessRoleId)
on g.RoleId equals p.Id
select new PermissionViewModel
{
RoleId = p.Id,
RoleName = p.RoleName,
Description = p.Description,
IsGranted = true
};
return(listuserRoles.ToList());
}
public BuildRunContainer GetNextIdleRun()
{
var availableBuilds = _buildRepository
.FindAll(x => x.Status == "Idle")
.Select(x => x.ID)
.ToList();
var runPersistenceModel = _runRepository
.FindAll(x => availableBuilds.Contains(x.BuildID) && x.EndedAt == null)
.OrderBy(x => x.RequestedAt)
.FirstOrDefault();
if (runPersistenceModel == null)
{
return(null);
}
var buildPersistenceModel = _buildRepository
.Find(runPersistenceModel.BuildID);
if (buildPersistenceModel == null) // dangling situation?
{
return(null);
}
var runDomainEntity = _mapper.Map <RunDomainEntity>(runPersistenceModel);
var buildDomainEntity = _mapper.Map <BuildDomainEntity>(buildPersistenceModel);
return(new BuildRunContainer(buildDomainEntity, runDomainEntity));
}
public Task <IQueryable <TodoListDto> > HandleAsync(GetTodoListsQuery query, CancellationToken cancellationToken)
{
var taskLists = mapper.ProjectTo <TodoListDto>(
readRepository
.FindAll <TodoListReadModel>());
return(Task.FromResult(taskLists));
}
public async Task <IActionResult> Get()
{
var entities = await _readRepository.FindAll(Includes.Students());
var dtos = _mapper.Map <IEnumerable <Course>, List <CourseListDto> >(entities);
return(new JsonResult(dtos));
}
public void Reload()
{
lock (dbMessageCache)
{
List <LocalizationMessage> messages = readRepository.FindAll <LocalizationMessage>().ToList();
dbMessageCache.ReplaceMessages(messages);
}
}
public Task <IQueryable <TodoListDto> > HandleAsync(GetTodoListsQuery query, CancellationToken cancellationToken)
{
IQueryable <TodoListDto> taskLists = readRepository
.FindAll <TodoListReadModel>()
.Include(x => x.Todos)
.ProjectTo <TodoListDto>();
return(Task.FromResult(taskLists));
}
public Task <RunApplicationModel> Handle(GetLatestRunQuery request, CancellationToken cancellationToken)
{
var latestRunPersistenceModel = _runRepository
.FindAll(r => r.BuildID == request.BuildID)
.OrderByDescending(r => r.StartedAt)
.FirstOrDefault();
return(Task.FromResult(_mapper.Map <RunApplicationModel>(latestRunPersistenceModel)));
}
public Task <BaseBuildApplicationModel[]> Handle(GetAllBuildsQuery request, CancellationToken cancellationToken)
{
var buildApplicationModels = _buildRepository
.FindAll()
.OrderBy(b => b.Order)
.ProjectTo <BaseBuildApplicationModel>(_mapper.ConfigurationProvider);
// _logger.LogTrace(buildApplicationModels.ToString());
return(Task.FromResult(buildApplicationModels.ToArray()));
}
public Task <IEnumerable <MinimalLinkApplicationModel> > Handle(GetDoneRequestLinksByRequestIDAfterIDQuery query, CancellationToken cancellationToken)
{
IEnumerable <MinimalLinkApplicationModel> linksApplicationModels = _linkRepository
.FindAll(x => x.RequestID == query.RequestID && x.ID > query.LinkID && x.Status == LinkStatus.Done)
.OrderBy(x => x.ID)
.Take(100)
.ProjectTo <MinimalLinkApplicationModel>(_mapper.ConfigurationProvider)
.ToList();
return(Task.FromResult(linksApplicationModels));
}
public async Task <MultiValueDictionary <NotificationBuffer, BufferedNotification> > SelectNotificationsForReleaseAsync(IReadRepository readRepository)
{
DateTimeOffset maxDate = Clock.Current.Now.Subtract(minTimeDelay);
var buffers = readRepository.FindAll <NotificationBuffer>()
.Where(x => x.GovernorId == Id);
var buffersWithNotifications = buffers.GroupJoin(readRepository.FindAll <BufferedNotification>(),
notification => notification.Id,
buffer => buffer.Buffer.Id,
(buffer, notifications) => new { Buffer = buffer, Notifications = notifications });
var toRelease = await buffersWithNotifications
.Where(x => x.Notifications.Any(y => y.TimeQueued <= maxDate))
.ToListAsync();
var res = new MultiValueDictionary <NotificationBuffer, BufferedNotification>();
foreach (var pair in toRelease)
{
res.AddRange(pair.Buffer, pair.Notifications);
}
return(res);
}
Task <MinimalRequestStatusApplicationModel> IRequestHandler <GetRequestStatusByUUIDQuery, MinimalRequestStatusApplicationModel> .Handle(GetRequestStatusByUUIDQuery query, CancellationToken cancellationToken)
{
var requestPersistenceModel = _requestRepository
.FindAll(x => x.UUID == query.UUID)
.FirstOrDefault();
if (requestPersistenceModel == null)
{
return(Task.FromResult <MinimalRequestStatusApplicationModel>(null));
}
var requestStatusApplicationModel = _mapper.Map <MinimalRequestStatusApplicationModel>(requestPersistenceModel);
return(Task.FromResult(requestStatusApplicationModel));
}
public Task <MinimalRequestWithDoneLinksCountApplicationModel> Handle(GetRequestByUUIDQuery query, CancellationToken cancellationToken)
{
#region Find request persistence model
var requestPersistenceModel = _requestRepository
.FindAll(x => x.UUID == query.UUID)
.FirstOrDefault();
#endregion
if (requestPersistenceModel == null)
{
return(Task.FromResult <MinimalRequestWithDoneLinksCountApplicationModel>(null));
}
#region Find links
var doneLinksCount = _linkRepository
.FindAll(x => x.RequestID == requestPersistenceModel.ID && x.Status == LinkStatus.Done) // TODO: Add link status filter in command
.Count();
var linksPersistenceModels = _linkRepository
.FindAll(x => x.RequestID == requestPersistenceModel.ID && x.Status == LinkStatus.Done) // TODO: Add link status filter in command
.OrderBy(x => x.ID)
.Take(2000) // TODO: Limit links in command
.ToList();
#endregion
#region Convert request to application model
var requestApplicationModel = _mapper.Map <MinimalRequestWithDoneLinksCountApplicationModel>(requestPersistenceModel);
#endregion
#region Convert links to application models
var linksApplicationModels = _mapper.Map <ICollection <MinimalLinkApplicationModel> >(linksPersistenceModels);
#endregion
requestApplicationModel.Links = linksApplicationModels;
requestApplicationModel.DoneLinksCount = doneLinksCount;
return(Task.FromResult(requestApplicationModel));
}
public IResult <IEnumerable <T> > FindAll(
int skip = AppConstants.DEFAULT_SKIP,
int take = AppConstants.DEFAULT_TAKE
) => Do <IEnumerable <T> > .Try(r =>
{
var result = _readRepository.FindAll(skip, take);
if (result.HasErrorsOrResultIsNull())
{
r.AddErrors(result);
return(default(IEnumerable <T>));
}
return(result.ResultObject);
})
.Result;
public Task <IEnumerable <MinimalLinkApplicationModel> > Handle(GetRequestLinksByUUIDQuery query, CancellationToken cancellationToken)
{
var requestPersistenceModel = _requestRepository
.FindAll(x => x.UUID == query.UUID)
.FirstOrDefault();
if (requestPersistenceModel == null)
{
return(Task.FromResult <IEnumerable <MinimalLinkApplicationModel> >(null));
}
IEnumerable <MinimalLinkApplicationModel> linksApplicationModels = _linkRepository
.Include(x => x.RedirectsTo)
.Where(x => x.RequestID == requestPersistenceModel.ID)
.ProjectTo <MinimalLinkApplicationModel>(_mapper.ConfigurationProvider);
return(Task.FromResult(linksApplicationModels));
}
public async Task <MultiValueDictionary <NotificationBuffer, BufferedNotification> > SelectNotificationsForReleaseAsync(IReadRepository readRepository)
{
DateTimeOffset maxDate = Clock.Current.Now.Subtract(minTimeDelay);
var notifications = readRepository.FindAll <BufferedNotification>()
.Where(x => x.TimeQueued <= maxDate && x.Buffer.GovernorId == Id);
var buffers = await notifications.Select(x => x.Buffer)
.Include(readRepository, x => x.Notifications)
.ToListAsync(readRepository);
var res = new MultiValueDictionary <NotificationBuffer, BufferedNotification>();
foreach (var buffer in buffers.Distinct())
{
res.AddRange(buffer, buffer.Notifications);
}
return(res);
}
public IList <CategoriesGroupViewModel> GetCategoriesGroup()
{
var groupJoin = from pc in postCategoryRepository.FindAll()
join c in categoryRepository.FindAll()
on pc.CategoryId equals c.Id
select new
{
Id = pc.PostId,
CategoryId = pc.CategoryId,
CategoryName = c.CategoryName,
Url = c.Url
};
var listGroupCount = groupJoin.GroupBy(info => info.CategoryName)
.Select(group => new CategoriesGroupViewModel
{
CategoryName = group.Key,
GroupCount = group.Count(),
});
return(listGroupCount.ToList());
}
public IList <RoleViewModel> GetAll()
{
return(roleRepository.FindAll().ProjectTo <RoleViewModel>().ToList());
}
public IList <TagViewModel> GetAll()
{
return(_tagRepository.FindAll().ProjectTo <TagViewModel>().ToList());
}
public bool BuildExistsByName(string name)
{
return(_buildRepository
.FindAll(x => x.Name.ToLower() == name.ToLower())
.Any());
}
public IList <PostViewModel> GetAll()
{
return(_postRepository.FindAll(x => x.Id).ProjectTo <PostViewModel>().ToList());
}
public DetailPostViewModel GetDetail(int id)
{
// lay chi tiet post theo id
var post = GetById(id);
// lay user theo post
var user = _userRepository.FindSingle(s => s.Id == post.UserId);
// lay danh sach tag theo post id
var tags = from t in _tagRepository.FindAll()
join pt in _postTagRepository.FindAll(s => s.PostId == id)
on t.Id equals pt.TagId
//where pt.PostId == id
select new TagViewModel
{
Id = t.Id,
TagName = t.TagName
};
// lay danh sach category theo postid
var categories = from pc in _postCategoryRepository.FindAll(s => s.PostId == id)
join c in _categoryRepository.FindAll()
on pc.CategoryId equals c.Id
//where pc.PostId == id
select new CategoryViewModel
{
Id = c.Id,
CategoryName = c.CategoryName
};
// lay danh sach comment
var comments = from cm in _commentRepository.FindAll()
join p in _postRepository.FindAll()
on cm.PostId equals p.Id
join us in _userRepository.FindAll()
on p.UserId equals us.Id
where cm.PostId == id && cm.Status == true
select new CommentInPostViewModel
{
UserName = us.UserName,
CreateDate = cm.CreateDate,
Content = cm.Content
};
//get previous post
var previousPost = _postRepository.FindAll(s => s.Id < id).ProjectTo <PostViewModel>().LastOrDefault();
//get next post
var nextPost = _postRepository.FindAll(s => s.Id > id).ProjectTo <PostViewModel>().FirstOrDefault();
var postViewModel = new DetailPostViewModel
{
PostId = post.Id,
Title = post.Title,
Content = post.Content,
Tags = tags,
Categories = categories,
Avatar = user.Avatar,
Author = user.FirstName,
Comments = comments.OrderByDescending(s => s.CreateDate),
DateAgo = DateFormat.GetPrettyDateAgo(post.CreateDate),
PreviousPost = previousPost,
NextPost = nextPost
};
return(postViewModel);
}
public Task <IQueryable <TodoReadModel> > HandleAsync(GetTodosQuery query, CancellationToken cancellationToken)
{
return(Task.FromResult(
readRepository.FindAll <TodoReadModel>()));
}
public IList <CategoryViewModel> GetAll()
{
return(categoryRepository.FindAll().ProjectTo <CategoryViewModel>().ToList());
}
public IList <UserViewModel> GetAll()
{
return(userRepository.FindAll().ProjectTo <UserViewModel>().ToList());
}
public UserRoleViewModel FindById(int userId, int roleId)
{
return(userRoleRepository.FindAll(s => s.UserId == userId && s.RoleId == roleId).ProjectTo <UserRoleViewModel>().SingleOrDefault());
}
public IActionResult GetDebt()
{
return(Ok(_repository.FindAll()));
}
public IList <BusinessRoleViewModel> GetAll()
{
return(businessRoleRepository.FindAll().ProjectTo <BusinessRoleViewModel>().ToList());
}
public UserViewModel checkLogin(string userName, string passWord)
{
var user = userRepository.FindAll(s => s.UserName == userName && s.Password == passWord && s.Allowed == 1).ProjectTo <UserViewModel>().SingleOrDefault();
return(user);
}
