Merge pull request #19 from Cambio-Project/42-generate-pattern-view-d…

…ynamically-based-on-psp-structure

42 generate pattern view dynamically based on psp structure

src/app/core/services/dashboard.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { DashboardService } from './dashboard.service';
+
+describe('DashboardService', () => {
+  let service: DashboardService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(DashboardService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

src/app/core/services/dashboard.service.ts

@@ -0,0 +1,31 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { Predicate } from 'src/app/modules/requirement-optimizer/components/property-edit-dynamic/property-edit-dynamic.component';
+
+// TODO add support for docker network
+const DASBOARD_SCENARIO_REFINEMENT_URL = 'http://localhost:3000/api/updateScenarioPredicates';
+
+@Injectable({
+	providedIn: 'root'
+})
+export class DashboardService {
+
+	constructor(private http: HttpClient) { }
+
+	updateScenarioResponse(simId: string, responseIndex: number, predicates: Predicate[]) {
+		const formattedPredicates = predicates.map(predicate => {
+			return {
+				...predicate,
+				predicate_comparison_value: '' + predicate.predicate_comparison_value,
+			}
+		})
+		return this.http.post(DASBOARD_SCENARIO_REFINEMENT_URL,
+			{
+				sim_id: simId,
+				response_index: responseIndex,
+				predicates: formattedPredicates,
+			})
+
+	}
+
+}

src/app/core/services/validation.service.ts

@@ -1,5 +1,5 @@
 import { Injectable } from '@angular/core';
-import { ValidationResponse } from '../../shared/models/validation-response';
+import { ValidationResponse, PredicateRefinementResponse } from '../../shared/models/validation-response';
 import { Event } from '../../shared/psp/sel/event';
 import { Dataset } from 'src/app/shared/models/dataset';
 import { Property } from 'src/app/shared/psp/sel/property';
@@ -11,9 +11,10 @@ import { UpperTimeBound } from 'src/app/shared/psp/constraints/upper-time-bound'
 import { Absence } from 'src/app/shared/psp/sel/patterns/occurence/absence';
 import { Universality } from 'src/app/shared/psp/sel/patterns/occurence/universality';
 import { TimeBound } from 'src/app/shared/psp/constraints/time-bound';
+import { Predicate } from 'src/app/modules/requirement-optimizer/components/property-edit-dynamic/property-edit-dynamic.component';
 
-// const VERIFIER_URL = "http://localhost:5000";  // local
-const VERIFIER_URL = "http://localhost:8083";  // docker
+const VERIFIER_URL = "http://localhost:5000";  // local
+//const VERIFIER_URL = "http://localhost:8083";  // docker
 
 @Injectable({
 	providedIn: 'root'
@@ -36,9 +37,9 @@ export class ValidationService {
 			],
 			"measurement_source": "csv",
 			"measurement_points": dataset.measurementPoints,
-            "options": {
-                "create_plots": false
-            }
+			"options": {
+				"create_plots": false
+			}
 		});
 		return this.sendRequest("monitor", request, predicate, dataset.file);
 	}
@@ -57,18 +58,107 @@ export class ValidationService {
 			"predicates_info": property.predicateInfos,
 			"measurement_source": "csv",
 			"measurement_points": dataset.measurementPoints,
-            "options": {
-                "create_plots": false
-            }
+			"options": {
+				"create_plots": false
+			}
 		});
 		return this.sendRequest("monitor", request, property, dataset.file).then(validationResponse => {
 			return validationResponse;
 		});
 	}
 
-    async refineTimeboundRemote(dataset: Dataset, property: Property): Promise<TimeBound | null> {
+	async validatePredicateDynamic(dataset: Dataset, predicateSpecification: string, predicate: Predicate): Promise<ValidationResponse> {
+		if (!predicateSpecification || !predicate) {
+			throw new Error('Invalid Predicate');
+		}
+
+		const predicateFormatted = {
+			...predicate,
+			predicate_comparison_value: "" + predicate.predicate_comparison_value
+		}
+
+		const request = JSON.stringify({
+			"behavior_description": "description",
+			"specification": predicateSpecification,
+			"specification_type": "mtl",
+			"predicates_info": [
+				predicateFormatted
+			],
+			"measurement_source": "csv",
+			"measurement_points": dataset.measurementPoints,
+			"options": {
+				"create_plots": false
+			}
+		});
+
+		console.log('validatePredicate');
+		console.log(request)
+
+		return this.sendRequest("monitor", request, null as any, dataset.file);
+	}
+
+	async validatePropertyDynamic(dataset: Dataset, tbv: string, predicates: Predicate[]) {
+
+		if (!tbv || !predicates) {
+			throw new Error('Invalid Property');
+		}
+
+		const predicatesFormatted = predicates.map(predicate => {
+			return {
+				...predicate,
+				predicate_comparison_value: "" + predicate.predicate_comparison_value
+			}
+		})
+
+		const request = JSON.stringify({
+			"behavior_description": "description",
+			"specification": tbv,
+			"specification_type": "tbv",
+			"predicates_info": predicatesFormatted,
+			"measurement_source": "csv",
+			"measurement_points": dataset.measurementPoints,
+			"options": {
+				"create_plots": false
+			}
+		});
+
+		console.log('validateProperty');
+		console.log(request)
+
+		return this.sendRequest("monitor", request, null as any, dataset.file).then(validationResponse => {
+			return validationResponse;
+		});
+	}
+
+	async refinePredicateRemoteDynamic(dataset: Dataset, tbv: string, predicates: Predicate[], predicateName: string, measurementSource: string): Promise<PredicateRefinementResponse> {
+
+		const predicatesFormatted = predicates.map(predicate => {
+			return {
+				...predicate,
+				predicate_comparison_value: "" + predicate.predicate_comparison_value
+			}
+		})
+
+		const request = JSON.stringify({
+			"behavior_description": "description",
+			"specification": tbv,
+			"specification_type": "tbv",
+			"predicates_info": predicatesFormatted,
+			"measurement_source": "csv",
+			"measurement_points": dataset.measurementPoints,
+		});
+
+		return this.sendPredicateRefinementRequest(
+			request,
+			dataset,
+			predicateName,
+			measurementSource
+		)
+	}
+
+	async refineTimeboundRemote(dataset: Dataset, property: Property): Promise<TimeBound | null> {
 
-        if (!property.propertySpecification || !property.predicateInfos) {
+		if (!property.propertySpecification || !property.predicateInfos) {
 			throw new Error('Invalid Property');
 		}
 
@@ -81,15 +171,15 @@ export class ValidationService {
 			"measurement_points": dataset.measurementPoints,
 		});
 
-        return this.sendRequest("refine_timebound", request, property, dataset.file)
-            .then(refinementResponse => {
-                if(refinementResponse.result === true) {
-			        return refinementResponse.timebound;
-                }
-                return null;
-		    });
+		return this.sendRequest("refine_timebound", request, property, dataset.file)
+			.then(refinementResponse => {
+				if (refinementResponse.result === true) {
+					return refinementResponse.timebound;
+				}
+				return null;
+			});
 
-    }
+	}
 
 	async refineTimebound(dataset: Dataset, property: Property): Promise<TimeBound | null> {
 		const pattern = property.getPattern();
@@ -108,9 +198,9 @@ export class ValidationService {
 				const propertyCandidate = Object.assign(Object.create(Object.getPrototypeOf(property)), property);
 				const patternCandidate = Object.assign(Object.create(Object.getPrototypeOf(pattern)), pattern);
 				const evaluatedTimebound = new Interval(
-                    new Event('Candidate' + lowerTimebound + ' to ' + upperTimebound),
-                    lowerTimebound, upperTimebound, 'time units'
-                );
+					new Event('Candidate' + lowerTimebound + ' to ' + upperTimebound),
+					lowerTimebound, upperTimebound, 'time units'
+				);
 				patternCandidate.setSTimeBound(evaluatedTimebound);
 				propertyCandidate.setPattern(patternCandidate);
 				const validationResponse = await this.validateProperty(dataset, propertyCandidate);
@@ -123,7 +213,7 @@ export class ValidationService {
 						refinedlowerTimebound = lowerTimebound = upperTimebound = refinedInterval.getLowerLimit();
 					} else {
 						lowerTimebound++;
-                    }
+					}
 				} else if (refinedUpperTimebound === -1) {
 					if (validationResponse.result === true) {
 						refinedUpperTimebound = upperTimebound;
@@ -154,6 +244,38 @@ export class ValidationService {
 		return null;
 	}
 
+	async refinePredicateRemote(dataset: Dataset, predicateName: string, property: Property): Promise<PredicateRefinementResponse> {
+		if (!property.propertySpecification || !property.predicateInfos) {
+			throw new Error('Invalid Property');
+		}
+		const pattern = property.getPattern();
+		if (!pattern) {
+			throw new Error('Invalid Pattern');
+		}
+		const event = pattern!.getEvents().find(event => event.getSpecification() === predicateName);
+		if (!event) {
+			throw new Error('Invalid Event');
+		}
+
+		console.log(event)
+
+		const request = JSON.stringify({
+			"behavior_description": "description",
+			"specification": property.propertySpecification,
+			"specification_type": "psp",
+			"predicates_info": property.predicateInfos,
+			"measurement_source": "csv",
+			"measurement_points": dataset.measurementPoints,
+		});
+
+		return this.sendPredicateRefinementRequest(
+			request,
+			dataset,
+			event.getName(),
+			event.getMeasurementSource()!
+		)
+	}
+
 	async refinePredicate(dataset: Dataset, predicateName: string, logicOperator: LogicOperator, property: Property) {
 		if (!requiresComparisonValue(logicOperator)) {
 			throw new Error('No refinement available for logic operators that do not require a comparison value');
@@ -193,7 +315,47 @@ export class ValidationService {
 		return Promise.all(promises);
 	}
 
-	private sendRequest(endpoint: string, request: string, validatedItem: Property | Event, file: File): Promise<ValidationResponse> {
+	private sendPredicateRefinementRequest(
+		request: string,
+		dataset: Dataset,
+		predicateName: string,
+		measurementName: string
+	): Promise<PredicateRefinementResponse> {
+		return new Promise((resolve, reject) => {
+			var formdata = new FormData();
+			formdata.append("formula_json", request);
+			formdata.append("file", dataset.file, dataset.file.name);
+
+			var requestOptions: RequestInit = {
+				method: 'POST',
+				body: formdata,
+				redirect: 'follow'
+			};
+
+			let url = VERIFIER_URL + "/refine_predicate";
+			url += `?predicate=${predicateName}&metric=${measurementName}`;
+
+			fetch(url, requestOptions)
+				.then(response => response.text())
+				.then(result => {
+					const response = JSON.parse(result);
+					const refinementResponse = new PredicateRefinementResponse(response);
+					console.log(refinementResponse);
+					resolve(refinementResponse);
+				})
+				.catch(error => {
+					console.log('error', error);
+					reject(error);
+				});
+		});
+	}
+
+	private sendRequest(
+		endpoint: string,
+		request: string,
+		validatedItem: Property | Event,
+		file: File,
+	): Promise<ValidationResponse> {
 		return new Promise((resolve, reject) => {
 			var formdata = new FormData();
 			formdata.append("formula_json", request);
@@ -205,14 +367,16 @@ export class ValidationService {
 				redirect: 'follow'
 			};
 
-            let url = VERIFIER_URL + "/" + endpoint;
+			let url = VERIFIER_URL + "/" + endpoint;
+
 			fetch(url, requestOptions)
 				.then(response => response.text())
 				.then(result => {
 					const response = JSON.parse(result);
-					const validationRespone = new ValidationResponse(response, validatedItem);
-					console.log(validationRespone);
-					resolve(validationRespone);
+					const validationResponse = new ValidationResponse(response, validatedItem);
+					console.log(validationResponse);
+					resolve(validationResponse);
+
 				})
 				.catch(error => {
 					console.log('error', error);