private void ResolveAssetsUrls(ISchemaEntity schema, IGrouping <DomainId, ContentEntity> contents, ILookup <DomainId, IEnrichedAssetEntity> assets)
{
foreach (var field in schema.SchemaDef.ResolvingAssets())
{
foreach (var content in contents)
{
content.ReferenceData ??= new ContentData();
var fieldReference = content.ReferenceData.GetOrAdd(field.Name, _ => new ContentFieldData()) !;
if (content.Data.TryGetValue(field.Name, out var fieldData) && fieldData != null)
{
foreach (var(partitionKey, partitionValue) in fieldData)
{
var referencedAsset =
field.GetReferencedIds(partitionValue)
.Select(x => assets[x])
.SelectMany(x => x)
.FirstOrDefault();
if (referencedAsset != null)
{
IJsonValue array;
if (referencedAsset.Type == AssetType.Image)
{
var url = urlGenerator.AssetContent(
referencedAsset.AppId,
referencedAsset.Id.ToString());
array = JsonValue.Array(url, referencedAsset.FileName);
}
else
{
array = JsonValue.Array(referencedAsset.FileName);
}
requestCache.AddDependency(referencedAsset.UniqueId, referencedAsset.Version);
fieldReference.AddLocalized(partitionKey, array);
}
}
}
}
}
}
public async Task <IResultList <IContentEntity> > QueryAsync(IAppEntity app, ISchemaEntity schema, ODataUriParser odataQuery, Status[] status = null, bool useDraft = false)
{
try
{
var propertyCalculator = FindExtensions.CreatePropertyCalculator(schema.SchemaDef, useDraft);
var filter = FindExtensions.BuildQuery(odataQuery, schema.Id, status, propertyCalculator);
var contentCount = Collection.Find(filter).CountDocumentsAsync();
var contentItems =
Collection.Find(filter)
.ContentTake(odataQuery)
.ContentSkip(odataQuery)
.ContentSort(odataQuery, propertyCalculator)
.Not(x => x.DataText)
.ToListAsync();
await Task.WhenAll(contentItems, contentCount);
foreach (var entity in contentItems.Result)
{
entity.ParseData(schema.SchemaDef);
}
return(ResultList.Create <IContentEntity>(contentCount.Result, contentItems.Result));
}
catch (NotSupportedException)
{
throw new ValidationException("This odata operation is not supported.");
}
catch (NotImplementedException)
{
throw new ValidationException("This odata operation is not supported.");
}
catch (MongoQueryException ex)
{
if (ex.Message.Contains("17406"))
{
throw new DomainException("Result set is too large to be retrieved. Use $top parameter to reduce the number of items.");
}
else
{
throw;
}
}
}
private ClrQuery ParseOData(Context context, ISchemaEntity schema, string odata)
{
try
{
var model = BuildEdmModel(context, schema);
return(model.ParseQuery(odata).ToQuery());
}
catch (NotSupportedException)
{
throw new ValidationException("OData operation is not supported.");
}
catch (ODataException ex)
{
throw new ValidationException($"Failed to parse query: {ex.Message}", ex);
}
}
public static Task CanChangeStatus(ChangeContentStatus command,
IContentEntity content,
IContentWorkflow contentWorkflow,
IContentRepository contentRepository,
ISchemaEntity schema)
{
Guard.NotNull(command, nameof(command));
if (schema.SchemaDef.IsSingleton)
{
if (content.NewStatus == null || command.Status != Status.Published)
{
throw new DomainException(T.Get("contents.singletonNotChangeable"));
}
return(Task.CompletedTask);
}
return(Validate.It(async e =>
{
var status = content.NewStatus ?? content.Status;
if (!await contentWorkflow.CanMoveToAsync(content, status, command.Status, command.User))
{
var values = new { oldStatus = status, newStatus = command.Status };
e(T.Get("contents.statusTransitionNotAllowed", values), nameof(command.Status));
}
if (content.Status == Status.Published && command.CheckReferrers)
{
var hasReferrer = await contentRepository.HasReferrersAsync(content.AppId.Id, command.ContentId, SearchScope.Published);
if (hasReferrer)
{
throw new DomainException(T.Get("contents.referenced"));
}
}
if (command.DueTime.HasValue && command.DueTime.Value < SystemClock.Instance.GetCurrentInstant())
{
e(T.Get("contents.statusSchedulingNotInFuture"), nameof(command.DueTime));
}
}));
}
public ContentDataGraphType(ISchemaEntity schema, string schemaName, string schemaType, IGraphModel model)
{
Name = $"{schemaType}DataDto";
foreach (var(field, fieldName, typeName) in schema.SchemaDef.Fields.SafeFields())
{
var(resolvedType, valueResolver, args) = model.GetGraphType(schema, field, typeName);
if (valueResolver != null)
{
var displayName = field.DisplayName();
var fieldGraphType = new ObjectGraphType
{
Name = $"{schemaType}Data{typeName}Dto"
};
var partitioning = model.ResolvePartition(field.Partitioning);
foreach (var partitionKey in partitioning.AllKeys)
{
fieldGraphType.AddField(new FieldType
{
Name = partitionKey.EscapePartition(),
Arguments = args,
Resolver = ContentResolvers.Partition(valueResolver, partitionKey),
ResolvedType = resolvedType,
Description = field.RawProperties.Hints
});
}
fieldGraphType.Description = $"The structure of the {displayName} field of the {schemaName} content type.";
AddField(new FieldType
{
Name = fieldName,
Resolver = ContentResolvers.Field(field),
ResolvedType = fieldGraphType,
Description = $"The {displayName} field."
});
}
}
Description = $"The structure of the {schemaName} data type.";
}
public async Task <IResultList <IContentEntity> > QueryAsync(IAppEntity app, ISchemaEntity schema, Status[] status, bool inDraft, Query query, bool includeDraft = true)
{
Guard.NotNull(app, nameof(app));
Guard.NotNull(schema, nameof(schema));
Guard.NotNull(query, nameof(query));
using (Profiler.TraceMethod <MongoContentRepository>("QueryAsyncByQuery"))
{
var fullTextIds = await indexer.SearchAsync(query.FullText, app, schema.Id, inDraft?Scope.Draft : Scope.Published);
if (fullTextIds?.Count == 0)
{
return(ResultList.CreateFrom <IContentEntity>(0));
}
return(await contents.QueryAsync(schema, query, fullTextIds, status, inDraft, includeDraft));
}
}
///-------------------------------------------------------------------------------------------------
/// <summary>
/// Executes the model element constructor for type on a different thread, and waits for the
/// result.
/// </summary>
/// <exception cref="Exception">
/// Thrown when an exception error condition occurs.
/// </exception>
/// <param name="schemaElement">
/// The schema element.
/// </param>
/// <param name="implementedType">
/// Type of the implemented.
/// </param>
/// <returns>
/// An IModelEntity.
/// </returns>
///-------------------------------------------------------------------------------------------------
protected virtual IModelEntity InvokeModelElementConstructorForType(ISchemaEntity schemaElement, Type implementedType)
{
Contract.Requires(schemaElement, "schemaElement");
var ctor = ReflectionHelper.GetPublicConstructor(implementedType, new[] { typeof(IDomainModel), typeof(ISchemaEntity) });
if (ctor != null)
{
return((IModelEntity)ctor.Invoke(new object[] { DomainModel, schemaElement }));
}
ctor = ReflectionHelper.GetPublicConstructor(implementedType, new[] { typeof(IDomainModel) });
if (ctor != null)
{
return((IModelEntity)ctor.Invoke(new object[] { DomainModel }));
}
throw new ModelElementCreationException(String.Format(ExceptionMessages.UnableToCreateEntityOfTypeCtorWithIDomainModelRequiredFormat, implementedType));
}
public static async Task <ContentsDto> FromContentsAsync(IResultList <IEnrichedContentEntity> contents, Context context, ApiController controller,
ISchemaEntity schema, IContentWorkflow workflow)
{
var result = new ContentsDto
{
Total = contents.Total,
Items = contents.Select(x => ContentDto.FromContent(context, x, controller)).ToArray()
};
if (schema != null)
{
await result.AssignStatusesAsync(workflow, schema);
result.CreateLinks(controller, schema.AppId.Name, schema.SchemaDef.Name);
}
return(result);
}
public async Task <IContentEntity?> FindContentAsync(ISchemaEntity schema, Guid id, Status[]?status, bool includeDraft)
{
var find = Collection.Find(x => x.Id == id);
var contentEntity = await find.WithoutDraft(includeDraft).FirstOrDefaultAsync();
if (contentEntity != null)
{
if (contentEntity.IndexedSchemaId != schema.Id || status?.Contains(contentEntity.Status) == false)
{
return(null);
}
contentEntity?.ParseData(schema.SchemaDef, serializer);
}
return(contentEntity);
}
private ContentOperation Operation(ContentEntity content, ISchemaEntity operationSchema, ClaimsPrincipal?currentUser)
{
var serviceProvider =
new ServiceCollection()
.AddSingleton(contentRepository)
.AddSingleton(contentWorkflow)
.BuildServiceProvider();
return(new ContentOperation(serviceProvider, () => content)
{
App = Mocks.App(appId),
Command = new CreateContent {
User = currentUser, Actor = actor
},
CommandId = content.Id,
Schema = operationSchema
});
}
public ContentQueryParserTests()
{
var options = Options.Create(new ContentOptions {
DefaultPageSize = 30
});
requestContext = new Context(Mocks.FrontendUser(), Mocks.App(appId));
var schemaDef =
new Schema(schemaId.Name)
.AddString(1, "firstName", Partitioning.Invariant);
schema = Mocks.Schema(appId, schemaId, schemaDef);
var cache = new MemoryCache(Options.Create(new MemoryCacheOptions()));
sut = new ContentQueryParser(cache, JsonHelper.DefaultSerializer, options);
}
///-------------------------------------------------------------------------------------------------
/// <summary>
/// Creates entity core.
/// </summary>
/// <param name="id">
/// The identifier.
/// </param>
/// <param name="metaClass">
/// the meta class.
/// </param>
/// <param name="instance">
/// The instance.
/// </param>
/// <returns>
/// The new entity core.
/// </returns>
///-------------------------------------------------------------------------------------------------
protected virtual IModelElement CreateEntityCore(Identity id, ISchemaEntity metaClass, IModelEntity instance)
{
Contract.Requires(id, "id");
Contract.Requires(metaClass, "metaClass");
IModelElement result = instance;
CheckInitialized();
using (var session = EnsuresRunInSession())
{
result = L1Cache.CreateEntity(id, metaClass, instance);
if (session != null)
{
session.AcceptChanges();
}
return(result);
}
}
private OperationContext CreateContext(ContentEntity content, ISchemaEntity contextSchema, ClaimsPrincipal?currentUser)
{
var serviceProvider =
new ServiceCollection()
.AddSingleton(contentRepository)
.AddSingleton(contentWorkflow)
.BuildServiceProvider();
return(new OperationContext(serviceProvider)
{
Actor = actor,
App = Mocks.App(appId),
ContentProvider = () => content,
ContentId = content.Id,
Schema = contextSchema,
User = currentUser
});
}
public CachingSchemaProviderTests()
{
var schemaV1Mock = new Mock <ISchemaEntity>();
var schemaV2Mock = new Mock <ISchemaEntity>();
schemaV1Mock.Setup(x => x.Id).Returns(schemaId.Id);
schemaV1Mock.Setup(x => x.Name).Returns(schemaId.Name);
schemaV1Mock.Setup(x => x.AppId).Returns(appId.Id);
schemaV2Mock.Setup(x => x.Id).Returns(schemaId.Id);
schemaV2Mock.Setup(x => x.Name).Returns(schemaId.Name);
schemaV2Mock.Setup(x => x.AppId).Returns(appId.Id);
schemaV1 = schemaV1Mock.Object;
schemaV2 = schemaV2Mock.Object;
sut = new CachingSchemaProvider(cache, repository.Object);
}
public ContentDomainObjectTests()
{
app = Mocks.App(AppNamedId, Language.DE);
var scripts = new SchemaScripts
{
Change = "<change-script>",
Create = "<create-script>",
Delete = "<delete-script>",
Update = "<update-script>"
};
var schemaDef =
new Schema("my-schema")
.AddNumber(1, "my-field1", Partitioning.Invariant,
new NumberFieldProperties {
IsRequired = true
})
.AddNumber(2, "my-field2", Partitioning.Invariant,
new NumberFieldProperties {
IsRequired = false
})
.SetScripts(scripts);
schema = Mocks.Schema(AppNamedId, SchemaNamedId, schemaDef);
A.CallTo(() => appProvider.GetAppAsync(AppName, false))
.Returns(app);
A.CallTo(() => appProvider.GetAppWithSchemaAsync(AppId, SchemaId, false))
.Returns((app, schema));
A.CallTo(() => scriptEngine.TransformAsync(A <ScriptVars> ._, A <string> ._, ScriptOptions()))
.ReturnsLazily(x => Task.FromResult(x.GetArgument <ScriptVars>(0) !.Data !));
patched = patch.MergeInto(data);
var validators = Enumerable.Repeat(new DefaultValidatorsFactory(), 1);
var context = new ContentOperationContext(appProvider, validators, scriptEngine, A.Fake <ISemanticLog>());
sut = new ContentDomainObject(Store, A.Dummy <ISemanticLog>(), contentWorkflow, contentRepository, context);
sut.Setup(Id);
}
public ContentDataInputGraphType(ISchemaEntity schema, string schemaName, string schemaType, IGraphModel model)
{
Name = $"{schemaType}DataInputDto";
foreach (var(field, fieldName, typeName) in schema.SchemaDef.Fields.SafeFields().Where(x => x.Field.IsForApi(true)))
{
var resolvedType = model.GetInputGraphType(schema, field, typeName);
if (resolvedType != null)
{
var displayName = field.DisplayName();
var fieldGraphType = new InputObjectGraphType
{
Name = $"{schemaType}Data{typeName}InputDto"
};
var partitioning = model.ResolvePartition(field.Partitioning);
foreach (var partitionKey in partitioning.AllKeys)
{
fieldGraphType.AddField(new FieldType
{
Name = partitionKey.EscapePartition(),
ResolvedType = resolvedType,
Resolver = null,
Description = field.RawProperties.Hints
}).WithSourceName(partitionKey);
}
fieldGraphType.Description = $"The structure of the {displayName} field of the {schemaName} content input type.";
AddField(new FieldType
{
Name = fieldName,
ResolvedType = fieldGraphType,
Resolver = null,
Description = $"The {displayName} field."
}).WithSourceName(field.Name);
}
}
Description = $"The structure of the {schemaName} data input type.";
}
public static async Task CanDelete(ISchemaEntity schema, ContentState content, IContentRepository contentRepository, DeleteContent command)
{
Guard.NotNull(command, nameof(command));
if (schema.SchemaDef.IsSingleton)
{
throw new DomainException(T.Get("contents.singletonNotDeletable"));
}
if (command.CheckReferrers)
{
var hasReferrer = await contentRepository.HasReferrersAsync(content.AppId.Id, command.ContentId);
if (hasReferrer)
{
throw new DomainException(T.Get("contents.referenced"));
}
}
}
public async Task <IResultList <IContentEntity> > QueryAsync(IAppEntity app, ISchemaEntity schema, Q q)
{
using (Profiler.TraceMethod <MongoContentRepository>())
{
if (q.Ids != null && q.Ids.Count > 0)
{
return(await queryByIds.QueryAsync(app.Id, new List <ISchemaEntity> {
schema
}, q));
}
if (q.Referencing == default)
{
return(await queryByQuery.QueryAsync(app, schema, q));
}
return(ResultList.CreateFrom <IContentEntity>(0));
}
}
public async Task <IResultList <IContentEntity> > QueryAsync(IAppEntity app, ISchemaEntity schema, HashSet <Guid> ids, Status[] status = null)
{
var find =
status != null && status.Length > 0 ?
Collection.Find(x => x.IndexedSchemaId == schema.Id && ids.Contains(x.Id) && x.IsDeleted != true && status.Contains(x.Status)) :
Collection.Find(x => x.IndexedSchemaId == schema.Id && ids.Contains(x.Id));
var contentItems = find.Not(x => x.DataText).ToListAsync();
var contentCount = find.CountDocumentsAsync();
await Task.WhenAll(contentItems, contentCount);
foreach (var entity in contentItems.Result)
{
entity.ParseData(schema.SchemaDef, Serializer);
}
return(ResultList.Create <IContentEntity>(contentCount.Result, contentItems.Result));
}
public ContentQueryParserTests()
{
var options = Options.Create(new ContentOptions {
DefaultPageSize = 30
});
requestContext = new Context(Mocks.FrontendUser(), Mocks.App(appId));
var schemaDef =
new Schema(schemaId.Name)
.AddString(1, "firstName", Partitioning.Invariant)
.AddGeolocation(2, "geo", Partitioning.Invariant);
schema = Mocks.Schema(appId, schemaId, schemaDef);
var cache = new MemoryCache(Options.Create(new MemoryCacheOptions()));
sut = new ContentQueryParser(appProvider, textIndex, options, cache, TestUtils.DefaultSerializer);
}
public static async Task CanCreate(ISchemaEntity schema, IContentWorkflow contentWorkflow, CreateContent command)
{
Guard.NotNull(command, nameof(command));
if (schema.SchemaDef.IsSingleton && command.ContentId != schema.Id)
{
throw new DomainException(T.Get("contents.singletonNotCreatable"));
}
if (command.Publish && !await contentWorkflow.CanPublishOnCreateAsync(schema, command.Data, command.User))
{
throw new DomainException(T.Get("contents.workflowErorPublishing"));
}
Validate.It(e =>
{
ValidateData(command, e);
});
}
public static async Task CanCreate(ISchemaEntity schema, IContentWorkflow contentWorkflow, CreateContent command)
{
Guard.NotNull(command, nameof(command));
if (schema.SchemaDef.IsSingleton && command.ContentId != schema.Id)
{
throw new DomainException("Singleton content cannot be created.");
}
if (command.Publish && !await contentWorkflow.CanPublishOnCreateAsync(schema, command.Data, command.User))
{
throw new DomainException("Content workflow prevents publishing.");
}
Validate.It(() => "Cannot created content.", e =>
{
ValidateData(command, e);
});
}
public async Task <IResultList <IContentEntity> > QueryAsync(IAppEntity app, ISchemaEntity schema, Q q, SearchScope scope)
{
using (Profiler.TraceMethod <MongoContentRepository>())
{
if (q.Ids != null && q.Ids.Count > 0l)
{
return(await queryByIds.QueryAsync(app.Id, new List <ISchemaEntity> {
schema
}, q));
}
if (q.Referencing == default)
{
return(await queryByQuery.QueryAsync(app, schema, q, scope));
}
throw new NotSupportedException();
}
}
public async Task <IContentEntity?> DoAsync(ISchemaEntity schema, Guid id, Status[]?status, bool includeDraft)
{
Guard.NotNull(schema);
var find = Collection.Find(x => x.Id == id).WithoutDraft(includeDraft);
var contentEntity = await find.FirstOrDefaultAsync();
if (contentEntity != null)
{
if (contentEntity.IndexedSchemaId != schema.Id || !contentEntity.HasStatus(status))
{
return(null);
}
contentEntity?.ParseData(schema.SchemaDef, serializer);
}
return(contentEntity);
}
public async Task <IContentEntity?> QueryAsync(ISchemaEntity schema, DomainId id)
{
Guard.NotNull(schema, nameof(schema));
var documentId = DomainId.Combine(schema.AppId, id);
var find = Collection.Find(x => x.DocumentId == documentId);
var contentEntity = await find.FirstOrDefaultAsync();
if (contentEntity != null)
{
if (contentEntity.IndexedSchemaId != schema.Id)
{
return(null);
}
}
return(contentEntity);
}
public static void CanCreate(CreateContent command, ISchemaEntity schema)
{
Guard.NotNull(command, nameof(command));
if (schema.SchemaDef.IsSingleton)
{
if (command.ContentId != schema.Id)
{
throw new DomainException(T.Get("contents.singletonNotCreatable"));
}
}
Validate.It(e =>
{
if (command.Data == null)
{
e(Not.Defined(nameof(command.Data)), nameof(command.Data));
}
});
}
public async Task <IContentEntity?> DoAsync(ISchemaEntity schema, Guid id)
{
Guard.NotNull(schema, nameof(schema));
var find = Collection.Find(x => x.Id == id);
var contentEntity = await find.FirstOrDefaultAsync();
if (contentEntity != null)
{
if (contentEntity.IndexedSchemaId != schema.Id)
{
return(null);
}
contentEntity?.ParseData(schema.SchemaDef, converter);
}
return(contentEntity);
}
private IEnumerable <IContentEntity> TransformCore(QueryContext context, ISchemaEntity schema, IEnumerable <IContentEntity> contents)
{
using (Profiler.TraceMethod <ContentQueryService>())
{
var converters = GenerateConverters(context).ToArray();
var scriptText = schema.SchemaDef.Scripts.Query;
var isScripting = !string.IsNullOrWhiteSpace(scriptText);
foreach (var content in contents)
{
var result = SimpleMapper.Map(content, new ContentEntity());
if (result.Data != null)
{
if (!context.IsFrontendClient && isScripting)
{
var ctx = new ScriptContext {
User = context.User, Data = content.Data, ContentId = content.Id
};
result.Data = scriptEngine.Transform(ctx, scriptText);
}
result.Data = result.Data.ConvertName2Name(schema.SchemaDef, converters);
}
if (result.DataDraft != null && (context.Unpublished || context.IsFrontendClient))
{
result.DataDraft = result.DataDraft.ConvertName2Name(schema.SchemaDef, converters);
}
else
{
result.DataDraft = null;
}
yield return(result);
}
}
}
public async Task<ISchemaEntity> GetSchemaAsync(QueryContext context)
{
ISchemaEntity schema = null;
if (Guid.TryParse(context.SchemaIdOrName, out var id))
{
schema = await appProvider.GetSchemaAsync(context.App.Id, id);
}
if (schema == null)
{
schema = await appProvider.GetSchemaAsync(context.App.Id, context.SchemaIdOrName);
}
if (schema == null)
{
throw new DomainObjectNotFoundException(context.SchemaIdOrName, typeof(ISchemaEntity));
}
return schema;
}
private List <IContentEntity> TransformContent(ClaimsPrincipal user, ISchemaEntity schema, List <IContentEntity> contents)
{
var scriptText = schema.ScriptQuery;
if (!string.IsNullOrWhiteSpace(scriptText))
{
for (var i = 0; i < contents.Count; i++)
{
var content = contents[i];
var contentData = scriptEngine.Transform(new ScriptContext {
User = user, Data = content.Data, ContentId = content.Id
}, scriptText);
contents[i] = SimpleMapper.Map(content, new Content {
Data = contentData
});
}
}
return(contents);
}
private void GetEntity(ISchemaEntity entity)
{
CreateStorageEntity(entity);
CreateConceptualEntity(entity);
}
private EntityContainer.EntitySetLocalType CreateStorageEntitySet(ISchemaEntity entity, out bool isNewView)
{
//<EntitySet Name="Category" EntityType="PetShopModel1.Store.Category" store:Type="Tables" Schema="dbo" />
//<EntitySet Name="vw_aspnet_Applications" EntityType="PetShopModel1.Store.vw_aspnet_Applications" store:Type="Views" store:Schema="dbo" store:Name="vw_aspnet_Applications">
var entitySet = StorageSchemaEntityContainer.EntitySets.Where(e =>
(entity.EntityKeyName.Equals(e.Name, StringComparison.OrdinalIgnoreCase) && entity.SchemaName.Equals(e.Schema, StringComparison.OrdinalIgnoreCase)) ||
(entity.EntityKeyName.Equals(e.Name1, StringComparison.OrdinalIgnoreCase) && entity.SchemaName.Equals(e.Schema1, StringComparison.OrdinalIgnoreCase)) ||
entity.EntityKeyName.Equals(e.Name1, StringComparison.OrdinalIgnoreCase) || entity.EntityKeyName.Equals(e.Name, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
isNewView = entitySet == null && entity is ViewEntity;
if (entitySet == null) {
entitySet = new EntityContainer.EntitySetLocalType {
Name = entity.EntityKeyName
};
StorageSchemaEntityContainer.EntitySets.Add(entitySet);
}
_storageEntityNames[entity.EntityKeyName] = entitySet.Name;
// Set or sync the default values.
// http://msdn.microsoft.com/en-us/library/bb387152.aspx
entitySet.Name = entity.EntityKeyName;
entitySet.EntityType = String.Concat(StorageSchema.Namespace, ".", entity.EntityKeyName);
entitySet.Type = entity is TableEntity ? EdmxConstants.StorageSchemaGenerationTypeAttributeValueTables : null;
entitySet.Schema = entity is TableEntity ? entity.SchemaName : null;
if (entity is ViewEntity) {
entitySet.Type = EdmxConstants.StorageSchemaGenerationTypeAttributeValueViews;
entitySet.DefiningQuery = ((ViewEntity)entity).SourceText.Remove(0, ((ViewEntity)entity).SourceText.IndexOf("SELECT", StringComparison.OrdinalIgnoreCase));
} else
entitySet.Table = entity.EntityKeyName;
if (!String.IsNullOrEmpty(entitySet.Schema1))
entitySet.Schema1 = entity.SchemaName;
if (!String.IsNullOrEmpty(entitySet.Name1))
entitySet.Name1 = entity.EntityKeyName;
return entitySet;
}
private void CreateStorageEntityTypeProperties(ISchemaEntity entity, EntityTypeStore entityType)
{
//<Property Name="CategoryId" Type="varchar" Nullable="false" MaxLength="10" />
foreach (ISchemaProperty property in entity.Properties) {
var entityProperty = entityType.Properties.Where(p => property.KeyName.Equals(p.Name, StringComparison.OrdinalIgnoreCase) || property.KeyName.Equals(p.Name, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
if (entityProperty == null) {
if (ExcludeProperty(property))
continue;
entityProperty = new EntityProperty() {
Name = property.KeyName
};
entityType.Properties.Add(entityProperty);
_newStorageEntityProperties.Add(String.Format("{0}-{1}", entity.Name, property.Name));
} else if (ExcludeProperty(property)) {
entityType.Properties.Remove(entityProperty);
continue;
}
entityProperty.Name = property.KeyName;
entityProperty.Type = GetNativeType(property);
if (!property.IsNullable)
entityProperty.Nullable = property.IsNullable;
if (String.IsNullOrEmpty(entityProperty.DefaultValue) && !String.IsNullOrEmpty(property.DefaultValue)) {
if (property.DefaultValue.ToLowerInvariant().Contains("autoincrement")) // Needed for sql anywhere
entityProperty.DefaultValue = null;
else if (String.Equals(property.BaseSystemType, "System.Boolean", StringComparison.OrdinalIgnoreCase))
entityProperty.DefaultValue = property.DefaultValue.ToLower();
else if (String.Equals(property.BaseSystemType, "System.Single", StringComparison.OrdinalIgnoreCase)
|| String.Equals(property.BaseSystemType, "System.Int16", StringComparison.OrdinalIgnoreCase)
|| String.Equals(property.BaseSystemType, "System.Int32", StringComparison.OrdinalIgnoreCase)
|| String.Equals(property.BaseSystemType, "System.Int64", StringComparison.OrdinalIgnoreCase)
|| String.Equals(property.BaseSystemType, "System.Byte", StringComparison.OrdinalIgnoreCase)
|| String.Equals(property.BaseSystemType, "System.Decimal", StringComparison.OrdinalIgnoreCase)
|| String.Equals(property.BaseSystemType, "System.Double", StringComparison.OrdinalIgnoreCase)
|| String.Equals(property.BaseSystemType, "System.String", StringComparison.OrdinalIgnoreCase))
entityProperty.DefaultValue = property.DefaultValue;
else
entityProperty.DefaultValue = null;
} else {
entityProperty.DefaultValue = null;
}
entityProperty.MaxLength = !String.IsNullOrEmpty(GetMaxLength(property)) && !GetMaxLength(property).Equals("Max", StringComparison.OrdinalIgnoreCase) && !GetNativeType(property).Equals("timestamp", StringComparison.OrdinalIgnoreCase) ? GetMaxLength(property) : null;
entityProperty.StoreGeneratedPattern = property.IsIdentity ? EdmxConstants.StoreGeneratedPatternIdentity : property.IsComputed ? EdmxConstants.StoreGeneratedPatternComputed : null;
}
}
private EntityTypeStore CreateStorageEntityType(ISchemaEntity entity, string name, ref bool isNewView)
{
EntityTypeStore entityType = StorageSchema.EntityTypeStores.Where(e => ResolveStorageEntityName(entity.EntityKeyName).Equals(e.Name, StringComparison.OrdinalIgnoreCase) || name.Equals(e.Name, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
if (entityType == null) {
entityType = new EntityTypeStore() {
Name = name,
Key = new EntityKeyElement()
};
StorageSchema.EntityTypeStores.Add(entityType);
isNewView = entity is ViewEntity;
}
// Sync the name.
entityType.Name = name;
return entityType;
}
private void CreateStorageEntity(ISchemaEntity entity)
{
// Check to see if this has already been processed.
if (_storageEntitys.Contains(entity.EntityKey()))
return;
bool isNewView;
var entitySet = CreateStorageEntitySet(entity, out isNewView);
var entityType = CreateStorageEntityType(entity, entitySet.Name, ref isNewView);
// Remove the duplicate properties.
RemoveDuplicateStorageEntityTypeKeysAndProperties(entityType);
// Remove extra properties values.
var properties = from property in entityType.Properties
where !(from prop in entity.Properties select prop.KeyName).Contains(property.Name)
select property;
// Remove all of the key properties that don't exist in the table entity.
foreach (var property in properties) {
var propertyName = ResolveConceptualPropertyNameFromStorageColumnName(entityType.Name, property.Name);
_removedStorageEntityProperties.Add(String.Format(PROPERTY_KEY, entity.EntityKeyName, propertyName).ToLower());
entityType.Properties.Remove(property);
}
CreateStorageEntityTypeKeys(entity, isNewView, entityType);
CreateStorageEntityTypeProperties(entity, entityType);
_storageEntitys.Add(entity.EntityKeyName);
}
private static void CreateStorageEntityTypeKeys(ISchemaEntity entity, bool isNewView, EntityTypeStore entityType)
{
//<Key>
// <PropertyRef Name="CategoryId" />
//</Key>
if (entity.HasKey || isNewView) {
#region Remove extra key values.
var items = from property in entityType.Key.PropertyRefs
where !(from prop in entity.Key.Properties select prop.KeyName).Contains(property.Name)
select property;
// Remove all of the key properties that don't exist in the table entity.
foreach (var property in items) {
entityType.Key.PropertyRefs.Remove(property);
}
#endregion
foreach (var property in entity.Key.Properties.Where(p => entityType.Key.PropertyRefs.Count(pr => pr.Name == p.Name) == 0)) {
entityType.Key.PropertyRefs.Add(new PropertyRef() {
Name = property.KeyName
});
}
} else if (entity is TableEntity) {
entityType.Key.PropertyRefs.Clear();
}
}
