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")
);
}
}