@spokane-folio/security-incident 1.0.28

package/src/settings/GetIncidentTypesDetails.js

@@ -0,0 +1,88 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { stripesConnect } from '@folio/stripes/core';
+import { IncidentContext } from '../contexts/IncidentContext';
+
+class GetIncidentTypesDetails extends React.Component {
+  static contextType = IncidentContext;
+  static manifest = Object.freeze({
+    incidentTypes: {
+      type: 'okapi',
+      path: 'incidents/configurations/incident-types',
+      records: 'data.value.incidentTypes',
+      throwErrors: false // prevent error modal if empty on first pass
+    },
+  });
+
+  static propTypes = {
+    resources: PropTypes.object.isRequired,
+    context: PropTypes.oneOf(['incidents', 'settings']).isRequired,
+    handleIncidentTypes: PropTypes.func, //only passed in 'settings' context
+  };
+
+  componentDidMount() {
+    // console.log("@GetIncidentTypesDetails - componentDidMount")
+    this.fetchRecords();
+  };
+
+  componentDidUpdate(prevProps) {
+    const resourceChanged = 
+    this.props.resources.incidentTypes !==
+    prevProps.resources.incidentTypes;
+
+    if (resourceChanged) {
+      // console.log("@GetIncidentTypesDetails - componentDidUPDATE")
+      this.fetchRecords();
+    };
+  };
+
+  fetchRecords() {
+    const incidentTypesBody = this.props.resources.incidentTypes;
+    if (!incidentTypesBody?.hasLoaded) return; 
+
+    const types = incidentTypesBody?.records;
+
+    if (!Array.isArray(types) || !types.length) return;
+
+    // make shape for id, title shape list
+    const incTypes = [...types]; 
+    const titlesAndIds = incTypes.map((type) => ({
+      id: type.id,
+      title: type.title,
+    }));
+
+    if (titlesAndIds) {
+      // set inc types names, ids list for ready use at 
+      // <IncidentsPaneset /> (app), < IncidentTypesPaneset/> (Settings)
+      this.context.setIncidentTypesNamesIdsList(titlesAndIds);
+    }
+
+
+    if (this.props.context === 'incidents') {
+      // set incident types for general application
+      this.context.setIncidentTypesList(types);
+
+    } else if (this.props.context === 'settings') {
+      /* 
+        set full-shape incidentTypes for Settings
+        <IncidentTypeDetailsPane />, <IncidentTypeEditPane />,
+        and <NewIncidentTypePane />. They pass handleIncidentTypes()
+        via props.
+      */ 
+      if (typeof this.props.handleIncidentTypes === 'function') {
+        this.props.handleIncidentTypes(types);
+      }
+    };
+  };
+
+  render() {
+    return null;
+  };
+};
+
+GetIncidentTypesDetails.contextType = IncidentContext;
+
+export default stripesConnect(
+  GetIncidentTypesDetails,
+  '@spokane-folio/security-incident'
+);

package/src/settings/GetIncidentTypesIds.js

@@ -0,0 +1,74 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { stripesConnect } from '@folio/stripes/core';
+import { IncidentContext } from '../contexts/IncidentContext';
+
+class GetIncidentTypesIds extends React.Component {
+  static contextType = IncidentContext;
+  /* 
+    'incTypesIds' named manifest key so no collision with 'incidentTypes' manifest key at GetIncidentTypesDetails.
+    GetIncidentTypesIds requests at the same /incident-types endpoint that
+    GetIncidentTypesDetails utilizes. GetIncidentTypesIds is for convenience. 
+  */ 
+  static manifest = Object.freeze({
+    incTypesIds: {
+      type: 'okapi',
+      path: 'incidents/configurations/incident-types'
+    },
+  });
+
+  static propTypes = {
+    resources: PropTypes.object.isRequired,
+    // not required, used in context of <IncidentTypesPaneset />
+    handleGetTypesList: PropTypes.func,
+    // leave use of oneOf for future addition
+    contextTypeProp: PropTypes.oneOf(['incident-types-paneset'])
+  };
+
+  componentDidMount() {
+    this.fetchRecords();
+  };
+
+  componentDidUpdate(prevProps) { 
+    const resourceChanged = 
+    this.props.resources.incTypesIds !== 
+    prevProps.resources.incTypesIds;
+    if (resourceChanged) {
+     this.fetchRecords();
+    };
+  };
+
+  fetchRecords() {
+    // console.log("this.props.resources --> ", JSON.stringify(this.props.resources, null, 2))
+    const incTypesIdsBody = this.props.resources.incTypesIds;
+    // console.log("incTypesIdsBody --> ", JSON.stringify(incTypesIdsBody, null, 2))
+    if (!incTypesIdsBody?.hasLoaded) return; 
+    
+    const incTypes = incTypesIdsBody?.records[0]?.data?.value?.incidentTypes;
+    // console.log("incTypes --> ", JSON.stringify(incTypes, null, 2));
+    
+    if (incTypes) {
+      const types = incTypes;
+      const titlesAndIds = types.map((type) => ({
+        id: type.id,
+        title: type.title,
+      }));
+
+      // console.log("titlesAndIds --> ", JSON.stringify(titlesAndIds, null, 2));
+
+      if (this.props.contextTypeProp === 'incident-types-paneset') {
+        this.props.handleGetTypesList(titlesAndIds);
+      };
+
+      this.context.setIncidentTypesNamesIdsList(titlesAndIds);
+    };
+  };
+
+  render() {
+    return null;
+  };
+};
+
+GetIncidentTypesIds.contextType = IncidentContext;
+
+export default stripesConnect(GetIncidentTypesIds, '@spokane-folio/security-incident');

package/src/settings/GetLocationsInService.js

@@ -0,0 +1,54 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { stripesConnect } from '@folio/stripes/core';
+import { IncidentContext } from '../contexts/IncidentContext';
+import alphabetize from './helpers/alphabetize';
+
+class GetLocationsInService extends React.Component {
+  static contextType = IncidentContext;
+  static manifest = Object.freeze({
+    locationsInService: {
+      type: 'okapi',
+      path: 'incidents/configurations/locations-in-service', 
+      records: 'data.value.locationsInService',
+      throwErrors: false // prevent error modal if empty on first pass
+    },
+  });
+
+  static propTypes = {
+    resources: PropTypes.object.isRequired,
+    handleFetchedLocationsInService: PropTypes.func,
+  };
+
+  componentDidMount() {
+    this.fetchRecords();
+  };
+
+  componentDidUpdate(prevProps) {
+    const resourceChanged = 
+      this.props.resources.locationsInService !== 
+      prevProps.resources.locationsInService;
+
+    if (resourceChanged) {
+      this.fetchRecords();
+    };
+  };
+
+  fetchRecords() {
+    const res = this.props.resources.locationsInService;
+    if (!res?.hasLoaded) return; 
+
+    const locationsInServiceList = res?.records;
+    if (!Array.isArray(locationsInServiceList)) return;
+
+    this.context.setLocationsInService(alphabetize(locationsInServiceList))
+  };
+
+  render() {
+    return null;
+  };
+};
+
+GetLocationsInService.contextType = IncidentContext;
+
+export default stripesConnect(GetLocationsInService, '@spokane-folio/security-incident');

package/src/settings/GetSingleCustomLocationDetails.js

@@ -0,0 +1,60 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { stripesConnect } from '@folio/stripes/core';
+
+class GetSingleCustomLocationDetails extends React.Component {
+  static manifest = Object.freeze({
+    customLocations: {
+      type: 'okapi',
+      path: 'configurations/entries?query=module==security-incident and configName=custom-locations and enabled=true',
+      accumulate: true,
+    },
+  });
+
+  static propTypes = {
+    customLocations: PropTypes.shape({
+      records: PropTypes.arrayOf(PropTypes.object),
+    }),
+    detailsId: PropTypes.string.isRequired,
+    handleFetchedDetails: PropTypes.func.isRequired,
+    mutator: PropTypes.shape({
+      customLocations: PropTypes.shape({
+        GET: PropTypes.func.isRequired,
+      }).isRequired,
+    }).isRequired,
+  };
+
+  componentDidMount() {
+    this.fetchCustomLocationDetails(this.props.detailsId);
+  }
+
+  componentDidUpdate(prevProps) {
+    if (this.props.detailsId !== prevProps.detailsId) {
+      this.fetchCustomLocationDetails(this.props.detailsId);
+    }
+  }
+
+  fetchCustomLocationDetails(id) {
+    this.props.mutator.customLocations
+      .GET({ path: 'configurations/entries?query=module==security-incident and configName=custom-locations and enabled=true' })
+      .then((records) => {
+        const valueObject = JSON.parse(records.configs[0].value);
+        const locations = valueObject.customLocations;
+        const singleLocation = locations.find((loc) => loc.id === id);
+        this.props.handleFetchedDetails(singleLocation);
+      })
+      .catch((error) => {
+        // placeholder
+        console.log('error fetching single custom location: ', error.message);
+      });
+  }
+
+  render() {
+    return <></>;
+  }
+}
+
+export default stripesConnect(
+  GetSingleCustomLocationDetails,
+  '@spokane-folio/security-incident'
+);

package/src/settings/GetSingleIncidentTypeDetails.js

@@ -0,0 +1,60 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { stripesConnect } from '@folio/stripes/core';
+class GetSingleIncidentTypeDetails extends React.Component {
+  static manifest = Object.freeze({
+    incidentTypes: {
+      type: 'okapi',
+      path: 'incidents/configurations/incident-types',
+      records: 'data.value.incidentTypes',
+      throwErrors: false
+    },
+  });
+
+  static propTypes = {
+    resources: PropTypes.object.isRequired,
+    detailsId: PropTypes.string.isRequired,
+    handleFetchedDetails: PropTypes.func.isRequired,
+  };
+
+  componentDidMount() {
+    this.fetchRecord(this.props.detailsId);
+  };
+
+  componentDidUpdate(prevProps) {
+    const resourceChanged = 
+      this.props.resources.incidentTypes !== 
+      prevProps.resources.incidentTypes;
+    const idChanged = this.props.detailsId !== prevProps.detailsId;
+
+    if (idChanged || resourceChanged) {
+      this.fetchRecord(this.props.detailsId);
+    };
+  };
+
+  fetchRecord(id) {
+    const res = this.props.resources.incidentTypes;
+    console.log("res --> ", JSON.stringify(res, null, 2))
+    if (!res?.hasLoaded) return; 
+
+    const incTypesRecords = res?.records;
+    console.log("incTypesRecords --> ", JSON.stringify(incTypesRecords, null, 2));
+
+
+    const singleType = incTypesRecords.find((type) => type.id === id);
+    this.props.handleFetchedDetails(singleType);
+    if (singleType) {
+      console.log("singleType --> ", JSON.stringify(singleType, null, 2));
+      this.props.handleFetchedDetails(singleType);
+    }
+  };
+
+  render() {
+    return null;
+  };
+};
+
+export default stripesConnect(
+  GetSingleIncidentTypeDetails,
+  '@spokane-folio/security-incident'
+);

package/src/settings/GetTrespassReasons.js

@@ -0,0 +1,67 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { stripesConnect } from '@folio/stripes/core';
+import { IncidentContext } from '../contexts/IncidentContext';
+
+class GetTrespassReasons extends React.Component {
+  static contextType = IncidentContext;
+  static manifest = Object.freeze({
+    trespassReasons: {
+      type: 'okapi',
+      path: 'incidents/configurations/trespass-reasons',
+      records: 'data.value.trespassReasons',
+      throwErrors: false
+    },
+  });
+
+  static propTypes = {
+    resources: PropTypes.object.isRequired,
+    handleFetchedTrespassReasons: PropTypes.func,
+    reloadKey: PropTypes.number // not required (invoked by Settings <TrespassReasonsPaneset> on new tr)
+  };
+
+  componentDidMount() {
+    this.fetchRecords();
+  };
+
+  componentDidUpdate(prevProps) {
+    // if parent bumped reloadKey make stripes refetch now
+    if (this.props.reloadKey !== prevProps.reloadKey) {
+      this.props.mutator.trespassReasons.reset?.();
+      this.props.mutator.trespassReasons.GET?.();
+      return;
+    }
+   const resourceChanged = 
+    this.props.resources.trespassReasons !==
+    prevProps.resources.trespassReasons;
+
+   if (resourceChanged) {
+    this.fetchRecords();
+   };
+  };
+
+  fetchRecords = () => {
+    const trBody = this.props.resources.trespassReasons;
+    if (!trBody?.hasLoaded || trBody?.isPending) return; // don't hit trespassReasons context value w/ partial
+
+    const reasons = trBody?.records;
+    if (Array.isArray(reasons)) {
+      this.context.setTrespassReasons(reasons)  
+    } else {
+      console.error(
+        `Error: skip setter, records not array`
+      );
+    }
+  };
+
+  render() {
+    return null;
+  };
+};
+
+GetTrespassReasons.contextType = IncidentContext;
+
+export default stripesConnect(
+  GetTrespassReasons,
+  '@spokane-folio/security-incident'
+);

package/src/settings/GetTrespassTemplates.js

@@ -0,0 +1,51 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { stripesConnect } from '@folio/stripes/core';
+import { IncidentContext } from '../contexts/IncidentContext';
+
+class GetTrespassTemplates extends React.Component {
+  static contextType = IncidentContext;
+  static manifest = Object.freeze({
+    trespassTemplates: {
+      type: 'okapi',
+      path: 'incidents/configurations/trespass-templates',
+      records: 'data.value.templates',
+      throwErrors: false // prevent error modal if empty on first pass
+    },
+  });
+
+  static propTypes = {
+    resources: PropTypes.object.isRequired,
+    handleFetchedTrespassTemplates: PropTypes.func,
+  };
+
+  componentDidMount() {
+    this.fetchRecords();
+  };
+
+  componentDidUpdate(prevProps) {
+    const resourceChanged =
+      this.props.resources.trespassTemplates !==
+      prevProps.resources.trespassTemplates;
+
+    if (resourceChanged) {
+      this.fetchRecords();
+    };
+  }; 
+
+  fetchRecords = () => {
+    const res = this.props.resources.trespassTemplates;
+    if (!res?.hasLoaded) return; 
+
+    const trespassTemplatesList = res?.records;
+    if (!Array.isArray(trespassTemplatesList)) return;
+
+    this.context.setTrespassTemplates(trespassTemplatesList);
+  };
+
+  render() {
+    return null;
+  };
+};
+
+export default stripesConnect(GetTrespassTemplates, '@spokane-folio/security-incident');