private static void AddLockingInformation(EntityToken entityToken, object ownerId) { LockingInformation lockingInformation; if (_lockingInformations.TryGetValue(entityToken, out lockingInformation)) { if (object.Equals(lockingInformation.OwnerId, ownerId)) { // NO OP: The owner may acquire a lock multiple times return; } // This will only happen if an entity token subclass is not rightly implemented throw new ActionLockingException("This item is used by another user, try again."); } lockingInformation = new LockingInformation { Username = UserValidationFacade.GetUsername(), OwnerId = ownerId }; string serializedOwnerId = SerializeOwnerId(lockingInformation.OwnerId); ILockingInformation li = DataFacade.BuildNew <ILockingInformation>(); li.Id = Guid.NewGuid(); li.SerializedEntityToken = EntityTokenSerializer.Serialize(entityToken); li.SerializedOwnerId = serializedOwnerId; li.Username = lockingInformation.Username; DataFacade.AddNew <ILockingInformation>(li); _lockingInformations.Add(entityToken, lockingInformation); }
/// <exclude /> public List <PackageFragmentValidationResult> Install() { Verify.IsNotNull(_packageInstaller, "Pre installation did not validate"); Verify.IsNotNull(_validationResult, "Call validation first"); if (_validationResult.Count > 0) { throw new InvalidOperationException("Installation did not validate"); } Verify.IsNull(_installationResult, "Install may only be called once"); var userName = UserValidationFacade.IsLoggedIn() ? UserValidationFacade.GetUsername() : "<system>"; Log.LogInformation(LogTitle, $"Installing package: {_packageName}, Version: {_packageVersion}, Id = {_packageId}; User name: '{userName}'"); PackageFragmentValidationResult result = _packageInstaller.Install(_systemLockingType); _installationResult = new List <PackageFragmentValidationResult>(); if (result != null) { _installationResult.Add(result); } _installationResult.AddRange(FinalizeProcess(true)); return(_installationResult); }
private static Dictionary <string, string> GetAvailablePublishingFlowTransitions(EntityToken entityToken) { var transitionNames = new Dictionary <string, string> { { GenericPublishProcessController.Draft, Texts.DraftTransition }, { GenericPublishProcessController.AwaitingApproval, Texts.AwaitingApprovalTransition } }; 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.Website_Forms_Administrative_EditPage_AwaitingPublicationTransition); break; } } return(transitionNames); }
private static Dictionary <string, string> GetAvailablePublishingFlowTransitions(EntityToken entityToken) { if (UserValidationFacade.IsLoggedIn()) { 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); } else { return(new Dictionary <string, string>()); } }
private void initializeCodeActivity_Initialize_ExecuteCode(object sender, EventArgs e) { EntityTokenLockedEntityToken entityToken = (EntityTokenLockedEntityToken)this.EntityToken; this.Bindings.Add("LockedByUsername", entityToken.LockedByUsername); this.Bindings.Add("IsSameUser", entityToken.LockedByUsername == UserValidationFacade.GetUsername()); }
private void finalizeCodeActivity_ExecuteCode(object sender, EventArgs e) { var dataEntityToken = (DataEntityToken)this.EntityToken; IUser user = (IUser)dataEntityToken.Data; if (!DataFacade.WillDeleteSucceed(user)) { this.ShowMessage( DialogType.Error, LocalizationFiles.Composite_Management.DeleteUserWorkflow_CascadeDeleteErrorTitle, LocalizationFiles.Composite_Management.DeleteUserWorkflow_CascadeDeleteErrorMessage); return; } UserPerspectiveFacade.DeleteAll(user.Username); DataFacade.Delete(user); LoggingService.LogEntry("UserManagement", $"C1 Console user '{user.Username}' deleted by '{UserValidationFacade.GetUsername()}'.", LoggingService.Category.Audit, TraceEventType.Information); this.CreateParentTreeRefresher().PostRefreshMessages(dataEntityToken, 2); }
private void initializeCodeActivity_Initialize_ExecuteCode(object sender, EventArgs e) { var dataEntityToken = (DataEntityToken)this.EntityToken; IUser user = (IUser)dataEntityToken.Data; _deleteSelf = user.Username == UserValidationFacade.GetUsername(); }
private void LogWorkflowChange(string change, WorkflowEventArgs args, bool logUserName, bool workflowDefinitionAvailable, bool error) { WorkflowInstance instance = null; string activityTypeName = null; try { instance = args.WorkflowInstance; } catch { // Silent } if (workflowDefinitionAvailable && instance != null) { try { activityTypeName = instance.GetWorkflowDefinition().GetType().FullName; } catch { // Silent } } var message = new StringBuilder("Workflow ").Append(change); if (activityTypeName != null) { message.Append(", Activity = " + activityTypeName); } if (instance != null) { message.Append(", Id = " + instance.InstanceId); } if (logUserName) { string identity = UserValidationFacade.IsLoggedIn() ? UserValidationFacade.GetUsername() : "(system process)"; message.Append(", User = " + identity); } if (!error) { Log.LogVerbose(LogTitle, message.ToString()); } else { Log.LogError(LogTitle, message.ToString()); } }
private void stepFinalize_codeActivity_ExecuteCode(object sender, EventArgs e) { string newPassword = this.GetBinding <string>(Fields.NewPassword); string currentUserName = UserValidationFacade.GetUsername(); UserValidationFacade.FormSetUserPassword(currentUserName, newPassword); LoggingService.LogVerbose("ChangeOwnPasswordWorkflow", string.Format("User '{0}' has changed password.", UserValidationFacade.GetUsername()), LoggingService.Category.Audit); }
private bool ValidateSpecifiedPasswords(string oldPassword, string newPassword, string newPasswordConfirmed) { string currentUserName = UserValidationFacade.GetUsername(); bool oldPasswordCorrect = UserValidationFacade.FormValidateUserWithoutLogin(currentUserName, oldPassword); if (!oldPasswordCorrect) { this.ShowFieldMessage(Fields.OldPassword, Texts.ChangeOwnPasswordWorkflow_Dialog_Validation_IncorrectPassword); return(false); } if (newPassword != newPasswordConfirmed) { this.ShowFieldMessage(Fields.NewPasswordConfirmed, Texts.ChangeOwnPasswordWorkflow_Dialog_Validation_NewPasswordFieldsNotMatch); return(false); } if (newPassword == oldPassword) { this.ShowFieldMessage(Fields.NewPassword, Texts.ChangeOwnPasswordWorkflow_Dialog_Validation_PasswordsAreTheSame); return(false); } if (string.IsNullOrEmpty(newPassword)) { this.ShowFieldMessage(Fields.NewPassword, Texts.ChangeOwnPasswordWorkflow_Dialog_Validation_NewPasswordIsEmpty); return(false); } string userName = UserValidationFacade.GetUsername(); var user = DataFacade.GetData <IUser>(u => string.Compare(u.Username, userName, StringComparison.InvariantCultureIgnoreCase) == 0) .FirstOrException("No user found with name '{0}'", userName); IList <string> newPasswordValidationMessages; if (!PasswordPolicyFacade.ValidatePassword(user, newPassword, out newPasswordValidationMessages)) { foreach (var message in newPasswordValidationMessages) { this.ShowFieldMessage(Fields.NewPassword, message); } return(false); } return(true); }
private void SetWorkflowInstanceStatus(Guid instanceId, WorkflowInstanceStatus workflowInstanceStatus, bool newlyCreateOrLoaded) { using (_resourceLocker.Locker) { var resources = _resourceLocker.Resources; Action releaseIdleWaitSemaphore = () => { if (resources.WorkflowIdleWaitSemaphores.TryGetValue(instanceId, out var semaphore)) { semaphore.Release(); resources.WorkflowIdleWaitSemaphores.Remove(instanceId); } }; switch (workflowInstanceStatus) { case WorkflowInstanceStatus.Idle: releaseIdleWaitSemaphore(); resources.WorkflowStatusDictionary[instanceId] = WorkflowInstanceStatus.Idle; PersistFormData(instanceId); break; case WorkflowInstanceStatus.Running: resources.WorkflowStatusDictionary[instanceId] = WorkflowInstanceStatus.Running; break; case WorkflowInstanceStatus.Terminated: releaseIdleWaitSemaphore(); resources.WorkflowStatusDictionary.Remove(instanceId); break; default: throw new InvalidOperationException("This line should not be reachable."); } } string identity = UserValidationFacade.IsLoggedIn() ? UserValidationFacade.GetUsername() : "(system process)"; Log.LogVerbose(LogTitle, $"Workflow instance status changed to {workflowInstanceStatus}. Id = {instanceId}, User = {identity}"); }
private static void SetChangeHistoryInformation(object sender, DataEventArgs dataEventArgs) { IData data = dataEventArgs.Data; if (data != null && data is IChangeHistory) { (data as IChangeHistory).ChangeDate = DateTime.Now; try { if (UserValidationFacade.IsLoggedIn()) { (data as IChangeHistory).ChangedBy = UserValidationFacade.GetUsername(); } } catch { // silent } } }
private void DoUninstallWithoutTransaction() { var userName = UserValidationFacade.IsLoggedIn() ? UserValidationFacade.GetUsername() : "<system>"; Log.LogInformation(LogTitle, $"Uninstalling package '{PackageInformation.Name}', Id = {PackageInformation.Id}. User name: '{userName}'"); try { foreach (IPackageFragmentUninstaller packageFragmentUninstaller in _packageFramentUninstallers) { packageFragmentUninstaller.Uninstall(); } } catch (Exception ex) { Log.LogError(LogTitle, ex); throw; } Log.LogInformation(LogTitle, "Package uninstalled successfully."); }
private static void SetCreationHistoryInformation(object sender, DataEventArgs dataEventArgs) { ICreationHistory data = dataEventArgs.Data as ICreationHistory; if (data != null) { data.CreationDate = DateTime.Now; try { if (UserValidationFacade.IsLoggedIn()) { data.CreatedBy = UserValidationFacade.GetUsername(); } } catch { // silent } } }
public IWampSessionAuthenticator CreateAuthenticator(ICookieProvider cookieProvider) { var userName = UserValidationFacade.GetUsername(); return(new UserNameBasedCookieAuthenticator(userName)); }
private void finalizeCodeActivity_ExecuteCode(object sender, EventArgs e) { var dataEntityToken = (DataEntityToken)this.EntityToken; IUser user = (IUser)dataEntityToken.Data; if (!DataFacade.WillDeleteSucceed(user)) { this.ShowMessage( DialogType.Error, StringResourceSystemFacade.GetString("Composite.Management", "DeleteUserWorkflow.CascadeDeleteErrorTitle"), StringResourceSystemFacade.GetString("Composite.Management", "DeleteUserWorkflow.CascadeDeleteErrorMessage")); return; } UserPerspectiveFacade.DeleteAll(user.Username); DataFacade.Delete(user); LoggingService.LogVerbose("UserManagement", $"C1 Console user '{user.Username}' deleted by '{UserValidationFacade.GetUsername()}'.", LoggingService.Category.Audit); this.CreateParentTreeRefresher().PostRefreshMessages(dataEntityToken, 2); }
private void finalizeCodeActivity_Delete_ExecuteCode(object sender, EventArgs e) { DeleteTreeRefresher deleteTreeRefresher = CreateDeleteTreeRefresher(this.EntityToken); DataEntityToken dataEntityToken = (DataEntityToken)this.EntityToken; IUserGroup userGroup = (IUserGroup)dataEntityToken.Data; DataFacade.Delete(userGroup); LoggingService.LogVerbose("UserManagement", String.Format("C1 Console user group '{0}' deleted by '{1}'.", userGroup.Name, UserValidationFacade.GetUsername()), LoggingService.Category.Audit); deleteTreeRefresher.PostRefreshMesseges(); }
private void saveCodeActivity_ExecuteCode(object sender, EventArgs e) { IUser user = this.GetBinding <IUser>(BindingNames.User); var userFormLogin = GetBinding <IUserFormLogin>(BindingNames.UserFormLogin); var userFormLoginFromDatabase = user.GetUserFormLogin(); bool userValidated = true; ValidationResults validationResults = ValidationFacade.Validate(user); foreach (ValidationResult result in validationResults) { this.ShowFieldMessage($"{BindingNames.User}.{result.Key}", result.Message); userValidated = false; } List <CultureInfo> newActiveLocales = ActiveLocalesFormsHelper.GetSelectedLocalesTypes(this.Bindings).ToList(); List <CultureInfo> currentActiveLocales = null; CultureInfo selectedActiveLocal = null; if (newActiveLocales.Count > 0) { currentActiveLocales = UserSettings.GetActiveLocaleCultureInfos(user.Username).ToList(); string selectedActiveLocaleName = (user.Username != UserSettings.Username ? this.GetBinding <string>("ActiveLocaleName") : UserSettings.ActiveLocaleCultureInfo.ToString()); if (selectedActiveLocaleName != null) { selectedActiveLocal = CultureInfo.CreateSpecificCulture(selectedActiveLocaleName); if (!newActiveLocales.Contains(selectedActiveLocal)) { if (user.Username != UserSettings.Username) { this.ShowFieldMessage("ActiveLocaleName", GetText("Website.Forms.Administrative.EditUserStep1.ActiveLocaleNotChecked")); } else { this.ShowFieldMessage("ActiveLocalesFormsHelper_Selected", GetText("Website.Forms.Administrative.EditUserStep1.NoActiveLocaleSelected")); } userValidated = false; } } } else { this.ShowFieldMessage("ActiveLocalesFormsHelper_Selected", GetText("Website.Forms.Administrative.EditUserStep1.NoActiveLocaleSelected")); userValidated = false; } string systemPerspectiveEntityToken = EntityTokenSerializer.Serialize(AttachingPoint.SystemPerspective.EntityToken); List <Guid> newUserGroupIds = UserGroupsFormsHelper.GetSelectedUserGroupIds(this.Bindings); List <string> newSerializedEnitityTokens = ActivePerspectiveFormsHelper.GetSelectedSerializedEntityTokens(this.Bindings).ToList(); if (string.Compare(user.Username, UserSettings.Username, StringComparison.InvariantCultureIgnoreCase) == 0) { // Current user shouldn't be able to lock itself if (userFormLogin.IsLocked) { this.ShowMessage(DialogType.Message, Texts.EditUserWorkflow_EditErrorTitle, Texts.EditUserWorkflow_LockingOwnUserAccount); userValidated = false; } // Current user shouldn't be able to remove its own access to "System" perspective var groupsWithAccessToSystemPerspective = new HashSet <Guid>(GetGroupsThatHasAccessToPerspective(systemPerspectiveEntityToken)); if (!newSerializedEnitityTokens.Contains(systemPerspectiveEntityToken) && !newUserGroupIds.Any(groupsWithAccessToSystemPerspective.Contains)) { this.ShowMessage(DialogType.Message, Texts.EditUserWorkflow_EditErrorTitle, Texts.EditUserWorkflow_EditOwnAccessToSystemPerspective); userValidated = false; } } string newPassword = this.GetBinding <string>(BindingNames.NewPassword); if (newPassword == NotPassword || UserFormLoginManager.ValidatePassword(userFormLoginFromDatabase, newPassword)) { newPassword = null; } else { IList <string> validationMessages; if (!PasswordPolicyFacade.ValidatePassword(user, newPassword, out validationMessages)) { foreach (var message in validationMessages) { this.ShowFieldMessage(BindingNames.NewPassword, message); } userValidated = false; } } if (!userValidated) { return; } if (!userFormLogin.IsLocked) { userFormLogin.LockoutReason = (int)UserLockoutReason.Undefined; } else { bool wasLockedBefore = userFormLoginFromDatabase.IsLocked; if (!wasLockedBefore) { userFormLoginFromDatabase.LockoutReason = (int)UserLockoutReason.LockedByAdministrator; } } UpdateTreeRefresher updateTreeRefresher = this.CreateUpdateTreeRefresher(this.EntityToken); bool reloadUsersConsoles = false; using (var transactionScope = TransactionsFacade.CreateNewScope()) { DataFacade.Update(user); userFormLoginFromDatabase.Folder = userFormLogin.Folder; userFormLoginFromDatabase.IsLocked = userFormLogin.IsLocked; DataFacade.Update(userFormLoginFromDatabase); if (newPassword != null) { UserFormLoginManager.SetPassword(userFormLoginFromDatabase, newPassword); } string cultureName = this.GetBinding <string>("CultureName"); string c1ConsoleUiLanguageName = this.GetBinding <string>("C1ConsoleUiLanguageName"); UserSettings.SetUserCultureInfo(user.Username, CultureInfo.CreateSpecificCulture(cultureName)); UserSettings.SetUserC1ConsoleUiLanguage(user.Username, CultureInfo.CreateSpecificCulture(c1ConsoleUiLanguageName)); List <string> existingSerializedEntityTokens = UserPerspectiveFacade.GetSerializedEntityTokens(user.Username).ToList(); int intersectCount = existingSerializedEntityTokens.Intersect(newSerializedEnitityTokens).Count(); if ((intersectCount != newSerializedEnitityTokens.Count) || (intersectCount != existingSerializedEntityTokens.Count)) { UserPerspectiveFacade.SetSerializedEntityTokens(user.Username, newSerializedEnitityTokens); if (UserSettings.Username == user.Username) { reloadUsersConsoles = true; } } if (DataLocalizationFacade.ActiveLocalizationCultures.Any()) { foreach (CultureInfo cultureInfo in newActiveLocales) { if (!currentActiveLocales.Contains(cultureInfo)) { UserSettings.AddActiveLocaleCultureInfo(user.Username, cultureInfo); } } foreach (CultureInfo cultureInfo in currentActiveLocales) { if (!newActiveLocales.Contains(cultureInfo)) { UserSettings.RemoveActiveLocaleCultureInfo(user.Username, cultureInfo); } } if (selectedActiveLocal != null) { if (!UserSettings.GetCurrentActiveLocaleCultureInfo(user.Username).Equals(selectedActiveLocal)) { reloadUsersConsoles = true; } UserSettings.SetCurrentActiveLocaleCultureInfo(user.Username, selectedActiveLocal); } else if (UserSettings.GetActiveLocaleCultureInfos(user.Username).Any()) { UserSettings.SetCurrentActiveLocaleCultureInfo(user.Username, UserSettings.GetActiveLocaleCultureInfos(user.Username).First()); } } List <IUserUserGroupRelation> oldRelations = DataFacade.GetData <IUserUserGroupRelation>(f => f.UserId == user.Id).ToList(); IEnumerable <IUserUserGroupRelation> deleteRelations = from r in oldRelations where !newUserGroupIds.Contains(r.UserGroupId) select r; DataFacade.Delete(deleteRelations); foreach (Guid newUserGroupId in newUserGroupIds) { Guid groupId = newUserGroupId; if (oldRelations.Any(f => f.UserGroupId == groupId)) { continue; } var userUserGroupRelation = DataFacade.BuildNew <IUserUserGroupRelation>(); userUserGroupRelation.UserId = user.Id; userUserGroupRelation.UserGroupId = newUserGroupId; DataFacade.AddNew(userUserGroupRelation); } LoggingService.LogEntry("UserManagement", $"C1 Console user '{user.Username}' updated by '{UserValidationFacade.GetUsername()}'.", LoggingService.Category.Audit, TraceEventType.Information); transactionScope.Complete(); } if (reloadUsersConsoles) { foreach (string consoleId in GetConsoleIdsOpenedByCurrentUser()) { ConsoleMessageQueueFacade.Enqueue(new RebootConsoleMessageQueueItem(), consoleId); } } SetSaveStatus(true); updateTreeRefresher.PostRefreshMesseges(user.GetDataEntityToken()); }
private void finalizeCodeActivity_Delete_ExecuteCode(object sender, EventArgs e) { DeleteTreeRefresher deleteTreeRefresher = CreateDeleteTreeRefresher(this.EntityToken); DataEntityToken dataEntityToken = (DataEntityToken)this.EntityToken; IUserGroup userGroup = (IUserGroup)dataEntityToken.Data; DataFacade.Delete(userGroup); LoggingService.LogEntry("UserManagement", $"C1 Console user group '{userGroup.Name}' deleted by '{UserValidationFacade.GetUsername()}'.", LoggingService.Category.Audit, TraceEventType.Information); deleteTreeRefresher.PostRefreshMesseges(); }
/// <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 is SecurityViolationWorkflowEntityToken)) { return(ExecuteSecurityViolation(actionToken, entityToken, flowControllerServicesContainer)); } #endif bool ignoreLocking = actionToken.IsIgnoreEntityTokenLocking(); if (!ignoreLocking && ActionLockingFacade.IsLocked(entityToken)) { return(ExecuteEntityTokenLocked(actionToken, entityToken, flowControllerServicesContainer)); } 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 { Log.LogWarning(nameof(ActionExecutorFacade), "Missing ManagementConsoleMessageService, can not register the flow"); } return(flowToken); }
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()); } }
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()); } }
/// <exclude /> public static PackageManagerInstallProcess Install(Stream zipFileStream, bool isLocalInstall, string packageServerAddress) { if (!isLocalInstall && string.IsNullOrEmpty(packageServerAddress)) { throw new ArgumentException("Non local install needs a packageServerAddress"); } string zipFilename = null; try { PackageFragmentValidationResult packageFragmentValidationResult = SaveZipFile(zipFileStream, out zipFilename); if (packageFragmentValidationResult != null) { return(new PackageManagerInstallProcess(new List <PackageFragmentValidationResult> { packageFragmentValidationResult }, null)); } XElement installContent; packageFragmentValidationResult = XmlHelper.LoadInstallXml(zipFilename, out installContent); if (packageFragmentValidationResult != null) { return(new PackageManagerInstallProcess(new List <PackageFragmentValidationResult> { packageFragmentValidationResult }, zipFilename)); } PackageInformation packageInformation; packageFragmentValidationResult = ValidatePackageInformation(installContent, out packageInformation); if (packageFragmentValidationResult != null) { return(new PackageManagerInstallProcess(new List <PackageFragmentValidationResult> { packageFragmentValidationResult }, zipFilename)); } if (RuntimeInformation.ProductVersion < packageInformation.MinCompositeVersionSupported || RuntimeInformation.ProductVersion > packageInformation.MaxCompositeVersionSupported) { return(new PackageManagerInstallProcess(new List <PackageFragmentValidationResult> { new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, Texts.PackageManager_CompositeVersionMisMatch( RuntimeInformation.ProductVersion, packageInformation.MinCompositeVersionSupported, packageInformation.MaxCompositeVersionSupported)) }, zipFilename)); } bool updatingInstalledPackage = false; if (IsInstalled(packageInformation.Id)) { string currentVersionString = GetCurrentVersion(packageInformation.Id); Version currentVersion = new Version(currentVersionString); Version newVersion = new Version(packageInformation.Version); if (newVersion <= currentVersion) { string validationError = newVersion == currentVersion ? Texts.PackageManager_PackageAlreadyInstalled : Texts.PackageManager_NewerVersionInstalled; return(new PackageManagerInstallProcess( new List <PackageFragmentValidationResult> { new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, validationError) }, zipFilename)); } updatingInstalledPackage = true; } string originalInstallDirectory = null; string packageInstallDirectory = CreatePackageDirectoryName(packageInformation); if (updatingInstalledPackage) { originalInstallDirectory = packageInstallDirectory; packageInstallDirectory += "-" + packageInformation.Version; } C1Directory.CreateDirectory(packageInstallDirectory); string packageZipFilename = Path.Combine(packageInstallDirectory, Path.GetFileName(zipFilename)); C1File.Copy(zipFilename, packageZipFilename, true); string username = "******"; if (UserValidationFacade.IsLoggedIn()) { username = UserValidationFacade.GetUsername(); } var doc = new XDocument(); XElement packageInfoElement = new XElement(XmlUtils.GetXName(PackageSystemSettings.XmlNamespace, PackageSystemSettings.PackageInfoElementName)); doc.Add(packageInfoElement); packageInfoElement.Add( new XAttribute(PackageSystemSettings.PackageInfo_NameAttributeName, packageInformation.Name), new XAttribute(PackageSystemSettings.PackageInfo_GroupNameAttributeName, packageInformation.GroupName), new XAttribute(PackageSystemSettings.PackageInfo_VersionAttributeName, packageInformation.Version), new XAttribute(PackageSystemSettings.PackageInfo_AuthorAttributeName, packageInformation.Author), new XAttribute(PackageSystemSettings.PackageInfo_WebsiteAttributeName, packageInformation.Website), new XAttribute(PackageSystemSettings.PackageInfo_DescriptionAttributeName, packageInformation.Description), new XAttribute(PackageSystemSettings.PackageInfo_InstallDateAttributeName, DateTime.Now), new XAttribute(PackageSystemSettings.PackageInfo_InstalledByAttributeName, username), new XAttribute(PackageSystemSettings.PackageInfo_IsLocalInstalledAttributeName, isLocalInstall), new XAttribute(PackageSystemSettings.PackageInfo_CanBeUninstalledAttributeName, packageInformation.CanBeUninstalled), new XAttribute(PackageSystemSettings.PackageInfo_FlushOnCompletionAttributeName, packageInformation.FlushOnCompletion), new XAttribute(PackageSystemSettings.PackageInfo_ReloadConsoleOnCompletionAttributeName, packageInformation.ReloadConsoleOnCompletion), new XAttribute(PackageSystemSettings.PackageInfo_SystemLockingAttributeName, packageInformation.SystemLockingType.Serialize())); if (!string.IsNullOrEmpty(packageServerAddress)) { packageInfoElement.Add(new XAttribute(PackageSystemSettings.PackageInfo_PackageServerAddressAttributeName, packageServerAddress)); } string infoFilename = Path.Combine(packageInstallDirectory, PackageSystemSettings.PackageInformationFilename); doc.SaveToFile(infoFilename); var packageInstaller = new PackageInstaller(new PackageInstallerUninstallerFactory(), packageZipFilename, packageInstallDirectory, TempDirectoryFacade.CreateTempDirectory(), packageInformation); return(new PackageManagerInstallProcess( packageInstaller, packageInformation.SystemLockingType, zipFilename, packageInstallDirectory, packageInformation.Name, packageInformation.Version, packageInformation.Id, originalInstallDirectory)); } catch (Exception ex) { return(new PackageManagerInstallProcess(new List <PackageFragmentValidationResult> { new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, ex) }, zipFilename)); } }
private void editStateCodeActivity_ExecuteCode(object sender, EventArgs e) { if (!PermissionsFacade.GetPermissionsForCurrentUser(EntityToken).Contains(PermissionType.Publish)) { var formData = WorkflowFacade.GetFormData(InstanceId, true); if (formData.ExcludedEvents == null) { formData.ExcludedEvents = new List <string>(); } formData.ExcludedEvents.Add("SaveAndPublish"); } IPage selectedPage; if (!BindingExist("SelectedPage")) { selectedPage = GetDataItemFromEntityToken <IPage>(); if (selectedPage.PublicationStatus == GenericPublishProcessController.Published) { selectedPage.PublicationStatus = GenericPublishProcessController.Draft; } Bindings.Add("SelectedPage", selectedPage); } else { selectedPage = GetBinding <IPage>("SelectedPage"); } if (!BindingExist("UrlTitleIsRequired")) { var isRootPage = PageManager.GetParentId(selectedPage.Id) == Guid.Empty; Bindings["UrlTitleIsRequired"] = !isRootPage; Bindings["IsRootPage"] = isRootPage; } IFormMarkupProvider markupProvider = new FormDefinitionFileMarkupProvider(@"\Administrative\EditPage.xml"); XDocument formDocument; using (var reader = markupProvider.GetReader()) { formDocument = XDocument.Load(reader); } var bindingsXElement = formDocument.Root.Element(DataTypeDescriptorFormsHelper.CmsNamespace + FormKeyTagNames.Bindings); var layoutXElement = formDocument.Root.Element(DataTypeDescriptorFormsHelper.CmsNamespace + FormKeyTagNames.Layout); var tabPanelsXElement = layoutXElement.Element(DataTypeDescriptorFormsHelper.MainNamespace + "TabPanels"); IEnumerable <ICompositionContainer> compositionContainers = selectedPage.GetAllowedMetaDataContainers().Evaluate(); var compositionTabs = new Dictionary <Guid, XElement>(); foreach (var compositionContainer in compositionContainers) { var element = new XElement(Namespaces.BindingFormsStdUiControls10 + "PlaceHolder"); element.Add(new XAttribute("Label", StringResourceSystemFacade.ParseString(compositionContainer.Label))); compositionTabs.Add(compositionContainer.Id, element); } var clientValidationRules = new Dictionary <string, List <ClientValidationRule> >(); var pageMetaDataDefinitions = selectedPage.GetAllowedMetaDataDefinitions(); foreach (var pageMetaDataDefinition in pageMetaDataDefinitions) { var metaDatTypeId = pageMetaDataDefinition.MetaDataTypeId; var dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(metaDatTypeId); Verify.IsNotNull(dataTypeDescriptor, "Failed to get meta data type by id '{0}'. If data type was purposely removed, in order to fix this exception you should remove IPageMetaDataDefinition records that reference this data type.", metaDatTypeId); var metaDataType = TypeManager.TryGetType(dataTypeDescriptor.TypeManagerTypeName); Verify.IsNotNull(metaDataType, "Failed to get meta data type '{0}', id: {1}. If it has been removed, references from '{2}' have to be removed as well", dataTypeDescriptor.TypeManagerTypeName, metaDatTypeId, typeof(IPageMetaDataDefinition).Name); var helper = CreateDataTypeDescriptorFormsHelper(pageMetaDataDefinition, dataTypeDescriptor); var metaData = selectedPage.GetMetaData(pageMetaDataDefinition.Name, metaDataType); if (metaData == null) { metaData = DataFacade.BuildNew(metaDataType); PageMetaDataFacade.AssignMetaDataSpecificValues(metaData, pageMetaDataDefinition.Name, selectedPage); var localizedData = metaData as ILocalizedControlled; if (localizedData != null) { localizedData.SourceCultureName = UserSettings.ActiveLocaleCultureInfo.Name; } var publishControlled = metaData as IPublishControlled; publishControlled.PublicationStatus = GenericPublishProcessController.Draft; helper.UpdateWithNewBindings(Bindings); helper.ObjectToBindings(metaData, Bindings); } else { helper.UpdateWithBindings(metaData, Bindings); } bindingsXElement.Add(helper.BindingXml.Elements()); compositionTabs[pageMetaDataDefinition.MetaDataContainerId].Add(helper.PanelXml); clientValidationRules.AddDictionary(helper.GetBindingsValidationRules(metaData)); } var previewTabPanel = tabPanelsXElement.Elements().Last(); foreach (var element in compositionTabs.Values) { previewTabPanel.AddBeforeSelf(element); } IDictionary <string, string> transitionNames = new Dictionary <string, string>(); transitionNames.Add(GenericPublishProcessController.Draft, StringResourceSystemFacade.GetString("Composite.Management", "PublishingStatus.draft")); transitionNames.Add(GenericPublishProcessController.AwaitingApproval, StringResourceSystemFacade.GetString("Composite.Management", "PublishingStatus.awaitingApproval")); var username = UserValidationFacade.GetUsername(); var userPermissionDefinitions = PermissionTypeFacade.GetUserPermissionDefinitions(username); var userGroupPermissionDefinitions = PermissionTypeFacade.GetUserGroupPermissionDefinitions(username); var currentPermissionTypes = PermissionTypeFacade.GetCurrentPermissionTypes(UserValidationFacade.GetUserToken(), EntityToken, userPermissionDefinitions, userGroupPermissionDefinitions); foreach (var permissionType in currentPermissionTypes) { if (GenericPublishProcessController.AwaitingPublicationActionPermissionType.Contains(permissionType)) { transitionNames.Add(GenericPublishProcessController.AwaitingPublication, StringResourceSystemFacade.GetString("Composite.Management", "PublishingStatus.awaitingPublication")); break; } } var contents = DataFacade.GetData <IPagePlaceholderContent>(f => f.PageId == selectedPage.Id && f.VersionId == selectedPage.VersionId).ToList(); var namedXhtmlFragments = contents.ToDictionary(content => content.PlaceHolderId, content => content.Content ?? ""); UpdateBinding("SelectablePageTypeIds", GetSelectablePageTypes()); UpdateBinding("SelectableTemplateIds", GetSelectablePageTemplates()); UpdateBinding("NamedXhtmlFragments", namedXhtmlFragments); UpdateBinding("StateOptions", transitionNames); var formDefinition = formDocument.GetDocumentAsString(); DeliverFormData( selectedPage.Title, StandardUiContainerTypes.Document, formDefinition, Bindings, clientValidationRules ); }
private void finalizeCodeActivity_ExecuteCode(object sender, EventArgs e) { AddNewTreeRefresher addNewTreeRefresher = this.CreateAddNewTreeRefresher(this.EntityToken); IUser newUser = this.GetBinding <IUser>(BindingNames.NewUser); var bindedUserFormLogin = this.GetBinding <IUserFormLogin>(BindingNames.UserFormLogin); NormalizeUsername(newUser); string password = this.GetBinding <string>(BindingNames.Password); newUser = DataFacade.AddNew <IUser>(newUser); UserFormLoginManager.CreateUserFormLogin(newUser.Id, password, bindedUserFormLogin.Folder); string cultureName = this.GetBinding <string>("CultureName"); string c1ConsoleUiLanguageName = this.GetBinding <string>("C1ConsoleUiLanguageName"); UserSettings.SetUserCultureInfo(newUser.Username, CultureInfo.CreateSpecificCulture(cultureName)); UserSettings.SetUserC1ConsoleUiLanguage(newUser.Username, CultureInfo.CreateSpecificCulture(c1ConsoleUiLanguageName)); CultureInfo locale = DataLocalizationFacade.DefaultLocalizationCulture; UserSettings.AddActiveLocaleCultureInfo(newUser.Username, locale); UserSettings.SetCurrentActiveLocaleCultureInfo(newUser.Username, locale); UserSettings.SetForeignLocaleCultureInfo(newUser.Username, locale); this.CloseCurrentView(); addNewTreeRefresher.PostRefreshMesseges(newUser.GetDataEntityToken()); LoggingService.LogVerbose("UserManagement", String.Format("New C1 Console user '{0}' created by '{1}'.", newUser.Username, UserValidationFacade.GetUsername()), LoggingService.Category.Audit); this.ExecuteWorklow(newUser.GetDataEntityToken(), typeof(EditUserWorkflow)); }
private void finalizeCodeActivity_Finalize_ExecuteCode(object sender, EventArgs e) { AddNewTreeRefresher addNewTreeRefresher = this.CreateAddNewTreeRefresher(this.EntityToken); IUserGroup userGroup = this.GetBinding <IUserGroup>("NewUserGroup"); userGroup = DataFacade.AddNew <IUserGroup>(userGroup); this.CloseCurrentView(); LoggingService.LogVerbose("UserManagement", String.Format("New C1 Console user group '{0}' created by '{1}'.", userGroup.Name, UserValidationFacade.GetUsername()), LoggingService.Category.Audit); addNewTreeRefresher.PostRefreshMesseges(userGroup.GetDataEntityToken()); this.ExecuteWorklow(userGroup.GetDataEntityToken(), typeof(EditUserGroupWorkflow)); }
private void finalizeCodeActivity_ExecuteCode(object sender, EventArgs e) { DeleteTreeRefresher deleteTreeRefresher = this.CreateDeleteTreeRefresher(this.EntityToken); DataEntityToken dataEntityToken = (DataEntityToken)this.EntityToken; IUser user = (IUser)dataEntityToken.Data; if (DataFacade.WillDeleteSucceed(user)) { UserPerspectiveFacade.DeleteAll(user.Username); DataFacade.Delete(user); LoggingService.LogVerbose("UserManagement", String.Format("C1 Console user '{0}' deleted by '{1}'.", user.Username, UserValidationFacade.GetUsername()), LoggingService.Category.Audit); deleteTreeRefresher.PostRefreshMesseges(); } else { this.ShowMessage( DialogType.Error, StringResourceSystemFacade.GetString("Composite.Management", "DeleteUserWorkflow.CascadeDeleteErrorTitle"), StringResourceSystemFacade.GetString("Composite.Management", "DeleteUserWorkflow.CascadeDeleteErrorMessage") ); } }