public static CheckIdResult <T> Create(int[] ids, string actionTypeCode)
{
var result = new CheckIdResult <T>();
foreach (var id in ids)
{
var item = EntityObjectRepository.GetById <T>(id);
var lockableItem = item as LockableEntityObject;
if (item == null)
{
result._NotFoundIds.Add(id);
}
else if (item != null && !SecurityRepository.IsEntityAccessible(item.EntityTypeCode, id, actionTypeCode))
{
result._NotAccessedIds.Add(id);
}
else if (lockableItem != null && lockableItem.LockedByAnyoneElse && !QPContext.CanUnlockItems)
{
result._LockedItems.Add(item);
}
else
{
result._ValidItems.Add(item);
}
}
return(result);
}
public void AutoUnlock()
{
if (LockedByYou && !PermanentLock)
{
EntityObjectRepository.UnLock(this);
}
}
public static void UnlockAllEntitiesLockedByCurrentUser()
{
var id = QPContext.CurrentUserId;
if (id != 0)
{
EntityObjectRepository.UnlockAllEntitiesLockedByUser(id);
}
}
public void AutoLock()
{
if (!LockedByAnyone)
{
LockedBy = QPContext.CurrentUserId;
// ReSharper disable once PossibleInvalidOperationException
Locked = EntityObjectRepository.Lock(this).Value;
}
}
internal void MutateName()
{
var name = Name;
var index = 0;
do
{
index++;
Name = MutateHelper.MutateString(name, index);
} while (EntityObjectRepository.CheckNameUniqueness(this));
}
protected virtual RulesException ValidateUnique(RulesException errors)
{
if (!string.IsNullOrEmpty(Name) && !string.IsNullOrEmpty(EntityTypeCode))
{
if (EntityObjectRepository.CheckNameUniqueness(this))
{
errors.Error(UniquePropertyName, Name, PropertyIsNotUniqueMessage);
}
}
return(errors);
}
private static Dictionary <string, Dictionary <int, string> > LoadDictionaries()
{
return(EntityObjectRepository.GetTranslations()
.Select(r => new
{
PhraseId = Converter.ToInt32(r.Field <decimal>("PHRASE_ID")),
Phrase = r.Field <string>("PHRASE_TEXT"),
LanguageId = Converter.ToInt32(r.Field <decimal>("LANGUAGE_ID")),
Translation = r.Field <string>("PHRASE_TRANSLATION")
})
.GroupBy(d => d.Phrase.ToLowerInvariant())
.ToDictionary(g => g.Key, g => g.ToDictionary(r => r.LanguageId, r => r.Translation)));
}
public void CaptureLockTemplateObject(int id)
{
var obj = ObjectRepository.GetObjectPropertiesById(id);
if (obj == null)
{
throw new Exception(string.Format(TemplateStrings.ObjectNotFound, id));
}
if (obj.CanBeUnlocked)
{
EntityObjectRepository.CaptureLock(obj);
}
}
public void CaptureLockTemplate(int id)
{
var template = PageTemplateRepository.GetPageTemplatePropertiesById(id);
if (template == null)
{
throw new Exception(string.Format(TemplateStrings.TemplateNotFound, id));
}
if (template.CanBeUnlocked)
{
EntityObjectRepository.CaptureLock(template);
}
}
public void CaptureLockPageObjectFormat(int id)
{
var format = ObjectFormatRepository.ReadObjectFormat(id, false);
if (format == null)
{
throw new Exception(string.Format(TemplateStrings.FormatNotFound, id));
}
if (format.CanBeUnlocked)
{
EntityObjectRepository.CaptureLock(format);
}
}
public static void CaptureLock(int id)
{
var site = SiteRepository.GetById(id);
if (site == null)
{
throw new Exception(string.Format(SiteStrings.SiteNotFound, id));
}
if (site.CanBeUnlocked)
{
EntityObjectRepository.CaptureLock(site);
}
}
public static void CaptureLock(int id)
{
var article = ArticleRepository.GetById(id);
if (article == null)
{
throw new Exception(string.Format(ArticleStrings.ArticleNotFound, id));
}
if (article.CanBeUnlocked)
{
EntityObjectRepository.CaptureLock(article);
}
}
/// <summary>
/// Возвращает цепочку сущностей для хлебных крошек
/// </summary>
/// <param name="entityTypeCode">код типа сущности</param>
/// <param name="entityId">идентификатор сущности</param>
/// <param name="parentEntityId">идентификатор родительской сущности</param>
/// <param name="actionCode"></param>
/// <returns>цепочка сущностей</returns>
public static IEnumerable <EntityInfo> GetBreadCrumbsList(string entityTypeCode, long entityId, long?parentEntityId, string actionCode)
{
if (!string.IsNullOrWhiteSpace(actionCode))
{
if (actionCode.Equals(ActionCode.ChildContentPermissions, StringComparison.InvariantCultureIgnoreCase))
{
entityTypeCode = EntityTypeCode.Content;
}
else if (actionCode.Equals(ActionCode.ChildArticlePermissions, StringComparison.InvariantCultureIgnoreCase))
{
entityTypeCode = EntityTypeCode.Article;
}
}
return(EntityObjectRepository.GetParentsChain(entityTypeCode, entityId, parentEntityId));
}
public static CheckIdResult <Article> CreateForPublish(int contentId, int[] ids, bool disableSecurityCheck)
{
var result = new CheckIdResult <Article>();
var list = EntityObjectRepository.GetList(EntityTypeCode.Article, ids).Cast <Article>();
if (list == null)
{
result._NotFoundIds.AddRange(ids);
}
else
{
result._NotFoundIds.AddRange(ids.Except(list.Select(n => n.Id)));
var checkResult = ArticleRepository.CheckSecurity(contentId, ids, false, disableSecurityCheck);
var relationCheckResult = ArticleRepository.CheckRelationSecurity(contentId, ids, false);
foreach (var article in list)
{
if (article.StatusTypeId == article.ActualWorkflowBinding.MaxStatus.Id && !article.Splitted)
{
result._RedundantIds.Add(article.Id);
}
else if (article.LockedByAnyoneElse && !QPContext.CanUnlockItems)
{
result._LockedItems.Add(article);
}
else if (!checkResult[article.Id])
{
result._NotAccessedIds.Add(article.Id);
}
else if (!article.IsPublishableWithWorkflow)
{
result._BlockedByWorkflowIds.Add(article.Id);
}
else if (!relationCheckResult[article.Id])
{
result._BlockedByRelationSecurityIds.Add(article.Id);
}
else
{
result._ValidItems.Add(article);
}
}
}
return(result);
}
public static CheckIdResult <Article> CreateForRemove(int contentId, int[] ids, bool disableSecurityCheck)
{
var result = new CheckIdResult <Article>();
var list = EntityObjectRepository.GetList(EntityTypeCode.Article, ids).Cast <Article>();
if (list == null)
{
result._NotFoundIds.AddRange(ids);
}
else
{
result._NotFoundIds.AddRange(ids.Except(list.Select(n => n.Id)));
var checkResult = ArticleRepository.CheckSecurity(contentId, ids, true, disableSecurityCheck);
var relationCheckResult = ArticleRepository.CheckRelationSecurity(contentId, ids, true);
foreach (var article in list)
{
if (article.LockedByAnyoneElse)
{
result._LockedItems.Add(article);
}
else if (!checkResult[article.Id])
{
result._NotAccessedIds.Add(article.Id);
}
else if (!article.IsRemovableWithWorkflow)
{
result._BlockedByWorkflowIds.Add(article.Id);
}
else if (!relationCheckResult[article.Id])
{
result._BlockedByRelationSecurityIds.Add(article.Id);
}
else
{
result._ValidItems.Add(article);
}
}
}
return(result);
}
public IList<EntityTreeItem> Process()
{
var treeField = FieldRepository.GetById(ContentRepository.GetTreeFieldId(_contentId));
return GetChildArticles(_entityId, _filter, EntityObjectRepository.GetTreeIdsToLoad(_entityTypeCode, treeField.ContentId, _selectedIdsString), treeField);
}
public static IEnumerable <BackendActionStatus> ResolveStatus(string entityTypeCode, int entityId, int parentEntityId, BackendActionStatus[] statuses)
{
var testEntityTypeCode = entityTypeCode != EntityTypeCode.VirtualArticle ? entityTypeCode : EntityTypeCode.VirtualContent;
var testEntityId = entityTypeCode != EntityTypeCode.VirtualArticle ? entityId : parentEntityId;
// Получить родительский контент и сайт
IEnumerable <EntityInfo> bindableParentEntities =
EntityObjectRepository.GetParentsChain(testEntityTypeCode, testEntityId)
.Where(ei =>
ei.Id > 0 &&
(
ei.Code.Equals(EntityTypeCode.Site, StringComparison.InvariantCultureIgnoreCase) ||
ei.Code.Equals(EntityTypeCode.Content, StringComparison.InvariantCultureIgnoreCase) ||
ei.Code.Equals(EntityTypeCode.VirtualContent, StringComparison.InvariantCultureIgnoreCase)
)
)
.ToArray();
var customActions = CustomActionRepository.GetListByCodes(statuses.Select(s => s.Code).ToArray());
// Если есть как минимум сайт - то проверяем
if (customActions.Any())
{
if (bindableParentEntities.Any())
{
var parentSiteInfo = bindableParentEntities.FirstOrDefault(ei => ei.Code.Equals(EntityTypeCode.Site, StringComparison.InvariantCultureIgnoreCase));
var parentContentInfo = bindableParentEntities.FirstOrDefault(ei => ei.Code.Equals(EntityTypeCode.Content, StringComparison.InvariantCultureIgnoreCase) ||
ei.Code.Equals(EntityTypeCode.VirtualContent, StringComparison.InvariantCultureIgnoreCase)
);
foreach (var ca in customActions)
{
var status = statuses.Single(s => s.Code.Equals(ca.Action.Code, StringComparison.InvariantCultureIgnoreCase));
if (status.Visible)
{
var visibleBySite = false;
var visibleByContent = false;
if (ca.Sites.Any(s => s.Id == parentSiteInfo.Id)) // сайт выбран для текущего Custom Action
{
visibleBySite = ca.SiteExcluded;
}
else
{
visibleBySite = !ca.SiteExcluded;
}
if (visibleBySite)
{
if (parentContentInfo != null)
{
if (ca.Contents.Any(c => c.Id == parentContentInfo.Id)) // контент выбран для текущего Custom Action
{
visibleByContent = ca.ContentExcluded;
}
//else if (!ca.Contents.Any())
// visibleByContent = true;
else
{
visibleByContent = !ca.ContentExcluded;
}
}
else
{
visibleByContent = visibleBySite;
}
}
// Побеждает всегда False если он есть
status.Visible = visibleBySite && visibleBySite == visibleByContent;
if (status.Visible && ca.Action.ExcludeCodes != null)
{
foreach (var code in ca.Action.ExcludeCodes)
{
var excludedStatus = statuses.SingleOrDefault(s => s.Code.Equals(code, StringComparison.InvariantCultureIgnoreCase));
if (excludedStatus != null)
{
excludedStatus.Visible = false;
}
}
}
}
}
}
else
{
foreach (var ca in customActions)
{
var status = statuses.Single(s => s.Code.Equals(ca.Action.Code, StringComparison.InvariantCultureIgnoreCase));
status.Visible = false;
}
}
}
return(statuses);
}
/// <summary>
/// Возвращает поддерево меню от корня до ближайшего существующего нода для параметров
/// </summary>
/// <param name="entityTypeCode"></param>
/// <param name="entityId"></param>
/// <param name="parentEntityId"></param>
/// <returns></returns>
public static TreeNode GetSubTreeToEntity(string entityTypeCode, long entityId, long parentEntityId)
{
// положить в стек все ВОЗМОЖНЫЕ (Folder и Not Folder) tree menu nodes от корня до Entity
var stack = new Stack <TreeNode>();
EntityObjectRepository.GetParentsChain(entityTypeCode, entityId, parentEntityId).ToList()
.ForEach(e =>
{
stack.Push(new TreeNode
{
Code = e.Code,
Id = Converter.ToInt32(e.Id),
ParentId = Converter.ToInt32(e.ParentId),
IsFolder = false
});
if (StringComparer.InvariantCultureIgnoreCase.Equals(e.Code, EntityTypeCode.Content))
{
var group = ContentRepository.GetContentGroup(Convert.ToInt32(e.Id));
if (group != null)
{
stack.Push(new TreeNode
{
Code = group.EntityTypeCode,
Id = Converter.ToInt32(group.Id),
ParentId = Converter.ToInt32(group.ParentEntityId),
GroupItemCode = GroupItemCodes.ContentGroup,
IsGroup = true
});
}
}
stack.Push(new TreeNode
{
Code = e.Code,
Id = Converter.ToInt32(e.ParentId),
IsFolder = true
});
});
// получить реальные nodes
var nodeQueue = new Queue <TreeNode>(stack.Count);
var nodes = TreeMenuRepository.GetChildNodeList(null, null, false, false, null);
while (stack.Count > 0)
{
var paramNode = stack.Pop();
TreeNode currentNode;
if (paramNode.IsFolder)
{
currentNode = nodes.SingleOrDefault(n => n.IsFolder && n.Code == paramNode.Code && n.ParentId == paramNode.Id);
}
else if (paramNode.IsGroup)
{
currentNode = nodes.SingleOrDefault(n => n.IsGroup && n.Code == paramNode.Code && n.Id == paramNode.Id);
}
else
{
currentNode = nodes.SingleOrDefault(n => !(n.IsFolder || n.IsGroup) && n.Code == paramNode.Code && n.Id == paramNode.Id);
}
if (currentNode != null)
{
nodes = TreeMenuRepository.GetChildNodeList(paramNode.Code, paramNode.Id, paramNode.IsFolder, paramNode.IsGroup, paramNode.GroupItemCode);
currentNode.ChildNodes = nodes;
currentNode.HasChildren = nodes.Any();
nodeQueue.Enqueue(currentNode);
}
}
return(nodeQueue.Any() ? nodeQueue.Dequeue() : null);
}
public static string GetNameById(int contentId) => EntityObjectRepository.GetName(EntityTypeCode.Content, contentId);
/// <summary> /// Проверяет уникальность имен /// </summary> /// <param name="item">сущность</param> /// <returns>true или false</returns> public static bool CheckNameUniqueness(EntityObject item) => EntityObjectRepository.CheckNameUniqueness(item);
public static int[] GetParentIdsForTree(string entityTypeCode, int[] ids) => EntityObjectRepository.GetParentIdsForTree(entityTypeCode, ids);
/// <summary> /// Возвращает информацию о текущей сущности и всех предках /// </summary> /// <param name="entityTypeCode">код типа сущности</param> /// <param name="entityId">идентификатор сущности</param> /// <param name="parentEntityId">идентификатор родительской сущности</param> /// <returns>информация о текущей и родительской сущности</returns> public static IEnumerable <EntityInfo> GetParentsChain(string entityTypeCode, long entityId, long?parentEntityId) => EntityObjectRepository.GetParentsChain(entityTypeCode, entityId, parentEntityId);
/// <summary> /// Возвращает идентификатор родительской сущности /// </summary> /// <param name="entityTypeCode">код типа сущности</param> /// <param name="entityId">идентификатор сущности</param> /// <returns>идентификатор родительской сущности</returns> public static int?GetParentId(string entityTypeCode, int entityId) => EntityObjectRepository.GetParentId(entityTypeCode, entityId);
public static int[] GetParentIdsForTree(ParentIdsForTreeQuery query) => EntityObjectRepository.GetParentIdsForTree(query);
/// <summary> /// Возвращает название сущности /// </summary> /// <param name="entityTypeCode">код типа сущности</param> /// <param name="entityId">идентификатор сущности</param> /// <param name="parentEntityId"></param> /// <returns>название сущности</returns> public static string GetName(string entityTypeCode, int entityId, int parentEntityId) => EntityObjectRepository.GetName(entityTypeCode, entityId, parentEntityId);
/// <summary> /// Проверяет сущность на наличие вариаций /// </summary> /// <param name="entityTypeCode">код типа сущности</param> /// <param name="entityId">идентификатор сущности</param> /// <returns>результат проверки (true - есть вариации; false - нет)</returns> public static bool CheckForVariations(string entityTypeCode, int entityId) => EntityObjectRepository.CheckForVariations(entityTypeCode, entityId);
/// <summary> /// Проверяет сущность на наличие рекурсивных связей /// </summary> /// <param name="entityTypeCode">код типа сущности</param> /// <param name="entityId">идентификатор сущности</param> /// <returns>результат проверки (true - есть рекурсивные связи; false - нет)</returns> public static bool CheckPresenceSelfRelations(string entityTypeCode, int entityId) => EntityObjectRepository.CheckPresenceSelfRelations(entityTypeCode, entityId);
/// <summary> /// Проверяет существование сущности /// </summary> /// <param name="entityTypeCode">код типа сущности</param> /// <param name="entityId">идентификатор сущности</param> /// <returns>результат проверки (true - существует; false - не существует)</returns> public static bool CheckExistence(string entityTypeCode, int entityId) => EntityObjectRepository.CheckExistence(entityTypeCode, entityId);
public static void UnlockAllEntitiesLockedByCurrentUser()
{
EntityObjectRepository.UnlockAllEntitiesLockedByUser(QPContext.CurrentUserId);
}
