@csmart/ngc-smart-victim 1.14.42 → 1.18.0

package/esm2022/lib/smart-victim.service.mjs

@@ -0,0 +1,352 @@
+import { HttpClient, HttpHeaders } from '@angular/common/http';
+import { Injectable, Inject } from '@angular/core';
+import { SMART_LOOKUP_SERVICE_URL, SMART_OFFENDER_SERVICE_URL, SMART_VICTIM_SERVICE_URL } from './smart-victim.model';
+import { throwError as observableThrowError } from 'rxjs';
+import { map, catchError } from 'rxjs/operators';
+import { Apollo } from 'apollo-angular';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "apollo-angular";
+const headers = new HttpHeaders({ 'Content-Type': 'application/json' });
+const options = { headers: headers };
+export class NgcSmartVictimService {
+    constructor(http, smartOffenderServiceUrl, smartLookupServiceUrl, smartVictimServiceUrl, apollo) {
+        this.http = http;
+        this.smartOffenderServiceUrl = smartOffenderServiceUrl;
+        this.smartLookupServiceUrl = smartLookupServiceUrl;
+        this.smartVictimServiceUrl = smartVictimServiceUrl;
+        this.apollo = apollo;
+        this.serviceApiUrl = 'https://smart-service-test.azurewebsites.net/graphql';
+    }
+    // getVictimInsurances(offenderId: any) {
+    //   return this.http.get(this.smartOffenderServiceUrl + '/VictimInsurances/?offenderId=' + offenderId).pipe();
+    // }
+    // getVictimInsurance(id: any) {
+    //   return this.http.get(this.smartOffenderServiceUrl + '/VictimInsurances/?id=' + id).pipe();
+    // } 
+    // postVictimInsurance(val: any) {
+    //   return this.http.post(this.smartOffenderServiceUrl + '/VictimInsurances', val).pipe();
+    // }
+    // putVictimInsurance(id: any, val: any) {
+    //   return this.http.put(this.smartOffenderServiceUrl + '/VictimInsurances/?id=' + id, val).pipe();
+    // }
+    // deleteVictimInsurance(id: any) {
+    //   return this.http.delete(this.smartOffenderServiceUrl + '/VictimInsurances/?id=' + id).pipe();
+    // }
+    // getVictimInsuranceTypes() {
+    //     return this.http.get(this.smartLookupServiceUrl + '/VictimInsuranceTypes').pipe();
+    // }
+    // getVictimInsurancePolicyHolders() {
+    //     return this.http.get(this.smartLookupServiceUrl + '/VictimInsurancePolicyHolders').pipe();
+    // }
+    //   getVictimInsuranceSwitchReasons() {
+    //       return this.http.get(this.smartLookupServiceUrl + '/VictimInsuranceSwitchReasons').pipe();
+    //   }
+    //   getVictimInsuranceProviders() {
+    //       return this.http.get(this.smartLookupServiceUrl + '/VictimInsuranceProvider').pipe();
+    //   }
+    //   getVictimInsuranceProvider(id) {
+    //     return this.http.get(this.smartLookupServiceUrl + '/VictimInsuranceProviders/' + id).pipe();
+    // }
+    //   postProviderInformation(val: any) {
+    //       return this.http.post(this.smartLookupServiceUrl + '/VictimInsuranceProviders', val).pipe();
+    //   }
+    getCurrentHousing(offenderId) {
+        return this.http
+            .get(this.smartOffenderServiceUrl + 'Housings/current/' + offenderId)
+            .pipe();
+    }
+    handleError(error) {
+        console.error(error);
+        return observableThrowError(error.json().error || 'Server error');
+    }
+    getDrugsTypes() {
+        return this.http.get(this.smartLookupServiceUrl + 'DrugTypes', options).pipe(map(res => res));
+    }
+    getDocketList(offenderId) {
+        const queryString = `
+  {
+    findDockets(input: { where: { offenderId:${offenderId} } }) {
+      totalCount
+      message
+      data {
+        docketId
+        docketNumber
+      
+      }
+    }
+  }`;
+        return this.http.post(this.serviceApiUrl, { query: queryString }).pipe(map(({ data }) => {
+            console.log('dockets for this offender:', data.findDockets.data);
+            return data.findDockets.data;
+        }));
+    }
+    getSupportTypes() {
+        return this.http.get(this.smartLookupServiceUrl + 'VictimSupportTypes', options).pipe(map(res => res));
+    }
+    getPrefixes() {
+        return this.http.get(this.smartLookupServiceUrl + 'Prefixes', options).pipe(map(res => res));
+    }
+    getSuffixes() {
+        return this.http.get(this.smartLookupServiceUrl + 'Suffixes', options).pipe(map(res => res));
+    }
+    getRelationshipTypes() {
+        return this.http.get(this.smartLookupServiceUrl + 'RelationshipTypes', options).pipe(map(res => res));
+    }
+    getGenders() {
+        return this.http.get(this.smartLookupServiceUrl + 'Genders', options).pipe(map(res => res));
+    }
+    getWeaponTypes() {
+        return this.http.get(this.smartLookupServiceUrl + 'WeaponTypes', options).pipe(map(res => res));
+    }
+    getFlagOptionYesNoUnknowns() {
+        return this.http.get(this.smartLookupServiceUrl + 'FlagOptionYesNoUnknowns', options).pipe(map(res => {
+            return res;
+        }));
+    }
+    getContactTypes() {
+        return this.http.get(this.smartLookupServiceUrl + 'ContactTypes', options).pipe(map(res => {
+            return res;
+        }));
+    }
+    getContactMethods() {
+        return this.http.get(this.smartLookupServiceUrl + 'VictimContactMethods', options).pipe(map(res => {
+            return res;
+        }));
+    }
+    getContactBys() {
+        return this.http.get(this.smartLookupServiceUrl + 'VictimContactPurposes', options).pipe(map(res => {
+            return res;
+        }));
+    }
+    getVictimContactPurposes() {
+        return this.http.get(this.smartLookupServiceUrl + 'VictimContactPurposes', options).pipe(map(res => {
+            return res;
+        }));
+    }
+    getVictimServiceTypes() {
+        return this.http.get(this.smartLookupServiceUrl + 'VictimServiceTypes', options).pipe(map(res => {
+            return res;
+        }));
+    }
+    getVictimServiceStatus() {
+        return this.http.get(this.smartLookupServiceUrl + 'VictimServiceStatus', options).pipe(map(res => {
+            return res;
+        }));
+    }
+    getvVictimServiceTypeProgramProviders() {
+        return this.http.get(this.smartLookupServiceUrl + 'vVictimServiceTypeProgramProviders', options).pipe(map(res => {
+            return res;
+        }));
+    }
+    getVictim(val) {
+        return this.http.get(this.smartVictimServiceUrl + 'Victims/' + val, options).pipe(map(res => {
+            console.log('victim return data');
+            console.log(res);
+            return res;
+        }));
+    }
+    getVictimAdvocate(val) {
+        return this.http.get(this.smartVictimServiceUrl + 'VictimAdvocates/' + val, options).pipe(map(res => {
+            return res;
+        }));
+    }
+    getVictimGuardian(val) {
+        return this.http.get(this.smartVictimServiceUrl + 'VictimGuardians/' + val, options).pipe(map(res => {
+            return res;
+        }));
+    }
+    postVictims(val) {
+        const tempVal = JSON.stringify(val);
+        return this.http.post(this.smartVictimServiceUrl + 'Victims', tempVal, options).pipe(map(res => { return res; }));
+    }
+    putVictims(id, val) {
+        const tempVal = JSON.stringify(val);
+        return this.http.put(this.smartVictimServiceUrl + 'Victims/' + id, tempVal, options).pipe(map(res => { return res; }));
+    }
+    putVictimAdvocate(id, val) {
+        let body;
+        body = JSON.stringify(val);
+        return this.http.put(this.smartVictimServiceUrl + 'VictimAdvocates/' + id, body, options).pipe(map(res => { return res; }));
+    }
+    postVictimAdvocate(id, val) {
+        const tempVal = JSON.stringify(val);
+        return this.http.post(this.smartVictimServiceUrl + 'VictimAdvocates/' + id, tempVal, options).pipe(map(res => { return res; }));
+    }
+    putVictimGuardian(id, val) {
+        console.log('update victim guardian');
+        console.log(val);
+        const tempVal = JSON.stringify(val);
+        return this.http.put(this.smartVictimServiceUrl + 'VictimGuardians/' + id, tempVal, options).pipe(map(res => { return res; }));
+    }
+    postVictimGuardian(id, val) {
+        const tempVal = JSON.stringify(val);
+        return this.http.post(this.smartVictimServiceUrl + 'VictimGuardians/' + id, tempVal, options).pipe(map(res => { return res; }));
+    }
+    getVictimDrugUse(val) {
+        return this.http.get(this.smartVictimServiceUrl + 'VictimDrugUses/' + val, options).pipe(map((res) => {
+            return res;
+        }));
+    }
+    putVictimDrugUse(id, val) {
+        const tempVal = JSON.stringify(val);
+        return this.http.put(this.smartVictimServiceUrl + 'VictimDrugUses/' + id, tempVal, options).pipe(map(res => { return res; }));
+    }
+    postVictimDrugUse(id, val) {
+        const tempVal = JSON.stringify(val);
+        return this.http.post(this.smartVictimServiceUrl + 'VictimDrugUses/' + id, tempVal, options).pipe(map(res => { return res; }));
+    }
+    putVictimWeaponUse(id, val) {
+        const tempVal = JSON.stringify(val);
+        return this.http.put(this.smartVictimServiceUrl + 'VictimWeaponUses/' + id, tempVal, options).pipe(map(res => { return res; }));
+    }
+    postVictimWeaponUse(id, val) {
+        const tempVal = JSON.stringify(val);
+        return this.http.post(this.smartVictimServiceUrl + 'VictimWeaponUses/' + id, tempVal, options).pipe(map(res => { return res; }));
+    }
+    putVictimSupport(id, val) {
+        const tempVal = JSON.stringify(val);
+        return this.http.put(this.smartVictimServiceUrl + 'VictimSupports/' + id, tempVal, options).pipe(map(res => { return res; }));
+    }
+    postVictimSupport(id, val) {
+        const tempVal = JSON.stringify(val);
+        return this.http.post(this.smartVictimServiceUrl + 'VictimSupports/' + id, tempVal, options).pipe(map(res => { return res; }));
+    }
+    deleteVictims(val, staffId) {
+        return this.http.delete(this.smartVictimServiceUrl + 'Victims/' + val + '?staffId=' + staffId, options).pipe(map(res => { return res; }));
+    }
+    // //==============Victim Serive===================================
+    getVictims(offenderId) {
+        return this.http.get(this.smartVictimServiceUrl + 'Victims/offender/' + offenderId)
+            .pipe(map((res) => {
+            return res;
+        }), catchError(this.handleError));
+    }
+    getVictimsByFilter(filter) {
+        return this.http
+            .post(this.smartVictimServiceUrl + '/Victims', JSON.stringify(filter), { headers: headers })
+            .pipe(map((res) => {
+            return res;
+        }), catchError(this.handleError));
+    }
+    getVictimListByFilter(filter) {
+        console.log('filer in service');
+        console.log(filter);
+        return this.http
+            .post(this.smartVictimServiceUrl + 'vVictims/Filter', JSON.stringify(filter), options)
+            .pipe();
+    }
+    getCasetNotes(victimId) {
+        return this.http.get(this.smartVictimServiceUrl + 'VictimCaseNotes/victim/' + victimId)
+            .pipe(map((res) => {
+            return res;
+        }), catchError(this.handleError));
+    }
+    addCaseNote(caseNote) {
+        let body;
+        body = JSON.stringify(caseNote);
+        return this.http
+            .post(this.smartVictimServiceUrl + 'VictimCaseNotes/', body, options);
+    }
+    updateCaseNote(caseNote) {
+        let body;
+        body = JSON.stringify(caseNote);
+        return this.http
+            .put(this.smartVictimServiceUrl + 'VictimCaseNotes/' + caseNote.victimCaseNoteId, body, options);
+    }
+    deleteCaseNote(id, staffId) {
+        return this.http.delete(`${this.smartVictimServiceUrl}VictimCaseNotes/${id}?staffId=${staffId}`);
+    }
+    getContacts(victimId) {
+        return this.http.get(this.smartVictimServiceUrl + 'VictimContacts/victim/' + victimId)
+            .pipe(map((res) => {
+            return res;
+        }), catchError(this.handleError));
+    }
+    addContact(contact) {
+        let body;
+        body = JSON.stringify(contact);
+        return this.http
+            .post(this.smartVictimServiceUrl + 'VictimContacts/', body, options);
+    }
+    updateContact(contact) {
+        let body;
+        body = JSON.stringify(contact);
+        return this.http
+            .put(this.smartVictimServiceUrl + 'VictimContacts/' + contact.victimContactId, body, options);
+    }
+    getSafetyPlans(victimId) {
+        return this.http.get(this.smartVictimServiceUrl + 'vVictimServiceLists/victim/' + victimId)
+            .pipe(map((res) => {
+            return res;
+        }), catchError(this.handleError));
+    }
+    getVictimServices(victimServiceId) {
+        return this.http.get(this.smartVictimServiceUrl + 'vVictimServiceLists/victimServiceId/' + victimServiceId)
+            .pipe(map((res) => {
+            return res;
+        }), catchError(this.handleError));
+    }
+    getVictimServiceDetail(victimServiceId) {
+        return this.http.get(this.smartVictimServiceUrl + 'VictimServiceDetails/' + victimServiceId)
+            .pipe(map((res) => {
+            return res;
+        }), catchError(this.handleError));
+    }
+    addSafetyPlan(victimSafetyPlan) {
+        let body;
+        body = JSON.stringify(victimSafetyPlan);
+        return this.http
+            .post(this.smartVictimServiceUrl + 'VictimServices/', body, options)
+            .pipe();
+    }
+    updateSafetyPlan(victimSafetyPlan) {
+        let body;
+        body = JSON.stringify(victimSafetyPlan);
+        return this.http
+            .put(this.smartVictimServiceUrl + 'VictimServices/' + victimSafetyPlan.victimServiceId, body, options);
+    }
+    addVictimServiceStatus(victimServiceStatusHistory) {
+        let body;
+        body = JSON.stringify(victimServiceStatusHistory);
+        return this.http
+            .post(this.smartVictimServiceUrl + 'VictimServiceStatusHistories/', body, options);
+    }
+    getServiceStatusHistories(victimServiceId) {
+        return this.http.get(this.smartVictimServiceUrl + 'VictimServiceStatusHistories/victimServiceId/' + victimServiceId)
+            .pipe(map((res) => {
+            return res;
+        }), catchError(this.handleError));
+    }
+    deleteSafetyPlan(victimServiceId, staffId) {
+        return this.http.delete(`${this.smartVictimServiceUrl}VictimServices/${victimServiceId}?staffId=${staffId}`);
+    }
+    addPlanProvider(victimServiceDetail) {
+        let body;
+        body = JSON.stringify(victimServiceDetail);
+        return this.http
+            .post(this.smartVictimServiceUrl + 'VictimServiceDetails/', body, options)
+            .pipe();
+    }
+    deleteProvider(victimProgramProviderId, staffId) {
+        return this.http.delete(`${this.smartVictimServiceUrl}VictimServiceDetails/${victimProgramProviderId}?staffId=${staffId}`);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: NgcSmartVictimService, deps: [{ token: i1.HttpClient }, { token: SMART_OFFENDER_SERVICE_URL }, { token: SMART_LOOKUP_SERVICE_URL }, { token: SMART_VICTIM_SERVICE_URL }, { token: i2.Apollo }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: NgcSmartVictimService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: NgcSmartVictimService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [SMART_OFFENDER_SERVICE_URL]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [SMART_LOOKUP_SERVICE_URL]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [SMART_VICTIM_SERVICE_URL]
+                }] }, { type: i2.Apollo }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smart-victim.service.js","sourceRoot":"","sources":["../../../../projects/ngc-smart-victim/src/lib/smart-victim.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpResponse, HttpHeaders } from '@angular/common/http';\r\nimport { Injectable, Inject } from '@angular/core';\r\nimport { SMART_LOOKUP_SERVICE_URL, SMART_OFFENDER_SERVICE_URL,SMART_VICTIM_SERVICE_URL,\r\n    VictimListFilter,VictimDrugUse,Victim,VictimSafetyPlan,\r\n   CaseNote,Contact,VictimServiceDetail,VictimServiceStatusHistory,VictimAdvocate,VictimGuardian} from './smart-victim.model';\r\nimport { Observable, throwError as observableThrowError} from 'rxjs';\r\nimport { map,catchError, filter } from 'rxjs/operators';\r\nimport { Apollo } from 'apollo-angular';\r\n\r\n\r\n\r\nconst headers = new HttpHeaders({ 'Content-Type': 'application/json' });\r\nconst options = { headers: headers };\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class NgcSmartVictimService {\r\n  private serviceApiUrl =  'https://smart-service-test.azurewebsites.net/graphql';\r\n  constructor(private http: HttpClient,\r\n   \r\n    @Inject(SMART_OFFENDER_SERVICE_URL) private smartOffenderServiceUrl: string,\r\n    @Inject(SMART_LOOKUP_SERVICE_URL) private smartLookupServiceUrl: string,\r\n    @Inject(SMART_VICTIM_SERVICE_URL) private smartVictimServiceUrl: string,\r\n    private apollo: Apollo\r\n\r\n    ) { }\r\n\r\n  // getVictimInsurances(offenderId: any) {\r\n  //   return this.http.get(this.smartOffenderServiceUrl + '/VictimInsurances/?offenderId=' + offenderId).pipe();\r\n  // }\r\n\r\n  // getVictimInsurance(id: any) {\r\n  //   return this.http.get(this.smartOffenderServiceUrl + '/VictimInsurances/?id=' + id).pipe();\r\n  // } \r\n\r\n  // postVictimInsurance(val: any) {\r\n  //   return this.http.post(this.smartOffenderServiceUrl + '/VictimInsurances', val).pipe();\r\n  // }\r\n\r\n  // putVictimInsurance(id: any, val: any) {\r\n  //   return this.http.put(this.smartOffenderServiceUrl + '/VictimInsurances/?id=' + id, val).pipe();\r\n  // }\r\n\r\n  // deleteVictimInsurance(id: any) {\r\n  //   return this.http.delete(this.smartOffenderServiceUrl + '/VictimInsurances/?id=' + id).pipe();\r\n  // }\r\n  \r\n  // getVictimInsuranceTypes() {\r\n  //     return this.http.get(this.smartLookupServiceUrl + '/VictimInsuranceTypes').pipe();\r\n  // }\r\n\r\n  // getVictimInsurancePolicyHolders() {\r\n  //     return this.http.get(this.smartLookupServiceUrl + '/VictimInsurancePolicyHolders').pipe();\r\n  // }\r\n\r\n//   getVictimInsuranceSwitchReasons() {\r\n//       return this.http.get(this.smartLookupServiceUrl + '/VictimInsuranceSwitchReasons').pipe();\r\n//   }\r\n\r\n//   getVictimInsuranceProviders() {\r\n//       return this.http.get(this.smartLookupServiceUrl + '/VictimInsuranceProvider').pipe();\r\n//   }\r\n\r\n//   getVictimInsuranceProvider(id) {\r\n//     return this.http.get(this.smartLookupServiceUrl + '/VictimInsuranceProviders/' + id).pipe();\r\n// }\r\n\r\n//   postProviderInformation(val: any) {\r\n//       return this.http.post(this.smartLookupServiceUrl + '/VictimInsuranceProviders', val).pipe();\r\n//   }\r\n\r\ngetCurrentHousing(offenderId: number) {\r\n\r\n  return this.http\r\n    .get(this.smartOffenderServiceUrl + 'Housings/current/' + offenderId)\r\n    .pipe();\r\n}\r\n\r\nprivate handleError(error: any) {\r\n  console.error(error);\r\n  return observableThrowError(error.json().error || 'Server error');\r\n}\r\n\r\ngetDrugsTypes() {\r\n  return this.http.get(this.smartLookupServiceUrl  + 'DrugTypes', options).pipe\r\n      (\r\n      map(res => res)\r\n      );\r\n}\r\n\r\ngetDocketList(offenderId: number) {\r\n  const queryString = `\r\n  {\r\n    findDockets(input: { where: { offenderId:${offenderId} } }) {\r\n      totalCount\r\n      message\r\n      data {\r\n        docketId\r\n        docketNumber\r\n      \r\n      }\r\n    }\r\n  }`;\r\n\r\n  return this.http.post<any>(this.serviceApiUrl, { query: queryString }).pipe(\r\n    map(({ data }) => {\r\n      console.log('dockets for this offender:', data.findDockets.data);\r\n      return data.findDockets.data;\r\n    }));\r\n\r\n\r\n}\r\n\r\ngetSupportTypes() {\r\n  return this.http.get(this.smartLookupServiceUrl + 'VictimSupportTypes', options).pipe\r\n      (\r\n      map(res => res)\r\n      );\r\n}\r\n\r\ngetPrefixes() {\r\n  return this.http.get(this.smartLookupServiceUrl  + 'Prefixes', options).pipe\r\n      (\r\n      map(res => res)\r\n      );\r\n}\r\n\r\ngetSuffixes() {\r\n  return this.http.get(this.smartLookupServiceUrl  + 'Suffixes', options).pipe\r\n      (\r\n      map(res => res)\r\n      );\r\n}\r\n\r\ngetRelationshipTypes() {\r\n  return this.http.get(this.smartLookupServiceUrl  + 'RelationshipTypes', options).pipe\r\n      (\r\n      map(res => res)\r\n      );\r\n}\r\n\r\ngetGenders() {\r\n  return this.http.get(this.smartLookupServiceUrl  + 'Genders', options).pipe\r\n      (\r\n      map(res => res)\r\n      );\r\n}\r\n\r\ngetWeaponTypes() {\r\n  return this.http.get(this.smartLookupServiceUrl  + 'WeaponTypes', options).pipe\r\n      (\r\n      map(res => res)\r\n      );\r\n}\r\n\r\ngetFlagOptionYesNoUnknowns() {\r\n return this.http.get(this.smartLookupServiceUrl + 'FlagOptionYesNoUnknowns', options).pipe\r\n      (\r\n      map(res => { \r\n          return res;\r\n      })\r\n      );\r\n}\r\n\r\ngetContactTypes() {\r\n  return this.http.get(this.smartLookupServiceUrl + 'ContactTypes', options).pipe\r\n       (\r\n       map(res => { \r\n           return res;\r\n       })\r\n       );\r\n }\r\n getContactMethods() {\r\n  return this.http.get(this.smartLookupServiceUrl + 'VictimContactMethods', options).pipe\r\n       (\r\n       map(res => { \r\n           return res;\r\n       })\r\n       );\r\n }\r\n getContactBys(){\r\n  return this.http.get(this.smartLookupServiceUrl + 'VictimContactPurposes', options).pipe\r\n  (\r\n  map(res => { \r\n      return res;\r\n  })\r\n  );\r\n\r\n }\r\n\r\ngetVictimContactPurposes() {\r\n  return this.http.get(this.smartLookupServiceUrl + 'VictimContactPurposes', options).pipe\r\n       (\r\n       map(res => { \r\n           return res;\r\n       })\r\n       );\r\n }\r\n\r\n getVictimServiceTypes() {\r\n  return this.http.get(this.smartLookupServiceUrl + 'VictimServiceTypes', options).pipe\r\n       (\r\n       map(res => { \r\n           return res;\r\n       })\r\n       );\r\n }\r\n getVictimServiceStatus() {\r\n  return this.http.get(this.smartLookupServiceUrl + 'VictimServiceStatus', options).pipe\r\n       (\r\n       map(res => { \r\n           return res;\r\n       })\r\n       );\r\n }\r\n\r\n getvVictimServiceTypeProgramProviders() {\r\n  return this.http.get(this.smartLookupServiceUrl + 'vVictimServiceTypeProgramProviders', options).pipe\r\n       (\r\n       map(res => { \r\n           return res;\r\n       })\r\n       );\r\n }\r\n\r\n\r\ngetVictim(val: any) {\r\n  return this.http.get(this.smartVictimServiceUrl + 'Victims/' + val, options).pipe\r\n  (\r\n    map(res => { \r\n      console.log('victim return data');\r\n      console.log(res);  \r\n      return res;\r\n\r\n    })\r\n      );\r\n}\r\n\r\ngetVictimAdvocate(val: any) {\r\n  return this.http.get(this.smartVictimServiceUrl + 'VictimAdvocates/' + val, options).pipe\r\n      (\r\n\r\n      map(res => { \r\n          return res;})\r\n      );\r\n}\r\n\r\ngetVictimGuardian(val: any) {\r\n  return this.http.get(this.smartVictimServiceUrl + 'VictimGuardians/' + val, options).pipe\r\n      (\r\n\r\n      map(res => { \r\n          return res;})\r\n      );\r\n}\r\n\r\npostVictims(val: any) {\r\n  const tempVal = JSON.stringify(val);\r\n  return this.http.post(this.smartVictimServiceUrl+ 'Victims', tempVal, options).pipe\r\n      (\r\n      map(res => { return res;})\r\n      );\r\n}\r\n\r\nputVictims(id: any, val: any) {\r\n  const tempVal = JSON.stringify(val);\r\n  return this.http.put(this.smartVictimServiceUrl + 'Victims/' + id, tempVal, options).pipe\r\n      (\r\n      map(res => { return res;})\r\n      );\r\n}\r\n\r\nputVictimAdvocate(id: any, val: VictimAdvocate) {\r\n  let body: string;\r\n  body = JSON.stringify(val);\r\n  return this.http.put(this.smartVictimServiceUrl + 'VictimAdvocates/' + id, body, options).pipe\r\n      (\r\n      map(res => { return res;})\r\n      );\r\n\r\n\r\n\r\n\r\n}\r\n\r\npostVictimAdvocate(id: any, val: any) {\r\n  const tempVal = JSON.stringify(val);\r\n  return this.http.post(this.smartVictimServiceUrl + 'VictimAdvocates/' + id, tempVal, options).pipe\r\n      (\r\n      map(res => { return res;})\r\n      );\r\n}\r\n\r\nputVictimGuardian(id: any, val: any) {\r\n  console.log('update victim guardian');\r\n  console.log(val);\r\n  const tempVal = JSON.stringify(val);\r\n  return this.http.put(this.smartVictimServiceUrl + 'VictimGuardians/' + id, tempVal, options).pipe\r\n      (\r\n      map(res => { return res;})\r\n      );\r\n}\r\n\r\npostVictimGuardian(id: any, val: any) {\r\n  const tempVal = JSON.stringify(val);\r\n  return this.http.post(this.smartVictimServiceUrl + 'VictimGuardians/' + id, tempVal, options).pipe\r\n      (\r\n      map(res => { return res;})\r\n      );\r\n}\r\n\r\ngetVictimDrugUse(val: any): Observable<VictimDrugUse[]>{\r\n  return this.http.get(this.smartVictimServiceUrl + 'VictimDrugUses/' + val, options).pipe\r\n      (\r\n      map((res: VictimDrugUse[]) => { \r\n            return res;})\r\n      );\r\n}\r\n\r\nputVictimDrugUse(id: any, val: VictimDrugUse[]) {\r\n  const tempVal = JSON.stringify(val);\r\n\r\n  return this.http.put(this.smartVictimServiceUrl + 'VictimDrugUses/' + id, tempVal, options).pipe\r\n      (\r\n      map(res => { return res;})\r\n      );\r\n}\r\n\r\npostVictimDrugUse(id: any, val: any) {\r\n  const tempVal = JSON.stringify(val);\r\n  return this.http.post(this.smartVictimServiceUrl + 'VictimDrugUses/' + id, tempVal, options).pipe\r\n      (\r\n      map(res => { return res;})\r\n      );\r\n}\r\n\r\nputVictimWeaponUse(id: any, val: any) {\r\n  const tempVal = JSON.stringify(val);\r\n  return this.http.put(this.smartVictimServiceUrl + 'VictimWeaponUses/' + id, tempVal, options).pipe\r\n      (\r\n      map(res => { return res;})\r\n      );\r\n}\r\n\r\npostVictimWeaponUse(id: any, val: any) {\r\n  const tempVal = JSON.stringify(val);\r\n  return this.http.post(this.smartVictimServiceUrl + 'VictimWeaponUses/' + id, tempVal, options).pipe\r\n      (\r\n      map(res => { return res;})\r\n      );\r\n}\r\nputVictimSupport(id: any, val: any) {\r\n  const tempVal = JSON.stringify(val);\r\n  return this.http.put(this.smartVictimServiceUrl + 'VictimSupports/' + id, tempVal, options).pipe\r\n      (\r\n      map(res => { return res;})\r\n      );\r\n}\r\n\r\npostVictimSupport(id: any, val: any) {\r\n  const tempVal = JSON.stringify(val);\r\n  return this.http.post(this.smartVictimServiceUrl + 'VictimSupports/' + id, tempVal, options).pipe\r\n      (\r\n      map(res => { return res;})\r\n      );\r\n}\r\n\r\ndeleteVictims(val: any,  staffId: number) {\r\n  return this.http.delete(this.smartVictimServiceUrl+ 'Victims/' + val + '?staffId='+ staffId, options).pipe\r\n  (\r\n  map(res => { return res;})\r\n  );\r\n}\r\n\r\n\r\n// //==============Victim Serive===================================\r\n\r\ngetVictims(offenderId: number): Observable <Victim[]> {\r\n\r\n  return this.http.get(this.smartVictimServiceUrl  + 'Victims/offender/' + offenderId)\r\n  .pipe(map((res: Victim[]) => {\r\n    \r\n      return res;\r\n  })\r\n  ,catchError(this.handleError));\r\n}\r\n\r\ngetVictimsByFilter(filter: VictimListFilter): Observable<Victim[]>{\r\n  return this.http\r\n          .post(this.smartVictimServiceUrl + '/Victims', JSON.stringify(filter), { headers: headers })\r\n          .pipe(map((res: Victim[]) => {\r\n              return res;\r\n          })\r\n          ,catchError(this.handleError));\r\n}\r\n\r\ngetVictimListByFilter(filter: VictimListFilter) \r\n{\r\n  console.log('filer in service');\r\n  console.log(filter);\r\n\r\n  return this.http\r\n  .post(this.smartVictimServiceUrl + 'vVictims/Filter', JSON.stringify(filter), options)\r\n  .pipe();\r\n\r\n}\r\n\r\n\r\ngetCasetNotes(victimId: number): Observable <CaseNote[]> {\r\n\r\n  return this.http.get(this.smartVictimServiceUrl + 'VictimCaseNotes/victim/' + victimId)\r\n  .pipe(map((res: CaseNote[]) => {\r\n      return res;\r\n  })\r\n  ,catchError(this.handleError));\r\n \r\n\r\n}\r\naddCaseNote(caseNote: CaseNote) {\r\n  let body: string;\r\n         body = JSON.stringify(caseNote);\r\n         return this.http\r\n       .post(this.smartVictimServiceUrl + 'VictimCaseNotes/', body, options);\r\n \r\n }\r\n\r\n \r\nupdateCaseNote(caseNote: CaseNote){\r\n\r\n  let body: string;\r\n  body = JSON.stringify(caseNote);\r\n  return this.http\r\n      .put(this.smartVictimServiceUrl + 'VictimCaseNotes/' + caseNote.victimCaseNoteId, body, options)\r\n\r\n      ;\r\n }\r\n\r\ndeleteCaseNote(id: number, staffId: number) {\r\n      return this.http.delete(`${this.smartVictimServiceUrl}VictimCaseNotes/${id}?staffId=${staffId}`);\r\n  }\r\n\r\n  getContacts(victimId: number): Observable <Contact[]> {\r\n\r\n    return this.http.get(this.smartVictimServiceUrl + 'VictimContacts/victim/' + victimId)\r\n    .pipe(map((res: Contact[]) => {\r\n        return res;\r\n    })\r\n    ,catchError(this.handleError));\r\n  \r\n  }\r\n  addContact(contact: Contact) {\r\n    let body: string;\r\n           body = JSON.stringify(contact);\r\n           return this.http\r\n         .post(this.smartVictimServiceUrl + 'VictimContacts/', body, options);\r\n   \r\n   }\r\n  \r\n   \r\n  updateContact(contact: Contact){\r\n  \r\n    let body: string;\r\n    body = JSON.stringify(contact);\r\n    return this.http\r\n        .put(this.smartVictimServiceUrl + 'VictimContacts/' + contact.victimContactId, body, options)\r\n  \r\n        ;\r\n   }\r\n  \r\ngetSafetyPlans(victimId: number): Observable <VictimSafetyPlan[]> {\r\n\r\n      return this.http.get(this.smartVictimServiceUrl + 'vVictimServiceLists/victim/' + victimId)\r\n      .pipe(map((res: VictimSafetyPlan[]) => {\r\n          return res;\r\n      })\r\n      ,catchError(this.handleError));\r\n  }\r\n\r\ngetVictimServices(victimServiceId: number): Observable <VictimSafetyPlan[]> {\r\n\r\n      return this.http.get(this.smartVictimServiceUrl + 'vVictimServiceLists/victimServiceId/' + victimServiceId)\r\n      .pipe(map((res: VictimSafetyPlan[]) => {\r\n          return  res;\r\n      })\r\n      ,catchError(this.handleError));\r\n  \r\n  }\r\n\r\ngetVictimServiceDetail(victimServiceId: number): Observable <VictimServiceDetail[]> {\r\n\r\n  return this.http.get(this.smartVictimServiceUrl + 'VictimServiceDetails/' + victimServiceId)\r\n  .pipe(map((res: VictimServiceDetail[]) => {\r\n  \r\n      return res;\r\n  })\r\n  ,catchError(this.handleError));\r\n\r\n}\r\naddSafetyPlan(victimSafetyPlan: VictimSafetyPlan) {\r\n\r\n  let body: string;\r\n          body = JSON.stringify(victimSafetyPlan);\r\n          return this.http\r\n          .post(this.smartVictimServiceUrl + 'VictimServices/', body, options)\r\n          .pipe();\r\n  \r\n  }\r\nupdateSafetyPlan(victimSafetyPlan: VictimSafetyPlan){\r\n\r\n      let body: string;\r\n      body = JSON.stringify(victimSafetyPlan);\r\n      return this.http\r\n          .put(this.smartVictimServiceUrl + 'VictimServices/' + victimSafetyPlan.victimServiceId, body, options)\r\n\r\n          ;\r\n     }\r\naddVictimServiceStatus(victimServiceStatusHistory: VictimServiceStatusHistory){\r\n  let body: string;\r\n  body = JSON.stringify(victimServiceStatusHistory);\r\n  return this.http\r\n  .post(this.smartVictimServiceUrl + 'VictimServiceStatusHistories/', body, options);\r\n\r\n  }\r\n\r\ngetServiceStatusHistories(victimServiceId: number){\r\n  return this.http.get(this.smartVictimServiceUrl + 'VictimServiceStatusHistories/victimServiceId/' + victimServiceId)\r\n  .pipe(\r\n      map((res: VictimServiceStatusHistory[]) => {\r\n  \r\n          return res;\r\n      })\r\n      ,catchError(this.handleError)\r\n  );\r\n}\r\n\r\ndeleteSafetyPlan(victimServiceId: number, staffId: number) {\r\n  return this.http.delete(`${this.smartVictimServiceUrl}VictimServices/${victimServiceId}?staffId=${staffId}`);\r\n\r\n  }\r\naddPlanProvider(victimServiceDetail:VictimServiceDetail){\r\n      let body: string;\r\n      body = JSON.stringify(victimServiceDetail);\r\n      return this.http\r\n      .post(this.smartVictimServiceUrl + 'VictimServiceDetails/', body, options)\r\n      .pipe();\r\n\r\n  }\r\n\r\ndeleteProvider(victimProgramProviderId: string, staffId: number){\r\n  return this.http.delete(`${this.smartVictimServiceUrl}VictimServiceDetails/${victimProgramProviderId}?staffId=${staffId}`);\r\n\r\n}\r\n\r\n\r\n\r\n}\r\n"]}

package/{esm2020 → esm2022}/lib/victim-routing.module.mjs

@@ -1,41 +1,41 @@
-import { MsalGuard } from '@azure/msal-angular';
-import { SmartErrorComponent } from '@csmart/ngc-smart-core';
-import { LoginStaffResolverService, SelectedOffenderResolverService } from '@csmart/ngc-smart-core';
-import { RouterModule } from '@angular/router';
-import { NgModule } from '@angular/core';
-import { CaseNoteComponent } from './caseNote/caseNote.component';
-import { ContactComponent } from './contact/contact.component';
-import { VictimSafetyPlanComponent } from './safetyPlan/victimSafetyPlan.component';
-import { VictimSafetyPlanDetailComponent } from './safetyPlan/victimSafetyPlanDetail.component';
-import { SmartVictimDetailComponent } from './smart-victim-detail/smart-victim-detail.component';
-import { NgcSmartVictimComponent } from './smart-victim.component';
-import * as i0 from "@angular/core";
-import * as i1 from "@angular/router";
-const routes = [
-    //{path: 'casenote/:victimId', component: CaseNoteComponent,pathMatch: 'full',canActivate: [MsalGuard],resolve: { loginStaff: LoginStaffResolverService } },
-    { path: 'casenote/:victimId/:offenderId', component: CaseNoteComponent, pathMatch: 'full', canActivate: [MsalGuard], resolve: { loginStaff: LoginStaffResolverService } },
-    { path: 'saftyPlan/:victimId', component: VictimSafetyPlanComponent, pathMatch: 'full', resolve: { loginStaff: LoginStaffResolverService } },
-    { path: 'saftyPlanDetail/:victimServiceId/:victimId', component: VictimSafetyPlanDetailComponent, pathMatch: 'full', resolve: { loginStaff: LoginStaffResolverService } },
-    { path: 'victimList', component: NgcSmartVictimComponent, resolve: { loginStaff: LoginStaffResolverService, selectedOffender: SelectedOffenderResolverService } },
-    { path: 'victimHome', component: NgcSmartVictimComponent, resolve: { loginStaff: LoginStaffResolverService, selectedOffender: SelectedOffenderResolverService } },
-    { path: 'victimContact/:victimId', component: ContactComponent, resolve: { loginStaff: LoginStaffResolverService, selectedOffender: SelectedOffenderResolverService } },
-    { path: 'victimDetail/:victimId', component: SmartVictimDetailComponent, resolve: { loginStaff: LoginStaffResolverService, selectedOffender: SelectedOffenderResolverService } },
-    { path: 'smart-error', component: SmartErrorComponent }
-];
-export class VictimRoutingModule {
-}
-/** @nocollapse */ VictimRoutingModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: VictimRoutingModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-/** @nocollapse */ VictimRoutingModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: VictimRoutingModule, imports: [i1.RouterModule], exports: [RouterModule] });
-/** @nocollapse */ VictimRoutingModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: VictimRoutingModule, imports: [RouterModule.forChild(routes), RouterModule] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: VictimRoutingModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    imports: [
-                        RouterModule.forChild(routes)
-                    ],
-                    exports: [
-                        RouterModule
-                    ]
-                }]
-        }] });
-//# sourceMappingURL=data:application/json;base64,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
+import { MsalGuard } from '@azure/msal-angular';
+import { SmartErrorComponent } from '@csmart/ngc-smart-core';
+import { LoginStaffResolverService, SelectedOffenderResolverService } from '@csmart/ngc-smart-core';
+import { RouterModule } from '@angular/router';
+import { NgModule } from '@angular/core';
+import { CaseNoteComponent } from './caseNote/caseNote.component';
+import { ContactComponent } from './contact/contact.component';
+import { VictimSafetyPlanComponent } from './safetyPlan/victimSafetyPlan.component';
+import { VictimSafetyPlanDetailComponent } from './safetyPlan/victimSafetyPlanDetail.component';
+import { SmartVictimDetailComponent } from './smart-victim-detail/smart-victim-detail.component';
+import { NgcSmartVictimComponent } from './smart-victim.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+const routes = [
+    //{path: 'casenote/:victimId', component: CaseNoteComponent,pathMatch: 'full',canActivate: [MsalGuard],resolve: { loginStaff: LoginStaffResolverService } },
+    { path: 'casenote/:victimId/:offenderId', component: CaseNoteComponent, pathMatch: 'full', canActivate: [MsalGuard], resolve: { loginStaff: LoginStaffResolverService } },
+    { path: 'saftyPlan/:victimId', component: VictimSafetyPlanComponent, pathMatch: 'full', resolve: { loginStaff: LoginStaffResolverService } },
+    { path: 'saftyPlanDetail/:victimServiceId/:victimId', component: VictimSafetyPlanDetailComponent, pathMatch: 'full', resolve: { loginStaff: LoginStaffResolverService } },
+    { path: 'victimList', component: NgcSmartVictimComponent, resolve: { loginStaff: LoginStaffResolverService, selectedOffender: SelectedOffenderResolverService } },
+    { path: 'victimHome', component: NgcSmartVictimComponent, resolve: { loginStaff: LoginStaffResolverService, selectedOffender: SelectedOffenderResolverService } },
+    { path: 'victimContact/:victimId', component: ContactComponent, resolve: { loginStaff: LoginStaffResolverService, selectedOffender: SelectedOffenderResolverService } },
+    { path: 'victimDetail/:victimId', component: SmartVictimDetailComponent, resolve: { loginStaff: LoginStaffResolverService, selectedOffender: SelectedOffenderResolverService } },
+    { path: 'smart-error', component: SmartErrorComponent }
+];
+export class VictimRoutingModule {
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: VictimRoutingModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    /** @nocollapse */ static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.1.0", ngImport: i0, type: VictimRoutingModule, imports: [i1.RouterModule], exports: [RouterModule] }); }
+    /** @nocollapse */ static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: VictimRoutingModule, imports: [RouterModule.forChild(routes), RouterModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: VictimRoutingModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        RouterModule.forChild(routes)
+                    ],
+                    exports: [
+                        RouterModule
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/lib/victimSearch/VictimSearchFilter.mjs

@@ -1,3 +1,3 @@
-export class VictimListFilter {
-}
+export class VictimListFilter {
+}
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiVmljdGltU2VhcmNoRmlsdGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmdjLXNtYXJ0LXZpY3RpbS9zcmMvbGliL3ZpY3RpbVNlYXJjaC9WaWN0aW1TZWFyY2hGaWx0ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxPQUFPLGdCQUFnQjtDQVE1QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjbGFzcyBWaWN0aW1MaXN0RmlsdGVyIHtcclxuIFxyXG4gICAgb2ZmZW5kZXJJZDogbnVtYmVyO1xyXG4gICAgbGFzdE5hbWU6IHN0cmluZztcclxuICAgIGZpcnN0TmFtZTogc3RyaW5nO1xyXG4gICAgcGRpZDogc3RyaW5nO1xyXG4gICAgYmlydGhEYXRlOiBEYXRlO1xyXG4gIFxyXG59Il19

package/esm2022/lib/victimSearch/victimSearchForm.component.mjs

@@ -0,0 +1,38 @@
+import { Component, ViewEncapsulation, Output, EventEmitter } from '@angular/core';
+import { VictimListFilter } from './VictimSearchFilter';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "@angular/material/button";
+import * as i3 from "@angular/material/expansion";
+import * as i4 from "@angular/material/input";
+import * as i5 from "@angular/material/form-field";
+export class VictimSearchFormComponent {
+    constructor() {
+        this.onSearch = new EventEmitter();
+        this.change = new EventEmitter();
+        this.filter = new VictimListFilter();
+    }
+    ngOnInit() {
+    }
+    ngAfterViewInit() {
+        //   var element = <HTMLInputElement> document.getElementById("victimSearchButton");
+        //   element.disabled = true;
+        //   setTimeout(function() {
+        //     element.disabled = false;
+        // }, 10000);
+    }
+    onChange() {
+        console.log('this.filter in serach form.');
+        console.log(this.filter);
+        this.onSearch.emit(this.filter);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: VictimSearchFormComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.1.0", type: VictimSearchFormComponent, selector: "app-victim-search-form", outputs: { onSearch: "onSearch" }, ngImport: i0, template: "<form name=\"victimSearchFrom\"  #From=\"ngForm\">\r\n<mat-expansion-panel [expanded]=\"true\">\r\n        <mat-expansion-panel-header>\r\n            <mat-panel-title>\r\n                Search for Victims\r\n            </mat-panel-title>\r\n        </mat-expansion-panel-header>\r\n        <div class=\"victimSearch\">\r\n            <mat-form-field>\r\n                <input matInput placeholder=\"Victim Last Name\"  [(ngModel)]=\"filter.lastName\" name=\"lastName\" id=\"lastName\">\r\n            </mat-form-field>\r\n            <mat-form-field>\r\n                <input matInput placeholder=\"Victim First Name\"  [(ngModel)]=\"filter.firstName\" name=\"firstName\" id=\"firstName\">\r\n            </mat-form-field>\r\n            <mat-form-field>\r\n                <input matInput placeholder=\"Victim Date of Birth\" type=\"date\"    [(ngModel)]=\"filter.birthDate\" name=\"birthDate\" id=\"birthDate\">\r\n            </mat-form-field>\r\n            <mat-form-field>\r\n                <input matInput placeholder=\"Offender PDID\"  [(ngModel)]=\"filter.pdid\" name=\"pdid\" id=\"pdid\">\r\n            </mat-form-field>\r\n            <mat-form-field>\r\n                <input matInput placeholder=\"Offender CSOSA #\"[(ngModel)]=\"filter.offenderId\" name=\"offenderId\" id=\"offenderId\">\r\n            </mat-form-field>\r\n\r\n\r\n            <section>\r\n                <button  id=\"victimSearchButton\" mat-stroked-button color=\"primary\" (click)=\"onChange()\">Search</button>\r\n                <span style=\"padding-right: 5px;\"></span>\r\n                <button   mat-stroked-button color=\"primary\"  type=\"reset\" value=\"Reset\">Clear Changes</button>\r\n            </section>\r\n        </div>\r\n    </mat-expansion-panel>\r\n</form>\r\n\r\n\r\n", styles: ["div.services{max-width:500px;margin:auto;border:3px solid #73AD21}.rTable{display:block;width:100%}.rTableHeading,.rTableBody,.rTableFoot,.rTableRow{clear:both}.rTableHead,.rTableFoot{background-color:#ddd;font-weight:700}.rTableCell,.rTableHead{border:0px;float:left;padding:1px;width:28%}.rTable:after{visibility:hidden;display:block;font-size:0;content:\" \";clear:both;height:0}.victimSearch{display:grid;grid-template-columns:1fr 1fr 1fr;grid-column-gap:10px}.edit-btn{margin-right:4px}.main-container{display:flex;margin-top:8px}.add-action{display:flex;justify-content:flex-end;margin-bottom:8px}.example-headers-align .mat-expansion-panel-header-title,.example-headers-align .mat-expansion-panel-header-description{flex-basis:0}.example-headers-align .mat-expansion-panel-header-description{justify-content:space-between;align-items:center}mat-form-field{margin-right:12px}.actions{display:flex;justify-content:space-around}.Row{display:table;width:100%;table-layout:fixed}.Column{display:table-cell}.sp-form textarea{float:left;margin-top:20px;margin-bottom:10px;width:462px;height:70px;overflow:auto;box-sizing:border-box}.mat-column-lastName,.mat-column-firstName,.mat-column-relationship,.mat-column-homePhone,.mat-column-offenderName{word-wrap:break-word!important;white-space:unset!important;flex:0 0 15%!important;width:15%!important;overflow-wrap:break-word;word-wrap:break-word;word-break:break-word;-ms-hyphens:auto;-moz-hyphens:auto;-webkit-hyphens:auto;hyphens:auto}.mat-column-victimId{word-wrap:break-word!important;white-space:unset!important;flex:0 0 25%!important;width:25%!important;overflow-wrap:break-word;word-wrap:break-word;word-break:break-word;-ms-hyphens:auto;-moz-hyphens:auto;-webkit-hyphens:auto;hyphens:auto}\n"], dependencies: [{ kind: "directive", type: i1.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i1.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "component", type: i2.MatButton, selector: "    button[mat-button], button[mat-raised-button], button[mat-flat-button],    button[mat-stroked-button]  ", exportAs: ["matButton"] }, { kind: "component", type: i3.MatExpansionPanel, selector: "mat-expansion-panel", inputs: ["hideToggle", "togglePosition"], outputs: ["afterExpand", "afterCollapse"], exportAs: ["matExpansionPanel"] }, { kind: "component", type: i3.MatExpansionPanelHeader, selector: "mat-expansion-panel-header", inputs: ["expandedHeight", "collapsedHeight", "tabIndex"] }, { kind: "directive", type: i3.MatExpansionPanelTitle, selector: "mat-panel-title" }, { kind: "directive", type: i4.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }, { kind: "component", type: i5.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i1.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "directive", type: i1.NgForm, selector: "form:not([ngNoForm]):not([formGroup]),ng-form,[ngForm]", inputs: ["ngFormOptions"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: VictimSearchFormComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-victim-search-form', encapsulation: ViewEncapsulation.None, template: "<form name=\"victimSearchFrom\"  #From=\"ngForm\">\r\n<mat-expansion-panel [expanded]=\"true\">\r\n        <mat-expansion-panel-header>\r\n            <mat-panel-title>\r\n                Search for Victims\r\n            </mat-panel-title>\r\n        </mat-expansion-panel-header>\r\n        <div class=\"victimSearch\">\r\n            <mat-form-field>\r\n                <input matInput placeholder=\"Victim Last Name\"  [(ngModel)]=\"filter.lastName\" name=\"lastName\" id=\"lastName\">\r\n            </mat-form-field>\r\n            <mat-form-field>\r\n                <input matInput placeholder=\"Victim First Name\"  [(ngModel)]=\"filter.firstName\" name=\"firstName\" id=\"firstName\">\r\n            </mat-form-field>\r\n            <mat-form-field>\r\n                <input matInput placeholder=\"Victim Date of Birth\" type=\"date\"    [(ngModel)]=\"filter.birthDate\" name=\"birthDate\" id=\"birthDate\">\r\n            </mat-form-field>\r\n            <mat-form-field>\r\n                <input matInput placeholder=\"Offender PDID\"  [(ngModel)]=\"filter.pdid\" name=\"pdid\" id=\"pdid\">\r\n            </mat-form-field>\r\n            <mat-form-field>\r\n                <input matInput placeholder=\"Offender CSOSA #\"[(ngModel)]=\"filter.offenderId\" name=\"offenderId\" id=\"offenderId\">\r\n            </mat-form-field>\r\n\r\n\r\n            <section>\r\n                <button  id=\"victimSearchButton\" mat-stroked-button color=\"primary\" (click)=\"onChange()\">Search</button>\r\n                <span style=\"padding-right: 5px;\"></span>\r\n                <button   mat-stroked-button color=\"primary\"  type=\"reset\" value=\"Reset\">Clear Changes</button>\r\n            </section>\r\n        </div>\r\n    </mat-expansion-panel>\r\n</form>\r\n\r\n\r\n", styles: ["div.services{max-width:500px;margin:auto;border:3px solid #73AD21}.rTable{display:block;width:100%}.rTableHeading,.rTableBody,.rTableFoot,.rTableRow{clear:both}.rTableHead,.rTableFoot{background-color:#ddd;font-weight:700}.rTableCell,.rTableHead{border:0px;float:left;padding:1px;width:28%}.rTable:after{visibility:hidden;display:block;font-size:0;content:\" \";clear:both;height:0}.victimSearch{display:grid;grid-template-columns:1fr 1fr 1fr;grid-column-gap:10px}.edit-btn{margin-right:4px}.main-container{display:flex;margin-top:8px}.add-action{display:flex;justify-content:flex-end;margin-bottom:8px}.example-headers-align .mat-expansion-panel-header-title,.example-headers-align .mat-expansion-panel-header-description{flex-basis:0}.example-headers-align .mat-expansion-panel-header-description{justify-content:space-between;align-items:center}mat-form-field{margin-right:12px}.actions{display:flex;justify-content:space-around}.Row{display:table;width:100%;table-layout:fixed}.Column{display:table-cell}.sp-form textarea{float:left;margin-top:20px;margin-bottom:10px;width:462px;height:70px;overflow:auto;box-sizing:border-box}.mat-column-lastName,.mat-column-firstName,.mat-column-relationship,.mat-column-homePhone,.mat-column-offenderName{word-wrap:break-word!important;white-space:unset!important;flex:0 0 15%!important;width:15%!important;overflow-wrap:break-word;word-wrap:break-word;word-break:break-word;-ms-hyphens:auto;-moz-hyphens:auto;-webkit-hyphens:auto;hyphens:auto}.mat-column-victimId{word-wrap:break-word!important;white-space:unset!important;flex:0 0 25%!important;width:25%!important;overflow-wrap:break-word;word-wrap:break-word;word-break:break-word;-ms-hyphens:auto;-moz-hyphens:auto;-webkit-hyphens:auto;hyphens:auto}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { onSearch: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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