public IEnumerable <DataListItem> GetItems(Dictionary <string, object> config)
{
if (config.TryGetValue("imageCropper", out var v) &&
v is JArray a &&
a.Count > 0 &&
a[0].Value <string>() is string s &&
string.IsNullOrWhiteSpace(s) == false &&
GuidUdi.TryParse(s, out var udi))
{
return(_dataTypeService
.GetDataType(udi.Guid)?
.ConfigurationAs <ImageCropperConfiguration>()?
.Crops?
.Select(x => new DataListItem
{
Name = x.Alias,
Value = x.Alias,
Icon = this.Icon,
Description = $"{x.Width}px × {x.Height}px"
}));
}
return(Enumerable.Empty <DataListItem>());
}
//borrowed from CMS core until SetValue is fixed with a stream
private string CreateImageCropperValue(PropertyType propertyType, object value, IDataTypeService dataTypeService)
{
if (value == null || string.IsNullOrEmpty(value.ToString()))
{
return(null);
}
// if we don't have a json structure, we will get it from the property type
var val = value.ToString();
if (val.DetectIsJson())
{
return(val);
}
var configuration = dataTypeService.GetDataType(propertyType.DataTypeId).ConfigurationAs <ImageCropperConfiguration>();
var crops = configuration?.Crops ?? Array.Empty <ImageCropperConfiguration.Crop>();
return(JsonConvert.SerializeObject(new
{
src = val,
crops = crops
}));
}
public ElementsPropertyType(PropertyType propertyType, IDataTypeService dataTypeService) : this(propertyType, dataTypeService.GetDataType(propertyType.DataTypeId))
{
}
private IDataType GetDataType(PropertyDataType dataType)
{
return(_DataTypeService.GetDataType((int)dataType));
}
public void Initialize()
{
try
{
var homeDocType = _contentTypeService.Get(DOCUMENT_TYPE_ALIAS);
if (!homeDocType.PropertyTypeExists(HOME_SPINNER_PROPERTY_ALIAS))
{
PropertyType spinner = new PropertyType(_dataTypeService.GetDataType(SPINNER_PROPERTY_TYPE_NAME), HOME_SPINNER_PROPERTY_ALIAS)
{
Name = HOME_SPINNER_PROPERTY_NAME,
Description = HOME_SPINNER_PROPERTY_DESCRIPTION,
Variations = ContentVariation.Culture
};
homeDocType.AddPropertyType(spinner, TAB_NAME);
_contentTypeService.Save(homeDocType);
}
var imgCropper = _dataTypeService.GetDataType(IMAGE_CROPPER_PROPERTY_TYPE_NAME);
if (imgCropper != null)
{
if (imgCropper.Configuration is Umbraco.Core.PropertyEditors.ImageCropperConfiguration)
{
var imageCropperConfiguration = (Umbraco.Core.PropertyEditors.ImageCropperConfiguration)imgCropper.Configuration;
if (imageCropperConfiguration == null)
{
imageCropperConfiguration = new Umbraco.Core.PropertyEditors.ImageCropperConfiguration()
{
Crops = new Core.PropertyEditors.ImageCropperConfiguration.Crop[0]
};
}
if (imageCropperConfiguration.Crops == null)
{
imageCropperConfiguration.Crops = new Core.PropertyEditors.ImageCropperConfiguration.Crop[0];
}
if (imageCropperConfiguration.Crops.FirstOrDefault(p => p.Alias == FORM_IMAGE_CROPPER_ALIAS) == null)
{
var crops = new List <Core.PropertyEditors.ImageCropperConfiguration.Crop>();
crops.AddRange(imageCropperConfiguration.Crops);
crops.Add(new Core.PropertyEditors.ImageCropperConfiguration.Crop()
{
Alias = FORM_IMAGE_CROPPER_ALIAS,
Height = FORM_IMAGE_CROPPER_ALIAS_HEIGHT,
Width = FORM_IMAGE_CROPPER_ALIAS_WIDTH
});
imageCropperConfiguration.Crops = crops.ToArray();
_dataTypeService.Save(imgCropper);
_logger.Info(typeof(_38_HomeDocumentTypeSpinner), $"{IMAGE_CROPPER_PROPERTY_TYPE_NAME} Alias saved: {JsonConvert.SerializeObject(imageCropperConfiguration.Crops)}");
}
else
{
_logger.Info(typeof(_38_HomeDocumentTypeSpinner), $"{IMAGE_CROPPER_PROPERTY_TYPE_NAME} Alias {FORM_IMAGE_CROPPER_ALIAS} Already Exists");
}
}
else
{
_logger.Info(typeof(_38_HomeDocumentTypeSpinner), $"Invalid type for imgCropper.Configuration TYPE: {imgCropper.Configuration.GetType()}");
}
}
else
{
_logger.Info(typeof(_38_HomeDocumentTypeSpinner), $"Datatype {IMAGE_CROPPER_PROPERTY_TYPE_NAME} Not Found");
}
}
catch (System.Exception ex)
{
_logger.Error(typeof(_38_HomeDocumentTypeSpinner), ex.Message);
_logger.Error(typeof(_38_HomeDocumentTypeSpinner), ex.StackTrace);
}
}
public FieldSqlWriter DataType(IDataTypeService dataTypeService) {
foreach (var key in CopyOutputKeys()) {
_output[key] = string.Concat(_output[key], " ", dataTypeService.GetDataType(_original[key]));
}
return this;
}
// note: there is NO variant support here
/// <summary>
/// Ensure that sub-editor values are translated through their ToEditor methods
/// </summary>
/// <param name="property"></param>
/// <param name="dataTypeService"></param>
/// <param name="culture"></param>
/// <param name="segment"></param>
/// <returns></returns>
public override object ToEditor(IProperty property, string?culture = null, string?segment = null)
{
var val = property.GetValue(culture, segment);
var valEditors = new Dictionary <int, IDataValueEditor>();
BlockEditorData?blockEditorData;
try
{
blockEditorData = _blockEditorValues.DeserializeAndClean(val);
}
catch (JsonSerializationException)
{
// if this occurs it means the data is invalid, shouldn't happen but has happened if we change the data format.
return(string.Empty);
}
if (blockEditorData == null)
{
return(string.Empty);
}
void MapBlockItemData(List <BlockItemData> items)
{
foreach (var row in items)
{
foreach (var prop in row.PropertyValues)
{
// create a temp property with the value
// - force it to be culture invariant as the block editor can't handle culture variant element properties
prop.Value.PropertyType.Variations = ContentVariation.Nothing;
var tempProp = new Property(prop.Value.PropertyType);
tempProp.SetValue(prop.Value.Value);
var propEditor = _propertyEditors[prop.Value.PropertyType.PropertyEditorAlias];
if (propEditor == null)
{
// NOTE: This logic was borrowed from Nested Content and I'm unsure why it exists.
// if the property editor doesn't exist I think everything will break anyways?
// update the raw value since this is what will get serialized out
row.RawPropertyValues[prop.Key] = tempProp.GetValue()?.ToString();
continue;
}
var dataType = _dataTypeService.GetDataType(prop.Value.PropertyType.DataTypeId);
if (dataType == null)
{
// deal with weird situations by ignoring them (no comment)
row.PropertyValues.Remove(prop.Key);
_logger.LogWarning(
"ToEditor removed property value {PropertyKey} in row {RowId} for property type {PropertyTypeAlias}",
prop.Key, row.Key, property.PropertyType.Alias);
continue;
}
if (!valEditors.TryGetValue(dataType.Id, out var valEditor))
{
var tempConfig = dataType.Configuration;
valEditor = propEditor.GetValueEditor(tempConfig);
valEditors.Add(dataType.Id, valEditor);
}
var convValue = valEditor.ToEditor(tempProp);
// update the raw value since this is what will get serialized out
row.RawPropertyValues[prop.Key] = convValue;
}
}
}
MapBlockItemData(blockEditorData.BlockValue.ContentData);
MapBlockItemData(blockEditorData.BlockValue.SettingsData);
// return json convertable object
return(blockEditorData.BlockValue);
}
public void OnActionExecuting(ActionExecutingContext context)
{
var dataType = (DataTypeSave?)context.ActionArguments["dataType"];
if (dataType is not null)
{
dataType.Name = dataType.Name?.CleanForXss('[', ']', '(', ')', ':');
dataType.Alias = dataType.Alias == null ? dataType.Name ! : dataType.Alias.CleanForXss('[', ']', '(', ')', ':');
}
// get the property editor, ensuring that it exits
if (!_propertyEditorCollection.TryGet(dataType?.EditorAlias, out var propertyEditor))
{
var message = $"Property editor \"{dataType?.EditorAlias}\" was not found.";
context.Result = new UmbracoProblemResult(message, HttpStatusCode.NotFound);
return;
}
if (dataType is null)
{
return;
}
// assign
dataType.PropertyEditor = propertyEditor;
// validate that the data type exists, or create one if required
IDataType?persisted;
switch (dataType.Action)
{
case ContentSaveAction.Save:
persisted = _dataTypeService.GetDataType(Convert.ToInt32(dataType.Id));
if (persisted == null)
{
var message = $"Data type with id {dataType.Id} was not found.";
context.Result = new UmbracoProblemResult(message, HttpStatusCode.NotFound);
return;
}
// map the model to the persisted instance
_umbracoMapper.Map(dataType, persisted);
break;
case ContentSaveAction.SaveNew:
// create the persisted model from mapping the saved model
persisted = _umbracoMapper.Map <IDataType>(dataType);
((DataType?)persisted)?.ResetIdentity();
break;
default:
context.Result = new UmbracoProblemResult($"Data type action {dataType.Action} was not found.", HttpStatusCode.NotFound);
return;
}
// assign (so it's available in the action)
dataType.PersistedDataType = persisted;
// validate the configuration
// which is posted as a set of fields with key (string) and value (object)
var configurationEditor = propertyEditor.GetConfigurationEditor();
if (dataType.ConfigurationFields is not null)
{
foreach (var field in dataType.ConfigurationFields)
{
var editorField = configurationEditor.Fields.SingleOrDefault(x => x.Key == field.Key);
if (editorField == null)
{
continue;
}
// run each IValueValidator (with null valueType and dataTypeConfiguration: not relevant here)
foreach (var validator in editorField.Validators)
{
foreach (var result in validator.Validate(field.Value, null, null))
{
context.ModelState.AddValidationError(result, "Properties", field.Key ?? string.Empty);
}
}
}
}
if (context.ModelState.IsValid == false)
{
// if it is not valid, do not continue and return the model state
context.Result = new ValidationErrorResult(context.ModelState);
}
}
public XElement Serialize(IMediaType mediaType)
{
var info = new XElement("Info",
new XElement("Name", mediaType.Name),
new XElement("Alias", mediaType.Alias),
new XElement("Icon", mediaType.Icon),
new XElement("Thumbnail", mediaType.Thumbnail),
new XElement("Description", mediaType.Description),
new XElement("AllowAtRoot", mediaType.AllowedAsRoot.ToString()));
var masterContentType = mediaType.CompositionAliases().FirstOrDefault();
if (masterContentType != null)
{
info.Add(new XElement("Master", masterContentType));
}
var structure = new XElement("Structure");
foreach (var allowedType in mediaType.AllowedContentTypes)
{
structure.Add(new XElement("MediaType", allowedType.Alias));
}
var genericProperties = new XElement("GenericProperties"); // actually, all of them
foreach (var propertyType in mediaType.PropertyTypes)
{
var definition = _dataTypeService.GetDataType(propertyType.DataTypeId);
var propertyGroup = propertyType.PropertyGroupId == null // true generic property
? null
: mediaType.PropertyGroups.FirstOrDefault(x => x.Id == propertyType.PropertyGroupId.Value);
var genericProperty = new XElement("GenericProperty",
new XElement("Name", propertyType.Name),
new XElement("Alias", propertyType.Alias),
new XElement("Type", propertyType.PropertyEditorAlias),
new XElement("Definition", definition.Key),
new XElement("Tab", propertyGroup == null ? "" : propertyGroup.Name),
new XElement("Mandatory", propertyType.Mandatory.ToString()),
new XElement("Validation", propertyType.ValidationRegExp),
new XElement("Description", new XCData(propertyType.Description)));
genericProperties.Add(genericProperty);
}
var tabs = new XElement("Tabs");
foreach (var propertyGroup in mediaType.PropertyGroups)
{
var tab = new XElement("Tab",
new XElement("Id", propertyGroup.Id.ToString(CultureInfo.InvariantCulture)),
new XElement("Caption", propertyGroup.Name),
new XElement("SortOrder", propertyGroup.SortOrder));
tabs.Add(tab);
}
var xml = new XElement("MediaType",
info,
structure,
genericProperties,
tabs);
return(xml);
}
private void Reconfigure()
{
try
{
var homeDocType = contentTypeService.Get(DOCUMENT_TYPE_ALIAS);
homeDocType.AddPropertyGroup(TAB_NAME);
//if (!homeDocType.PropertyTypeExists("gameMessage"))
//{
// var richTextEditor = dataTypeService.GetDataType("Full Rich Text Editor");
// PropertyType richTextPropType = new PropertyType(dataTypeService.GetDataType(richTextEditor.Id), "gameMessage")
// {
// Name = "Game Terms and Conditions",
// Description = "Terms and Conditions for playing games",
// Variations = ContentVariation.Culture
// };
// homeDocType.AddPropertyType(richTextPropType, TAB_NAME);
//}
if (homeDocType.PropertyTypeExists("gameMessage"))
{
homeDocType.RemovePropertyType("gameMessage");
contentTypeService.Save(homeDocType);
}
if (!homeDocType.PropertyTypeExists("gameAgreeText"))
{
PropertyType gameAgreePropType = new PropertyType(dataTypeService.GetDataType(-88), "gameAgreeText")
{
Name = "Agreement text",
Description = "Agreement text with checkbox",
Variations = ContentVariation.Culture
};
homeDocType.AddPropertyType(gameAgreePropType, TAB_NAME);
PropertyType playButtonTextPropType = new PropertyType(dataTypeService.GetDataType(-88), "playButtonText")
{
Name = "Play Button Text",
Description = "Text for the play button",
Variations = ContentVariation.Culture
};
homeDocType.AddPropertyType(playButtonTextPropType, TAB_NAME);
PropertyType demoButtonTextPropType = new PropertyType(dataTypeService.GetDataType(-88), "demoButtonText")
{
Name = "Demo Button Text",
Description = "Text for the demo button",
Variations = ContentVariation.Culture
};
homeDocType.AddPropertyType(demoButtonTextPropType, TAB_NAME);
var mediaPickerContainer = dataTypeService.GetContainers(DATA_TYPE_CONTAINER, 1).FirstOrDefault();
var mediaPickerContainerId = -1;
if (mediaPickerContainer != null)
{
mediaPickerContainerId = mediaPickerContainer.Id;
}
var mediaPickerDataType = dataTypeService.GetDataType("Demo Page Media Picker");
PropertyType demoPageImages = new PropertyType(dataTypeService.GetDataType(mediaPickerDataType.Id), "demoPageImages")
{
Name = "Game Mode Images",
Description = "Images to display in the Game Mode Dialog",
Variations = ContentVariation.Culture
};
homeDocType.AddPropertyType(demoPageImages, TAB_NAME);
contentTypeService.Save(homeDocType);
ConnectorContext.AuditService.Add(AuditType.Save, -1, homeDocType.Id, "DocumentType", $"Document Type '{DOCUMENT_TYPE_ALIAS}' has been updated");
}
}
catch (Exception ex)
{
logger.Error(typeof(_24_HomeDocumentTypeGameModeDialog), ex.Message);
logger.Error(typeof(_24_HomeDocumentTypeGameModeDialog), ex.StackTrace);
}
}
private IEnumerable <TPropertyType> MapProperties(
IEnumerable <IPropertyType>?properties,
IContentTypeBase contentType,
int groupId,
bool inherited)
{
var mappedProperties = new List <TPropertyType>();
foreach (IPropertyType p in properties?.Where(x => x.DataTypeId != 0).OrderBy(x => x.SortOrder) ??
Enumerable.Empty <IPropertyType>())
{
var propertyEditorAlias = p.PropertyEditorAlias;
IDataEditor?propertyEditor = _propertyEditors[propertyEditorAlias];
IDataType? dataType = _dataTypeService.GetDataType(p.DataTypeId);
// fixme: Don't explode if we can't find this, log an error and change this to a label
if (propertyEditor == null)
{
_logger.LogError(
"No property editor could be resolved with the alias: {PropertyEditorAlias}, defaulting to label",
p.PropertyEditorAlias);
propertyEditorAlias = Constants.PropertyEditors.Aliases.Label;
propertyEditor = _propertyEditors[propertyEditorAlias];
}
IDictionary <string, object>?config = propertyEditor is null || dataType is null ? new Dictionary <string, object>()
: dataType.Editor?.GetConfigurationEditor().ToConfigurationEditor(dataType.Configuration);
mappedProperties.Add(new TPropertyType
{
Id = p.Id,
Alias = p.Alias,
Description = p.Description,
LabelOnTop = p.LabelOnTop,
Editor = p.PropertyEditorAlias,
Validation = new PropertyTypeValidation
{
Mandatory = p.Mandatory,
MandatoryMessage = p.MandatoryMessage,
Pattern = p.ValidationRegExp,
PatternMessage = p.ValidationRegExpMessage,
},
Label = p.Name,
View = propertyEditor?.GetValueEditor().View,
Config = config,
// Value = "",
GroupId = groupId,
Inherited = inherited,
DataTypeId = p.DataTypeId,
DataTypeKey = p.DataTypeKey,
DataTypeName = dataType?.Name,
DataTypeIcon = propertyEditor?.Icon,
SortOrder = p.SortOrder,
ContentTypeId = contentType.Id,
ContentTypeName = contentType.Name,
AllowCultureVariant = p.VariesByCulture(),
AllowSegmentVariant = p.VariesBySegment(),
});
}
return(mappedProperties);
}
private void UpdateDocumentType()
{
const string
propertyAlias = "bannerSlider",
propertyName = "Banner Slider",
propertyDescription = "Slider with banner images";
try
{
#region Nested Document Type
var container = contentTypeService.GetContainers(DOCUMENT_TYPE_CONTAINER, 1).FirstOrDefault();
int containerId = -1;
if (container != null)
{
containerId = container.Id;
}
var contentType = contentTypeService.Get(NESTED_DOCUMENT_TYPE_ALIAS);
if (contentType == null)
{
ContentType docType = (ContentType)contentType ?? new ContentType(containerId)
{
Name = NESTED_DOCUMENT_TYPE_NAME,
Alias = NESTED_DOCUMENT_TYPE_ALIAS,
AllowedAsRoot = false,
Description = NESTED_DOCUMENT_TYPE_DESCRIPTION,
Icon = NESTED_DOCUMENT_TYPE_ICON,
IsElement = true,
SortOrder = 0,
ParentId = contentTypeService.Get(NESTED_DOCUMENT_TYPE_PARENT_ALIAS).Id,
Variations = ContentVariation.Culture
};
docType.AddPropertyGroup(SLIDERS_TAB);
#region Nested Document Type Properties
PropertyType ImagePropType = new PropertyType(dataTypeService.GetDataType(-88), "sliderItemImage")
{
Name = "Image",
Description = "Image used in the Slider",
Variations = ContentVariation.Nothing
};
docType.AddPropertyType(ImagePropType, SLIDERS_TAB);
PropertyType ButtonLabelPropType = new PropertyType(dataTypeService.GetDataType(-88), "sliderItemButtonLabel")
{
Name = " Button Label",
Description = "Label for the Button",
Variations = ContentVariation.Nothing
};
docType.AddPropertyType(ButtonLabelPropType, SLIDERS_TAB);
PropertyType TitlePropType = new PropertyType(dataTypeService.GetDataType(-88), "sliderItemTitle")
{
Name = "Title",
Description = "Title for the banner item",
Variations = ContentVariation.Nothing
};
docType.AddPropertyType(TitlePropType, SLIDERS_TAB);
PropertyType SubtitlePropType = new PropertyType(dataTypeService.GetDataType(-88), "sliderItemSubtitle")
{
Name = "Subtitle",
Description = "Subtitle for the banner item",
Variations = ContentVariation.Nothing
};
docType.AddPropertyType(SubtitlePropType, SLIDERS_TAB);
PropertyType UrlPropType = new PropertyType(dataTypeService.GetDataType(-88), "sliderItemUrl")
{
Name = "Url",
Description = "The Link to the item",
Variations = ContentVariation.Nothing
};
docType.AddPropertyType(UrlPropType, SLIDERS_TAB);
#endregion
contentTypeService.Save(docType);
ConnectorContext.AuditService.Add(AuditType.New, -1, docType.Id, "Document Type", $"Document Type '{NESTED_DOCUMENT_TYPE_ALIAS}' has been created");
}
else
{
if (contentType.PropertyTypeExists("sliderItemImage") && contentType.PropertyTypes.Single(x => x.Alias == "sliderItemImage").DataTypeId == -88)
{
var mediaPickerContainer = dataTypeService.GetContainers(DATA_TYPE_CONTAINER, 1).FirstOrDefault();
var mediaPickerContainerId = -1;
if (mediaPickerContainer != null)
{
mediaPickerContainerId = mediaPickerContainer.Id;
}
var dataTypeExists = dataTypeService.GetDataType("sliderItemImageMediaPicker") != null;
if (!dataTypeExists)
{
var created = Web.Composing.Current.PropertyEditors.TryGet("Umbraco.MediaPicker", out IDataEditor editor);
if (created)
{
DataType mediaPickerSliderImage = new DataType(editor, mediaPickerContainerId)
{
Name = "sliderItemImageMediaPicker",
ParentId = mediaPickerContainerId,
Configuration = new MediaPickerConfiguration
{
DisableFolderSelect = true,
Multiple = false,
OnlyImages = true
}
};
dataTypeService.Save(mediaPickerSliderImage);
contentType.PropertyTypes.Single(x => x.Alias == "sliderItemImage").DataTypeId = mediaPickerSliderImage.Id;
contentTypeService.Save(contentType);
}
}
}
}
#endregion
#region Update Home Document Type
var homeDocumentType = contentTypeService.Get(DOCUMENT_TYPE_ALIAS);
var dataTypeContainer = dataTypeService.GetContainers(DATA_TYPE_CONTAINER, 1).FirstOrDefault();
var dataTypeContainerId = -1;
if (dataTypeContainer != null)
{
dataTypeContainerId = dataTypeContainer.Id;
}
var exists = dataTypeService.GetDataType(propertyName) != null;
if (!exists)
{
var created = Web.Composing.Current.PropertyEditors.TryGet("Umbraco.NestedContent", out IDataEditor editor);
if (!created)
{
DataType bannerSliderNestedDataType = new DataType(editor, dataTypeContainerId)
{
Name = propertyName,
ParentId = dataTypeContainerId,
Configuration = new NestedContentConfiguration
{
MinItems = 0,
MaxItems = 999,
ConfirmDeletes = true,
HideLabel = false,
ShowIcons = true,
ContentTypes = new[]
{
new NestedContentConfiguration.ContentType {
Alias = NESTED_DOCUMENT_TYPE_ALIAS, TabAlias = SLIDERS_TAB
}
}
}
};
dataTypeService.Save(bannerSliderNestedDataType);
}
}
if (!homeDocumentType.PropertyTypeExists("bannerSlider"))
{
var bannerSliderNestedDataType = dataTypeService.GetDataType(propertyName);
PropertyType BannerSlider = new PropertyType(bannerSliderNestedDataType, propertyAlias)
{
Name = propertyName,
Description = propertyDescription,
Variations = ContentVariation.Culture
};
var propertyGroup = homeDocumentType.PropertyGroups.SingleOrDefault(x => x.Name == SLIDERS_TAB);
if (propertyGroup == null)
{
homeDocumentType.AddPropertyGroup(SLIDERS_TAB);
}
homeDocumentType.AddPropertyType(BannerSlider, SLIDERS_TAB);
contentTypeService.Save(homeDocumentType);
ConnectorContext.AuditService.Add(AuditType.Save, -1, homeDocumentType.Id, "Document Type", $"Document Type '{DOCUMENT_TYPE_ALIAS}' has been updated");
}
#endregion
}
catch (System.Exception ex)
{
logger.Error(typeof(_17_HomeDocumentTypeSlider), ex.Message);
logger.Error(typeof(_17_HomeDocumentTypeSlider), ex.StackTrace);
}
}
private void Reconfigure()
{
try
{
var oldControlAlias = "links";
var contentType = contentTypeService.Get(DOCUMENT_TYPE_ALIAS);
if (contentType == null)
{
return;
}
if (!contentType.PropertyTypeExists(oldControlAlias))
{
return;
}
var MNTPpropertyName = "Total Code MNTP Menu - Single Site";
var NestedContentPropertyName = "Nested Content Footer Link Group";
var dataTypeContainer = dataTypeService.GetContainers(DATA_TYPE_CONTAINER, 1).FirstOrDefault();
var dataTypeContainerId = -1;
if (dataTypeContainer != null)
{
dataTypeContainerId = dataTypeContainer.Id;
}
var exists = dataTypeService.GetDataType(MNTPpropertyName) != null;
if (!exists)
{
var created = Web.Composing.Current.PropertyEditors.TryGet("Umbraco.MultiNodeTreePicker", out IDataEditor editor);
if (editor != null)
{
DataType MNTPMenu_SingleSite = new DataType(editor, dataTypeContainerId)
{
Name = MNTPpropertyName,
ParentId = dataTypeContainerId,
Configuration = new MultiNodePickerConfiguration()
{
MaxNumber = 1,
MinNumber = 1,
ShowOpen = false,
TreeSource = new MultiNodePickerConfigurationTreeSource()
{
StartNodeQuery = "$site",
ObjectType = "content"
},
}
};
dataTypeService.Save(MNTPMenu_SingleSite);
}
}
var container = contentTypeService.GetContainers(DOCUMENT_TYPE_CONTAINER, 1).FirstOrDefault();
int containerId = -1;
if (container != null)
{
containerId = container.Id;
}
contentType = contentTypeService.Get(NESTED_FOOTERLINKSSETTING_DOCUMENT_TYPE_ALIAS);
if (contentType == null)
{
ContentType docType = (ContentType)contentType ?? new ContentType(containerId)
{
Name = NESTED_FOOTERLINKSSETTING_DOCUMENT_TYPE_NAME,
Alias = NESTED_FOOTERLINKSSETTING_DOCUMENT_TYPE_ALIAS,
AllowedAsRoot = false,
Description = "",
Icon = NESTED_DOCUMENT_TYPE_ICON,
IsElement = true,
SortOrder = 0,
ParentId = 1087,
Variations = ContentVariation.Culture
};
docType.AddPropertyGroup(NESTED_TAB_NAME);
#region Nested Document Type Properties
var FooterContent_MNTPpropertyName = dataTypeService.GetDataType(MNTPpropertyName);
PropertyType internalLinkPropType = new PropertyType(FooterContent_MNTPpropertyName, "internalLink")
{
Name = "Internal Link",
Description = "",
Variations = ContentVariation.Culture
};
docType.AddPropertyType(internalLinkPropType, NESTED_TAB_NAME);
PropertyType ExternalLinkTextPropType = new PropertyType(dataTypeService.GetDataType(-88), "externalLinkText")
{
Name = "External Link Text",
Description = "",
Variations = ContentVariation.Culture,
};
docType.AddPropertyType(ExternalLinkTextPropType, NESTED_TAB_NAME);
PropertyType LinkUrlPropType = new PropertyType(dataTypeService.GetDataType(-88), "externalLinkUrl")
{
Name = "External Link URL",
Description = "",
Variations = ContentVariation.Culture,
ValidationRegExp = "https?://[a-zA-Z0-9-.]+.[a-zA-Z]{2,}"
};
docType.AddPropertyType(LinkUrlPropType, NESTED_TAB_NAME);
#endregion
contentTypeService.Save(docType);
ConnectorContext.AuditService.Add(AuditType.New, -1, docType.Id, "Document Type", $"Document Type '{NESTED_FOOTERLINKSSETTING_DOCUMENT_TYPE_ALIAS}' has been created");
}
exists = dataTypeService.GetDataType(NestedContentPropertyName) != null;
if (!exists)
{
var created = Web.Composing.Current.PropertyEditors.TryGet("Umbraco.NestedContent", out IDataEditor editor);
if (editor != null)
{
DataType bannerSliderNestedDataType = new DataType(editor, dataTypeContainerId)
{
Name = NestedContentPropertyName,
ParentId = dataTypeContainerId,
Configuration = new NestedContentConfiguration
{
MinItems = 0,
MaxItems = 999,
ConfirmDeletes = true,
HideLabel = false,
ShowIcons = true,
ContentTypes = new[]
{
new NestedContentConfiguration.ContentType {
Alias = NESTED_FOOTERLINKSSETTING_DOCUMENT_TYPE_ALIAS, TabAlias = NESTED_TAB_NAME
}
}
}
};
dataTypeService.Save(bannerSliderNestedDataType);
}
}
contentType = contentTypeService.Get(DOCUMENT_TYPE_ALIAS);
contentType.RemovePropertyType(oldControlAlias);
var FooterContent_NestedContentPropertyName = dataTypeService.GetDataType(NestedContentPropertyName);
PropertyType linksPropType = new PropertyType(FooterContent_NestedContentPropertyName, "footerLinks")
{
Name = "Links",
Description = "",
Variations = ContentVariation.Culture
};
contentType.AddPropertyType(linksPropType, NESTED_TAB_NAME);
contentTypeService.Save(contentType);
ConnectorContext.AuditService.Add(AuditType.New, -1, contentType.Id, "Document Type", $"Document Type '{DOCUMENT_TYPE_ALIAS}' has been created");
}
catch (Exception ex)
{
logger.Error(typeof(_35_FooterLinkGroupChangesDocumentType), ex.Message);
logger.Error(typeof(_35_FooterLinkGroupChangesDocumentType), ex.StackTrace);
}
}
private void Reconfigure()
{
const string
propertyAlias = "gameSlider",
propertyName = "Game Slider",
propertyDescription = "Slider with game banners";
try
{
var casinoDocType = contentTypeService.Get(DOCUMENT_TYPE_ALIAS);
// Create the Template if it doesn't exist
if (fileService.GetTemplate(TEMPLATE_ALIAS) == null)
{
//then create the template
Template newTemplate = new Template(TEMPLATE_NAME, TEMPLATE_ALIAS);
ITemplate masterTemplate = fileService.GetTemplate(PARENT_TEMPLATE_ALIAS);
newTemplate.SetMasterTemplate(masterTemplate);
fileService.SaveTemplate(newTemplate);
// Set template for document type
casinoDocType.AddTemplate(contentTypeService, newTemplate);
ContentHelper.CopyPhysicalAssets(new ReconfigureCasinoPageEmbeddedResources());
ConnectorContext.AuditService.Add(AuditType.Save, -1, newTemplate.Id, "Template", $"Teplate '{TEMPLATE_NAME}' has been created and assigned");
}
var dataTypeContainer = dataTypeService.GetContainers(DATA_TYPE_CONTAINER, 1).FirstOrDefault();
var dataTypeContainerId = -1;
if (dataTypeContainer != null)
{
dataTypeContainerId = dataTypeContainer.Id;
}
var exists = dataTypeService.GetDataType(propertyName) != null;
if (!exists)
{
var created = Web.Composing.Current.PropertyEditors.TryGet("Umbraco.NestedContent", out IDataEditor editor);
if (created)
{
DataType bannerSliderNestedDataType = new DataType(editor, dataTypeContainerId)
{
Name = propertyName,
ParentId = dataTypeContainerId,
Configuration = new NestedContentConfiguration
{
MinItems = 0,
MaxItems = 999,
ConfirmDeletes = true,
HideLabel = false,
ShowIcons = true,
ContentTypes = new[]
{
new NestedContentConfiguration.ContentType {
Alias = NESTED_DOCUMENT_TYPE_ALIAS, TabAlias = SLIDERS_TAB
}
}
}
};
dataTypeService.Save(bannerSliderNestedDataType);
ConnectorContext.AuditService.Add(AuditType.Save, -1, casinoDocType.Id, "Document Type", $"Document Type '{DOCUMENT_TYPE_ALIAS}' has been updated");
}
}
if (!casinoDocType.PropertyTypeExists(propertyAlias))
{
var bannerSliderNestedDataType = dataTypeService.GetDataType(propertyName);
PropertyType BannerSlider = new PropertyType(bannerSliderNestedDataType, propertyAlias)
{
Name = propertyName,
Description = propertyDescription,
Variations = ContentVariation.Culture
};
casinoDocType.AddPropertyGroup(SLIDERS_TAB);
casinoDocType.AddPropertyType(BannerSlider, SLIDERS_TAB);
contentTypeService.Save(casinoDocType);
}
}
catch (Exception ex)
{
logger.Error(typeof(_10_CasinoPageIntegration), ex.Message);
logger.Error(typeof(_10_CasinoPageIntegration), ex.StackTrace);
}
}
private void CreateDocumentType()
{
try
{
var richTextContainer = dataTypeService.GetContainers(DATA_TYPE_CONTAINER, 1).FirstOrDefault();
var richTextContainerId = -1;
if (richTextContainer != null)
{
richTextContainerId = richTextContainer.Id;
}
var dataTypeExists = dataTypeService.GetDataType("Full Rich Text Editor") != null;
if (!dataTypeExists)
{
var created = Web.Composing.Current.PropertyEditors.TryGet("Umbraco.TinyMCE", out IDataEditor editor);
if (created)
{
DataType richTextEditor = new DataType(editor, richTextContainerId)
{
Name = "Full Rich Text Editor",
ParentId = richTextContainerId,
Configuration = new RichTextConfiguration
{
Editor = JObject.Parse("{\"toolbar\":[\"ace\",\"removeformat\",\"undo\",\"redo\",\"cut\",\"copy\",\"paste\",\"styleselect\",\"bold\",\"italic\",\"underline\",\"strikethrough\",\"alignleft\",\"aligncenter\",\"alignright\",\"alignjustify\",\"bullist\",\"numlist\",\"outdent\",\"indent\",\"link\",\"unlink\",\"anchor\",\"umbmediapicker\",\"umbmacro\",\"table\",\"umbembeddialog\",\"hr\",\"subscript\",\"superscript\",\"charmap\",\"rtl\",\"ltr\"],\"stylesheets\":[],\"maxImageSize\":500,\"mode\":\"classic\"}"),
HideLabel = true
}
};
dataTypeService.Save(richTextEditor);
var container = contentTypeService.GetContainers(CONTAINER, 1).FirstOrDefault();
var containerId = container.Id;
string propertyName = "Page Content",
propertyDescription = "Text to be displayed on the Page";
// categories page
var contentCategoriesType = contentTypeService.Get(CATEGORIES_DOCUMENT_TYPE_ALIAS);
if (contentCategoriesType != null)
{
PropertyType richTextPropType = new PropertyType(dataTypeService.GetDataType(richTextEditor.Id), "pageContent")
{
Name = propertyName,
Description = propertyDescription,
Variations = ContentVariation.Culture
};
contentCategoriesType.AddPropertyType(richTextPropType, TAB);
contentTypeService.Save(contentCategoriesType);
ConnectorContext.AuditService.Add(AuditType.Save, -1, contentCategoriesType.Id, "Document Type", $"Document Type '{CATEGORIES_DOCUMENT_TYPE_ALIAS}' has been updated");
}
// category page
var contentCategoryType = contentTypeService.Get(CATEGORY_DOCUMENT_TYPE_ALIAS);
if (contentCategoryType != null)
{
PropertyType richTextPropType = new PropertyType(dataTypeService.GetDataType(richTextEditor.Id), "pageContent")
{
Name = propertyName,
Description = propertyDescription,
Variations = ContentVariation.Culture
};
contentCategoryType.AddPropertyType(richTextPropType, TAB);
contentTypeService.Save(contentCategoryType);
ConnectorContext.AuditService.Add(AuditType.Save, -1, contentCategoryType.Id, "Document Type", $"Document Type '{CATEGORY_DOCUMENT_TYPE_ALIAS}' has been updated");
}
}
}
}
catch (Exception ex)
{
logger.Error(typeof(_20_ContentPagesReconfiguration), ex.Message);
logger.Error(typeof(_20_ContentPagesReconfiguration), ex.StackTrace);
}
}
private void UpdateHomeDocumentType()
{
try
{
var contentType = contentTypeService.Get(DOCUMENT_TYPE_ALIAS);
var container = contentTypeService.GetContainers(CONTAINER, 1).FirstOrDefault();
if (contentType != null)
{
if (contentType.PropertyTypes.ToList().SingleOrDefault(x => x.Alias == "termsAndConditionsMessage") == null)
{
// Add Document Type Properties
#region Tenant Home Page Content
PropertyType termsAndConditionsMessagePropType = new PropertyType(dataTypeService.GetDataType(-88), "termsAndConditionsMessage")
{
Name = "Terms and Conditions",
Description = "Message to display for required accepting Terms and Conditions",
Variations = ContentVariation.Culture
};
contentType.AddPropertyType(termsAndConditionsMessagePropType, CONTENT_TAB);
#endregion
contentTypeService.Save(contentType);
ConnectorContext.AuditService.Add(AuditType.New, -1, contentType.Id, "Document Type", $"Document Type '{DOCUMENT_TYPE_ALIAS}' has been updated");
ContentHelper.CopyPhysicalAssets(new RegisterUpdateHomeEmbeddedResources());
//CreateMasterTemplate();
}
var telegramUsername = contentType.PropertyTypes.ToList().SingleOrDefault(x => x.Alias == "telegramUsername");
if (telegramUsername != null)
{
if (telegramUsername.Name != "Telegram URL")
{
telegramUsername.Name = "Telegram URL";
telegramUsername.Description = "";
telegramUsername.ValidationRegExp = "";
contentType.AddPropertyType(telegramUsername);
contentTypeService.Save(contentType);
}
else if (!string.IsNullOrEmpty(telegramUsername.ValidationRegExp))
{
telegramUsername.ValidationRegExp = "";
contentType.AddPropertyType(telegramUsername);
contentTypeService.Save(contentType);
}
}
var helpdeskTelegramAccount = contentType.PropertyTypes.ToList().SingleOrDefault(x => x.Alias == "helpdeskTelegramAccount");
if (helpdeskTelegramAccount != null)
{
if (helpdeskTelegramAccount.Name != "HelpDesk Telegram Bot")
{
helpdeskTelegramAccount.Name = "HelpDesk Telegram Bot";
helpdeskTelegramAccount.Description = "";
helpdeskTelegramAccount.ValidationRegExp = "";
contentType.AddPropertyType(helpdeskTelegramAccount);
contentTypeService.Save(contentType);
}
else if (!string.IsNullOrEmpty(helpdeskTelegramAccount.ValidationRegExp))
{
helpdeskTelegramAccount.ValidationRegExp = "";
contentType.AddPropertyType(helpdeskTelegramAccount);
contentTypeService.Save(contentType);
}
}
var whatsAppNumber = contentType.PropertyTypes.ToList().SingleOrDefault(x => x.Alias == "whatsAppNumber");
if (whatsAppNumber != null)
{
if (whatsAppNumber.Name != "Whatsapp URL")
{
whatsAppNumber.Name = "Whatsapp URL";
whatsAppNumber.Description = "";
whatsAppNumber.ValidationRegExp = "";
contentType.AddPropertyType(whatsAppNumber);
contentTypeService.Save(contentType);
}
else if (!string.IsNullOrEmpty(whatsAppNumber.ValidationRegExp))
{
whatsAppNumber.ValidationRegExp = "";
contentType.AddPropertyType(whatsAppNumber);
contentTypeService.Save(contentType);
}
}
//var
//var
}
if (createDictionaryItems)
{
var language = new LanguageDictionaryService(ConnectorContext.LocalizationService, ConnectorContext.DomainService, ConnectorContext.Logger);
// Check if parent Key exists, and skip if true
if (!language.CheckExists(typeof(Home_ParentKey)))
{
// Add Dictionary Items
var dictionaryItems = new List <Type>
{
typeof(Home_ParentKey),
typeof(Home_Register),
typeof(Site_ParentKey),
typeof(Site_AlreadyHaveAccount),
typeof(Register_ParentKey),
typeof(Register_RegisterTitle),
typeof(Register_RegisterStep),
typeof(Register_RegisterOf),
typeof(Register_PhoneNumber),
typeof(Register_PhoneNumberPlaceholder),
typeof(Register_IsMandatory),
typeof(Register_Continue),
typeof(Register_PhoneNumberInstructions),
typeof(Register_VerificationCode),
typeof(Register_VerificationCodePlaceholder),
typeof(Register_EnterCode),
typeof(Register_Enter6DigitVerificationCode),
typeof(Register_EnterVerificationCode),
typeof(Register_ResendCode),
typeof(Register_Wait),
typeof(Register_VerificationCodeInvalidOrExpired),
typeof(Register_Email),
typeof(Register_EmailPlaceholder),
typeof(Register_Password),
typeof(Register_PasswordPlaceholder),
typeof(Register_ConfirmPassword),
typeof(Register_FirstName),
typeof(Register_FirstNamePlaceholder),
typeof(Register_LastName),
typeof(Register_LastNamePlaceholder),
typeof(Register_Username),
typeof(Register_UsernamePlaceholder),
typeof(Register_Gender),
typeof(Register_DateOfBirth),
typeof(Register_DateOfBirthDay),
typeof(Register_DateOfBirthMonth),
typeof(Register_DateOfBirthMonthJanuary),
typeof(Register_DateOfBirthMonthFebruary),
typeof(Register_DateOfBirthMonthMarch),
typeof(Register_DateOfBirthMonthApril),
typeof(Register_DateOfBirthMonthMay),
typeof(Register_DateOfBirthMonthJune),
typeof(Register_DateOfBirthMonthJuly),
typeof(Register_DateOfBirthMonthAugust),
typeof(Register_DateOfBirthMonthSeptember),
typeof(Register_DateOfBirthMonthOctober),
typeof(Register_DateOfBirthMonthNovember),
typeof(Register_DateOfBirthMonthDecember),
typeof(Register_DateOfBirthYear),
typeof(Register_IAgreeWithThe),
typeof(Register_TermsAndConditions),
typeof(Register_Finish),
typeof(Register_IncorrectOrInvalid),
typeof(Register_VerifyEmailSentToTitle),
typeof(Register_VerifyEmailSentTo),
typeof(Register_VerifyEmailSentToPleaseClick),
typeof(Register_ResendVerificationEmail),
typeof(Register_ResendVerificationEmailSent),
typeof(Register_ChangeEmail),
typeof(Register_IsInvalid),
typeof(Register_Title),
typeof(Register_Address1),
typeof(Register_Address1Placeholder),
typeof(Register_Address2),
typeof(Register_Address2Placeholder),
typeof(Register_Address3),
typeof(Register_Address3Placeholder),
typeof(Register_CityOrTown),
typeof(Register_CityOrTownPlaceholder),
typeof(Register_PostalCode),
typeof(Register_PostalCodePlaceholder),
typeof(Register_Country),
typeof(Register_Preferences),
typeof(Register_Language),
typeof(Register_Currency),
typeof(Register_OddsDisplay),
typeof(Register_TimeZone),
typeof(Register_BonusCode),
typeof(Register_BonusCodePlaceholder),
typeof(Register_Referrer),
typeof(Register_ReferrerPlaceholder),
typeof(Register_ReceiveNotifications),
typeof(Register_ReceiveNotificationsViaInPlatformMessages),
typeof(Register_ReceiveNotificationsViaEmail),
typeof(Register_ReceiveNotificationsViaSMS),
typeof(Register_CookiesPolicy),
typeof(Register_PrivacyPolicy),
typeof(Register_MinimunAge),
typeof(Register_Age),
typeof(Register_AgeYearsOld),
typeof(Register_NewEmail),
typeof(Register_CurrentEmail)
};
language.CreateDictionaryItems(dictionaryItems); // Create Dictionary Items
ConnectorContext.AuditService.Add(AuditType.Save, -1, contentType.Id, "Document Type", $"Document Type '{DOCUMENT_TYPE_ALIAS}' has been updated, and Dictionaries Created");
}
}
var oldHome = contentTypeService.Get(HomeDocumentType.DOCUMENT_TYPE_ALIAS);
if (oldHome != null)
{
// remove old home document type
contentTypeService.Delete(contentTypeService.Get(HomeDocumentType.DOCUMENT_TYPE_ALIAS));
// remove old home template
fileService.DeleteTemplate(HomeDocumentType.TEMPLATE_ALIAS);
}
}
catch (Exception ex)
{
logger.Error(typeof(_02_HomeDocumentTypePhase2Milestone6), ex.Message);
logger.Error(typeof(_02_HomeDocumentTypePhase2Milestone6), ex.StackTrace);
}
}
public IEnumerable <ValidationResult> Validate(object rawValue, string valueType, object dataTypeConfiguration)
{
var validationResults = new List <ValidationResult>();
foreach (var row in _nestedContentValues.GetPropertyValues(rawValue, out _))
{
if (row.PropType == null)
{
continue;
}
var config = _dataTypeService.GetDataType(row.PropType.DataTypeId).Configuration;
var propertyEditor = _propertyEditors[row.PropType.PropertyEditorAlias];
if (propertyEditor == null)
{
continue;
}
foreach (var validator in propertyEditor.GetValueEditor().Validators)
{
foreach (var result in validator.Validate(row.JsonRowValue[row.PropKey], propertyEditor.GetValueEditor().ValueType, config))
{
result.ErrorMessage = "Item " + (row.RowIndex + 1) + " '" + row.PropType.Name + "' " + result.ErrorMessage;
validationResults.Add(result);
}
}
// Check mandatory
if (row.PropType.Mandatory)
{
if (row.JsonRowValue[row.PropKey] == null)
{
var message = string.IsNullOrWhiteSpace(row.PropType.MandatoryMessage)
? $"'{row.PropType.Name}' cannot be null"
: row.PropType.MandatoryMessage;
validationResults.Add(new ValidationResult($"Item {(row.RowIndex + 1)}: {message}", new[] { row.PropKey }));
}
else if (row.JsonRowValue[row.PropKey].ToString().IsNullOrWhiteSpace() || (row.JsonRowValue[row.PropKey].Type == JTokenType.Array && !row.JsonRowValue[row.PropKey].HasValues))
{
var message = string.IsNullOrWhiteSpace(row.PropType.MandatoryMessage)
? $"'{row.PropType.Name}' cannot be empty"
: row.PropType.MandatoryMessage;
validationResults.Add(new ValidationResult($"Item {(row.RowIndex + 1)}: {message}", new[] { row.PropKey }));
}
}
// Check regex
if (!row.PropType.ValidationRegExp.IsNullOrWhiteSpace() &&
row.JsonRowValue[row.PropKey] != null && !row.JsonRowValue[row.PropKey].ToString().IsNullOrWhiteSpace())
{
var regex = new Regex(row.PropType.ValidationRegExp);
if (!regex.IsMatch(row.JsonRowValue[row.PropKey].ToString()))
{
var message = string.IsNullOrWhiteSpace(row.PropType.ValidationRegExpMessage)
? $"'{row.PropType.Name}' is invalid, it does not match the correct pattern"
: row.PropType.ValidationRegExpMessage;
validationResults.Add(new ValidationResult($"Item {(row.RowIndex + 1)}: {message}", new[] { row.PropKey }));
}
}
}
return(validationResults);
}
private void CreateHomeDocumentType()
{
try
{
var container = contentTypeService.GetContainers(CONTAINER, 1).FirstOrDefault();
int containerId = 0;
if (container == null)
{
var newcontainer = contentTypeService.CreateContainer(-1, CONTAINER);
if (newcontainer.Success)
{
containerId = newcontainer.Result.Entity.Id;
}
}
else
{
containerId = container.Id;
}
var contentType = contentTypeService.Get(DOCUMENT_TYPE_ALIAS);
if (contentType == null)
{
//http://refreshwebsites.co.uk/blog/umbraco-document-types-explained-in-60-seconds/
//https://our.umbraco.org/forum/developers/api-questions/43278-programmatically-creating-a-document-type
ContentType docType = (ContentType)contentType ?? new ContentType(containerId)
{
Name = DOCUMENT_TYPE_NAME,
Alias = DOCUMENT_TYPE_ALIAS,
AllowedAsRoot = true,
Description = DOCUMENT_TYPE_DESCRIPTION,
Icon = ICON,
SortOrder = 0,
Variations = ContentVariation.Culture
};
// Create the Template if it doesn't exist
if (fileService.GetTemplate(TEMPLATE_ALIAS) == null)
{
//then create the template
Template newTemplate = new Template(TEMPLATE_NAME, TEMPLATE_ALIAS);
fileService.SaveTemplate(newTemplate);
}
// Set templates for document type
var template = fileService.GetTemplate(TEMPLATE_ALIAS);
docType.AllowedTemplates = new List <ITemplate> {
template
};
docType.SetDefaultTemplate(template);
docType.AddPropertyGroup(CONTENT_TAB);
docType.AddPropertyGroup(TENANT_TAB);
// Set Document Type Properties
#region Tenant Home Page Content
PropertyType brandLogoPropType = new PropertyType(dataTypeService.GetDataType(1043), "brandLogo")
{
Name = "Brand Logo",
Variations = ContentVariation.Nothing
};
docType.AddPropertyType(brandLogoPropType, CONTENT_TAB);
PropertyType homeContentProType = new PropertyType(dataTypeService.GetDataType(-87), "homeContent")
{
Name = "Content",
Variations = ContentVariation.Culture
};
docType.AddPropertyType(homeContentProType, CONTENT_TAB);
#endregion
#region Tenant Info Tab
PropertyType tenantUidPropType = new PropertyType(dataTypeService.GetDataType(-92), "tenantUid")
{
Name = "Tenant Uid",
Description = "Tenant Unique Id",
Variations = ContentVariation.Nothing
};
docType.AddPropertyType(tenantUidPropType, TENANT_TAB);
PropertyType brandNamePropType = new PropertyType(dataTypeService.GetDataType(-92), "brandName")
{
Name = "Brand Name",
Variations = ContentVariation.Nothing
};
docType.AddPropertyType(brandNamePropType, TENANT_TAB);
PropertyType domainPropType = new PropertyType(dataTypeService.GetDataType(-92), "domain")
{
Name = "Domain",
Variations = ContentVariation.Nothing
};
docType.AddPropertyType(domainPropType, TENANT_TAB);
PropertyType subDomainPropType = new PropertyType(dataTypeService.GetDataType(-92), "subDomain")
{
Name = "Sub Domain",
Variations = ContentVariation.Nothing
};
docType.AddPropertyType(subDomainPropType, TENANT_TAB);
PropertyType appIdPropType = new PropertyType(dataTypeService.GetDataType(-92), "appId")
{
Name = "App Id",
Variations = ContentVariation.Nothing
};
docType.AddPropertyType(appIdPropType, TENANT_TAB);
PropertyType apiKeyPropType = new PropertyType(dataTypeService.GetDataType(-92), "apiKey")
{
Name = "Api Key",
Variations = ContentVariation.Nothing
};
docType.AddPropertyType(apiKeyPropType, TENANT_TAB);
PropertyType defaultLanguagePropType = new PropertyType(dataTypeService.GetDataType(-92), "defaultLanguage")
{
Name = "Default Language",
Description = "System Default Language",
Variations = ContentVariation.Nothing
};
docType.AddPropertyType(defaultLanguagePropType, TENANT_TAB);
PropertyType languagestPropType = new PropertyType(dataTypeService.GetDataType(-92), "languages")
{
Name = "Alternate Languages",
Variations = ContentVariation.Nothing
};
docType.AddPropertyType(languagestPropType, TENANT_TAB);
PropertyType tenantStatusPropType = new PropertyType(dataTypeService.GetDataType(-92), "tenantStatus")
{
Name = "Tenant Status",
Description = "Total Code Tenant Status",
Variations = ContentVariation.Nothing
};
docType.AddPropertyType(tenantStatusPropType, TENANT_TAB);
#endregion
contentTypeService.Save(docType);
ConnectorContext.AuditService.Add(AuditType.New, -1, docType.Id, "Document Type", $"Document Type '{DOCUMENT_TYPE_NAME}' has been created");
ContentHelper.CopyPhysicalAssets(new EmbeddedResources());
}
}
catch (System.Exception ex)
{
logger.Error(typeof(HomeDocumentType), ex.Message);
logger.Error(typeof(HomeDocumentType), ex.StackTrace);
}
}
private IDataValueEditor GetPropertyValueEditor(int dataTypeId, out object wrappedConfiguration)
{
var dataType = _dataTypeService.GetDataType(dataTypeId);
return(GetPropertyValueEditor(dataType?.ConfigurationAs <TextCountConfiguration>(), out wrappedConfiguration));
}
public static ContentApp CreateContentApp(IDataTypeService dataTypeService,
PropertyEditorCollection propertyEditors,
string entityType, string contentTypeAlias,
int defaultListViewDataType)
{
if (dataTypeService == null)
{
throw new ArgumentNullException(nameof(dataTypeService));
}
if (propertyEditors == null)
{
throw new ArgumentNullException(nameof(propertyEditors));
}
if (string.IsNullOrWhiteSpace(entityType))
{
throw new ArgumentException("message", nameof(entityType));
}
if (string.IsNullOrWhiteSpace(contentTypeAlias))
{
throw new ArgumentException("message", nameof(contentTypeAlias));
}
if (defaultListViewDataType == default)
{
throw new ArgumentException("defaultListViewDataType", nameof(defaultListViewDataType));
}
var contentApp = new ContentApp
{
Alias = "umbListView",
Name = "Child items",
Icon = "icon-list",
View = "views/content/apps/listview/listview.html",
Weight = Weight
};
var customDtdName = Constants.Conventions.DataTypes.ListViewPrefix + contentTypeAlias;
//first try to get the custom one if there is one
var dt = dataTypeService.GetDataType(customDtdName)
?? dataTypeService.GetDataType(defaultListViewDataType);
if (dt == null)
{
throw new InvalidOperationException("No list view data type was found for this document type, ensure that the default list view data types exists and/or that your custom list view data type exists");
}
var editor = propertyEditors[dt.EditorAlias];
if (editor == null)
{
throw new NullReferenceException("The property editor with alias " + dt.EditorAlias + " does not exist");
}
var listViewConfig = editor.GetConfigurationEditor().ToConfigurationEditor(dt.Configuration);
//add the entity type to the config
listViewConfig["entityType"] = entityType;
//Override Tab Label if tabName is provided
if (listViewConfig.ContainsKey("tabName"))
{
var configTabName = listViewConfig["tabName"];
if (configTabName != null && String.IsNullOrWhiteSpace(configTabName.ToString()) == false)
{
contentApp.Name = configTabName.ToString();
}
}
//Override Icon if icon is provided
if (listViewConfig.ContainsKey("icon"))
{
var configIcon = listViewConfig["icon"];
if (configIcon != null && String.IsNullOrWhiteSpace(configIcon.ToString()) == false)
{
contentApp.Icon = configIcon.ToString();
}
}
// if the list view is configured to show umbContent first, update the list view content app weight accordingly
if (listViewConfig.ContainsKey("showContentFirst") &&
listViewConfig["showContentFirst"]?.ToString().TryConvertTo <bool>().Result == true)
{
contentApp.Weight = ContentEditorContentAppFactory.Weight + 1;
}
//This is the view model used for the list view app
contentApp.ViewModel = new List <ContentPropertyDisplay>
{
new ContentPropertyDisplay
{
Alias = $"{Constants.PropertyEditors.InternalGenericPropertiesPrefix}containerView",
Label = "",
Value = null,
View = editor.GetValueEditor().View,
HideLabel = true,
Config = listViewConfig
}
};
return(contentApp);
}
public XElement Serialize(IDataTypeService dataTypeService, IContentTypeService contentTypeService, IContentType contentType)
{
var info = new XElement("Info",
new XElement("Name", contentType.Name),
new XElement("Alias", contentType.Alias),
new XElement("Icon", contentType.Icon),
new XElement("Thumbnail", contentType.Thumbnail),
new XElement("Description", contentType.Description),
new XElement("AllowAtRoot", contentType.AllowedAsRoot.ToString()),
new XElement("IsListView", contentType.IsContainer.ToString()),
new XElement("IsElement", contentType.IsElement.ToString()));
var masterContentType = contentType.ContentTypeComposition.FirstOrDefault(x => x.Id == contentType.ParentId);
if (masterContentType != null)
{
info.Add(new XElement("Master", masterContentType.Alias));
}
var compositionsElement = new XElement("Compositions");
var compositions = contentType.ContentTypeComposition;
foreach (var composition in compositions)
{
compositionsElement.Add(new XElement("Composition", composition.Alias));
}
info.Add(compositionsElement);
var allowedTemplates = new XElement("AllowedTemplates");
foreach (var template in contentType.AllowedTemplates)
{
allowedTemplates.Add(new XElement("Template", template.Alias));
}
info.Add(allowedTemplates);
if (contentType.DefaultTemplate != null && contentType.DefaultTemplate.Id != 0)
{
info.Add(new XElement("DefaultTemplate", contentType.DefaultTemplate.Alias));
}
else
{
info.Add(new XElement("DefaultTemplate", ""));
}
var structure = new XElement("Structure");
foreach (var allowedType in contentType.AllowedContentTypes)
{
structure.Add(new XElement("DocumentType", allowedType.Alias));
}
var genericProperties = new XElement("GenericProperties"); // actually, all of them
foreach (var propertyType in contentType.PropertyTypes)
{
var definition = dataTypeService.GetDataType(propertyType.DataTypeId);
var propertyGroup = propertyType.PropertyGroupId == null // true generic property
? null
: contentType.PropertyGroups.FirstOrDefault(x => x.Id == propertyType.PropertyGroupId.Value);
var genericProperty = new XElement("GenericProperty",
new XElement("Name", propertyType.Name),
new XElement("Alias", propertyType.Alias),
new XElement("Type", propertyType.PropertyEditorAlias),
new XElement("Definition", definition.Key),
new XElement("Tab", propertyGroup == null ? "" : propertyGroup.Name),
new XElement("SortOrder", propertyType.SortOrder),
new XElement("Mandatory", propertyType.Mandatory.ToString()),
propertyType.ValidationRegExp != null ? new XElement("Validation", propertyType.ValidationRegExp) : null,
propertyType.Description != null ? new XElement("Description", new XCData(propertyType.Description)) : null);
genericProperties.Add(genericProperty);
}
var tabs = new XElement("Tabs");
foreach (var propertyGroup in contentType.PropertyGroups)
{
var tab = new XElement("Tab",
new XElement("Id", propertyGroup.Id.ToString(CultureInfo.InvariantCulture)),
new XElement("Caption", propertyGroup.Name),
new XElement("SortOrder", propertyGroup.SortOrder));
tabs.Add(tab);
}
var xml = new XElement("DocumentType",
info,
structure,
genericProperties,
tabs);
var folderNames = string.Empty;
//don't add folders if this is a child doc type
if (contentType.Level != 1 && masterContentType == null)
{
//get url encoded folder names
var folders = contentTypeService.GetContainers(contentType)
.OrderBy(x => x.Level)
.Select(x => HttpUtility.UrlEncode(x.Name));
folderNames = string.Join("/", folders.ToArray());
}
if (string.IsNullOrWhiteSpace(folderNames) == false)
{
xml.Add(new XAttribute("Folders", folderNames));
}
return(xml);
}
private void UpdateHomeDocumentType()
{
const string faviconName = "Tenant Favicon";
const string faviconDescription = "Favicon (Browser Tab icon)";
const string faviconAlias = "tenantFavicon";
const string size16x16 = "16x16", size32x32 = "32x32", size72x72 = "72x72", size144x144 = "144x144", size192x192 = "192x192", size256x256 = "256x256";
try
{
var contentType = contentTypeService.Get(DOCUMENT_TYPE_ALIAS);
if (contentType != null)
{
var changed = false;
#region Tenant Favicons
if (!contentType.PropertyTypeExists($"{faviconAlias}{size16x16}"))
{
PropertyType tenantFavicon16x16PropType = new PropertyType(dataTypeService.GetDataType(-90), $"{faviconAlias}{size16x16}")
{
Name = $"{faviconName} {size16x16}",
Description = $"{faviconDescription} size {size16x16} (*.ico)",
Variations = ContentVariation.Nothing
};
contentType.AddPropertyType(tenantFavicon16x16PropType, TENANT_TAB);
changed = true;
}
if (!contentType.PropertyTypeExists($"{faviconAlias}{size32x32}"))
{
PropertyType tenantFavicon32x32PropType = new PropertyType(dataTypeService.GetDataType(-90), $"{faviconAlias}{size32x32}")
{
Name = $"{faviconName} {size32x32}",
Description = $"{faviconDescription} size {size32x32} (*.png)",
Variations = ContentVariation.Nothing
};
contentType.AddPropertyType(tenantFavicon32x32PropType, TENANT_TAB);
changed = true;
}
if (!contentType.PropertyTypeExists($"{faviconAlias}{size72x72}"))
{
PropertyType tenantFavicon72x72PropType = new PropertyType(dataTypeService.GetDataType(-90), $"{faviconAlias}{size72x72}")
{
Name = $"{faviconName} {size72x72}",
Description = $"{faviconDescription} size {size72x72} (*.png)",
Variations = ContentVariation.Nothing
};
contentType.AddPropertyType(tenantFavicon72x72PropType, TENANT_TAB);
changed = true;
}
if (!contentType.PropertyTypeExists($"{faviconAlias}{size144x144}"))
{
PropertyType tenantFavicon144x144PropType = new PropertyType(dataTypeService.GetDataType(-90), $"{faviconAlias}{size144x144}")
{
Name = $"{faviconName} {size144x144}",
Description = $"{faviconDescription} size {size144x144} (*.png)",
Variations = ContentVariation.Nothing
};
contentType.AddPropertyType(tenantFavicon144x144PropType, TENANT_TAB);
changed = true;
}
if (!contentType.PropertyTypeExists($"{faviconAlias}{size192x192}"))
{
PropertyType tenantFavicon192x192PropType = new PropertyType(dataTypeService.GetDataType(-90), $"{faviconAlias}{size192x192}")
{
Name = $"{faviconName} {size192x192}",
Description = $"{faviconDescription} size {size192x192} (*.png)",
Variations = ContentVariation.Nothing
};
contentType.AddPropertyType(tenantFavicon192x192PropType, TENANT_TAB);
changed = true;
}
if (!contentType.PropertyTypeExists($"{faviconAlias}{size256x256}"))
{
PropertyType tenantFavicon256x256PropType = new PropertyType(dataTypeService.GetDataType(-90), $"{faviconAlias}{size256x256}")
{
Name = $"{faviconName} {size256x256}",
Description = $"{faviconDescription} size {size256x256} (*.png)",
Variations = ContentVariation.Nothing
};
contentType.AddPropertyType(tenantFavicon256x256PropType, TENANT_TAB);
changed = true;
}
if (changed)
{
contentTypeService.Save(contentType);
}
#endregion
}
}
catch (System.Exception ex)
{
logger.Error(typeof(_29_TenantFavicon), ex.Message);
logger.Error(typeof(_29_TenantFavicon), ex.StackTrace);
}
}
private static void ContentService_Saved(IContentService contentService, ContentSavedEventArgs e)
{
foreach (IContent content in e.SavedEntities)
{
List <string> editors = new List <string>
{
Umbraco.Core.Constants.PropertyEditors.Aliases.Grid,
BentoItemDataEditor.EditorAlias,
BentoStackDataEditor.EditorAlias
};
foreach (Property contentProperty in content.Properties.Where(x => editors.Contains(x.PropertyType.PropertyEditorAlias)))
{
IDataType editor = DataTypeService.GetDataType(contentProperty.PropertyType.DataTypeId);
IRelationType bentoBlocksRelationType = RelationService.GetRelationTypeByAlias(RelationTypes.BentoItemsAlias);
if (bentoBlocksRelationType == null)
{
RelationType relationType = new RelationType(
RelationTypes.BentoItemsAlias,
RelationTypes.BentoItemsName,
true,
UmbracoObjectTypes.Document.GetGuid(),
UmbracoObjectTypes.Document.GetGuid());
RelationService.Save(relationType);
bentoBlocksRelationType = RelationService.GetRelationTypeByAlias(RelationTypes.BentoItemsAlias);
}
//todo: this does work but it's a bit brute force...
//i guess we could store the current relationships and then store the ones we're creating and compare them and then
//delete the ones from the old list that arent in the new list? but that's a lot of db hits...
IEnumerable <IRelation> rels = RelationService.GetByParentId(content.Id);
foreach (IRelation currentRelation in rels.Where(x => x.RelationType.Id == bentoBlocksRelationType.Id))
{
RelationService.Delete(currentRelation);
}
if (contentProperty.PropertyType.PropertyEditorAlias == BentoItemDataEditor.EditorAlias)
{
foreach (Property.PropertyValue value in contentProperty.Values)
{
if (value.PublishedValue == null)
{
break;
}
var area = JsonConvert.DeserializeObject <Area>(value.PublishedValue.ToString());
if (area.Id <= 0)
{
continue;
}
var bentoContent = contentService.GetById(area.Id);
if (bentoContent == null)
{
continue;
}
BentoItemConfiguration config = (BentoItemConfiguration)editor.Configuration;
ProcessRelationship(contentService, bentoContent, content, bentoBlocksRelationType, config.ItemDoctypeCompositionAlias);
}
}
else
{
foreach (Property.PropertyValue value in contentProperty.Values)
{
if (value.PublishedValue == null)
{
break;
}
string valueString = value.PublishedValue?.ToString();
if (string.IsNullOrWhiteSpace(valueString))
{
continue;
}
IEnumerable <StackItem> items = JsonConvert.DeserializeObject <IEnumerable <StackItem> >(valueString, new StackItemConverter());
var itemList = items.Where(x => x.Areas != null && x.Areas.Any())
.SelectMany(stackItem => stackItem.Areas.Where(x => x.Id > 0), (stackItem, x) => contentService.GetById(x.Id))
.Where(bentoContent => bentoContent != null)
.Distinct();
BentoStackConfiguration config = (BentoStackConfiguration)editor.Configuration;
foreach (IContent item in itemList)
{
ProcessRelationship(contentService, item, content, bentoBlocksRelationType, config.ItemDoctypeCompositionAlias);
}
}
}
}
}
}
private void UpdateDocumentType()
{
const string
propertyAlias = "meta",
propertyName = "Meta Tag";
try
{
#region Home Document Type
var container = contentTypeService.GetContainers(DOCUMENT_TYPE_CONTAINER, 1).FirstOrDefault();
int containerId = -1;
if (container != null)
{
containerId = container.Id;
}
var contentType = contentTypeService.Get(DOCUMENT_TYPE_ALIAS);
if (contentType != null)
{
var changed = false;
#region Meta Tags Property Type
if (!contentType.PropertyTypeExists($"{propertyAlias}Author"))
{
PropertyType metaAuthorPropType = new PropertyType(dataTypeService.GetDataType(-88), $"{propertyAlias}Author")
{
Name = $"Author {propertyName}",
Variations = ContentVariation.Culture
};
contentType.AddPropertyType(metaAuthorPropType, META_TAB);
changed = true;
}
if (!contentType.PropertyTypeExists($"{propertyAlias}Copyright"))
{
PropertyType metaCopyrightPropType = new PropertyType(dataTypeService.GetDataType(-88), $"{propertyAlias}Copyright")
{
Name = $"Copyright {propertyName}",
Variations = ContentVariation.Culture
};
contentType.AddPropertyType(metaCopyrightPropType, META_TAB);
changed = true;
}
if (!contentType.PropertyTypeExists($"{propertyAlias}Description"))
{
PropertyType metaDescriptionPropType = new PropertyType(dataTypeService.GetDataType(-88), $"{propertyAlias}Description")
{
Name = $"Description {propertyName}",
Variations = ContentVariation.Culture
};
contentType.AddPropertyType(metaDescriptionPropType, META_TAB);
changed = true;
}
if (!contentType.PropertyTypeExists($"{propertyAlias}Keywords"))
{
PropertyType metaKeywordsPropType = new PropertyType(dataTypeService.GetDataType(-88), $"{propertyAlias}Keywords")
{
Name = $"Keywords {propertyName}",
Variations = ContentVariation.Culture
};
contentType.AddPropertyType(metaKeywordsPropType, META_TAB);
changed = true;
}
if (!contentType.PropertyTypeExists($"{propertyAlias}Robots"))
{
PropertyType metaRobotsPropType = new PropertyType(dataTypeService.GetDataType(-88), $"{propertyAlias}Robots")
{
Name = $"Robots {propertyName}",
Variations = ContentVariation.Culture
};
contentType.AddPropertyType(metaRobotsPropType, META_TAB);
changed = true;
}
#endregion
if (changed)
{
contentTypeService.Save(contentType);
}
ConnectorContext.AuditService.Add(AuditType.New, -1, contentType.Id, "Document Type", $"Document Type '{DOCUMENT_TYPE_ALIAS}' has been updated");
}
#endregion
}
catch (System.Exception ex)
{
logger.Error(typeof(_31_MetaTags), ex.Message);
logger.Error(typeof(_31_MetaTags), ex.StackTrace);
}
}
public ContentTypeMapperProfile(PropertyEditorCollection propertyEditors, IDataTypeService dataTypeService, IFileService fileService, IContentTypeService contentTypeService, IMediaTypeService mediaTypeService)
{
CreateMap <DocumentTypeSave, IContentType>()
//do the base mapping
.MapBaseContentTypeSaveToEntity <DocumentTypeSave, PropertyTypeBasic, IContentType>()
.ConstructUsing((source) => new ContentType(source.ParentId))
.ForMember(source => source.AllowedTemplates, opt => opt.Ignore())
.ForMember(dto => dto.DefaultTemplate, opt => opt.Ignore())
.AfterMap((source, dest) =>
{
dest.AllowedTemplates = source.AllowedTemplates
.Where(x => x != null)
.Select(fileService.GetTemplate)
.Where(x => x != null)
.ToArray();
if (source.DefaultTemplate != null)
{
dest.SetDefaultTemplate(fileService.GetTemplate(source.DefaultTemplate));
}
else
{
dest.SetDefaultTemplate(null);
}
ContentTypeProfileExtensions.AfterMapContentTypeSaveToEntity(source, dest, contentTypeService);
});
CreateMap <MediaTypeSave, IMediaType>()
//do the base mapping
.MapBaseContentTypeSaveToEntity <MediaTypeSave, PropertyTypeBasic, IMediaType>()
.ConstructUsing((source) => new MediaType(source.ParentId))
.AfterMap((source, dest) =>
{
ContentTypeProfileExtensions.AfterMapMediaTypeSaveToEntity(source, dest, mediaTypeService);
});
CreateMap <MemberTypeSave, IMemberType>()
//do the base mapping
.MapBaseContentTypeSaveToEntity <MemberTypeSave, MemberPropertyTypeBasic, IMemberType>()
.ConstructUsing(source => new MemberType(source.ParentId))
.AfterMap((source, dest) =>
{
ContentTypeProfileExtensions.AfterMapContentTypeSaveToEntity(source, dest, contentTypeService);
//map the MemberCanEditProperty,MemberCanViewProperty,IsSensitiveData
foreach (var propertyType in source.Groups.SelectMany(x => x.Properties))
{
var localCopy = propertyType;
var destProp = dest.PropertyTypes.SingleOrDefault(x => x.Alias.InvariantEquals(localCopy.Alias));
if (destProp != null)
{
dest.SetMemberCanEditProperty(localCopy.Alias, localCopy.MemberCanEditProperty);
dest.SetMemberCanViewProperty(localCopy.Alias, localCopy.MemberCanViewProperty);
dest.SetIsSensitiveProperty(localCopy.Alias, localCopy.IsSensitiveData);
}
}
});
CreateMap <IContentTypeComposition, string>().ConvertUsing(dest => dest.Alias);
CreateMap <IMemberType, MemberTypeDisplay>()
//map base logic
.MapBaseContentTypeEntityToDisplay <IMemberType, MemberTypeDisplay, MemberPropertyTypeDisplay>(propertyEditors, dataTypeService, contentTypeService)
.AfterMap((memberType, display) =>
{
//map the MemberCanEditProperty,MemberCanViewProperty,IsSensitiveData
foreach (var propertyType in memberType.PropertyTypes)
{
var localCopy = propertyType;
var displayProp = display.Groups.SelectMany(dest => dest.Properties).SingleOrDefault(dest => dest.Alias.InvariantEquals(localCopy.Alias));
if (displayProp != null)
{
displayProp.MemberCanEditProperty = memberType.MemberCanEditProperty(localCopy.Alias);
displayProp.MemberCanViewProperty = memberType.MemberCanViewProperty(localCopy.Alias);
displayProp.IsSensitiveData = memberType.IsSensitiveProperty(localCopy.Alias);
}
}
});
CreateMap <IMediaType, MediaTypeDisplay>()
//map base logic
.MapBaseContentTypeEntityToDisplay <IMediaType, MediaTypeDisplay, PropertyTypeDisplay>(propertyEditors, dataTypeService, contentTypeService)
.AfterMap((source, dest) =>
{
//default listview
dest.ListViewEditorName = Constants.Conventions.DataTypes.ListViewPrefix + "Media";
if (string.IsNullOrEmpty(source.Name) == false)
{
var name = Constants.Conventions.DataTypes.ListViewPrefix + source.Name;
if (dataTypeService.GetDataType(name) != null)
{
dest.ListViewEditorName = name;
}
}
});
CreateMap <IContentType, DocumentTypeDisplay>()
//map base logic
.MapBaseContentTypeEntityToDisplay <IContentType, DocumentTypeDisplay, PropertyTypeDisplay>(propertyEditors, dataTypeService, contentTypeService)
.ForMember(dto => dto.AllowedTemplates, opt => opt.Ignore())
.ForMember(dto => dto.DefaultTemplate, opt => opt.Ignore())
.ForMember(display => display.Notifications, opt => opt.Ignore())
.ForMember(display => display.AllowCultureVariant, opt => opt.MapFrom(type => type.VariesByCulture()))
.AfterMap((source, dest) =>
{
//sync templates
dest.AllowedTemplates = source.AllowedTemplates.Select(Mapper.Map <EntityBasic>).ToArray();
if (source.DefaultTemplate != null)
{
dest.DefaultTemplate = Mapper.Map <EntityBasic>(source.DefaultTemplate);
}
//default listview
dest.ListViewEditorName = Constants.Conventions.DataTypes.ListViewPrefix + "Content";
if (string.IsNullOrEmpty(source.Alias) == false)
{
var name = Constants.Conventions.DataTypes.ListViewPrefix + source.Alias;
if (dataTypeService.GetDataType(name) != null)
{
dest.ListViewEditorName = name;
}
}
});
CreateMap <IMemberType, ContentTypeBasic>()
.ForMember(dest => dest.Udi, opt => opt.MapFrom(source => Udi.Create(Constants.UdiEntityType.MemberType, source.Key)))
.ForMember(dest => dest.Blueprints, opt => opt.Ignore())
.ForMember(dest => dest.AdditionalData, opt => opt.Ignore());
CreateMap <IMediaType, ContentTypeBasic>()
.ForMember(dest => dest.Udi, opt => opt.MapFrom(source => Udi.Create(Constants.UdiEntityType.MediaType, source.Key)))
.ForMember(dest => dest.Blueprints, opt => opt.Ignore())
.ForMember(dest => dest.AdditionalData, opt => opt.Ignore());
CreateMap <IContentType, ContentTypeBasic>()
.ForMember(dest => dest.Udi, opt => opt.MapFrom(source => Udi.Create(Constants.UdiEntityType.DocumentType, source.Key)))
.ForMember(dest => dest.Blueprints, opt => opt.Ignore())
.ForMember(dest => dest.AdditionalData, opt => opt.Ignore());
CreateMap <PropertyTypeBasic, PropertyType>()
.ConstructUsing(propertyTypeBasic =>
{
var dataType = dataTypeService.GetDataType(propertyTypeBasic.DataTypeId);
if (dataType == null)
{
throw new NullReferenceException("No data type found with id " + propertyTypeBasic.DataTypeId);
}
return(new PropertyType(dataType, propertyTypeBasic.Alias));
})
.IgnoreEntityCommonProperties()
.ForMember(dest => dest.IsPublishing, opt => opt.Ignore())
// see note above - have to do this here?
.ForMember(dest => dest.PropertyEditorAlias, opt => opt.Ignore())
.ForMember(dest => dest.DeleteDate, opt => opt.Ignore())
.ForMember(dto => dto.Variations, opt => opt.ResolveUsing <PropertyTypeVariationsResolver>())
//only map if it is actually set
.ForMember(dest => dest.Id, opt => opt.Condition(source => source.Id > 0))
//only map if it is actually set, if it's not set, it needs to be handled differently and will be taken care of in the
// IContentType.AddPropertyType
.ForMember(dest => dest.PropertyGroupId, opt => opt.Condition(source => source.GroupId > 0))
.ForMember(dest => dest.PropertyGroupId, opt => opt.MapFrom(display => new Lazy <int>(() => display.GroupId, false)))
.ForMember(dest => dest.Key, opt => opt.Ignore())
.ForMember(dest => dest.HasIdentity, opt => opt.Ignore())
//ignore because this is set in the ctor NOT ON UPDATE, STUPID!
//.ForMember(type => type.Alias, opt => opt.Ignore())
//ignore because this is obsolete and shouldn't be used
.ForMember(dest => dest.DataTypeId, opt => opt.Ignore())
.ForMember(dest => dest.Mandatory, opt => opt.MapFrom(source => source.Validation.Mandatory))
.ForMember(dest => dest.ValidationRegExp, opt => opt.MapFrom(source => source.Validation.Pattern))
.ForMember(dest => dest.DataTypeId, opt => opt.MapFrom(source => source.DataTypeId))
.ForMember(dest => dest.Name, opt => opt.MapFrom(source => source.Label));
#region *** Used for mapping on top of an existing display object from a save object ***
CreateMap <MemberTypeSave, MemberTypeDisplay>()
.MapBaseContentTypeSaveToDisplay <MemberTypeSave, MemberPropertyTypeBasic, MemberTypeDisplay, MemberPropertyTypeDisplay>();
CreateMap <MediaTypeSave, MediaTypeDisplay>()
.MapBaseContentTypeSaveToDisplay <MediaTypeSave, PropertyTypeBasic, MediaTypeDisplay, PropertyTypeDisplay>();
CreateMap <DocumentTypeSave, DocumentTypeDisplay>()
.MapBaseContentTypeSaveToDisplay <DocumentTypeSave, PropertyTypeBasic, DocumentTypeDisplay, PropertyTypeDisplay>()
.ForMember(dto => dto.AllowedTemplates, opt => opt.Ignore())
.ForMember(dto => dto.DefaultTemplate, opt => opt.Ignore())
.AfterMap((source, dest) =>
{
//sync templates
var destAllowedTemplateAliases = dest.AllowedTemplates.Select(x => x.Alias);
//if the dest is set and it's the same as the source, then don't change
if (destAllowedTemplateAliases.SequenceEqual(source.AllowedTemplates) == false)
{
var templates = fileService.GetTemplates(source.AllowedTemplates.ToArray());
dest.AllowedTemplates = source.AllowedTemplates
.Select(x => Mapper.Map <EntityBasic>(templates.SingleOrDefault(t => t.Alias == x)))
.WhereNotNull()
.ToArray();
}
if (source.DefaultTemplate.IsNullOrWhiteSpace() == false)
{
//if the dest is set and it's the same as the source, then don't change
if (dest.DefaultTemplate == null || source.DefaultTemplate != dest.DefaultTemplate.Alias)
{
var template = fileService.GetTemplate(source.DefaultTemplate);
dest.DefaultTemplate = template == null ? null : Mapper.Map <EntityBasic>(template);
}
}
else
{
dest.DefaultTemplate = null;
}
});
//for doc types, media types
CreateMap <PropertyGroupBasic <PropertyTypeBasic>, PropertyGroup>()
.MapPropertyGroupBasicToPropertyGroupPersistence <PropertyGroupBasic <PropertyTypeBasic>, PropertyTypeBasic>();
//for members
CreateMap <PropertyGroupBasic <MemberPropertyTypeBasic>, PropertyGroup>()
.MapPropertyGroupBasicToPropertyGroupPersistence <PropertyGroupBasic <MemberPropertyTypeBasic>, MemberPropertyTypeBasic>();
//for doc types, media types
CreateMap <PropertyGroupBasic <PropertyTypeBasic>, PropertyGroupDisplay <PropertyTypeDisplay> >()
.MapPropertyGroupBasicToPropertyGroupDisplay <PropertyGroupBasic <PropertyTypeBasic>, PropertyTypeBasic, PropertyTypeDisplay>();
//for members
CreateMap <PropertyGroupBasic <MemberPropertyTypeBasic>, PropertyGroupDisplay <MemberPropertyTypeDisplay> >()
.MapPropertyGroupBasicToPropertyGroupDisplay <PropertyGroupBasic <MemberPropertyTypeBasic>, MemberPropertyTypeBasic, MemberPropertyTypeDisplay>();
CreateMap <PropertyTypeBasic, PropertyTypeDisplay>()
.ForMember(g => g.Editor, opt => opt.Ignore())
.ForMember(g => g.View, opt => opt.Ignore())
.ForMember(g => g.Config, opt => opt.Ignore())
.ForMember(g => g.ContentTypeId, opt => opt.Ignore())
.ForMember(g => g.ContentTypeName, opt => opt.Ignore())
.ForMember(g => g.Locked, exp => exp.Ignore());
CreateMap <MemberPropertyTypeBasic, MemberPropertyTypeDisplay>()
.ForMember(g => g.Editor, opt => opt.Ignore())
.ForMember(g => g.View, opt => opt.Ignore())
.ForMember(g => g.Config, opt => opt.Ignore())
.ForMember(g => g.ContentTypeId, opt => opt.Ignore())
.ForMember(g => g.ContentTypeName, opt => opt.Ignore())
.ForMember(g => g.Locked, exp => exp.Ignore());
#endregion
}
/// <summary>
/// Gets data type by name
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public DataTypeDisplay GetByName(string name)
{
var dataType = _dataTypeService.GetDataType(name);
return(dataType == null ? null : _umbracoMapper.Map <IDataType, DataTypeDisplay>(dataType));
}
public void Export(
string fileName,
int blogRootNode)
{
var root = _contentService.GetById(blogRootNode);
if (root == null)
{
throw new InvalidOperationException("No node found with id " + blogRootNode);
}
if (!root.ContentType.Alias.InvariantEquals("Articulate"))
{
throw new InvalidOperationException("The node with id " + blogRootNode + " is not an Articulate root node");
}
var postType = _contentTypeService.Get("ArticulateRichText");
if (postType == null)
{
throw new InvalidOperationException("Articulate is not installed properly, the ArticulateRichText doc type could not be found");
}
var archiveContentType = _contentTypeService.Get("ArticulateArchive");
var archiveNodes = _contentService.GetPagedOfType(archiveContentType.Id, 0, int.MaxValue, out long totalArchive, null);
var authorsContentType = _contentTypeService.Get("ArticulateAuthors");
var authorsNodes = _contentService.GetPagedOfType(authorsContentType.Id, 0, int.MaxValue, out long totalAuthors, null);
if (totalArchive == 0)
{
throw new InvalidOperationException("No ArticulateArchive found under the blog root node");
}
if (totalAuthors == 0)
{
throw new InvalidOperationException("No ArticulateAuthors found under the blog root node");
}
var categoryDataType = _dataTypeService.GetDataType("Articulate Categories");
if (categoryDataType == null)
{
throw new InvalidOperationException("No Articulate Categories data type found");
}
var categoryConfiguration = categoryDataType.ConfigurationAs <TagConfiguration>();
var categoryGroup = categoryConfiguration.Group;
var tagDataType = _dataTypeService.GetDataType("Articulate Tags");
if (tagDataType == null)
{
throw new InvalidOperationException("No Articulate Tags data type found");
}
var tagConfiguration = tagDataType.ConfigurationAs <TagConfiguration>();
var tagGroup = tagConfiguration.Group;
//TODO: See: http://argotic.codeplex.com/wikipage?title=Generating%20portable%20web%20log%20content&referringTitle=Home
var blogMlDoc = new BlogMLDocument
{
RootUrl = new Uri(_umbracoContextAccessor.UmbracoContext.UrlProvider.GetUrl(root.Id), UriKind.RelativeOrAbsolute),
GeneratedOn = DateTime.Now,
Title = new BlogMLTextConstruct(root.GetValue <string>("blogTitle")),
Subtitle = new BlogMLTextConstruct(root.GetValue <string>("blogDescription"))
};
foreach (var authorsNode in authorsNodes)
{
AddBlogAuthors(authorsNode, blogMlDoc);
}
AddBlogCategories(blogMlDoc, categoryGroup);
foreach (var archiveNode in archiveNodes)
{
AddBlogPosts(archiveNode, blogMlDoc, categoryGroup, tagGroup);
}
WriteFile(blogMlDoc);
}
protected override IDataType FindItem(Guid key) => dataTypeService.GetDataType(key);
public void Initialize()
{
try
{
var contentType = contentTypeService.Get(DOCUMENT_TYPE_ALIAS);
if (contentType == null)
{
return;
}
if (!contentType.PropertyGroups.Any(x => x.Name == NOTIFICATION_SETTINGS_TAB))
{
contentType.AddPropertyGroup(NOTIFICATION_SETTINGS_TAB);
}
const string ddlNotificationPositions = "ddl Notification Positions";
var dataTypeContainer = dataTypeService.GetContainers(DATA_TYPE_CONTAINER, 1).FirstOrDefault();
var dataTypeContainerId = -1;
if (dataTypeContainer != null)
{
dataTypeContainerId = dataTypeContainer.Id;
}
var exists = dataTypeService.GetDataType(ddlNotificationPositions) != null;
if (!exists)
{
var created = Web.Composing.Current.PropertyEditors.TryGet("Umbraco.DropDown.Flexible", out IDataEditor editor);
if (editor != null)
{
var positionList = new List <ValueListConfiguration.ValueListItem>();
positionList.Add(new ValueListConfiguration.ValueListItem {
Id = 1, Value = "Top Right"
});
positionList.Add(new ValueListConfiguration.ValueListItem {
Id = 2, Value = "Bottom Right"
});
positionList.Add(new ValueListConfiguration.ValueListItem {
Id = 3, Value = "Bottom Left"
});
positionList.Add(new ValueListConfiguration.ValueListItem {
Id = 4, Value = "Top Left"
});
positionList.Add(new ValueListConfiguration.ValueListItem {
Id = 5, Value = "Top Center"
});
positionList.Add(new ValueListConfiguration.ValueListItem {
Id = 6, Value = "Bottom Center"
});
DataType ddlNotificationPositionsDataType = new DataType(editor, dataTypeContainerId)
{
Name = ddlNotificationPositions,
ParentId = dataTypeContainerId,
Configuration = new DropDownFlexibleConfiguration()
{
Multiple = false,
Items = positionList
}
};
dataTypeService.Save(ddlNotificationPositionsDataType);
}
}
var isNewPropertyAdded = false;
if (!contentType.PropertyTypeExists("notificationPosition"))
{
isNewPropertyAdded = true;
var ddlPositionsDataType = dataTypeService.GetDataType(ddlNotificationPositions);
PropertyType ddlPositionsPropType = new PropertyType(ddlPositionsDataType, "notificationPosition")
{
Name = "Position",
Variations = ContentVariation.Culture
};
contentType.AddPropertyType(ddlPositionsPropType, NOTIFICATION_SETTINGS_TAB);
}
if (!contentType.PropertyTypeExists("notificationBgColor"))
{
isNewPropertyAdded = true;
PropertyType notificationBackgroundColor = new PropertyType(dataTypeService.GetDataType(6018), "notificationBgColor")
{
Name = "Background Color",
Variations = ContentVariation.Culture
};
contentType.AddPropertyType(notificationBackgroundColor, NOTIFICATION_SETTINGS_TAB);
}
if (!contentType.PropertyTypeExists("notificationWidth"))
{
isNewPropertyAdded = true;
PropertyType widthPropType = new PropertyType(dataTypeService.GetDataType(-88), "notificationWidth")
{
Name = "Width",
Description = "If required enter only numeric value",
Variations = ContentVariation.Culture
};
contentType.AddPropertyType(widthPropType, NOTIFICATION_SETTINGS_TAB);
}
if (isNewPropertyAdded)
{
contentTypeService.Save(contentType);
ConnectorContext.AuditService.Add(AuditType.New, -1, contentType.Id, "Document Type", $"Document Type '{DOCUMENT_TYPE_ALIAS}' has been updated");
}
}
catch (Exception ex)
{
logger.Error(typeof(_39_HomeDocTypeNotificationSettings), ex.Message);
logger.Error(typeof(_39_HomeDocTypeNotificationSettings), ex.StackTrace);
}
}
/// <summary>
/// Used to submit a media file
/// </summary>
/// <returns></returns>
/// <remarks>
/// We cannot validate this request with attributes (nicely) due to the nature of the multi-part for data.
/// </remarks>
public async Task <IActionResult> PostAddFile([FromForm] string path, [FromForm] string currentFolder, [FromForm] string contentTypeAlias, List <IFormFile> file)
{
var root = _hostingEnvironment.MapPathContentRoot(Constants.SystemDirectories.TempFileUploads);
//ensure it exists
Directory.CreateDirectory(root);
//must have a file
if (file.Count == 0)
{
return(NotFound());
}
//get the string json from the request
var parentIdResult = await GetParentIdAsIntAsync(currentFolder, validatePermissions : true);
if (!(parentIdResult.Result is null))
{
return(parentIdResult.Result);
}
var parentId = parentIdResult.Value;
if (!parentId.HasValue)
{
return(NotFound("The passed id doesn't exist"));
}
var tempFiles = new PostedFiles();
//in case we pass a path with a folder in it, we will create it and upload media to it.
if (!string.IsNullOrEmpty(path))
{
if (!IsFolderCreationAllowedHere(parentId.Value))
{
AddCancelMessage(tempFiles, _localizedTextService.Localize("speechBubbles", "folderUploadNotAllowed"));
return(Ok(tempFiles));
}
var folders = path.Split(Constants.CharArrays.ForwardSlash);
for (int i = 0; i < folders.Length - 1; i++)
{
var folderName = folders[i];
IMedia folderMediaItem;
//if uploading directly to media root and not a subfolder
if (parentId == Constants.System.Root)
{
//look for matching folder
folderMediaItem =
_mediaService.GetRootMedia().FirstOrDefault(x => x.Name == folderName && x.ContentType.Alias == Constants.Conventions.MediaTypes.Folder);
if (folderMediaItem == null)
{
//if null, create a folder
folderMediaItem = _mediaService.CreateMedia(folderName, -1, Constants.Conventions.MediaTypes.Folder);
_mediaService.Save(folderMediaItem);
}
}
else
{
//get current parent
var mediaRoot = _mediaService.GetById(parentId.Value);
//if the media root is null, something went wrong, we'll abort
if (mediaRoot == null)
{
return(Problem(
"The folder: " + folderName + " could not be used for storing images, its ID: " + parentId +
" returned null"));
}
//look for matching folder
folderMediaItem = FindInChildren(mediaRoot.Id, folderName, Constants.Conventions.MediaTypes.Folder);
if (folderMediaItem == null)
{
//if null, create a folder
folderMediaItem = _mediaService.CreateMedia(folderName, mediaRoot, Constants.Conventions.MediaTypes.Folder);
_mediaService.Save(folderMediaItem);
}
}
//set the media root to the folder id so uploaded files will end there.
parentId = folderMediaItem.Id;
}
}
var mediaTypeAlias = string.Empty;
var allMediaTypes = _mediaTypeService.GetAll().ToList();
var allowedContentTypes = new HashSet <IMediaType>();
if (parentId != Constants.System.Root)
{
var mediaFolderItem = _mediaService.GetById(parentId.Value);
var mediaFolderType = allMediaTypes.FirstOrDefault(x => x.Alias == mediaFolderItem.ContentType.Alias);
if (mediaFolderType != null)
{
IMediaType mediaTypeItem = null;
foreach (ContentTypeSort allowedContentType in mediaFolderType.AllowedContentTypes)
{
IMediaType checkMediaTypeItem = allMediaTypes.FirstOrDefault(x => x.Id == allowedContentType.Id.Value);
allowedContentTypes.Add(checkMediaTypeItem);
var fileProperty = checkMediaTypeItem?.CompositionPropertyTypes.FirstOrDefault(x => x.Alias == Constants.Conventions.Media.File);
if (fileProperty != null)
{
mediaTypeItem = checkMediaTypeItem;
}
}
//Only set the permission-based mediaType if we only allow 1 specific file under this parent.
if (allowedContentTypes.Count == 1 && mediaTypeItem != null)
{
mediaTypeAlias = mediaTypeItem.Alias;
}
}
}
else
{
var typesAllowedAtRoot = allMediaTypes.Where(x => x.AllowedAsRoot).ToList();
allowedContentTypes.UnionWith(typesAllowedAtRoot);
}
//get the files
foreach (var formFile in file)
{
var fileName = formFile.FileName.Trim(Constants.CharArrays.DoubleQuote).TrimEnd();
var safeFileName = fileName.ToSafeFileName(ShortStringHelper);
var ext = safeFileName.Substring(safeFileName.LastIndexOf('.') + 1).ToLower();
if (!_contentSettings.IsFileAllowedForUpload(ext))
{
tempFiles.Notifications.Add(new BackOfficeNotification(
_localizedTextService.Localize("speechBubbles", "operationFailedHeader"),
_localizedTextService.Localize("media", "disallowedFileType"),
NotificationStyle.Warning));
continue;
}
if (string.IsNullOrEmpty(mediaTypeAlias))
{
mediaTypeAlias = Constants.Conventions.MediaTypes.File;
if (contentTypeAlias == Constants.Conventions.MediaTypes.AutoSelect)
{
// Look up MediaTypes
foreach (var mediaTypeItem in allMediaTypes)
{
var fileProperty = mediaTypeItem.CompositionPropertyTypes.FirstOrDefault(x => x.Alias == Constants.Conventions.Media.File);
if (fileProperty == null)
{
continue;
}
var dataTypeKey = fileProperty.DataTypeKey;
var dataType = _dataTypeService.GetDataType(dataTypeKey);
if (dataType == null || dataType.Configuration is not IFileExtensionsConfig fileExtensionsConfig)
{
continue;
}
var fileExtensions = fileExtensionsConfig.FileExtensions;
if (fileExtensions == null || fileExtensions.All(x => x.Value != ext))
{
continue;
}
mediaTypeAlias = mediaTypeItem.Alias;
break;
}
// If media type is still File then let's check if it's an image.
if (mediaTypeAlias == Constants.Conventions.MediaTypes.File && _imageUrlGenerator.SupportedImageFileTypes.Contains(ext))
{
mediaTypeAlias = Constants.Conventions.MediaTypes.Image;
}
}
else
{
mediaTypeAlias = contentTypeAlias;
}
}
if (allowedContentTypes.Any(x => x.Alias == mediaTypeAlias) == false)
{
tempFiles.Notifications.Add(new BackOfficeNotification(
_localizedTextService.Localize("speechBubbles", "operationFailedHeader"),
_localizedTextService.Localize("media", "disallowedMediaType", new[] { mediaTypeAlias }),
NotificationStyle.Warning));
continue;
}
var mediaItemName = fileName.ToFriendlyName();
var createdMediaItem = _mediaService.CreateMedia(mediaItemName, parentId.Value, mediaTypeAlias, _backofficeSecurityAccessor.BackOfficeSecurity.CurrentUser.Id);
await using (var stream = formFile.OpenReadStream())
{
createdMediaItem.SetValue(_mediaFileManager, _mediaUrlGenerators, _shortStringHelper, _contentTypeBaseServiceProvider, Constants.Conventions.Media.File, fileName, stream);
}
var saveResult = _mediaService.Save(createdMediaItem, _backofficeSecurityAccessor.BackOfficeSecurity.CurrentUser.Id);
if (saveResult == false)
{
AddCancelMessage(tempFiles, _localizedTextService.Localize("speechBubbles", "operationCancelledText") + " -- " + mediaItemName);
}
}
//Different response if this is a 'blueimp' request
if (HttpContext.Request.Query.Any(x => x.Key == "origin"))
{
var origin = HttpContext.Request.Query.First(x => x.Key == "origin");
if (origin.Value == "blueimp")
{
return(new JsonResult(tempFiles)); //Don't output the angular xsrf stuff, blue imp doesn't like that
}
}
return(Ok(tempFiles));
}
public void Initialize()
{
try
{
var container = contentTypeService.GetContainers(DOCUMENT_TYPE_CONTAINER, 1).FirstOrDefault();
int containerId = -1;
if (container != null)
{
containerId = container.Id;
}
var contentType = contentTypeService.Get(DOCUMENT_TYPE_ALIAS);
if (contentType != null)
{
return;
}
const string CONTENT_TAB = "CONTENT";
ContentType docType = (ContentType)contentType ?? new ContentType(containerId)
{
Name = DOCUMENT_TYPE_NAME,
Alias = DOCUMENT_TYPE_ALIAS,
AllowedAsRoot = true,
Description = "",
Icon = NESTED_DOCUMENT_TYPE_ICON,
ParentId = contentTypeService.Get(NESTED_DOCUMENT_TYPE_PARENT_ALIAS).Id,
SortOrder = 0,
Variations = ContentVariation.Culture,
};
// Create the Template if it doesn't exist
if (fileService.GetTemplate(TEMPLATE_ALIAS) == null)
{
//then create the template
Template newTemplate = new Template(TEMPLATE_NAME, TEMPLATE_ALIAS);
ITemplate masterTemplate = fileService.GetTemplate(PARENT_TEMPLATE_ALIAS);
newTemplate.SetMasterTemplate(masterTemplate);
fileService.SaveTemplate(newTemplate);
}
var template = fileService.GetTemplate(TEMPLATE_ALIAS);
docType.AllowedTemplates = new List <ITemplate> {
template
};
docType.SetDefaultTemplate(template);
docType.AddPropertyGroup(CONTENT_TAB);
#region Content
PropertyType CotentPageTitlePropType = new PropertyType(dataTypeService.GetDataType(-88), "genericInfoPageTitle")
{
Name = "Page Title",
Variations = ContentVariation.Culture
};
docType.AddPropertyType(CotentPageTitlePropType, CONTENT_TAB);
PropertyType CotentPageContentPropType = new PropertyType(dataTypeService.GetDataType(-87), "genericInfoPageContent")
{
Name = "Page Content",
Variations = ContentVariation.Culture
};
docType.AddPropertyType(CotentPageContentPropType, CONTENT_TAB);
#endregion
contentTypeService.Save(docType);
ConnectorContext.AuditService.Add(AuditType.New, -1, docType.Id, "Document Type", $"Document Type '{DOCUMENT_TYPE_NAME}' has been created");
ContentHelper.CopyPhysicalAssets(new GenericInfoPageEmbeddedResources());
}
catch (Exception ex)
{
logger.Error(typeof(_40_GenericInfoPageDocumentType), ex.Message);
logger.Error(typeof(_40_GenericInfoPageDocumentType), ex.StackTrace);
}
}
