public MetadataBuilderTests()
{
const Behavior behavior = Behavior.Strict;
var fixture = new Fixture();
var key = fixture.Create <string>();
var value = fixture.Create <string>();
_localServerName = Environment.MachineName.ToLower();
_ipAddressByServerName = Mock.Create <IReadOnlyDictionary <string, string> >(behavior);
_ipAddressByServerNameEnumerator = Mock.Create <IEnumerator <KeyValuePair <string, string> > >(behavior);
_keyValuePair = new KeyValuePair <string, string>(key, value);
_ipAddress = _keyValuePair.Value;
_remoteServerNames = new List <string> {
_keyValuePair.Key
};
_ping = Mock.Create <Ping>(behavior);
_pingReply = Mock.Create <PingReply>(behavior);
_buffer = new byte[0];
_pingOptions = new PingOptions(ttl: 64, dontFragment: true);
_timeout = 1;
_configurationMetadata = Mock.Create <IConfigurationMetadata>(behavior);
_pingCreator = Mock.Create <IPingCreator>(behavior);
_pingReplyEvaluator = Mock.Create <IPingReplyEvaluator>(behavior);
_testObject = new MetadataBuilder(_configurationMetadata, _pingCreator, _pingReplyEvaluator);
}
public static IMetadataBuilder AddGridSpan(this IMetadataBuilder builder, int column, int row)
{
Ensure.NotNull(builder, "builder");
return(builder
.AddGridColumnSpan(column)
.AddGridRowSpan(row));
}
public Metadata Create(string destination, string fileName, string exifToolPath)
{
var fullPath = Path.Combine(destination, fileName);
var document = new XDocument(GetFullXml(fullPath, exifToolPath));
var fileSize = (string)document.Descendants(SystemNamespace + "FileSize").FirstOrDefault();
var fileType = (string)document.Descendants(FileNamespace + "FileType").FirstOrDefault();
var mimeType = (string)document.Descendants(FileNamespace + "MIMEType").FirstOrDefault();
var type = mimeType.ToLower().Split('/')[0];
switch (type)
{
case "image":
builder = new ImageMetadataBuilder(document, fileSize, fileType, mimeType);
builder.SetCreateDate();
builder.SetModifyDate();
builder.SetImageWidth();
builder.SetImageHeight();
builder.SetImageSize();
break;
case "document":
builder = new DocumentMetadataBuilder(document, fileSize, fileType, mimeType);
builder.SetCreateDate();
builder.SetModifyDate();
break;
}
return(builder.GetMetadata());
}
protected override void ApplyInternal(DescriptionAttribute attribute, IMetadataBuilder builder)
{
if (!builder.Has("Description"))
{
builder.Add("Description", attribute.Description);
}
}
/// <summary>
/// Creates an instance of <see cref="MemberMetadataBuilder"/>
/// </summary>
/// <param name="memberInfo">The member information to use</param>
/// <param name="successorMetadataBuilder">A succesor metadata builder to use</param>
/// <param name="isSkipped">A value that indicates whether a value must be skipped during binary serialization</param>
public MemberMetadataBuilder(IMemberInfo memberInfo,
IMetadataBuilder successorMetadataBuilder, bool isSkipped = false)
{
this._memberInfo = memberInfo;
this._successorMetadataBuilder = successorMetadataBuilder;
_isSkipped = isSkipped;
}
public static IMetadataBuilder Entity <TEntity>(
this IMetadataBuilder metadataBuilder,
Action <ITypeMetadataBuilder <TEntity> > typeBuilder)
{
typeBuilder.Invoke(metadataBuilder.Entity <TEntity>());
return(metadataBuilder);
}
protected override void ApplyInternal(RequiredAttribute attribute, IMetadataBuilder builder)
{
builder.Add("Required", true);
builder.Add("Required.AllowEmptyStrings", attribute.AllowEmptyStrings);
builder.Add("Required.ErrorMessage", attribute.ErrorMessage);
builder.Add("Required.Attribute", attribute);
}
/// <summary>
/// Converts database model to code model (AST).
/// </summary>
/// <param name="sqlBuilder">Database-specific <see cref="ISqlBuilder"/> instance.</param>
/// <param name="dataModel">Database model.</param>
/// <param name="metadataBuilder">Data model metadata builder.</param>
/// <param name="modelConverters">Optional AST post-processing converters.</param>
/// <returns>Code model as collection of code file models.</returns>
public CodeFile[] GenerateCodeModel(
ISqlBuilder sqlBuilder,
DatabaseModel dataModel,
IMetadataBuilder metadataBuilder,
params ConvertCodeModelVisitor[] modelConverters)
{
var generator = new DataModelGenerator(
Language,
dataModel,
metadataBuilder,
name => _namingServices.NormalizeIdentifier(_options.DataModel.FindParameterNameOptions, name),
sqlBuilder,
_options);
var files = generator.ConvertToCodeModel();
foreach (var converter in modelConverters)
{
for (var i = 0; i < files.Length; i++)
{
files[i] = (CodeFile)converter.Visit(files[i]);
}
}
return(files);
}
public void Add(IMetadataBuilder <AttributeMetadata> builder)
{
if (_attributes is null)
{
_attributes = new List <IMetadataBuilder <AttributeMetadata> >();
}
_attributes.Add(builder);
}
public void Apply(IMetadataBuilder builder)
{
if (column != null)
{
builder.AddGridColumn(column.Value);
}
if (row != null)
{
builder.AddGridRow(row.Value);
}
}
internal PropertyMetadata(EntityMetadata entity, IMetadataBuilder propBuilder)
: base(propBuilder.Name)
{
var clrProperty = entity.ClrType.GetProperty(propBuilder.Name);
Entity = entity;
Nullable = propBuilder.Nullable;
PropertyType = propBuilder.PropertyType?.ClrType ?? clrProperty?.PropertyType;
Default = _defaultValueCache.GetOrAdd(PropertyType, p => CreateDefaultValue(p));
HasClrProperty = clrProperty != null;
}
protected override void ApplyInternal(DisplayAttribute attribute, IMetadataBuilder builder)
{
builder.Add("Display.Name", attribute.Name);
builder.Add("Display.ShortName", attribute.ShortName);
if (!builder.Has("Description"))
{
builder.Add("Description", attribute.Description);
}
builder.Add("Display.Order", attribute.Order);
builder.Add("Display.Watermark", attribute.Prompt);
}
public void Apply(Attribute attribute, IMetadataBuilder builder)
{
Ensure.NotNull(attribute, "attribute");
Ensure.NotNull(builder, "builder");
T targetAttribute = attribute as T;
if (targetAttribute == null)
{
throw Ensure.Exception.InvalidOperation("Reader can process only attribute of type '{0}'", typeof(T).FullName);
}
ApplyInternal(targetAttribute, builder);
}
/// <summary>
/// Registeres metadata with specific <see cref="metadataBuilder"/>
///
///
/// <exception cref="MetadataRegistrationException"></exception>
/// <exception cref="MetadataAlreadyExistsException"></exception>
///
/// </summary>
/// <param name="metadataBuilder">The metadata builder</param>
protected internal void RegisterMetadata([NotNull] IMetadataBuilder metadataBuilder)
{
Guard.AgainstNullReference <MetadataRegistrationException>(metadataBuilder, "metadataBuilder",
NULL_METADATA_BUILDER_MESSAGE);
var metadataType = metadataBuilder.TypeToBuild;
if (TypeHelper.IsPrimitiveType(metadataType))
{
Guard.Throw <MetadataRegistrationException>(PRIMITIVE_TYPE_MESSAGE);
}
if (this._collection.ContainsKey(metadataBuilder.TypeToBuild))
{
Guard.Throw <MetadataAlreadyExistsException>(string.Format(METADATA_CONFLICT_MESSAGE_PATTERN, metadataBuilder.TypeToBuild));
}
this._collection.Add(metadataType, metadataBuilder.Build());
}
public void Entity_OnPersonTypeWithEntityBuilderAction_ShouldReturnMemberBuilder()
{
// Arrange
TypeCache typeCache = new TypeCache();
IMetadataBuilder builder = new MetadataBuilder(typeCache);
// Act
IMetadataBuilder entityBuilder = builder
.Entity <Person>(t =>
{
t.Property(p => p.FirstName).IsRequired();
t.Property(p => p.LastName).IsRequired();
t.Property(p => p.Positions).NonEditable();
})
.Entity <Position>(t =>
{
t.Property(p => p.Title).IsRequired().NonEditable();
t.Property(p => p.StartDate).IsRequired();
t.Property(p => p.EndDate).IsRequired();
});
// Assert
Assert.NotNull(entityBuilder);
}
public static IMetadataBuilder AddIsAutoFocus(this IMetadataBuilder builder, bool value)
{
return(builder.Add("IsAutoFocus", value));
}
protected override void ApplyInternal(StringLengthAttribute attribute, IMetadataBuilder builder)
{
builder.Add("StringLength.ErrorMessage", attribute.ErrorMessage);
builder.Add("StringLength.Minimum", attribute.MinimumLength);
builder.Add("StringLength.Maximum", attribute.MaximumLength);
}
protected abstract void OnModelCreating(IMetadataBuilder metadataBuilder);
protected override void ApplyInternal(DataTypeAttribute attribute, IMetadataBuilder builder)
{
builder.Add("DataType", attribute.DataType);
}
public MetadataModelBuilder()
{
_typeCache = new TypeCache();
_metadataBuilder = new MetadataBuilder(_typeCache);
}
/// <summary>
/// Creates an instance of <see cref="GenericCollectionTypeMetadataBuilder"/>
/// </summary>
/// <param name="metadataBuilder"></param>
public GenericCollectionTypeMetadataBuilder(IMetadataBuilder metadataBuilder)
{
this._metadataBuilder = metadataBuilder;
}
public IDictionary <IMetadataMember, MetadataToken> UnlockMetadata(IMetadataBuilder builder)
{
if (!IsLocked)
{
throw new InvalidOperationException("Cannot unlock the metadata if it has not already been locked.");
}
var image = Image;
// Construct new metadata streams.
var buffer = builder.Rebuild(image);
// Create resources.
NetDirectory.ResourcesManifest = buffer.ResourcesBuffer.CreateDirectory();
// Serialize new streams.
var newStreams = new MetadataStreamBuffer[]
{
buffer.TableStreamBuffer,
buffer.BlobStreamBuffer,
buffer.GuidStreamBuffer,
buffer.StringStreamBuffer,
buffer.UserStringStreamBuffer
}.ToDictionary(x => x, x => x.CreateStream());
// Determine new entrypoint token.
var newTokenMapping = buffer.TableStreamBuffer.GetNewTokenMapping();
uint entrypointToken;
if (image.ManagedEntrypoint == null)
{
entrypointToken = 0u;
}
else
{
if (newTokenMapping.TryGetValue(image.ManagedEntrypoint, out var token))
{
entrypointToken = token.ToUInt32();
}
else
{
throw new MemberNotImportedException(image.ManagedEntrypoint);
}
}
// Unlock metadata, commit changes to streams.
Image = null;
foreach (var entry in newStreams)
{
var header = StreamHeaders.FirstOrDefault(x => x.Name == entry.Key.Name);
if (header == null)
{
header = new MetadataStreamHeader(entry.Key.Name);
StreamHeaders.Add(header);
}
header.Stream = entry.Value;
}
// Update managed entrypoint.
NetDirectory.EntryPointToken = entrypointToken;
return(newTokenMapping);
}
/// <summary>
/// Creates an instance of <see cref="ArrayTypeMetadataBuilder"/>
/// </summary>
/// <param name="metadataBuilder">A metadata builder to use for elements of an array</param>
public ArrayTypeMetadataBuilder(IMetadataBuilder metadataBuilder)
{
Guard.AgainstNullReference <MetadataBuilderException>(metadataBuilder, "metadataBuilder", "Can't create enumeration metadata builder with null metadata builder");
this._metadataBuilder = metadataBuilder;
}
public MetadataEntry(Schema schema, IMetadataBuilder builder)
{
this.Schema = schema;
this.Builder = builder;
}
protected override void ApplyInternal(CompareAttribute attribute, IMetadataBuilder builder)
{
builder.Add("MatchProperty", attribute.OtherProperty);
builder.Add("MatchProperty.ErrorMessage", attribute.ErrorMessage);
builder.Add("MatchProperty.Attribute", attribute);
}
public void Apply(IMetadataBuilder builder)
{
builder.AddGridColumnSpan(Span);
}
protected override void ApplyInternal(DefaultValueAttribute attribute, IMetadataBuilder builder)
{
builder.Add("DefaultValue", attribute.Value);
}
public static IMetadataBuilder AddLabel(this IMetadataBuilder builder, string value)
{
return(builder.Add("Label", value));
}
public static IMetadataBuilder AddGridRowSpan(this IMetadataBuilder builder, int value)
{
Ensure.NotNull(builder, "builder");
return(builder.Add("Grid.RowSpan", value));
}
public static IMetadataBuilder AddIsReadOnly(this IMetadataBuilder builder, bool value)
{
return(builder.Add("IsReadOnly", value));
}
