()
15 | @Input() domainNetwork: string;
16 | @Input() tier: string;
17 | @Input() subNetwork: string;
18 |
19 | public btnDisabled(): boolean {
20 | return this.domainNetwork === undefined ||
21 | this.tier === undefined ||
22 | this.subNetwork === undefined;
23 | }
24 |
25 | public executeTrace(): void {
26 | this.traceBegan.emit(true);
27 | this._utilityNetworkService.subnetworkTrace(this.domainNetwork, this.tier , this.subNetwork)
28 | .then(results => this.traceComplete.emit(results))
29 | .catch(err=> console.log(err));
30 |
31 | }
32 | }
33 |
--------------------------------------------------------------------------------
/src/app/components/trace/trace.component.css:
--------------------------------------------------------------------------------
1 | .btn-no-focus:focus {
2 | outline: none;
3 | }
4 |
5 | .btn-size {
6 | width: 50px;
7 | height: 60px
8 | }
--------------------------------------------------------------------------------
/src/app/components/trace/trace.component.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
Tracing Options
6 |
9 |
10 |
11 |
--------------------------------------------------------------------------------
/src/app/components/trace/trace.component.spec.ts:
--------------------------------------------------------------------------------
1 | import { async, ComponentFixture, TestBed } from '@angular/core/testing';
2 |
3 | import { TraceComponent } from './trace.component';
4 |
5 | describe('TraceComponent', () => {
6 | let component: TraceComponent;
7 | let fixture: ComponentFixture;
8 |
9 | beforeEach(async(() => {
10 | TestBed.configureTestingModule({
11 | declarations: [ TraceComponent ]
12 | })
13 | .compileComponents();
14 | }));
15 |
16 | beforeEach(() => {
17 | fixture = TestBed.createComponent(TraceComponent);
18 | component = fixture.componentInstance;
19 | fixture.detectChanges();
20 | });
21 |
22 | it('should create', () => {
23 | expect(component).toBeTruthy();
24 | });
25 | });
26 |
--------------------------------------------------------------------------------
/src/app/components/trace/trace.component.ts:
--------------------------------------------------------------------------------
1 | import * as Constants from "../../models/constants";
2 | import { Component, Input, OnInit, Output, EventEmitter } from '@angular/core';
3 | import { TraceType } from '../../models/enums';
4 |
5 | @Component({
6 | selector: 'app-trace',
7 | templateUrl: './trace.component.html',
8 | styleUrls: ['./trace.component.css']
9 | })
10 | export class TraceComponent implements OnInit {
11 |
12 | @Input() traceType: TraceType;
13 | @Output() traceTypeChange = new EventEmitter();
14 |
15 | constructor() { }
16 |
17 | ngOnInit() {
18 | }
19 |
20 | public toggleUpstream(btnDownstream: HTMLElement, btnUpstream: HTMLElement): void {
21 | if (this.traceType !== TraceType.Upstream) {
22 | btnUpstream.setAttribute("style", Constants.ActiveButtonColor);
23 | btnDownstream.setAttribute("style", "");
24 | this.traceTypeChange.emit(TraceType.Upstream);
25 | } else {
26 | btnUpstream.setAttribute("style", "");
27 | this.traceTypeChange.emit(TraceType.Unknown);
28 | }
29 | }
30 |
31 | public toggleDownstream(btnDownstream: HTMLElement, btnUpstream: HTMLElement): void {
32 | if (this.traceType !== TraceType.Downstream) {
33 | btnDownstream.setAttribute("style", Constants.ActiveButtonColor);
34 | btnUpstream.setAttribute("style", "");
35 | this.traceTypeChange.emit(TraceType.Downstream);
36 | } else {
37 | btnDownstream.setAttribute("style", "");
38 | this.traceTypeChange.emit(TraceType.Unknown);
39 | }
40 | }
41 |
42 | }
43 |
--------------------------------------------------------------------------------
/src/app/models/constants.ts:
--------------------------------------------------------------------------------
1 | export const ActiveButtonColor = "background-color: #a6a6a6;";
2 | export const AppStorage_Token = 'appstorage_token';
3 | export const UserInfo = 'userinfo';
4 | export const SDEDefault = "sde.DEFAULT";
--------------------------------------------------------------------------------
/src/app/models/enums.ts:
--------------------------------------------------------------------------------
1 | export enum GeometryType {
2 | Polygon = "polygon",
3 | Polyline = "polyline",
4 | Point = "point"
5 | }
6 |
7 | export enum PhaseType {
8 | None = 0,
9 | A = 4,
10 | B = 2,
11 | C = 1,
12 | AB = 6,
13 | AC = 5,
14 | ABC = 7
15 | }
16 |
17 | export enum TraceType {
18 | Upstream = 'upstream',
19 | Downstream = 'downstream',
20 | Connected = 'connected',
21 | Subnetwork = 'subnetwork',
22 | Unknown = 'unknown',
23 | Loops = 'loops',
24 | Shortestpath = 'shortestpath',
25 | Subnetworkcontroller = 'subnetworkcontroller'
26 | }
27 |
28 | export enum TraceConditionBarrierType {
29 | NetworkAttribute = 'networkAttribute',
30 | Category = 'category',
31 | }
32 |
33 | export enum TraceConfigurationTraversabilityScope {
34 | Junctions = 'junctions',
35 | Edges = 'edges',
36 | JunctionsAndEdges = 'junctionsAndEdges',
37 | }
38 |
39 | export enum TraceFunctionBarrierFunctionType {
40 | Add = 'add',
41 | Subtract = 'subtract',
42 | Average = 'average',
43 | Count = 'count',
44 | Min = 'min',
45 | Max = 'max',
46 | }
47 |
48 | export enum TraceFunctionBarrierOperator {
49 | Equal = 'equal',
50 | NotEqual = 'notEqual',
51 | }
52 |
53 | export enum TraceOutputConditionType {
54 | NetworkAttribute = 'networkAttribute',
55 | Category = 'category',
56 | }
57 |
58 | export enum TraceLocationsTraceLocationType {
59 | StartingPoint = 'startingPoint',
60 | Barrier = 'barrier',
61 | }
--------------------------------------------------------------------------------
/src/app/models/featuretrace.ts:
--------------------------------------------------------------------------------
1 | import { GeometryType, PhaseType, TraceType } from '../models/enums';
2 |
3 | export class FeatureTrace implements IFeatureTrace {
4 | globalId: string;
5 | geometryType: GeometryType;
6 | traceType: TraceType;
7 | domainNetwork: string;
8 | tierName: string;
9 | phaseType: PhaseType;
10 |
11 | constructor(featureTrace: FeatureTrace) {
12 | Object.assign(this, featureTrace);
13 | }
14 | }
15 |
16 | export interface IFeatureTrace {
17 | globalId: string;
18 | geometryType: GeometryType;
19 | traceType: TraceType;
20 | domainNetwork: string;
21 | tierName: string;
22 | phaseType: PhaseType;
23 | }
--------------------------------------------------------------------------------
/src/app/models/functions.ts:
--------------------------------------------------------------------------------
1 | import { NetworkAttributeConditions } from "./networkattributeconditions";
2 |
3 | export class Functions implements IFunctions {
4 | functionType?: string | undefined;
5 | networkAttributeName?: string | undefined;
6 | networkAttributeConditions?: NetworkAttributeConditions[] | undefined;
7 | subnetworkAttributeName?: string | undefined;
8 | }
9 |
10 | export interface IFunctions {
11 | functionType?: string | undefined;
12 | networkAttributeName?: string | undefined;
13 | networkAttributeConditions?: NetworkAttributeConditions[] | undefined;
14 | subnetworkAttributeName?: string | undefined;
15 | }
--------------------------------------------------------------------------------
/src/app/models/nearestneighbor.ts:
--------------------------------------------------------------------------------
1 | export class NearestNeighbor implements INearestNeighbor {
2 | count?: number | undefined;
3 | costNetworkAttributeName?: string | undefined;
4 | nearestCategories?: string[] | undefined;
5 | nearestAssets?: string[] | undefined;
6 | }
7 |
8 | export interface INearestNeighbor {
9 | count?: number | undefined;
10 | costNetworkAttributeName?: string | undefined;
11 | nearestCategories?: string[] | undefined;
12 | nearestAssets?: string[] | undefined;
13 | }
--------------------------------------------------------------------------------
/src/app/models/networkattributeconditions.ts:
--------------------------------------------------------------------------------
1 | export class NetworkAttributeConditions implements INetworkAttributeConditions {
2 | networkAttributeName?: string | undefined;
3 | operator?: string | undefined;
4 | value?: number | undefined;
5 | combineUsingOr?: boolean | undefined;
6 | isTypeSpecificValue?: boolean | undefined;
7 | }
8 |
9 | export interface INetworkAttributeConditions {
10 | networkAttributeName?: string | undefined;
11 | operator?: string | undefined;
12 | value?: number | undefined;
13 | combineUsingOr?: boolean | undefined;
14 | isTypeSpecificValue?: boolean | undefined;
15 | }
--------------------------------------------------------------------------------
/src/app/models/networkmoments.ts:
--------------------------------------------------------------------------------
1 | export class NetworkMoments implements INetworkMoments {
2 | duration: number;
3 | moment?: string | undefined;
4 | time?: number | undefined;
5 | }
6 |
7 | /** Model for NetworkMoments */
8 | export interface INetworkMoments {
9 | duration: number;
10 | moment?: string | undefined;
11 | time?: number | undefined;
12 | }
--------------------------------------------------------------------------------
/src/app/models/phase.ts:
--------------------------------------------------------------------------------
1 | import { PhaseType } from "../models/enums";
2 |
3 | export class Phase implements IPhase {
4 | type: PhaseType;
5 | isActive: boolean;
6 |
7 | constructor(phase: Phase) {
8 | Object.assign(this, phase);
9 | }
10 | }
11 |
12 | export interface IPhase {
13 | type: PhaseType;
14 | isActive: boolean;
15 | }
--------------------------------------------------------------------------------
/src/app/models/querynetworkmoments.ts:
--------------------------------------------------------------------------------
1 | import { NetworkMoments } from './networkmoments';
2 |
3 | export class QueryNetworkMoments implements IQueryNetworkMoments {
4 | networkMoments: NetworkMoments[];
5 | success?: boolean | undefined;
6 | validNetworkTopology?: boolean | undefined;
7 | }
8 |
9 | /** Model for QueryNetworkMoments */
10 | export interface IQueryNetworkMoments {
11 | networkMoments: NetworkMoments[];
12 | success?: boolean | undefined;
13 | validNetworkTopology?: boolean | undefined;
14 | }
--------------------------------------------------------------------------------
/src/app/models/serviceerror.ts:
--------------------------------------------------------------------------------
1 | export class ServiceError {
2 | public error: ErrorDetails;
3 | }
4 |
5 | export interface ErrorDetails {
6 | code: number;
7 | message: string;
8 | details: string;
9 | }
--------------------------------------------------------------------------------
/src/app/models/session.ts:
--------------------------------------------------------------------------------
1 | export class Session {
2 | public static AuthToken: string;
3 | }
--------------------------------------------------------------------------------
/src/app/models/traceconditionbarrier.ts:
--------------------------------------------------------------------------------
1 | import { TraceConditionBarrierType } from './enums';
2 |
3 | export class TraceConditionBarrier implements ITraceConditionBarrier {
4 | name: string;
5 | type: TraceConditionBarrierType;
6 | operator: string;
7 | /** 0 = unknown, 1 = open, 2 = closed */
8 | value: number;
9 | combineUsingOr: boolean;
10 | isTypeSpecificValue: boolean;
11 | }
12 |
13 | export interface ITraceConditionBarrier {
14 | name: string;
15 | type: TraceConditionBarrierType;
16 | operator: string;
17 | /** 0 = unknown, 1 = open, 2 = closed */
18 | value: number;
19 | combineUsingOr: boolean;
20 | isTypeSpecificValue: boolean;
21 | }
--------------------------------------------------------------------------------
/src/app/models/traceconfiguration.ts:
--------------------------------------------------------------------------------
1 | import { Functions } from './functions';
2 | import { NearestNeighbor } from './nearestneighbor';
3 | import { TraceOuputFilter } from './traceoutputfilter';
4 | import { TraceOutputCondition } from './traceoutputcondition';
5 | import { TracePropagator } from './tracepropagator';
6 | import { TraceFunctionBarrier } from './tracefunctionbarrier';
7 | import { TraceConditionBarrier } from './traceconditionbarrier';
8 | import { TraceConfigurationTraversabilityScope } from './enums';
9 |
10 | export class TraceConfiguration implements ITraceConfiguration {
11 | includeContainers: boolean;
12 | includeContent: boolean;
13 | includeStructures: boolean;
14 | includeBarriers: boolean;
15 | validateConsistency: boolean;
16 | domainNetworkName: string;
17 | tierName: string;
18 | targetTierName: string;
19 | subnetworkName: string;
20 | diagramTemplateName: string;
21 | shortestPathNetworkAttributeName: string;
22 | filterBitsetNetworkAttributeName: string;
23 | traversabilityScope: TraceConfigurationTraversabilityScope;
24 | conditionBarriers: TraceConditionBarrier[];
25 | functionBarriers: TraceFunctionBarrier[];
26 | arcadeExpressionBarrier?: string | undefined;
27 | filterBarriers?: string[] | undefined;
28 | filterFunctionBarriers?: string[] | undefined;
29 | filterScope: string;
30 | functions?: Functions[] | undefined;
31 | nearestNeighbor?: NearestNeighbor | undefined;
32 | outputFilters?: TraceOuputFilter[] | undefined;
33 | outputConditions?: TraceOutputCondition[] | undefined;
34 | propagators?: TracePropagator[] | undefined;
35 | }
36 |
37 | export interface ITraceConfiguration {
38 | includeContainers: boolean;
39 | includeContent: boolean;
40 | includeStructures: boolean;
41 | includeBarriers: boolean;
42 | validateConsistency: boolean;
43 | domainNetworkName: string;
44 | tierName: string;
45 | targetTierName: string;
46 | subnetworkName: string;
47 | diagramTemplateName: string;
48 | shortestPathNetworkAttributeName: string;
49 | filterBitsetNetworkAttributeName: string;
50 | traversabilityScope: TraceConfigurationTraversabilityScope;
51 | conditionBarriers: TraceConditionBarrier[];
52 | functionBarriers: TraceFunctionBarrier[];
53 | arcadeExpressionBarrier?: string | undefined;
54 | filterBarriers?: string[] | undefined;
55 | filterFunctionBarriers?: string[] | undefined;
56 | filterScope: string;
57 | functions?: Functions[] | undefined;
58 | nearestNeighbor?: NearestNeighbor | undefined;
59 | outputFilters?: TraceOuputFilter[] | undefined;
60 | outputConditions?: TraceOutputCondition[] | undefined;
61 | propagators?: TracePropagator[] | undefined;
62 | }
--------------------------------------------------------------------------------
/src/app/models/tracefunctionbarrier.ts:
--------------------------------------------------------------------------------
1 | import { TraceFunctionBarrierFunctionType, TraceFunctionBarrierOperator } from './enums';
2 |
3 | export class TraceFunctionBarrier implements ITraceFunctionBarrier {
4 | /** Choose from a number of different calculation functions. */
5 | functionType: TraceFunctionBarrierFunctionType;
6 | /** Choose to filter by any network attribute defined in the system. */
7 | networkAttributeName: string;
8 | /** Choose from a number of different operators */
9 | operator: TraceFunctionBarrierOperator;
10 | /** Specific value of the input attribute type that, if discovered, will cause the termination */
11 | value: string;
12 | /** Calculates values in each direction as opposed to an overall global value. */
13 | useLocalValues: boolean;
14 | }
15 |
16 | export interface ITraceFunctionBarrier {
17 | /** Choose from a number of different calculation functions. */
18 | functionType: TraceFunctionBarrierFunctionType;
19 | /** Choose to filter by any network attribute defined in the system. */
20 | networkAttributeName: string;
21 | /** Choose from a number of different operators */
22 | operator: TraceFunctionBarrierOperator;
23 | /** Specific value of the input attribute type that, if discovered, will cause the termination */
24 | value: string;
25 | /** Calculates values in each direction as opposed to an overall global value. */
26 | useLocalValues: boolean;
27 | }
--------------------------------------------------------------------------------
/src/app/models/tracelocations.ts:
--------------------------------------------------------------------------------
1 | import { TraceLocationsTraceLocationType } from './enums';
2 |
3 | export class TraceLocations implements ITraceLocations {
4 | traceLocationType?: TraceLocationsTraceLocationType | undefined;
5 | globalId?: string | undefined;
6 | percentAlong?: number | undefined;
7 | terminalId?: number | undefined;
8 | }
9 |
10 | export interface ITraceLocations {
11 | traceLocationType?: TraceLocationsTraceLocationType | undefined;
12 | globalId?: string | undefined;
13 | percentAlong?: number | undefined;
14 | terminalId?: number | undefined;
15 | }
--------------------------------------------------------------------------------
/src/app/models/traceoutputcondition.ts:
--------------------------------------------------------------------------------
1 | import { TraceOutputConditionType } from './enums';
2 |
3 | export class TraceOutputCondition implements ITraceOutputCondition {
4 | name: string;
5 | type: TraceOutputConditionType;
6 | operator: string;
7 | value?: number | undefined;
8 | combineUsingOr?: boolean | undefined;
9 | isSpecificValue: boolean;
10 | }
11 |
12 | export interface ITraceOutputCondition {
13 | name: string;
14 | type: TraceOutputConditionType;
15 | operator: string;
16 | value?: number | undefined;
17 | combineUsingOr?: boolean | undefined;
18 | isSpecificValue: boolean;
19 | }
--------------------------------------------------------------------------------
/src/app/models/traceoutputfilter.ts:
--------------------------------------------------------------------------------
1 | export class TraceOuputFilter implements ITraceOuputFilter {
2 | networkSourceId: number;
3 | assetGroupCode: number;
4 | assetTypeCode: number;
5 | }
6 |
7 | export interface ITraceOuputFilter {
8 | networkSourceId: number;
9 | assetGroupCode: number;
10 | assetTypeCode: number;
11 | }
--------------------------------------------------------------------------------
/src/app/models/tracepayload.ts:
--------------------------------------------------------------------------------
1 | import { TraceType } from './enums';
2 | import { TraceLocations } from './tracelocations';
3 | import { TraceConfiguration } from './traceconfiguration';
4 |
5 | export class TracePayload implements ITracePayload {
6 | featureServiceUrl: string;
7 | gdbVersion: string;
8 | traceType: TraceType;
9 | traceLocations: TraceLocations[];
10 | traceConfiguration: TraceConfiguration;
11 |
12 | constructor(tracePayload: TracePayload) {
13 | Object.assign(this, tracePayload);
14 | }
15 | }
16 |
17 | export interface ITracePayload {
18 | featureServiceUrl: string;
19 | gdbVersion: string;
20 | traceType: TraceType;
21 | traceLocations: TraceLocations[];
22 | traceConfiguration: TraceConfiguration;
23 | }
--------------------------------------------------------------------------------
/src/app/models/tracepropagator.ts:
--------------------------------------------------------------------------------
1 | export class TracePropagator implements ITracePropagator {
2 | networkAttributeName: string;
3 | propagatorFunctionType: string;
4 | operator: string;
5 | value: number;
6 | propagatedAttributeName: string;
7 | }
8 |
9 | export interface ITracePropagator {
10 | networkAttributeName: string;
11 | propagatorFunctionType: string;
12 | operator: string;
13 | value: number;
14 | propagatedAttributeName: string;
15 | }
--------------------------------------------------------------------------------
/src/app/models/traceresultfeature.ts:
--------------------------------------------------------------------------------
1 | export class TraceResultFeature implements ITraceResultFeature {
2 | networkSourceId?: number | undefined;
3 | globalId?: string | undefined;
4 | objectId?: number | undefined;
5 | terminalId?: number | undefined;
6 | assetGroupCode: number;
7 | assetTypeCode: number | undefined; // custom property to keep track of AssetTypeId
8 |
9 | constructor(traceResultFeature: TraceResultFeature) {
10 | Object.assign(this, traceResultFeature);
11 | }
12 | }
13 |
14 | /** Model for Features */
15 | export interface ITraceResultFeature {
16 | networkSourceId?: number | undefined;
17 | globalId?: string | undefined;
18 | objectId?: number | undefined;
19 | terminalId?: number | undefined;
20 | assetGroupCode: number;
21 | }
--------------------------------------------------------------------------------
/src/app/models/traceresults.ts:
--------------------------------------------------------------------------------
1 | import { TraceResultFeature } from './traceresultfeature';
2 |
3 | export class TraceResults implements ITraceResults {
4 | traceResults?: TraceResults2 | undefined;
5 | globalFunctionResults?: string[] | undefined;
6 | isConsistent?: boolean | undefined;
7 | kFeaturesForKNNFound?: boolean | undefined;
8 | startingPointsIgnored?: boolean | undefined;
9 | warnings?: string[] | undefined;
10 | success?: boolean | undefined;
11 | layers: any[];
12 | }
13 |
14 | export interface ITraceResults {
15 | traceResults?: TraceResults2 | undefined;
16 | globalFunctionResults?: string[] | undefined;
17 | isConsistent?: boolean | undefined;
18 | kFeaturesForKNNFound?: boolean | undefined;
19 | startingPointsIgnored?: boolean | undefined;
20 | warnings?: string[] | undefined;
21 | success?: boolean | undefined;
22 | }
23 |
24 | export class TraceResults2 implements ITraceResults2 {
25 | features?: TraceResultFeature[] | undefined;
26 | diagramName?: string | undefined;
27 |
28 | constructor(traceResults2: TraceResults2) {
29 | Object.assign(this, traceResults2);
30 | }
31 | }
32 |
33 | export interface ITraceResults2 {
34 | features?: TraceResultFeature[] | undefined;
35 | diagramName?: string | undefined;
36 | }
--------------------------------------------------------------------------------
/src/app/models/unitem.ts:
--------------------------------------------------------------------------------
1 | export class UNItem {
2 | public id: string;
3 | public title: string;
4 | }
--------------------------------------------------------------------------------
/src/app/models/user.ts:
--------------------------------------------------------------------------------
1 | export class UserInfo {
2 | public username: string;
3 | public password: string;
4 | }
--------------------------------------------------------------------------------
/src/app/services/auth.service.spec.ts:
--------------------------------------------------------------------------------
1 | import { TestBed, inject } from '@angular/core/testing';
2 |
3 | import { AuthService } from './auth.service';
4 |
5 | describe('AuthService', () => {
6 | beforeEach(() => {
7 | TestBed.configureTestingModule({
8 | providers: [AuthService]
9 | });
10 | });
11 |
12 | it('should be created', inject([AuthService], (service: AuthService) => {
13 | expect(service).toBeTruthy();
14 | }));
15 | });
16 |
--------------------------------------------------------------------------------
/src/app/services/auth.service.ts:
--------------------------------------------------------------------------------
1 | import { Injectable } from '@angular/core';
2 | import { AppStorage_Token, UserInfo as UI } from '../models/constants';
3 | import { Router } from '@angular/router';
4 | import { UserInfo } from '../models/user';
5 |
6 | @Injectable()
7 | export class AuthService {
8 |
9 | constructor(private _router: Router) { }
10 |
11 | public loggedIn(): boolean {
12 | if (localStorage[AppStorage_Token] != null) {
13 | return true;
14 | }
15 |
16 | return false;
17 | }
18 |
19 | public logout(): void {
20 | localStorage.clear();
21 | this._router.navigate(['home']);
22 | }
23 |
24 | public inspectResponse(response: any): boolean {
25 | if (response.hasOwnProperty('error'))
26 | return false;
27 |
28 | return true;
29 | }
30 |
31 | public token(): string {
32 | return localStorage[AppStorage_Token];
33 | }
34 |
35 | public token_set(token: string): void {
36 | localStorage[AppStorage_Token] = token;
37 | }
38 |
39 | public userInfo(): UserInfo {
40 | return JSON.parse(localStorage[UI]);
41 | }
42 |
43 | public userInfo_set(username: string, password: string): void {
44 | const ui = new UserInfo();
45 | ui.username = username;
46 | ui.password = password;
47 | localStorage[UI] = JSON.stringify(ui);
48 | }
49 |
50 | }
51 |
--------------------------------------------------------------------------------
/src/app/services/feature.service.spec.ts:
--------------------------------------------------------------------------------
1 | import { TestBed, inject } from '@angular/core/testing';
2 |
3 | import { FeatureService } from './feature.service';
4 |
5 | describe('FeatureService', () => {
6 | beforeEach(() => {
7 | TestBed.configureTestingModule({
8 | providers: [FeatureService]
9 | });
10 | });
11 |
12 | it('should be created', inject([FeatureService], (service: FeatureService) => {
13 | expect(service).toBeTruthy();
14 | }));
15 | });
16 |
--------------------------------------------------------------------------------
/src/app/services/feature.service.ts:
--------------------------------------------------------------------------------
1 | import { Injectable } from '@angular/core';
2 | import { AuthService } from './auth.service';
3 | import { HttpClient, HttpParams } from '@angular/common/http';
4 | import { Observable } from 'rxjs';
5 |
6 | @Injectable()
7 | export class FeatureService {
8 |
9 | private _featureServiceUrl: string;
10 |
11 | constructor(private _http: HttpClient, private _authService: AuthService) {
12 | this._featureServiceUrl = "https://cen0-pddemo01.sspinnovations.com/server/rest/services/Electric_Distribution_Utility_Network/FeatureServer/";
13 | }
14 |
15 | public getFeatures(layerId: number, gdbVersion: string, objectIds: Array): Observable {
16 | const strObjectIds = objectIds.join(",");
17 |
18 | const queryUrl = this._featureServiceUrl + layerId + "/query";
19 |
20 | let formData = new FormData();
21 | formData.append('token', this._authService.token());
22 | formData.append('f', 'json');
23 | formData.append('gdbVersion', gdbVersion);
24 | formData.append('objectIds', strObjectIds);
25 | formData.append('outFields', '*')
26 |
27 | return this._http.post(queryUrl, formData).pipe();
28 | }
29 |
30 | }
31 |
--------------------------------------------------------------------------------
/src/app/services/portal.service.spec.ts:
--------------------------------------------------------------------------------
1 | import { TestBed, inject } from '@angular/core/testing';
2 |
3 | import { PortalService } from './portal.service';
4 |
5 | describe('PortalService', () => {
6 | beforeEach(() => {
7 | TestBed.configureTestingModule({
8 | providers: [PortalService]
9 | });
10 | });
11 |
12 | it('should be created', inject([PortalService], (service: PortalService) => {
13 | expect(service).toBeTruthy();
14 | }));
15 | });
16 |
--------------------------------------------------------------------------------
/src/app/services/portal.service.ts:
--------------------------------------------------------------------------------
1 | import { Injectable } from '@angular/core';
2 | import { environment } from '../../environments/environment';
3 | import { HttpClient, HttpHeaders } from '@angular/common/http';
4 | import { Observable } from 'rxjs';
5 | import { AuthService } from './auth.service';
6 | import { UNItem } from '../models/unitem';
7 |
8 | @Injectable()
9 | export class PortalService {
10 |
11 | constructor(private http: HttpClient,
12 | private _authService: AuthService) { }
13 |
14 | public authenticate(username: string, password: string): Observable {
15 | let formData = new FormData();
16 | formData.append('username',username);
17 | formData.append('password',password);
18 | formData.append('referer', window.location.host);
19 | formData.append('expiration','840');
20 | formData.append('f','pjson');
21 |
22 | return this.http.post(`${environment.portalBaseURL}sharing/rest/generateToken`,formData).pipe();
23 | }
24 |
25 | public items(amount: number): Observable {
26 | let formData = new FormData();
27 | formData.append('token',this._authService.token());
28 | formData.append('f','pjson');
29 | formData.append('num',amount.toString());
30 | formData.append('q',`owner:${this._authService.userInfo().username}`);
31 |
32 | return this.http.post(`${environment.portalBaseURL}sharing/rest/search`,formData).pipe();
33 | }
34 |
35 | public item_get(itemId: string): Observable {
36 | const url = `${environment.portalBaseURL}/sharing/rest/content/items/${itemId}/data`;
37 |
38 | let formData = new FormData();
39 | formData.append('token',this._authService.token());
40 | formData.append('f','json');
41 |
42 | return this.http.post(url,formData).pipe();
43 | }
44 |
45 | public webMaps_extract(itemData: any): UNItem[] {
46 | let webMaps: UNItem[] = new Array();
47 | let results = itemData.results;
48 | results.forEach((item) => {
49 | if (item.type === 'Web Map')
50 | webMaps.push(item);
51 | });
52 | return webMaps;
53 | }
54 |
55 | }
56 |
--------------------------------------------------------------------------------
/src/app/services/trace.service.ts:
--------------------------------------------------------------------------------
1 | import { Observable, from, of, merge} from 'rxjs';
2 | import { map } from 'rxjs/operators';
3 | import { Injectable, Inject, Optional } from '@angular/core';
4 | import { HttpClient, HttpHeaders, HttpParams, HttpResponse, HttpResponseBase, HttpErrorResponse } from '@angular/common/http';
5 | import { environment } from './../../environments/environment';
6 | import { AuthService } from './auth.service';
7 | import { TraceType } from '../models/enums';
8 | import { QueryNetworkMoments } from '../models/querynetworkmoments';
9 | import { TracePayload } from '../models/tracepayload';
10 | import { TraceResults } from '../models/traceresults';
11 | import { TraceLocations } from '../models/tracelocations';
12 | import { TraceConfiguration } from '../models/traceconfiguration';
13 |
14 | @Injectable()
15 | export class TraceService {
16 | private http: HttpClient;
17 | private baseUrl: string;
18 | protected jsonParseReviver: ((key: string, value: any) => any) | undefined = undefined;
19 |
20 | constructor(@Inject(HttpClient) http: HttpClient, private _authService: AuthService) {
21 | this.http = http;
22 | this.baseUrl = environment.portalBaseURL;
23 | }
24 |
25 | /**
26 | * @f f
27 | * @traceType traceType
28 | * @traceLocations traceLocations
29 | * @traceConfiguration Trace Configuration
30 | * @return OK
31 | */
32 | public trace(tracePayload: TracePayload): Observable {
33 | const ar = tracePayload.featureServiceUrl.split('/');
34 | ar[ar.length - 1] = 'UtilityNetworkServer';
35 | const traceUrl = `${ar.join('/')}/trace`;
36 |
37 | const formData = new FormData();
38 | formData.append('token', this._authService.token());
39 | formData.append('f', 'json');
40 | formData.append('gdbVersion', tracePayload.gdbVersion);
41 | formData.append('traceType', tracePayload.traceType);
42 | formData.append('traceLocations', JSON.stringify(tracePayload.traceLocations));
43 | formData.append('traceConfiguration', JSON.stringify(tracePayload.traceConfiguration));
44 | return this.http.post(traceUrl, formData).pipe();
45 | }
46 | }
47 |
48 | export class SwaggerException extends Error {
49 | message: string;
50 | status: number;
51 | response: string;
52 | headers: { [key: string]: any; };
53 | result: any;
54 |
55 | constructor(message: string, status: number, response: string, headers: { [key: string]: any; }, result: any) {
56 | super();
57 |
58 | this.message = message;
59 | this.status = status;
60 | this.response = response;
61 | this.headers = headers;
62 | this.result = result;
63 | }
64 |
65 | protected isSwaggerException = true;
66 |
67 | static isSwaggerException(obj: any): obj is SwaggerException {
68 | return obj.isSwaggerException === true;
69 | }
70 | }
71 |
72 | function blobToText(blob: any): Observable {
73 | return new Observable((observer: any) => {
74 | if (!blob) {
75 | observer.next("");
76 | observer.complete();
77 | } else {
78 | let reader = new FileReader();
79 | reader.onload = function() {
80 | observer.next(this.result);
81 | observer.complete();
82 | }
83 | reader.readAsText(blob);
84 | }
85 | });
86 | }
--------------------------------------------------------------------------------
/src/app/services/utilitynetwork.service.ts:
--------------------------------------------------------------------------------
1 | import * as Constants from "../models/constants";
2 | import { Injectable } from '@angular/core';
3 | import { AuthService } from './auth.service';
4 | import { TraceService } from './trace.service';
5 | import { GeometryType, PhaseType, TraceType, TraceConfigurationTraversabilityScope, TraceLocationsTraceLocationType } from '../models/enums';
6 | import { FeatureTrace } from '../models/featuretrace';
7 | import { TraceResultFeature } from '../models/traceresultfeature';
8 | import { TraceResults, TraceResults2 } from '../models/traceresults';
9 | import { TraceConfiguration } from '../models/traceconfiguration';
10 | import { NearestNeighbor } from '../models/nearestneighbor';
11 | import { TraceLocations } from '../models/tracelocations';
12 | import { TracePayload } from '../models/tracepayload';
13 |
14 | @Injectable()
15 | export class UtilityNetworkService {
16 |
17 | constructor(private _authService: AuthService, private _traceService: TraceService) { }
18 |
19 | public featureServiceUrl: string;
20 | public featureServiceJson: any;
21 | public dataElement: any;
22 | public layerDefinition: any;
23 | public itemId: string;
24 | public subnetLineLayerId: string;
25 | public domainNetwork: string;
26 | public GraphicClass: any;
27 | private token: string = this._authService.token();
28 |
29 | ///first function one should call after creating an instance of a utility network
30 | public load = async (): Promise => {
31 | let thisObj = this;
32 | //pull the feature service definition
33 | let featureServiceJsonResult: any = await makeRequest({ method: 'POST', url: thisObj.featureServiceUrl, params: { f: "json", token: thisObj.token } });
34 | this.featureServiceJson = featureServiceJsonResult;
35 | //check to see if the feature service has a UN
36 | if (this.featureServiceJson.controllerDatasetLayers != undefined) {
37 | let layerId = this.featureServiceJson.controllerDatasetLayers.utilityNetworkLayerId;
38 | let queryDataElementUrl = thisObj.featureServiceUrl + "/queryDataElements";
39 | let layers = "[" + layerId + "]"
40 |
41 | let postJson: any = {
42 | token: thisObj.token,
43 | layers: layers,
44 | f: "json"
45 | }
46 | //pull the data element definition of the utility network now that we have the utility network layer
47 | let undataElement: any = await makeRequest({ method: 'POST', url: queryDataElementUrl, params: postJson });
48 |
49 | //request the un layer defition which has different set of information
50 | let unLayerUrl = thisObj.featureServiceUrl + "/" + layerId;
51 | postJson = {
52 | token: thisObj.token,
53 | f: "json"
54 | }
55 | let unLayerDef = await makeRequest({ method: 'POST', url: unLayerUrl, params: postJson });
56 |
57 | thisObj.dataElement = undataElement.layerDataElements[0].dataElement;
58 | thisObj.layerDefinition = unLayerDef
59 | thisObj.subnetLineLayerId = thisObj.getSubnetLineLayerId();
60 | return thisObj;
61 | }
62 | else
63 | throw ("No Utility Network found in this feature service");
64 | }
65 |
66 |
67 | //return the domainNetwork object.
68 | public getDomainNetwork(domainNetworkName: string): any {
69 |
70 | for (let domainNetwork of this.dataElement.domainNetworks)
71 | if (domainNetwork.domainNetworkName === domainNetworkName) return domainNetwork;
72 |
73 | }
74 | //return the tier
75 | public getTier(domainNetworkName, tierName): any {
76 | for (let tier of this.getDomainNetwork(domainNetworkName).tiers)
77 | if (tier.name === tierName)
78 | return tier;
79 | }
80 | //query the subnetwokrs table
81 | getSubnetworks(domainNetworkName, tierName) {
82 | let subnetworkTableUrl = this.featureServiceUrl + "/" + this.layerDefinition.systemLayers.subnetworksTableId + "/query";
83 |
84 | let postJson = {
85 | token: this.token,
86 | where: "DOMAINNETWORKNAME = '" + domainNetworkName + "' AND TIERNAME = '" + tierName + "'",
87 | outFields: "SUBNETWORKNAME",
88 | orderByFields: "SUBNETWORKNAME",
89 | returnDistinctValues: true,
90 | f: "json"
91 | }
92 |
93 | return makeRequest({ method: 'POST', url: subnetworkTableUrl, params: postJson });
94 |
95 | }
96 |
97 | //query that projects to webmercator.
98 | public query(layerId: string, where: string, obj: any, objectids: any): any {
99 | let webMercSpatialReference = {
100 | "wkid": 102100,
101 | "latestWkid": 3857,
102 | "xyTolerance": 0.001,
103 | "zTolerance": 0.001,
104 | "mTolerance": 0.001,
105 | "falseX": -20037700,
106 | "falseY": -30241100,
107 | "xyUnits": 148923141.92838538,
108 | "falseZ": -100000,
109 | "zUnits": 10000,
110 | "falseM": -100000,
111 | "mUnits": 10000
112 | }
113 |
114 | let queryJson = {
115 | f: "json",
116 | token: this.token,
117 | outFields: "*",
118 | where: where,
119 | outSR: JSON.stringify(webMercSpatialReference)
120 | }
121 |
122 | if (objectids != undefined)
123 | queryJson['objectIds'] = objectids;
124 | queryJson['layerId'] = layerId
125 | return new Promise((resolve, reject) => {
126 |
127 | makeRequest({ method: 'POST', params: queryJson, url: this.featureServiceUrl + "/" + layerId + "/query" }).then(rowsJson => {
128 | rowsJson['obj'] = obj;
129 | resolve(rowsJson);
130 | }).catch(rej => reject("failed to query"));
131 |
132 | });
133 | }
134 |
135 | //get the terminal configuration using the id
136 | getTerminalConfiguration(terminalConfigurationId) {
137 | return this.dataElement.terminalConfigurations.find(tc => tc.terminalConfigurationId === terminalConfigurationId);
138 | }
139 |
140 | //get the subenetline layer
141 | getSubnetLineLayerId() {
142 |
143 | //esriUNFCUTSubnetLine
144 |
145 | let domainNetworks = this.dataElement.domainNetworks;
146 |
147 | for (let i = 0; i < domainNetworks.length; i++) {
148 | let domainNetwork = domainNetworks[i];
149 | //only search edgeSources since subnetline is a line
150 | for (let j = 0; j < domainNetwork.edgeSources.length; j++)
151 | if (domainNetwork.edgeSources[j].utilityNetworkFeatureClassUsageType === "esriUNFCUTSubnetLine")
152 | return domainNetwork.edgeSources[j].layerId;
153 | }
154 |
155 | }
156 |
157 | //return the asset type
158 | getAssetType(layerId, assetGroupCode, assetTypeCode) {
159 |
160 | let domainNetworks = this.dataElement.domainNetworks;
161 | let layerObj = undefined;
162 |
163 | for (let i = 0; i < domainNetworks.length; i++) {
164 | let domainNetwork = domainNetworks[i];
165 | for (let j = 0; j < domainNetwork.junctionSources.length; j++)
166 | if (domainNetwork.junctionSources[j].layerId == layerId) {
167 | let assetGroup = domainNetwork.junctionSources[j].assetGroups.find(ag => ag.assetGroupCode === assetGroupCode);
168 | if (assetGroup instanceof Object) {
169 | let assetType = assetGroup.assetTypes.find(at => at.assetTypeCode === assetTypeCode);
170 | assetType.assetGroupName = assetGroup.assetGroupName;
171 | assetType.utilityNetworkFeatureClassUsageType = domainNetwork.junctionSources[j].utilityNetworkFeatureClassUsageType;
172 | if (assetType instanceof Object) return assetType;
173 | }
174 | }
175 |
176 | for (let j = 0; j < domainNetwork.edgeSources.length; j++)
177 | if (domainNetwork.edgeSources[j].layerId == layerId) {
178 | let assetGroup = domainNetwork.edgeSources[j].assetGroups.find(ag => ag.assetGroupCode === assetGroupCode);
179 | if (assetGroup instanceof Object) {
180 | let assetType = assetGroup.assetTypes.find(at => at.assetTypeCode === assetTypeCode);
181 | assetType.assetGroupName = assetGroup.assetGroupName;
182 | assetType.utilityNetworkFeatureClassUsageType = domainNetwork.edgeSources[j].utilityNetworkFeatureClassUsageType;
183 | if (assetType instanceof Object) return assetType;
184 | }
185 | }
186 | }
187 |
188 | return undefined;
189 | }
190 |
191 | //return layer by type
192 | getLayer(utilityNetworkUsageType) {
193 |
194 | let domainNetworks = this.dataElement.domainNetworks;
195 |
196 | for (let i = 0; i < domainNetworks.length; i++) {
197 | let domainNetwork = domainNetworks[i];
198 |
199 | for (let j = 0; j < domainNetwork.junctionSources.length; j++)
200 | if (domainNetwork.junctionSources[j].utilityNetworkFeatureClassUsageType === utilityNetworkUsageType)
201 | return domainNetwork.junctionSources[j].layerId;
202 | }
203 |
204 | for (let i = 0; i < domainNetworks.length; i++) {
205 | let domainNetwork = domainNetworks[i];
206 |
207 | for (let j = 0; j < domainNetwork.edgeSources.length; j++)
208 | if (domainNetwork.edgeSources[j].utilityNetworkFeatureClassUsageType === utilityNetworkUsageType)
209 | return domainNetwork.edgeSources[j].layerId;
210 | }
211 | }
212 | //return the first device layer
213 | getDeviceLayer() {
214 |
215 | return this.getLayer("esriUNFCUTDevice");
216 |
217 | }
218 | //return the first junction layer
219 | getJunctionLayer() {
220 |
221 | return this.getLayer("esriUNFCUTJunction");
222 | }
223 | //return the first Line layer
224 | getLineLayer() {
225 | return this.getLayer("esriUNFCUTLine");
226 | }
227 |
228 | //get layer id from Source Id used to map sourceid to layer id
229 | getLayerIdfromSourceId(sourceId) {
230 | let domainNetworks = this.dataElement.domainNetworks;
231 | let layerObj = undefined;
232 |
233 | for (let i = 0; i < domainNetworks.length; i++) {
234 | let domainNetwork = domainNetworks[i];
235 | for (let j = 0; j < domainNetwork.junctionSources.length; j++)
236 | if (domainNetwork.junctionSources[j].sourceId == sourceId) {
237 | layerObj = { type: domainNetwork.junctionSources[j].shapeType, layerId: domainNetwork.junctionSources[j].layerId }
238 | break;
239 | }
240 |
241 | for (let j = 0; j < domainNetwork.edgeSources.length; j++)
242 | if (domainNetwork.edgeSources[j].sourceId == sourceId) {
243 | layerObj = { type: domainNetwork.edgeSources[j].shapeType, layerId: domainNetwork.edgeSources[j].layerId }
244 | break;
245 | }
246 | }
247 |
248 | if (layerObj != undefined)
249 | layerObj.type = layerObj.type.replace("esriGeometry", "").toLowerCase();
250 |
251 | return layerObj;
252 | }
253 |
254 | //run connected Trace
255 | connectedTrace(startingPoints, barriers) {
256 | let traceLocations = [];
257 | //terminalId percentAlong: 0
258 |
259 | startingPoints.forEach(s => traceLocations.push({ traceLocationType: "startingPoint", globalId: s.globalId, terminalId: s.terminalId }));
260 | barriers.forEach(s => traceLocations.push({ traceLocationType: "barrier", globalId: s.globalId, terminalId: s.terminalId }));
261 |
262 | return new Promise((resolve, reject) => {
263 |
264 | let subnetworkDef: TraceConfiguration = this.connectedTraceConfiguration();
265 |
266 | const tracePayload = new TracePayload({
267 | featureServiceUrl: this.featureServiceUrl,
268 | gdbVersion: Constants.SDEDefault,
269 | traceType: TraceType.Connected,
270 | traceLocations: traceLocations,
271 | traceConfiguration: subnetworkDef
272 | });
273 |
274 | this._traceService.trace(tracePayload)
275 | .subscribe(response => {
276 | resolve(this.buildTraceResults(response));
277 | });
278 | });
279 | }
280 |
281 | private connectedTraceConfiguration(): TraceConfiguration {
282 | let subnetworkDef: TraceConfiguration = new TraceConfiguration();
283 | subnetworkDef.includeContainers = false;
284 | subnetworkDef.includeContent = false;
285 | subnetworkDef.includeStructures = false;
286 | subnetworkDef.includeBarriers = true;
287 | subnetworkDef.validateConsistency = true;
288 | subnetworkDef.domainNetworkName = '';
289 | subnetworkDef.tierName = '';
290 | subnetworkDef.targetTierName = '';
291 | subnetworkDef.subnetworkName = '';
292 | subnetworkDef.diagramTemplateName = '';
293 | subnetworkDef.shortestPathNetworkAttributeName = '';
294 | subnetworkDef.filterBitsetNetworkAttributeName = '';
295 | subnetworkDef.traversabilityScope = TraceConfigurationTraversabilityScope.JunctionsAndEdges;
296 | subnetworkDef.conditionBarriers = new Array();
297 | subnetworkDef.functionBarriers = new Array();
298 | subnetworkDef.arcadeExpressionBarrier = '';
299 | subnetworkDef.filterBarriers = new Array();
300 | subnetworkDef.filterFunctionBarriers = new Array();
301 | subnetworkDef.filterScope = TraceConfigurationTraversabilityScope.JunctionsAndEdges;
302 | subnetworkDef.functions = new Array();
303 | let nn = new NearestNeighbor();
304 | nn.count = -1;
305 | nn.costNetworkAttributeName = '';
306 | nn.nearestCategories = new Array();
307 | nn.nearestAssets = new Array();
308 |
309 | subnetworkDef.nearestNeighbor = nn;
310 | subnetworkDef.outputFilters = new Array();
311 | subnetworkDef.outputConditions = new Array();
312 | subnetworkDef.propagators = new Array();
313 |
314 | return subnetworkDef;
315 | }
316 |
317 | private buildTraceResults(featuresJson): TraceResults {
318 | //build the trace results so we group them by layerid
319 | let features: TraceResultFeature[] = new Array();
320 | let traceResults: TraceResults = new TraceResults();
321 | traceResults.layers = [];
322 |
323 | for (let f of featuresJson.traceResults.elements) {
324 | let layerObj = this.getLayerIdfromSourceId(f.networkSourceId);
325 | if (layerObj === undefined) continue;
326 |
327 | let layerId = layerObj.layerId;
328 |
329 | if (traceResults.layers[layerId] == undefined) traceResults.layers[layerId] = {};
330 | if (traceResults.layers[layerId].objectIds == undefined) traceResults.layers[layerId].objectIds = [];
331 | if (traceResults.layers[layerId].type == undefined) traceResults.layers[layerId].type = layerObj.type;
332 |
333 | traceResults.layers[layerId].objectIds.push(f.objectId);
334 |
335 | let feature = new TraceResultFeature(f);
336 | features.push(feature);
337 | }
338 |
339 | traceResults.traceResults = new TraceResults2({ features: features });
340 |
341 | return traceResults;
342 | }
343 |
344 | //run subnetwork Trace
345 | public subnetworkTrace(domainNetworkName, tierName, subnetworkName): any {
346 | return new Promise((resolve, reject) => {
347 | let tier = this.getTier(domainNetworkName, tierName);
348 | let subnetworkDef = tier.updateSubnetworkTraceConfiguration;
349 | subnetworkDef.subnetworkName = subnetworkName;
350 | const traceLocations: TraceLocations[] = new Array();
351 |
352 | const tracePayload = new TracePayload({
353 | featureServiceUrl: this.featureServiceUrl,
354 | gdbVersion: Constants.SDEDefault,
355 | traceType: TraceType.Subnetwork,
356 | traceLocations: traceLocations,
357 | traceConfiguration: subnetworkDef
358 | });
359 |
360 | this._traceService.trace(tracePayload)
361 | .subscribe(response => {
362 | resolve(this.buildTraceResults(response));
363 | });
364 | });
365 | }
366 |
367 | public traceFromStartingPoint(featureTrace: FeatureTrace): Promise {
368 | const tier = this.getTier(featureTrace.domainNetwork, featureTrace.tierName);
369 | const traceConfig = this.getTraceConfig(tier, featureTrace.phaseType);
370 |
371 | const traceLocation = this.getTraceLocation(featureTrace.globalId, featureTrace.geometryType);
372 | const traceLocations: TraceLocations[] = new Array();
373 | traceLocations.push(traceLocation);
374 |
375 | const tracePayload = new TracePayload({
376 | featureServiceUrl: this.featureServiceUrl,
377 | gdbVersion: Constants.SDEDefault,
378 | traceType: featureTrace.traceType,
379 | traceLocations: traceLocations,
380 | traceConfiguration: traceConfig
381 | });
382 |
383 | return new Promise((resolve, reject) => {
384 | this._traceService.trace(tracePayload)
385 | .subscribe(response => {
386 | resolve(this.buildTraceResults(response));
387 | });
388 | });
389 | }
390 |
391 | private getTraceConfig(tier: any, phaseType: PhaseType): TraceConfiguration {
392 | const traceConfig = tier.updateSubnetworkTraceConfiguration;
393 | traceConfig.subnetworkName = "";
394 | traceConfig.functions = new Array();
395 | traceConfig.includeContainers = false;
396 | traceConfig.includeStructures = false;
397 | traceConfig.propagators = new Array();
398 | traceConfig.targetTierName = tier.tierName;
399 |
400 | const filterBarrier = {
401 | "combineUsingOr": false,
402 | "isSpecificValue": true,
403 | "name": "Phases Current",
404 | "operator": "doesNotIncludeAny",
405 | "type": "networkAttribute",
406 | "value": phaseType
407 | };
408 | traceConfig.filterBarrier = new Array();
409 | traceConfig.filterBarriers.push(filterBarrier);
410 |
411 | return traceConfig;
412 | }
413 |
414 | private getTraceLocation(globalId: string, geometryType: GeometryType): TraceLocations {
415 | let traceLocation = new TraceLocations();
416 | traceLocation.traceLocationType = TraceLocationsTraceLocationType.StartingPoint;
417 | traceLocation.globalId = globalId;
418 |
419 | if (geometryType === GeometryType.Polyline)
420 | traceLocation.percentAlong = 0;
421 | else if (geometryType === GeometryType.Point)
422 | traceLocation.terminalId = 1;
423 |
424 | return traceLocation;
425 | }
426 |
427 | }
428 |
429 |
430 | //Makes a request
431 | function makeRequest(opts) {
432 | return new Promise(function (resolve, reject) {
433 | let xhr = new XMLHttpRequest();
434 |
435 | xhr.open(opts.method, opts.url);
436 | xhr.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
437 | xhr.onload = function () {
438 | let context: any = this;
439 | if (context.status >= 200 && context.status < 300) {
440 | let jsonRes = xhr.response;
441 | if (typeof jsonRes !== "object") jsonRes = JSON.parse(xhr.response);
442 | resolve(jsonRes);
443 | } else {
444 | reject({
445 | status: context.status,
446 | statusText: xhr.statusText
447 | });
448 | }
449 | };
450 |
451 | //xhr.onerror = err => reject({status: this.status, statusText: xhr.statusText}) ;
452 | xhr.onerror = err => reject(err);
453 |
454 |
455 | if (opts.headers)
456 | Object.keys(opts.headers).forEach(key => xhr.setRequestHeader(key, opts.headers[key]))
457 |
458 | let params = opts.params;
459 | // We'll need to stringify if we've been given an object
460 | // If we have a string, this is skipped.
461 | if (params && typeof params === 'object')
462 | params = Object.keys(params).map(key => encodeURIComponent(key) + '=' + encodeURIComponent(params[key])).join('&');
463 |
464 | xhr.send(params);
465 | });
466 | }
--------------------------------------------------------------------------------
/src/assets/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sspinnovations/UtilityNetworkTracingWebApp/31c7c2760ca6ee39fc038fe94409dc604e1fb1a6/src/assets/.gitkeep
--------------------------------------------------------------------------------
/src/assets/images/DownstreamTraceIcon32.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sspinnovations/UtilityNetworkTracingWebApp/31c7c2760ca6ee39fc038fe94409dc604e1fb1a6/src/assets/images/DownstreamTraceIcon32.png
--------------------------------------------------------------------------------
/src/assets/images/UpstreamTraceIcon32.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sspinnovations/UtilityNetworkTracingWebApp/31c7c2760ca6ee39fc038fe94409dc604e1fb1a6/src/assets/images/UpstreamTraceIcon32.png
--------------------------------------------------------------------------------
/src/environments/environment.prod.ts:
--------------------------------------------------------------------------------
1 | export const environment = {
2 | production: true,
3 | portalBaseURL: 'https://cen0-pddemo01.sspinnovations.com/portal/'
4 | };
5 |
--------------------------------------------------------------------------------
/src/environments/environment.ts:
--------------------------------------------------------------------------------
1 | // The file contents for the current environment will overwrite these during build.
2 | // The build system defaults to the dev environment which uses `environment.ts`, but if you do
3 | // `ng build --env=prod` then `environment.prod.ts` will be used instead.
4 | // The list of which env maps to which file can be found in `.angular-cli.json`.
5 |
6 | export const environment = {
7 | production: false,
8 | portalBaseURL: 'https://cen0-pddemo01.sspinnovations.com/portal/'
9 | };
10 |
--------------------------------------------------------------------------------
/src/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sspinnovations/UtilityNetworkTracingWebApp/31c7c2760ca6ee39fc038fe94409dc604e1fb1a6/src/favicon.ico
--------------------------------------------------------------------------------
/src/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 | Utility Network Web Tracing
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
--------------------------------------------------------------------------------
/src/main.ts:
--------------------------------------------------------------------------------
1 | import { enableProdMode } from '@angular/core';
2 | import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
3 |
4 | import { AppModule } from './app/app.module';
5 | import { environment } from './environments/environment';
6 |
7 | if (environment.production) {
8 | enableProdMode();
9 | }
10 |
11 | platformBrowserDynamic().bootstrapModule(AppModule)
12 | .catch(err => console.log(err));
13 |
--------------------------------------------------------------------------------
/src/polyfills.ts:
--------------------------------------------------------------------------------
1 | /**
2 | * This file includes polyfills needed by Angular and is loaded before the app.
3 | * You can add your own extra polyfills to this file.
4 | *
5 | * This file is divided into 2 sections:
6 | * 1. Browser polyfills. These are applied before loading ZoneJS and are sorted by browsers.
7 | * 2. Application imports. Files imported after ZoneJS that should be loaded before your main
8 | * file.
9 | *
10 | * The current setup is for so-called "evergreen" browsers; the last versions of browsers that
11 | * automatically update themselves. This includes Safari >= 10, Chrome >= 55 (including Opera),
12 | * Edge >= 13 on the desktop, and iOS 10 and Chrome on mobile.
13 | *
14 | * Learn more in https://angular.io/docs/ts/latest/guide/browser-support.html
15 | */
16 |
17 | /***************************************************************************************************
18 | * BROWSER POLYFILLS
19 | */
20 |
21 | /** IE9, IE10 and IE11 requires all of the following polyfills. **/
22 | // import 'core-js/es6/symbol';
23 | // import 'core-js/es6/object';
24 | // import 'core-js/es6/function';
25 | // import 'core-js/es6/parse-int';
26 | // import 'core-js/es6/parse-float';
27 | // import 'core-js/es6/number';
28 | // import 'core-js/es6/math';
29 | // import 'core-js/es6/string';
30 | // import 'core-js/es6/date';
31 | // import 'core-js/es6/array';
32 | // import 'core-js/es6/regexp';
33 | // import 'core-js/es6/map';
34 | // import 'core-js/es6/weak-map';
35 | // import 'core-js/es6/set';
36 |
37 | /** IE10 and IE11 requires the following for NgClass support on SVG elements */
38 | // import 'classlist.js'; // Run `npm install --save classlist.js`.
39 |
40 | /** IE10 and IE11 requires the following for the Reflect API. */
41 | // import 'core-js/es6/reflect';
42 |
43 |
44 | /** Evergreen browsers require these. **/
45 | // Used for reflect-metadata in JIT. If you use AOT (and only Angular decorators), you can remove.
46 | import 'core-js/es7/reflect';
47 |
48 |
49 | /**
50 | * Required to support Web Animations `@angular/platform-browser/animations`.
51 | * Needed for: All but Chrome, Firefox and Opera. http://caniuse.com/#feat=web-animation
52 | **/
53 | // import 'web-animations-js'; // Run `npm install --save web-animations-js`.
54 |
55 | /**
56 | * By default, zone.js will patch all possible macroTask and DomEvents
57 | * user can disable parts of macroTask/DomEvents patch by setting following flags
58 | */
59 |
60 | // (window as any).__Zone_disable_requestAnimationFrame = true; // disable patch requestAnimationFrame
61 | // (window as any).__Zone_disable_on_property = true; // disable patch onProperty such as onclick
62 | // (window as any).__zone_symbol__BLACK_LISTED_EVENTS = ['scroll', 'mousemove']; // disable patch specified eventNames
63 |
64 | /*
65 | * in IE/Edge developer tools, the addEventListener will also be wrapped by zone.js
66 | * with the following flag, it will bypass `zone.js` patch for IE/Edge
67 | */
68 | // (window as any).__Zone_enable_cross_context_check = true;
69 |
70 | /***************************************************************************************************
71 | * Zone JS is required by default for Angular itself.
72 | */
73 | import 'zone.js/dist/zone'; // Included with Angular CLI.
74 |
75 |
76 |
77 | /***************************************************************************************************
78 | * APPLICATION IMPORTS
79 | */
80 |
--------------------------------------------------------------------------------
/src/styles.css:
--------------------------------------------------------------------------------
1 | /* Sticky footer styles
2 | -------------------------------------------------- */
3 | html {
4 | position: relative;
5 | min-height: 100%;
6 | }
7 | body {
8 | /* Margin bottom by footer height */
9 | margin-bottom: 60px;
10 | }
11 | .footer {
12 | position: absolute;
13 | bottom: 0;
14 | width: 100%;
15 | /* Set the fixed height of the footer here */
16 | height: 60px;
17 | line-height: 60px; /* Vertically center the text there */
18 | background-color: #f5f5f5;
19 | }
20 |
21 | main {
22 | margin-top: 50px;
23 | }
24 |
25 |
26 | /* Custom page CSS
27 | -------------------------------------------------- */
28 | /* Not required for template or sticky footer method. */
29 |
30 | body > .container {
31 | padding: 60px 15px 0;
32 | }
33 |
34 | .footer > .container {
35 | padding-right: 15px;
36 | padding-left: 15px;
37 | }
38 |
39 | code {
40 | font-size: 80%;
41 | }
42 |
--------------------------------------------------------------------------------
/src/test.ts:
--------------------------------------------------------------------------------
1 | // This file is required by karma.conf.js and loads recursively all the .spec and framework files
2 |
3 | import 'zone.js/dist/zone-testing';
4 | import { getTestBed } from '@angular/core/testing';
5 | import {
6 | BrowserDynamicTestingModule,
7 | platformBrowserDynamicTesting
8 | } from '@angular/platform-browser-dynamic/testing';
9 |
10 | declare const require: any;
11 |
12 | // First, initialize the Angular testing environment.
13 | getTestBed().initTestEnvironment(
14 | BrowserDynamicTestingModule,
15 | platformBrowserDynamicTesting()
16 | );
17 | // Then we find all the tests.
18 | const context = require.context('./', true, /\.spec\.ts$/);
19 | // And load the modules.
20 | context.keys().map(context);
21 |
--------------------------------------------------------------------------------
/src/tsconfig.app.json:
--------------------------------------------------------------------------------
1 | {
2 | "extends": "../tsconfig.json",
3 | "compilerOptions": {
4 | "outDir": "../out-tsc/app",
5 | "baseUrl": "./",
6 | "module": "es2015",
7 | "types": []
8 | },
9 | "exclude": [
10 | "test.ts",
11 | "**/*.spec.ts"
12 | ]
13 | }
14 |
--------------------------------------------------------------------------------
/src/tsconfig.spec.json:
--------------------------------------------------------------------------------
1 | {
2 | "extends": "../tsconfig.json",
3 | "compilerOptions": {
4 | "outDir": "../out-tsc/spec",
5 | "baseUrl": "./",
6 | "module": "commonjs",
7 | "types": [
8 | "jasmine",
9 | "node"
10 | ]
11 | },
12 | "files": [
13 | "test.ts",
14 | "polyfills.ts"
15 | ],
16 | "include": [
17 | "**/*.spec.ts",
18 | "**/*.d.ts"
19 | ]
20 | }
21 |
--------------------------------------------------------------------------------
/src/typings.d.ts:
--------------------------------------------------------------------------------
1 | /* SystemJS module definition */
2 | declare var module: NodeModule;
3 | interface NodeModule {
4 | id: string;
5 | }
6 |
--------------------------------------------------------------------------------
/src/web.config:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 | "compileOnSave": false,
3 | "compilerOptions": {
4 | "outDir": "./dist/out-tsc",
5 | "sourceMap": true,
6 | "declaration": false,
7 | "moduleResolution": "node",
8 | "emitDecoratorMetadata": true,
9 | "experimentalDecorators": true,
10 | "target": "es5",
11 | "typeRoots": [
12 | "node_modules/@types"
13 | ],
14 | "lib": [
15 | "es2017",
16 | "dom"
17 | ]
18 | }
19 | }
20 |
--------------------------------------------------------------------------------
/tslint.json:
--------------------------------------------------------------------------------
1 | {
2 | "rulesDirectory": [
3 | "node_modules/codelyzer"
4 | ],
5 | "rules": {
6 | "arrow-return-shorthand": true,
7 | "callable-types": true,
8 | "class-name": true,
9 | "comment-format": [
10 | true,
11 | "check-space"
12 | ],
13 | "curly": true,
14 | "deprecation": {
15 | "severity": "warn"
16 | },
17 | "eofline": true,
18 | "forin": true,
19 | "import-blacklist": [
20 | true,
21 | "rxjs/Rx"
22 | ],
23 | "import-spacing": true,
24 | "indent": [
25 | true,
26 | "spaces"
27 | ],
28 | "interface-over-type-literal": true,
29 | "label-position": true,
30 | "max-line-length": [
31 | true,
32 | 140
33 | ],
34 | "member-access": false,
35 | "member-ordering": [
36 | true,
37 | {
38 | "order": [
39 | "static-field",
40 | "instance-field",
41 | "static-method",
42 | "instance-method"
43 | ]
44 | }
45 | ],
46 | "no-arg": true,
47 | "no-bitwise": true,
48 | "no-console": [
49 | true,
50 | "debug",
51 | "info",
52 | "time",
53 | "timeEnd",
54 | "trace"
55 | ],
56 | "no-construct": true,
57 | "no-debugger": true,
58 | "no-duplicate-super": true,
59 | "no-empty": false,
60 | "no-empty-interface": true,
61 | "no-eval": true,
62 | "no-inferrable-types": [
63 | true,
64 | "ignore-params"
65 | ],
66 | "no-misused-new": true,
67 | "no-non-null-assertion": true,
68 | "no-shadowed-variable": true,
69 | "no-string-literal": false,
70 | "no-string-throw": true,
71 | "no-switch-case-fall-through": true,
72 | "no-trailing-whitespace": true,
73 | "no-unnecessary-initializer": true,
74 | "no-unused-expression": true,
75 | "no-use-before-declare": true,
76 | "no-var-keyword": true,
77 | "object-literal-sort-keys": false,
78 | "one-line": [
79 | true,
80 | "check-open-brace",
81 | "check-catch",
82 | "check-else",
83 | "check-whitespace"
84 | ],
85 | "prefer-const": true,
86 | "quotemark": [
87 | true,
88 | "single"
89 | ],
90 | "radix": true,
91 | "semicolon": [
92 | true,
93 | "always"
94 | ],
95 | "triple-equals": [
96 | true,
97 | "allow-null-check"
98 | ],
99 | "typedef-whitespace": [
100 | true,
101 | {
102 | "call-signature": "nospace",
103 | "index-signature": "nospace",
104 | "parameter": "nospace",
105 | "property-declaration": "nospace",
106 | "variable-declaration": "nospace"
107 | }
108 | ],
109 | "unified-signatures": true,
110 | "variable-name": false,
111 | "whitespace": [
112 | true,
113 | "check-branch",
114 | "check-decl",
115 | "check-operator",
116 | "check-separator",
117 | "check-type"
118 | ],
119 | "directive-selector": [
120 | true,
121 | "attribute",
122 | "app",
123 | "camelCase"
124 | ],
125 | "component-selector": [
126 | true,
127 | "element",
128 | "app",
129 | "kebab-case"
130 | ],
131 | "no-output-on-prefix": true,
132 | "use-input-property-decorator": true,
133 | "use-output-property-decorator": true,
134 | "use-host-property-decorator": true,
135 | "no-input-rename": true,
136 | "no-output-rename": true,
137 | "use-life-cycle-interface": true,
138 | "use-pipe-transform-interface": true,
139 | "component-class-suffix": true,
140 | "directive-class-suffix": true
141 | }
142 | }
143 |
--------------------------------------------------------------------------------