public IActionResult Get([FromQuery] MenuRequestModel requestModel)
{
Expression <Func <Menu, bool> > where = x => true;
DateTime dateFrom, dateTo;
if (!string.IsNullOrWhiteSpace(requestModel.Name))
{
where = ExpressionHelpers.CombineAnd(where, a => a.Name.Contains(requestModel.Name));
}
if ((requestModel.DateFrom.IsNotNullOrEmpty()))
{
dateFrom = requestModel.DateFrom.ToDateTime();
where = ExpressionHelpers.CombineAnd(where, a => a.CreatedDate >= dateFrom);
}
if ((requestModel.DateTo.IsNotNullOrEmpty()))
{
dateTo = requestModel.DateTo.ToDateTime().AddDays(1);
where = ExpressionHelpers.CombineAnd(where, a => a.CreatedDate <= dateTo);
}
var services = _menuService.GetPagedList(where, x => x.Sequence, true, requestModel.Page - 1, requestModel.Count);
if (services == null)
{
return(RespondFailure());
}
List <MenuModel> serviceModels = services.Select(x => x.ToModel(requestModel.LanguageId)).ToList();
return(RespondSuccess(serviceModels, services.TotalCount));
}
public IActionResult GetTreeview([FromQuery] NewsCategoryRequestModel requestModel)
{
#region predicate
Expression <Func <NewsCategory, bool> > where = x => true;
if (!string.IsNullOrWhiteSpace(requestModel.Name))
{
where = a => a.Name.Contains(requestModel.Name);
}
if (requestModel.IsGetParent.HasValue && requestModel.IsGetParent.Value)
{
where = ExpressionHelpers.CombineAnd <NewsCategory>(where, x => x.ParentId == null || x.ParentId == 0);
}
bool ascending = false;
if (requestModel.Ascending.HasValue)
{
ascending = requestModel.Ascending.Value;
}
#endregion
var categories = _newsCategoryService.GetPagedList(
where,
null,
ascending,
requestModel.Page - 1,
requestModel.Count);
var newsCategoryModels = categories.ToList().ToParentModels();
return(RespondSuccess(newsCategoryModels, newsCategoryModels.Count));
}
public async Task <IActionResult> GetById([FromQuery] NewsItemRequestModel requestModel)
{
#region predicate
Expression <Func <NewsItem, bool> > where = x => true;
where = ExpressionHelpers.CombineAnd(where, x => x.Id == requestModel.Id);
#endregion
var article = await _newsItemService.FirstOrDefaultAsync(
where,
x => x.NewsItemCategories,
x => x.NewsItemTags);
if (article == null)
{
VerboseReporter.ReportError("Không tìm thấy tin tức này", "get");
return(RespondFailure());
}
var model = article.ToModel(requestModel.LanguageId);
//GetLocales(article, model);
return(RespondSuccess(model));
}
public IActionResult Get(RootRequestModel requestModel)
{
#region predicate
Expression <Func <EmailMessage, bool> > where = x => true;
if (!string.IsNullOrWhiteSpace(requestModel.Name))
{
where = ExpressionHelpers.CombineAnd(where, a => a.To.Contains(requestModel.Name));
}
#endregion
var allEmailMessage = _emailService.GetPagedList(
where,
null,
false,
requestModel.Page - 1,
requestModel.Count);
if (allEmailMessage == null)
{
return(RespondFailure());
}
var model = allEmailMessage;
return(RespondSuccess(model, model.TotalCount));
}
public IActionResult Get(RootRequestModel requestModel)
{
#region predicate
Expression <Func <EmailAccount, bool> > where = x => true;
if (!string.IsNullOrWhiteSpace(requestModel.Name))
{
where = ExpressionHelpers.CombineAnd(where, a => a.Username.Contains(requestModel.Name));
}
#endregion
var emailAccounts = _emailAccountService.GetPagedList(
where,
null,
false,
requestModel.Page - 1,
requestModel.Count);
if (emailAccounts == null)
{
return(RespondFailure());
}
var model = emailAccounts;//.Select(x => x.ToModel());
return(RespondSuccess(model, emailAccounts.TotalCount));
}
public IActionResult Get(RootRequestModel requestModel)
{
#region predicate
Expression <Func <LocalizedProperty, bool> > where = x => true;
if (!string.IsNullOrWhiteSpace(requestModel.Name))
{
where = ExpressionHelpers.CombineAnd <LocalizedProperty>(where, a => a.LocaleKey.Contains(requestModel.Name));
}
if (!string.IsNullOrWhiteSpace(requestModel.Content))
{
where = ExpressionHelpers.CombineAnd <LocalizedProperty>(where, a => a.LocaleValue.Contains(requestModel.Content));
}
#endregion
var allLocalizedProperty = _localizedPropertyService.GetPagedList(
where,
x => x.Id,
false,
requestModel.Page - 1,
requestModel.Count);
if (allLocalizedProperty == null)
{
return(RespondFailure());
}
var model = allLocalizedProperty;
return(RespondSuccess(model, model.TotalCount));
}
private Expression <Func <T, bool> > AppendSoftDeletableCondition(Expression <Func <T, bool> > where)
{
if (typeof(ISoftDeletable).IsAssignableFrom(typeof(T)))
{
//the parameter
var param = Expression.Parameter(typeof(T), "x");
var deletedWhere =
Expression.Lambda <Func <T, bool> >(
Expression.Equal(Expression.Property(param, "Deleted"), Expression.Constant(false)), param);
//combine these to create a single expression
where = ExpressionHelpers.CombineAnd <T>(where, deletedWhere);
}
return(where);
}
public async Task <IActionResult> GetById(int id)
{
#region predicate
Expression <Func <NewsCategory, bool> > where = x => true;
where = ExpressionHelpers.CombineAnd(where, x => x.Id == id);
#endregion
var newsCategory = await _newsCategoryService.FirstOrDefaultAsync(where);
if (newsCategory == null)
{
return(RespondFailure());
}
return(RespondSuccess(newsCategory.ToModel()));
}
public IActionResult GetParents([FromQuery] MenuRequestModel requestModel)
{
#region predicate
Expression <Func <Menu, bool> > where = x => true;
if (!string.IsNullOrWhiteSpace(requestModel.Name))
{
where = ExpressionHelpers.CombineAnd(where, a => a.Name.Contains(requestModel.Name));
}
if (requestModel.PositionId.HasValue)
{
where = ExpressionHelpers.CombineAnd(where, x => x.PositionId == requestModel.PositionId);
}
if (requestModel.ParentId.HasValue)
{
where = ExpressionHelpers.CombineAnd(where, x => x.ParentId == requestModel.ParentId);
}
if (requestModel.Active.HasValue)
{
where = ExpressionHelpers.CombineAnd(where, x => x.Active == requestModel.Active);
}
#endregion
var menus = _menuService.Get(
where).ToList();
#region get permissions
// TODO fix menus null exception
//foreach (var userRole in CurrentUser.UserRoles)
//{
// var permissions = _permissionRecordService.GetPermissionRecords(userRole.Role);
// foreach (var permission in permissions)
// {
// menus = menus.Where(x => x.Url.Contains(permission.Category)).ToList();
// }
//}
#endregion
List <MenuModel> menuModelParents = menus.ToParentModels(requestModel.LanguageId);
return(RespondSuccess(menuModelParents, menuModelParents.Count));
}
public IActionResult Get([FromQuery] RootRequestModel requestModel)
{
#region predicate
Expression <Func <NewsLetterSubscription, bool> > where = x => true;
DateTime dateFrom, dateTo;
if (!string.IsNullOrWhiteSpace(requestModel.Name))
{
where = a => a.Name.Contains(requestModel.Name);
}
if (!string.IsNullOrWhiteSpace(requestModel.Email))
{
where = ExpressionHelpers.CombineAnd <NewsLetterSubscription>(where, a => a.Email.Contains(requestModel.Email));
}
if (!string.IsNullOrWhiteSpace(requestModel.Mobile))
{
where = ExpressionHelpers.CombineAnd <NewsLetterSubscription>(where, a => a.Mobile.Contains(requestModel.Mobile));
}
if ((requestModel.DateFrom.IsNotNullOrEmpty()))
{
dateFrom = requestModel.DateFrom.ToDateTime();
where = ExpressionHelpers.CombineAnd <NewsLetterSubscription>(where, a => a.CreatedOnUtc >= dateFrom);
}
if ((requestModel.DateTo.IsNotNullOrEmpty()))
{
dateTo = requestModel.DateTo.ToDateTimeAddOneDay();
where = ExpressionHelpers.CombineAnd <NewsLetterSubscription>(where, a => a.CreatedOnUtc <= dateTo);
}
#endregion
var newsLetterSubscriptions = _newsLetterSubscriptionService.GetPagedList(
where,
null,
false,
requestModel.Page - 1,
requestModel.Count);
return(RespondSuccess(newsLetterSubscriptions, newsLetterSubscriptions.TotalCount));
}
public async Task <IActionResult> Get([FromQuery] RootRequestModel requestModel)
{
#region predicate
Expression <Func <NewsItem, bool> > where = x => true;
DateTime dateFrom, dateTo;
if (!string.IsNullOrWhiteSpace(requestModel.Name))
{
where = a => a.Name.Contains(requestModel.Name);
}
if ((requestModel.DateFrom.IsNotNullOrEmpty()))
{
dateFrom = requestModel.DateFrom.ToDateTime();
where = ExpressionHelpers.CombineAnd <NewsItem>(where, a => a.CreatedOnUtc >= dateFrom);
}
if ((requestModel.DateTo.IsNotNullOrEmpty()))
{
dateTo = requestModel.DateTo.ToDateTime().AddDays(1);
where = ExpressionHelpers.CombineAnd <NewsItem>(where, a => a.CreatedOnUtc <= dateTo);
}
if (requestModel.CategoryId.HasValue)
{
where = ExpressionHelpers.CombineAnd <NewsItem>(where,
a => a.NewsItemCategories.Any(x => x.NewsCategoryId == requestModel.CategoryId.Value));
}
#endregion
var newsItems = await _newsItemService.GetPagedListAsync(
where,
x => x.StartDateUtc,
false,
requestModel.Page - 1,
requestModel.Count);
return(RespondSuccess(newsItems.Select(x => x.ToModel()), newsItems.TotalCount));
}
public async Task <IActionResult> GetById([FromRoute] int id)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
#region predicate
Expression <Func <Category, bool> > where = x => true;
where = ExpressionHelpers.CombineAnd(where, x => x.Id == id);
#endregion
var category = await _categoryService.FirstOrDefaultAsync(where);
if (category == null)
{
return(RespondFailure());
}
return(RespondSuccess(category.ToModel()));
}
public async Task <IActionResult> Get([FromQuery] RootRequestModel requestModel)
{
if (requestModel == null)
{
return(BadRequest());
}
if (requestModel.Page < 1)
{
requestModel.Page = 1;
}
if (requestModel.Count < 1)
{
requestModel.Count = 10;
}
Expression <Func <Order, bool> > where = x => true;
if (!string.IsNullOrWhiteSpace(requestModel.Name))
{
where = ExpressionHelpers.CombineAnd(where, a => a.BuyerId.Contains(requestModel.Name));
}
var orders = await _orderService.GetPagedListAsync(
where,
x => x.OrderDate,
true,
requestModel.Page - 1,
requestModel.Count);
if (orders == null)
{
return(RespondFailure());
}
var model = orders;//.Select(x => x.ToModel());
return(RespondSuccess(model, orders.TotalCount));
}
/// <summary>
/// Gets all languages
/// </summary>
/// <param name="showHidden">A value indicating whether to show hidden records</param>
/// <returns>Languages</returns>
public virtual IList <Language> GetAllLanguages(bool showHidden = false)
{
string key = string.Format(ConstantKey.LANGUAGES_ALL_KEY, showHidden);
var languages = _cacheService.Get(key, () =>
{
Expression <Func <Language, bool> > where = x => true;
if (!showHidden)
{
where = ExpressionHelpers.CombineAnd <Language>(where, l => l.Published);
}
var query = Repository.Get(where);
if (!showHidden)
{
query = query.Where(l => l.Published);
}
query = query.OrderBy(l => l.DisplayOrder).ThenBy(l => l.Id);
return(query.ToList());
});
return(languages);
}
public IActionResult Get([FromQuery] RootRequestModel requestModel)
{
Expression <Func <Language, bool> > where = x => true;
if (!string.IsNullOrWhiteSpace(requestModel.Name))
{
where = ExpressionHelpers.CombineAnd <Language>(where, a => a.Name.Contains(requestModel.Name));
}
var languages = _languageService.GetPagedList(
where,
null,
false,
requestModel.Page - 1,
requestModel.Count);
if (languages == null)
{
return(RespondFailure());
}
var model = languages;
return(RespondSuccess(model, model.TotalCount));
}
public async Task <IActionResult> Get([FromQuery] NewsCategoryRequestModel requestModel)
{
#region predicate
if (requestModel == null)
{
return(BadRequest());
}
if (requestModel.Page < 1)
{
requestModel.Page = 1;
}
if (requestModel.Count < 1)
{
requestModel.Count = 10;
}
Expression <Func <NewsCategory, bool> > where = x => true;
if (!string.IsNullOrWhiteSpace(requestModel.Name))
{
where = a => a.Name.Contains(requestModel.Name);
}
if (requestModel.IsGetParent.HasValue)
{
where = ExpressionHelpers.CombineAnd <NewsCategory>(where, x => x.ParentId == null || x.ParentId == 0);
}
bool ascending = true;
if (requestModel.Ascending.HasValue)
{
ascending = requestModel.Ascending.Value;
}
#endregion
IPagedList <NewsCategory> categories;
switch (requestModel.OrderBy)
{
case "Name":
categories = await _newsCategoryService.GetPagedListAsync(
where,
x => x.Name,
ascending,
requestModel.Page - 1,
requestModel.Count);
break;
default:
categories = await _newsCategoryService.GetPagedListAsync(
where,
x => x.DisplayOrder,
ascending,
requestModel.Page - 1,
requestModel.Count);
break;
}
var model = categories.Select(x => x.ToModel()).ToList();
return(RespondSuccess(model, categories.TotalCount));
}