/// <exclude />
public static ClientElement GetRoot()
{
List <Element> roots = ElementFacade.GetRoots(null).ToList();
if (roots.Count == 0)
{
// user with out any access logging in - return "empty root"
roots = ElementFacade.GetRootsWithNoSecurity().ToList();
if (roots.Count == 0)
{
throw new InvalidOperationException("No roots specified");
}
if (roots.Count > 1)
{
throw new InvalidOperationException("More than one root specified");
}
var emptyElement = new Element(new ElementHandle("nullRoot", new NullRootEntityToken()));
emptyElement.VisualData = new ElementVisualizedData {
HasChildren = false, Label = "nullroot", Icon = CommonElementIcons.Folder
};
roots.Clear();
roots.Add(emptyElement);
}
else if (roots.Count > 1)
{
throw new InvalidOperationException("More than one root specified");
}
return(roots[0].GetClientElement());
}
private void CreateHooks(string parentId, IEnumerable <VirtualElementConfigurationElement> elements, List <EntityTokenHook> foundHooks)
{
var entityToken = new VirtualElementProviderEntityToken(_context.ProviderName, parentId);
var entityTokenHook = new EntityTokenHook(entityToken);
foreach (var attachProviderElement in elements.OfType <AttachProviderVirtualElement>())
{
lock (_notLoadedVirtualElements)
{
if (_notLoadedVirtualElements.Contains(attachProviderElement.Name))
{
continue;
}
}
string providerName = attachProviderElement.ProviderName;
var childElements = ElementFacade.GetRootsWithNoSecurity(new ElementProviderHandle(providerName), null).ToList();
foreach (Element childElement in childElements)
{
entityTokenHook.AddHookie(childElement.ElementHandle.EntityToken);
}
}
foundHooks.Add(entityTokenHook);
foreach (var simpleElement in elements.OfType <SimpleVirtualElement>())
{
CreateHooks(simpleElement.Name, simpleElement.Elements, foundHooks);
}
}
/// <exclude />
public ActivePerspectiveFormsHelper(string fieldLabel, string multiSelectLabel, string multiSelectHelp)
{
this.FieldLabel = fieldLabel;
this.MultiSelectLabel = multiSelectLabel;
this.MultiSelectHelp = multiSelectHelp;
_perspectiveElements = ElementFacade.GetPerspectiveElementsWithNoSecurity().ToList();
}
public static bool ExecuteElementDraggedAndDropped(ElementHandle draggedElementHandle, ElementHandle newParentdElementHandle, int dropIndex, string consoleId, bool isCopy)
{
var flowServicesContainer = new FlowControllerServicesContainer(
new ManagementConsoleMessageService(consoleId),
new ElementDataExchangeService(draggedElementHandle.ProviderName),
new ActionExecutionService(draggedElementHandle.ProviderName, consoleId)
);
return(ElementFacade.ExecuteElementDraggedAndDropped(draggedElementHandle, newParentdElementHandle, dropIndex, isCopy, flowServicesContainer));
}
/// <summary>
/// This method returns true if the given username <paramref name="username"/> has admin rights on the root element.
/// This is normal way of creating a administrator in C1.
/// </summary>
/// <param name="username">Username to test</param>
/// <returns>True if the given username has admin rights on the root element.</returns>
public static bool IsAdministrator(string username)
{
UserToken userToken = new UserToken(username);
EntityToken rootEntityToken = ElementFacade.GetRootsWithNoSecurity().First().ElementHandle.EntityToken;
IEnumerable <PermissionType> permissions = GetPermissions(userToken, rootEntityToken);
return(permissions.Contains(PermissionType.Administrate));
}
/// <exclude />
public static List <RefreshChildrenInfo> GetMultipleChildren(List <RefreshChildrenParams> nodesToBeRefreshed)
{
int t1 = Environment.TickCount;
var result = new List <RefreshChildrenInfo>();
foreach (RefreshChildrenParams node in nodesToBeRefreshed)
{
EntityToken entityToken;
try
{
entityToken = EntityTokenSerializer.Deserialize(node.EntityToken);
}
catch (EntityTokenSerializerException)
{
continue;
}
var elementHandle = new ElementHandle(node.ProviderName, entityToken, node.Piggybag);
SearchToken searchToken = null;
if (!string.IsNullOrEmpty(node.SearchToken))
{
searchToken = SearchToken.Deserialize(node.SearchToken);
}
List <Element> childElements;
if (UserSettings.ForeignLocaleCultureInfo == null || UserSettings.ForeignLocaleCultureInfo.Equals(UserSettings.ActiveLocaleCultureInfo))
{
childElements = ElementFacade.GetChildren(elementHandle, searchToken).ToList();
}
else
{
childElements = ElementFacade.GetForeignChildren(elementHandle, searchToken).ToList();
}
result.Add(new RefreshChildrenInfo
{
ElementKey = GetElementKey(node.ProviderName, node.EntityToken, node.Piggybag),
ClientElements = childElements.ToClientElementList()
});
}
int t2 = Environment.TickCount;
//LoggingService.LogVerbose("TreeServiceFacade", string.Format("GetMultipleChildren: {0} ms", t2 - t1));
return(result);
}
private void UpdateFormDefinitionWithGlobalPermissions(IUserGroup userGroup, XElement bindingsElement, XElement placeHolderElement)
{
var helper = new GlobalPermissionsFormsHelper(
SR.GetString("Composite.Plugins.UserGroupElementProvider", "EditUserGroup.EditUserGroupStep1.GlobalPermissionsFieldLabel"),
SR.GetString("Composite.Plugins.UserGroupElementProvider", "EditUserGroup.EditUserGroupStep1.GlobalPermissionsMultiSelectLabel"),
SR.GetString("Composite.Plugins.UserGroupElementProvider", "EditUserGroup.EditUserGroupStep1.GlobalPermissionsMultiSelectHelp")
);
bindingsElement.Add(helper.GetBindingsMarkup());
placeHolderElement.Add(helper.GetFormMarkup());
EntityToken rootEntityToken = ElementFacade.GetRootsWithNoSecurity().Select(f => f.ElementHandle.EntityToken).Single();
IEnumerable <PermissionType> permissionTypes = PermissionTypeFacade.GetLocallyDefinedUserGroupPermissionTypes(userGroup.Id, rootEntityToken).ToList();
helper.UpdateWithNewBindings(this.Bindings, permissionTypes);
}
/// <exclude />
public static List <ClientLabeledProperty> GetLabeledProperties(string providerName, string serializedEntityToken, string piggybag)
{
var elementEntityToken = EntityTokenSerializer.Deserialize(serializedEntityToken);
var elementHandle = new ElementHandle(providerName, elementEntityToken, piggybag);
bool showForeign = UserSettings.ForeignLocaleCultureInfo != null &&
UserSettings.ForeignLocaleCultureInfo.Equals(UserSettings.ActiveLocaleCultureInfo);
var labeledProperties = showForeign
? ElementFacade.GetForeignLabeledProperties(elementHandle)
: ElementFacade.GetLabeledProperties(elementHandle);
return
((from property in labeledProperties
select new ClientLabeledProperty(property)).ToList());
}
/// <exclude />
public static List <string> GetLocaleAwarePerspectiveElements()
{
IEnumerable <Element> elements = ElementFacade.GetPerspectiveElements(true);
List <string> clientElementKeys = new List <string>();
foreach (Element element in elements)
{
if (element.IsLocaleAware)
{
clientElementKeys.Add(element.GetClientElement().ElementKey);
}
}
return(clientElementKeys);
}
public void Initialize()
{
using (_resourceLocker.Locker)
{
var resources = _resourceLocker.Resources;
if (!GlobalInitializerFacade.IsReinitializingTheSystem)
{
DataEvents <IDataItemTreeAttachmentPoint> .OnAfterAdd += OnUpdateTreeAttachmentPoints;
DataEvents <IDataItemTreeAttachmentPoint> .OnDeleted += OnUpdateTreeAttachmentPoints;
DataEvents <IDataItemTreeAttachmentPoint> .OnStoreChanged += OnTreeAttachmentPointsStoreChange;
GeneratedTypesFacade.SubscribeToUpdateTypeEvent(OnDataTypeChanged);
var treeAuxiliaryAncestorProvider = new TreeAuxiliaryAncestorProvider();
var entityTokenTypes = new[]
{
typeof(TreeSimpleElementEntityToken),
typeof(TreeFunctionElementGeneratorEntityToken),
typeof(TreeDataFieldGroupingElementEntityToken),
typeof(DataEntityToken),
typeof(TreePerspectiveEntityToken)
};
entityTokenTypes.ForEach(type => AuxiliarySecurityAncestorFacade
.AddAuxiliaryAncestorProvider(type, treeAuxiliaryAncestorProvider, true));
resources.PersistentAttachmentPoints = new Dictionary <string, List <IAttachmentPoint> >();
LoadAllTrees();
InitializeTreeAttachmentPoints();
TreeSharedRootsFacade.Clear();
var fileWatcher = new C1FileSystemWatcher(TreeDefinitionsFolder, "*.xml");
fileWatcher.Created += OnReloadTrees;
fileWatcher.Deleted += OnReloadTrees;
fileWatcher.Changed += OnReloadTrees;
fileWatcher.Renamed += OnReloadTrees;
fileWatcher.EnableRaisingEvents = true;
resources.FileSystemWatcher = fileWatcher;
resources.RootEntityToken = ElementFacade.GetRootsWithNoSecurity().First().ElementHandle.EntityToken;
}
}
}
private string GetCurrentPath()
{
if (this.EntityToken is WebsiteFileElementProviderRootEntityToken)
{
string rootPath = (string)ElementFacade.GetData(new ElementProviderHandle(this.EntityToken.Source), "RootPath");
return(rootPath);
}
else if (this.EntityToken is WebsiteFileElementProviderEntityToken)
{
return((this.EntityToken as WebsiteFileElementProviderEntityToken).Path);
}
else
{
throw new NotImplementedException();
}
}
/// <exclude />
public static List <ClientElement> GetChildren(string providerName, string serializedEntityToken, string piggybag, string serializedSearchToken)
{
//LoggingService.LogVerbose("RGB(255, 0, 255)TreeServiceFacade", "----- Start -----------------------------------------------");
int t1 = Environment.TickCount;
EntityToken entityToken = EntityTokenSerializer.Deserialize(serializedEntityToken);
ElementHandle elementHandle = new ElementHandle(providerName, entityToken, piggybag);
//int t2 = Environment.TickCount;
SearchToken searchToken = null;
if (!string.IsNullOrEmpty(serializedSearchToken))
{
searchToken = SearchToken.Deserialize(serializedSearchToken);
}
List <Element> childElements;
if (UserSettings.ForeignLocaleCultureInfo == null || UserSettings.ForeignLocaleCultureInfo.Equals(UserSettings.ActiveLocaleCultureInfo))
{
childElements = ElementFacade.GetChildren(elementHandle, searchToken).ToList();
}
else
{
childElements = ElementFacade.GetForeignChildren(elementHandle, searchToken).ToList();
}
//int t3 = Environment.TickCount;
List <ClientElement> resultList = childElements.ToClientElementList();
int t4 = Environment.TickCount;
//LoggingService.LogVerbose("RGB(255, 0, 255)TreeServiceFacade", string.Format("ElementHandle: {0} ms", t2 - t1));
//LoggingService.LogVerbose("RGB(255, 0, 255)TreeServiceFacade", string.Format("GetChildren: {0} ms", t3 - t2));
//LoggingService.LogVerbose("RGB(255, 0, 255)TreeServiceFacade", string.Format("ToClientElementList: {0} ms", t4 - t3));
//LoggingService.LogVerbose("RGB(255, 0, 255)TreeServiceFacade", string.Format("Total: {0} ms", t4 - t1));
//LoggingService.LogVerbose("RGB(255, 0, 255)TreeServiceFacade", "----- End -------------------------------------------------");
//LoggingService.LogVerbose("TreeServiceFacade", string.Format("GetChildren: {0} ms", t4 - t1));
return(resultList);
}
public IEnumerable <EntityToken> GetParents(EntityToken entityToken)
{
if ((entityToken is SqlFunctionProviderRootEntityToken))
{
return(new EntityToken[] { });
}
else if ((entityToken is SqlFunctionProviderFolderEntityToken))
{
SqlFunctionProviderFolderEntityToken token = entityToken as SqlFunctionProviderFolderEntityToken;
NamespaceTreeBuilder builder = (NamespaceTreeBuilder)ElementFacade.GetData(new ElementProviderHandle(token.Source), token.ConnectionId);
NamespaceTreeBuilderFolder folder = builder.FindFolder(f => StringExtensionMethods.CreateNamespace(f.Namespace, f.Name, '.') == token.Id);
if (folder == null)
{
return(null);
}
else
{
int idx = token.Id.LastIndexOf('.');
if (idx != -1)
{
return(new EntityToken[] { new SqlFunctionProviderFolderEntityToken(token.Id.Remove(idx), token.Source, token.ConnectionId) });
}
else
{
Guid id = new Guid(token.ConnectionId);
ISqlConnection sqlConnection = DataFacade.GetData <ISqlConnection>(f => f.Id == id).SingleOrDefault();
if (sqlConnection == null)
{
return(new EntityToken[] { });
}
return(new EntityToken[] { sqlConnection.GetDataEntityToken() });
}
}
}
else
{
throw new NotImplementedException();
}
}
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);
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());
}
}
private static IEnumerable <PermissionType> FilterParentPermissions(
UserToken userToken, EntityToken entityToken, IReadOnlyCollection <PermissionType> permissions)
{
if (!permissions.Any() ||
!ElementFacade.IsPerspectiveEntityToken(entityToken))
{
return(permissions);
}
bool perspectiveVisible = UserPerspectiveFacade.PerspectiveVisible(userToken.Username, entityToken);
if (perspectiveVisible)
{
return(permissions);
}
return(GlobalSettingsFacade.InheritGlobalReadPermissionOnHiddenPerspectives
? permissions.Where(p => p == PermissionType.Read)
: Enumerable.Empty <PermissionType>());
}
private void UpdateFormDefinitionWithActiveLocalePermissions(IUserGroup userGroup, XElement bindingsElement, XElement placeHolderElement)
{
var helper = new ActiveLocalesFormsHelper(
SR.GetString("Composite.Plugins.UserGroupElementProvider", "EditUserGroup.EditUserGroupStep1.ActiveLocalesFieldLabel"),
SR.GetString("Composite.Plugins.UserGroupElementProvider", "EditUserGroup.EditUserGroupStep1.ActiveLocalesMultiSelectLabel"),
SR.GetString("Composite.Plugins.UserGroupElementProvider", "EditUserGroup.EditUserGroupStep1.ActiveLocalesMultiSelectHelp")
);
bindingsElement.Add(helper.GetBindingsMarkup());
placeHolderElement.Add(helper.GetFormMarkup());
EntityToken rootEntityToken = ElementFacade.GetRootsWithNoSecurity().Select(f => f.ElementHandle.EntityToken).Single();
using (var connection = new DataConnection())
{
IEnumerable <CultureInfo> activeCultures = null;
activeCultures = connection.Get <IUserGroupActiveLocale>().Where(f => f.UserGroupId == userGroup.Id).Select(f => new CultureInfo(f.CultureName));
helper.UpdateWithNewBindings(this.Bindings, activeCultures);
}
}
/// <exclude />
public static List <ClientLabeledProperty> GetLabeledProperties(string providerName, string serializedEntityToken, string piggybag)
{
EntityToken elementEntityToken = EntityTokenSerializer.Deserialize(serializedEntityToken);
ElementHandle elementHandle = new ElementHandle(providerName, elementEntityToken, piggybag);
IEnumerable <LabeledProperty> labeledProperties;
if (UserSettings.ForeignLocaleCultureInfo == null || UserSettings.ForeignLocaleCultureInfo.Equals(UserSettings.ActiveLocaleCultureInfo))
{
labeledProperties = ElementFacade.GetLabeledProperties(elementHandle);
}
else
{
labeledProperties = ElementFacade.GetForeignLabeledProperties(elementHandle);
}
return
((from property in labeledProperties
select new ClientLabeledProperty(property)).ToList());
}
/// <exclude />
public static List <ClientElement> GetRoots(string providerHandle, string serializedSearchToken)
{
SearchToken searchToken = null;
if (!string.IsNullOrEmpty(serializedSearchToken))
{
searchToken = SearchToken.Deserialize(serializedSearchToken);
}
List <Element> roots;
if (UserSettings.ForeignLocaleCultureInfo == null || UserSettings.ForeignLocaleCultureInfo.Equals(UserSettings.ActiveLocaleCultureInfo))
{
roots = ElementFacade.GetRoots(new ElementProviderHandle(providerHandle), searchToken).ToList();
}
else
{
roots = ElementFacade.GetForeignRoots(new ElementProviderHandle(providerHandle), searchToken).ToList();
}
return(roots.ToClientElementList());
}
private Element CreateElement(SimpleVirtualElement simpleElementNode)
{
EntityToken entityToken = new VirtualElementProviderEntityToken(_context.ProviderName, simpleElementNode.Name);
Element element = new Element(_context.CreateElementHandle(entityToken))
{
TagValue = simpleElementNode.Tag,
VisualData = new ElementVisualizedData
{
Label = StringResourceSystemFacade.ParseString(simpleElementNode.Label),
HasChildren = true // fixing refresh problem easy way... was: HasChildren(baseElementNode)
}
};
Action <IEnumerable> collectProviders = null;
// Recursively searching for attached providers
var attachedProviders = new List <AttachProviderVirtualElement>();
collectProviders = currentElements =>
{
attachedProviders.AddRange(currentElements.OfType <AttachProviderVirtualElement>());
currentElements.OfType <SimpleVirtualElement>().ForEach(e => collectProviders(e.Elements));
};
collectProviders(simpleElementNode.Elements);
foreach (var attachedProvider in attachedProviders)
{
if (ElementFacade.ContainsLocalizedData(new ElementProviderHandle(attachedProvider.ProviderName)))
{
element.IsLocaleAware = true;
}
}
if (element.VisualData.HasChildren)
{
ResourceHandle openHandle = IconResourceSystemFacade.GetResourceHandle(simpleElementNode.OpenFolderIconName);
ResourceHandle closeHandle = IconResourceSystemFacade.GetResourceHandle(simpleElementNode.CloseFolderIconName);
closeHandle = closeHandle ?? openHandle;
openHandle = openHandle ?? closeHandle;
if (openHandle == null)
{
openHandle = CommonElementIcons.Folder;
closeHandle = CommonElementIcons.FolderOpen;
}
element.VisualData.Icon = openHandle;
element.VisualData.OpenedIcon = closeHandle;
}
else
{
element.VisualData.Icon = CommonElementIcons.FolderDisabled;
}
return(element);
}
/// <summary>
/// Used for "first time" login on systems configured for this. A way to create the first user. This only works on systems
/// with no users and with a valid "auto create admin username" specified by the global settings.
/// </summary>
/// <param name="userName">The user name - must match GlobalSettingsProvider.AutoCreatedAdministratorUserName</param>
/// <param name="password">A password that meets a minimum requirement.</param>
/// <param name="email">THe users email.</param>
/// <param name="validateAutoCreateUserName">When true only the username specified in Composite.config as auto createable (usually 'admin') is allowed. Set to false to use a different user name.</param>
/// <returns>true if the user was auto created. Otherwise false.</returns>
public static void AutoCreateAdministrator(string userName, string password, string email, bool validateAutoCreateUserName = true)
{
if (validateAutoCreateUserName && !CanBeAutoCreated(userName))
{
throw new InvalidOperationException("Unable to auto create account. Either the user name is not eligble for auto creation or other users exists in the system. This feature only works for a specific user name and when no users exists.");
}
if (!LoginProviderPluginFacade.CanAddNewUser)
{
throw new InvalidOperationException("Unable to auto create account. The current login provider does not support adding users");
}
if (!PermissionTypeFacade.CanAlterDefinitions)
{
throw new InvalidOperationException("Unable to auto create account. The current permission defintion provider does not support changes");
}
//PasswordValidator validator = new PasswordValidator();
//ValidationResults validationResults = validator.Validate(password);
//if (validationResults.IsValid == false)
//{
// throw new InvalidOperationException("Unable to auto create account. The specified password is not strong enough.");
//}
// All seems bo be ok green light go for auto creating the user.
string group = StringResourceSystemFacade.GetString("Composite.C1Console.Users", "AdministratorAutoCreator.DefaultGroupName");
LoginProviderPluginFacade.FormAddNewUser(userName, password, group, email);
Log.LogVerbose("AdministratorAutoCreator", String.Format("Auto Created Administrator with user name '{0}'.", userName), LoggingService.Category.Audit);
IUser user = DataFacade.GetData <IUser>().Where(f => f.Username == userName).SingleOrDefault();
IUserGroup userGroup = DataFacade.GetData <IUserGroup>().Where(f => f.Name == "Administrator").SingleOrDefault();
if (user != null && userGroup != null)
{
IUserUserGroupRelation userUserGroupRelation = DataFacade.BuildNew <IUserUserGroupRelation>();
userUserGroupRelation.UserId = user.Id;
userUserGroupRelation.UserGroupId = userGroup.Id;
DataFacade.AddNew <IUserUserGroupRelation>(userUserGroupRelation);
}
else
{
foreach (Element appRootElement in ElementFacade.GetRootsWithNoSecurity())
{
string serializedEntityToken = EntityTokenSerializer.Serialize(appRootElement.ElementHandle.EntityToken);
LoggingService.LogVerbose("AdministratorAutoCreator", String.Format("Adding '{0}' on element '{1}' ('{2}').", userName, appRootElement.VisualData.Label ?? "(no label)", serializedEntityToken), LoggingService.Category.Audit);
UserPermissionDefinition userPermissionDefinition = new ConstructorBasedUserPermissionDefinition(userName, PermissionTypeFacade.GrantingPermissionTypes, serializedEntityToken);
PermissionTypeFacade.SetUserPermissionDefinition(userPermissionDefinition);
}
Log.LogVerbose("AdministratorAutoCreator", string.Format("Activating all known perspectives for user '{0}'", userName));
IEnumerable <EntityToken> perspectiveEntityTokens = ElementFacade.GetPerspectiveElementsWithNoSecurity().Select(f => f.ElementHandle.EntityToken);
UserPerspectiveFacade.SetEntityTokens(userName, perspectiveEntityTokens);
}
foreach (CultureInfo cultureInfo in DataLocalizationFacade.ActiveLocalizationCultures)
{
UserSettings.AddActiveLocaleCultureInfo(userName, cultureInfo);
if (Core.Localization.LocalizationFacade.IsDefaultLocale(cultureInfo))
{
UserSettings.SetCurrentActiveLocaleCultureInfo(userName, cultureInfo);
UserSettings.SetForeignLocaleCultureInfo(userName, cultureInfo);
}
}
}
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());
}
}
/// <exclude />
public static List <ClientElement> GetPerspectiveElementsWithNoSecurity()
{
return(ElementFacade.GetPerspectiveElementsWithNoSecurity().ToList().ToClientElementList());
}
private IEnumerable <Element> GetChildren(EntityToken entityToken, SearchToken seachToken, bool useForeign)
{
IEnumerable <VirtualElementConfigurationElement> elementNodes;
if (entityToken.Id == RootElementId)
{
elementNodes = _configuration.Perspectives;
}
else
{
SimpleVirtualElement node = FindElementNode(entityToken.Id, _configuration.Perspectives);
Verify.IsNotNull(node, "No corresponding node was found with the id '{0}'", entityToken.Id);
elementNodes = node.Elements;
}
var result = new List <Element>();
foreach (var elementNode in elementNodes)
{
if (elementNode is SimpleVirtualElement)
{
Element createdElement;
if (TryBuildElement(elementNode as SimpleVirtualElement, out createdElement))
{
result.Add(createdElement);
}
continue;
}
if (elementNode is AttachProviderVirtualElement)
{
string providerName = (elementNode as AttachProviderVirtualElement).ProviderName;
var providerHandle = new ElementProviderHandle(providerName);
List <Element> elementsFromProvider;
if (useForeign && ElementFacade.IsLocaleAwareElementProvider(providerHandle))
{
elementsFromProvider = ElementFacade.GetForeignRoots(providerHandle, seachToken).ToList();
}
else
{
elementsFromProvider = ElementFacade.GetRoots(providerHandle, seachToken).ToList();
}
foreach (Element element in elementsFromProvider)
{
element.ElementExternalActionAdding = element.ElementExternalActionAdding.Remove(ElementExternalActionAdding.AllowGlobal);
}
result.AddRange(elementsFromProvider);
continue;
}
throw new NotSupportedException();
}
return(result);
}
/// <exclude />
protected void RefreshRootEntityToken()
{
SpecificTreeRefresher specificTreeRefresher = this.CreateSpecificTreeRefresher();
specificTreeRefresher.PostRefreshMesseges(ElementFacade.GetRootsWithNoSecurity().First().ElementHandle.EntityToken);
}
public IEnumerable <EntityToken> GetParents(EntityToken entityToken)
{
VirtualElementProviderEntityToken virtualEntityToken = (VirtualElementProviderEntityToken)entityToken;
List <EntityToken> parentEntityTokens = new List <EntityToken>();
VirtualElementProviderEntityToken parentToken = (VirtualElementProviderEntityToken)ElementFacade.GetData(new ElementProviderHandle(virtualEntityToken.Source), virtualEntityToken.Id);
if (parentToken != null)
{
parentEntityTokens.Add(parentToken);
}
return(parentEntityTokens);
}
