/// <summary>
/// Gets the basic page content for the site
/// </summary>
/// <param name="page">The pagination page</param>
/// <param name="itemsPerPage">The pagination items per page</param>
/// <param name="criteria">The filter criteria</param>
/// <param name="orderBy">The order by clause</param>
/// <returns>A list of content items</returns>
public Page <ContentItem> GetContent(long page, long itemsPerPage, ContentCriteria criteria = null, string orderBy = "N.id")
{
string sql = @"SELECT N.Id, N.ParentId, N.Level, CT.icon, N.Trashed, CT.alias, D.Text as Name, N.createDate, D.updateDate, Creator.Id AS CreatorId, Creator.userName as CreatorName, Updater.Id as UpdaterId, Updater.userName as UpdaterName
FROM cmsContent C
INNER JOIN umbracoNode N ON N.Id = C.nodeId
INNER JOIN cmsContentType CT ON C.contentType = CT.nodeId
INNER JOIN cmsDocument D ON D.nodeId = C.nodeId
INNER JOIN umbracoUser AS Creator ON Creator.Id = N.nodeUser
INNER JOIN umbracoUser AS Updater ON Updater.Id = D.documentUser
WHERE D.Newest = 1 ";
Sql query = new Sql(sql);
if (criteria != null)
{
if (!String.IsNullOrEmpty(criteria.Alias))
{
query = query.Append(" AND CT.alias = @0", criteria.Alias);
}
if (!String.IsNullOrEmpty(criteria.Name))
{
query = query.Append(" AND D.text LIKE @0", "%" + criteria.Name + "%");
}
if (criteria.Id.HasValue)
{
query = query.Append(" AND N.id = @0", criteria.Id.Value);
}
if (criteria.Level.HasValue)
{
query = query.Append(" AND N.Level = @0", criteria.Level.Value);
}
if (criteria.Trashed.HasValue)
{
query = query.Append(" AND N.Trashed = @0", criteria.Trashed.Value);
}
if (criteria.CreatorId.HasValue)
{
query = query.Append(" AND Creator.Id = @0", criteria.CreatorId.Value);
}
if (criteria.UpdaterId.HasValue)
{
query = query.Append(" AND Updater.Id = @0", criteria.UpdaterId.Value);
}
}
if (!String.IsNullOrEmpty(orderBy))
{
query.OrderBy(orderBy);
}
var paged = db.Page <ContentItem>(page, itemsPerPage, query);
return(paged);
}
private void ApplyContentRestrictions <T>(ref ContentCriteria criteria)
{
// Restricts results to only Smart Forms that are mapped to this type definition.
var XmlConfigId = Common.PropertyRequest.GetEktronDefinition(typeof(T));
criteria.AddFilter(ContentProperty.XmlConfigurationId, CriteriaFilterOperator.EqualTo, XmlConfigId);
}
private ContentCriteria GetFolderCriteria(long FolderID)
{
var criteria = new ContentCriteria();
criteria.AddFilter(ContentProperty.FolderId, CriteriaFilterOperator.EqualTo, FolderID);
return(criteria);
}
/// <summary>
/// Gets a collection of the current user's recently edited content items
/// </summary>
private IEnumerable <ContentData> loadContentData()
{
ContentManager cAPI = new ContentManager();
UserManager uAPI = new UserManager();
var me = uAPI.GetItem(cAPI.UserId, true);
ContentCriteria criteria = new ContentCriteria();
criteria.OrderByField = ContentProperty.DateModified;
criteria.AddFilter(ContentProperty.UserId, CriteriaFilterOperator.EqualTo, me.Id);
criteria.AddFilter(ContentProperty.FolderName, CriteriaFilterOperator.NotEqualTo, "Workspace");
criteria.AddFilter(ContentProperty.FolderName, CriteriaFilterOperator.NotEqualTo, "_meta_");
if (this.DaysLimit > 0)
{
criteria.AddFilter(ContentProperty.DateModified, CriteriaFilterOperator.GreaterThanOrEqualTo, DateTime.Now.AddDays(-DaysLimit));
}
if (this.PublishedOnly)
{
criteria.AddFilter(ContentProperty.Status, CriteriaFilterOperator.EqualTo, "A");
}
var list = cAPI.GetList(criteria);
if (this.ItemLimit > 0)
{
list = list.Take(this.ItemLimit).ToList();
}
return(list);
}
public void SetsOrderFieldAndAscendingDirection(ContentProperty field)
{
var sut = new ContentCriteria().OrderBy(field);
Assert.AreEqual(EkEnumeration.OrderByDirection.Ascending, sut.OrderByDirection);
Assert.AreEqual(field, sut.OrderByField);
}
public void AddsFilterForXmlConfig(int id)
{
var sut = new ContentCriteria().BySmartForm(id);
Assert.AreEqual(1, sut.FilterGroups.Count);
Assert.AreEqual(ContentProperty.XmlConfigurationId, sut.FilterGroups[0].Filters[0].Field);
Assert.AreEqual(id, sut.FilterGroups[0].Filters[0].Value);
}
protected void Page_Load(object sender, EventArgs e)
{
var manager = new ContentManager();
var criteria = new ContentCriteria();
var items = manager.GetList(criteria).AsContentType <Content>();
this.rptrContent.DataSource = items;
this.rptrContent.DataBind();
}
public void AddsToCriteriaFilter(string value)
{
var field = ContentProperty.Path;
var criteria = new ContentCriteria();
var sut = new FilterContent(criteria, field);
sut.Contains(value);
Assert.AreEqual(1, criteria.FilterGroups.Count);
Assert.AreEqual(field, criteria.FilterGroups[0].Filters[0].Field);
Assert.AreEqual(value, criteria.FilterGroups[0].Filters[0].Value);
}
private ContentCriteria GetContentCriteria(long ContentTypeID, DateTime?StartDate = null, DateTime?EndDate = null)
{
var criteria = new ContentCriteria(Ektron.Cms.Common.ContentProperty.DateModified, Ektron.Cms.Common.EkEnumeration.OrderByDirection.Descending);
criteria.AddFilter(Ektron.Cms.Common.ContentProperty.XmlConfigurationId, Ektron.Cms.Common.CriteriaFilterOperator.EqualTo, ContentTypeID);
if (StartDate.HasValue && EndDate.HasValue)
{
criteria.AddFilter(Ektron.Cms.Common.ContentProperty.DateModified, Ektron.Cms.Common.CriteriaFilterOperator.GreaterThanOrEqualTo, StartDate.Value);
criteria.AddFilter(Ektron.Cms.Common.ContentProperty.DateModified, Ektron.Cms.Common.CriteriaFilterOperator.LessThanOrEqualTo, EndDate.Value);
}
criteria.PagingInfo = new PagingInfo(1, 1);
return(criteria);
}
/// <summary>
/// Gets all content paged
/// </summary>
/// <param name="page">The current page</param>
/// <param name="pageSize">The items per page</param>
/// <param name="criteria"></param>
public Page <ContentItem> GetContentPaged(long page = 1, long pageSize = 50, string name = null, string alias = null, int?creatorId = null, string id = null, int?level = null, bool?trashed = null, int?updaterId = null, string orderBy = "N.id")
{
var criteria = new ContentCriteria
{
Name = name,
Alias = alias,
CreatorId = creatorId,
Id = id,
Level = level,
Trashed = trashed,
UpdaterId = updaterId
};
return(dataService.GetContent(page, pageSize, criteria, orderBy));
}
private void GetHolidayList()
{
ContentTypeManager<HolidayOffers> holidayOfferManager = new ContentTypeManager<HolidayOffers>();
string folderid = Resources.ID.HolidayOfferFolderId;
long holidayFolderId = 0;
bool isFolderId = long.TryParse(folderid, out holidayFolderId);
if (isFolderId)
{
ContentCriteria criteria = new ContentCriteria();
criteria.AddFilter(ContentProperty.FolderId, CriteriaFilterOperator.EqualTo, holidayFolderId);
List<ContentType<HolidayOffers>> holidayOffers = holidayOfferManager.GetList(criteria);
lstOffers.DataSource = holidayOffers;
lstOffers.DataBind();
}
}
private ContentCriteria GetCriteriaForSingleItem(long ItemID)
{
var criteria = new ContentCriteria();
criteria.PagingInfo = new Ektron.Cms.PagingInfo(1, 1);
criteria.AddFilter(ContentProperty.Id, CriteriaFilterOperator.EqualTo, ItemID);
// This rule catches both archived and non-archived content.
// Change to 0 for only non-archived content.
// Change to 1 for only archived content.
criteria.AddFilter(ContentProperty.IsArchived, CriteriaFilterOperator.GreaterThan, -1);
// Because this API is only interested in HTML content
//criteria.AddFilter(ContentProperty.XmlConfigurationId, CriteriaFilterOperator.EqualTo, 0);
criteria.ReturnMetadata = true;
return(criteria);
}
internal static void BuildTitleAndPathGroups(DataTable data, ContentCriteria criteria)
{
foreach (DataRow row in data.Rows.Cast<DataRow>().Where(dr => dr.IsNew()))
{
CriteriaFilterGroup<ContentProperty> critGroup = new CriteriaFilterGroup<ContentProperty>();
critGroup.Condition = LogicalOperation.And;
string contentTitle = EncodeTitle(row["title"].ToString());
critGroup.AddFilter(
ContentProperty.Title,
CriteriaFilterOperator.EqualTo,
contentTitle);
critGroup.AddFilter(
ContentProperty.Path,
CriteriaFilterOperator.EqualTo,
row["folderPath"].ToString());
criteria.FilterGroups.Add(critGroup);
}
}
protected override void GetExistingContentFilters(ContentCriteria criteria)
{
criteria.ReturnMetadata = true;
base.GetExistingContentFilters(criteria);
DestinationHelper.BuildTitleAndPathGroups(Data, criteria);
}
/// <summary>
/// Adds an exact match filter for <see cref="ContentProperty.XmlConfigurationId"/>.
/// </summary>
/// <param name="criteria">The criteria to extend.</param>
/// <param name="xmlConfigId">The Smart Form configuration id.</param>
/// <returns>The updated criteria.</returns>
public static ContentCriteria BySmartForm(this ContentCriteria criteria, long xmlConfigId)
{
criteria.FilteredBy(ContentProperty.XmlConfigurationId).EqualTo(xmlConfigId);
return(criteria);
}
/// <summary>
/// Adds a filter option.
/// </summary>
/// <param name="criteria">The criteria to extend.</param>
/// <param name="field">The field to filter on.</param>
/// <returns>An instance of <see cref="FilterContent"/>, which further refines the operator.</returns>
public static FilterContent FilteredBy(this ContentCriteria criteria, ContentProperty field)
{
return(new FilterContent(criteria, field));
}
public void SetsConditionPropertyToAnd()
{
var sut = new ContentCriteria().OrSeparated().AndSeparated();
Assert.AreEqual(LogicalOperation.And, sut.Condition);
}
public void SetsFolderRecursivePropertyToTrue()
{
var sut = new ContentCriteria().Recursive();
Assert.IsTrue(sut.FolderRecursive);
}
private List<ContentData> LookForExistingContent()
{
ContentCriteria criteria = new ContentCriteria
{
PagingInfo = { RecordsPerPage = 10000 },
Condition = LogicalOperation.Or
};
GetExistingContentFilters(criteria);
// remove groups with no filters, they mess up search
List<CriteriaFilterGroup<ContentProperty>> groupsWithFilters =
criteria.FilterGroups.Where(fg => fg.Filters.Any()).ToList();
int numFilters = groupsWithFilters.SelectMany(g => g.Filters).Count();
List<ContentData> contentList = new List<ContentData>();
Action<List<CriteriaFilterGroup<ContentProperty>>> doSearch = groups =>
{
criteria.FilterGroups.Clear();
criteria.FilterGroups.AddRange(groups);
contentList.AddRange(ContentManager.GetList(criteria));
};
if (numFilters > MaxFiltersInCriteria)
{
var groups = new List<CriteriaFilterGroup<ContentProperty>>();
int currentFilterCount = 0;
foreach (var group in groupsWithFilters)
{
if (currentFilterCount <= MaxFiltersInCriteria
&& ((currentFilterCount + group.Filters.Count) <= MaxFiltersInCriteria
|| groups.Count == 0))
{
currentFilterCount += group.Filters.Count;
groups.Add(group);
continue;
}
doSearch(groups);
currentFilterCount = group.Filters.Count;
groups.Clear();
groups.Add(group);
}
if (groups.Any())
{
doSearch(groups);
}
}
else
{
doSearch(groupsWithFilters);
}
return contentList;
}
public void SetsPagingPropertyToIntMax()
{
var sut = new ContentCriteria().MaxItems();
Assert.AreEqual(int.MaxValue, sut.PagingInfo.RecordsPerPage);
}
protected virtual void GetExistingContentFilters(ContentCriteria criteria)
{
var rowGroups = Data.Rows.Cast<DataRow>().Where(dr => !dr.IsNew())
.Select((r, i) => new { Index = i, Row = r })
.GroupBy(obj => Math.Truncate(obj.Index / 10.0))
.Select(grp => grp.Select(v => v.Row).ToList());
foreach (var rowGroup in rowGroups)
{
CriteriaFilterGroup<ContentProperty> critGroup = new CriteriaFilterGroup<ContentProperty>();
critGroup.Condition = LogicalOperation.Or;
foreach (DataRow row in rowGroup)
{
critGroup.AddFilter(ContentProperty.Id, CriteriaFilterOperator.EqualTo, row["contentid"]);
}
criteria.FilterGroups.Add(critGroup);
}
}
public void SetsReturnMetadataPropertyToTrue()
{
var sut = new ContentCriteria().WithMetadata();
Assert.IsTrue(sut.ReturnMetadata);
}
/// <summary>
/// Gets the basic page content for the site
/// </summary>
/// <param name="page">The pagination page</param>
/// <param name="itemsPerPage">The pagination items per page</param>
/// <param name="criteria">The filter criteria</param>
/// <param name="orderBy">The order by clause</param>
/// <returns>A list of content items</returns>
public Page <ContentItem> GetContent(long page, long itemsPerPage, ContentCriteria criteria = null, string orderBy = "N.id")
{
var sql = @"SELECT N.uniqueID as Udi, N.Id, N.ParentId, N.Level, CT.icon, N.Trashed as Trashed, CT.alias, N.Text as Name,
N.createDate, Creator.Id AS CreatorId, Creator.userName as CreatorName,
V.versionDate as UpdateDate, Updater.Id as UpdaterID, Updater.userName as UpdaterName,
(SELECT COUNT(languageId) FROM umbracoDocumentCultureVariation CV WHERE CV.nodeId = N.id) as LanguageCount
FROM umbracoContent C
INNER JOIN umbracoNode N ON N.Id = C.nodeId
INNER JOIN cmsContentType CT ON C.contentTypeId = CT.nodeId
INNER JOIN umbracoDocument D ON D.nodeId = C.nodeId
INNER JOIN umbracoContentVersion As V ON V.nodeId = N.id
INNER JOIN umbracoUser AS Creator ON Creator.Id = N.nodeUser
INNER JOIN umbracoUser As Updater ON V.userId = Updater.id
WHERE V.[current] = 1 ";
var query = new Sql(sql);
if (criteria != null)
{
if (!string.IsNullOrEmpty(criteria.Alias))
{
query = query.Append(" AND CT.alias = @0", criteria.Alias);
}
if (!string.IsNullOrEmpty(criteria.Name))
{
query = query.Append(" AND N.text LIKE @0", "%" + criteria.Name + "%");
}
if (!string.IsNullOrEmpty(criteria.Id))
{
int.TryParse(criteria.Id, out int criteriaId);
query = query.Append(" AND (N.id = @0 OR N.uniqueID LIKE @1)", criteriaId, "%" + criteria.Id + "%");
}
if (criteria.Level.HasValue)
{
query = query.Append(" AND N.Level = @0", criteria.Level.Value);
}
if (criteria.Trashed.HasValue)
{
query = query.Append(" AND N.Trashed = @0", criteria.Trashed.Value);
}
if (criteria.CreatorId.HasValue)
{
query = query.Append(" AND Creator.Id = @0", criteria.CreatorId.Value);
}
if (criteria.UpdaterId.HasValue)
{
query = query.Append(" AND Updater.Id = @0", criteria.UpdaterId.Value);
}
if (criteria.LanguageId.HasValue)
{
query = query.Append(" AND @0 IN (SELECT languageId FROM umbracoDocumentCultureVariation CV WHERE CV.nodeId = N.id)", criteria.LanguageId.Value);
}
}
if (!string.IsNullOrEmpty(orderBy))
{
query.OrderBy(orderBy);
}
using (var scope = this.scopeProvider.CreateScope(autoComplete: true))
{
var paged = scope.Database.Page <ContentItem>(page, itemsPerPage, query);
return(paged);
}
}
private ContentCriteria GetContentCriteria(long ContentTypeID, DateTime? StartDate = null, DateTime? EndDate = null)
{
var criteria = new ContentCriteria(Ektron.Cms.Common.ContentProperty.DateModified, Ektron.Cms.Common.EkEnumeration.OrderByDirection.Descending);
criteria.AddFilter(Ektron.Cms.Common.ContentProperty.XmlConfigurationId, Ektron.Cms.Common.CriteriaFilterOperator.EqualTo, ContentTypeID);
if (StartDate.HasValue && EndDate.HasValue)
{
criteria.AddFilter(Ektron.Cms.Common.ContentProperty.DateModified, Ektron.Cms.Common.CriteriaFilterOperator.GreaterThanOrEqualTo, StartDate.Value);
criteria.AddFilter(Ektron.Cms.Common.ContentProperty.DateModified, Ektron.Cms.Common.CriteriaFilterOperator.LessThanOrEqualTo, EndDate.Value);
}
criteria.PagingInfo = new PagingInfo(1, 1);
return criteria;
}
internal static List<ContentData> GetContentByFolderPath(string folderPath)
{
IContentManager cm = ObjectFactory.GetContent();
ContentCriteria criteria = new ContentCriteria();
criteria.AddFilter(ContentProperty.Path, CriteriaFilterOperator.EqualTo, folderPath);
return cm.GetList(criteria);
}
