/
services.ts
128 lines (102 loc) · 3.4 KB
/
services.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
///<reference path="../references.ts"/>
module JSONForms{
declare var tv4;
class HashTable {
private hashes;
constructor() {
this.hashes = {}
}
put(key, value) {
this.hashes[JSON.stringify(key)] = value;
}
get(key) {
return this.hashes[JSON.stringify(key)];
}
}
export class Services {
private services: any = {};
add(service: IService): void {
this.services[service.getId()] = service;
}
get<T extends IService>(serviceId: ServiceId): T {
return this.services[serviceId];
}
}
export class ScopeProvider implements IScopeProvider {
constructor(private scope: ng.IScope) { }
getId():JSONForms.ServiceId {
return ServiceId.ScopeProvider;
}
getScope(): ng.IScope {
return this.scope;
}
}
export class PathResolverService implements IPathResolverService {
constructor(private resolver: PathResolver) { }
getId(): JSONForms.ServiceId {
return ServiceId.PathResolver;
}
getResolver() {
return this.resolver;
}
}
export class SchemaProvider implements ISchemaProvider {
constructor(private schema: SchemaElement) {
}
getId():JSONForms.ServiceId {
return ServiceId.SchemaProvider;
}
getSchema():SchemaElement {
return this.schema;
}
}
export class ValidationService implements IValidationService {
private validationResults = new HashTable();
getId(): ServiceId {
return ServiceId.Validation;
}
getResult(instance: any, dataPath: string): any {
if (this.validationResults.get(instance) == undefined) {
return undefined;
} else {
return this.validationResults.get(instance)[dataPath];
}
}
private convertAllDates(instance): void {
for(var prop in instance) {
if(instance.hasOwnProperty(prop)){
if (instance[prop] instanceof Date) {
instance[prop] = instance[prop].toString();
} else if (instance[prop] instanceof Object){
this.convertAllDates(instance[prop]);
}
}
}
}
validate(instance: any, schema: SchemaElement): void {
if (tv4 == undefined) {
return;
}
this.clear(instance);
this.convertAllDates(instance);
var results = tv4.validateMultiple(instance, schema);
results['errors'].forEach((error) => {
if (error['schemaPath'].indexOf("required") != -1) {
var propName = error['dataPath'] + "/" + error['params']['key'];
this.validationResults.get(instance)[propName] = "Required";
} else {
this.validationResults.get(instance)[error['dataPath']] = error['message'];
}
});
}
private clear(instance: any) { this.validationResults.put(instance, {}); }
}
export enum ServiceId {
Validation,
DataProvider,
SchemaProvider,
ScopeProvider,
RuleService,
PathResolver
}
}