245 lines
8.5 KiB
TypeScript
245 lines
8.5 KiB
TypeScript
import { Observable } from "rxjs";
|
|
import { Injectable } from "@angular/core";
|
|
import { ApiService } from "./crud.service";
|
|
import {JSONSchema7} from "json-schema";
|
|
|
|
|
|
@Injectable({
|
|
providedIn: 'root',
|
|
})
|
|
export class JsonschemasService {
|
|
private rawSchemas: any | null = null;
|
|
|
|
constructor(
|
|
private apiService: ApiService
|
|
) {}
|
|
|
|
getSchemas(): Observable<Schema> {
|
|
return new Observable<Schema>((observer) => {
|
|
if (this.rawSchemas === null) {
|
|
this.apiService.getSchema().subscribe((jsonSchemas: any) => {
|
|
this.rawSchemas = jsonSchemas;
|
|
observer.next(this.rawSchemas)
|
|
});
|
|
} else {
|
|
observer.next(this.rawSchemas)
|
|
}
|
|
});
|
|
}
|
|
|
|
buildResource(resourceName: string) {
|
|
let resource;
|
|
|
|
resource = { ... this.rawSchemas.components.schemas[resourceName]};
|
|
resource.components = { schemas: {} };
|
|
for (let prop_name in resource.properties) {
|
|
let prop = resource.properties[prop_name];
|
|
|
|
if (prop_name === '_id') {
|
|
delete resource.properties[prop_name]
|
|
} else if (this.is_reference(prop)) {
|
|
this.resolveReference(resource, prop);
|
|
} else if (this.is_union(prop)) {
|
|
for (let i in prop.oneOf) {
|
|
this.resolveReference(resource, prop.oneOf[i]);
|
|
}
|
|
} else if (this.is_enum(prop)) {
|
|
for (let i in prop.allOf) {
|
|
this.resolveReference(resource, prop.allOf[i]);
|
|
}
|
|
} else if (this.is_array(prop) && this.is_reference(prop.items)) {
|
|
this.resolveReference(resource, prop.items);
|
|
}
|
|
}
|
|
|
|
return resource;
|
|
}
|
|
|
|
resolveReference(resource: any, prop_reference: any) {
|
|
let subresourceName = this.get_reference_name(prop_reference);
|
|
let subresource = this.buildResource(subresourceName);
|
|
resource.components.schemas[subresourceName] = subresource;
|
|
for (let subsubresourceName in subresource.components.schemas) {
|
|
if (! resource.components.schemas.hasOwnProperty(subsubresourceName)) {
|
|
resource.components.schemas[subsubresourceName] = subresource.components.schemas[subsubresourceName];
|
|
}
|
|
}
|
|
}
|
|
|
|
getReferencedSchema() {
|
|
|
|
}
|
|
|
|
getCreateResource(resourceName: string): Observable<Schema> {
|
|
return new Observable<Schema>((observer) => {
|
|
this.getSchemas().subscribe(() => {
|
|
observer.next(this.buildResource(resourceName + 'Create'))
|
|
})
|
|
})
|
|
}
|
|
|
|
getUpdateResource(resourceName: string): Observable<Schema> {
|
|
return new Observable<Schema>((observer) => {
|
|
this.getSchemas().subscribe(() => {
|
|
let resource = this.buildResource(resourceName + 'Read');
|
|
let updateResource = this.rawSchemas.components.schemas[resourceName + 'Update']
|
|
|
|
for (let prop_name in resource.properties) {
|
|
if (! updateResource.properties.hasOwnProperty(prop_name)) {
|
|
if (this.is_reference(resource.properties[prop_name])) {
|
|
let subresourceName = this.get_reference_name(resource.properties[prop_name]);
|
|
resource.components.schemas[subresourceName].readOnly = true;
|
|
} else {
|
|
resource.properties[prop_name].readOnly = true;
|
|
}
|
|
}
|
|
}
|
|
this.changePropertiesOrder(resource);
|
|
observer.next(resource);
|
|
})
|
|
})
|
|
}
|
|
|
|
changePropertiesOrder(resource: any) {
|
|
let created_at;
|
|
let updated_at;
|
|
let new_properties: any = {};
|
|
for (let prop_name in resource.properties) {
|
|
if (prop_name == 'created_at') {
|
|
created_at = resource.properties[prop_name];
|
|
} else if (prop_name == 'updated_at') {
|
|
updated_at = resource.properties[prop_name];
|
|
} else {
|
|
new_properties[prop_name] = resource.properties[prop_name];
|
|
}
|
|
}
|
|
if (created_at) {
|
|
new_properties['created_at'] = created_at;
|
|
}
|
|
if (updated_at) {
|
|
new_properties['updated_at'] = updated_at;
|
|
}
|
|
resource.properties = new_properties
|
|
}
|
|
|
|
private is_object(prop: any) {
|
|
return prop.hasOwnProperty('properties')
|
|
}
|
|
|
|
private is_reference(prop: any) {
|
|
return prop.hasOwnProperty('$ref');
|
|
}
|
|
|
|
private is_array(prop: any) {
|
|
return prop.hasOwnProperty('items');
|
|
}
|
|
|
|
private is_union(prop: any) {
|
|
return prop.hasOwnProperty('oneOf');
|
|
}
|
|
|
|
private is_enum(prop: any) {
|
|
return prop.hasOwnProperty('allOf');
|
|
}
|
|
|
|
private get_reference_name(prop: any) {
|
|
return prop['$ref'].substring(prop['$ref'].lastIndexOf('/')+1);
|
|
}
|
|
|
|
has_descendant(resource: JSONSchema7, property_name: string): boolean {
|
|
if (this.is_array(resource)) {
|
|
return property_name == 'items';
|
|
} else if (this.is_object(resource)) {
|
|
return property_name in resource.properties!;
|
|
} else if (this.is_reference(resource)) {
|
|
let subresourceName = this.get_reference_name(resource);
|
|
return this.has_descendant(this.buildResource(subresourceName), property_name);
|
|
} else if (this.is_union(resource)) {
|
|
for (const ref of resource.oneOf!) {
|
|
// @ts-ignore
|
|
if (this.has_descendant(ref, property_name)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
} else if (this.is_enum(resource)) {
|
|
for (const ref of resource.allOf!) {
|
|
// @ts-ignore
|
|
if (this.has_descendant(ref, property_name)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
throw new Error("Jsonschema format not implemented in property finder");
|
|
return false;
|
|
}
|
|
|
|
get_descendant(resource: JSONSchema7, property_name: string): JSONSchema7 {
|
|
if (this.is_array(resource) && property_name == 'items') {
|
|
// @ts-ignore
|
|
return resource.items;
|
|
} else if (this.is_object(resource) && property_name in resource.properties!) {
|
|
// @ts-ignore
|
|
return resource.properties[property_name];
|
|
} else if (this.is_reference(resource)) {
|
|
let subresourceName = this.get_reference_name(resource);
|
|
let subresource = this.buildResource(subresourceName);
|
|
return this.get_descendant(subresource, property_name);
|
|
} else if (this.is_union(resource)) {
|
|
for (const ref of resource.oneOf!) {
|
|
// @ts-ignore
|
|
if (this.has_descendant(ref, property_name)) {
|
|
// @ts-ignore
|
|
return this.get_descendant(ref, property_name);
|
|
}
|
|
}
|
|
} else if (this.is_enum(resource)) {
|
|
for (const ref of resource.allOf!) {
|
|
// @ts-ignore
|
|
if (this.has_descendant(ref, property_name)) {
|
|
// @ts-ignore
|
|
return this.get_descendant(ref, property_name);
|
|
}
|
|
}
|
|
}
|
|
throw new Error("property not found or Jsonschema format not implemented");
|
|
}
|
|
|
|
path_exists(resource: JSONSchema7, path: string): boolean{
|
|
const pointFirstPosition = path.indexOf('.')
|
|
if (pointFirstPosition == -1) {
|
|
return this.has_descendant(resource, path);
|
|
}
|
|
|
|
|
|
return this.has_descendant(resource, path.substring(0, pointFirstPosition))
|
|
&& this.path_exists(
|
|
this.get_descendant(
|
|
resource,
|
|
path.substring(0, pointFirstPosition)
|
|
),
|
|
path.substring(pointFirstPosition + 1)
|
|
);
|
|
}
|
|
|
|
get_property_by_path(resource: JSONSchema7, path: string): JSONSchema7 {
|
|
const pointFirstPosition = path.indexOf('.')
|
|
if (pointFirstPosition == -1) {
|
|
return this.get_descendant(resource, path);
|
|
}
|
|
|
|
return this.get_property_by_path(
|
|
this.get_descendant(
|
|
resource,
|
|
path.substring(0, pointFirstPosition)
|
|
),
|
|
path.substring(pointFirstPosition + 1)
|
|
);
|
|
}
|
|
}
|
|
|
|
export interface Schema {
|
|
components: { };
|
|
}
|