public Metadata Apply(JObject input)
{
var metadata = input["metadata"].ToObject <JObject>();
var metadataType = MetadataTypeExtension.GetRawValue(metadata["metadataType"].ToObject <int>());
var fields = metadata["fields"].ToObject <List <FieldDTO> >();
var fieldList = fields.Select(f => new Field(f.Key, f.Value)).ToList();
Metadata metadataInfo = null;
switch (metadataType)
{
case MetadataType.ACCOUNT:
var address = Address.CreateFromHex(metadata["metadataId"].ToObject <string>());
metadataInfo = new AddressMetadata(fieldList, address);
break;
case MetadataType.NAMESPACE:
var namespaceId = new NamespaceId(metadata["metadataId"].ToObject <UInt64DTO>().ToUInt64());
metadataInfo = new NamespaceMetadata(fieldList, namespaceId);
break;
case MetadataType.MOSAIC:
var mosaicId = new MosaicId(metadata["metadataId"].ToObject <UInt64DTO>().ToUInt64());
metadataInfo = new MosaicMetadata(fieldList, mosaicId);
break;
case MetadataType.NONE:
break;
default:
throw new ArgumentOutOfRangeException();
}
return(metadataInfo);
}
private IEnumerable <OneWayRelation> GetRelations(NamespaceMetadata value)
{
foreach (var item in value.Types)
{
yield return(new OneWayRelation($"Namespace: {value.Id}", item.Id));
}
}
private static NamespaceBase ToBase(NamespaceMetadata metadata)
{
return(new NamespaceBase()
{
name = metadata.m_NamespaceName,
types = metadata.m_Types?.Select(ToBase)
});
}
public void TypesNamesTest()
{
NamespaceMetadata namespace1 = refl.AssemblyModel.Namespaces.ToList().ElementAt(0);
NamespaceMetadata namespace2 = refl.AssemblyModel.Namespaces.ToList().ElementAt(1);
Assert.AreEqual("Model", namespace1.Types.ToList().ElementAt(0).Name);
Assert.AreEqual("ClassWithAttribute", namespace2.Types.ToList().ElementAt(1).Name);
}
public VMNamespaceMetadata(NamespaceMetadata namespaceMetadata)
{
this.namespaceMetadata = namespaceMetadata;
if (CanLoadChildren())
{
Children.Add(null);
}
}
private static NamespaceDTG NamespaceDtg(NamespaceMetadata namespaceModel)
{
return(new NamespaceDTG()
{
Name = namespaceModel.Name,
MetadataName = namespaceModel.MetadataName,
Types = namespaceModel.Types?.Select(LoadType).ToList()
});
}
public NamespaceViewModel(NamespaceMetadata namespaceMetadata, [Import(typeof(Logger))] Logger logger)
{
this.logger = logger;
this.namespaceMetadata = namespaceMetadata;
if (CanLoadChildren())
{
Children.Add(null);
}
}
public void NamespaceTest()
{
Reflector reflector = new Reflector();
reflector.Reflect(path);
NamespaceMetadata _namespace = reflector.AssemblyModel.m_Namespaces.ToList()[0];
Assert.AreEqual(_namespace.m_Types.Count(), 5);
}
public void CopyCtorTest()
{
AssemblyMetadata tmpass = new AssemblyMetadata(Assembly.GetExecutingAssembly());
INamespaceMetadata tmp = tmpass.Namespaces.First();
NamespaceMetadata sut = new NamespaceMetadata(tmp);
Assert.IsTrue(tmp.Name.Equals(sut.Name));
Assert.AreEqual(tmp.SavedHash, sut.SavedHash);
Assert.AreEqual(tmp.Types.Count(), sut.Types.Count());
}
public void AmountOfPropertiesInTypesInNamespacesTest()
{
NamespaceMetadata namespaceMetadata2 = refl.AssemblyModel.Namespaces.ToList().ElementAt(1);
TypeMetadata typeMetadata1 = namespaceMetadata2.Types.ToList().ElementAt(3);
TypeMetadata typeMetadata2 = namespaceMetadata2.Types.ToList().ElementAt(1);
Assert.AreEqual(4, typeMetadata2.Methods.ToList().Count);
Assert.AreEqual(29, typeMetadata1.Methods.ToList().Count);
}
public NamespaceMetadataBase MapToSerialize(NamespaceMetadata metadata, Type namespaceMetadataType)
{
object namespaceMetadata = Activator.CreateInstance(namespaceMetadataType);
PropertyInfo nameProperty = namespaceMetadataType.GetProperty("NamespaceName");
PropertyInfo namespaceMetadatasProperty = namespaceMetadataType.GetProperty("Types", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
nameProperty?.SetValue(namespaceMetadata, metadata.NamespaceName);
namespaceMetadatasProperty?.SetValue(namespaceMetadata, ConvertionUtilities.ConvertList(namespaceMetadatasProperty.PropertyType.GetGenericArguments()[0],
metadata.Types.Select(t => new TypeMetadataMapper().MapToSerialize(t, namespaceMetadatasProperty.PropertyType.GetGenericArguments()[0])).ToList()));
return((NamespaceMetadataBase)namespaceMetadata);
}
public void CountMethodTest()
{
NamespaceMetadata n1 = refl.AssemblyModel.Namespaces.ToList().ElementAt(0);
NamespaceMetadata n2 = refl.AssemblyModel.Namespaces.ToList().ElementAt(1);
TypeMetadata typeMetadata1 = n1.Types.ToList().ElementAt(0);
TypeMetadata typeMetadata2 = n2.Types.ToList().ElementAt(1);
Assert.AreEqual(6, typeMetadata1.Methods.ToList().Count);
Assert.AreEqual(4, typeMetadata2.Methods.ToList().Count);
}
public void NameMethodTest()
{
NamespaceMetadata n1 = refl.AssemblyModel.Namespaces.ToList().ElementAt(0);
NamespaceMetadata n2 = refl.AssemblyModel.Namespaces.ToList().ElementAt(1);
TypeMetadata typeMetadata1 = n1.Types.ToList().ElementAt(0);
TypeMetadata typeMetadata2 = n2.Types.ToList().ElementAt(1);
Assert.AreEqual("get_Linq2SQL", typeMetadata1.Methods.ToList().ElementAt(0).Name);
Assert.AreEqual("Equals", typeMetadata2.Methods.ToList().ElementAt(1).Name);
}
public void NumberofParameterOfMethodTest()
{
NamespaceMetadata n1 = refl.AssemblyModel.Namespaces.ToList().ElementAt(0);
NamespaceMetadata n2 = refl.AssemblyModel.Namespaces.ToList().ElementAt(1);
TypeMetadata typeMetadata1 = n1.Types.ToList().ElementAt(0);
TypeMetadata typeMetadata2 = n2.Types.ToList().ElementAt(1);
Assert.AreEqual(1, typeMetadata1.Methods.ToList().ElementAt(3).Parameters.Count());
Assert.AreEqual(1, typeMetadata2.Methods.ToList().ElementAt(1).Parameters.Count());
}
public static NamespaceBaseDTO ToBaseDTO(this NamespaceMetadata metadata)
{
if (metadata == null)
{
return(null);
}
return(new NamespaceBaseDTO
{
NamespaceName = metadata.NamespaceName,
Types = CollectionToBaseDTO(metadata.Types, i => i.ToBaseDTO())
});
}
public BaseNamespace MapDown(NamespaceMetadata model, Type namespaceModelType)
{
object namespaceModel = Activator.CreateInstance(namespaceModelType);
PropertyInfo nameProperty = namespaceModelType.GetProperty("Name");
PropertyInfo namespaceModelsProperty = namespaceModelType.GetProperty("Types",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
nameProperty?.SetValue(namespaceModel, model.Name);
namespaceModelsProperty?.SetValue(namespaceModel,
Converter.ConvertList(namespaceModelsProperty.PropertyType.GetGenericArguments()[0],
model.Types.Select(t => new MapperType().MapDown(t, namespaceModelsProperty.PropertyType.GetGenericArguments()[0])).ToList()));
return((BaseNamespace)namespaceModel);
}
public void CorrectTypesInNamespaceMetadata()
{
AssemblyMetadata assemblyMetadata = new AssemblyMetadata(testAssembly);
NamespaceMetadata namespaceMetadata = assemblyMetadata.m_Namespaces.ToList <NamespaceMetadata>()[1];
List <string> typeNames = new List <string>(from _type in namespaceMetadata.m_Types
select _type.m_typeName);
Assert.IsTrue(typeNames.Contains("AbstractEnum"));
Assert.IsTrue(typeNames.Contains("AccessLevelEnum"));
Assert.IsTrue(typeNames.Contains("SealedEnum"));
Assert.IsTrue(typeNames.Contains("StaticEnum"));
Assert.IsTrue(typeNames.Contains("VirtualEnum"));
}
public NamespaceModel MapDown(NamespaceMetadata model, Type NamespaceMetadataType)
{
object NamespaceMetadata = Activator.CreateInstance(NamespaceMetadataType);
PropertyInfo nameProperty = NamespaceMetadataType.GetProperty("Name");
PropertyInfo NamespaceMetadatasProperty = NamespaceMetadataType.GetProperty("Types",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
nameProperty?.SetValue(NamespaceMetadata, model.Name);
NamespaceMetadatasProperty?.SetValue(NamespaceMetadata,
HelperClass.ConvertList(NamespaceMetadatasProperty.PropertyType.GetGenericArguments()[0],
model.Types.Select(t => new TypeModelMapper().MapDown(t, NamespaceMetadatasProperty.PropertyType.GetGenericArguments()[0])).ToList()));
return((NamespaceModel)NamespaceMetadata);
}
public NamespaceMetadata MapUp(BaseNamespace model)
{
NamespaceMetadata namespaceModel = new NamespaceMetadata();
namespaceModel.Name = model.Name;
Type type = model.GetType();
PropertyInfo typesProperty = type.GetProperty("Types",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
List <BaseType> types = (List <BaseType>)Helper.ConvertList(typeof(BaseType), (IList)typesProperty?.GetValue(model));
if (types != null)
{
namespaceModel.Types = types.Select(n => TypeMapper.EmitType(n)).ToList();
}
return(namespaceModel);
}
public NamespaceMetadata MapUp(NamespaceModel model)
{
NamespaceMetadata NamespaceMetadata = new NamespaceMetadata();
NamespaceMetadata.Name = model.Name;
Type type = model.GetType();
PropertyInfo typesProperty = type.GetProperty("Types",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
List <TypeModel> types = (List <TypeModel>)HelperClass.ConvertList(typeof(TypeModel), (IList)typesProperty?.GetValue(model));
if (types != null)
{
NamespaceMetadata.Types = types.Select(n => TypeModelMapper.EmitType(n)).ToList();
}
return(NamespaceMetadata);
}
public NamespaceMetadata MapToDeserialize(NamespaceMetadataBase metadata)
{
NamespaceMetadata namespaceMetadata = new NamespaceMetadata
{
NamespaceName = metadata.NamespaceName
};
Type type = metadata.GetType();
PropertyInfo typesProperty = type.GetProperty("Types", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
List <TypeMetadataBase> types = (List <TypeMetadataBase>)ConvertionUtilities.ConvertList(typeof(TypeMetadataBase), (IList)typesProperty?.GetValue(metadata));
if (types != null)
{
namespaceMetadata.Types = types.Select(n => TypeMetadataMapper.EmitTypeForDeserialization(n)).ToList();
}
return(namespaceMetadata);
}
public void TypesInMetadata()
{
AssemblyMetadata assemblyMeta = new AssemblyMetadata(assembly);
List <NamespaceMetadata> namespaceMetadata = assemblyMeta.Namespaces.ToList <NamespaceMetadata>();
NamespaceMetadata name = namespaceMetadata[0];
List <string> list = new List <string>(from Type in name.Types
select Type.Name);
Assert.IsTrue(list.Contains("Model"));
Assert.IsTrue(list.Contains("ServiceA"));
Assert.IsTrue(list.Contains("ServiceB"));
Assert.IsTrue(list.Contains("ServiceC"));
Assert.IsTrue(list.Contains("ViewModel"));
}
public static DTGNamespaceMetadata MapToDTGModel(NamespaceMetadata namespaceMetadata)
{
var m_NamespaceName = namespaceMetadata.NamespaceName;
//May be even more beneficial to create all types from all namespaces beforehand
foreach (var type in namespaceMetadata.Types)
{
HelperDictonaries.TypeDictonaryForDTG[type] = TypeMapper.MapToDTGModel(type);
}
var m_Types = from type in namespaceMetadata.Types orderby type.TypeName select TypeMapper.FillTypeDTG(HelperDictonaries.TypeDictonaryForDTG[type], type);
DTGNamespaceMetadata namespaceModel = new DTGNamespaceMetadata {
NamespaceName = m_NamespaceName,
Types = m_Types
};
return(namespaceModel);
}
internal NamespaceMetadata LoadNamespaceMetadata(string name, IEnumerable <Type> types, AssemblyMetadataStore metaStore)
{
if (string.IsNullOrWhiteSpace(name))
{
throw new ArgumentException($"{nameof(name)} is null/empty/whitespace");
}
NamespaceMetadata namespaceMetadata = new NamespaceMetadata()
{
Id = name,
Name = name
};
_logger.Trace("Adding Namespace to dictionary: " + namespaceMetadata.Name);
metaStore.NamespacesDictionary.Add(namespaceMetadata.Name, namespaceMetadata);
namespaceMetadata.Types = (from type in types orderby type.Name select LoadTypeMetadataDto(type, metaStore)).ToList();
return(namespaceMetadata);
}
public NamesapceTreeViewItem(NamespaceMetadata namespaceMetadata)
{
_namespaceMetadata = namespaceMetadata;
Name = "Namesapce " + _namespaceMetadata.NamespaceName;
}
private TreeItem MapItem(NamespaceMetadata value)
{
return(new TreeItem($"Namespace: {value.Id}", value.Types.Any()));
}
public NamespaceMetadataView(ILogger log, NamespaceMetadata namespaceMetadata) : base(log)
{
_namespaceMetadata = namespaceMetadata;
}
public NamespaceTreeViewItem(NamespaceMetadata namespaceMetadata)
{
this.namespaceMetadata = namespaceMetadata;
Name = namespaceMetadata.NamespaceName;
}
internal ReflectorTestClass() : base(TestAssemblyName)
{
Namespaces = this.m_AssemblyModel.m_Namespaces.ToDictionary <NamespaceMetadata, string>(x => x.m_NamespaceName);
MyNamespace = Namespaces.ContainsKey(m_NamespaceName) ? Namespaces["TPA.ApplicationArchitecture.Data"] : null;
}
public void TypesInNamespacesCountTest()
{
NamespaceMetadata namespace1 = refl.AssemblyModel.Namespaces.ToList().ElementAt(2);
Assert.AreEqual(2, namespace1.Types.ToList().Count);
}
