public ModelPager <VueSystemNotification> querySystemNotification(QMsgUser query)
{
ModelPager <VueSystemNotification> result = new ModelPager <VueSystemNotification>(query.pageIndex, query.pageSize);
var mainSql = Db.Queryable <EMsgInfo_System, EMsgContent_System>((m, c) => new object[]
{
JoinType.Left, m.ContentId == c.Id,
})
.Where((m, c) => m.ReceiveUserId == query.userId)
.OrderBy((m, c) => m.CreatedDateTime, OrderByType.Desc)
.Select((m, c) => new VueSystemNotification
{
dbDateTime = m.CreatedDateTime,
htmlContent = c.htmlContent,
htmlTitle = c.htmlTitle,
NotificationStatus = m.NotificationStatus,
msgId = m.Id,
contentId = c.Id
});
int totalNumber = 0;
result.datas = mainSql.ToPageList(query.pageIndex, query.pageSize, ref totalNumber);
result.totalCount = totalNumber;
return(result);
}
public async Task <ModelPager <VueUserCommReply> > queryUserCommReply(QUserCommReply query)
{
ModelPager <VueUserCommReply> result = new ModelPager <VueUserCommReply>(query.pageIndex, query.pageSize);
var mainSql = Db.Queryable <ECommentReply_Res, EComment_Res, EUserInfo, EBookInfo>((r, c, cu, b) => new object[]
{
JoinType.Inner, r.commentId == c.Id,
JoinType.Inner, r.authorId == cu.Id,
JoinType.Inner, c.parentRefCode == b.Code,
})
.Where((r, c, cu, b) => r.authorId == query.userId)
.OrderBy(r => r.CreateDateTime, OrderByType.Desc)
.Select((r, c, cu, b) => new VueUserCommReply
{
bookCode = b.Code,
bookName = b.Title,
resCode = c.refCode,
bookCoverUrl = b.CoverUrl,
commentId = c.Id,
commentAuthorId = c.authorId,
commentAuthor = cu.NickName,
pCommentDateTime = c.CreateDateTime,
commentContent = c.content,
replyId = r.Id,
replyContent = r.content,
replyTarget = r.replyName,
pReplyDateTime = r.CreateDateTime,
});
RefAsync <int> totalNumber = new RefAsync <int>();
result.datas = await mainSql.ToPageListAsync(query.pageIndex, query.pageSize, totalNumber);
result.totalCount = totalNumber;
return(result);
}
public async Task <ModelPager <VueUserBook> > queryUserBook(QUserBook query)
{
ModelPager <VueUserBook> result = new ModelPager <VueUserBook>(query.pageIndex, query.pageSize);
var mainSql = Db.Queryable <EUserBook, EBookInfo>((ub, b) => new object[]
{
JoinType.Inner, ub.bookCode == b.Code
})
.Where(ub => ub.userId == query.userId)
.OrderBy(ub => ub.createdDateTime, OrderByType.Desc)
.Select((ub, b) => new VueUserBook
{
id = ub.Id,
Code = b.Code,
CoverUrl = b.CoverUrl,
Name = b.Title,
ResourceCount = b.ResoureNum,
Score = b.Score,
CreateDateTime = ub.createdDateTime,
});
RefAsync <int> totalNumber = new RefAsync <int>();
result.datas = await mainSql.ToPageListAsync(query.pageIndex, query.pageSize, totalNumber);
result.totalCount = totalNumber;
return(result);
}
public async Task <ModelPager <VueMsgInfoNotification> > queryUserReply(QMsgUser query)
{
ModelPager <VueMsgInfoNotification> result = new ModelPager <VueMsgInfoNotification>(query.pageIndex, query.pageSize);
var mainSql = Db.Queryable <EMsgInfo_ReplyRes, EMsgContent_ReplyRes>((m, c) => new object[]
{
JoinType.Left, m.resCode == c.ResCode
})
.Where((m, c) => m.ReceiveUserId == query.userId)
.OrderBy((m, c) => m.CreatedDateTime, OrderByType.Desc)
.Select((m, c) => new VueMsgInfoNotification
{
dbDateTime = m.CreatedDateTime,
senderHeaderUrl = m.SendHeaderUrl,
senderId = m.SendUserId,
senderName = m.SendName,
bookCode = c.BookCode,
bookUrl = c.BookUrl,
resCode = c.ResCode,
resName = c.ResName,
commentId = m.CommentId,
replyId = m.ReplyId,
receiveContent = m.ReceiveContent,
NotificationStatus = m.NotificationStatus,
msgId = m.Id
});
RefAsync <int> totalNumber = new RefAsync <int>();
result.datas = await mainSql.ToPageListAsync(query.pageIndex, query.pageSize, totalNumber);
result.totalCount = totalNumber;
return(result);
}
public DataSourceResult <PatientViewModel> Search(SearchPatientViewModel searchPatientViewModel, int pageIndex, int pageSize)
{
ModelPager modelPager = new ModelPager()
{
PageIndex = pageIndex,
PageSize = pageSize,
IncludeAll = false,
SortOrder = SortOrder.ASCENDING,
OrderColumn = "FirstName"
};
PatientDtoResult response = _PhekoServiceClient.Search(_PatientViewModelMapper.MapSearchPatientViewModelToPatientDto(searchPatientViewModel), modelPager);
//if (response.)
//{
// ModelException modelException = new ModelException();
// response.FieldErrors.ToList<FieldError>().ForEach(item => modelException.ModelErrors.Add(new ModelError() { FieldName = item.FieldName, Message = item.ErrorMessage }));
// throw modelException;
//}
return(new DataSourceResult <PatientViewModel>()
{
Total = response.Total,
Data = response.Models.Select(item => _PatientViewModelMapper.MapToPatientViewModel(item)).ToList <PatientViewModel>()
});
}
public Result <PatientDto> Search(PatientDto searchPatient, ModelPager modelPager)
{
Result <PatientDto> response = new Result <PatientDto>();
using (UnitOfWork unitOfWork = new UnitOfWork())
{
Expression <Func <Patient, bool> > searchFilter = null;
if (searchPatient != null)
{
searchFilter = p => (searchPatient.PatientId == null || p.PatientId == searchPatient.PatientId) &&
(string.IsNullOrEmpty(searchPatient.FirstName) || p.FirstName.Contains(searchPatient.FirstName)) &&
(string.IsNullOrEmpty(searchPatient.LastName) || p.LastName.Contains(searchPatient.LastName)) &&
(searchPatient.BirthDate == null || p.BirthDate == searchPatient.BirthDate) &&
(string.IsNullOrEmpty(searchPatient.IDNumber) || p.IDNumber.Contains(searchPatient.IDNumber));
}
response.Models = unitOfWork.PatientRepository.GetPagedEntities(searchFilter, GetOrderExpression(modelPager), modelPager, "PostalAddress, PhysicalAddress")
.Select(item => _PatientMapper.MapToPatientDto(item))
.ToList <PatientDto>();
response.Total = unitOfWork.PatientRepository.Count(searchFilter);
}
return(response);
}
public ModelPager <VueMsgInfoNotification> QueryUserNotifictaion(QMsgUser query)
{
if (string.IsNullOrEmpty(query.userId))
{
throw new CCException("非法请求");
}
ModelPager <VueMsgInfoNotification> result = null;
switch (query.notificationType)
{
case NotificationType.praize:
result = _msgPraizeRepository.queryUserPraize(query).Result;
break;
case NotificationType.comment:
result = _msgCommentResRepository.queryUserComment(query).Result;
break;
case NotificationType.reply:
result = _msgReplyRepository.queryUserReply(query).Result;
break;
}
//异步更新消息数据
if (query.updateMsgToRead)
{
Async_MsgToReadAfterQuery(query, result.datas);
}
return(result == null? new ModelPager <VueMsgInfoNotification>():result);
}
public ModelPager <RBookList> GetBookListPager(QBookList query)
{
ModelPager <RBookList> result = new ModelPager <RBookList>();
result.pageIndex = query.pageIndex;
result.pageSize = query.pageSize;
RefAsync <int> totalNumber = new RefAsync <int>();
if (query.QueryType == QBookList_Type.Tag)
{
result.datas = _bookDb.GetBookListByTag(query.pageIndex, query.pageSize, query.Code, totalNumber).Result;
result.totalCount = totalNumber;
return(result);
}
else if (query.QueryType == QBookList_Type.Section)
{
ESection section = _sectionRepository.GetByKey(query.Code).Result;
if (section != null)
{
if (section.SectionType == SectionType.Column)
{
result.datas = _bookDb.GetBookListBySection_ST(query.pageIndex, query.pageSize, query.Code, totalNumber).Result;
result.totalCount = totalNumber;
return(result);
}
else
{
if (section.Code == WebSectionCode.NewExpress)
{
result.datas = _bookDb.GetBookListBySection_DT(query.pageIndex, query.pageSize, query.Code, totalNumber).Result;
result.totalCount = totalNumber;
return(result);
}
else if (section.Code == WebSectionCode.ResDownLoad)
{
result.datas = _bookDb.GetBookListBySection_Resource(query.pageIndex, query.pageSize, totalNumber).Result;
result.totalCount = totalNumber;
return(result);
}
else if (section.Code == WebSectionCode.HighScore)
{
result.datas = _bookDb.GetBookListBySection_HighScroe(query.pageIndex, query.pageSize, totalNumber, defaultTop: query.HighScoreTop).Result;
if (totalNumber > query.HighScoreTop)
{
totalNumber = new RefAsync <int>(query.HighScoreTop);
}
result.totalCount = totalNumber;
return(result);
}
}
}
}
return(null);
// return _bookDb.GetSimpleBookPager(pageIndex, pageSize, bookSection).Result;
}
private Expression <Func <Patient, object> > GetOrderExpression(ModelPager modelPager)
{
switch (modelPager.OrderColumn)
{
case "LastName":
return(p => p.LastName);
default:
return(p => p.FirstName);
}
}
private Expression <Func <SecurityUser, object> > GetOrderExpression(ModelPager modelPager)
{
switch (modelPager.OrderColumn)
{
case "LastName":
return(s => s.LastName);
default:
return(s => s.FirstName);
}
}
public async Task <ModelPager <VueCommentReply> > GetReplysByCommentId(QComment_Reply query)
{
ModelPager <VueCommentReply> result = new ModelPager <VueCommentReply>(query.pageIndex, query.pageSize);
var qOwn = Db.Queryable <EPraize_CommentReply>().Where(c => c.commentId == query.commentId && c.userId == query.reqUserId);
var q = base.Db.Queryable <ECommentReply_Res, EUserInfo>((c, u) => new object[]
{
JoinType.Inner, c.authorId == u.Id
})
.Where(c => c.commentId == query.commentId)
.Select((c, u) => new VueCommentReply
{
CreateDateTime = c.CreateDateTime,// c.CreateDateTime.ToString("yyyy-MM-dd hh:MM"),
authorId = u.Id,
authorName = u.NickName,
replyId = c.Id,
content = c.content,
goodNum = c.goodNum,
headerUrl = u.HeaderUrl,
replyAuthorId = c.replyAuthorId,
replyAuthorName = c.replyName,
bookCode = c.bookCode,
});
var orderByPraize = $"case when j1.goodNum <{ SysRules.OrderByPraizeStartNum} then 0 else j1.goodNum end desc";
var orderByFixedReply = $"case when j1.replyId = '{query.fixedReplyId}' then 0 else j1.replyId end";
var mainSql = Db.Queryable(q, qOwn, JoinType.Left, (j1, j2) => j1.replyId == j2.replyId)
.OrderByIF(query.fixedReplyId > 0, orderByFixedReply)
.OrderBy(orderByPraize)
.OrderBy(j1 => j1.CreateDateTime, OrderByType.Desc)
.Select((j1, j2) => new VueCommentReply
{
CreateDateTime = j1.CreateDateTime,
authorId = j1.authorId,
authorName = j1.authorName,
replyId = j1.replyId,
content = j1.content,
goodNum = j1.goodNum,
headerUrl = j1.headerUrl,
replyAuthorId = j1.replyAuthorId,
replyAuthorName = j1.replyAuthorName,
userPraizeType = j2.PraizeType,
bookCode = j1.bookCode
});
RefAsync <int> totalNumber = new RefAsync <int>();
result.datas = await mainSql.ToPageListAsync(query.pageIndex, query.pageSize, totalNumber);
result.totalCount = totalNumber;
return(result);
}
public async Task <ModelPager <VueUserPraize> > queryUserCommentReplyPraize(QUserPraize query)
{
ModelPager <VueUserPraize> result = new ModelPager <VueUserPraize>(query.pageIndex, query.pageSize);
var prSql = sql_UserCommReplyPraize(query);
RefAsync <int> totalNumber = new RefAsync <int>();
result.datas = await prSql.ToPageListAsync(query.pageIndex, query.pageSize, totalNumber);
result.totalCount = totalNumber;
return(result);
}
public async Task <ModelPager <VueResInfo> > GetResByRefCode(QRes qRes)
{
ModelPager <VueResInfo> result = new ModelPager <VueResInfo>(qRes.pager.pageIndex, qRes.pager.pageSize);
var mainSql = this.sqlResByCode(qRes.refCode, qRes.reqUserId, qRes.fixedResCode);
RefAsync <int> totalNumber = new RefAsync <int>();
result.datas = await mainSql.ToPageListAsync(qRes.pager.pageIndex, qRes.pager.pageSize, totalNumber);
result.totalCount = totalNumber;
return(result);
}
public ModelPager <VueSystemNotification> QuerySystemNotifictaion(QMsgUser query)
{
if (string.IsNullOrEmpty(query.userId))
{
throw new CCException("非法请求");
}
ModelPager <VueSystemNotification> result = _msgSystemRepository.querySystemNotification(query);
if (query.updateMsgToRead)
{
Async_MsgToReadAfterQuery(query, null, result.datas);
}
return(result);
}
public ModelPager <ESearchOneBookResult> SearchBook(QueryBookSearch query)
{
if (string.IsNullOrEmpty(query.keyword))
{
throw new Exception("没有关键字");
}
ModelPager <ESearchOneBookResult> result = new ModelPager <ESearchOneBookResult>(query.pageIndex, query.pageSize);
var mainSql = _Db.Queryable <ESearchOneBookResult>()
.Where(r => r.keyWord == query.keyword);
result.datas = mainSql.ToPageList(query.pageIndex, query.pageSize);
return(result);
}
public DataSourceResult <SecurityUserViewModel> GetUsers(string searchText, int pageIndex, int pageSize)
{
ModelPager modelPager = new ModelPager()
{
PageIndex = pageIndex,
PageSize = pageSize,
IncludeAll = false,
SortOrder = SortOrder.ASCENDING,
OrderColumn = "FirstName"
};
SecurityUserDtoResult response = _PhekoServiceClient.GetUsers(searchText, modelPager);
return(new DataSourceResult <SecurityUserViewModel>()
{
Total = response.Total,
Data = response.Models.Select(item => _SecurityUserViewModelMapper.MapToPatientAddressViewModel(item)).ToList <SecurityUserViewModel>()
});
}
public DataSourceResult <PatientConsultationViewModel> Search(int patientId, string searchText, int pageIndex, int pageSize)
{
ModelPager modelPager = new ModelPager()
{
PageIndex = pageIndex,
PageSize = pageSize,
IncludeAll = false,
SortOrder = SortOrder.DESCENDING,
OrderColumn = "StartDate"
};
PatientConsultationDtoResult response = _PhekoServiceClient.GetPatientConsultations(patientId, searchText, modelPager);
return(new DataSourceResult <PatientConsultationViewModel>()
{
Total = response.Total,
Data = response.Models.Select(item => _PatientConsultationViewModelMapper.MapToPatientConsultationViewModel(item)).ToList <PatientConsultationViewModel>()
});
}
public Result <SecurityUserDto> GetUsers(string searchText, ModelPager modelPager)
{
Result <SecurityUserDto> response = new Result <SecurityUserDto>();
using (UnitOfWork unitOfWork = new UnitOfWork())
{
Expression <Func <SecurityUser, bool> > searchFilter = null;
if (!string.IsNullOrEmpty(searchText))
{
searchFilter = s => s.FirstName.Contains(searchText) || s.LastName.Contains(searchText);
}
response.Models = unitOfWork.SecurityUserRepository.GetPagedEntities(searchFilter, GetOrderExpression(modelPager), modelPager)
.Select(item => _SecurityUserMapper.MapToSecurityUserDto(item))
.ToList <SecurityUserDto>();
response.Total = unitOfWork.SecurityUserRepository.Count(searchFilter);
}
return(response);
}
public virtual IEnumerable <TEntity> GetPagedEntities(Expression <Func <TEntity, bool> > filter = null,
Expression <Func <TEntity, object> > orderExpression = null,
ModelPager modelPager = null, string includeProperties = "")
{
IQueryable <TEntity> query = _DbSet;
if (filter != null)
{
query = query.Where(filter);
}
if (!string.IsNullOrEmpty(includeProperties))
{
query = Include(query, includeProperties);
}
if (modelPager != null & !modelPager.IncludeAll)
{
return(GetPagedEntityData(query, orderExpression, modelPager));
}
return(query.ToList());
}
public async Task <ModelPager <VueUserPointTrans> > getPointTrans(QUserTrans query)
{
ModelPager <VueUserPointTrans> result = new ModelPager <VueUserPointTrans>(query.pageIndex, query.pageSize);
var mainSql = Db.Queryable <EUserPointsTrans>()
.Where(a => a.userId == query.userId &&
a.createdDateTime.Date >= query.startDate.Date &&
a.createdDateTime.Date <= query.endDate.Date)
.OrderBy(a => a.createdDateTime, OrderByType.Desc)
.Select(a => new VueUserPointTrans
{
dbDateTime = a.createdDateTime,
changeType = a.changeType,
point = a.point
});
RefAsync <int> totalNumber = new RefAsync <int>();
result.datas = await mainSql.ToPageListAsync(query.pageIndex, query.pageSize, totalNumber);
result.totalCount = totalNumber;
return(result);
}
public ResultPager <RBookList> getBookListPager(QBookList query)
{
ResultPager <RBookList> result = new ResultPager <RBookList>();
var st = DateTime.Now;
Console.WriteLine($"开始Query{st}");
try
{
if (query.QueryType == QBookList_Type.Search)
{
result = _searchServices.searchBook(new SearchReq
{
keyword = query.Code,
pageIndex = query.pageIndex,
pageSize = query.pageSize,
userId = this.getUserId()
});
}
else
{
ModelPager <RBookList> pd = _bookServices.GetBookListPager(query);
result.PageData = pd;
result.PageData.pageIndex = query.pageIndex;
result.PageData.pageSize = query.pageSize;
}
}
catch (Exception ex)
{
result.ErrorMsg = ex.Message;
}
var et = DateTime.Now;
Console.WriteLine($"结束Query{et}");
Console.WriteLine($"时间差{et - st}");
return(result);
}
public ModelPager <VueUserRes> queryUserRes_GroupByBook(QUserRes query)
{
ModelPager <VueUserRes> result = new ModelPager <VueUserRes>(query.pageIndex, query.pageSize);
var mainSql = Db.Queryable <EResourceInfo, EBookInfo>((r, b) => new object[]
{
JoinType.Inner, r.RefCode == b.Code
})
.Where((r, b) => r.Owner == query.userId && r.IsDelete == false)
.GroupBy((r, b) => new { b.Code, r.Owner, b.Title, b.CoverUrl })
.Select((r, b) => new VueUserRes
{
bookCode = b.Code,
bookCoverUrl = b.CoverUrl,
bookName = b.Title,
});
// RefAsync<int> totalNumber = new RefAsync<int>();
int totalNumber = 0;
result.datas = mainSql.ToPageList(query.pageIndex, query.pageSize, ref totalNumber);
result.totalCount = totalNumber;
result.datas = arrangeUserRes(result.datas);
return(result);
}
public ModelPager <ESearchOneBookResult> CrawlerSearch(string keyword, int maxUserLine = 5)
{
ModelPager <ESearchOneBookResult> result = new ModelPager <ESearchOneBookResult>();
var searchUrl = getSearchUrlByKeyword(keyword);
HtmlDocument htmlDoc = getDocbyEntryUrl(searchUrl);
var nodeResultList = htmlDoc.DocumentNode.SelectNodes("//div[@class='result-list']/div[@class='result']");
if (nodeResultList == null)
{
return(result);
}
result.datas = new List <ESearchOneBookResult>();
foreach (var nodeResult in nodeResultList)
{
ESearchOneBookResult resultItem = new ESearchOneBookResult();
var imgNode = nodeResult.SelectSingleNode("div[@class='pic']/a/img");
resultItem.CoverUrl = imgNode.Attributes["src"].Value;
var hrefNode = nodeResult.SelectSingleNode("div[@class='content']/div/h3/a");
resultItem.Name = hrefNode.InnerText;
var onClickString = hrefNode.Attributes["onclick"].Value;
resultItem.Code = getCodeFromSearchOnClickString(onClickString);
resultItem.keyWord = keyword;
result.datas.Add(resultItem);
if (result.datas.Count == maxUserLine)
{
break;
}
}
return(result);
}
public Result <PatientConsultationDto> GetPatientConsultations(int patientId, string searchText, ModelPager modelPager)
{
return(_IPatientConsultationManager.GetPatientConsultations(patientId, searchText, modelPager));
}
public virtual IEnumerable <TEntity> GetPagedEntityData(IQueryable <TEntity> query, Expression <Func <TEntity, object> > orderExpression, ModelPager modelPager)
{
Func <IQueryable <TEntity>, IOrderedQueryable <TEntity> > orderby = OrderEntities(modelPager, orderExpression);
int elementsToSkip = (modelPager.PageIndex - 1) * modelPager.PageSize;
return(orderby(query).Skip(elementsToSkip).Take(modelPager.PageSize).ToList <TEntity>());
}
public virtual Func <IQueryable <TEntity>, IOrderedQueryable <TEntity> > OrderEntities(ModelPager modelPager, Expression <Func <TEntity, object> > orderExpression)
{
var unaryExpression = orderExpression.Body as UnaryExpression;
if (unaryExpression != null)
{
var propertyExpression = (MemberExpression)unaryExpression.Operand;
var parameters = orderExpression.Parameters;
if (propertyExpression.Type == typeof(decimal))
{
var newExpression = Expression.Lambda <Func <TEntity, decimal> >(propertyExpression, parameters);
if (modelPager.SortOrder == SortOrder.DESCENDING)
{
return(p => p.OrderByDescending(newExpression));
}
else
{
return(p => p.OrderBy(newExpression));
}
}
if (propertyExpression.Type == typeof(DateTime))
{
var newExpression = Expression.Lambda <Func <TEntity, DateTime> >(propertyExpression, parameters);
if (modelPager.SortOrder == SortOrder.DESCENDING)
{
return(p => p.OrderByDescending(newExpression));
}
else
{
return(p => p.OrderBy(newExpression));
}
}
if (propertyExpression.Type == typeof(int))
{
var newExpression = Expression.Lambda <Func <TEntity, int> >(propertyExpression, parameters);
if (modelPager.SortOrder == SortOrder.DESCENDING)
{
return(p => p.OrderByDescending(newExpression));
}
else
{
return(p => p.OrderBy(newExpression));
}
}
}
if (modelPager.SortOrder == SortOrder.DESCENDING)
{
return(p => p.OrderByDescending(orderExpression));
}
else
{
return(p => p.OrderBy(orderExpression));
}
}
protected override void Because_of()
{
_destination = Mapper.Map <ModelPager <int> >(new Pager <int>(_items));
}
public Result <SecurityUserDto> GetUsers(string searchText, ModelPager modelPager)
{
return(_ISecurityUserManager.GetUsers(searchText, modelPager));
}
public Result <PatientConsultationDto> GetPatientConsultations(int patientId, string searchText, ModelPager modelPager)
{
Result <PatientConsultationDto> response = new Result <PatientConsultationDto>();
using (UnitOfWork unitOfWork = new UnitOfWork())
{
Expression <Func <PatientConsultation, bool> > searchFilter = p => p.PatientId == patientId;
response.Total = unitOfWork.PatientConsultationRepository.CountEntities(searchFilter);
response.Models = unitOfWork.PatientConsultationRepository.GetPagedEntities(searchFilter, o => o.StartDate, modelPager)
.Select(item => _PatientConsultationMapper.MapToPatientConsultationDto(item)).ToList <PatientConsultationDto>();
}
return(response);
}
public Result <PatientDto> Search(PatientDto searchPatient, ModelPager modelPager)
{
return(_IPatientManager.Search(searchPatient, modelPager));
}
