public void Add(Type serviceType, Type requestType, Type responseType)
{
this.ServiceTypes.Add(serviceType);
this.RequestTypes.Add(requestType);
var restrictTo = requestType.FirstAttribute<RestrictAttribute>()
?? serviceType.FirstAttribute<RestrictAttribute>();
var operation = new Operation {
ServiceType = serviceType,
RequestType = requestType,
ResponseType = responseType,
RestrictTo = restrictTo,
Actions = GetImplementedActions(serviceType, requestType),
Routes = new List<RestPath>(),
};
this.OperationsMap[requestType] = operation;
this.OperationNamesMap[operation.Name.ToLower()] = operation;
//this.OperationNamesMap[requestType.Name.ToLower()] = operation;
if (responseType != null)
{
this.ResponseTypes.Add(responseType);
this.OperationsResponseMap[responseType] = operation;
}
//Only count non-core ServiceStack Services, i.e. defined outside of ServiceStack.dll or Swagger
var nonCoreServicesCount = OperationsMap.Values
.Count(x => x.ServiceType.Assembly != typeof(Service).Assembly
&& x.ServiceType.FullName != "ServiceStack.Api.Swagger.SwaggerApiService"
&& x.ServiceType.FullName != "ServiceStack.Api.Swagger.SwaggerResourcesService"
&& x.ServiceType.Name != "__AutoQueryServices");
LicenseUtils.AssertValidUsage(LicenseFeature.ServiceStack, QuotaType.Operations, nonCoreServicesCount);
}
public void Add(Type serviceType, Type requestType, Type responseType)
{
this.ServiceTypes.Add(serviceType);
this.RequestTypes.Add(requestType);
var restrictTo = requestType.FirstAttribute<RestrictAttribute>()
?? serviceType.FirstAttribute<RestrictAttribute>();
var operation = new Operation {
ServiceType = serviceType,
RequestType = requestType,
ResponseType = responseType,
RestrictTo = restrictTo,
Actions = GetImplementedActions(serviceType, requestType),
Routes = new List<RestPath>(),
};
this.OperationsMap[requestType] = operation;
this.OperationNamesMap[operation.Name.ToLower()] = operation;
//this.OperationNamesMap[requestType.Name.ToLower()] = operation;
if (responseType != null)
{
this.ResponseTypes.Add(responseType);
this.OperationsResponseMap[responseType] = operation;
}
LicenseUtils.AssertValidUsage(LicenseFeature.ServiceStack, QuotaType.Operations, OperationsMap.Count);
}
public void Add(Type serviceType, Type requestType, Type responseType)
{
this.ServiceTypes.Add(serviceType);
this.RequestTypes.Add(requestType);
var restrictTo = requestType.FirstAttribute<RestrictAttribute>()
?? serviceType.FirstAttribute<RestrictAttribute>();
var operation = new Operation {
ServiceType = serviceType,
RequestType = requestType,
ResponseType = responseType,
RestrictTo = restrictTo,
Actions = GetImplementedActions(serviceType, requestType),
Routes = new List<RestPath>(),
};
this.OperationsMap[requestType] = operation;
this.OperationNamesMap[requestType.Name.ToLower()] = operation;
if (responseType != null)
{
this.ResponseTypes.Add(responseType);
this.OperationsResponseMap[responseType] = operation;
}
}
public void Add(Type serviceType, Type requestType, Type responseType)
{
this.ServiceTypes.Add(serviceType);
this.RequestTypes.Add(requestType);
var restrictTo = requestType.FirstAttribute<RestrictAttribute>()
?? serviceType.FirstAttribute<RestrictAttribute>();
var reqFilterAttrs = new[] { requestType, serviceType }
.SelectMany(x => x.AllAttributes<IHasRequestFilter>()).ToList();
var resFilterAttrs = (responseType != null ? new[] { responseType, serviceType } : new[] { serviceType })
.SelectMany(x => x.AllAttributes<IHasResponseFilter>()).ToList();
var authAttrs = reqFilterAttrs.OfType<AuthenticateAttribute>().ToList();
var actions = GetImplementedActions(serviceType, requestType);
authAttrs.AddRange(actions.SelectMany(x => x.AllAttributes<AuthenticateAttribute>()));
var operation = new Operation
{
ServiceType = serviceType,
RequestType = requestType,
ResponseType = responseType,
RestrictTo = restrictTo,
Actions = actions.Map(x => x.Name.ToUpper()),
Routes = new List<RestPath>(),
RequestFilterAttributes = reqFilterAttrs,
ResponseFilterAttributes = resFilterAttrs,
RequiresAuthentication = authAttrs.Count > 0,
RequiredRoles = authAttrs.OfType<RequiredRoleAttribute>().SelectMany(x => x.RequiredRoles).ToList(),
RequiresAnyRole = authAttrs.OfType<RequiresAnyRoleAttribute>().SelectMany(x => x.RequiredRoles).ToList(),
RequiredPermissions = authAttrs.OfType<RequiredPermissionAttribute>().SelectMany(x => x.RequiredPermissions).ToList(),
RequiresAnyPermission = authAttrs.OfType<RequiresAnyPermissionAttribute>().SelectMany(x => x.RequiredPermissions).ToList(),
};
this.OperationsMap[requestType] = operation;
this.OperationNamesMap[operation.Name.ToLower()] = operation;
if (responseType != null)
{
this.ResponseTypes.Add(responseType);
this.OperationsResponseMap[responseType] = operation;
}
//Only count non-core ServiceStack Services, i.e. defined outside of ServiceStack.dll or Swagger
var nonCoreServicesCount = OperationsMap.Values
.Count(x => x.ServiceType.Assembly != typeof(Service).Assembly
&& x.ServiceType.FullName != "ServiceStack.Api.Swagger.SwaggerApiService"
&& x.ServiceType.FullName != "ServiceStack.Api.Swagger.SwaggerResourcesService"
&& x.ServiceType.Name != "__AutoQueryServices");
LicenseUtils.AssertValidUsage(LicenseFeature.ServiceStack, QuotaType.Operations, nonCoreServicesCount);
}
public static TableDefinition GetTableDefinition(Type modelType)
{
//Looks for PetaPoco's TableNameAtribute for the name of the table
//If no attribute is set we use the name of the Type as the default convention
var tableNameAttribute = modelType.FirstAttribute<TableNameAttribute>();
string tableName = tableNameAttribute == null ? modelType.Name : tableNameAttribute.Value;
var tableDefinition = new TableDefinition {Name = tableName};
var objProperties = modelType.GetProperties().ToList();
foreach (var propertyInfo in objProperties)
{
//If current property has an IgnoreAttribute then skip it
var ignoreAttribute = propertyInfo.FirstAttribute<IgnoreAttribute>();
if (ignoreAttribute != null) continue;
//If current property has a ResultColumnAttribute then skip it
var resultColumnAttribute = propertyInfo.FirstAttribute<ResultColumnAttribute>();
if (resultColumnAttribute != null) continue;
//Looks for ColumnAttribute with the name of the column, which would exist with ExplicitColumns
//Otherwise use the name of the property itself as the default convention
var columnAttribute = propertyInfo.FirstAttribute<ColumnAttribute>();
string columnName = columnAttribute != null ? columnAttribute.Name : propertyInfo.Name;
var columnDefinition = GetColumnDefinition(modelType, propertyInfo, columnName, tableName);
tableDefinition.Columns.Add(columnDefinition);
//Creates a foreignkey definition and adds it to the collection on the table definition
var foreignKeyAttributes = propertyInfo.MultipleAttribute<ForeignKeyAttribute>();
if (foreignKeyAttributes != null)
{
foreach (var foreignKeyAttribute in foreignKeyAttributes)
{
var foreignKeyDefinition = GetForeignKeyDefinition(modelType, propertyInfo, foreignKeyAttribute, columnName, tableName);
tableDefinition.ForeignKeys.Add(foreignKeyDefinition);
}
}
//Creates an index definition and adds it to the collection on the table definition
var indexAttribute = propertyInfo.FirstAttribute<IndexAttribute>();
if (indexAttribute != null)
{
var indexDefinition = GetIndexDefinition(modelType, propertyInfo, indexAttribute, columnName, tableName);
tableDefinition.Indexes.Add(indexDefinition);
}
}
return tableDefinition;
}
public virtual RazorPage TrackPage(Type pageType)
{
var pageBaseType = this.Config.PageBaseType;
var transformer = new RazorViewPageTransformer(pageBaseType);
var pagePath = pageType.FirstAttribute<VirtualPathAttribute>().VirtualPath.TrimStart('~');
var file = GetVirtualFile(pagePath);
var page = new RazorPage
{
PageHost = file != null ? CreatePageHost(file, transformer) : null,
PageType = pageType,
IsValid = true,
File = file,
VirtualPath = pagePath,
};
AddPage(page, pagePath);
return page;
}
public virtual RazorPage AddPage(Type pageType)
{
var virtualPathAttr = pageType.FirstAttribute<VirtualPathAttribute>();
if (virtualPathAttr == null || !this.IsWatchedFile(virtualPathAttr.VirtualPath))
return null;
var pagePath = virtualPathAttr.VirtualPath.TrimStart('~');
var page = GetPage(pagePath);
if (page != null)
return page;
return TrackPage(pageType);
}
public static Lazy<IContentType> GetContentTypeDefinition(Type modelType)
{
//Check for BaseType different from ContentTypeBase
bool hasParent = modelType.BaseType != null && modelType.BaseType != typeof(ContentTypeBase) && modelType.BaseType != typeof(object);
var parent = new Lazy<IContentType>();
if(hasParent)
{
var isResolved = _contentTypeCache.ContainsKey(modelType.BaseType.FullName);
parent = isResolved
? _contentTypeCache[modelType.BaseType.FullName].ContentType
: GetContentTypeDefinition(modelType.BaseType);
}
var contentTypeAttribute = modelType.FirstAttribute<ContentTypeAttribute>();
var contentTypeAlias = contentTypeAttribute == null ? modelType.Name.ToUmbracoAlias() : contentTypeAttribute.Alias;
//Check if ContentType already exists by looking it up by Alias.
var existing = ApplicationContext.Current.Services.ContentTypeService.GetContentType(contentTypeAlias);
Lazy<IContentType> contentType = contentTypeAttribute == null
? PlainPocoConvention(modelType, existing)
: ContentTypeConvention(contentTypeAttribute, modelType, existing);
//Check for interfaces that'll be used for ContentTypeComposition
var mixins = GetAliasesFromTypeInterfaces(modelType);
var definitions = new List<PropertyDefinition>();
int order = 0;
var objProperties = modelType.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly).ToList();
foreach (var propertyInfo in objProperties)
{
var propertyTypeAttribute = propertyInfo.FirstAttribute<PropertyTypeConventionAttribute>();
var definition = propertyTypeAttribute == null
? new PropertyDefinition()
: propertyTypeAttribute.GetPropertyConvention();
//DataTypeDefinition fallback
if(definition.DataTypeDefinition == null)
{
definition.DataTypeDefinition = Conventions.GetDataTypeDefinitionByAttributeOrType(null, propertyInfo.PropertyType);
}
if(string.IsNullOrEmpty(definition.PropertyGroup))
{
definition.PropertyGroup = "Generic Properties";
}
//Alias fallback
if (string.IsNullOrEmpty(definition.Alias))
{
var aliasAttribute = propertyInfo.FirstAttribute<AliasAttribute>();
definition.Alias = Conventions.GetPropertyTypeAlias(aliasAttribute, propertyInfo.Name);
definition.Name = Conventions.GetPropertyTypeName(aliasAttribute, propertyInfo.Name);
}
//Description fallback
if (string.IsNullOrEmpty(definition.Description))
{
var descriptionAttribute = propertyInfo.FirstAttribute<DescriptionAttribute>();
definition.Description = descriptionAttribute != null
? descriptionAttribute.Description
: string.Empty;
}
//SortOrder fallback
if (definition.Order == default(int))
{
var sortOrderAttribute = propertyInfo.FirstAttribute<SortOrderAttribute>();
definition.Order = sortOrderAttribute != null ? sortOrderAttribute.Order : order;
}
definitions.Add(definition);
order++;
}
//Loop through definitions for PropertyGroups and create those that not already exists
var groupDefinitions = definitions.DistinctBy(d => d.PropertyGroup);
foreach (var groupDefinition in groupDefinitions)
{
var groupExists = contentType.Value.PropertyGroups.Contains(groupDefinition.PropertyGroup);
if(groupExists == false)
{
var propertyGroup = new PropertyGroup {Name = groupDefinition.PropertyGroup};
contentType.Value.PropertyGroups.Add(propertyGroup);
}
}
//Loop through definitions for PropertyTypes and add them to the correct PropertyGroup
foreach (var definition in definitions)
{
var group = contentType.Value.PropertyGroups.First(x => x.Name == definition.PropertyGroup);
//Check if a PropertyType with the same alias already exists, as we don't want to override existing ones
if(group.PropertyTypes.Contains(definition.Alias)) continue;
var propertyType = new PropertyType(definition.DataTypeDefinition)
{
Mandatory = definition.Mandatory,
ValidationRegExp = definition.ValidationRegExp,
SortOrder = definition.Order,
Alias = definition.Alias,
Name = definition.Name
};
group.PropertyTypes.Add(propertyType);
}
//If current ContentType has a Parent the ParentId should be set and the ContentType added to the composition.
if(hasParent)
{
contentType.Value.SetLazyParentId(new Lazy<int>(() => parent.Value.Id));
contentType.Value.AddContentType(parent.Value);
}
//Add the resolved ContentType to the internal cache
var field = new DependencyField {ContentType = contentType, Alias = contentType.Value.Alias};
var dependencies = new List<string>();
//If current type has a parent (inherited model) we add the alias of that type as a dependency
if(hasParent)
{
dependencies.Add(parent.Value.Alias);
}
//Check ContentType for existing 'Allowed ContentTypes'
if(contentType.Value.AllowedContentTypes.Any())
{
dependencies.AddRange(contentType.Value.AllowedContentTypes.Select(allowed => allowed.Alias));
}
//Check for interfaces with AliasAttribute and add those as dependencies
//NOTE: might also be an idea to check if ContentType has already been created/added to cache that implements the interface.
if(mixins.Any())
{
foreach (var mixin in mixins)
{
if(dependencies.Contains(mixin.Item1)) continue;
dependencies.Add(mixin.Item1);
var isMixinResolved = _contentTypeCache.ContainsKey(mixin.Item2);
Lazy<IContentType> compositionType = null;
if (isMixinResolved)
{
compositionType = _contentTypeCache[mixin.Item2].ContentType;
}
else
{
GetContentTypeDefinition(mixin.Item3);
compositionType = _contentTypeCache[mixin.Item2].ContentType;
}
contentType.Value.AddContentType(compositionType.Value);
}
}
field.DependsOn = dependencies.ToArray();
_contentTypeCache.AddOrUpdate(modelType.FullName, field, (x, y) => field);
return contentType;
}
public virtual RazorPage TrackPage(Type pageType)
{
var pageBaseType = this.Config.PageBaseType;
var transformer = new RazorViewPageTransformer(pageBaseType);
var pagePath = pageType.FirstAttribute<VirtualPathAttribute>().VirtualPath.TrimStart('~');
var file = GetVirtualFile(pagePath);
var page = new RazorPage
{
PageHost = file != null ? new RazorPageHost(PathProvider, file, transformer, new CSharpCodeProvider(), new Dictionary<string, string>()) : null,
PageType = pageType,
IsValid = true,
File = file,
VirtualPath = pagePath,
};
AddPage(page, pagePath);
return page;
}
private static string GetNamespace(Type type)
{
var attr = type.FirstAttribute<SchemaAttribute>();
return attr != null ? attr.Name : type.Namespace;
}
/// <summary>
/// Gets the namespace from an attribute marked on the type's definition
/// </summary>
/// <param name="type"></param>
/// <returns>Namespace of type</returns>
public static string GetNamespace(Type type)
{
var dcAttr = type.FirstAttribute<DataContractAttribute>();
if (dcAttr != null)
{
return dcAttr.Namespace;
}
var xrAttr = type.FirstAttribute<XmlRootAttribute>();
if (xrAttr != null)
{
return xrAttr.Namespace;
}
var xtAttr = type.FirstAttribute<XmlTypeAttribute>();
if (xtAttr != null)
{
return xtAttr.Namespace;
}
var xeAttr = type.FirstAttribute<XmlElementAttribute>();
if (xeAttr != null)
{
return xeAttr.Namespace;
}
return null;
}
public virtual RazorPage TrackPage(Type pageType)
{
var pagePath = pageType.FirstAttribute<VirtualPathAttribute>().VirtualPath.TrimStart('~');
var page = new RazorPage { PageType = pageType, IsValid = true };
AddPage(page, pagePath);
return page;
}
public virtual RazorPage AddPage(Type pageType)
{
var virtualPathAttr = pageType.FirstAttribute<VirtualPathAttribute>();
if (virtualPathAttr == null || !this.IsWatchedFile(virtualPathAttr.VirtualPath))
return null;
var pagePath = virtualPathAttr.VirtualPath.TrimStart('~');
RazorPage page;
if (this.Pages.TryGetValue(GetDictionaryPagePath(pagePath), out page))
return page;
return TrackPage(pageType);
}
public override string ToCreateTableStatement(Type tableType)
{
var sbColumns = StringBuilderCache.Allocate();
var sbConstraints = StringBuilderCacheAlt.Allocate();
var sbMemOptimized = StringBuilderCacheAlt.Allocate();
var isMemoryTable = tableType.HasAttribute<SqlServerMemoryOptimizedAttribute>();
var modelDef = OrmLiteUtils.GetModelDefinition(tableType);
foreach (var fieldDef in modelDef.FieldDefinitions)
{
if (fieldDef.CustomSelect != null)
continue;
var columnDefinition = GetColumnDefinition(fieldDef);
if (columnDefinition == null)
continue;
var collationAttribs = fieldDef.PropertyInfo.GetAttributes<SqlServerCollateAttribute>();
if (collationAttribs.Count > 0)
{
columnDefinition += $" COLLATE {collationAttribs[0].Collation}";
}
if (isMemoryTable && fieldDef.IsPrimaryKey)
{
columnDefinition = columnDefinition.Replace("PRIMARY KEY", "PRIMARY KEY NONCLUSTERED");
var bucketCountAtribs = fieldDef.PropertyInfo.GetAttributes<SqlServerBucketCountAttribute>();
if (bucketCountAtribs.Count > 0)
{
columnDefinition += $" HASH WITH (BUCKET_COUNT={bucketCountAtribs[0].Count})";
}
}
if (sbColumns.Length != 0)
sbColumns.Append(", \n ");
sbColumns.Append(columnDefinition);
if (fieldDef.ForeignKey == null || OrmLiteConfig.SkipForeignKeys)
continue;
var refModelDef = OrmLiteUtils.GetModelDefinition(fieldDef.ForeignKey.ReferenceType);
sbConstraints.Append(
$", \n\n CONSTRAINT {GetQuotedName(fieldDef.ForeignKey.GetForeignKeyName(modelDef, refModelDef, NamingStrategy, fieldDef))} " +
$"FOREIGN KEY ({GetQuotedColumnName(fieldDef.FieldName)}) " +
$"REFERENCES {GetQuotedTableName(refModelDef)} ({GetQuotedColumnName(refModelDef.PrimaryKey.FieldName)})");
sbConstraints.Append(GetForeignKeyOnDeleteClause(fieldDef.ForeignKey));
sbConstraints.Append(GetForeignKeyOnUpdateClause(fieldDef.ForeignKey));
}
if (isMemoryTable)
{
var attrib = tableType.FirstAttribute<SqlServerMemoryOptimizedAttribute>();
sbMemOptimized.Append(" WITH (MEMORY_OPTIMIZED=ON");
if (attrib.Durability == SqlServerDurability.SchemaOnly)
sbMemOptimized.Append(", DURABILITY=SCHEMA_ONLY");
else if (attrib.Durability == SqlServerDurability.SchemaAndData)
sbMemOptimized.Append(", DURABILITY=SCHEMA_AND_DATA");
sbMemOptimized.Append(")");
}
var sql = $"CREATE TABLE {GetQuotedTableName(modelDef)} " +
$"\n(\n {StringBuilderCache.ReturnAndFree(sbColumns)}{StringBuilderCacheAlt.ReturnAndFree(sbConstraints)} \n){StringBuilderCache.ReturnAndFree(sbMemOptimized)}; \n";
return sql;
}
