void CompileFiles(ExtensionEntity ext, UxlEntity uxl)
{
foreach (var e in uxl.CopyFiles)
{
if (!Test(e.Condition))
{
continue;
}
if (e.Type != null)
{
string newType;
if (!_deprecated.TryGetValue(e.Type.Value.String, out newType))
{
newType = e.Type.Value.String;
}
ext.CopyFiles.Add(new CopyFile(e.SourceName, e.Flags, e.TargetName, e.Condition, new SourceValue(e.Type.Value.Source, newType)));
}
else
{
ext.CopyFiles.Add(e);
}
}
foreach (var e in uxl.ImageFiles)
{
if (Test(e.Condition))
{
ext.ImageFiles.Add(e);
}
}
}
void VisitExtension(ExtensionEntity f)
{
if (f.Status.HasFlag(EntityStats.RefCount))
{
return;
}
f.Status |= EntityStats.RefCount;
foreach (var e in f.RequiredEntities)
{
if (!Keep(e))
{
Log.Warning(f.Source, ErrorCode.W0000, "Invalid reference to entity " + e.Quote());
}
}
foreach (var e in f.RequiredTemplates)
{
VisitExtension(e);
}
foreach (var r in f.Requirements)
{
foreach (var e in r.Value)
{
Environment.Expand(e.Source, e.String, false, null, e.Usings);
}
}
foreach (var e in f.CopyFiles)
{
VisitFile(e);
}
}
void CompileRequirements(ExtensionEntity ext)
{
List <Element> elms;
if (ext.Requirements.TryGetValue("Entity", out elms))
{
foreach (var e in elms)
{
ext.RequiredEntities.Add(_ilf.GetEntity(e.Source, e.String, e.Usings));
}
}
if (ext.Requirements.TryGetValue("Template", out elms))
{
foreach (var e in elms)
{
ExtensionEntity template;
if (!_root.Templates.TryGetValue(e.String, out template))
{
Log.Error(e.Source, ErrorCode.E0000, "Template " + e.String.Quote() + " is not defined (on this backend)");
}
else
{
ext.RequiredTemplates.Add(template);
}
}
}
}
public void Should_WriteExtensionEntity()
{
var entity = new ExtensionEntity()
{
Key = "Abc",
ExtensionData = new Dictionary <string, JToken>()
{
{ nameof(Entity.IntValue), 123 },
{ nameof(Entity.LongValue), null },
{ nameof(Entity.StringValue), "Abc" },
{ nameof(Entity.DateTimeOffsetValue), DateTimeOffset.Now },
}
};
var tEntity = (ITableEntity)entity;
var result = tEntity.WriteEntity(new OperationContext());
result[nameof(Entity.IntValue)].PropertyAsObject.Should().Be(123L);
result[nameof(Entity.LongValue)].PropertyAsObject.Should().BeNull();
result[nameof(Entity.DateTimeOffsetValue)].PropertyAsObject.Should().NotBeNull();
result[nameof(Entity.StringValue)].PropertyAsObject.Should().Be("Abc");
result.Should().NotContainKey(nameof(entity.Key));
result.Should().NotContainKey(nameof(entity.PartitionKey));
result.Should().NotContainKey(nameof(entity.RowKey));
}
public void Create(ExtensionEntity extension)
{
extensionRepository.Create(new DalExtension()
{
Name = extension.Name
});
uow.Commit();
}
void CompileRequirements(ExtensionEntity ext)
{
ListDictionary <string, Element> deprecated = null;
foreach (var e in ext.Requirements)
{
string key;
if (_deprecated.TryGetValue(e.Key, out key))
{
foreach (var req in e.Value)
{
Log.Warning(req.Source, ErrorCode.W0000, e.Key.Quote() + " is deprecated -- please replace with " + key.Quote());
}
if (deprecated == null)
{
deprecated = new ListDictionary <string, Element>();
}
deprecated.Add(key, e.Value);
}
}
if (deprecated != null)
{
foreach (var e in deprecated)
{
ext.Requirements.AddRange(e.Key, e.Value);
}
}
List <Element> elms;
if (ext.Requirements.TryGetValue("Entity", out elms))
{
foreach (var e in elms)
{
ext.RequiredEntities.Add(_ilf.GetEntity(e.Source, e.String, e.Usings));
}
}
if (ext.Requirements.TryGetValue("Template", out elms))
{
foreach (var e in elms)
{
ExtensionEntity template;
if (!_root.Templates.TryGetValue(e.String, out template))
{
Log.Error(e.Source, ErrorCode.E0000, "Template " + e.String.Quote() + " is not defined (on this backend)");
}
else
{
ext.RequiredTemplates.Add(template);
}
}
}
}
void CompileExtensionElement(ExtensionEntity ext, string type, string key, UxlElement elm, Namescope[] usings)
{
if (elm.Type == UxlElementType.Require && _root.ElementDefinitions.Contains(key))
{
ext.Requirements.Add(key, new Element(elm.Value.Source, elm.Value.String, elm.Disambiguation, usings));
}
else
{
Log.Error(elm.Source, ErrorCode.E0000, "<" + elm.Type + " Key=\"" + key + "\"> is not valid in <" + type + "> (on this backend)");
}
}
void CompileTypeElement(ExtensionEntity ext, string type, string key, UxlElement elm, Namescope[] usings)
{
if (elm.Type == UxlElementType.Require && _root.TypeElementDefinitions.Contains(key))
{
ext.Requirements.Add(key, new Element(elm.Value.Source, elm.Value.String, elm.Disambiguation, usings));
}
else
{
CompileExtensionElement(ext, type, key, elm, usings);
}
}
void AddDependencies(string type, ExtensionEntity template, HashSet<string> foundLibs, HashSet<ExtensionEntity> foundTemplates, List<string> result)
{
if (foundTemplates.Contains(template))
return;
foundTemplates.Add(template);
foreach (var t in template.RequiredTemplates)
AddDependencies(type, t, foundLibs, foundTemplates, result);
foreach (var e in template.Requirements.GetList(type))
AddLibrary(type, e, foundLibs, foundTemplates, result);
}
void FlattenTemplate(ExtensionEntity template)
{
// For templates to support requiring other templates we need some special behaviour.
// If the template is introducing a new required template, flatten the new one first. Otherwise it would be lost.
foreach (var e in template.RequiredTemplates)
{
if (!_root.RequiredTemplates.Contains(e))
{
_root.RequiredTemplates.Add(e);
FlattenTemplate(e);
}
}
FlattenExtensionEntity(_root, template);
}
public void Should_ReadExtensionEntity()
{
var entity = new ExtensionEntity();
var tEntity = (ITableEntity)entity;
tEntity.ReadEntity(new Dictionary <string, EntityProperty>
{
{ nameof(Entity.IntValue), EntityProperty.GeneratePropertyForInt(123) },
{ nameof(Entity.LongValue), EntityProperty.GeneratePropertyForLong(null) },
{ nameof(Entity.StringValue), EntityProperty.GeneratePropertyForString("Abc") },
{ nameof(Entity.DateTimeOffsetValue), EntityProperty.GeneratePropertyForDateTimeOffset(DateTimeOffset.Now) },
}, new OperationContext());
entity.ExtensionData[nameof(Entity.IntValue)]
.ToObject <int>().Should().Be(123);
entity.ExtensionData[nameof(Entity.LongValue)]
.ToObject <long?>().Should().BeNull();
entity.ExtensionData[nameof(Entity.StringValue)]
.ToObject <string>().Should().Be("Abc");
entity.ExtensionData[nameof(Entity.DateTimeOffsetValue)]
.ToObject <DateTimeOffset>().Should().BeOnOrBefore(DateTimeOffset.Now);
}
void FlattenExtensionEntity(ExtensionEntity parent, ExtensionEntity child)
{
parent.CopyFiles.AddRange(child.CopyFiles);
parent.ImageFiles.AddRange(child.ImageFiles);
foreach (var e in child.Requirements)
{
if (_root.ElementDefinitions.Contains(e.Key))
{
parent.Requirements.AddRange(e.Key, e.Value);
}
}
foreach (var e in child.RequiredEntities)
{
parent.RequiredEntities.Add(e);
}
foreach (var e in child.RequiredTemplates)
{
parent.RequiredTemplates.Add(e);
}
}
void CompileTemplate(UxlTemplate uxl, Namescope[] usings)
{
if (!Test(uxl.Condition))
{
return;
}
var template = new ExtensionEntity(uxl.Name.Source, uxl.Name.String, uxl.Disambiguation);
Apply("Template", uxl.Name.String, template, _root.Templates);
foreach (var e in uxl.Elements)
{
string key;
if (!TryGetKey(e, out key) || !Test(e.Condition))
{
continue;
}
CompileExtensionElement(template, "Template", key, e, usings);
}
CompileFiles(template, uxl);
}
public void Delete(ExtensionEntity extension)
{
throw new System.NotImplementedException();
}
public static Extension ToMvcExtension(this ExtensionEntity user)
{
throw new NotImplementedException();
}
