public async Task <ActionResult <JObject> > GetList(
[FromBody] RequestPaging request)
{
var parsed = HttpUtility.ParseQueryString(request.Query ?? "");
bool isLevel = int.TryParse(parsed.Get("level"), out int level);
bool isType = int.TryParse(parsed.Get("pageType"), out int pageType);
ParseRequestPagingDate(request);
Expression <Func <MixPage, bool> > predicate = model =>
model.Specificulture == _lang &&
(!request.Status.HasValue || model.Status == request.Status.Value) &&
(!isLevel || model.Level == level) &&
(!isType || model.Type == pageType) &&
(string.IsNullOrWhiteSpace(request.Keyword) ||
(EF.Functions.Like(model.Title, $"%{request.Keyword}%")) ||
(EF.Functions.Like(model.Excerpt, $"%{request.Keyword}%"))
) &&
(!request.FromDate.HasValue ||
(model.CreatedDateTime >= request.FromDate.Value)
) &&
(!request.ToDate.HasValue ||
(model.CreatedDateTime <= request.ToDate.Value)
);
switch (request.Key)
{
case "mvc":
var mvcResult = await base.GetListAsync <ReadMvcViewModel>(request, predicate);
if (mvcResult.IsSucceed)
{
mvcResult.Data.Items.ForEach(a =>
{
a.DetailsUrl = MixCmsHelper.GetRouterUrl(
new { action = "page", culture = _lang, seoName = a.SeoName }, Request, Url);
});
}
return(Ok(JObject.FromObject(mvcResult)));
case "portal":
var portalResult = await base.GetListAsync <UpdateViewModel>(request, predicate);
if (portalResult.IsSucceed)
{
portalResult.Data.Items.ForEach(a =>
{
a.DetailsUrl = MixCmsHelper.GetRouterUrl(
new { action = "page", culture = _lang, seoName = a.SeoName }, Request, Url);
});
}
return(Ok(JObject.FromObject(portalResult)));
default:
var listItemResult = await base.GetListAsync <ReadListItemViewModel>(request, predicate);
if (listItemResult.IsSucceed)
{
listItemResult.Data.Items.ForEach((Action <ReadListItemViewModel>)(a =>
{
a.DetailsUrl = MixCmsHelper.GetRouterUrl(
new { action = "page", culture = _lang, seoName = a.SeoName }, Request, Url);
a.Childs.ForEach((Action <Lib.ViewModels.MixPagePages.ReadViewModel>)(c =>
{
c.Page.DetailsUrl = MixCmsHelper.GetRouterUrl(
new { action = "page", culture = _lang, seoName = c.Page.SeoName }, Request, Url);
}));
}));
}
return(JObject.FromObject(listItemResult));
}
}
protected QueryString ParseQuery(RequestPaging request)
{
return(new QueryString(request.Query));
}
public async Task <RepositoryResponse <PaginationModel <InfoModuleViewModel> > > GetList(RequestPaging request)
{
if (string.IsNullOrEmpty(request.Keyword))
{
var data = await InfoModuleViewModel.Repository.GetModelListByAsync(m => m.Specificulture == _lang, request.OrderBy, request.Direction, request.PageSize, request.PageIndex).ConfigureAwait(false);
string domain = string.Format("{0}://{1}", Request.Scheme, Request.Host);
return(data);
}
else
{
Expression <Func <SiocModule, bool> > predicate = model =>
model.Specificulture == _lang &&
(string.IsNullOrWhiteSpace(request.Keyword) ||
(model.Title.Contains(request.Keyword) ||
model.Description.Contains(request.Keyword)));
return(await InfoModuleViewModel.Repository.GetModelListByAsync(predicate, request.OrderBy, request.Direction, request.PageSize, request.PageIndex).ConfigureAwait(false));
}
}
public async Task <RepositoryResponse <PaginationModel <UserInfoViewModel> > > GetList(RequestPaging request)
{
Expression <Func <MixCmsUser, bool> > predicate = model =>
(!request.Status.HasValue || model.Status == request.Status.Value) &&
(string.IsNullOrWhiteSpace(request.Keyword) ||
(
model.Username.Contains(request.Keyword) ||
model.FirstName.Contains(request.Keyword) ||
model.LastName.Contains(request.Keyword)
)
) &&
(!request.FromDate.HasValue ||
(model.CreatedDateTime >= request.FromDate.Value.ToUniversalTime())
) &&
(!request.ToDate.HasValue ||
(model.CreatedDateTime <= request.ToDate.Value.ToUniversalTime())
);
var data = await UserInfoViewModel.Repository.GetModelListByAsync(predicate, request.OrderBy, request.Direction, request.PageSize, request.PageIndex).ConfigureAwait(false);
if (data.IsSucceed)
{
data.Data.Items.ForEach(a =>
{
a.DetailsUrl = MixCmsHelper.GetRouterUrl(
"Profile", new { a.Id }, Request, Url);
}
);
}
return(data);
}
public static async Task <RepositoryResponse <PaginationModel <TView> > > FilterByKeywordAsync <TView>(string culture, string attributeSetName
, RequestPaging request, string keyword
, Dictionary <string, Microsoft.Extensions.Primitives.StringValues> queryDictionary = null
, MixCmsContext _context = null, IDbContextTransaction _transaction = null)
where TView : ViewModelBase <MixCmsContext, MixAttributeSetData, TView>
{
UnitOfWorkHelper <MixCmsContext> .InitTransaction(_context, _transaction, out MixCmsContext context, out IDbContextTransaction transaction, out bool isRoot);
try
{
Expression <Func <MixAttributeSetValue, bool> > attrPredicate =
m => m.Specificulture == culture && m.AttributeSetName == attributeSetName &&
(!request.FromDate.HasValue ||
(m.CreatedDateTime >= request.FromDate.Value)
) &&
(!request.ToDate.HasValue ||
(m.CreatedDateTime <= request.ToDate.Value)
)
;
Expression <Func <MixAttributeSetValue, bool> > valPredicate = null;
RepositoryResponse <PaginationModel <TView> > result = new RepositoryResponse <PaginationModel <TView> >()
{
IsSucceed = true,
Data = new PaginationModel <TView>()
};
var filterType = queryDictionary.FirstOrDefault(q => q.Key == "filterType");
var tasks = new List <Task <RepositoryResponse <TView> > >();
if (queryDictionary != null)
{
foreach (var q in queryDictionary)
{
if (!string.IsNullOrEmpty(q.Key) && q.Key != "attributeSetId" && q.Key != "attributeSetName" && q.Key != "filterType" && !string.IsNullOrEmpty(q.Value))
{
if (!string.IsNullOrEmpty(filterType.Value) && filterType.Value == "equal")
{
Expression <Func <MixAttributeSetValue, bool> > pre = m =>
m.AttributeFieldName == q.Key && m.StringValue == (q.Value.ToString());
if (valPredicate != null)
{
valPredicate = ReflectionHelper.CombineExpression(valPredicate, pre, Heart.Enums.MixHeartEnums.ExpressionMethod.And);
}
else
{
valPredicate = pre;
}
}
else
{
Expression <Func <MixAttributeSetValue, bool> > pre =
m => m.AttributeFieldName == q.Key &&
(EF.Functions.Like(m.StringValue, $"%{q.Value.ToString()}%"));
if (valPredicate != null)
{
valPredicate = ReflectionHelper.CombineExpression(valPredicate, pre, Heart.Enums.MixHeartEnums.ExpressionMethod.And);
}
else
{
valPredicate = pre;
}
}
}
}
if (valPredicate != null)
{
attrPredicate = ReflectionHelper.CombineExpression(valPredicate, attrPredicate, Heart.Enums.MixHeartEnums.ExpressionMethod.And);
}
}
// Loop queries string => predicate
if (!string.IsNullOrEmpty(keyword))
{
Expression <Func <MixAttributeSetValue, bool> > pre = m => m.AttributeSetName == attributeSetName && m.Specificulture == culture && m.StringValue.Contains(keyword);
attrPredicate = ReflectionHelper.CombineExpression(attrPredicate, pre, Heart.Enums.MixHeartEnums.ExpressionMethod.And);
}
var query = context.MixAttributeSetValue.Where(attrPredicate).Select(m => m.DataId).Distinct();
var dataIds = query.ToList();
if (query != null)
{
Expression <Func <MixAttributeSetData, bool> > predicate = m => dataIds.Any(id => m.Id == id);
result = await DefaultRepository <MixCmsContext, MixAttributeSetData, TView> .Instance.GetModelListByAsync(
predicate, request.OrderBy, request.Direction, request.PageSize, request.PageIndex, null, null, context, transaction);
}
return(result);
}
catch (Exception ex)
{
return(UnitOfWorkHelper <MixCmsContext> .HandleException <PaginationModel <TView> >(ex, isRoot, transaction));
}
finally
{
if (isRoot)
{
//if current Context is Root
context.Database.CloseConnection(); transaction.Dispose(); context.Dispose();
}
}
}
public async Task <RepositoryResponse <PaginationModel <InfoCategoryViewModel> > > GetList(RequestPaging request)
{
string domain = string.Format("{0}://{1}", Request.Scheme, Request.Host);
if (string.IsNullOrEmpty(request.Keyword))
{
var data = await InfoCategoryViewModel.Repository.GetModelListByAsync(
m => m.Status != (int)SWStatus.Deleted && m.Specificulture == _lang, request.OrderBy, request.Direction, request.PageSize, request.PageIndex).ConfigureAwait(false);
if (data.IsSucceed)
{
data.Data.Items.ForEach(a =>
{
a.DetailsUrl = SWCmsHelper.GetRouterUrl(
"Page", new { a.SeoName }, Request, Url);
a.Domain = domain;
}
);
}
return(data);
}
else
{
Expression <Func <SiocCategory, bool> > predicate = model =>
model.Specificulture == _lang &&
(string.IsNullOrWhiteSpace(request.Keyword) ||
(model.Title.Contains(request.Keyword) ||
model.Excerpt.Contains(request.Keyword)));
var data = await InfoCategoryViewModel.Repository.GetModelListByAsync(predicate, request.OrderBy, request.Direction, request.PageSize, request.PageIndex).ConfigureAwait(false);
if (data.IsSucceed)
{
data.Data.Items.ForEach(a =>
{
a.DetailsUrl = SWCmsHelper.GetRouterUrl(
"Page", new { a.SeoName }, Request, Url);
a.Domain = domain;
}
);
}
return(data);
}
}
public object GetUserAnswerList(RequestPaging request)
{
IList <FilterModel> filterlist = null;
string nickname = null;
string title = null;
int type = -1;
//IList<SortModel> sortlist = null;
if (!string.IsNullOrEmpty(request.Filter))
{
filterlist = Newtonsoft.Json.JsonConvert.DeserializeObject <IList <FilterModel> >(request.Filter);
}
//if(!string.IsNullOrEmpty(request.Sort))
//{
// sortlist = Newtonsoft.Json.JsonConvert.DeserializeObject<IList<SortModel>>(request.Sort);
//}
if (filterlist != null)
{
var useridFilter = filterlist.FirstOrDefault(x => string.Equals(x.Property.ToLower(), "nickname"));
if (useridFilter != null)
{
nickname = useridFilter.Value.ToStringN();
}
var titleFilter = filterlist.FirstOrDefault(x => string.Equals(x.Property.ToLower(), "title"));
if (titleFilter != null)
{
title = titleFilter.Value.ToStringN();
}
var typeFilter = filterlist.FirstOrDefault(x => string.Equals(x.Property.ToLower(), "type"));
if (typeFilter != null)
{
type = typeFilter.Value.ToInt();
}
}
var table = _userAnswerService.QueryByPaged(nickname, title, type, request.Page - 1, request.Limit);
var result = table.Select(x =>
{
return(new UserAnswerViewModel()
{
id = x.Id,
begintime = x.BeginTime,
completedtime = x.CompletedTime,
nickname = x.User.NickName,
user_id = x.User_Id,
questionbank_id = x.QuestionBank_Id,
questionbanktype = x.QuestionBank.Type,
questionbank = x.QuestionBank.Title,
status = x.UserAnswerStatus.ToString()
});
}).ToList();
return(new
{
total = table.TotalCount,
data = result
});
}
public async Task <RepositoryResponse <PaginationModel <ApiCustomerViewModel> > > GetList([FromBody] RequestPaging request)
{
ParseRequestPagingDate(request);
Expression <Func <SiocCustomer, bool> > predicate = model =>
(string.IsNullOrWhiteSpace(request.Keyword) ||
(model.FullName.Contains(request.Keyword) ||
model.FirstName.Contains(request.Keyword) ||
model.LastName.Contains(request.Keyword) ||
model.PhoneNumber.Contains(request.Keyword) ||
model.Email.Contains(request.Keyword)));
var data = await ApiCustomerViewModel.Repository.GetModelListByAsync(predicate, request.OrderBy, request.Direction, request.PageSize, request.PageIndex).ConfigureAwait(false);
return(data);
}
public async Task <RepositoryResponse <PaginationModel <ApiLanguageViewModel> > > GetList([FromBody] RequestPaging request)
{
ParseRequestPagingDate(request);
Expression <Func <SiocLanguage, bool> > predicate = model =>
model.Specificulture == _lang &&
(string.IsNullOrWhiteSpace(request.Keyword) ||
(model.Description.Contains(request.Keyword) ||
model.Value.Contains(request.Keyword) ||
model.Keyword.Contains(request.Keyword)));
var data = await ApiLanguageViewModel.Repository.GetModelListByAsync(predicate, request.OrderBy, request.Direction, request.PageSize, request.PageIndex).ConfigureAwait(false);
return(data);
}
public PolicyRemarkSearchRequest()
{
Paging = new RequestPaging();
}
public async Task <RepositoryResponse <PaginationModel <BEMediaViewModel> > > GetList(RequestPaging request)
{
if (string.IsNullOrEmpty(request.Keyword))
{
var data = await BEMediaViewModel.Repository.GetModelListByAsync(
m => m.Specificulture == _lang, request.OrderBy, request.Direction, request.PageSize, request.PageIndex).ConfigureAwait(false);
return(data);
}
else
{
Expression <Func <SiocMedia, bool> > predicate = model =>
model.Specificulture == _lang &&
(string.IsNullOrWhiteSpace(request.Keyword) ||
(model.FileName.Contains(request.Keyword) ||
model.Title.Contains(request.Keyword) ||
model.Description.Contains(request.Keyword)));
var data = await BEMediaViewModel.Repository.GetModelListByAsync(predicate, request.OrderBy, request.Direction, request.PageSize, request.PageIndex).ConfigureAwait(false);
return(data);
}
}
public async Task <RepositoryResponse <PaginationModel <InfoConfigurationViewModel> > > GetList([FromBody] RequestPaging request)
{
ParseRequestPagingDate(request);
string[] cates = { "Site", "System" };
Expression <Func <SiocConfiguration, bool> > predicate = model =>
model.Specificulture == _lang &&
(!request.Status.HasValue || model.Category == cates[request.Status.Value]) &&
(string.IsNullOrWhiteSpace(request.Keyword) ||
(model.Description.Contains(request.Keyword) ||
model.Value.Contains(request.Keyword) ||
model.Keyword.Contains(request.Keyword)));
var data = await InfoConfigurationViewModel.Repository.GetModelListByAsync(predicate, request.OrderBy, request.Direction, request.PageSize, request.PageIndex).ConfigureAwait(false);
return(data);
}
public async Task <RepositoryResponse <PaginationModel <InfoModuleViewModel> > > GetList([FromBody] RequestPaging request, int?level = 0)
{
string domain = string.Format("{0}://{1}", Request.Scheme, Request.Host);
Expression <Func <SiocModule, bool> > predicate = model =>
model.Specificulture == _lang &&
(string.IsNullOrWhiteSpace(request.Keyword) ||
(model.Title.Contains(request.Keyword) ||
model.Description.Contains(request.Keyword))) &&
(!request.FromDate.HasValue ||
(model.LastModified >= request.FromDate.Value.ToUniversalTime())
) &&
(!request.ToDate.HasValue ||
(model.LastModified <= request.ToDate.Value.ToUniversalTime())
)
;
var data = await InfoModuleViewModel.Repository.GetModelListByAsync(predicate, request.OrderBy, request.Direction, request.PageSize, request.PageIndex).ConfigureAwait(false);
//if (data.IsSucceed)
//{
// data.Data.Items.ForEach(a =>
// {
// a.DetailsUrl = SwCmsHelper.GetRouterUrl(
// "Page", new { a.SeoName }, Request, Url);
// a.Childs.ForEach(c =>
// {
// c.DetailsUrl = SwCmsHelper.GetRouterUrl(
// "Page", new { c.SeoName }, Request, Url);
// }
// );
// }
// );
//}
return(data);
}
public async Task <RepositoryResponse <PaginationModel <InfoThemeViewModel> > > GetList([FromBody] RequestPaging request, int?level = 0)
{
ParseRequestPagingDate(request);
Expression <Func <SiocTheme, bool> > predicate = model =>
string.IsNullOrWhiteSpace(request.Keyword) ||
(model.Name.Contains(request.Keyword)
) &&
(!request.FromDate.HasValue ||
(model.CreatedDateTime >= request.FromDate.Value)
) &&
(!request.ToDate.HasValue ||
(model.CreatedDateTime <= request.ToDate.Value)
)
;
var data = await InfoThemeViewModel.Repository.GetModelListByAsync(
predicate, request.OrderBy, request.Direction,
request.PageSize, request.PageIndex).ConfigureAwait(false);
return(data);
}
public async Task <ActionResult <JObject> > GetList(
[FromBody] RequestPaging request)
{
var parsed = HttpUtility.ParseQueryString(request.Query ?? "");
bool isLevel = int.TryParse(parsed.Get("level"), out int level);
ParseRequestPagingDate(request);
Expression <Func <MixOrder, bool> > predicate = model =>
model.Specificulture == _lang &&
(!request.Status.HasValue || model.Status == request.Status.Value) &&
(string.IsNullOrWhiteSpace(request.Keyword)
) &&
(!request.FromDate.HasValue ||
(model.CreatedDateTime >= request.FromDate.Value)
) &&
(!request.ToDate.HasValue ||
(model.CreatedDateTime <= request.ToDate.Value)
);
switch (request.Key)
{
case "mvc":
var mvcResult = await base.GetListAsync <ReadViewModel>(request, predicate);
if (mvcResult.IsSucceed)
{
mvcResult.Data.Items.ForEach(a =>
{
a.DetailsUrl = MixCmsHelper.GetRouterUrl(
new { culture = _lang, action = "order", seoName = a.Id }, Request, Url);
});
}
return(Ok(JObject.FromObject(mvcResult)));
case "portal":
var portalResult = await base.GetListAsync <UpdateViewModel>(request, predicate);
if (portalResult.IsSucceed)
{
portalResult.Data.Items.ForEach(a =>
{
a.DetailsUrl = MixCmsHelper.GetRouterUrl(
new { culture = _lang, action = "order", seoName = a.Id }, Request, Url);
});
}
return(Ok(JObject.FromObject(portalResult)));
default:
var listItemResult = await base.GetListAsync <ReadListItemViewModel>(request, predicate);
if (listItemResult.IsSucceed)
{
listItemResult.Data.Items.ForEach((Action <ReadListItemViewModel>)(a =>
{
a.DetailsUrl = MixCmsHelper.GetRouterUrl(
new { culture = _lang, action = "order", seoName = a.Id }, Request, Url);
}));
}
return(JObject.FromObject(listItemResult));
}
}
public async Task <JObject> GetList(
[FromBody] RequestPaging request, int?level = 0)
{
ParseRequestPagingDate(request);
Expression <Func <SiocCategory, bool> > predicate = model =>
model.Specificulture == _lang &&
(!level.HasValue || model.Level == level) &&
(string.IsNullOrWhiteSpace(request.Keyword) ||
(model.Title.Contains(request.Keyword) ||
model.Excerpt.Contains(request.Keyword))) &&
(!request.FromDate.HasValue ||
(model.CreatedDateTime >= request.FromDate.Value)
) &&
(!request.ToDate.HasValue ||
(model.CreatedDateTime <= request.ToDate.Value)
);
switch (request.Key)
{
case "fe":
var fedata = await FECategoryViewModel.Repository.GetModelListByAsync(predicate, request.OrderBy, request.Direction, request.PageSize, request.PageIndex).ConfigureAwait(false);
if (fedata.IsSucceed)
{
fedata.Data.Items.ForEach(a =>
{
a.DetailsUrl = SwCmsHelper.GetRouterUrl(
"Alias", new { seoName = a.UrlAlias.Alias }, Request, Url);
});
}
return(JObject.FromObject(fedata));
case "be":
var bedata = await ApiCategoryViewModel.Repository.GetModelListByAsync(predicate, request.OrderBy, request.Direction, request.PageSize, request.PageIndex).ConfigureAwait(false);
if (bedata.IsSucceed)
{
bedata.Data.Items.ForEach(a =>
{
a.DetailsUrl = SwCmsHelper.GetRouterUrl(
"Alias", new { seoName = a.UrlAlias.Alias }, Request, Url);
});
}
return(JObject.FromObject(bedata));
default:
var data = await InfoCategoryViewModel.Repository.GetModelListByAsync(predicate, request.OrderBy, request.Direction, request.PageSize, request.PageIndex).ConfigureAwait(false);
if (data.IsSucceed)
{
data.Data.Items.ForEach((Action <InfoCategoryViewModel>)(a =>
{
a.DetailsUrl = SwCmsHelper.GetRouterUrl(
"Alias", new { seoName = a.UrlAlias.Alias }, Request, Url);
a.Childs.ForEach((Action <InfoCategoryViewModel>)(c =>
{
c.DetailsUrl = SwCmsHelper.GetRouterUrl(
"Alias", new { seoName = c.UrlAlias.Alias }, Request, Url);
}));
}));
}
return(JObject.FromObject(data));
}
}
public async Task <RepositoryResponse <PaginationModel <NavRelatedProductViewModel> > > GetList(RequestPaging request)
{
if (string.IsNullOrEmpty(request.Keyword))
{
var data = await NavRelatedProductViewModel.Repository.GetModelListByAsync(
m => m.Specificulture == _lang, request.OrderBy, request.Direction, request.PageSize, request.PageIndex).ConfigureAwait(false);
return(data);
}
else
{
Expression <Func <SiocRelatedProduct, bool> > predicate = model =>
model.Specificulture == _lang &&
(string.IsNullOrWhiteSpace(request.Keyword));
var data = await NavRelatedProductViewModel.Repository.GetModelListByAsync(predicate, request.OrderBy, request.Direction, request.PageSize, request.PageIndex).ConfigureAwait(false);
return(data);
}
}
public async Task <ActionResult <JObject> > GetList(
[FromBody] RequestPaging request)
{
var query = HttpUtility.ParseQueryString(request.Query ?? "");
bool isPage = int.TryParse(query.Get("page_id"), out int pageId);
bool isNotPage = int.TryParse(query.Get("not_page_id"), out int notPageId);
bool isModule = int.TryParse(query.Get("module_id"), out int moduleId);
ParseRequestPagingDate(request);
Expression <Func <SioArticle, bool> > predicate = model =>
model.Specificulture == _lang &&
(!request.Status.HasValue || model.Status == request.Status.Value) &&
(!isPage || model.SioPageArticle.Any(nav => nav.CategoryId == pageId && nav.ArticleId == model.Id && nav.Specificulture == _lang)) &&
(!isNotPage || !model.SioPageArticle.Any(nav => nav.CategoryId == notPageId && nav.ArticleId == model.Id && nav.Specificulture == _lang)) &&
(!isModule || model.SioModuleArticle.Any(nav => nav.ModuleId == moduleId && nav.ArticleId == model.Id)) &&
(string.IsNullOrWhiteSpace(request.Keyword) ||
(model.Title.Contains(request.Keyword) ||
model.Excerpt.Contains(request.Keyword))) &&
(!request.FromDate.HasValue ||
(model.CreatedDateTime >= request.FromDate.Value)
) &&
(!request.ToDate.HasValue ||
(model.CreatedDateTime <= request.ToDate.Value)
);
string key = $"{request.Key}_{request.Query}_{request.PageSize}_{request.PageIndex}";
switch (request.Key)
{
case "mvc":
var mvcResult = await base.GetListAsync <ReadMvcViewModel>(key, request, predicate);
if (mvcResult.IsSucceed)
{
mvcResult.Data.Items.ForEach(a =>
{
a.DetailsUrl = SioCmsHelper.GetRouterUrl(
"article", new { seoName = a.SeoName }, Request, Url);
});
}
return(Ok(JObject.FromObject(mvcResult)));
case "portal":
var portalResult = await base.GetListAsync <UpdateViewModel>(key, request, predicate);
if (portalResult.IsSucceed)
{
portalResult.Data.Items.ForEach(a =>
{
a.DetailsUrl = SioCmsHelper.GetRouterUrl(
"article", new { seoName = a.SeoName }, Request, Url);
});
}
return(Ok(JObject.FromObject(portalResult)));
default:
var listItemResult = await base.GetListAsync <ReadListItemViewModel>(key, request, predicate);
if (listItemResult.IsSucceed)
{
listItemResult.Data.Items.ForEach((Action <ReadListItemViewModel>)(a =>
{
a.DetailsUrl = SioCmsHelper.GetRouterUrl(
"article", new { seoName = a.SeoName }, Request, Url);
}));
}
return(JObject.FromObject(listItemResult));
}
}
public async Task <RepositoryResponse <PaginationModel <BETemplateViewModel> > > GetList(RequestPaging request)
{
string domain = string.Format("{0}://{1}", Request.Scheme, Request.Host);
int.TryParse(request.Key, out int themeId);
Expression <Func <SiocTemplate, bool> > predicate = model =>
model.TemplateId == themeId &&
(string.IsNullOrWhiteSpace(request.Keyword)
||
(
model.FileName.Contains(request.Keyword) ||
model.FileFolder.Contains(request.Keyword) ||
model.FolderType == request.Keyword
));
var data = await BETemplateViewModel.Repository.GetModelListByAsync(predicate, request.OrderBy, request.Direction, request.PageSize, request.PageIndex).ConfigureAwait(false);
return(data);
}
public async Task <ActionResult <JObject> > GetList(
[FromBody] RequestPaging request)
{
var queryDictionary = Microsoft.AspNetCore.WebUtilities.QueryHelpers.ParseQuery(request.Query);
var queries = HttpUtility.ParseQueryString(request.Query ?? "");
int.TryParse(queries.Get("attributeSetId"), out int attributeSetId);
string attributeSetName = queries.Get("attributeSetName");
ParseRequestPagingDate(request);
switch (request.Key)
{
case "portal":
if (!string.IsNullOrEmpty(request.Query))
{
var portalResult = await Helper.FilterByKeywordAsync <MobileViewModel>(_lang, attributeSetName,
request, request.Keyword, queryDictionary);
return(Ok(JObject.FromObject(portalResult)));
}
else
{
Expression <Func <MixAttributeSetData, bool> > predicate = m => (m.AttributeSetId == attributeSetId || m.AttributeSetName == attributeSetName) && m.Specificulture == _lang;
var portalResult = await base.GetListAsync <UpdateViewModel>(request, predicate);
return(Ok(JObject.FromObject(portalResult)));
}
case "readData":
if (!string.IsNullOrEmpty(request.Query))
{
var portalResult = await Helper.FilterByKeywordAsync <ReadDataViewModel>(_lang, attributeSetName,
request, request.Keyword, queryDictionary);
return(Ok(JObject.FromObject(portalResult)));
}
else
{
Expression <Func <MixAttributeSetData, bool> > predicate = m => (m.AttributeSetId == attributeSetId || m.AttributeSetName == attributeSetName) && m.Specificulture == _lang;
var portalResult = await base.GetListAsync <ReadDataViewModel>(request, predicate);
return(Ok(JObject.FromObject(portalResult)));
}
case "data":
if (!string.IsNullOrEmpty(request.Query))
{
var result = await Helper.FilterByKeywordAsync <ReadDataViewModel>(_lang, attributeSetName,
request, request.Keyword, queryDictionary);
var parsed = new PaginationModel <JObject>()
{
Items = new List <JObject>(),
TotalItems = result.Data.TotalItems,
TotalPage = result.Data.TotalPage,
PageIndex = result.Data.PageIndex,
PageSize = result.Data.PageSize
};
foreach (var item in result.Data.Items)
{
parsed.Items.Add(item.Data);
}
return(Ok(JObject.FromObject(new RepositoryResponse <PaginationModel <JObject> >()
{
IsSucceed = result.IsSucceed,
Data = parsed,
Errors = result.Errors,
Exception = result.Exception
})));
}
else
{
Expression <Func <MixAttributeSetData, bool> > predicate = m => (m.AttributeSetId == attributeSetId || m.AttributeSetName == attributeSetName) && m.Specificulture == _lang;
var portalResult = await base.GetListAsync <ReadDataViewModel>(request, predicate);
return(Ok(JObject.FromObject(portalResult)));
}
default:
if (!string.IsNullOrEmpty(request.Query))
{
var portalResult = await Helper.FilterByKeywordAsync <ReadViewModel>(_lang, attributeSetName,
request, request.Keyword, queryDictionary);
return(Ok(JObject.FromObject(portalResult)));
}
else
{
Expression <Func <MixAttributeSetData, bool> > predicate = m => (m.AttributeSetId == attributeSetId || m.AttributeSetName == attributeSetName) && m.Specificulture == _lang;
var portalResult = await base.GetListAsync <ReadViewModel>(request, predicate);
return(Ok(JObject.FromObject(portalResult)));
}
}
}
protected async Task <List <TView> > GetListAsync <TView>(ODataQueryOptions <TModel> queryOptions)
where TView : ViewModelBase <TDbContext, TModel, TView>
{
Expression <Func <TModel, bool> > predicate = null;
if (queryOptions.Filter != null)
{
ODataHelper <TModel> .ParseFilter(queryOptions.Filter.FilterClause.Expression, ref predicate);
}
int? top = queryOptions.Top?.Value;
var skip = queryOptions.Skip?.Value ?? 0;
RequestPaging request = new RequestPaging()
{
PageIndex = 0,
PageSize = top.HasValue ? top + top * (skip / top + 1) : null,
OrderBy = queryOptions.OrderBy?.RawValue
//Top = queryOptions.Top?.Value,
//Skip = queryOptions.Skip?.Value
};
var cacheKey = $"odata_{_lang}_{typeof(TView).FullName}_{SeoHelper.GetSEOString(queryOptions.Filter?.RawValue, '_')}_ps-{request.PageSize}";
List <TView> data = null;
if (MixService.GetConfig <bool>("IsCache"))
{
var getData = await MixCacheService.GetAsync <RepositoryResponse <PaginationModel <TView> > >(cacheKey);
if (getData != null)
{
data = getData.Data.Items;
}
}
if (data == null)
{
if (predicate != null)
{
var getData = await DefaultRepository <TDbContext, TModel, TView> .Instance.GetModelListByAsync(predicate,
request.OrderBy, request.Direction, request.PageSize, request.PageIndex, request.Skip, request.Top).ConfigureAwait(false);
if (getData.IsSucceed)
{
await MixCacheService.SetAsync(cacheKey, getData);
data = getData.Data.Items;
}
}
else
{
var getData = await DefaultRepository <TDbContext, TModel, TView> .Instance.GetModelListAsync(
request.OrderBy, request.Direction, request.PageSize, request.PageIndex
, null, null).ConfigureAwait(false);
if (getData.IsSucceed)
{
await MixCacheService.SetAsync(cacheKey, getData);
data = getData.Data.Items;
}
}
}
return(data);
}
public async Task <RepositoryResponse <PaginationModel <InfoModuleViewModel> > > GetList([FromBody] RequestPaging request, int?level = 0)
{
Expression <Func <SiocModule, bool> > predicate = model =>
model.Specificulture == _lang &&
(string.IsNullOrWhiteSpace(request.Keyword) ||
(model.Title.Contains(request.Keyword) ||
model.Description.Contains(request.Keyword))) &&
(!request.FromDate.HasValue ||
(model.LastModified >= request.FromDate.Value.ToUniversalTime())
) &&
(!request.ToDate.HasValue ||
(model.LastModified <= request.ToDate.Value.ToUniversalTime())
)
;
var data = await InfoModuleViewModel.Repository.GetModelListByAsync(predicate, request.OrderBy, request.Direction, request.PageSize, request.PageIndex).ConfigureAwait(false);
return(data);
}
public async Task <RepositoryResponse <PaginationModel <InfoProductViewModel> > > GetList([FromBody] RequestPaging request)
{
string domain = string.Format("{0}://{1}", Request.Scheme, Request.Host);
Expression <Func <SiocProduct, bool> > predicate = model =>
model.Specificulture == _lang &&
(!request.Status.HasValue || model.Status == (int)request.Status.Value) &&
(string.IsNullOrWhiteSpace(request.Keyword) ||
(
model.Title.Contains(request.Keyword)
|| model.Excerpt.Contains(request.Keyword) ||
model.Code.Contains(request.Keyword)
)
) &&
(!request.FromDate.HasValue ||
(model.CreatedDateTime >= request.FromDate.Value.ToUniversalTime())
) &&
(!request.ToDate.HasValue ||
(model.CreatedDateTime <= request.ToDate.Value.ToUniversalTime())
);
var data = await InfoProductViewModel.Repository.GetModelListByAsync(predicate, request.OrderBy, request.Direction, request.PageSize, request.PageIndex).ConfigureAwait(false);
if (data.IsSucceed)
{
data.Data.Items.ForEach(a =>
{
a.DetailsUrl = SwCmsHelper.GetRouterUrl(
"Product", new { a.SeoName }, Request, Url);
});
}
return(data);
}
protected async Task <RepositoryResponse <PaginationModel <TView> > > GetListAsync <TView>(string key, RequestPaging request, Expression <Func <TModel, bool> > predicate = null, TModel model = null)
where TView : ViewModelBase <TDbContext, TModel, TView>
{
var getData = new RepositoryResponse <Lib.ViewModels.SioPages.ReadMvcViewModel>();
var cacheKey = $"{typeof(TModel).Name}_list_{_lang}_{key}_{request.Status}_{request.Keyword}_{request.OrderBy}_{request.Direction}_{request.PageSize}_{request.PageIndex}";
var data = _memoryCache.Get <RepositoryResponse <PaginationModel <TView> > >(cacheKey);
if (data == null)
{
if (predicate != null)
{
data = await DefaultRepository <TDbContext, TModel, TView> .Instance.GetModelListByAsync(predicate, request.OrderBy, request.Direction, request.PageSize, request.PageIndex).ConfigureAwait(false);
_memoryCache.Set(cacheKey, data);
}
else
{
data = await DefaultRepository <TDbContext, TModel, TView> .Instance.GetModelListAsync(request.OrderBy, request.Direction, request.PageSize, request.PageIndex).ConfigureAwait(false);
_memoryCache.Set(cacheKey, data);
}
if (!SioConstants.cachedKeys.Contains(cacheKey))
{
SioConstants.cachedKeys.Add(cacheKey);
}
AlertAsync("Add Cache", 200, cacheKey);
}
data.LastUpdateConfiguration = SioService.GetConfig <DateTime?>("LastUpdateConfiguration");
//AlertAsync("Get List Page", 200, $"Get {request.Key} list page");
return(data);
}
protected async Task <RepositoryResponse <PaginationModel <TView> > > GetListAsync <TView>(RequestPaging request, Expression <Func <TModel, bool> > predicate = null, TModel model = null)
where TView : ViewModelBase <TDbContext, TModel, TView>
{
RepositoryResponse <PaginationModel <TView> > data = null;
if (data == null)
{
if (predicate != null)
{
data = await DefaultRepository <TDbContext, TModel, TView> .Instance.GetModelListByAsync(
predicate, request.OrderBy, request.Direction, request.PageSize, request.PageIndex, null, null);
}
else
{
data = await DefaultRepository <TDbContext, TModel, TView> .Instance.GetModelListAsync(request.OrderBy, request.Direction, request.PageSize, request.PageIndex, null, null).ConfigureAwait(false);
}
}
data.LastUpdateConfiguration = MixService.GetConfig <DateTime?>("LastUpdateConfiguration");
AlertAsync($"Get List {typeof(TView).Name}", data?.Status ?? 400, data?.ResponseKey);
return(data);
}
public async Task <RepositoryResponse <PaginationModel <BEMediaViewModel> > > GetList([FromBody] RequestPaging request)
{
ParseRequestPagingDate(request);
Expression <Func <SiocMedia, bool> > predicate = model =>
model.Specificulture == _lang &&
(string.IsNullOrWhiteSpace(request.Keyword) ||
(model.FileName.Contains(request.Keyword) ||
model.Title.Contains(request.Keyword) ||
model.Description.Contains(request.Keyword))) &&
(!request.FromDate.HasValue ||
(model.CreatedDateTime >= request.FromDate.Value)
) &&
(!request.ToDate.HasValue ||
(model.CreatedDateTime <= request.ToDate.Value)
);
var data = await BEMediaViewModel.Repository.GetModelListByAsync(predicate, request.OrderBy, request.Direction, request.PageSize, request.PageIndex).ConfigureAwait(false);
return(data);
}
public async Task <JObject> GetList([FromBody] RequestPaging request)
{
ParseRequestPagingDate(request);
Expression <Func <SiocProduct, bool> > predicate = model =>
model.Specificulture == _lang &&
(!request.Status.HasValue || model.Status == (int)request.Status.Value) &&
(string.IsNullOrWhiteSpace(request.Keyword) ||
(
model.Title.Contains(request.Keyword)
|| model.Excerpt.Contains(request.Keyword) ||
model.Code.Contains(request.Keyword)
)
) &&
(!request.FromDate.HasValue ||
(model.CreatedDateTime >= request.FromDate.Value)
) &&
(!request.ToDate.HasValue ||
(model.CreatedDateTime <= request.ToDate.Value)
);
switch (request.Key)
{
case "fe":
var fedata = await FEProductViewModel.Repository.GetModelListByAsync(predicate, request.OrderBy, request.Direction, request.PageSize, request.PageIndex).ConfigureAwait(false);
if (fedata.IsSucceed)
{
fedata.Data.Items.ForEach(a =>
{
a.DetailsUrl = SwCmsHelper.GetRouterUrl(
"Product", new { a.SeoName }, Request, Url);
});
}
return(JObject.FromObject(fedata));
case "be":
var bedata = await ApiProductViewModel.Repository.GetModelListByAsync(predicate, request.OrderBy, request.Direction, request.PageSize, request.PageIndex).ConfigureAwait(false);
if (bedata.IsSucceed)
{
bedata.Data.Items.ForEach(a =>
{
a.DetailsUrl = SwCmsHelper.GetRouterUrl(
"Product", new { a.SeoName }, Request, Url);
});
}
return(JObject.FromObject(bedata));
default:
var data = await InfoProductViewModel.Repository.GetModelListByAsync(predicate, request.OrderBy, request.Direction, request.PageSize, request.PageIndex).ConfigureAwait(false);
if (data.IsSucceed)
{
data.Data.Items.ForEach(a =>
{
a.DetailsUrl = SwCmsHelper.GetRouterUrl(
"Product", new { a.SeoName }, Request, Url);
});
}
return(JObject.FromObject(data));
}
}
public async Task <RepositoryResponse <PaginationModel <NavProductMediaViewModel> > > GetListByProduct(RequestPaging request, string productId = null)
{
var data = await NavProductMediaViewModel.Repository.GetModelListByAsync(
m => m.ProductId == productId && m.Specificulture == _lang, request.OrderBy
, request.Direction, request.PageSize, request.PageIndex)
.ConfigureAwait(false);
return(data);
}
public async Task <ActionResult <JObject> > GetList(
[FromBody] RequestPaging request)
{
var parsed = HttpUtility.ParseQueryString(request.Query ?? "");
bool isLevel = int.TryParse(parsed.Get("level"), out int level);
ParseRequestPagingDate(request);
Expression <Func <SioPage, bool> > predicate = model =>
model.Specificulture == _lang &&
(!request.Status.HasValue || model.Status == request.Status.Value) &&
(!isLevel || model.Level == level) &&
(string.IsNullOrWhiteSpace(request.Keyword) ||
(model.Title.Contains(request.Keyword) ||
model.Excerpt.Contains(request.Keyword))) &&
(!request.FromDate.HasValue ||
(model.CreatedDateTime >= request.FromDate.Value)
) &&
(!request.ToDate.HasValue ||
(model.CreatedDateTime <= request.ToDate.Value)
);
string key = $"{request.Key}_{request.PageSize}_{request.PageIndex}";
switch (request.Key)
{
case "mvc":
var mvcResult = await base.GetListAsync <ReadMvcViewModel>(key, request, predicate);
if (mvcResult.IsSucceed)
{
mvcResult.Data.Items.ForEach(a =>
{
a.DetailsUrl = SioCmsHelper.GetRouterUrl(
"page", new { seoName = a.SeoName }, Request, Url);
});
}
return(Ok(JObject.FromObject(mvcResult)));
case "portal":
var portalResult = await base.GetListAsync <UpdateViewModel>(key, request, predicate);
if (portalResult.IsSucceed)
{
portalResult.Data.Items.ForEach(a =>
{
a.DetailsUrl = SioCmsHelper.GetRouterUrl(
"page", new { seoName = a.SeoName }, Request, Url);
});
}
return(Ok(JObject.FromObject(portalResult)));
default:
var listItemResult = await base.GetListAsync <ReadListItemViewModel>(key, request, predicate);
if (listItemResult.IsSucceed)
{
listItemResult.Data.Items.ForEach((Action <ReadListItemViewModel>)(a =>
{
a.DetailsUrl = SioCmsHelper.GetRouterUrl(
"page", new { seoName = a.SeoName }, Request, Url);
a.Childs.ForEach((Action <ReadListItemViewModel>)(c =>
{
c.DetailsUrl = SioCmsHelper.GetRouterUrl(
"page", new { seoName = c.SeoName }, Request, Url);
}));
}));
}
return(JObject.FromObject(listItemResult));
}
}
protected async Task <RepositoryResponse <PaginationModel <TView> > > GetListAsync <TView>(string key, RequestPaging request, Expression <Func <TModel, bool> > predicate = null, TModel model = null)
where TView : ViewModelBase <TDbContext, TModel, TView>
{
var cacheKey = $"api_{_lang}_{typeof(TModel).Name.ToLower()}_list_{key}_{request.Status}_{request.Keyword}_{request.OrderBy}_{request.Direction}_{request.PageSize}_{request.PageIndex}_{request.Query}";
RepositoryResponse <PaginationModel <TView> > data = null;
if (MixService.GetConfig <bool>("IsCache"))
{
data = await MixCacheService.GetAsync <RepositoryResponse <PaginationModel <TView> > >(cacheKey);
}
if (data == null)
{
if (predicate != null)
{
data = await DefaultRepository <TDbContext, TModel, TView> .Instance.GetModelListByAsync(
predicate, request.OrderBy, request.Direction, request.PageSize, request.PageIndex, null, null);
if (data.IsSucceed)
{
await MixCacheService.SetAsync(cacheKey, data);
AlertAsync("Add Cache", 200, cacheKey);
}
}
else
{
data = await DefaultRepository <TDbContext, TModel, TView> .Instance.GetModelListAsync(request.OrderBy, request.Direction, request.PageSize, request.PageIndex, null, null).ConfigureAwait(false);
if (data.IsSucceed)
{
await MixCacheService.SetAsync(cacheKey, data);
AlertAsync("Add Cache", 200, cacheKey);
}
}
}
data.LastUpdateConfiguration = MixService.GetConfig <DateTime?>("LastUpdateConfiguration");
return(data);
}
