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(); }