public static void AddLocale(string providerName, IEnumerable <Type> interfaceTypes, CultureInfo cultureInfo)
{
XmlDataProviderConfiguration xmlDataProviderConfiguration = new XmlDataProviderConfiguration(providerName);
foreach (Type type in interfaceTypes)
{
if (!DataLocalizationFacade.IsLocalized(type))
{
continue;
}
var dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(type);
object key = xmlDataProviderConfiguration.Section.Interfaces.GetKey(dataTypeDescriptor);
var oldConfigurationElement = xmlDataProviderConfiguration.Section.Interfaces.Get(key);
var newConfigurationElement = BuildXmlProviderInterfaceConfigurationElement(dataTypeDescriptor, cultureInfo, null, oldConfigurationElement);
xmlDataProviderConfiguration.Section.Interfaces.Remove(key);
xmlDataProviderConfiguration.Section.Interfaces.Add(newConfigurationElement);
foreach (Dictionary <string, DataScopeConfigurationElement> filesByCulture in newConfigurationElement.DataScopes.Values)
{
XmlDataProviderStoreManipulator.CreateStore(providerName, filesByCulture[cultureInfo.Name]);
}
}
xmlDataProviderConfiguration.Save();
}
public static IQueryable OrderData(IQueryable source, Type interfaceType)
{
var typeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(interfaceType);
List <DataFieldDescriptor> orderFields = typeDescriptor.Fields.Where(f => f.TreeOrderingProfile.OrderPriority.HasValue).OrderBy(f => f.TreeOrderingProfile.OrderPriority).ToList();
if (orderFields.Any())
{
IOrderedQueryable ordered = source.OrderBy(interfaceType, orderFields.First().Name, orderFields.First().TreeOrderingProfile.OrderDescending);
foreach (DataFieldDescriptor field in orderFields.Skip(1))
{
ordered = ordered.ThenBy(interfaceType, field.Name, field.TreeOrderingProfile.OrderDescending);
}
return(ordered);
}
if (!string.IsNullOrEmpty(typeDescriptor.LabelFieldName))
{
return(source.OrderBy(interfaceType, typeDescriptor.LabelFieldName));
}
return(source);
}
/// <exclude />
public static IData GetMetaData(this IPage page, string definitionName, Guid metaDataTypeId)
{
DataTypeDescriptor dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(metaDataTypeId);
Type metaDataType = TypeManager.GetType(dataTypeDescriptor.TypeManagerTypeName);
return(GetMetaData(page, definitionName, metaDataType));
}
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 static XhtmlDocument BuildDefaultDocument(IVisualFunction newFunction)
{
XElement htmlTable = new XElement(Namespaces.Xhtml + "table");
Type interfaceType = TypeManager.GetType(newFunction.TypeManagerName);
DataTypeDescriptor typeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(interfaceType);
foreach (DataFieldDescriptor dataField in typeDescriptor.Fields.OrderBy(f => f.Position))
{
if (!typeDescriptor.KeyPropertyNames.Contains(dataField.Name) &&
dataField.FormRenderingProfile != null &&
!string.IsNullOrEmpty(dataField.FormRenderingProfile.Label))
{
string fieldMarkup = string.Format("<data:fieldreference fieldname=\"{0}\" typemanagername=\"{1}\" xmlns:data=\"{2}\" />", dataField.Name, newFunction.TypeManagerName, Namespaces.DynamicData10);
htmlTable.Add(new XElement(Namespaces.Xhtml + "tr",
new XElement(Namespaces.Xhtml + "td",
dataField.FormRenderingProfile.Label),
new XElement(Namespaces.Xhtml + "td",
XElement.Parse(fieldMarkup))));
}
}
XhtmlDocument defaultDocument = new XhtmlDocument();
defaultDocument.Body.Add(htmlTable);
return(defaultDocument);
}
internal static Type GetFileBuilderNewHandler(Type dataType)
{
Type result;
if (!_fileBuildNewHandlerTypes.TryGetValue(dataType, out result))
{
lock (_lock)
{
if (!_fileBuildNewHandlerTypes.TryGetValue(dataType, out result))
{
DataTypeDescriptor dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(dataType);
string fullName = EmptyDataClassCodeGenerator.GetEmptyClassTypeFullName(dataTypeDescriptor);
result = TypeManager.TryGetType(fullName);
if (result == null)
{
CodeAttributeDeclaration codeAttributeDeclaration = new CodeAttributeDeclaration(
new CodeTypeReference(typeof(FileStreamManagerAttribute)),
new [] {
new CodeAttributeArgument(new CodeTypeOfExpression(typeof(IFileEmptyDataClassFileStreamManager)))
});
result = EmptyDataClassTypeManager.CreateEmptyDataClassType(dataTypeDescriptor, typeof(IFileEmptyDataClassBase), codeAttributeDeclaration);
}
_fileBuildNewHandlerTypes.Add(dataType, result);
}
}
}
return(result);
}
protected override string GetJson(HttpContext context)
{
var list = DataFacade.GetAllInterfaces()
.Select(i =>
{
try
{
return(DynamicTypeManager.GetDataTypeDescriptor(i));
}
catch
{
return(null);
}
})
.Where(d => d != null)
.Select(d =>
new
{
d.Name,
d.Namespace,
TypeId = d.DataTypeId,
Properties = d.Fields.Select(f => new
{
f.Name,
Type = f.InstanceType.FullName
})
})
.OrderBy(o => o.Name);
var json = JsonConvert.SerializeObject(list);
return(json);
}
private void initializeCodeActivity_ExecuteCode(object sender, EventArgs e)
{
DataEntityToken token = (DataEntityToken)this.EntityToken;
IVisualFunction function = (IVisualFunction)token.Data;
this.Bindings.Add("OriginalFullName", string.Format("{0}.{1}", function.Namespace, function.Name));
this.Bindings.Add("Function", function);
this.Bindings.Add("XhtmlBody", function.XhtmlTemplate);
Type interfaceType = TypeManager.GetType(function.TypeManagerName);
DataTypeDescriptor typeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(interfaceType);
this.Bindings.Add("EmbedableFieldsTypes", new List <Type> {
interfaceType
});
this.Bindings.Add("SourceTypeFullName", interfaceType.FullName);
this.Bindings.Add("FieldNameList", FieldNames(typeDescriptor).ToList());
Dictionary <Guid, string> templateInfos = new Dictionary <Guid, string>();
foreach (PageTemplateDescriptor pageTemplate in PageTemplateFacade.GetPageTemplates())
{
if (pageTemplate.PlaceholderDescriptions.Any())
{
templateInfos.Add(pageTemplate.Id, pageTemplate.Title);
}
}
this.Bindings.Add("PreviewTemplateId", templateInfos.First().Key);
this.Bindings.Add("TemplateList", templateInfos);
}
/// <summary>
/// Returns (if any) folder types that are defined on the given page
/// </summary>
/// <param name="page"></param>
/// <returns></returns>
public static IEnumerable <Type> GetDefinedFolderTypes(this IPage page)
{
Verify.ArgumentNotNull(page, nameof(page));
var folderDefinitions = DataFacade.GetData <IPageFolderDefinition>();
IEnumerable <Guid> typeIds;
if (folderDefinitions.IsEnumerableQuery())
{
typeIds = folderDefinitions
.Evaluate()
.Where(f => f.PageId == page.Id)
.Select(f => f.FolderTypeId);
}
else
{
typeIds = folderDefinitions
.Where(f => f.PageId == page.Id)
.Select(f => f.FolderTypeId)
.Evaluate();
}
foreach (Guid typeId in typeIds)
{
var dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(typeId);
Verify.IsNotNull(dataTypeDescriptor, "Missing a page data folder type with id '{0}', referenced by a IPageFolderDefinition record", typeId);
yield return(TypeManager.GetType(dataTypeDescriptor.TypeManagerTypeName));
}
}
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)
);
}
/// <exclude />
public override IEnumerable <PackageFragmentValidationResult> Validate()
{
_validationResult = new List <PackageFragmentValidationResult>();
if (this.Configuration.Count(f => f.Name == "Types") > 1)
{
_validationResult.AddFatal(GetText("DynamicDataTypePackageFragmentUninstaller.OnlyOneElement"));
return(_validationResult);
}
XElement typesElement = this.Configuration.SingleOrDefault(f => f.Name == "Types");
_dataTypeDescriptorsToDelete = new List <DataTypeDescriptor>();
if (typesElement != null)
{
foreach (XElement typeElement in typesElement.Elements("Type").Reverse())
{
XAttribute typeIdAttribute = typeElement.Attribute("typeId");
if (typeIdAttribute == null)
{
_validationResult.AddFatal(GetText("DynamicDataTypePackageFragmentUninstaller.MissingAttribute").FormatWith("typeId"), typeElement);
continue;
}
Guid typeId;
if (!typeIdAttribute.TryGetGuidValue(out typeId))
{
_validationResult.AddFatal(GetText("DynamicDataTypePackageFragmentUninstaller.WrongAttributeFormat"), typeIdAttribute);
continue;
}
var dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(typeId);
if (dataTypeDescriptor == null)
{
continue;
}
_dataTypeDescriptorsToDelete.Add(dataTypeDescriptor);
Type interfaceType = dataTypeDescriptor.GetInterfaceType();
var foreignRefereeTypes = DataReferenceFacade.GetRefereeTypes(interfaceType).Where(f => !_dataTypeDescriptorsToDelete.Any(g => g.GetInterfaceType() == f));
foreach (Type foreignRefereeType in foreignRefereeTypes)
{
// TODO: localize
_validationResult.AddFatal(string.Format("Data type '{0}' has references to type '{1}' about to be uninstalled. References must be removed before the package can be uninstalled.", foreignRefereeType, dataTypeDescriptor.TypeManagerTypeName),
typeIdAttribute);
}
UninstallerContext.AddPendingForDeletionDataType(interfaceType);
}
}
if (_validationResult.Count > 0)
{
_dataTypeDescriptorsToDelete = null;
}
return(_validationResult);
}
/// <exclude />
public void SetForeignKeyReference(Type targetDataType, DataAssociationType dataAssociationType)
{
if (dataAssociationType == DataAssociationType.None) throw new ArgumentException("dataAssociationType");
DataTypeDescriptor targetDataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(targetDataType);
SetForeignKeyReference(targetDataTypeDescriptor, dataAssociationType);
}
/// <summary>
/// Return all allowed metadata types on the given page
/// </summary>
/// <param name="page"></param>
/// <returns></returns>
public static IEnumerable <Type> GetAllowedMetaDataTypes(this IPage page)
{
foreach (Guid metaDataTypeId in GetAllowedMetaDataDefinitions(page).Select(f => f.MetaDataTypeId).Distinct())
{
DataTypeDescriptor dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(metaDataTypeId);
yield return(TypeManager.GetType(dataTypeDescriptor.TypeManagerTypeName));
}
}
/// <exclude />
public GeneratedTypesHelper(Type oldType)
{
Verify.ArgumentNotNull(oldType, "oldType");
_oldType = oldType;
_oldDataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(oldType);
Initialize();
}
private void CanSkipStep2(object sender, ConditionalEventArgs e)
{
IPage newPage = this.GetBinding <IPage>("NewPage");
var dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(typeof(IPage));
e.Result = this.GetBinding <string>("SelectedSortOrder") != "Relative" &&
UrlTitleIsUniqueAmongSiblings() &&
newPage.UrlTitle.Length <= dataTypeDescriptor.Fields["UrlTitle"].StoreType.MaximumLength &&
newPage.MenuTitle.Length <= dataTypeDescriptor.Fields["MenuTitle"].StoreType.MaximumLength;
}
public List <Element> GetChildren(T data, EntityToken parentEntityToken)
{
var children = new List <Element>();
PropertyInfo idPropertyInfo = typeof(T).GetKeyProperties()[0];
foreach (Type type in PageFolderFacade.GetDefinedFolderTypes((IPage)data).OrderBy(t => t.Name))
{
var entityToken = new AssociatedDataElementProviderHelperEntityToken(
TypeManager.SerializeType(typeof(T)),
_elementProviderContext.ProviderName,
ValueTypeConverter.Convert <string>(idPropertyInfo.GetValue(data, null)),
TypeManager.SerializeType(type)
);
DataTypeDescriptor dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(type);
var element = new Element(_elementProviderContext.CreateElementHandle(entityToken))
{
VisualData = new ElementVisualizedData
{
Label = dataTypeDescriptor.Title ?? type.Name,
ToolTip = dataTypeDescriptor.Title ?? type.Name,
Icon = this.InterfaceClosedIcon,
OpenedIcon = this.InterfaceOpenIcon,
HasChildren = true // This is sat to always true to boost performance.
}
};
element.AddAction(new ElementAction(new ActionHandle(new WorkflowActionToken(WorkflowFacade.GetWorkflowType("Composite.C1Console.Elements.ElementProviderHelpers.AssociatedDataElementProviderHelper.DeleteDataFolderWorkflow"), RemoveAssociatedTypePermissionTypes)))
{
VisualData = new ActionVisualizedData
{
Label = StringResourceSystemFacade.GetString("Composite.Management", "AssociatedDataElementProviderHelper.RemoveAssociatedTypeLabel"),
ToolTip = StringResourceSystemFacade.GetString("Composite.Management", "AssociatedDataElementProviderHelper.RemoveAssociatedTypeToolTip"),
Icon = this.RemoveDataAssociationTypeIcon,
Disabled = false,
ActionLocation = new ActionLocation
{
ActionType = ActionType.Delete,
IsInFolder = false,
IsInToolbar = false,
ActionGroup = AppendedActionGroup
}
}
});
AddAddAssociatedDataAction(element, true);
children.Add(element);
}
return(children);
}
/// <summary>
/// Using the given pageType this methods adds meta data instances that are missing
/// </summary>
/// <param name="definingPageType"></param>
/// <param name="metaDataDefinitionName"></param>
/// <param name="newDataTemplate"></param>
public static void AddNewMetaDataToExistingPages(this IPageType definingPageType, string metaDataDefinitionName, IData newDataTemplate)
{
IPageMetaDataDefinition pageMetaDataDefinition = GetMetaDataDefinition(definingPageType.Id, metaDataDefinitionName);
DataTypeDescriptor dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(pageMetaDataDefinition.MetaDataTypeId);
Type metaDataType = TypeManager.GetType(dataTypeDescriptor.TypeManagerTypeName);
IEnumerable <IPage> affectedPages = PageMetaDataFacade.GetMetaDataAffectedPagesByPageTypeId(definingPageType.Id);
AddNewMetaDataToExistingPages(affectedPages, metaDataDefinitionName, metaDataType, newDataTemplate);
}
public static IEnumerable <string> OrderByFieldNames(string typeManagerName)
{
yield return("(random)");
Type interfaceType = TypeManager.GetType(typeManagerName);
foreach (DataFieldDescriptor dataField in DynamicTypeManager.GetDataTypeDescriptor(interfaceType).Fields.OrderBy(f => f.Position))
{
yield return(dataField.Name);
}
}
public DataTypeHelper(Guid targetId, Guid?pageId)
{
DataSourceId dataSourceId;
TargetDataSourceFacade.TryDeserialize(targetId, pageId, out dataSourceId);
if (dataSourceId != null)
{
_dataSourceId = dataSourceId;
_dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(dataSourceId.InterfaceType);
}
}
public IEnumerable <ReferenceFailingPropertyInfo> GetReferencingLocalizeFailingProperties(ILocalizedControlled data)
{
DataTypeDescriptor dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(data.DataSourceId.InterfaceType);
IEnumerable <DataFieldDescriptor> requiredDataFieldDescriptors = dataTypeDescriptor.Fields.Where(f => f.ForeignKeyReferenceTypeName != null);
foreach (DataFieldDescriptor dataFieldDescriptor in requiredDataFieldDescriptors)
{
Type referencedType = TypeManager.GetType(dataFieldDescriptor.ForeignKeyReferenceTypeName);
if (!DataLocalizationFacade.IsLocalized(referencedType))
{
continue; // No special handling for not localized data.
}
IData referencedData = data.GetReferenced(dataFieldDescriptor.Name);
if (referencedData != null)
{
continue; // Data has already been localized
}
bool optionalReferenceWithValue = false;
if (dataFieldDescriptor.IsNullable)
{
PropertyInfo propertyInfo = data.DataSourceId.InterfaceType.GetPropertiesRecursively().Single(f => f.Name == dataFieldDescriptor.Name);
object value = propertyInfo.GetValue(data, null);
if (value == null || object.Equals(value, dataFieldDescriptor.DefaultValue))
{
continue; // Optional reference is null;
}
optionalReferenceWithValue = true;
}
CultureInfo locale = data.DataSourceId.LocaleScope;
using (new DataScope(locale))
{
referencedData = data.GetReferenced(dataFieldDescriptor.Name);
}
ReferenceFailingPropertyInfo referenceFailingPropertyInfo = new ReferenceFailingPropertyInfo
(
dataFieldDescriptor,
referencedType,
referencedData,
optionalReferenceWithValue
);
yield return(referenceFailingPropertyInfo);
}
}
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;
}
}
protected override string GetJson(HttpContext context)
{
var typeId = context.Request.Form["typeId"];
using (new DataScope(PublicationScope.Published))
{
var type = DynamicTypeManager.GetDataTypeDescriptor(Guid.Parse(typeId)).GetInterfaceType();
var list = DataFacade.GetData(type).ToListOfObjects();
var json = JsonConvert.SerializeObject(list);
return(json);
}
}
private void ValidateFirstPage(object sender, ConditionalEventArgs e)
{
IPage newPage = this.GetBinding <IPage>("NewPage");
var dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(typeof(IPage));
if (newPage.Title.Length > dataTypeDescriptor.Fields["Title"].StoreType.MaximumLength)
{
this.ShowFieldMessage("NewPage.Title", GetText("AddNewPageStep1.TitleTooLong"));
e.Result = false;
return;
}
e.Result = true;
}
/// <summary>
/// Using the given page this methods adds meta data instances that are missing
/// </summary>
/// <param name="definingPage">If null, empty guid is used</param>
/// <param name="metaDataDefinitionName"></param>
/// <param name="newDataTemplate"></param>
public static void AddNewMetaDataToExistingPages(this IPage definingPage, string metaDataDefinitionName, IData newDataTemplate)
{
Guid pageId = definingPage.GetPageIdOrNull();
IPageMetaDataDefinition pageMetaDataDefinition = GetMetaDataDefinition(pageId, metaDataDefinitionName);
DataTypeDescriptor dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(pageMetaDataDefinition.MetaDataTypeId);
Type metaDataType = TypeManager.GetType(dataTypeDescriptor.TypeManagerTypeName);
IEnumerable <IPage> affectedPages = definingPage.GetMetaDataAffectedPages(metaDataDefinitionName);
foreach (IPage affectedPage in affectedPages)
{
AddNewMetaDataToExistingPage(affectedPage, metaDataDefinitionName, metaDataType, newDataTemplate);
}
}
private void editPreviewCodeActivity_ExecuteCode(object sender, EventArgs e)
{
try
{
XhtmlDocument templateDocument = GetTemplateDocumentFromBindings();
IVisualFunction function = this.GetBinding <IVisualFunction>("Function");
Type interfaceType = TypeManager.GetType(function.TypeManagerName);
DataTypeDescriptor typeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(interfaceType);
this.LogMessage(Composite.Core.Logging.LogLevel.Info, DataScopeManager.CurrentDataScope.Name);
FunctionContextContainer fcc = PageRenderer.GetPageRenderFunctionContextContainer();
XhtmlDocument result = RenderingHelper.RenderCompleteDataList(function, templateDocument, typeDescriptor, fcc);
IPage previewPage = DataFacade.BuildNew <IPage>();
previewPage.Id = GetRootPageId();
previewPage.Title = function.Name;
previewPage.DataSourceId.DataScopeIdentifier = DataScopeIdentifier.Administrated;
previewPage.DataSourceId.LocaleScope = LocalizationScopeManager.CurrentLocalizationScope;
previewPage.TemplateId = this.GetBinding <Guid>("PreviewTemplateId");
var pageTemplate = PageTemplateFacade.GetPageTemplate(previewPage.TemplateId);
IPagePlaceholderContent placeHolderContent = DataFacade.BuildNew <IPagePlaceholderContent>();
placeHolderContent.Content = string.Concat((result.Body.Elements().Select(b => b.ToString())).ToArray());
placeHolderContent.PlaceHolderId = pageTemplate.DefaultPlaceholderId;
string output = PagePreviewBuilder.RenderPreview(previewPage, new List <IPagePlaceholderContent> {
placeHolderContent
});
var serviceContainer = WorkflowFacade.GetFlowControllerServicesContainer(WorkflowEnvironment.WorkflowInstanceId);
var webRenderService = serviceContainer.GetService <IFormFlowWebRenderingService>();
webRenderService.SetNewPageOutput(new LiteralControl(output));
}
catch (Exception ex)
{
FlowControllerServicesContainer serviceContainer = WorkflowFacade.GetFlowControllerServicesContainer(WorkflowEnvironment.WorkflowInstanceId);
Control errOutput = new LiteralControl("<pre>" + ex + "</pre>");
var webRenderService = serviceContainer.GetService <IFormFlowWebRenderingService>();
webRenderService.SetNewPageOutput(errOutput);
}
}
private static TypeInfo GetTypeInfo(string typeManagerName)
{
TypeInfo cachedValue = _typeLookup.Get(typeManagerName);
if (cachedValue != null)
{
return(cachedValue);
}
Type type = TypeManager.GetType(typeManagerName);
DataTypeDescriptor typeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(type);
var result = new TypeInfo(type, typeDescriptor);
_typeLookup.Add(typeManagerName, result);
return(result);
}
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);
}
/// <summary>
/// Returns all meta data types that are defined on the given page.
/// </summary>
/// <param name="page">If this is null, Guid.Empty is assumed as defining item id</param>
/// <returns></returns>
public static IEnumerable <Type> GetDefinedMetaDataTypes(this IPage page)
{
Guid pageId = page.GetPageIdOrNull();
IEnumerable <Guid> metaDataTypeIds =
DataFacade.GetData <IPageMetaDataDefinition>().
Where(f => f.DefiningItemId == pageId).
Select(f => f.MetaDataTypeId).
Distinct();
foreach (Guid metaDataTypeId in metaDataTypeIds)
{
DataTypeDescriptor dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(metaDataTypeId);
yield return(TypeManager.GetType(dataTypeDescriptor.TypeManagerTypeName));
}
}
/// <exclude />
public static IEnumerable <Tuple <Type, string> > GetDefinedMetaDataTypeAndNames(this IPage page)
{
Guid pageId = page.GetPageIdOrNull();
IEnumerable <Tuple <Guid, string> > metaDataTypeIdAndNames =
DataFacade.GetData <IPageMetaDataDefinition>().
Where(f => f.DefiningItemId == pageId).
Select(f => new Tuple <Guid, string>(f.MetaDataTypeId, f.Name)).
Distinct();
foreach (Tuple <Guid, string> metaDataTypeIdAndName in metaDataTypeIdAndNames)
{
DataTypeDescriptor dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(metaDataTypeIdAndName.Item1);
yield return(new Tuple <Type, string>(TypeManager.GetType(dataTypeDescriptor.TypeManagerTypeName), metaDataTypeIdAndName.Item2));
}
}
private void initializeCodeActivity_UpdateBindings_ExecuteCode(object sender, EventArgs e)
{
IPageTypeMetaDataTypeLink pageTypeMetaDataTypeLink = this.GetDataItemFromEntityToken <IPageTypeMetaDataTypeLink>();
IPageMetaDataDefinition pageMetaDataDefinition = PageMetaDataFacade.GetMetaDataDefinition(pageTypeMetaDataTypeLink.PageTypeId, pageTypeMetaDataTypeLink.Name);
//this.UpdateBinding("CompositionDescriptionName", compositionDescription.Name);
this.UpdateBinding("CompositionDescriptionLabel", pageMetaDataDefinition.Label);
List <KeyValuePair <Guid, string> > metaDataContainerOptions = PageMetaDataFacade.GetAllMetaDataContainers();
this.Bindings.Add("MetaDataContainerOptions", metaDataContainerOptions);
this.Bindings.Add("CompositionContainerId", pageMetaDataDefinition.MetaDataContainerId);
var dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(pageTypeMetaDataTypeLink.DataTypeId);
this.Bindings.Add("MetaTypeName", dataTypeDescriptor.TypeManagerTypeName);
}
