private static void SetToCache(UserToken userToken, EntityToken entityToken, IReadOnlyCollection<PermissionType> permissionTypes, object cachingKey)
{
// Using RequestLifetimeCache and there for no thread locking /MRJ
Dictionary<UserToken, Dictionary<EntityToken, IReadOnlyCollection<PermissionType>>> permissionTypeCache;
if (RequestLifetimeCache.HasKey(cachingKey))
{
permissionTypeCache = RequestLifetimeCache.TryGet<Dictionary<UserToken, Dictionary<EntityToken, IReadOnlyCollection<PermissionType>>>>(cachingKey);
}
else
{
permissionTypeCache = new Dictionary<UserToken, Dictionary<EntityToken, IReadOnlyCollection<PermissionType>>>();
RequestLifetimeCache.Add(cachingKey, permissionTypeCache);
}
Dictionary<EntityToken, IReadOnlyCollection<PermissionType>> entityTokenPermissionTypes;
if (!permissionTypeCache.TryGetValue(userToken, out entityTokenPermissionTypes))
{
entityTokenPermissionTypes = new Dictionary<EntityToken, IReadOnlyCollection<PermissionType>>();
permissionTypeCache.Add(userToken, entityTokenPermissionTypes);
}
if (!entityTokenPermissionTypes.ContainsKey(entityToken))
{
entityTokenPermissionTypes.Add(entityToken, permissionTypes);
}
else
{
entityTokenPermissionTypes[entityToken] = entityTokenPermissionTypes[entityToken].Concat(permissionTypes).Distinct().ToList();
}
}
public static ISecurityAncestorProvider GetSecurityAncestorProvider(EntityToken entityToken)
{
Verify.ArgumentNotNull(entityToken, "entityToken");
ISecurityAncestorProvider securityAncestorProvider;
Type entityTokenType = entityToken.GetType();
if (_securityAncestorProviderCache.TryGetValue(entityTokenType, out securityAncestorProvider) == false)
{
lock (_lock)
{
if (_securityAncestorProviderCache.TryGetValue(entityTokenType, out securityAncestorProvider) == false)
{
object[] attributes = entityTokenType.GetCustomAttributes(typeof(SecurityAncestorProviderAttribute), true);
Verify.That(attributes.Length > 0, "Missing {0} attribute on the entity token {1}", typeof(SecurityAncestorProviderAttribute), entityTokenType);
var attribute = (SecurityAncestorProviderAttribute)attributes[0];
Verify.IsNotNull(attribute.SecurityAncestorProviderType, "Security ancestor provider type can not be null on the entity token {0}", entityTokenType);
Verify.That(typeof(ISecurityAncestorProvider).IsAssignableFrom(attribute.SecurityAncestorProviderType), "Security ancestor provider '{0}' should implement the interface '{1}'", attribute.SecurityAncestorProviderType, typeof(ISecurityAncestorProvider));
securityAncestorProvider = (ISecurityAncestorProvider)Activator.CreateInstance(attribute.SecurityAncestorProviderType);
_securityAncestorProviderCache.Add(entityTokenType, securityAncestorProvider);
}
}
}
return securityAncestorProvider;
}
public static IEnumerable<EntityToken> GetParents(EntityToken entityToken)
{
if (entityToken == null) throw new ArgumentNullException("entityToken");
ISecurityAncestorProvider provider = SecurityAncestorProviderCache.GetSecurityAncestorProvider(entityToken);
IEnumerable<EntityToken> result = provider.GetParents(entityToken);
return result;
}
public XmlReader GetSearchFormDefinition(EntityToken entityToken)
{
IFormMarkupProvider markupProvider = new FormDefinitionFileMarkupProvider("/Administrative/AllFunctionsElementProviderSearchForm.xml");
return(markupProvider.GetReader());
}
protected override IFunctionTreeBuilderLeafInfo OnIsEntityOwner(EntityToken entityToken)
{
return(null);
}
/// <exclude />
public static FlowToken Execute(EntityToken entityToken, ActionToken actionToken, FlowControllerServicesContainer flowControllerServicesContainer, TaskManagerEvent taskManagerEvent)
{
if (entityToken == null)
{
throw new ArgumentNullException("entityToken");
}
if (actionToken == null)
{
throw new ArgumentNullException("actionToken");
}
string username = UserValidationFacade.GetUsername();
#if NO_SECURITY
#else
HookingFacade.EnsureInitialization();
IEnumerable <UserPermissionDefinition> userPermissionDefinitions = PermissionTypeFacade.GetUserPermissionDefinitions(username);
IEnumerable <UserGroupPermissionDefinition> userGroupPermissionDefinitions = PermissionTypeFacade.GetUserGroupPermissionDefinitions(username);
SecurityResult securityResult = SecurityResolver.Resolve(UserValidationFacade.GetUserToken(), actionToken, entityToken, userPermissionDefinitions, userGroupPermissionDefinitions);
if ((securityResult != SecurityResult.Allowed) && (entityToken.GetType() != typeof(SecurityViolationWorkflowEntityToken)))
{
return(ExecuteSecurityViolation(actionToken, entityToken, flowControllerServicesContainer));
}
#endif
bool ignoreLocking = actionToken.IsIgnoreEntityTokenLocking();
if ((ignoreLocking) ||
(ActionLockingFacade.IsLocked(entityToken) == false))
{
IActionExecutor actionExecutor = ActionExecutorCache.GetActionExecutor(actionToken);
ActionEventSystemFacade.FireOnBeforeActionExecution(entityToken, actionToken);
FlowToken flowToken;
using (TaskContainer taskContainer = TaskManagerFacade.CreateNewTasks(entityToken, actionToken, taskManagerEvent))
{
ITaskManagerFlowControllerService taskManagerService = null;
if (flowControllerServicesContainer.GetService(typeof(ITaskManagerFlowControllerService)) == null)
{
taskManagerService = new TaskManagerFlowControllerService(taskContainer);
flowControllerServicesContainer.AddService(taskManagerService);
}
try
{
if ((actionExecutor is IActionExecutorSerializedParameters))
{
string serializedEntityToken = EntityTokenSerializer.Serialize(entityToken);
string serializedActionToken = ActionTokenSerializer.Serialize(actionToken);
flowToken = Execute(actionExecutor as IActionExecutorSerializedParameters,
serializedEntityToken, serializedActionToken, actionToken,
flowControllerServicesContainer);
}
else
{
flowToken = Execute(actionExecutor, entityToken, actionToken,
flowControllerServicesContainer);
}
}
finally
{
if (taskManagerService != null)
{
flowControllerServicesContainer.RemoveService(taskManagerService);
}
}
taskContainer.SetOnIdleTaskManagerEvent(new FlowTaskManagerEvent(flowToken));
taskContainer.UpdateTasksWithFlowToken(flowToken);
taskContainer.SaveTasks();
}
ActionEventSystemFacade.FireOnAfterActionExecution(entityToken, actionToken, flowToken);
IManagementConsoleMessageService managementConsoleMessageService = flowControllerServicesContainer.GetService <IManagementConsoleMessageService>();
if (managementConsoleMessageService != null)
{
FlowControllerFacade.RegisterNewFlowInformation(flowToken, entityToken, actionToken, managementConsoleMessageService.CurrentConsoleId);
}
else
{
LoggingService.LogWarning("ActionExecutorFacade", "Missing ManagementConsoleMessageService, can not register the flow");
}
return(flowToken);
}
else
{
return(ExecuteEntityTokenLocked(actionToken, entityToken, flowControllerServicesContainer));
}
}
/// <exclude />
public static FlowToken ExecuteEntityTokenLocked(ActionToken lockedActionToken, EntityToken lockedEntityToken, FlowControllerServicesContainer flowControllerServicesContainer)
{
EntityToken entityToken = new EntityTokenLockedEntityToken(
ActionLockingFacade.LockedBy(lockedEntityToken),
ActionTokenSerializer.Serialize(lockedActionToken),
EntityTokenSerializer.Serialize(lockedEntityToken)
);
WorkflowActionToken actionToken = new WorkflowActionToken(WorkflowFacade.GetWorkflowType("Composite.C1Console.Actions.Workflows.EntityTokenLockedWorkflow"));
return(Execute(entityToken, actionToken, flowControllerServicesContainer));
}
/// <exclude />
public OpenExternalViewQueueItem(EntityToken entityToken)
{
this.EntityToken = EntityTokenSerializer.Serialize(entityToken);
}
private List <Element> GetElements(List <KeyValuePair <PageLocaleState, IPage> > pages, bool rootPages)
{
//ElementDragAndDropInfo dragAndDropInfo = new ElementDragAndDropInfo(typeof(IPage));
//dragAndDropInfo.AddDropType(typeof(IPage));
//dragAndDropInfo.SupportsIndexedPosition = true;
string editPageLabel = StringResourceSystemFacade.GetString("Composite.Plugins.PageElementProvider", "PageElementProvider.EditPage");
string editPageToolTip = StringResourceSystemFacade.GetString("Composite.Plugins.PageElementProvider", "PageElementProvider.EditPageToolTip");
string localizePageLabel = StringResourceSystemFacade.GetString("Composite.Plugins.PageElementProvider", "PageElementProvider.LocalizePage");
string localizePageToolTip = StringResourceSystemFacade.GetString("Composite.Plugins.PageElementProvider", "PageElementProvider.LocalizePageToolTip");
string addNewPageLabel = StringResourceSystemFacade.GetString("Composite.Plugins.PageElementProvider", "PageElementProvider.AddSubPageFormat");
//string addNewPageToolTip = StringResourceSystemFacade.GetString("Composite.Plugins.PageElementProvider", "PageElementProvider.AddSubPageToolTip");
string deletePageLabel = StringResourceSystemFacade.GetString("Composite.Plugins.PageElementProvider", "PageElementProvider.Delete");
string deletePageToolTip = StringResourceSystemFacade.GetString("Composite.Plugins.PageElementProvider", "PageElementProvider.DeleteToolTip");
string duplicatePageLabel = StringResourceSystemFacade.GetString("Composite.Plugins.PageElementProvider", "PageElementProvider.Duplicate");
string duplicatePageToolTip = StringResourceSystemFacade.GetString("Composite.Plugins.PageElementProvider", "PageElementProvider.DuplicateToolTip");
string urlMappingName = null;
if (UserSettings.ForeignLocaleCultureInfo != null)
{
urlMappingName = DataLocalizationFacade.GetCultureTitle(UserSettings.ForeignLocaleCultureInfo);
}
var elements = new Element[pages.Count];
var allPageTypes = DataFacade.GetData <IPageType>().AsEnumerable();
ParallelFacade.For("PageElementProvider. Getting elements", 0, pages.Count, i =>
{
var kvp = pages[i];
IPage page = kvp.Value;
EntityToken entityToken = page.GetDataEntityToken();
var dragAndDropInfo = new ElementDragAndDropInfo(typeof(IPage));
dragAndDropInfo.AddDropType(typeof(IPage));
dragAndDropInfo.SupportsIndexedPosition = true;
var element = new Element(_context.CreateElementHandle(entityToken), MakeVisualData(page, kvp.Key, urlMappingName, rootPages), dragAndDropInfo);
element.PropertyBag.Add("Uri", $"~/page({page.Id})");
element.PropertyBag.Add("ElementType", "application/x-composite-page");
element.PropertyBag.Add("DataId", page.Id.ToString());
if (kvp.Key == PageLocaleState.Own)
{
// Normal actions
element.AddAction(new ElementAction(new ActionHandle(new ProxyDataActionToken(ActionIdentifier.Edit, EditPermissionTypes)))
{
VisualData = new ActionVisualizedData
{
Label = editPageLabel,
ToolTip = editPageToolTip,
Icon = PageElementProvider.EditPage,
Disabled = false,
ActionLocation = new ActionLocation
{
ActionType = ActionType.Edit,
IsInFolder = false,
IsInToolbar = true,
ActionGroup = PrimaryActionGroup
}
}
});
IPageType parentPageType = allPageTypes.FirstOrDefault(f => f.Id == page.PageTypeId);
Verify.IsNotNull(parentPageType, "Failed to find page type by id '{0}'", page.PageTypeId);
element.AddAction(new ElementAction(new ActionHandle(new ProxyDataActionToken(ActionIdentifier.Duplicate, DuplicatePermissionTypes)))
{
VisualData = new ActionVisualizedData
{
Label = duplicatePageLabel,
ToolTip = duplicatePageToolTip,
Icon = PageElementProvider.DuplicatePage,
Disabled = false,
ActionLocation = new ActionLocation
{
ActionType = ActionType.Add,
IsInFolder = false,
IsInToolbar = true,
ActionGroup = PrimaryActionGroup
}
}
});
foreach (var pageType in page.GetChildPageSelectablePageTypes().OrderByDescending(pt => pt.Id == parentPageType.DefaultChildPageType))
{
element.AddAction(new ElementAction(new ActionHandle(new PageAddActionToken(pageType.Id, ActionIdentifier.Add, AddPermissionTypes)
{
DoIgnoreEntityTokenLocking = true
}))
{
VisualData = new ActionVisualizedData
{
Label = string.Format(addNewPageLabel, pageType.Name),
ToolTip = pageType.Description,
Icon = PageElementProvider.AddPage,
Disabled = false,
ActionLocation = new ActionLocation
{
ActionType = ActionType.Add,
IsInFolder = false,
IsInToolbar = true,
ActionGroup = PrimaryActionGroup,
ActionBundle = "AddPage"
}
}
});
}
element.AddAction(new ElementAction(new ActionHandle(new ProxyDataActionToken(ActionIdentifier.Delete, DeletePermissionTypes)))
{
VisualData = new ActionVisualizedData
{
Label = deletePageLabel,
ToolTip = deletePageToolTip,
Icon = DeletePage,
Disabled = false,
ActionLocation = new ActionLocation
{
ActionType = ActionType.Delete,
IsInFolder = false,
IsInToolbar = true,
ActionGroup = PrimaryActionGroup
}
}
});
_pageAssociatedHelper.AttachElementActions(element, page);
}
else if (kvp.Key == PageLocaleState.ForeignActive)
{
// Localized actions
bool addAction = false;
Guid parentId = page.GetParentId();
if (parentId == Guid.Empty)
{
addAction = true;
}
else
{
using (new DataScope(DataScopeIdentifier.Administrated, UserSettings.ActiveLocaleCultureInfo))
{
bool exists = DataFacade.GetData <IPage>(f => f.Id == parentId).Any();
if (exists)
{
addAction = true;
}
}
}
if (addAction)
{
element.AddAction(new ElementAction(new ActionHandle(new WorkflowActionToken(WorkflowFacade.GetWorkflowType("Composite.Plugins.Elements.ElementProviders.PageElementProvider.LocalizePageWorkflow"), LocalizePermissionTypes)))
{
VisualData = new ActionVisualizedData
{
Label = localizePageLabel,
ToolTip = localizePageToolTip,
Icon = PageElementProvider.LocalizePage,
Disabled = false,
ActionLocation = new ActionLocation
{
ActionType = ActionType.Edit,
IsInFolder = false,
IsInToolbar = true,
ActionGroup = PrimaryActionGroup
}
}
});
}
}
elements[i] = element;
});
return(new List <Element>(elements));
}
/// <exclude />
public DataTypeDescriptorFormsHelper(DataTypeDescriptor dataTypeDescriptor, string bindingNamesPrefix, bool showPublicationStatusSelector, EntityToken entityToken)
{
if (dataTypeDescriptor == null)
{
throw new ArgumentNullException("dataTypeDescriptor");
}
_dataTypeDescriptor = dataTypeDescriptor;
_bindingNamesPrefix = bindingNamesPrefix;
_showPublicationStatusSelector = showPublicationStatusSelector;
EntityToken = entityToken;
LayoutIconHandle = null;
}
/// <exclude />
public DataTypeDescriptorFormsHelper(DataTypeDescriptor dataTypeDescriptor, bool showPublicationStatusSelector, EntityToken entityToken)
: this(dataTypeDescriptor, null, showPublicationStatusSelector, entityToken)
{
}
private static Dictionary <string, string> GetAvailablePublishingFlowTransitions(EntityToken entityToken)
{
var transitionNames = new Dictionary <string, string>
{
{ GenericPublishProcessController.Draft, LocalizationFiles.Composite_Management.PublishingStatus_draft },
{ GenericPublishProcessController.AwaitingApproval, LocalizationFiles.Composite_Management.PublishingStatus_awaitingApproval }
};
var username = UserValidationFacade.GetUsername();
var userPermissionDefinitions = PermissionTypeFacade.GetUserPermissionDefinitions(username);
var userGroupPermissionDefinition = PermissionTypeFacade.GetUserGroupPermissionDefinitions(username);
var currentPermissionTypes = PermissionTypeFacade.GetCurrentPermissionTypes(UserValidationFacade.GetUserToken(), entityToken, userPermissionDefinitions, userGroupPermissionDefinition);
foreach (var permissionType in currentPermissionTypes)
{
if (GenericPublishProcessController.AwaitingPublicationActionPermissionType.Contains(permissionType))
{
transitionNames.Add(GenericPublishProcessController.AwaitingPublication,
LocalizationFiles.Composite_Management.PublishingStatus_awaitingPublication);
break;
}
}
return(transitionNames);
}
protected BasePackItem(EntityToken entityToken)
{
this._entityToken = entityToken;
}
public string TryGetUrl(EntityToken entityToken) => null;
/// <exclude />
public override IEnumerable <EntityToken> GetEntityTokens(EntityToken childEntityToken, TreeNodeDynamicContext dynamicContext)
{
IEnumerable <IData> dataset = GetDataset(dynamicContext, false).DataItems;
return(dataset.Select(f => (EntityToken)f.GetDataEntityToken()).Evaluate());
}
private Element BuildElement(IData data,
DynamicValuesHelperReplaceContext replaceContext,
TreeNodeDynamicContext dynamicContext,
bool localizationEnabled,
List <object> itemKeys,
ref IEnumerable <object> keysJoinedByParentFilters,
EntityToken parentEntityToken
)
{
replaceContext.CurrentDataItem = data;
object keyValue = this.KeyPropertyInfo.GetValue(data, null);
bool itemLocalizationEnabledAndForeign = localizationEnabled && !data.DataSourceId.LocaleScope.Equals(UserSettings.ActiveLocaleCultureInfo);
if (itemLocalizationEnabledAndForeign && itemKeys.Contains(keyValue))
{
return(null);
}
var currentEntityToken = data.GetDataEntityToken();
var element = new Element(new ElementHandle
(
dynamicContext.ElementProviderName,
currentEntityToken,
dynamicContext.Piggybag.PreparePiggybag(this.ParentNode, parentEntityToken)
));
if (parentEntityToken is TreePerspectiveEntityToken)
{
element.ElementHandle.Piggyback[StringConstants.PiggybagTreeId] = Tree.TreeId;
}
bool hasChildren;
bool isDisabled = false;
ResourceHandle icon, openedIcon;
if (itemLocalizationEnabledAndForeign)
{
hasChildren = false;
isDisabled = !data.IsTranslatable();
if (this.Icon != null)
{
icon = this.Icon;
openedIcon = this.OpenedIcon;
}
else
{
icon = data.GetForeignIcon();
openedIcon = icon;
}
}
else
{
if (this.Display != LeafDisplayMode.Auto)
{
hasChildren = ChildNodes.Any();
}
else
{
hasChildren = ChildNodes.OfType <SimpleElementTreeNode>().Any();
if (!hasChildren)
{
if (keysJoinedByParentFilters != null)
{
keysJoinedByParentFilters = keysJoinedByParentFilters.Evaluate();
hasChildren = keysJoinedByParentFilters.Contains(keyValue);
}
}
// Checking children filtered by FunctionFilters
if (!hasChildren)
{
foreach (var childNode in this.ChildNodes.OfType <DataElementsTreeNode>()
.Where(n => n.FilterNodes.OfType <FunctionFilterNode>().Any()))
{
var newDynamicContext = new TreeNodeDynamicContext(TreeNodeDynamicContextDirection.Down)
{
ElementProviderName = dynamicContext.ElementProviderName,
Piggybag = dynamicContext.Piggybag.PreparePiggybag(this.ParentNode, parentEntityToken),
CurrentEntityToken = currentEntityToken
};
if (childNode.GetDataset(newDynamicContext, false).DataItems.Any())
{
hasChildren = true;
break;
}
}
}
}
if (this.Icon != null)
{
icon = this.Icon;
openedIcon = this.OpenedIcon;
}
else
{
openedIcon = icon = data.GetIcon();
}
}
string label = this.Label.IsNullOrEmpty()
? data.GetLabel()
: this.LabelDynamicValuesHelper.ReplaceValues(replaceContext);
string toolTip = this.ToolTip.IsNullOrEmpty()
? label
: this.ToolTipDynamicValuesHelper.ReplaceValues(replaceContext);
if (itemLocalizationEnabledAndForeign)
{
label = string.Format("{0} ({1})", label, DataLocalizationFacade.GetCultureTitle(UserSettings.ForeignLocaleCultureInfo));
if (!data.IsTranslatable())
{
toolTip = StringResourceSystemFacade.GetString("Composite.C1Console.Trees", "LocalizeDataWorkflow.DisabledData");
}
else
{
toolTip = string.Format("{0} ({1})", toolTip, DataLocalizationFacade.GetCultureTitle(UserSettings.ForeignLocaleCultureInfo));
}
}
element.VisualData = new ElementVisualizedData
{
Label = label,
ToolTip = toolTip,
HasChildren = hasChildren,
Icon = icon,
OpenedIcon = openedIcon,
IsDisabled = isDisabled
};
if (InternalUrls.DataTypeSupported(data.DataSourceId.InterfaceType))
{
var dataReference = data.ToDataReference();
if (DataUrls.CanBuildUrlForData(dataReference))
{
string internalUrl = InternalUrls.TryBuildInternalUrl(dataReference);
if (internalUrl != null)
{
element.PropertyBag.Add("Uri", internalUrl);
}
}
}
if (itemLocalizationEnabledAndForeign)
{
var actionToken = new WorkflowActionToken(
WorkflowFacade.GetWorkflowType("Composite.C1Console.Trees.Workflows.LocalizeDataWorkflow"),
LocalizeDataPermissionTypes);
element.AddAction(new ElementAction(new ActionHandle(actionToken))
{
VisualData = new ActionVisualizedData
{
Label = StringResourceSystemFacade.GetString("Composite.C1Console.Trees", "LocalizeDataWorkflow.LocalizeDataLabel"),
ToolTip = StringResourceSystemFacade.GetString("Composite.C1Console.Trees", "LocalizeDataWorkflow.LocalizeDataToolTip"),
Icon = LocalizeDataTypeIcon,
Disabled = false,
ActionLocation = ActionLocation.OtherPrimaryActionLocation
}
});
}
return(element);
}
public static IReadOnlyCollection<PermissionType> GetUserGroupPermissionTypes(UserToken userToken, EntityToken entityToken)
{
return GetFromCache(userToken, entityToken, UserGroupPermissionTypeCachingKey);
}
/// <exclude />
protected void SetSaveStatus(bool succeeded, EntityToken entityToken)
{
string serializedEntityToken = EntityTokenSerializer.Serialize(entityToken, true);
SetSaveStatus(succeeded, serializedEntityToken);
}
/// <exclude />
public void ExecuteWorklow(EntityToken entityToken, Type workflowType)
{
ExecuteAction(entityToken, new WorkflowActionToken(workflowType));
}
/// <exclude />
protected AddNewTreeRefresher CreateAddNewTreeRefresher(EntityToken parentEntityToken)
{
return(new AddNewTreeRefresher(parentEntityToken, WorkflowFacade.GetFlowControllerServicesContainer(WorkflowEnvironment.WorkflowInstanceId)));
}
public FlowToken Execute(EntityToken entityToken, ActionToken actionToken, FlowControllerServicesContainer flowControllerServicesContainer)
{
DataEntityToken token = (DataEntityToken)entityToken;
IPublishControlled publishControlled = (IPublishControlled)DataFacade.GetDataFromDataSourceId(token.DataSourceId);
ValidationResults validationResults = ValidationFacade.Validate((IData)publishControlled);
if (validationResults.IsValid)
{
UpdateTreeRefresher treeRefresher = new UpdateTreeRefresher(token.Data.GetDataEntityToken(), flowControllerServicesContainer);
if (actionToken is PublishActionToken)
{
publishControlled.PublicationStatus = Published;
}
else if (actionToken is DraftActionToken)
{
publishControlled.PublicationStatus = Draft;
}
else if (actionToken is AwaitingApprovalActionToken)
{
publishControlled.PublicationStatus = AwaitingApproval;
}
else if (actionToken is AwaitingPublicationActionToken)
{
publishControlled.PublicationStatus = AwaitingPublication;
}
else if (actionToken is UnpublishActionToken)
{
publishControlled.PublicationStatus = Draft;
using (TransactionScope transactionScope = TransactionsFacade.CreateNewScope())
{
IData data = DataFacade.GetDataFromOtherScope(token.Data, DataScopeIdentifier.Public).SingleOrDefault();
if (data != null)
{
IPage page = data as IPage;
if (page != null)
{
IEnumerable <IData> referees;
using (new DataScope(DataScopeIdentifier.Public))
{
referees = page.GetMetaData();
}
DataFacade.Delete(referees, CascadeDeleteType.Disable);
}
DataFacade.Delete(data, CascadeDeleteType.Disable);
}
transactionScope.Complete();
}
}
else if (actionToken is UndoPublishedChangesActionToken)
{
using (TransactionScope transactionScope = TransactionsFacade.CreateNewScope())
{
using (ProcessControllerFacade.NoProcessControllers)
{
var administrativeData = (IPublishControlled)token.Data;
IData publishedData = DataFacade.GetDataFromOtherScope(token.Data, DataScopeIdentifier.Public).Single();
publishedData.FullCopyChangedTo(administrativeData);
administrativeData.PublicationStatus = Draft;
DataFacade.Update(administrativeData);
}
transactionScope.Complete();
}
}
else
{
throw new ArgumentException("Unknown action token", "actionToken");
}
DataFacade.Update(publishControlled);
treeRefresher.PostRefreshMesseges(publishControlled.GetDataEntityToken());
}
else
{
var managementConsoleMessageService = flowControllerServicesContainer.GetService <IManagementConsoleMessageService>();
StringBuilder sb = new System.Text.StringBuilder();
sb.AppendLine(StringResourceSystemFacade.GetString("Composite.Plugins.GenericPublishProcessController", "ValidationErrorMessage"));
foreach (ValidationResult result in validationResults)
{
sb.AppendLine(result.Message);
}
managementConsoleMessageService.ShowMessage(DialogType.Error, StringResourceSystemFacade.GetString("Composite.Plugins.GenericPublishProcessController", "ValidationErrorTitle"), sb.ToString());
}
return(null);
}
/// <exclude />
protected DeleteTreeRefresher CreateDeleteTreeRefresher(EntityToken beforeDeleteEntityToken)
{
return(new DeleteTreeRefresher(beforeDeleteEntityToken, WorkflowFacade.GetFlowControllerServicesContainer(WorkflowEnvironment.WorkflowInstanceId)));
}
public IEnumerable <Element> Provide(ElementProviderContext context, EntityToken token)
{
var returnList = new List <Element>();
var dataSourceToken = (DataSourceEntityToken)token;
var type = Type.GetType(dataSourceToken.Type);
if (type != typeof(StringBasedDataSourceAttribute))
{
return(returnList);
}
var form = DynamicFormsFacade.GetFormByName(dataSourceToken.FormName);
if (form == null)
{
return(returnList);
}
var field = form.Model.Fields.Get(dataSourceToken.FieldName);
if (field == null)
{
return(returnList);
}
var dataSource = field.DataSource;
if (dataSource == null)
{
return(returnList);
}
foreach (var entry in dataSource)
{
var fieldsElementHandle = context.CreateElementHandle(new StringBasedDataSourceEntryEntityToken(form.Name, field.Name, entry.Key));
var fieldElement = new Element(fieldsElementHandle)
{
VisualData = new ElementVisualizedData
{
Label = entry.Key,
ToolTip = entry.Key,
HasChildren = false,
Icon = ResourceHandle.BuildIconFromDefaultProvider("localization-element-closed-root"),
OpenedIcon = ResourceHandle.BuildIconFromDefaultProvider("localization-element-opened-root")
}
};
var deleteActionToken = new ConfirmWorkflowActionToken("Delete: " + entry.Key, typeof(DeleteStringBasedDataSourceEntryActionToken));
fieldElement.AddAction(new ElementAction(new ActionHandle(deleteActionToken))
{
VisualData = new ActionVisualizedData
{
Label = "Delete",
ToolTip = "Delete",
Icon = ResourceHandle.BuildIconFromDefaultProvider("generated-type-data-delete"),
ActionLocation = ActionLocation
}
});
returnList.Add(fieldElement);
}
return(returnList);
}
/// <exclude />
protected void RefreshEntityToken(EntityToken entityToken)
{
SpecificTreeRefresher specificTreeRefresher = this.CreateSpecificTreeRefresher();
specificTreeRefresher.PostRefreshMesseges(entityToken);
}
/// <exclude />
public static FlowToken Execute(EntityToken entityToken, ActionToken actionToken, FlowControllerServicesContainer flowControllerServicesContainer)
{
return(Execute(entityToken, actionToken, flowControllerServicesContainer, null));
}
/// <exclude />
protected void AcquireLock(EntityToken entityToken)
{
ActionLockingFacade.AcquireLock(entityToken, this.WorkflowInstanceId);
}
public override void OnGetPrettyHtml(EntityTokenHtmlPrettyfier prettyfier)
{
EntityToken parentEntityToken = this.ParentEntityToken;
prettyfier.OnWriteType = (token, helper) => helper.AddFullRow(new string[] { "<b>Type</b>", string.Format("<b>ParentEntityToken:</b><br /><b>Type:</b> {0}<br /><b>Source:</b> {1}<br /><b>Id:</b>{2}<br />", parentEntityToken.Type, parentEntityToken.Source, parentEntityToken.Id) });
}
private void saveCodeActivity_Save_ExecuteCode(object sender, EventArgs e)
{
IUserGroup userGroup = this.GetBinding <IUserGroup>("UserGroup");
List <string> newUserGroupEntityTokens = ActivePerspectiveFormsHelper.GetSelectedSerializedEntityTokens(this.Bindings).ToList();
// If current user belongs to currently edited group -> checking that user won't lost access "Users" perspective
if (!ValidateUserPreservesAdminRights(userGroup, newUserGroupEntityTokens))
{
return;
}
UpdateTreeRefresher updateTreeRefresher = CreateUpdateTreeRefresher(this.EntityToken);
EntityToken rootEntityToken = ElementFacade.GetRootsWithNoSecurity().Select(f => f.ElementHandle.EntityToken).Single();
IEnumerable <PermissionType> newPermissionTypes = GlobalPermissionsFormsHelper.GetSelectedPermissionTypes(this.Bindings);
UserGroupPermissionDefinition userGroupPermissionDefinition =
new ConstructorBasedUserGroupPermissionDefinition(
userGroup.Id,
newPermissionTypes,
EntityTokenSerializer.Serialize(rootEntityToken)
);
PermissionTypeFacade.SetUserGroupPermissionDefinition(userGroupPermissionDefinition);
UserGroupPerspectiveFacade.SetSerializedEntityTokens(userGroup.Id, newUserGroupEntityTokens);
List <CultureInfo> selectedUserGroupActiveLocales = ActiveLocalesFormsHelper.GetSelectedLocalesTypes(this.Bindings).ToList();
using (var connection = new DataConnection())
{
var existingLocales = connection.Get <IUserGroupActiveLocale>().Where(f => f.UserGroupId == userGroup.Id).ToList();
var toDelete = existingLocales.Where(f => !selectedUserGroupActiveLocales.Contains(new CultureInfo(f.CultureName)));
connection.Delete <IUserGroupActiveLocale>(toDelete);
foreach (var localeToAdd in selectedUserGroupActiveLocales.Where(f => !existingLocales.Any(g => g.CultureName == f.Name)))
{
var toAdd = connection.CreateNew <IUserGroupActiveLocale>();
toAdd.Id = Guid.NewGuid();
toAdd.UserGroupId = userGroup.Id;
toAdd.CultureName = localeToAdd.Name;
connection.Add(toAdd);
}
}
SetSaveStatus(true);
LoggingService.LogEntry("UserManagement",
$"C1 Console user group '{userGroup.Name}' updated by '{UserValidationFacade.GetUsername()}'.",
LoggingService.Category.Audit,
TraceEventType.Information);
if (userGroup.Name != this.GetBinding <string>("OldName"))
{
DataFacade.Update(userGroup);
this.UpdateBinding("OldName", userGroup.Name);
updateTreeRefresher.PostRefreshMesseges(userGroup.GetDataEntityToken());
}
}
public SearchToken GetNewSearchToken(EntityToken entityToken)
{
return(new AllFunctionsElementProviderSearchToken());
}
internal override IEnumerable <EntityToken> FilterParentGeneretedEntityTokens(EntityToken selfEntityToken, IEnumerable <EntityToken> parentGeneretedEntityTokens, TreeNodeDynamicContext dynamicContext)
{
// Check below ensures that the parent EntityToken actually present in a tree and not been filtered out
var treeSimpleElementEntityToken = (TreeSimpleElementEntityToken)selfEntityToken;
var parentEntityToken = treeSimpleElementEntityToken.ParentEntityToken;
foreach (EntityToken entityToken in parentGeneretedEntityTokens)
{
if (parentEntityToken.Equals(entityToken))
{
return(new[] { parentEntityToken });
}
var castedEntityToken = entityToken as TreeSimpleElementEntityToken;
if (castedEntityToken != null &&
parentEntityToken.Equals(castedEntityToken.ParentEntityToken))
{
return(new [] { parentEntityToken });
}
}
return(Array.Empty <EntityToken>());
}
public IEnumerable <Element> GetChildren(EntityToken parentEntityToken, Dictionary <string, string> piggybag)
{
TreeSharedRootsFacade.Initialize(Context.ProviderName);
List <Tree> trees;
if (parentEntityToken is TreePerspectiveEntityToken)
{
if (TreeSharedRootsFacade.SharedRootFolders.ContainsKey(parentEntityToken.Id))
{
trees = TreeSharedRootsFacade.SharedRootFolders[parentEntityToken.Id].Trees;
}
else
{
trees = new List <Tree>();
}
}
else
{
if (piggybag.ContainsKey(StringConstants.PiggybagTreeId))
{
string treeId = piggybag.Where(f => f.Key == StringConstants.PiggybagTreeId).SingleOrDefault().Value;
Tree tree = TreeFacade.GetTree(treeId);
if (tree == null)
{
return new Element[] { }
}
;
trees = new List <Tree> {
tree
};
}
else
{
trees = new List <Tree>();
int counter = 0;
while (true)
{
string key = StringConstants.PiggybagSharedTreeId + (counter++);
if (!piggybag.ContainsKey(key))
{
break;
}
string treeId = piggybag[key];
Tree tree = TreeFacade.GetTree(treeId);
if (tree != null)
{
trees.Add(tree);
}
}
}
}
IEnumerable <Element> result = new List <Element>();
foreach (Tree tree in trees)
{
TreeNodeDynamicContext dynamicContext = new TreeNodeDynamicContext(TreeNodeDynamicContextDirection.Down)
{
ElementProviderName = this.Context.ProviderName,
Piggybag = piggybag,
CurrentEntityToken = parentEntityToken
};
try
{
if (parentEntityToken is TreePerspectiveEntityToken)
{
TreeNode treeNode = tree.RootTreeNode;
dynamicContext.CurrentTreeNode = treeNode;
IEnumerable <Element> elements = treeNode.ChildNodes.GetElements(parentEntityToken, dynamicContext);
result = result.ConcatOrDefault(elements);
}
else if (parentEntityToken is TreeSimpleElementEntityToken)
{
TreeNode treeNode = tree.GetTreeNode(parentEntityToken.Id);
if (treeNode == null)
{
throw new InvalidOperationException("Tree is out of sync");
}
dynamicContext.CurrentTreeNode = treeNode;
IEnumerable <Element> elements = treeNode.ChildNodes.GetElements(parentEntityToken, dynamicContext);
result = result.ConcatOrDefault(elements);
}
else if (parentEntityToken is TreeFunctionElementGeneratorEntityToken)
{
TreeNode treeNode = tree.GetTreeNode(parentEntityToken.Id);
if (treeNode == null)
{
throw new InvalidOperationException("Tree is out of sync");
}
dynamicContext.CurrentTreeNode = treeNode;
IEnumerable <Element> elements = treeNode.ChildNodes.GetElements(parentEntityToken, dynamicContext);
result = result.ConcatOrDefault(elements);
}
else if (parentEntityToken is TreeDataFieldGroupingElementEntityToken)
{
TreeDataFieldGroupingElementEntityToken castedParentEntityToken = parentEntityToken as TreeDataFieldGroupingElementEntityToken;
TreeNode treeNode = tree.GetTreeNode(parentEntityToken.Id);
if (treeNode == null)
{
throw new InvalidOperationException("Tree is out of sync");
}
dynamicContext.CurrentTreeNode = treeNode;
dynamicContext.FieldGroupingValues = castedParentEntityToken.GroupingValues;
dynamicContext.FieldFolderRangeValues = castedParentEntityToken.FolderRangeValues;
IEnumerable <Element> elements = treeNode.ChildNodes.GetElements(parentEntityToken, dynamicContext);
result = result.ConcatOrDefault(elements);
}
else if (parentEntityToken is DataEntityToken)
{
DataEntityToken dataEntityToken = parentEntityToken as DataEntityToken;
Type interfaceType = dataEntityToken.InterfaceType;
List <TreeNode> treeNodes;
if (tree.BuildProcessContext.DataInteraceToTreeNodes.TryGetValue(interfaceType, out treeNodes) == false)
{
throw new InvalidOperationException();
}
string parentNodeId = piggybag.GetParentIdFromPiggybag();
TreeNode treeNode = treeNodes.Where(f => f.ParentNode.Id == parentNodeId).SingleOrDefault();
if (treeNode == null)
{
throw new InvalidOperationException("Tree is out of sync");
}
dynamicContext.CurrentTreeNode = treeNode;
IEnumerable <Element> elements = treeNode.ChildNodes.GetElements(parentEntityToken, dynamicContext);
result = result.ConcatOrDefault(elements);
}
else
{
throw new NotImplementedException("Unhandled entityt token type");
}
result = result.Evaluate();
}
catch (Exception ex)
{
LoggingService.LogError("TreeFacade", string.Format("Getting elements from the three '{0}' failed", tree.TreeId));
LoggingService.LogError("TreeFacade", ex);
Element errorElement = ShowErrorElementHelper.CreateErrorElement(
StringResourceSystemFacade.GetString("Composite.C1Console.Trees", "KeyFacade.ErrorTreeNode.Label"),
tree.TreeId,
ex.Message);
return(new Element[] { errorElement });
}
}
return(result);
}
}
public override AncestorResult GetParentEntityToken(EntityToken ownEntityToken, Type parentInterfaceOfInterest, TreeNodeDynamicContext dynamicContext)
{
return(new AncestorResult(this.ParentNode, ((TreeSimpleElementEntityToken)ownEntityToken).ParentEntityToken));
}
private static IReadOnlyCollection<PermissionType> GetFromCache(UserToken userToken, EntityToken entityToken, object cachingKey)
{
// Using RequestLifetimeCache and there for no thread locking /MRJ
Dictionary<UserToken, Dictionary<EntityToken, IReadOnlyCollection<PermissionType>>> permissionTypeCache;
if (RequestLifetimeCache.HasKey(cachingKey))
{
permissionTypeCache = RequestLifetimeCache.TryGet<Dictionary<UserToken, Dictionary<EntityToken, IReadOnlyCollection<PermissionType>>>>(cachingKey);
}
else
{
permissionTypeCache = new Dictionary<UserToken, Dictionary<EntityToken, IReadOnlyCollection<PermissionType>>>();
RequestLifetimeCache.Add(cachingKey, permissionTypeCache);
}
Dictionary<EntityToken, IReadOnlyCollection<PermissionType>> entityTokenPermissionTypes;
if (!permissionTypeCache.TryGetValue(userToken, out entityTokenPermissionTypes))
{
entityTokenPermissionTypes = new Dictionary<EntityToken, IReadOnlyCollection<PermissionType>>();
permissionTypeCache.Add(userToken, entityTokenPermissionTypes);
}
IReadOnlyCollection<PermissionType> permissionTypes;
entityTokenPermissionTypes.TryGetValue(entityToken, out permissionTypes);
return permissionTypes;
}
public IEnumerable <Element> GetForeignChildren(EntityToken entityToken, SearchToken searchToken)
{
if (entityToken is DataEntityToken dataEntityToken && dataEntityToken.Data == null)
{
return(Array.Empty <Element>());
}
if (entityToken is AssociatedDataElementProviderHelperEntityToken associatedData)
{
return(_pageAssociatedHelper.GetChildren(associatedData, true));
}
if (entityToken is DataGroupingProviderHelperEntityToken dataGrouping)
{
return(_pageAssociatedHelper.GetChildren(dataGrouping, true));
}
IEnumerable <IPage> pages;
using (new DataScope(DataScopeIdentifier.Administrated))
{
pages = GetChildrenPages(entityToken, searchToken).ToList();
}
IEnumerable <IPage> foreignAdministratedPages;
using (new DataScope(DataScopeIdentifier.Administrated, UserSettings.ForeignLocaleCultureInfo))
{
foreignAdministratedPages = GetChildrenPages(entityToken, searchToken).ToList();
}
IEnumerable <IPage> foreignPublicPages;
using (new DataScope(DataScopeIdentifier.Public, UserSettings.ForeignLocaleCultureInfo))
{
foreignPublicPages = GetChildrenPages(entityToken, searchToken).ToList();
}
Guid?itemId = GetParentPageId(entityToken);
if (itemId.HasValue == false)
{
return new Element[] { }
}
;
IEnumerable <Guid> childPageIds =
(from ps in DataFacade.GetData <IPageStructure>()
where ps.ParentId == itemId.Value
orderby ps.LocalOrdering
select ps.Id).ToList();
var resultPages = new List <KeyValuePair <PageLocaleState, IPage> >();
foreach (Guid pageId in childPageIds)
{
if (pages.Any(f => f.Id == pageId))
{
resultPages.AddRange(
pages.Where(f => f.Id == pageId)
.Select(p => new KeyValuePair <PageLocaleState, IPage>(PageLocaleState.Own, p)));
}
else if (foreignAdministratedPages.Any(f => f.Id == pageId && f.IsTranslatable()))
{
resultPages.AddRange(
foreignAdministratedPages.Where(f => f.Id == pageId && f.IsTranslatable())
.Select(p => new KeyValuePair <PageLocaleState, IPage>(PageLocaleState.ForeignActive, p)));
}
else if (foreignPublicPages.Any(f => f.Id == pageId))
{
resultPages.AddRange(
foreignPublicPages.Where(f => f.Id == pageId)
.Select(p => new KeyValuePair <PageLocaleState, IPage>(PageLocaleState.ForeignActive, p)));
}
else if (foreignAdministratedPages.Any(f => f.Id == pageId))
{
resultPages.AddRange(
foreignAdministratedPages.Where(f => f.Id == pageId)
.Select(p => new KeyValuePair <PageLocaleState, IPage>(PageLocaleState.ForeignDisabled, p)));
}
}
List <Element> childPageElements = GetElements(resultPages, entityToken is PageElementProviderEntityToken);
return(GetChildElements(entityToken, childPageElements));
}
public static void SetUserGroupPermissionTypes(UserToken userToken, EntityToken entityToken, IReadOnlyCollection<PermissionType> permissionTypes)
{
SetToCache(userToken, entityToken, permissionTypes, UserGroupPermissionTypeCachingKey);
}
public bool OnElementDraggedAndDropped(EntityToken draggedEntityToken, EntityToken newParentEntityToken, int dropIndex, DragAndDropType dragAndDropType, FlowControllerServicesContainer flowControllerServicesContainer)
{
IPage draggedPage = (IPage)((DataEntityToken)draggedEntityToken).Data;
Verify.IsNotNull(draggedPage, "Dragged page does not exist");
Guid newParentPageId;
if (newParentEntityToken is PageElementProviderEntityToken)
{
newParentPageId = Guid.Empty;
}
else if (newParentEntityToken is DataEntityToken dataEntityToken)
{
IPage newParentPage = dataEntityToken.Data as IPage;
newParentPageId = newParentPage.Id;
}
else
{
throw new NotImplementedException();
}
IPage oldParent = null;
Guid oldParentId = draggedPage.GetParentId();
if (oldParentId != Guid.Empty)
{
oldParent = DataFacade.GetData <IPage>(f => f.Id == oldParentId).FirstOrDefault();
}
if (dragAndDropType == DragAndDropType.Move)
{
using (var transactionScope = TransactionsFacade.CreateNewScope())
{
string urlTitle = draggedPage.UrlTitle;
int counter = 1;
while (true)
{
bool urlTitleClash =
(from p in PageServices.GetChildren(newParentPageId).AsEnumerable()
where p.UrlTitle == urlTitle && p.Id != draggedPage.Id
select p).Any();
if (!urlTitleClash)
{
break;
}
urlTitle = $"{draggedPage.UrlTitle}{counter++}";
}
draggedPage.UrlTitle = urlTitle;
// Real drop index takes into account pages from other locales
int realDropIndex = GetRealDropIndex(draggedPage, newParentPageId, dropIndex);
draggedPage.MoveTo(newParentPageId, realDropIndex, false);
DataFacade.Update(draggedPage);
EntityTokenCacheFacade.ClearCache(draggedPage.GetDataEntityToken());
transactionScope.Complete();
}
}
else
{
throw new NotImplementedException();
}
if (oldParent != null)
{
var oldParentParentTreeRefresher = new ParentTreeRefresher(flowControllerServicesContainer);
oldParentParentTreeRefresher.PostRefreshMesseges(oldParent.GetDataEntityToken());
}
else
{
var oldParentspecificTreeRefresher = new SpecificTreeRefresher(flowControllerServicesContainer);
oldParentspecificTreeRefresher.PostRefreshMesseges(new PageElementProviderEntityToken(_context.ProviderName));
}
var newParentParentTreeRefresher = new ParentTreeRefresher(flowControllerServicesContainer);
newParentParentTreeRefresher.PostRefreshMesseges(newParentEntityToken);
return(true);
}
/// <exclude />
public SecurityToken(EntityToken entityToken, ActionToken actionToken, UserToken userToken)
{
_entityToken = entityToken;
_actionToken = actionToken;
_userToken = userToken;
}
/// <exclude />
public IEnumerable<EntityToken> GetParents(EntityToken entityToken)
{
if (entityToken == null) throw new ArgumentNullException("entityToken");
return new EntityToken[] { };
}
