private void collectDefaultValuesCodeActivity_ShowWizzard_ExecuteCode(object sender, EventArgs e) { Pair <string, Type> metaDataPair = this.GetBinding <Pair <string, Type> >("SelectedMetaDataDefinition"); DataTypeDescriptor dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(metaDataPair.Second); Type metaDataType = TypeManager.GetType(dataTypeDescriptor.TypeManagerTypeName); DataTypeDescriptorFormsHelper helper = new DataTypeDescriptorFormsHelper(dataTypeDescriptor); helper.LayoutLabel = StringResourceSystemFacade.GetString("Composite.Plugins.PageTypeElementProvider", "PageType.AddPageTypeMetaDataFieldWorkflow.AddingDefaultMetaData.Title"); helper.LayoutIconHandle = "pagetype-add-metedatafield"; GeneratedTypesHelper generatedTypesHelper = new GeneratedTypesHelper(dataTypeDescriptor); helper.AddReadOnlyFields(generatedTypesHelper.NotEditableDataFieldDescriptorNames); IData newDataTemplate = DataFacade.BuildNew(metaDataType); helper.UpdateWithNewBindings(this.Bindings); helper.ObjectToBindings(newDataTemplate, this.Bindings); this.UpdateBinding("NewDataTemplate", newDataTemplate); this.DeliverFormData( metaDataType.GetTypeTitle(), StandardUiContainerTypes.Wizard, helper.GetForm(), this.Bindings, helper.GetBindingsValidationRules(newDataTemplate) ); }
private void initializeCodeActivity_ExecuteCode(object sender, EventArgs e) { DataTypeDescriptor dataTypeDescriptor = GetDataTypeDescriptor(); string formMarkup; XDocument formMarkupDocument = DynamicTypesCustomFormFacade.GetCustomFormMarkup(dataTypeDescriptor); if (formMarkupDocument != null) { formMarkup = formMarkupDocument.ToString(); } else { bool isMetaDataType = dataTypeDescriptor.SuperInterfaces.Contains(typeof(IPageMetaData)); var formsHelper = new DataTypeDescriptorFormsHelper(dataTypeDescriptor, null, !isMetaDataType, null); var generatedTypesHelper = new GeneratedTypesHelper(dataTypeDescriptor); formsHelper.AddReadOnlyFields(generatedTypesHelper.NotEditableDataFieldDescriptorNames); formMarkup = formsHelper.GetForm(); } this.Bindings.Add("Title", string.Format("{0}.{1} XML", dataTypeDescriptor.Namespace, dataTypeDescriptor.Name)); this.Bindings.Add("FileContent", formMarkup); }
private DataTypeDescriptorFormsHelper GetDataTypeDescriptorFormsHelper() { if (_helper == null) { var type = GetInterfaceType(); var guid = type.GetImmutableTypeId(); var typeDescriptor = DataMetaDataFacade.GetDataTypeDescriptor(guid); if (typeDescriptor == null) { throw new InvalidOperationException(string.Format("Can not find the type descriptor for the type '{0}'", type)); } var generatedTypesHelper = new GeneratedTypesHelper(typeDescriptor) { AllowForeignKeyEditing = true }; _helper = new DataTypeDescriptorFormsHelper(typeDescriptor, true, EntityToken) { LayoutIconHandle = "generated-type-data-add" }; _helper.AddReadOnlyFields(generatedTypesHelper.NotEditableDataFieldDescriptorNames); _typeName = typeDescriptor.Name; } return(_helper); }
private DataTypeDescriptorFormsHelper GetDataTypeDescriptorFormsHelper() { if (_helper == null) { var dataEntityToken = (DataEntityToken)EntityToken; var guid = dataEntityToken.Data.DataSourceId.InterfaceType.GetImmutableTypeId(); var typeDescriptor = DataMetaDataFacade.GetDataTypeDescriptor(guid); var generatedTypesHelper = new GeneratedTypesHelper(typeDescriptor) { AllowForeignKeyEditing = true }; _helper = new DataTypeDescriptorFormsHelper(typeDescriptor, true, EntityToken) { LayoutIconHandle = "generated-type-data-edit" }; _helper.AddReadOnlyFields(generatedTypesHelper.NotEditableDataFieldDescriptorNames); _typeName = typeDescriptor.Name; } return(_helper); }
private void enterDefaultValuesCodeActivity_Initialize_ExecuteCode(object sender, EventArgs e) { Type type = this.GetBinding <Type>(SelectedTypeBindingName); DataTypeDescriptor dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(type.GetImmutableTypeId()); DataTypeDescriptorFormsHelper helper = new DataTypeDescriptorFormsHelper(dataTypeDescriptor); helper.LayoutIconHandle = "associated-data-add"; GeneratedTypesHelper generatedTypesHelper = new GeneratedTypesHelper(dataTypeDescriptor); helper.AddReadOnlyFields(generatedTypesHelper.NotEditableDataFieldDescriptorNames); IData newData = DataFacade.BuildNew(type); helper.UpdateWithNewBindings(this.Bindings); helper.ObjectToBindings(newData, this.Bindings); this.DeliverFormData( type.Name, StandardUiContainerTypes.Wizard, helper.GetForm(), this.Bindings, helper.GetBindingsValidationRules(newData) ); }
private void enterDataCodeActivity_ExecuteCode(object sender, EventArgs e) { var dataTypeDescriptor = GetBinding <DataTypeDescriptor>("DataTypeDescriptor"); var type = TypeManager.GetType(dataTypeDescriptor.TypeManagerTypeName); Guid pageId = GetBinding <Guid>(BindingNames.PageId); var helper = new DataTypeDescriptorFormsHelper(dataTypeDescriptor, true, EntityToken) { LayoutIconHandle = "associated-data-add" }; var generatedTypesHelper = new GeneratedTypesHelper(dataTypeDescriptor); helper.AddReadOnlyFields(generatedTypesHelper.NotEditableDataFieldDescriptorNames); IData newData; if (!BindingExist("NewData")) { newData = DataFacade.BuildNew(type); PageFolderFacade.AssignFolderDataSpecificValues(newData, pageId); var publishControlled = newData as IPublishControlled; if (publishControlled != null) { publishControlled.PublicationStatus = GenericPublishProcessController.Draft; } var localizedData = newData as ILocalizedControlled; if (localizedData != null) { var cultureInfo = UserSettings.ActiveLocaleCultureInfo ?? DataLocalizationFacade.DefaultLocalizationCulture; localizedData.SourceCultureName = cultureInfo.Name; } Bindings.Add("NewData", newData); helper.UpdateWithNewBindings(Bindings); helper.ObjectToBindings(newData, Bindings); } else { newData = GetBinding <IData>("NewData"); } DeliverFormData( type.Name, StandardUiContainerTypes.Document, helper.GetForm(), Bindings, helper.GetBindingsValidationRules(newData) ); }
private static DataTypeDescriptorFormsHelper CreateDataTypeDescriptorFormsHelper(IPageMetaDataDefinition pageMetaDataDefinition, DataTypeDescriptor dataTypeDescriptor) { var bindingPrefix = $"{pageMetaDataDefinition.Name}:{dataTypeDescriptor.Namespace}.{dataTypeDescriptor.Name}"; var helper = new DataTypeDescriptorFormsHelper(dataTypeDescriptor, bindingPrefix); var generatedTypesHelper = new GeneratedTypesHelper(dataTypeDescriptor); helper.AddReadOnlyFields(generatedTypesHelper.NotEditableDataFieldDescriptorNames); helper.FieldGroupLabel = StringResourceSystemFacade.ParseString(pageMetaDataDefinition.Label); return(helper); }
private void DefaultValuesAreValid(object sender, ConditionalEventArgs e) { IData newDataTemplate; if (!this.TryGetBinding("NewDataTemplate", out newDataTemplate)) { e.Result = true; return; } IPageTypeMetaDataTypeLink pageTypeMetaDataTypeLink = this.GetBinding<IPageTypeMetaDataTypeLink>("NewMetaDataTypeLink"); var dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(pageTypeMetaDataTypeLink.DataTypeId); var helper = new DataTypeDescriptorFormsHelper(dataTypeDescriptor); e.Result = BindAndValidate(helper, newDataTemplate); }
private DataTypeDescriptorFormsHelper GetDataTypeDescriptorFormsHelper() { if (_helper == null) { var dataEntityToken = (DataEntityToken)EntityToken; var interfaceType = dataEntityToken.Data.DataSourceId.InterfaceType; var guid = interfaceType.GetImmutableTypeId(); var typeDescriptor = DataMetaDataFacade.GetDataTypeDescriptor(guid); var generatedTypesHelper = new GeneratedTypesHelper(typeDescriptor); _helper = new DataTypeDescriptorFormsHelper(typeDescriptor, true, EntityToken); _helper.AddReadOnlyFields(generatedTypesHelper.NotEditableDataFieldDescriptorNames); _typeName = typeDescriptor.Name; } return(_helper); }
private void finalizeCodeActivity_Finalize_ExecuteCode(object sender, EventArgs e) { Type selectedMetaDataType = this.GetBinding <Type>(SelectedTypeBindingName); DataTypeDescriptor dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(selectedMetaDataType.GetImmutableTypeId()); PageMetaDataDescription dataAssociationVisabilityRule = this.GetBinding <PageMetaDataDescription>(DataAssociationVisabilityDescriptionBindingName); Guid metaDataContainerId = this.GetBinding <Guid>(SelectedContainerBindingName); string metaDataDefinitionName = this.GetBinding <string>(FieldGroupNameBindingName); string metaDataDefinitionLabel = this.GetBinding <string>(FieldGroupLabelBindingName); IData newDataTemplate = null; if (IsAnyPagesAffected()) { DataTypeDescriptorFormsHelper helper = new DataTypeDescriptorFormsHelper(dataTypeDescriptor); GeneratedTypesHelper generatedTypesHelper = new GeneratedTypesHelper(dataTypeDescriptor); helper.AddReadOnlyFields(generatedTypesHelper.NotEditableDataFieldDescriptorNames); newDataTemplate = DataFacade.BuildNew(selectedMetaDataType); helper.BindingsToObject(this.Bindings, newDataTemplate); } using (TransactionScope transactionScope = TransactionsFacade.CreateNewScope()) { IPage page = GetCurrentPage(); page.AddMetaDataDefinition(metaDataDefinitionName, metaDataDefinitionLabel, selectedMetaDataType.GetImmutableTypeId(), metaDataContainerId, dataAssociationVisabilityRule.StartLevel, dataAssociationVisabilityRule.Levels); if (newDataTemplate != null) { page.AddNewMetaDataToExistingPages(metaDataDefinitionName, newDataTemplate); } transactionScope.Complete(); } ParentTreeRefresher parentTreeRefresher = this.CreateParentTreeRefresher(); parentTreeRefresher.PostRefreshMesseges(this.EntityToken); }
private void MetaDataValid(object sender, ConditionalEventArgs e) { bool valid = ValidateBindings(); Type selectedMetaDataType = this.GetBinding <Type>(SelectedTypeBindingName); DataTypeDescriptor dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(selectedMetaDataType.GetImmutableTypeId()); DataTypeDescriptorFormsHelper helper = new DataTypeDescriptorFormsHelper(dataTypeDescriptor); GeneratedTypesHelper generatedTypesHelper = new GeneratedTypesHelper(dataTypeDescriptor); helper.AddReadOnlyFields(generatedTypesHelper.NotEditableDataFieldDescriptorNames); IData newDataTemplate = DataFacade.BuildNew(selectedMetaDataType); if (!BindAndValidate(helper, newDataTemplate)) { valid = false; } if (valid) { var fieldsWithInvalidForeginKey = new List <string>(); DataReferenceFacade.TryValidateForeignKeyIntegrity(newDataTemplate, fieldsWithInvalidForeginKey); if (fieldsWithInvalidForeginKey.Count > 0) { foreach (string fieldName in fieldsWithInvalidForeginKey) { if (!generatedTypesHelper.NotEditableDataFieldDescriptorNames.Contains(fieldName)) { this.ShowFieldMessage(fieldName, "Invalid reference"); valid = false; } } } } e.Result = valid; }
private void finalizeCodeActivity_ExecuteCode(object sender, EventArgs e) { var dataTypeDescriptor = GetBinding <DataTypeDescriptor>("DataTypeDescriptor"); var newData = GetBinding <IData>("NewData"); var helper = new DataTypeDescriptorFormsHelper(dataTypeDescriptor, true, newData.GetDataEntityToken()); var generatedTypesHelper = new GeneratedTypesHelper(dataTypeDescriptor); helper.AddReadOnlyFields(generatedTypesHelper.NotEditableDataFieldDescriptorNames); var isValid = ValidateBindings(); if (!BindAndValidate(helper, newData)) { isValid = false; } var justAdded = false; if (isValid) { var published = false; if (!BindingExist("DataAdded")) { var dataScopeIdentifier = DataScopeIdentifier.Public; if (dataTypeDescriptor.SuperInterfaces.Contains(typeof(IPublishControlled))) { dataScopeIdentifier = DataScopeIdentifier.Administrated; } using (new DataScope(dataScopeIdentifier)) { newData = DataFacade.AddNew(newData); justAdded = true; } PublishControlledHelper.PublishIfNeeded(newData, _doPublish, Bindings, ShowMessage); AcquireLock(newData.GetDataEntityToken()); UpdateBinding("NewData", newData); Bindings.Add("DataAdded", true); } else { var publishedControlled = newData as IPublishControlled; if (publishedControlled != null) { var refreshedData = (IPublishControlled)DataFacade.GetDataFromDataSourceId(newData.DataSourceId); if (refreshedData != null && refreshedData.PublicationStatus == GenericPublishProcessController.Published) { refreshedData.PublicationStatus = GenericPublishProcessController.Draft; DataFacade.Update(refreshedData); } } DataFacade.Update(newData); published = PublishControlledHelper.PublishIfNeeded(newData, _doPublish, Bindings, ShowMessage); EntityTokenCacheFacade.ClearCache(newData.GetDataEntityToken()); } if (!published) { var specificTreeRefresher = CreateParentTreeRefresher(); specificTreeRefresher.PostRefreshMesseges(EntityToken); } if (justAdded) { SetSaveStatus(true, newData); } else { SetSaveStatus(true); } } else { SetSaveStatus(false); } }
public static void InsertForm(Control control, ParameterList parameters) { Page currentPageHandler = HttpContext.Current.Handler as Page; if (currentPageHandler == null) { throw new InvalidOperationException("The Current HttpContext Handler must be a System.Web.Ui.Page"); } Type dataType = null; DataTypeDescriptor dataTypeDescriptor = null; string dataTypeName = parameters.GetParameter <string>("DataType"); dataType = TypeManager.GetType(dataTypeName); dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(dataType); IFormChannelIdentifier channelIdentifier = FormsRendererChannel.Identifier; formHelper = new DataTypeDescriptorFormsHelper(dataTypeDescriptor); newData = DataFacade.BuildNew(dataType); GeneratedTypesHelper.SetNewIdFieldValue(newData); //Hide not editable fields, fox example - PageId GeneratedTypesHelper generatedTypesHelper = new GeneratedTypesHelper(dataTypeDescriptor); formHelper.AddReadOnlyFields(generatedTypesHelper.NotEditableDataFieldDescriptorNames); //If is Page Datatype if (PageFolderFacade.GetAllFolderTypes().Contains(dataType)) { IPage currentPage = PageRenderer.CurrentPage; if (currentPage.GetDefinedFolderTypes().Contains(dataType) == false) { currentPage.AddFolderDefinition(dataType.GetImmutableTypeId()); } PageFolderFacade.AssignFolderDataSpecificValues(newData, currentPage); } _compiler = new FormTreeCompiler(); //bindings = formHelper.GetBindings(newData); bindings = new Dictionary <string, object>(); formHelper.UpdateWithNewBindings(bindings); formHelper.ObjectToBindings(newData, bindings); using (XmlReader reader = XDocument.Parse(formHelper.GetForm()).CreateReader()) { try { _compiler.Compile(reader, channelIdentifier, bindings, formHelper.GetBindingsValidationRules(newData)); #region ClientValidationRules clientValidationRules = new Dictionary <string, List <ClientValidationRule> >(); foreach (var item in _compiler.GetField <object>("_context").GetProperty <IEnumerable>("Rebindings")) { var SourceProducer = item.GetProperty <object>("SourceProducer"); var uiControl = SourceProducer as IWebUiControl; if (uiControl != null) { clientValidationRules[uiControl.UiControlID] = uiControl.ClientValidationRules; } } #endregion } catch (ConfigurationErrorsException e) { if (e.Message.Contains("Failed to load the configuration for IUiControlFactory")) { throw new ConfigurationErrorsException("Composite.Forms.Renderer does not support widget. " + e.Message); } else { throw new ConfigurationErrorsException(e.Message); } } } webUiControl = (IWebUiControl)_compiler.UiControl; Control form = webUiControl.BuildWebControl(); control.Controls.Add(form); /*if (currentPageHandler.IsPostBack) * try * { * compiler.SaveControlProperties(); * } * catch { }*/ if (!currentPageHandler.IsPostBack) { webUiControl.InitializeViewState(); } return; }
private void finalizeCodeActivity_Finalize_ExecuteCode(object sender, EventArgs e) { using (TransactionScope transactionScope = TransactionsFacade.CreateNewScope()) { List <Guid> oldPageIds = GetOldAffectedPageIds(); List <Guid> newPageIds = GetNewAffectedPageIds(); Pair <string, Type> metaDataPair = this.GetBinding <Pair <string, Type> >("SelectedMetaDataDefinition"); Guid newMetaDataContainerId = this.GetBinding <Guid>("SelectedMetaDataContainer"); string newLabel = this.GetBinding <string>("Label"); int startLevel = this.GetBinding <int>("SelectedStartDisplay"); int levels = this.GetBinding <int>("SelectedInheritDisplay"); PageMetaDataFacade.UpdateDefinition(GetCurrentPageId(), metaDataPair.First, newLabel, startLevel, levels, newMetaDataContainerId); IEnumerable <Guid> oldPageIdsToRemove = oldPageIds.Except(newPageIds); foreach (Guid id in oldPageIdsToRemove) { IPage page = Composite.Data.PageManager.GetPageById(id); bool otherDefinitionExists = page.GetAllowedMetaDataDefinitions().Where(f => f.Name == metaDataPair.First).Any(); if (otherDefinitionExists) { continue; } using (new DataScope(DataScopeIdentifier.Public)) { IData dataToDelete = page.GetMetaData(metaDataPair.First, metaDataPair.Second); if (dataToDelete != null) { DataFacade.Delete(dataToDelete); } } using (new DataScope(DataScopeIdentifier.Administrated)) { IData dataToDelete = page.GetMetaData(metaDataPair.First, metaDataPair.Second); if (dataToDelete != null) { DataFacade.Delete(dataToDelete); } } } IData newDataTemplate = null; if (this.BindingExist("NewDataTemplate")) { newDataTemplate = this.GetBinding <IData>("NewDataTemplate"); DataTypeDescriptor dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(metaDataPair.Second.GetImmutableTypeId()); DataTypeDescriptorFormsHelper helper = new DataTypeDescriptorFormsHelper(dataTypeDescriptor); helper.BindingsToObject(this.Bindings, newDataTemplate); } IEnumerable <Guid> newPageIdsToAdd = newPageIds.Except(oldPageIds); foreach (Guid id in newPageIdsToAdd) { IPage page = Composite.Data.PageManager.GetPageById(id); page.AddNewMetaDataToExistingPage(metaDataPair.First, metaDataPair.Second, newDataTemplate); } transactionScope.Complete(); } }
/// <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 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); }