public ActionResult PostManagement(int page = 1)
{
SortBuilder sortBuilder = new SortBuilder()
{
ColumnName = "CreatedDate",
ColumnOrder = SortBuilder.SortOrder.Descending
};
Paging paging = new Paging()
{
PageNumber = page,
PageSize = 10,
TotalRecord = 0
};
Expression <Func <Post, bool> > expression = PredicateBuilder.True <Post>();
expression = expression.And <Post>((Post x) => x.CreatedBy.Equals(this.HttpContext.User.Identity.Name));
IEnumerable <Post> posts = this._postService.FindAndSort(expression, sortBuilder, paging);
if (posts.IsAny <Post>())
{
Helper.PageInfo pageInfo = new Helper.PageInfo(ExtentionUtils.PageSize, page, paging.TotalRecord, (int i) => base.Url.Action("PostManagement", "Account", new { page = i }));
((dynamic)base.ViewBag).PageInfo = pageInfo;
((dynamic)base.ViewBag).CountItem = pageInfo.TotalItems;
}
return(base.View(posts));
}
public SearchResult <T> Search(SearchParameters parameters)
{
int?start = null;
int?rows = null;
if (parameters.PageIndex > 0)
{
start = (parameters.PageIndex - 1) * parameters.PageSize;
rows = parameters.PageSize;
}
var queryOptions = new QueryOptions
{
FilterQueries = FilterBuilder.BuildFilterQueries(parameters),
Rows = rows,
Start = start,
OrderBy = SortBuilder.GetSelectedSort(parameters),
};
try
{
var matchingResults = _solr.Query(QueryBuilder.BuildQuery(parameters), queryOptions);
return(new SearchResult <T>
{
MatchingResults = matchingResults,
TotalResults = matchingResults.NumFound
});
}
catch (SolrConnectionException exception)
{
// log exception and return empty result
Console.WriteLine($"Url: {exception.Url} Message: {exception.Message}");
return(new SearchResult <T>());
}
}
public async Task <ActionResult> Index(int page = 1, string keywords = "")
{
((dynamic)this.ViewBag).Keywords = keywords;
SortingPagingBuilder sortingPagingBuilder = new SortingPagingBuilder()
{
Keywords = keywords
};
SortBuilder sortBuilder = new SortBuilder()
{
ColumnName = "UserName",
ColumnOrder = SortBuilder.SortOrder.Descending
};
sortingPagingBuilder.Sorts = sortBuilder;
SortingPagingBuilder sortingPagingBuilder1 = sortingPagingBuilder;
Paging paging = new Paging()
{
PageNumber = page,
PageSize = this._pageSize,
TotalRecord = 0
};
Paging paging1 = paging;
IEnumerable <App.Domain.Entities.Account.User> users = await this._userService.PagedList(sortingPagingBuilder1, paging1);
if (users != null && users.Any())
{
Helper.PageInfo pageInfo = new Helper.PageInfo(ExtentionUtils.PageSize, page, paging1.TotalRecord, (int i) => this.Url.Action("Index", new { page = i, keywords = keywords }));
((dynamic)this.ViewBag).PageInfo = pageInfo;
}
return(this.View(users));
}
public ActionResult GetAccesssoriesHome(int page, string id)
{
Expression <Func <Post, bool> > expression = PredicateBuilder.True <Post>();
expression = expression.And <Post>((Post x) => x.Status == 1);
expression = expression.And <Post>((Post x) => x.VirtualCategoryId.Contains(id));
expression = expression.And <Post>((Post x) => x.ProductHot);
SortBuilder sortBuilder = new SortBuilder()
{
ColumnName = "UpdatedDate",
ColumnOrder = SortBuilder.SortOrder.Descending
};
Paging paging = new Paging()
{
PageNumber = page,
PageSize = 4,
TotalRecord = 0
};
IEnumerable <Post> posts = this._postService.FindAndSort(expression, sortBuilder, paging);
if (!posts.IsAny <Post>())
{
return(base.Json(new { success = true, data = "" }, JsonRequestBehavior.AllowGet));
}
return(base.Json(new { data = this.RenderRazorViewToString("_SlideProductHome", posts), success = true }, JsonRequestBehavior.AllowGet));
}
public ActionResult PostManagement(int page = 1)
{
var sortBuilder = new SortBuilder
{
ColumnName = "CreatedDate",
ColumnOrder = SortBuilder.SortOrder.Descending
};
var paging = new Paging
{
PageNumber = page,
PageSize = 10,
TotalRecord = 0
};
var expression = PredicateBuilder.True <Post>();
expression = expression.And(x => x.CreatedBy.Equals(HttpContext.User.Identity.Name));
var posts = _postService.FindAndSort(expression, sortBuilder, paging);
if (posts.IsAny())
{
var pageInfo = new Helper.PageInfo(ExtentionUtils.PageSize, page, paging.TotalRecord, i => Url.Action("PostManagement", "Account", new { page = i }));
ViewBag.PageInfo = pageInfo;
ViewBag.CountItem = pageInfo.TotalItems;
}
return(View(posts));
}
public ActionResult PostHomeNew(int page, string id)
{
var expression = PredicateBuilder.True <Post>();
expression = expression.And(x => x.Status == (int)Status.Enable);
expression = expression.And(x => x.VirtualCategoryId.Contains(id));
expression = expression.And(x => x.ProductHot);
var sortBuilder = new SortBuilder
{
ColumnName = "UpdatedDate",
ColumnOrder = SortBuilder.SortOrder.Descending
};
var paging = new Paging
{
PageNumber = page,
PageSize = 4,
TotalRecord = 0
};
var posts = _postService.FindAndSort(expression, sortBuilder, paging);
if (!posts.IsAny())
{
return(Json(new { success = true, data = string.Empty }, JsonRequestBehavior.AllowGet));
}
return(Json(new
{
data = this.RenderRazorViewToString("_SlideProductHome",
from x in posts
orderby x.OrderDisplay descending
select x),
success = true
}, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// Get the names of all of the triggers in the given state that have
/// misfired - according to the given timestamp. No more than count will
/// be returned.
/// </summary>
/// <param name="nextFireTime"></param>
/// <param name="maxResults"></param>
/// <param name="results"></param>
/// <returns></returns>
public bool HasMisfiredTriggers(DateTime nextFireTime, int maxResults, out List <TriggerKey> results)
{
var cursor = Collection.Find(
trigger => trigger.Id.InstanceName == InstanceName &&
trigger.MisfireInstruction != MisfireInstruction.IgnoreMisfirePolicy &&
trigger.NextFireTime < nextFireTime &&
trigger.State == Models.TriggerState.Waiting)
.Project(trigger => trigger.Id.GetTriggerKey())
.Sort(SortBuilder.Combine(
SortBuilder.Ascending(trigger => trigger.NextFireTime),
SortBuilder.Descending(trigger => trigger.Priority)
)).ToCursor();
results = new List <TriggerKey>();
var hasReachedLimit = false;
while (cursor.MoveNext() && !hasReachedLimit)
{
foreach (var triggerKey in cursor.Current)
{
if (results.Count == maxResults)
{
hasReachedLimit = true;
}
else
{
results.Add(triggerKey);
}
}
}
return(hasReachedLimit);
}
public async Task <ActionResult> Index(int page = 1, string keywords = "")
{
ViewBag.Keywords = keywords;
var sortingPagingBuilder = new SortingPagingBuilder
{
Keywords = keywords
};
var sortBuilder = new SortBuilder
{
ColumnName = "Name",
ColumnOrder = SortBuilder.SortOrder.Descending
};
sortingPagingBuilder.Sorts = sortBuilder;
var sortingPagingBuilder1 = sortingPagingBuilder;
var paging = new Paging
{
PageNumber = page,
PageSize = PageSize,
TotalRecord = 0
};
var paging1 = paging;
var roles = await _roleService.PagedList(sortingPagingBuilder1, paging1);
if (roles != null && roles.Any())
{
var pageInfo = new Helper.PageInfo(ExtentionUtils.PageSize, page, paging1.TotalRecord, i => Url.Action("Index", new { page = i, keywords }));
ViewBag.PageInfo = pageInfo;
}
return(View(roles));
}
public ActionResult GetCustomerCareCategory(string virtualCategoryId, int page, string title)
{
SortBuilder sortBuilder = new SortBuilder()
{
ColumnName = "CreatedDate",
ColumnOrder = SortBuilder.SortOrder.Descending
};
Paging paging = new Paging()
{
PageNumber = page,
PageSize = base._pageSize,
TotalRecord = 0
};
IEnumerable <News> news = this._newsService.FindAndSort((News x) => !x.Video && x.Status == 1 && x.VirtualCategoryId.Contains(virtualCategoryId), sortBuilder, paging);
if (news.IsAny <News>())
{
Helper.PageInfo pageInfo = new Helper.PageInfo(ExtentionUtils.PageSize, page, paging.TotalRecord, (int i) => base.Url.Action("GetContent", "Menu", new { page = i }));
((dynamic)base.ViewBag).PageInfo = pageInfo;
((dynamic)base.ViewBag).CountItem = pageInfo.TotalItems;
}
((dynamic)base.ViewBag).Title = title;
((dynamic)base.ViewBag).virtualCategoryId = virtualCategoryId;
return(base.PartialView(news));
}
public List <TriggerKey> GetTriggersToAcquire(DateTimeOffset noLaterThan, DateTimeOffset noEarlierThan,
int maxCount)
{
if (maxCount < 1)
{
maxCount = 1;
}
var noLaterThanDateTime = noLaterThan.UtcDateTime;
var noEarlierThanDateTime = noEarlierThan.UtcDateTime;
return(Collection.Find(trigger => trigger.Id.InstanceName == InstanceName &&
trigger.State == Models.TriggerState.Waiting &&
trigger.NextFireTime <= noLaterThanDateTime &&
(trigger.MisfireInstruction == -1 ||
(trigger.MisfireInstruction != -1 &&
trigger.NextFireTime >= noEarlierThanDateTime)))
.Sort(SortBuilder.Combine(
SortBuilder.Ascending(trigger => trigger.NextFireTime),
SortBuilder.Descending(trigger => trigger.Priority)
))
.Limit(maxCount)
.Project(trigger => trigger.Id.GetTriggerKey())
.ToList());
}
public ActionResult GetCustomerCareCategory(string virtualCategoryId, int page, string title)
{
var sortBuilder = new SortBuilder
{
ColumnName = "CreatedDate",
ColumnOrder = SortBuilder.SortOrder.Descending
};
var paging = new Paging
{
PageNumber = page,
PageSize = CommonHelper.PageSize,
TotalRecord = 0
};
var news = _newsService.FindAndSort(x => !x.Video && x.Status == 1 && x.VirtualCategoryId.Contains(virtualCategoryId), sortBuilder, paging);
if (news.IsAny())
{
var pageInfo = new Helper.PageInfo(CommonHelper.PageSize, page, paging.TotalRecord, i => Url.Action("GetContent", "Menu", new { page = i }));
ViewBag.PageInfo = pageInfo;
ViewBag.CountItem = pageInfo.TotalItems;
}
ViewBag.Title = title;
ViewBag.virtualCategoryId = virtualCategoryId;
return(PartialView(news));
}
public QueryBuilder <T> Sorting(Expression <Func <T, object> > sort, bool desc)
{
if (sort == null)
{
sort = x => x.Id;
}
if (Sort == null)
{
if (desc)
{
Sort = SortBuilder.Descending(sort);
}
else
{
Sort = SortBuilder.Ascending(sort);
}
}
else
{
if (desc)
{
Sort = Sort.Descending(sort);
}
else
{
Sort = Sort.Ascending(sort);
}
}
return(this);
}
public ActionResponse <IEnumerable <TEntity> > Find <TValue>(string fieldName, TValue value, MatchingStrategy strategy, int limit = 100)
{
FilterDefinition <TEntity> filter;
switch (strategy)
{
case MatchingStrategy.LessThan:
filter = FilterBuilder.Lt(fieldName, value);
break;
case MatchingStrategy.GreaterThan:
filter = FilterBuilder.Gt(fieldName, value);
break;
default:
filter = FilterBuilder.Eq(fieldName, value);
break;
}
var hits = Collection.Find(filter).Sort(SortBuilder.Descending(fieldName)).Limit(limit);
return(new ActionResponse <IEnumerable <TEntity> >
{
Code = AppStatusCode.Ok,
Data = hits.ToList()
});
}
public void AppendSort(string sort)
{
if (string.IsNullOrWhiteSpace(sort))
{
return;
}
SortBuilder.Add(sort);
}
public IEnumerable <T> Fetch <T, T1, T2, T3, T4>(
string table,
string fields,
Func <T, T1, T2, T3, T4, T> func,
ConditionBuilder condition,
SortBuilder sort)
{
return(ToDo(conn => conn.Fetch(table, fields, func, condition, sort)));
}
public T FirstOrDefault <T, T1, T2, T3, T4>(
string table,
string fields,
Func <T, T1, T2, T3, T4, T> func,
ConditionBuilder condition,
SortBuilder sort) where T : BaseEntity <TPrimaryKey>
{
return(ToDo(conn => conn.FirstOrDefault <T, T1, T2, T3, T4, TPrimaryKey>(table, fields, func, condition, sort)));
}
public Task <Show> FindLastShow()
{
var sort = SortBuilder.Descending(x => x.ExternalId);
return(this.Collection
.Find(x => true)
.Limit(1)
.Sort(sort)
.FirstOrDefaultAsync());
}
public TBuilder SortWith(
Action <SortBuilder <TRequest, TEntity> > build)
{
var builder = new SortBuilder <TRequest, TEntity>();
build(builder);
Sorter = builder.Build();
return((TBuilder)this);
}
public Task <List <Show> > FindShows(int offset, int limit)
{
var sort = SortBuilder.Ascending(x => x.ExternalId);
return(this.Collection
.Find(x => true)
.Limit(limit)
.Skip(offset * limit)
.Sort(sort)
.ToListAsync());
}
/// <summary>
/// Sugere uma tecnologia com base em uma palavra chave
/// </summary>
/// <param name="text">palavra chave</param>
/// <returns></returns>
public async Task <List <Techie> > SugestTechie(string text)
{
var filter = FilterBuilder.Regex(a => a.Name, BsonRegularExpression.Create(new Regex(text, RegexOptions.IgnoreCase)))
& FilterBuilder.Exists(a => a.DeletedAt, false);
var sort = SortBuilder.Ascending(a => a.Name);
return(await Collection
.Find(filter)
.Sort(sort)
.Limit(5)
.ToListAsync());
}
public IEnumerable <T> PageList <T>(
int pageIndex,
int pageSize,
ConditionBuilder condition,
SortBuilder sort,
out int total)
{
using (var conn = new SqlConnection(_connectionString))
{
return(conn.PageList <T>(condition, sort, pageIndex, pageSize, out total));
}
}
public async Task <List <Publication> > ListPublications()
{
var filter = FilterBuilder.Exists(a => a.DeletedAt, false);
var sort = SortBuilder.Descending(a => a.DateCreation);
var projection = ProjectionBuilder.Slice(a => a.Comments, 0, 3);
return(await Collection
.Find(filter)
.Sort(sort)
.Project <Publication>(projection)
.ToListAsync());
}
public static List <T> Fetch <T, T1, T2, T3, T4>(this SqlConnection conn,
string table,
string fields,
Func <T, T1, T2, T3, T4, T> func,
ConditionBuilder condition,
SortBuilder sort, SqlTransaction trans = null)
{
condition = condition ?? ConditionBuilder.New();
sort = sort ?? new SortBuilder();
var sql = $"SELECT {fields} FROM [{table}] WHERE {condition.ToCondition()} ORDER BY {sort.ToOrderBy()}";
return(conn.Query(sql, func, condition.ToParameters(), trans).ToList());
}
public IEnumerable <T> PageList <T, T1, T2, T3, T4>(
int pageIndex,
int pageSize,
string table,
string fields,
Func <T, T1, T2, T3, T4, T> func,
ConditionBuilder condition,
SortBuilder sort,
out int total)
{
using (var conn = new SqlConnection(_connectionString))
{
return(conn.PageList(table, fields, func, condition, sort, pageIndex, pageSize, out total));
}
}
/// <summary>
/// Lista todas as publicações
/// </summary>
/// <returns>Lista de publicações</returns>
public async Task <List <Publication> > ListPublications(int page)
{
var filter = FilterBuilder.Exists(a => a.DeletedAt, false);
var sort = SortBuilder.Descending(a => a.DateCreation);
var projection = ProjectionBuilder.Slice(a => a.Comments, 0, 3);
return(await Collection
.Find(filter)
.Sort(sort)
.Skip((page - 1) * UtilBO.QUANTIDADE_PAGINAS)
.Limit(UtilBO.QUANTIDADE_PAGINAS)
.Project <Publication>(projection)
.ToListAsync());
}
public ActionResult SearchResult(string catUrl, string parameters, int page)
{
HttpCookie httpCookie = base.HttpContext.Request.Cookies.Get("system_search");
if (!base.Request.Cookies.ExistsCokiee("system_search"))
{
return(base.View());
}
Expression <Func <Post, bool> > expression = PredicateBuilder.True <Post>();
SortBuilder sortBuilder = new SortBuilder()
{
ColumnName = "CreatedDate",
ColumnOrder = SortBuilder.SortOrder.Descending
};
Paging paging = new Paging()
{
PageNumber = page,
PageSize = base._pageSize,
TotalRecord = 0
};
SeachConditions seachCondition = JsonConvert.DeserializeObject <SeachConditions>(base.Server.UrlDecode(httpCookie.Value));
expression = expression.And <Post>((Post x) => (int?)x.MenuId == seachCondition.CategoryId);
MenuLink byId = this._menuLinkService.GetById(seachCondition.CategoryId.Value);
((dynamic)base.ViewBag).KeyWords = byId.MetaKeywords;
((dynamic)base.ViewBag).SiteUrl = base.Url.Action("GetContent", "Menu", new { catUrl = catUrl, parameters = parameters, page = page, area = "" });
((dynamic)base.ViewBag).Description = byId.MetaDescription;
((dynamic)base.ViewBag).Image = base.Url.Content(string.Concat("~/", byId.ImageUrl));
((dynamic)base.ViewBag).VirtualId = byId.CurrentVirtualId;
string menuName = byId.MenuName;
if (!string.IsNullOrEmpty(seachCondition.Keywords))
{
expression = expression.And <Post>((Post x) => x.Title.Contains(seachCondition.Keywords) || x.Description.Contains(seachCondition.Keywords));
}
IEnumerable <Post> posts = this._postService.FindAndSort(expression, sortBuilder, paging);
((dynamic)base.ViewBag).PageNumber = page;
((dynamic)base.ViewBag).Title = menuName;
if (posts.IsAny <Post>())
{
Helper.PageInfo pageInfo = new Helper.PageInfo(ExtentionUtils.PageSize, page, paging.TotalRecord, (int i) => base.Url.Action("GetContent", "Menu", new { page = i }));
((dynamic)base.ViewBag).PageInfo = pageInfo;
((dynamic)base.ViewBag).CountItem = pageInfo.TotalItems;
}
return(base.View("GetPostByCategory", posts));
}
public static T FirstOrDefault <T, TPrimaryKey>(
this SqlConnection conn,
string table,
string fields,
ConditionBuilder condition,
SortBuilder sort,
SqlTransaction trans = null)
where T : IBaseEntity <TPrimaryKey>
{
condition = condition ?? ConditionBuilder.New();
sort = sort ?? new SortBuilder();
var sql = SqlServerSqlBuilder.LoadByCondition(table, fields, condition.ToCondition(), sort.ToOrderBy());
return(conn.QueryFirstOrDefault <T>(sql, condition.ToParameters()));
}
public List <EpisodeHistory> GetBySeason(int seriesId, int seasonNumber, EpisodeHistoryEventType?eventType)
{
SortBuilder <EpisodeHistory> query = Query
.Join <EpisodeHistory, Episode>(JoinType.Inner, h => h.Episode, (h, e) => h.EpisodeId == e.Id)
.Join <EpisodeHistory, Series>(JoinType.Inner, h => h.Series, (h, s) => h.SeriesId == s.Id)
.Where(h => h.SeriesId == seriesId)
.AndWhere(h => h.Episode.SeasonNumber == seasonNumber);
if (eventType.HasValue)
{
query.AndWhere(h => h.EventType == eventType);
}
query.OrderByDescending(h => h.Date);
return(query);
}
public virtual IQueryable <T> ApplySorts(IQueryable <T> query)
{
if (SortBuilder != null)
{
var orderBy = SortBuilder.Build();
if (orderBy != null)
{
var sortedQuery = orderBy(query);
if (sortedQuery != null)
{
query = sortedQuery;
}
}
}
return(query);
}
public ActionResult SearchResult(string catUrl, string parameters, int page)
{
var httpCookie = HttpContext.Request.Cookies.Get("system_search");
if (!Request.Cookies.ExistsCokiee("system_search"))
{
return(View());
}
var expression = PredicateBuilder.True <Post>();
var sortBuilder = new SortBuilder
{
ColumnName = "CreatedDate",
ColumnOrder = SortBuilder.SortOrder.Descending
};
var paging = new Paging
{
PageNumber = page,
PageSize = PageSize,
TotalRecord = 0
};
var seachCondition = JsonConvert.DeserializeObject <SeachConditions>(Server.UrlDecode(httpCookie.Value));
if (!string.IsNullOrEmpty(seachCondition.Keywords))
{
expression = expression.And(x =>
x.SeoUrl.Contains(seachCondition.Keywords) || x.Title.Contains(seachCondition.Keywords) ||
x.Description.Contains(seachCondition.Keywords));
}
var posts = _postService.FindAndSort(expression, sortBuilder, paging);
if (posts.IsAny())
{
var pageInfo = new Helper.PageInfo(ExtentionUtils.PageSize, page, paging.TotalRecord,
i => Url.Action("GetContent", "Menu", new { page = i }));
ViewBag.PageInfo = pageInfo;
ViewBag.CountItem = pageInfo.TotalItems;
}
ViewBag.PageNumber = page;
ViewBag.Title = "Tìm kiếm";
return(View(posts));
}
