@worksafevictoria/wcl7.5 1.1.0-beta.9 → 1.1.0-beta.91

package/src/components/Paragraphs/Chart/index.vue

@@ -5,7 +5,7 @@
         <single-taxonomy
           v-for="(t, i) in computedPropFilters"
           :key="i"
-          :ref="`${t.record_id}`"
+          ref="items"
           :data="t"
           :results="filteredList.length"
           :loading="isFiltering"
@@ -42,8 +42,8 @@
                 ? chart.filter === 'primary'
                   ? by_primary()
                   : chart.filter === 'months'
-                  ? by_months()
-                  : compare()
+                    ? by_months()
+                    : compare()
                 : noData()
             "
             :options="chart.options"
@@ -54,264 +54,255 @@
   </container>
 </template>
 
-<script>
+<script setup>
 import { GChart } from 'vue-google-charts'
-import Container from '../../Containers/Container/index.vue' 
+import Container from '../../Containers/Container/index.vue'
 import Column from '../../Containers/Column/index.vue'
 import Row from '../../Containers/Row/index.vue'
 import FilterButton from '../../Common/FilterButton/index.vue' // Reset
 import SingleTaxonomy from '../../Global/DirectoryFilters/SingleTaxonomy/index.vue'
 import { BFormGroup, BFormSelect } from 'bootstrap-vue-next'
+import { defineProps, computed, toRefs, ref, useTemplateRef } from 'vue'
 
-export default {
-  name: 'Chart',
-  components: {
-    Row,
-    Column,
-    Container,
-    GChart,
-    FilterButton,
-    SingleTaxonomy,
-    BFormGroup,
-    BFormSelect
-  },
-  props: {
-    statsData: { type: Array, default: () => [] },
-    filterFields: { type: Array, default: () => [] },
-    chart: { type: Object, default: () => {} }
-  },
-  data() {
+const props = defineProps({
+  statsData: { type: Array, default: () => [] },
+  filterFields: { type: Array, default: () => [] },
+  chart: { type: Object, default: () => {} },
+})
+
+const { statsData, filterFields, chart } = toRefs(props)
+
+const hideReset = ref(true)
+const isFiltering = ref(false)
+const filters = ref({
+  taxonomies: [],
+  selected: {},
+  availableBundles: [],
+})
+const graphSelected = ref(null)
+const chartHeight = ref(
+  chart.value.options.height ? chart.value.options.height : 600,
+)
+
+const itemRefs = useTemplateRef('items')
+
+const graphOptions = computed(() => {
+  return filterFields.value.slice(1).map((field) => {
+    if (!graphSelected.value) {
+      graphSelected.value = field.record_id
+    }
+    return { value: field.record_id, text: field.name }
+  })
+})
+
+const computedPropFilters = computed(() => {
+  let fields = filterFields.value.map((field) => {
+    let terms = null
+    if (field.date) {
+      terms = statsData.value
+        .map((item) => item[field.record_id].split('/')[2]) // Date field get year
+        .filter((value, index, self) => self.indexOf(value) === index)
+        .map((value) => {
+          return { tid: value, name: value, preselected: false }
+        })
+        .sort((a, b) => a.name.localeCompare(b.name))
+    } else {
+      terms = statsData.value
+        .map((item) => item[field.record_id])
+        .filter((value, index, self) => self.indexOf(value) === index)
+        .map((value) => {
+          return { tid: value, name: value, preselected: false }
+        })
+        .sort((a, b) => a.name.localeCompare(b.name))
+    }
     return {
-      hideReset: true,
-      isFiltering: false,
-      filters: {
-        taxonomies: [],
-        selected: {},
-        availableBundles: []
-      },
-      graphSelected: null,
-      chartHeight: this.chart.options.height ? this.chart.options.height : 600
+      name: field.name,
+      record_id: field.record_id,
+      terms,
     }
-  },
-  computed: {
-    graphOptions: function() {
-      return this.filterFields.slice(1).map((field) => {
-        if (!this.graphSelected) {
-          this.graphSelected = field.record_id
-        }
-        return { value: field.record_id, text: field.name }
-      })
-    },
-    computedPropFilters: function() {
-      let fields = this.filterFields.map((field) => {
-        let terms = null
-        if (field.date) {
-          terms = this.statsData
-            .map((item) => item[field.record_id].split('/')[2]) // Date field get year
-            .filter((value, index, self) => self.indexOf(value) === index)
-            .map((value) => {
-              return { tid: value, name: value, preselected: false }
-            })
-            .sort((a, b) => a.name.localeCompare(b.name))
+  })
+  return fields
+})
+
+const filteredList = computed(() => {
+  let filterKeys = Object.keys(filters.value.selected).map((key) => key)
+  let list = statsData.value.filter((element) => {
+    let include = true
+    for (var i = 0, n = filterKeys.length; i < n; ++i) {
+      if (filters.value.selected[filterKeys[i]].length > 0) {
+        let filterType = filterFields.value.find(
+          (item) => item.record_id === filterKeys[i],
+        )
+        if (filterType.date) {
+          // Filter by year
+          if (
+            filters.value.selected[filterKeys[i]].indexOf(
+              element[filterKeys[i]].split('/')[2],
+            ) === -1
+          ) {
+            include = false
+          }
         } else {
-          terms = this.statsData
-            .map((item) => item[field.record_id])
-            .filter((value, index, self) => self.indexOf(value) === index)
-            .map((value) => {
-              return { tid: value, name: value, preselected: false }
-            })
-            .sort((a, b) => a.name.localeCompare(b.name))
-        }
-        return {
-          name: field.name,
-          record_id: field.record_id,
-          terms
-        }
-      })
-      return fields
-    },
-    filteredList: function() {
-      let filterKeys = Object.keys(this.filters.selected).map((key) => key)
-      let list = this.statsData.filter((element) => {
-        let include = true
-        for (var i = 0, n = filterKeys.length; i < n; ++i) {
-          if (this.filters.selected[filterKeys[i]].length > 0) {
-            let filterType = this.filterFields.find(
-              (item) => item.record_id === filterKeys[i]
-            )
-            if (filterType.date) {
-              // Filter by year
-              if (
-                this.filters.selected[filterKeys[i]].indexOf(
-                  element[filterKeys[i]].split('/')[2]
-                ) === -1
-              ) {
-                include = false
-              }
-            } else {
-              if (
-                this.filters.selected[filterKeys[i]].indexOf(
-                  element[filterKeys[i]]
-                ) === -1
-              ) {
-                include = false
-              }
-            }
+          if (
+            filters.value.selected[filterKeys[i]].indexOf(
+              element[filterKeys[i]],
+            ) === -1
+          ) {
+            include = false
           }
         }
-        if (include) {
-          return element
-        }
-      })
-      return list
+      }
     }
-  },
-  methods: {
-    onFilter(filters) {
-      this.hideReset = false
-      const allFiltersUnselected = Object.values(this.$refs).every(
-        (taxonomy) => {
-          return Object.values(taxonomy[0].selectedFilters).every(
-            (filter) => filter.filter((item) => !item.preselected).length === 0
-          )
-        }
+    if (include) {
+      return element
+    }
+  })
+  return list
+})
+
+const onFilter = (filterParam) => {
+  hideReset.value = false
+  const allFiltersUnselected = Object.values(itemRefs.value).every(
+    (taxonomy) => {
+      return Object.values(taxonomy.selectedFilters).every(
+        (filter) => filter.filter((item) => !item.preselected).length === 0,
       )
-      if (allFiltersUnselected) {
-        this.hideReset = true
-      }
-      Object.keys(filters).forEach((filter) => {
-        this.filters.selected[filter] = filters[filter].map((obj) => obj.tid)
-      })
     },
-    reset() {
-      this.hideReset = true
-      Object.keys(this.$refs).forEach((key) => {
-        this.$refs[key][0].reset()
-      })
-      this.filters.selected = {}
-    },
-    by_primary() {
-      let primaryFilter = this.filterFields[0]
-      let data = [[primaryFilter.name, this.chart.header]]
-      let keys = {}
+  )
+  if (allFiltersUnselected) {
+    hideReset.value = true
+  }
+  Object.keys(filterParam).forEach((filter) => {
+    filters.value.selected[filter] = filterParam[filter].map((obj) => obj.tid)
+  })
+}
+const reset = () => {
+  hideReset.value = true
+  Object.keys(itemRefs.value).forEach((key) => {
+    itemRefs.value[key].reset()
+  })
+  filters.value.selected = {}
+}
+const by_primary = () => {
+  let primaryFilter = filterFields.value[0]
+  let data = [[primaryFilter.name, chart.value.header]]
+  let keys = {}
 
-      this.filteredList.forEach((element) => {
-        // Work off primary field
-        let group = null
-        if (primaryFilter.date) {
-          group = `${element[primaryFilter.record_id].split('/')[2]} `
-        } else {
-          group = element[primaryFilter.record_id]
-        }
+  filteredList.value.forEach((element) => {
+    // Work off primary field
+    let group = null
+    if (primaryFilter.date) {
+      group = `${element[primaryFilter.record_id].split('/')[2]} `
+    } else {
+      group = element[primaryFilter.record_id]
+    }
 
-        if (group in keys) {
-          keys[group]++
-        } else {
-          keys[group] = 1
-        }
-      })
-      Object.keys(keys).forEach((item) => {
-        data.push([item, keys[item]])
-      })
-      if (this.chart.type === 'BarChart') {
-        this.chart.options.height = data[0].length * 200
-      } else {
-        this.chart.options.height = this.chartHeight
-      }
-      return data
-    },
-    by_months() {
-      let primaryFilter = this.filterFields[0]
-      if (!primaryFilter.date) {
-        return ['Requires date in primary field']
-      }
-      let data = [
-        ['Month'],
-        ['Jan'],
-        ['Feb'],
-        ['Mar'],
-        ['Apr'],
-        ['May'],
-        ['Jun'],
-        ['Jul'],
-        ['Aug'],
-        ['Sep'],
-        ['Oct'],
-        ['Nov'],
-        ['Dec']
-      ]
-      let years = this.filteredList
-        .map((item) => item[primaryFilter.record_id].split('/')[2])
-        .filter((value, index, self) => self.indexOf(value) === index)
-      data[0].push(...years)
-      for (var i = 1, n = data.length; i < n; ++i) {
-        for (var j = 0, m = years.length; j < m; ++j) {
-          data[i].push(0)
-        }
-      }
-      this.filteredList.forEach((element) => {
-        let year = element[primaryFilter.record_id].split('/')[2]
-        let month = element[primaryFilter.record_id].split('/')[1]
-        data[month][data[0].indexOf(year)]++
-      })
-      for (var i = 2; i < data.length; i++) {
-        for (var j = 1; j < data[i].length; j++) {
-          data[i][j] = data[i][j] + data[i - 1][j]
-        }
-      }
-      if (this.chart.type === 'BarChart') {
-        this.chart.options.height = data[0].length * 200
-      } else {
-        this.chart.options.height = this.chartHeight
-      }
-      return data
-    },
-    compare() {
-      let primaryFilter = this.filterFields[0]
-      let comparison = this.filteredList
-        .map((item) => item[this.graphSelected])
-        .filter((value, index, self) => self.indexOf(value) === index)
-        .sort((a, b) => a.localeCompare(b))
-      let data = [['Year', ...comparison]]
-      let keys = {}
-      this.filteredList.forEach((element) => {
-        let group = null
-        if (primaryFilter.date) {
-          group = `${element[primaryFilter.record_id].split('/')[2]} `
-        } else {
-          group = element[primaryFilter.record_id]
-        }
-        if (group in keys) {
-        } else {
-          keys[group] = {}
-          comparison.forEach((co) => {
-            keys[group][co] = 0
-          })
-        }
-        keys[group][element[this.graphSelected]]++
-      })
-      Object.keys(keys).forEach((key) => {
-        data.push([key, ...Object.entries(keys[key]).map(([k, v]) => v)])
+    if (group in keys) {
+      keys[group]++
+    } else {
+      keys[group] = 1
+    }
+  })
+  Object.keys(keys).forEach((item) => {
+    data.push([item, keys[item]])
+  })
+  if (chart.value.type === 'BarChart') {
+    chart.value.options.height = data[0].length * 200
+  } else {
+    chart.value.options.height = chartHeight.value
+  }
+  return data
+}
+const by_months = () => {
+  let primaryFilter = filterFields.value[0]
+  if (!primaryFilter.date) {
+    return ['Requires date in primary field']
+  }
+  let data = [
+    ['Month'],
+    ['Jan'],
+    ['Feb'],
+    ['Mar'],
+    ['Apr'],
+    ['May'],
+    ['Jun'],
+    ['Jul'],
+    ['Aug'],
+    ['Sep'],
+    ['Oct'],
+    ['Nov'],
+    ['Dec'],
+  ]
+  let years = filteredList.value
+    .map((item) => item[primaryFilter.record_id].split('/')[2])
+    .filter((value, index, self) => self.indexOf(value) === index)
+  data[0].push(...years)
+  for (var i = 1, n = data.length; i < n; ++i) {
+    for (var j = 0, m = years.length; j < m; ++j) {
+      data[i].push(0)
+    }
+  }
+  filteredList.value.forEach((element) => {
+    let year = element[primaryFilter.record_id].split('/')[2]
+    let month = element[primaryFilter.record_id].split('/')[1]
+    data[month][data[0].indexOf(year)]++
+  })
+  for (var i = 2; i < data.length; i++) {
+    for (var j = 1; j < data[i].length; j++) {
+      data[i][j] = data[i][j] + data[i - 1][j]
+    }
+  }
+  if (chart.value.type === 'BarChart') {
+    chart.value.options.height = data[0].length * 200
+  } else {
+    chart.value.options.height = chartHeight.value
+  }
+  return data
+}
+const compare = () => {
+  let primaryFilter = filterFields.value[0]
+  let comparison = filteredList.value
+    .map((item) => item[graphSelected.value])
+    .filter((value, index, self) => self.indexOf(value) === index)
+    .sort((a, b) => a.localeCompare(b))
+  let data = [['Year', ...comparison]]
+  let keys = {}
+  filteredList.value.forEach((element) => {
+    let group = null
+    if (primaryFilter.date) {
+      group = `${element[primaryFilter.record_id].split('/')[2]} `
+    } else {
+      group = element[primaryFilter.record_id]
+    }
+    if (group in keys) {
+    } else {
+      keys[group] = {}
+      comparison.forEach((co) => {
+        keys[group][co] = 0
       })
-      if (this.chart.type === 'BarChart') {
-        this.chart.options.height = data[0].length * 200
-      } else {
-        this.chart.options.height = this.chartHeight
-      }
-      return data
-    },
-    noData() {
-      return [
-        [
-          { label: 'Results', type: 'string' },
-          { label: 'Results', type: 'number' },
-          { role: 'style', type: 'string' },
-          { role: 'annotation', type: 'string' }
-        ],
-        ['', 0, null, 'No results found']
-      ]
     }
+    keys[group][element[graphSelected.value]]++
+  })
+  Object.keys(keys).forEach((key) => {
+    data.push([key, ...Object.entries(keys[key]).map(([k, v]) => v)])
+  })
+  if (chart.value.type === 'BarChart') {
+    chart.value.options.height = data[0].length * 200
+  } else {
+    chart.value.options.height = chartHeight.value
   }
+  return data
+}
+const noData = () => {
+  return [
+    [
+      { label: 'Results', type: 'string' },
+      { label: 'Results', type: 'number' },
+      { role: 'style', type: 'string' },
+      { role: 'annotation', type: 'string' },
+    ],
+    ['', 0, null, 'No results found'],
+  ]
 }
 </script>
 

package/src/components/Paragraphs/Directory/Records/CJ/index.vue

@@ -30,9 +30,9 @@
   </div>
 </template>
 <script>
-import Container from '../../../../Containers/Container'
-import Row from '../../../../Containers/Row'
-import Column from '../../../../Containers/Column'
+import Container from '../../../../Containers/Container/index.vue'
+import Row from '../../../../Containers/Row/index.vue'
+import Column from '../../../../Containers/Column/index.vue'
 import { format } from 'date-fns'
 
 export default {

package/src/components/Paragraphs/Directory/Records/HSCP/index.stories.js

@@ -0,0 +1,32 @@
+import hscpRecord from './index.vue'
+
+const cpData = 
+    {
+        title: 'Australian Nurses and Midwifery Federation - Victorian Branch',
+        fulladdress: 'Level 8/535 Elizabeth St Melbourne VIC 3000',
+        workphone: '03 9275 9333',
+        tollfreephone: '1800 133 353',
+        email: 'ohs@anmfvic.asn.au',
+        website: 'https://www.anmfvic.asn.au/education-and-training/hsr-training/events',
+        courses: ['HSR Initial', 'HSR Refresher'],
+        // companyid: 'ACAR-A842BA'
+    }
+
+
+export default {
+    title: 'Paragraphs/Directory/Record',
+    component: hscpRecord,
+    tags: ['autodocs'],
+    argTypes: {
+        location: {
+            control: ['object', 'boolean'],
+            table: { disable: true }
+          },
+    }
+}
+
+export const CourseProvider = {}
+
+CourseProvider.args = {
+    item: cpData,    
+}