@valtimo/milestone 4.15.2-next-main.8

package/esm2015/lib/milestone.module.js

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2015-2020 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { NgModule } from '@angular/core';
+import { MilestoneComponent } from './milestone.component';
+import { MilestoneSetCreateComponent } from './milestone-set-create/milestone-set-create.component';
+import { RouterModule } from '@angular/router';
+import { MilestoneRoutingModule } from './milestone-routing.module';
+import { MilestoneListComponent } from './milestone-list/milestone-list.component';
+import { CommonModule } from '@angular/common';
+import { ListModule, WidgetModule } from '@valtimo/components';
+import { MilestoneCreateComponent } from './milestone-create/milestone-create.component';
+import { MilestoneEditComponent } from './milestone-edit/milestone-edit.component';
+import { MilestoneSetEditComponent } from './milestone-set-edit/milestone-set-edit.component';
+import { ReactiveFormsModule } from '@angular/forms';
+import { ColorPickerModule } from 'ngx-color-picker';
+import { TranslateModule } from '@ngx-translate/core';
+export class MilestoneModule {
+}
+MilestoneModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [MilestoneComponent, MilestoneSetCreateComponent, MilestoneListComponent,
+                    MilestoneCreateComponent, MilestoneEditComponent, MilestoneSetEditComponent],
+                imports: [
+                    RouterModule,
+                    MilestoneRoutingModule,
+                    CommonModule,
+                    ListModule,
+                    WidgetModule,
+                    ReactiveFormsModule,
+                    ColorPickerModule,
+                    TranslateModule
+                ],
+                exports: [MilestoneComponent]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/milestone.service.js

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2015-2020 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { ConfigService } from '@valtimo/config';
+import * as i0 from "@angular/core";
+import * as i1 from "@valtimo/config";
+import * as i2 from "@angular/common/http";
+export class MilestoneService {
+    constructor(configService, http) {
+        this.configService = configService;
+        this.http = http;
+        this.valtimoApiConfig = configService.config.valtimoApi;
+    }
+    getMilestones() {
+        return this.http.get(`${this.valtimoApiConfig.endpointUri}milestones`);
+    }
+    getMilestone(milestoneId) {
+        return this.http.get(`${this.valtimoApiConfig.endpointUri}milestones/${milestoneId}`);
+    }
+    createMilestone(milestone) {
+        return this.http.post(`${this.valtimoApiConfig.endpointUri}milestones`, milestone);
+    }
+    updateMilestone(milestone) {
+        return this.http.post(`${this.valtimoApiConfig.endpointUri}milestones`, milestone);
+    }
+    deleteMilestone(milestoneId) {
+        return this.http.delete(`${this.valtimoApiConfig.endpointUri}milestones/${milestoneId}`);
+    }
+    getMilestoneSets() {
+        return this.http.get(`${this.valtimoApiConfig.endpointUri}milestone-sets`);
+    }
+    getMilestoneSet(milestoneSetId) {
+        return this.http.get(`${this.valtimoApiConfig.endpointUri}milestone-sets/${milestoneSetId}`);
+    }
+    createMilestoneSet(milestoneSet) {
+        return this.http.post(`${this.valtimoApiConfig.endpointUri}milestone-sets`, milestoneSet);
+    }
+    updateMilestoneSet(milestoneSet) {
+        return this.http.post(`${this.valtimoApiConfig.endpointUri}milestone-sets`, milestoneSet);
+    }
+    deleteMilestoneSet(milestoneSetId) {
+        return this.http.delete(`${this.valtimoApiConfig.endpointUri}milestone-sets/${milestoneSetId}`);
+    }
+    getFlownodes(processDefinitionId) {
+        return this.http.get(`${this.valtimoApiConfig.endpointUri}milestones/${processDefinitionId}/flownodes`);
+    }
+}
+MilestoneService.ɵprov = i0.ɵɵdefineInjectable({ factory: function MilestoneService_Factory() { return new MilestoneService(i0.ɵɵinject(i1.ConfigService), i0.ɵɵinject(i2.HttpClient)); }, token: MilestoneService, providedIn: "root" });
+MilestoneService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+MilestoneService.ctorParameters = () => [
+    { type: ConfigService },
+    { type: HttpClient }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/public-api.js

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2015-2020 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/*
+ * Public API Surface of milestone
+ */
+export * from './lib/milestone.service';
+export * from './lib/milestone.component';
+export * from './lib/milestone.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3ZhbHRpbW8vbWlsZXN0b25lL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7OztHQWNHO0FBRUg7O0dBRUc7QUFFSCxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyx3QkFBd0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBDb3B5cmlnaHQgMjAxNS0yMDIwIFJpdGVuc2UgQlYsIHRoZSBOZXRoZXJsYW5kcy5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciBFVVBMLCBWZXJzaW9uIDEuMiAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqIGh0dHBzOi8vam9pbnVwLmVjLmV1cm9wYS5ldS9jb2xsZWN0aW9uL2V1cGwvZXVwbC10ZXh0LWV1cGwtMTJcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgYmFzaXMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbi8qXG4gKiBQdWJsaWMgQVBJIFN1cmZhY2Ugb2YgbWlsZXN0b25lXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9saWIvbWlsZXN0b25lLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvbWlsZXN0b25lLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9taWxlc3RvbmUubW9kdWxlJztcbiJdfQ==

package/esm2015/valtimo-milestone.js

@@ -0,0 +1,11 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+export { MilestoneCreateComponent as ɵc } from './lib/milestone-create/milestone-create.component';
+export { MilestoneEditComponent as ɵd } from './lib/milestone-edit/milestone-edit.component';
+export { MilestoneListComponent as ɵb } from './lib/milestone-list/milestone-list.component';
+export { MilestoneRoutingModule as ɵf } from './lib/milestone-routing.module';
+export { MilestoneSetCreateComponent as ɵa } from './lib/milestone-set-create/milestone-set-create.component';
+export { MilestoneSetEditComponent as ɵe } from './lib/milestone-set-edit/milestone-set-edit.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsdGltby1taWxlc3RvbmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy92YWx0aW1vL21pbGVzdG9uZS9zcmMvdmFsdGltby1taWxlc3RvbmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQztBQUU3QixPQUFPLEVBQUMsd0JBQXdCLElBQUksRUFBRSxFQUFDLE1BQU0sbURBQW1ELENBQUM7QUFDakcsT0FBTyxFQUFDLHNCQUFzQixJQUFJLEVBQUUsRUFBQyxNQUFNLCtDQUErQyxDQUFDO0FBQzNGLE9BQU8sRUFBQyxzQkFBc0IsSUFBSSxFQUFFLEVBQUMsTUFBTSwrQ0FBK0MsQ0FBQztBQUMzRixPQUFPLEVBQUMsc0JBQXNCLElBQUksRUFBRSxFQUFDLE1BQU0sZ0NBQWdDLENBQUM7QUFDNUUsT0FBTyxFQUFDLDJCQUEyQixJQUFJLEVBQUUsRUFBQyxNQUFNLDJEQUEyRCxDQUFDO0FBQzVHLE9BQU8sRUFBQyx5QkFBeUIsSUFBSSxFQUFFLEVBQUMsTUFBTSx1REFBdUQsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcblxuZXhwb3J0IHtNaWxlc3RvbmVDcmVhdGVDb21wb25lbnQgYXMgybVjfSBmcm9tICcuL2xpYi9taWxlc3RvbmUtY3JlYXRlL21pbGVzdG9uZS1jcmVhdGUuY29tcG9uZW50JztcbmV4cG9ydCB7TWlsZXN0b25lRWRpdENvbXBvbmVudCBhcyDJtWR9IGZyb20gJy4vbGliL21pbGVzdG9uZS1lZGl0L21pbGVzdG9uZS1lZGl0LmNvbXBvbmVudCc7XG5leHBvcnQge01pbGVzdG9uZUxpc3RDb21wb25lbnQgYXMgybVifSBmcm9tICcuL2xpYi9taWxlc3RvbmUtbGlzdC9taWxlc3RvbmUtbGlzdC5jb21wb25lbnQnO1xuZXhwb3J0IHtNaWxlc3RvbmVSb3V0aW5nTW9kdWxlIGFzIMm1Zn0gZnJvbSAnLi9saWIvbWlsZXN0b25lLXJvdXRpbmcubW9kdWxlJztcbmV4cG9ydCB7TWlsZXN0b25lU2V0Q3JlYXRlQ29tcG9uZW50IGFzIMm1YX0gZnJvbSAnLi9saWIvbWlsZXN0b25lLXNldC1jcmVhdGUvbWlsZXN0b25lLXNldC1jcmVhdGUuY29tcG9uZW50JztcbmV4cG9ydCB7TWlsZXN0b25lU2V0RWRpdENvbXBvbmVudCBhcyDJtWV9IGZyb20gJy4vbGliL21pbGVzdG9uZS1zZXQtZWRpdC9taWxlc3RvbmUtc2V0LWVkaXQuY29tcG9uZW50JzsiXX0=