private void ValidateFunctionName(object sender, ConditionalEventArgs e)
{
IInlineFunction function = this.GetBinding <IInlineFunction>("NewFunction");
bool exists = FunctionFacade.FunctionExists(function.Namespace, function.Name);
if (exists)
{
string errorMessage = StringResourceSystemFacade.GetString("Composite.Plugins.MethodBasedFunctionProviderElementProvider", "AddFunction.NameAlreadyUsed");
errorMessage = string.Format(errorMessage, FunctionFacade.GetFunctionCompositionName(function.Namespace, function.Name));
ShowFieldMessage("NewFunction.Name", errorMessage);
e.Result = false;
return;
}
ValidationResults validationResults = ValidationFacade.Validate <IInlineFunction>(function);
if (!validationResults.IsValid)
{
foreach (ValidationResult result in validationResults)
{
this.ShowFieldMessage(string.Format("{0}.{1}", "NewFunction", result.Key), result.Message);
}
e.Result = false;
return;
}
e.Result = true;
}
private void ValidateData(object sender, ConditionalEventArgs e)
{
IUserGroup userGroup = this.GetBinding <IUserGroup>("NewUserGroup");
ValidationResults validationResults = ValidationFacade.Validate <IUserGroup>(userGroup);
e.Result = validationResults.IsValid;
}
public override void SetUp()
{
this.context = this.Stub <IValidationContext>();
this.clientValidator = this.Stub <IClientValidator>();
this.contextFactory = this.Stub <IValidationContextFactory>();
this.target = new ValidationFacade();
this.target.ClientValidator = this.clientValidator;
this.target.ContextFactory = this.contextFactory;
}
private void ShowDataValidateErrorCodeActivity_ExecuteCode(object sender, EventArgs e)
{
IUserGroup userGroup = this.GetBinding <IUserGroup>("NewUserGroup");
ValidationResults validationResults = ValidationFacade.Validate <IUserGroup>(userGroup);
this.ShowFieldMessage(
"NewUserGroup.Name",
validationResults.First().Message);
}
public BasicTabViewModel(ValidationFacade validations)
{
/// Inject dependencies
this.validations = validations;
/// Initialize properties
Status = new RenameStatus();
Data = new BasicRequestData("", 1, 1);
Mode = new BasicRequestMode(false, true, IndexPlacement.Prefix);
RegisterValidations();
}
private void IsUserValid(object sender, ConditionalEventArgs e)
{
IUser newUser = this.GetBinding <IUser>(BindingNames.NewUser);
var bindedUserFormLogin = this.GetBinding <IUserFormLogin>(BindingNames.UserFormLogin);
NormalizeUsername(newUser);
ValidationResults validationResults = ValidationFacade.Validate(newUser);
bool isValid = validationResults.IsValid;
if (isValid)
{
validationResults = ValidationFacade.Validate(bindedUserFormLogin);
isValid = validationResults.IsValid;
}
if (isValid)
{
IQueryable <IUser> usersWithTheSameName =
from user in DataFacade.GetData <IUser>()
where string.Compare(user.Username, newUser.Username, StringComparison.InvariantCultureIgnoreCase) == 0
select user;
if (usersWithTheSameName.Any())
{
ShowFieldMessage(BindingNames.Username,
StringResourceSystemFacade.GetString("Composite.Management", "UserElementProvider.UserLoginIsAlreadyUsed"));
isValid = false;
}
string password = this.GetBinding <string>(BindingNames.Password);
IList <string> validationMessages;
if (!PasswordPolicyFacade.ValidatePassword(newUser, password, out validationMessages))
{
foreach (var message in validationMessages)
{
this.ShowFieldMessage(BindingNames.Password, message);
}
isValid = false;
}
}
e.Result = isValid;
}
private void ValidateData(object sender, ConditionalEventArgs e)
{
IUserGroup userGroup = this.GetBinding <IUserGroup>("UserGroup");
ValidationResults validationResults = ValidationFacade.Validate <IUserGroup>(userGroup);
e.Result = validationResults.IsValid;
if (!validationResults.IsValid)
{
this.ShowFieldMessage(
"UserGroup.Name",
validationResults.First().Message);
}
}
private void ValidateUrlTitle(object sender, ConditionalEventArgs e)
{
IPage newPage = this.GetBinding <IPage>("NewPage");
if (this.CurrentStateName == "step1State")
{
SetDefaultValues(newPage);
}
e.Result = true;
if (!UrlTitleIsUniqueAmongSiblings())
{
string fieldName = "NewPage.UrlTitle";
if (this.CurrentStateName == "step1State")
{
fieldName = "NewPage.Title";
}
this.ShowFieldMessage(fieldName, GetText("UrlTitleNotUniqueError"));
e.Result = false;
}
else
{
ValidationResults validationResults = ValidationFacade.Validate <IPage>(newPage);
if (!validationResults.IsValid && validationResults.Any(f => f.Key == "UrlTitle"))
{
this.ShowFieldMessage("NewPage.Title", "${Composite.Plugins.PageElementProvider, UrlTitleNotValidError}");
e.Result = false;
}
}
DataTypeDescriptor dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(typeof(IPage));
if (newPage.UrlTitle.Length > dataTypeDescriptor.Fields["UrlTitle"].StoreType.MaximumLength)
{
this.ShowFieldMessage("NewPage.UrlTitle", GetText("UrlTitleTooLong"));
e.Result = false;
return;
}
if (newPage.MenuTitle.Length > dataTypeDescriptor.Fields["MenuTitle"].StoreType.MaximumLength)
{
this.ShowFieldMessage("NewPage.MenuTitle", GetText("AddNewPageStep1.MenuTitleTooLong"));
e.Result = false;
return;
}
}
public MainViewModel(MainServiceFacade clientServices, ValidationFacade validations,
BasicTabViewModel basicTabViewModel, AdvancedTabViewModel advancedTabViewModel,
FilesViewModel filesViewModel)
{
/// Inject dependencies
this.BasicTabViewModel = basicTabViewModel;
this.AdvancedTabViewModel = advancedTabViewModel;
this.FilesViewModel = filesViewModel;
this.clientServices = clientServices;
this.validations = validations;
/// Initialize properties
Status = basicTabViewModel.Status;
History = new Stack <CommittedChange>();
RegisterValidations();
ImplementsCommands();
HandleChildEvents();
}
private void step1CodeActivity_ExecuteCode(object sender, EventArgs e)
{
IUser newUser = this.GetBinding <IUser>(BindingNames.NewUser);
NormalizeUsername(newUser);
ValidationResults validationResults = ValidationFacade.Validate(newUser);
foreach (ValidationResult result in validationResults)
{
this.ShowFieldMessage(string.Format("{0}.{1}", BindingNames.NewUser, result.Key), result.Message);
}
IQueryable <IUser> usersWithTheSameName =
from user in DataFacade.GetData <IUser>()
where string.Compare(user.Username, newUser.Username, StringComparison.InvariantCultureIgnoreCase) == 0
select user;
if (usersWithTheSameName.Any())
{
this.ShowFieldMessage(BindingNames.Username, StringResourceSystemFacade.GetString("Composite.Management", "AddNewUserWorkflow.UsernameDuplicateError"));
}
}
public static bool SubmitForm(ParameterList parameters, string captchaText)
{
try
{
_compiler.SaveControlProperties();
}
catch (Exception)
{ }
webUiControl.InitializeViewState();
Dictionary <string, string> errorMessages = formHelper.BindingsToObject(bindings, newData);
DataTypeDescriptor dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(newData.DataSourceId.InterfaceType);
foreach (var property in newData.DataSourceId.InterfaceType.GetProperties())
{
if (property.PropertyType == typeof(string) && (string)property.GetValue(newData, null) == string.Empty)
{
property.SetValue(newData, null, null);
}
}
ValidationResults validationResults = ValidationFacade.Validate(newData.DataSourceId.InterfaceType, newData);
var isValid = true;
var useCaptcha = parameters.GetParameter <bool>("UseCaptcha");
if (useCaptcha)
{
var Session = HttpContext.Current.Session;
if (Session["FormsRendererCaptcha"] == null || !Captcha.IsValid(captchaText, Session["FormsRendererCaptcha"].ToString()))
{
ErrorSummary.AddError(StringResourceSystemFacade.GetString("Composite.Forms.Renderer", "Composite.Forms.Captcha.CaptchaText.error"));
isValid = false;
}
}
if (validationResults.IsValid == false)
{
isValid = false;
Dictionary <string, string> errorSummary = new Dictionary <string, string>();
foreach (ValidationResult result in validationResults)
{
var label = result.Key;
var help = result.Message;
try
{
label = dataTypeDescriptor.Fields[result.Key].FormRenderingProfile.Label;
help = dataTypeDescriptor.Fields[result.Key].FormRenderingProfile.HelpText;
//if no HelpText specified - use standard C1 error
if (help == string.Empty)
{
help = result.Message;
}
string error = GetLocalized(label) + ": " + GetLocalized(help);
if (!errorSummary.ContainsValue(error))
{
errorSummary.Add(errorSummary.Count().ToString(), error);
}
}
catch { }
}
// add errors to ErrorSummary
foreach (var dict in errorSummary)
{
ErrorSummary.AddError(dict.Value);
}
}
//TODO: Looks like rudimentary code related to old C1 errros with binding?
if (errorMessages != null)
{
isValid = false;
foreach (var kvp in errorMessages)
{
var label = kvp.Key;
try
{
label = dataTypeDescriptor.Fields[kvp.Key].FormRenderingProfile.Label;
}
catch { }
ErrorSummary.AddError(GetLocalized(label) + ": " + GetLocalized(kvp.Value));
}
}
if (isValid)
{
using (new DataScope(DataScopeIdentifier.Administrated))
{
IPublishControlled publishControlled = newData as IPublishControlled;
if (publishControlled != null)
{
publishControlled.PublicationStatus = GenericPublishProcessController.Draft;
}
DataFacade.AddNew(newData);
using (var datascope = new FormsRendererDataScope(newData))
{
var formEmailHeaders = parameters.GetParameter("Email") as IEnumerable <FormEmail>;
if (formEmailHeaders != null)
{
foreach (var formEmail in formEmailHeaders)
{
ParameterFacade.ResolveProperties(formEmail);
var inputXml = GetXElement(newData);
var body = new XhtmlDocument();
body.AppendDocument(formEmail.Body);
if (formEmail.AppendFormData)
{
var formData = new XDocument();
var xslTransform = new XslCompiledTransform();
xslTransform.LoadFromPath(FormsRendererLocalPath + "Xslt/MailBody.xslt");
using (var writer = formData.CreateWriter())
{
xslTransform.Transform(inputXml.CreateReader(), writer);
}
body.AppendDocument(formData);
}
Reflection.CallStaticMethod <object>("Composite.Core.WebClient.Renderings.Page.PageRenderer", "NormalizeXhtmlDocument", body);
var mailMessage = new MailMessage();
try
{
mailMessage.From = new MailAddress(formEmail.From);
}
catch (Exception e)
{
LoggingService.LogError(string.Format("Mail sending(From: '{0}')", formEmail.From), e.Message);
continue;
}
try
{
mailMessage.To.Add(formEmail.To);
}
catch (Exception e)
{
LoggingService.LogError(string.Format("Mail sending(To: '{0}')", formEmail.To), e.Message);
continue;
}
if (!string.IsNullOrEmpty(formEmail.Cc))
{
try
{
mailMessage.CC.Add(formEmail.Cc);
}
catch (Exception e)
{
LoggingService.LogError(string.Format("Mail sending(Cc: '{0}')", formEmail.Cc), e.Message);
}
}
try
{
mailMessage.Subject = formEmail.Subject;
mailMessage.IsBodyHtml = true;
mailMessage.Body = body.ToString();
new SmtpClient().Send(mailMessage);
}
catch (Exception e)
{
throw new InvalidOperationException("Unable to send mail. Please ensure that web.config has correct /configuration/system.net/mailSettings: " + e.Message);
}
}
}
}
}
}
return(isValid);
}
public FlowToken Execute(EntityToken entityToken, ActionToken actionToken, FlowControllerServicesContainer flowControllerServicesContainer)
{
DataEntityToken token = (DataEntityToken)entityToken;
IPublishControlled publishControlled = (IPublishControlled)DataFacade.GetDataFromDataSourceId(token.DataSourceId);
ValidationResults validationResults = ValidationFacade.Validate((IData)publishControlled);
if (validationResults.IsValid)
{
UpdateTreeRefresher treeRefresher = new UpdateTreeRefresher(token.Data.GetDataEntityToken(), flowControllerServicesContainer);
if (actionToken is PublishActionToken)
{
publishControlled.PublicationStatus = Published;
}
else if (actionToken is DraftActionToken)
{
publishControlled.PublicationStatus = Draft;
}
else if (actionToken is AwaitingApprovalActionToken)
{
publishControlled.PublicationStatus = AwaitingApproval;
}
else if (actionToken is AwaitingPublicationActionToken)
{
publishControlled.PublicationStatus = AwaitingPublication;
}
else if (actionToken is UnpublishActionToken)
{
publishControlled.PublicationStatus = Draft;
using (TransactionScope transactionScope = TransactionsFacade.CreateNewScope())
{
IData data = DataFacade.GetDataFromOtherScope(token.Data, DataScopeIdentifier.Public).SingleOrDefault();
if (data != null)
{
IPage page = data as IPage;
if (page != null)
{
IEnumerable <IData> referees;
using (new DataScope(DataScopeIdentifier.Public))
{
referees = page.GetMetaData();
}
DataFacade.Delete(referees, CascadeDeleteType.Disable);
}
DataFacade.Delete(data, CascadeDeleteType.Disable);
}
transactionScope.Complete();
}
}
else if (actionToken is UndoPublishedChangesActionToken)
{
using (TransactionScope transactionScope = TransactionsFacade.CreateNewScope())
{
using (ProcessControllerFacade.NoProcessControllers)
{
var administrativeData = (IPublishControlled)token.Data;
IData publishedData = DataFacade.GetDataFromOtherScope(token.Data, DataScopeIdentifier.Public).Single();
publishedData.FullCopyChangedTo(administrativeData);
administrativeData.PublicationStatus = Draft;
DataFacade.Update(administrativeData);
}
transactionScope.Complete();
}
}
else
{
throw new ArgumentException("Unknown action token", "actionToken");
}
DataFacade.Update(publishControlled);
treeRefresher.PostRefreshMesseges(publishControlled.GetDataEntityToken());
}
else
{
var managementConsoleMessageService = flowControllerServicesContainer.GetService <IManagementConsoleMessageService>();
StringBuilder sb = new System.Text.StringBuilder();
sb.AppendLine(StringResourceSystemFacade.GetString("Composite.Plugins.GenericPublishProcessController", "ValidationErrorMessage"));
foreach (ValidationResult result in validationResults)
{
sb.AppendLine(result.Message);
}
managementConsoleMessageService.ShowMessage(DialogType.Error, StringResourceSystemFacade.GetString("Composite.Plugins.GenericPublishProcessController", "ValidationErrorTitle"), sb.ToString());
}
return(null);
}
/// <summary>
/// Binds form values to a data item and sends messages to client to display validation messages.
/// </summary>
/// <param name="helper">Form binding helper</param>
/// <param name="data">An IData instance</param>
/// <returns>True, if there were no binding/validation errors</returns>
protected bool BindAndValidate(DataTypeDescriptorFormsHelper helper, IData data)
{
Dictionary <string, string> errorMessages = helper.BindingsToObject(this.Bindings, data);
ValidationResults validationResults = ValidationFacade.Validate(data.DataSourceId.InterfaceType, data);
bool isValid = true;
if (!validationResults.IsValid)
{
foreach (ValidationResult result in validationResults)
{
if (!result.Key.IsNullOrEmpty())
{
this.ShowFieldMessage(result.Key, result.Message);
}
else
{
this.ShowMessage(DialogType.Error, "Validation error", result.Message);
}
isValid = false;
}
}
// Checking that required strings are not empty
var dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(data.DataSourceId.InterfaceType);
foreach (var fieldName in dataTypeDescriptor.Fields
.Where(f => !f.IsNullable &&
f.InstanceType == typeof(string) &&
!(f.Inherited && f.Name == "FieldName")) // Skipping validation for inherited IPageMetaData.FieldName
.Select(f => f.Name))
{
string bindingName = (helper.BindingNamesPrefix ?? "").Replace('.', '_') + fieldName;
if (validationResults.Any(r => r.Key == bindingName))
{
continue;
}
object fieldValue = this.Bindings[bindingName];
if (fieldValue is string &&
(fieldValue as string) == string.Empty &&
!helper.BindingIsOptional(bindingName))
{
this.ShowFieldMessage(bindingName, LocalizationFiles.Composite_Management.Validation_RequiredField);
isValid = false;
}
}
if (errorMessages != null)
{
isValid = false;
foreach (var kvp in errorMessages)
{
this.ShowFieldMessage(kvp.Key, kvp.Value);
}
}
return(isValid);
}
private static List <T> AddNew_AddingMethod <T>(string providerName, IEnumerable <T> dataset, bool suppressEventing, bool performForeignKeyIntegrityCheck, bool performValidation)
where T : class, IData
{
Verify.ArgumentNotNullOrEmpty(providerName, "providerName");
Verify.ArgumentNotNull(dataset, "dataset");
Verify.ArgumentCondition(!dataset.Contains(null), "dataset", "The enumeration may not contain null values");
List <string> writeableProviders = DataProviderRegistry.GetWriteableDataProviderNamesByInterfaceType(typeof(T));
if (!writeableProviders.Contains(providerName))
{
Log.LogVerbose(LogTitle, $"Type data interface '{typeof(T)}' is marked auto updateable and is not supported by the provider '{providerName}', adding it");
DynamicTypeManager.EnsureCreateStore(typeof(T), providerName);
}
writeableProviders = DataProviderRegistry.GetWriteableDataProviderNamesByInterfaceType(typeof(T));
if (!writeableProviders.Contains(providerName))
{
throw new InvalidOperationException($"The writeable data providers '{providerName}' does not support the interface '{typeof(T)}'.");
}
foreach (T data in dataset)
{
if (performValidation)
{
CheckValidationResult(ValidationFacade.Validate <T>(data), typeof(T));
}
if (performForeignKeyIntegrityCheck)
{
data.ValidateForeignKeyIntegrity();
}
}
if (!suppressEventing)
{
foreach (T data in dataset)
{
DataEventSystemFacade.FireDataBeforeAddEvent <T>(data);
}
}
List <T> addedDataset = DataProviderPluginFacade.AddNew <T>(providerName, dataset);
DataCachingFacade.ClearCache(typeof(T), DataScopeManager.MapByType(typeof(T)), LocalizationScopeManager.MapByType(typeof(T)));
if (!suppressEventing)
{
foreach (T data in addedDataset)
{
DataEventSystemFacade.FireDataAfterAddEvent <T>(data);
}
}
return(addedDataset);
}
private bool PrepareAddUpdateMetaData(IPage selectedPage, IDictionary <string, IData> dataToAdd, IDictionary <string, IData> dataToUpdate)
{
var isValid = ValidateBindings();
IEnumerable <IPageMetaDataDefinition> pageMetaDataDefinitions = selectedPage.GetAllowedMetaDataDefinitions().Evaluate();
foreach (var pageMetaDataDefinition in pageMetaDataDefinitions)
{
var dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(pageMetaDataDefinition.MetaDataTypeId);
var metaDataType = TypeManager.GetType(dataTypeDescriptor.TypeManagerTypeName);
var helper = CreateDataTypeDescriptorFormsHelper(pageMetaDataDefinition, dataTypeDescriptor);
var metaData = selectedPage.GetMetaData(pageMetaDataDefinition.Name, metaDataType);
if (metaData == null)
{
var newData = DataFacade.BuildNew(metaDataType);
PageMetaDataFacade.AssignMetaDataSpecificValues(newData, pageMetaDataDefinition.Name, selectedPage);
var localizedData = newData as ILocalizedControlled;
if (localizedData != null)
{
localizedData.SourceCultureName = UserSettings.ActiveLocaleCultureInfo.Name;
}
if (!BindAndValidate(helper, newData))
{
isValid = false;
}
dataToAdd.Add(helper.BindingNamesPrefix, newData);
}
else
{
if (!BindAndValidate(helper, metaData))
{
isValid = false;
}
dataToUpdate.Add(helper.BindingNamesPrefix, metaData);
}
}
var pageValidationResults = ValidationFacade.Validate(selectedPage);
if (!pageValidationResults.IsValid)
{
isValid = false;
}
foreach (var kvp in dataToAdd.Concat(dataToUpdate))
{
var validationResults = ValidationFacade.Validate(kvp.Value);
if (!validationResults.IsValid)
{
isValid = false;
foreach (var result in validationResults)
{
ShowFieldMessage(DataTypeDescriptorFormsHelper.GetBindingName(kvp.Key, result.Key), result.Message);
}
}
}
return(isValid);
}
private void IsValidData(object sender, ConditionalEventArgs e)
{
IXsltFunction function = this.GetBinding <IXsltFunction>("NewXslt");
e.Result = false;
if (function.Name == string.Empty)
{
this.ShowFieldMessage("NewXslt.Name", GetText("AddNewXsltFunctionWorkflow.MethodEmpty"));
return;
}
if (string.IsNullOrWhiteSpace(function.Namespace))
{
this.ShowFieldMessage("NewXslt.Namespace", GetText("AddNewXsltFunctionWorkflow.NamespaceEmpty"));
return;
}
if (!function.Namespace.IsCorrectNamespace('.'))
{
this.ShowFieldMessage("NewXslt.Namespace", GetText("AddNewXsltFunctionWorkflow.InvalidNamespace"));
return;
}
string functionName = function.Name;
string functionNamespace = function.Namespace;
bool nameIsReserved = DataFacade.GetData <IXsltFunction>()
.Where(func => string.Compare(func.Name, functionName, true) == 0 &&
string.Compare(func.Namespace, functionNamespace, true) == 0)
.Any();
if (nameIsReserved)
{
this.ShowFieldMessage("NewXslt.Name", GetText("AddNewXsltFunctionWorkflow.DuplicateName"));
return;
}
function.XslFilePath = function.CreateXslFilePath();
ValidationResults validationResults = ValidationFacade.Validate <IXsltFunction>(function);
if (!validationResults.IsValid)
{
foreach (ValidationResult result in validationResults)
{
this.ShowFieldMessage(string.Format("{0}.{1}", "NewXslt", result.Key), result.Message);
}
return;
}
if (!function.ValidateXslFilePath())
{
this.ShowFieldMessage("NewXslt.Name", GetText("AddNewXsltFunctionWorkflow.TotalNameTooLang"));
return;
}
IXsltFile xsltfile = DataFacade.BuildNew <IXsltFile>();
xsltfile.FolderPath = System.IO.Path.GetDirectoryName(function.XslFilePath);
xsltfile.FileName = System.IO.Path.GetFileName(function.XslFilePath);
if (!DataFacade.ValidatePath(xsltfile, "XslFileProvider"))
{
this.ShowFieldMessage("NewXslt.Name", GetText("AddNewXsltFunctionWorkflow.TotalNameTooLang"));
return;
}
e.Result = true;
}
private void IsValidData(object sender, ConditionalEventArgs e)
{
IXsltFunction function = this.GetBinding <IXsltFunction>("CurrentXslt");
if (function.Name == string.Empty)
{
this.ShowFieldMessage("CurrentXslt.Name", GetString("EditXsltFunctionWorkflow.EmptyMethodName"));
e.Result = false;
return;
}
if (string.IsNullOrWhiteSpace(function.Namespace))
{
this.ShowFieldMessage("CurrentXslt.Namespace", GetString("EditXsltFunctionWorkflow.NamespaceEmpty"));
return;
}
if (!function.Namespace.IsCorrectNamespace('.'))
{
this.ShowFieldMessage("CurrentXslt.Namespace", GetString("EditXsltFunctionWorkflow.InvalidNamespace"));
e.Result = false;
return;
}
if (!(function.XslFilePath.StartsWith("\\") || function.XslFilePath.StartsWith("/")))
{
this.ShowFieldMessage("CurrentXslt.Name", GetString("EditXsltFunctionWorkflow.InvalidFileName"));
e.Result = false;
return;
}
function.XslFilePath = function.CreateXslFilePath();
ValidationResults validationResults = ValidationFacade.Validate <IXsltFunction>(function);
if (!validationResults.IsValid)
{
foreach (ValidationResult result in validationResults)
{
this.ShowFieldMessage(string.Format("{0}.{1}", "CurrentXslt", result.Key), result.Message);
}
return;
}
if (!function.ValidateXslFilePath())
{
this.ShowFieldMessage("NewXslt.Name", GetString("AddNewXsltFunctionWorkflow.TotalNameTooLang"));
return;
}
IXsltFile xsltfile = DataFacade.BuildNew <IXsltFile>();
xsltfile.FolderPath = System.IO.Path.GetDirectoryName(function.XslFilePath);
xsltfile.FileName = System.IO.Path.GetFileName(function.XslFilePath);
if (!DataFacade.ValidatePath(xsltfile, "XslFileProvider"))
{
this.ShowFieldMessage("CurrentXslt.Name", GetString("EditXsltFunctionWorkflow.TotalNameTooLang"));
return;
}
e.Result = true;
}
private void ValidateSave(object sender, ConditionalEventArgs e)
{
var selectedPage = GetBinding <IPage>("SelectedPage");
selectedPage.MenuTitle = selectedPage.MenuTitle ?? string.Empty;
selectedPage.FriendlyUrl = selectedPage.FriendlyUrl ?? string.Empty;
TrimFieldValues(selectedPage);
if (!FieldHasValidLength(selectedPage.Title, "Title", 255) ||
!FieldHasValidLength(selectedPage.MenuTitle, "MenuTitle", 64) ||
!FieldHasValidLength(selectedPage.UrlTitle, "UrlTitle", 64) ||
!FieldHasValidLength(selectedPage.FriendlyUrl, "FriendlyUrl", 64))
{
e.Result = false;
return;
}
e.Result = true;
var processedUrlTitle = UrlFormattersPluginFacade.FormatUrl(selectedPage.UrlTitle, true);
if (selectedPage.UrlTitle != processedUrlTitle)
{
RerenderView();
selectedPage.UrlTitle = processedUrlTitle;
ShowMessage(DialogType.Message,
GetText("EditPage.UrlTitleFormattedTitle"),
(GetText("EditPage.UrlTitleFormattedMessage") ?? string.Empty).FormatWith(processedUrlTitle));
}
var siblingPageUrlTitles =
(from page in PageServices.GetChildren(selectedPage.GetParentId())
where page.Id != selectedPage.Id
select page.UrlTitle).ToList();
foreach (var siblingUrlTitle in siblingPageUrlTitles)
{
if (siblingUrlTitle.Equals(selectedPage.UrlTitle, StringComparison.InvariantCultureIgnoreCase))
{
ShowFieldMessage("SelectedPage.UrlTitle", "${Composite.Plugins.PageElementProvider, UrlTitleNotUniqueError}");
e.Result = false;
break;
}
}
if (string.IsNullOrEmpty(selectedPage.FriendlyUrl) == false)
{
var usedFriendlyUrls = DataFacade.GetData <IPage>(f => f.FriendlyUrl != null && f.FriendlyUrl != string.Empty && f.Id != selectedPage.Id).Select(f => f.FriendlyUrl).ToList();
if (usedFriendlyUrls.Any(f => f.Equals(selectedPage.FriendlyUrl, StringComparison.InvariantCultureIgnoreCase)))
{
ShowFieldMessage("SelectedPage.FriendlyUrl", "${Composite.Plugins.PageElementProvider, FriendlyUrlNotUniqueError}");
e.Result = false;
}
}
if (string.IsNullOrEmpty(selectedPage.Title))
{
ShowFieldMessage("SelectedPage.Title", "${Composite.Plugins.PageElementProvider, TitleMissingError}");
e.Result = false;
}
var validationResults = ValidationFacade.Validate(selectedPage);
if (!validationResults.IsValid)
{
if (validationResults.Any(f => f.Key == "UrlTitle"))
{
ShowFieldMessage("SelectedPage.UrlTitle", "${Composite.Plugins.PageElementProvider, UrlTitleNotValidError}");
e.Result = false;
}
foreach (var validationResult in validationResults.Where(f => f.Key != "UrlTitle"))
{
ShowFieldMessage("SelectedPage." + validationResult.Key, validationResult.Message);
}
}
if (!ValidateBindings())
{
e.Result = false;
}
}
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());
}
public void Update(IEnumerable <IData> dataset, bool suppressEventing, bool performForeignKeyIntegrityCheck, bool performValidation)
{
Verify.ArgumentNotNull(dataset, "dataset");
var sortedDataset = dataset.ToDataProviderAndInterfaceTypeSortedDictionary();
if (!suppressEventing)
{
foreach (IData data in dataset)
{
DataEventSystemFacade.FireDataBeforeUpdateEvent(data.DataSourceId.InterfaceType, data);
}
}
foreach (IData data in dataset)
{
if (performValidation)
{
CheckValidationResult(ValidationFacade.Validate(data), data.DataSourceId.InterfaceType);
}
if (performForeignKeyIntegrityCheck)
{
data.ValidateForeignKeyIntegrity();
}
}
foreach (KeyValuePair <string, Dictionary <Type, List <IData> > > providerPair in sortedDataset)
{
foreach (KeyValuePair <Type, List <IData> > interfaceTypePair in providerPair.Value)
{
List <IData> dataToUpdate = interfaceTypePair.Value;
if (DataCachingFacade.IsTypeCacheable(interfaceTypePair.Key))
{
List <IData> newDataToUpdate = new List <IData>();
foreach (IData d in interfaceTypePair.Value)
{
newDataToUpdate.Add(DataWrappingFacade.UnWrap(d));
}
dataToUpdate = newDataToUpdate;
}
DataProviderPluginFacade.Update(providerPair.Key, dataToUpdate);
if (DataCachingFacade.IsTypeCacheable(interfaceTypePair.Key))
{
DataCachingFacade.ClearCache(interfaceTypePair.Key);
}
}
}
if (!suppressEventing)
{
foreach (IData data in dataset)
{
DataEventSystemFacade.FireDataAfterUpdateEvent(data.DataSourceId.InterfaceType, data);
}
}
}
