private static void ProcessToOtherController(AutumnSettings settings, Operation operation,
ControllerActionDescriptor actionDescriptor)
{
if (operation.Parameters.Count > actionDescriptor.MethodInfo.GetParameters().Length)
{
operation.Parameters.Clear();
}
foreach (var parameterInfo in actionDescriptor.MethodInfo.GetParameters())
{
var parameterType = parameterInfo.ParameterType;
if (parameterType.IsGenericType && (typeof(IPageable <>).IsSubclassOfRawGeneric(parameterType) ||
typeof(Page <>).IsSubclassOfRawGeneric(parameterType)))
{
BuildPageableParameters(settings, operation, parameterType.GetGenericArguments()[0]);
}
if (!parameterType.IsGenericType ||
(!typeof(Expression <>).IsSubclassOfRawGeneric(parameterType)))
{
continue;
}
{
BuildQueryParameters(settings, operation);
}
}
}
public RepositoryControllerAsync(ICrudPageableRepositoryAsync <TEntity, TKey> repository,
AutumnSettings settings, IHttpContextAccessor httpContextAccessor)
{
_repository = repository;
_settings = settings ?? throw new ArgumentNullException(nameof(settings));
_entityInfo = _settings.DataSettings().EntitiesInfos[typeof(TEntity)];
_httpContextAccessor = httpContextAccessor;
}
public static AutumnDataSettings DataSettings(this AutumnSettings settings)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
return(dataSettings.GetOrAdd(settings, new AutumnDataSettings(settings)));
}
public MongoDBCrudPageableRepositoryAsync(AutumnSettings settings,
AutumnMongoDBSettings mongoDbSettings) :
base(settings)
{
_filterDefinitionBuilder = new FilterDefinitionBuilder <TEntity>();
var client = new MongoClient(mongoDbSettings.ConnectionString);
var database = client.GetDatabase(mongoDbSettings.Database);
var collectionInfo = mongoDbSettings.CollectionInfos[typeof(TEntity)];
_collection = database.GetCollection <TEntity>(collectionInfo.Name);
}
private static void BuildQueryParameters(AutumnSettings settings, Operation operation)
{
IParameter parameter = new NonBodyParameter
{
Type = "string",
In = "query",
Description = "Query to search (cf. http://tools.ietf.org/html/draft-nottingham-atompub-fiql-00)",
Name = settings.QueryField
};
operation.Parameters.Add(parameter);
}
private static void BuildPageableParameters(AutumnSettings settings, Operation operation, Type entityType)
{
var genericPageType = typeof(Page <>);
var pageType = genericPageType.MakeGenericType(entityType);
var schema = GetOrRegistrySchema(pageType, HttpMethod.Get, settings.NamingStrategy);
operation.Responses = new Dictionary <string, Response>
{
{ "200", new Response()
{
Schema = schema, Description = "OK"
} },
{ "206", new Response()
{
Schema = schema, Description = "Partial Content"
} }
};
IParameter parameter;
parameter = new NonBodyParameter
{
In = "query",
Type = "integer",
Minimum = 0,
Format = "int32",
Description = "Size of the page",
Default = settings.PageSize,
Name = settings.PageSizeField
};
operation.Parameters.Add(parameter);
parameter = new NonBodyParameter
{
In = "query",
Type = "integer",
Description = "Paging number (start to zero)",
Minimum = 0,
Format = "int32",
Default = 0,
Name = settings.PageNumberField
};
operation.Parameters.Add(parameter);
}
private static Expression <Func <T, bool> > GetOrRegistryQuery(string query, AutumnSettings autumnSettings)
{
lock (QueryExpressionHelper.QueriesCache)
{
if (string.IsNullOrWhiteSpace(query))
{
return(QueryExpressionHelper.True <T>());
}
var hash = Hash($"{typeof(T).FullName}?{query}");
if (QueryExpressionHelper.QueriesCache.TryGetValue(hash, out Expression <Func <T, bool> > result))
{
return(result);
}
var antlrInputStream = new AntlrInputStream(query);
var lexer = new QueryLexer(antlrInputStream);
var commonTokenStream = new CommonTokenStream(lexer);
var parser = new QueryParser(commonTokenStream);
var eval = parser.or();
var visitor = new DefaultQueryVisitor <T>(autumnSettings.NamingStrategy);
result = visitor.VisitOr(eval);
QueryExpressionHelper.QueriesCache.Set(hash, result);
return(result);
}
}
protected CrudPageableRepositoryAsync(AutumnSettings settings)
{
_parameter = Expression.Parameter(typeof(TEntity));
_settings = settings ?? throw new ArgumentNullException(nameof(settings));
_entityInfo = _settings.DataSettings().EntitiesInfos[typeof(TEntity)];
}
/// <summary>
/// initialize a new instance of controller
/// </summary>
/// <param name="repository"></param>
/// <param name="settings"></param>
/// <param name="httpContextAccessor"></param>
public DefaultCrudPageableRepositortyController(ICrudPageableRepositoryAsync <TEntity, TKey> repository,
AutumnSettings settings, IHttpContextAccessor httpContextAccessor, ILogger <TEntity> logger)
: base(repository, settings, httpContextAccessor)
{
_logger = logger;
}
public DefaultSwaggerOperationFilter(AutumnSettings settings) : base(settings)
{
}
public EntityFrameworkCrudPageableRepositoryAsync(AutumnSettings settings, DbContext dbContext) : base(settings)
{
_dbContext = dbContext;
}
public QueryModelBinder(AutumnSettings autumnSettings)
{
_autumnSettings = autumnSettings ?? throw new ArgumentNullException(nameof(autumnSettings));
}
public RespositoryControllerFeatureProvider(AutumnSettings settings)
{
_settings = settings ?? throw new ArgumentNullException(nameof(settings));
}
public AutumnDataSettings(AutumnSettings parent)
{
Parent = parent;
}
private static void ProcessToRepositoryControllerAsync(AutumnSettings settings, Operation operation,
ControllerActionDescriptor actionDescriptor)
{
// find entity type
var entityType = actionDescriptor.ControllerTypeInfo.GetGenericArguments()[0];
// find entity type info
if (!settings.DataSettings().ResourceInfos.ContainsKey(entityType))
{
return;
}
var resourceInfo = settings.DataSettings().ResourceInfos[entityType];
// register response swagger schema for GET request
var entitySchemaGet = GetOrRegistrySchema(entityType, HttpMethod.Get, settings.NamingStrategy);
// register request swagger schema for POST request
var entitySchemaPost = GetOrRegistrySchema(resourceInfo.ProxyRequestTypes[HttpMethod.Post], HttpMethod.Post, settings.NamingStrategy);
// register request swagger schema for PUT request
var entitySchemaPut = GetOrRegistrySchema(resourceInfo.ProxyRequestTypes[HttpMethod.Put], HttpMethod.Put, settings.NamingStrategy);
var errorSchemaBadRequest = GetOrRegistrySchema(typeof(ErrorModelBadRequest), HttpMethod.Get, settings.NamingStrategy);
var errorSchemaInternalErrorRequest = GetOrRegistrySchema(typeof(ErrorModelInternalError), HttpMethod.Get, settings.NamingStrategy);
operation.Responses = new ConcurrentDictionary <string, Response>();
// add generic reponse for internal error from server
operation.Responses.Add(((int)HttpStatusCode.BadRequest).ToString(), new Response()
{
Schema = errorSchemaBadRequest
});
// add generic reponse for internal error from server
operation.Responses.Add(((int)HttpStatusCode.InternalServerError).ToString(), new Response()
{
Schema = errorSchemaInternalErrorRequest
});
operation.Consumes.Clear();
IParameter parameter;
// create operation description in term of ActionName
switch (actionDescriptor.ActionName)
{
// operation is "Put"
case "Put":
operation.Consumes.Add(ConsumeContentType);
parameter = operation.Parameters.Single(p => p.Name == "id");
parameter.Description = "ID of the object to update";
parameter = operation.Parameters.Single(p => p.Name == "entityPutRequest");
parameter.Name = "entity";
parameter.Description = "New value of the object";
((BodyParameter)parameter).Schema = entitySchemaPut;
parameter.Required = true;
operation.Responses.Add(((int)HttpStatusCode.OK).ToString(),
new Response()
{
Schema = entitySchemaGet, Description = "Resource is Updated"
});
break;
case "Delete":
operation.Consumes.Add(ConsumeContentType);
parameter = operation.Parameters.Single(p => p.Name == "id");
parameter.Description = "ID of the object to delete";
parameter.Required = true;
operation.Responses.Add(((int)HttpStatusCode.OK).ToString(),
new Response()
{
Schema = entitySchemaGet, Description = "Resource is deleted"
});
break;
case "Post":
operation.Consumes.Add(ConsumeContentType);
parameter = operation.Parameters.Single(p => p.Name == "entityPostRequest");
parameter.Name = "entity";
parameter.Description = "Object to create";
parameter.Required = true;
((BodyParameter)parameter).Schema = entitySchemaPost;
operation.Responses.Add(((int)HttpStatusCode.Created).ToString(),
new Response()
{
Schema = entitySchemaGet, Description = "Resource is created"
});
break;
case "GetById":
parameter = operation.Parameters.Single(p => p.Name == "id");
parameter.Description = "ID of resource to search";
parameter.Required = true;
operation.Responses.Add(((int)HttpStatusCode.OK).ToString(),
new Response()
{
Schema = entitySchemaGet
});
operation.Responses.Add(((int)HttpStatusCode.NotFound).ToString(),
new Response()
{
Description = "Resource not Found"
});
break;
default:
operation.Parameters.Clear();
BuildQueryParameters(settings, operation);
BuildPageableParameters(settings, operation, entityType);
break;
}
}
public PageableModelBinderProvider(AutumnSettings autumnSettings)
{
_autumnSettings = autumnSettings ?? throw new ArgumentNullException(nameof(autumnSettings));
}
public SwaggerOperationFilter(AutumnSettings autumnSettings)
{
_autumnSettings = autumnSettings;
}
public SwaggerDocumentFilter(AutumnSettings settings)
{
_settings = settings ?? throw new ArgumentNullException(nameof(settings));
}
public IgnoreOperationMiddleware(RequestDelegate next, AutumnSettings settings)
{
_next = next;
_settings = settings;
}
