public void InitTest()
{
Tools.DeleteCmsFile();
manager = new CmsManager();
Repository repository = new Repository()
{
Id = repositoryId, Name = repositoryName
};
IContentDefinition definition = ContentDefinitionFactory.CreateContentDefinition(IContentDefinition.DefinitionType.String);
definition.DefinitionId = definitionId;
definition.Name = contentName;
repository.ContentDefinitions.Add(definition);
manager.Data.Repositories.Add(repository);
// filters
manager.Data.Filters.Add(new RegExFilter()
{
Id = regexFilterId, Name = "Email"
});
manager.Data.Filters.Add(new BooleanFilter()
{
Id = booleanFilterId, Name = "IsLoggedIn"
});
manager.Save();
}
public string GetContentString(string contentName)
{
IContentDefinition definition = repo.GetByName(contentName);
ContentItem contentItem = contentStore.GetDefaultByDefinitionId(definition.DefinitionId).FirstOrDefault();
if (contentItem == null)
{
return("");
}
return(contentItem == null ? "" : contentItem.GetValue().ToString());
}
void MapChilderen(FolderContentDefinition model, HttpRequest request)
{
model.Definitions.Clear();
int numberoffilters = Utility.GetRequestIntValueDef(request, "numbderoffvalues", -1);
for (int i = 1; i <= numberoffilters; i++)
{
IContentDefinition child = ContentDefinitionFactory.CreateContentDefinition(Utility.GetRequestValueDef(request, "childtype" + i.ToString(), ""));
child.DefinitionId = Guid.Parse(Utility.GetRequestValueDef(request, "childid" + i.ToString(), ""));
child.Name = Utility.GetRequestValueDef(request, "childname" + i.ToString(), "");
model.Definitions.Add(child);
}
}
public static ContentItem CreateContentByType(IContentDefinition definition)
{
if (definition is StringContentDefinition)
{
return(new StringContentItem());
}
if (definition is FolderContentDefinition)
{
return(new ContentFolderItem());
}
return(new StringContentItem());
}
private TypeDefinition GetContentTypeDefinition(IContentDefinition contentDefinition)
{
if (contentDefinition.TypeName != null)
{
return(schemaTypeDefinitions[contentDefinition.TypeName]);
}
if (runtimeTypeDefinitions.ContainsKey(contentDefinition.RuntimeType))
{
return(runtimeTypeDefinitions[contentDefinition.RuntimeType]);
}
return(schemaDefinitionProvider.GetTypeDefinition(contentDefinition.RuntimeType));
}
public IContentDefinition MapToModel(IContentDefinition model, HttpRequest request)
{
if (model == null)
{
model = ContentDefinitionFactory.CreateContentDefinition(this.ContentType);
}
model.Name = this.Name;
model.DefinitionId = this.DefinitionId ?? Guid.NewGuid();
if (this.ContentType == FOLDER_CONTENT_TYPE)
{
MapChilderen(model as FolderContentDefinition, request);
}
return(model);
}
public void InitTest()
{
Tools.DeleteCmsFile();
manager = CmsManager.Load();
Repository repository = new Repository()
{
Id = repositoryId, Name = repositoryName
};
IContentDefinition definition = ContentDefinitionFactory.CreateContentDefinition(IContentDefinition.DefinitionType.String);
definition.DefinitionId = definitionId;
definition.Name = contentName;
repository.ContentDefinitions.Add(definition);
manager.Repositories.Add(repository);
manager.Save();
}
private static void MapFolder(ContentItem model, HttpRequest request, IContentDefinition ContentDefinition)
{
((ContentFolderItem)model).Childeren.Clear();
((ContentFolderItem)model).Name = Utility.GetRequestValueDef(request, "FolderName" + model.DefinitionId, "");
foreach (var definition in (ContentDefinition as FolderContentDefinition).Definitions)
{
if (definition is StringContentDefinition)
{
((ContentFolderItem)model).Childeren.Add(
new StringContentItem()
{
DefinitionId = definition.DefinitionId,
Data = Utility.GetRequestValueDef(request, "Value" + definition.DefinitionId.ToString(), ""),
Id = Utility.GetRequestGuidDefNew(request, "Id" + definition.DefinitionId.ToString())
}
);
}
}
}
public IActionResult edit(Guid repositoryid, Guid id)
{
ICmsManager manager = CmsManager.Load();
var repo = manager.GetRepositoryById(repositoryid);
IContentDefinition definition = repo?.ContentDefinitions.Where(m => m.DefinitionId == id).FirstOrDefault();
if (definition == null)
{
return(Redirect("/fcmsmanager/repository"));
}
ContentDefinitionViewModel model = new ContentDefinitionViewModel()
{
RepositoryId = repositoryid
};
model.MapFromModel(definition);
return(View("Edit", model));
}
public IEnumerable <T> GetContents <T>(string contentName, object filters) where T : ContentItem
{
if (filters == null)
{
filters = new { };
}
IContentDefinition definition = repo.GetByName(contentName);
List <ContentItem> contentitems = contentStore.GetByDefinitionId(definition.DefinitionId).ToList();
var filterProperties = filters.GetType().GetProperties().ToLookup(m => m.Name);
foreach (T contentitem in contentitems)
{
if (contentitem.ValidateFilters(filterProperties, filters))
{
yield return(contentitem);
}
}
}
public object Deserialize(XmlReader reader, IXmlTemplateNode templateNode, IContentDefinition definition, XRoadMessage message)
{
if (!reader.ReadToDescendant("Include", NamespaceConstants.XOP))
{
throw XRoadException.InvalidQuery("Missing `xop:Include` reference to multipart content.");
}
var contentID = reader.GetAttribute("href");
if (string.IsNullOrWhiteSpace(contentID))
{
throw XRoadException.InvalidQuery("Missing `href` attribute to multipart content.");
}
var attachment = message.GetAttachment(contentID.Substring(4));
if (attachment == null)
{
throw XRoadException.PäringusPuudubAttachment(contentID);
}
return(attachment.ContentStream);
}
public void InitTest()
{
Tools.DeleteCmsFile();
manager = new CmsManager();
Repository repository = new Repository()
{
Id = repositoryId, Name = repositoryName
};
IContentDefinition definition = ContentDefinitionFactory.CreateContentDefinition(IContentDefinition.DefinitionType.String);
definition.DefinitionId = definitionId;
definition.Name = contentName;
repository.ContentDefinitions.Add(definition);
manager.Data.Repositories.Add(repository);
// filters
manager.Data.Filters.Add(new DateRangeFilter()
{
Id = datetimeFilterId, Name = "Active"
});
manager.Save();
}
public void MapFromModel(IContentDefinition model)
{
this.Name = model.Name;
this.DefinitionId = model.DefinitionId;
this.ContentType = model.GetTypeName();
if (model is FolderContentDefinition)
{
int i = 1;
foreach (var child in (model as FolderContentDefinition).Definitions)
{
this.Children.Add(
new FolderItemViewModel()
{
Id = child.DefinitionId,
Name = child.Name,
Index = i,
Type = child.GetTypeName()
}
);
i++;
}
}
}
public override void Serialize(XmlWriter writer, IXmlTemplateNode templateNode, object value, IContentDefinition definition, XRoadMessage message)
{
if (!(definition is RequestValueDefinition))
{
message.Protocol.Style.WriteExplicitType(writer, Definition.Name);
}
writer.WriteValue(XmlConvert.ToString((DateTime)value, "yyyy-MM-dd"));
}
public override object Deserialize(XmlReader reader, IXmlTemplateNode templateNode, IContentDefinition definition, XRoadMessage message)
{
if (reader.IsEmptyElement)
{
return(MoveNextAndReturn(reader, new DateTime()));
}
var value = reader.ReadElementContentAsString();
if (string.IsNullOrEmpty(value))
{
return(null);
}
var date = DateTime.ParseExact(value, dateFormats, CultureInfo.InvariantCulture, DateTimeStyles.None);
if (value[value.Length - 1] == 'Z')
{
date = date.ToLocalTime();
}
return(date);
}
public override object Deserialize(XmlReader reader, IXmlTemplateNode templateNode, IContentDefinition definition, XRoadMessage message)
{
if (reader.IsEmptyElement)
{
return(MoveNextAndReturn(reader, 0.0f));
}
var value = reader.ReadElementContentAsString();
return(string.IsNullOrEmpty(value) ? 0.0f : XmlConvert.ToDouble(value));
}
/// <summary>
/// String serialization logic.
/// </summary>
public override void Serialize(XmlWriter writer, IXmlTemplateNode templateNode, object value, IContentDefinition definition, XRoadMessage message)
{
if (!(definition is RequestValueDefinition))
{
message.Protocol.Style.WriteExplicitType(writer, Definition.Name);
}
writer.WriteStringWithMode(value.ToString(), message.Protocol.Style.StringSerializationMode);
}
public static ContentItem MapToContentItem(ContentItem model, HttpRequest request, Guid?id, IContentDefinition contentDefinition)
{
model.DefinitionId = contentDefinition.DefinitionId;
model.Id = id ?? Guid.NewGuid();
if (model is ContentFolderItem)
{
MapFolder(model, request, contentDefinition);
}
else
{
MapScalar(model, request);
}
if (request.Form.ContainsKey("numbderoffilters"))
{
model.Filters.AddRange(ViewModelHelpers.GetFilters(request));
}
return(model);
}
public override object Deserialize(XmlReader reader, IXmlTemplateNode templateNode, IContentDefinition definition, XRoadMessage message)
{
if (reader.IsEmptyElement)
{
return(MoveNextAndReturn(reader, new T[0]));
}
var items = new List <T>();
var parentDepth = definition.MergeContent ? reader.Depth - 1 : reader.Depth;
var itemDepth = parentDepth + 1;
var itemName = definition.ArrayItemDefinition.Name.LocalName;
if (!definition.MergeContent)
{
reader.Read();
}
while (parentDepth < reader.Depth)
{
if (reader.NodeType != XmlNodeType.Element || reader.Depth != itemDepth)
{
reader.Read();
continue;
}
if (reader.LocalName != itemName)
{
if (definition.MergeContent)
{
break;
}
if (!definition.ArrayItemDefinition.AcceptAnyName)
{
throw new Exception($"Invalid array item name {reader.LocalName}.");
}
}
if (reader.IsNilElement())
{
items.Add(default(T));
reader.Read();
continue;
}
var typeMap = serializerCache.GetTypeMapFromXsiType(reader) ?? elementTypeMap;
var value = typeMap.Deserialize(reader, templateNode, definition.ArrayItemDefinition, message);
items.Add(value == null ? default(T) : (T)value);
}
return(items.ToArray());
}
public abstract object Deserialize(XmlReader reader, IXmlTemplateNode templateNode, IContentDefinition definition, XRoadMessage message);
public override void Serialize(XmlWriter writer, IXmlTemplateNode templateNode, object value, IContentDefinition definition, XRoadMessage message)
{
var valueArray = (Array)value;
if (!(definition is RequestValueDefinition))
{
message.Protocol.Style.WriteExplicitArrayType(writer, elementTypeMap.Definition.Name, valueArray.Length);
}
var arrayItemDefinition = definition.ArrayItemDefinition;
var itemName = arrayItemDefinition.Name.LocalName;
foreach (var valueItem in valueArray)
{
writer.WriteStartElement(itemName);
if (valueItem != null)
{
var typeMap = serializerCache != null?serializerCache.GetTypeMap(valueItem.GetType()) : elementTypeMap;
typeMap.Serialize(writer, templateNode, valueItem, arrayItemDefinition, message);
}
else
{
writer.WriteNilAttribute();
}
writer.WriteEndElement();
}
}
private ITypeMap GetContentDefinitionTypeMap(IContentDefinition contentDefinition, IDictionary <Type, ITypeMap> partialTypeMaps)
{
return(contentDefinition.TypeName == null
? GetTypeMap(contentDefinition.RuntimeType, partialTypeMaps)
: GetTypeMap(contentDefinition.TypeName, contentDefinition.RuntimeType.IsArray));
}
public IEnumerable <string> GetContentStrings(string contentName)
{
IContentDefinition definition = repo.GetByName(contentName);
return(contentStore.GetDefaultByDefinitionId(definition.DefinitionId).Select(m => m.GetValue().ToString()));
}
public override object Deserialize(XmlReader reader, IXmlTemplateNode templateNode, IContentDefinition definition, XRoadMessage message)
{
if (reader.IsEmptyElement)
{
return(MoveNextAndReturn(reader, new DateTime()));
}
var value = reader.ReadElementContentAsString();
if (string.IsNullOrEmpty(value))
{
return(null);
}
var dateTime = XmlConvert.ToDateTimeOffset(value).DateTime;
return(dateTime.AddTicks(-(dateTime.Ticks % TimeSpan.TicksPerSecond)));
}
public ArrayItemDefinition(IContentDefinition wrapperDefinition)
{
WrapperDefinition = wrapperDefinition;
}
public void Serialize(XmlWriter writer, IXmlTemplateNode templateNode, object value, IContentDefinition definition, XRoadMessage message)
{
var attachment = new XRoadAttachment((Stream)value);
message.AllAttachments.Add(attachment);
if (!(definition is RequestValueDefinition))
{
message.Protocol.Style.WriteExplicitType(writer, Definition.Name);
}
writer.WriteStartElement(PrefixConstants.XOP, "Include", NamespaceConstants.XOP);
//writer.WriteAttributeString(PrefixConstants.XMIME, "contentType", NamespaceConstants.XMIME, "application/octet-stream");
writer.WriteAttributeString("href", $"cid:{attachment.ContentID}");
writer.WriteEndElement();
}
private void ValidateRemainingProperties(IEnumerator <IPropertyMap> properties, IContentDefinition contentDefinition)
{
while (properties.MoveNext())
{
if (!properties.Current.Definition.IsOptional)
{
var typeName = Definition?.Name ?? (((contentDefinition as ArrayItemDefinition)?.WrapperDefinition) as PropertyDefinition)?.DeclaringTypeDefinition?.Name;
throw XRoadException.InvalidQuery($"Element `{properties.Current.Definition.GetSerializedName()}` is required by type `{typeName}` definition.");
}
}
}
public override void Serialize(XmlWriter writer, IXmlTemplateNode templateNode, object value, IContentDefinition definition, XRoadMessage message)
{
message.Protocol.Style.WriteType(writer, Definition, definition.RuntimeType, definition is RequestValueDefinition);
if (contentPropertyMap != null)
{
var childTemplateNode = templateNode?[contentPropertyMap.Definition.TemplateName, message.Version];
if (templateNode == null || childTemplateNode != null)
{
contentPropertyMap.Serialize(writer, childTemplateNode, value, message);
}
return;
}
foreach (var propertyMap in propertyMaps)
{
var childTemplateNode = templateNode?[propertyMap.Definition.TemplateName, message.Version];
if (templateNode == null || childTemplateNode != null)
{
propertyMap.Serialize(writer, childTemplateNode, value, message);
}
}
}
public abstract void Serialize(XmlWriter writer, IXmlTemplateNode templateNode, object value, IContentDefinition definition, XRoadMessage message);
public override object Deserialize(XmlReader reader, IXmlTemplateNode templateNode, IContentDefinition definition, XRoadMessage message)
{
var entity = new T();
entity.SetTemplateMembers(templateNode.ChildNames);
var validateRequired = definition is RequestValueDefinition;
if (contentPropertyMap != null)
{
ReadPropertyValue(reader, contentPropertyMap, templateNode[contentPropertyMap.Definition.TemplateName, message.Version], message, validateRequired, entity);
return(entity);
}
var properties = propertyMaps.GetEnumerator();
if (reader.IsEmptyElement)
{
ValidateRemainingProperties(properties, definition);
return(MoveNextAndReturn(reader, entity));
}
var parentDepth = reader.Depth;
var itemDepth = parentDepth + 1;
reader.Read();
while (parentDepth < reader.Depth)
{
if (reader.NodeType != XmlNodeType.Element || reader.Depth != itemDepth)
{
reader.Read();
continue;
}
var propertyNode = MoveToProperty(reader, properties, templateNode, message, validateRequired);
ReadPropertyValue(reader, properties.Current, propertyNode, message, validateRequired, entity);
}
ValidateRemainingProperties(properties, definition);
return(entity);
}
