@dative-gpi/foundation-core-components 1.0.69 → 1.0.71-groupings-2

package/components/lists/chartOrganisations/FSBaseChartOrganisationsList.vue

@@ -1,10 +1,14 @@
 <template>
   <FSDataTable
+    defaultMode="iterator"
     :items="chartOrganisations"
     :itemTo="$props.itemTo"
     :loading="fetchingChartOrganisations"
+    :headersOptions="headersOptions"
     :tableCode="$props.tableCode"
     :modelValue="$props.modelValue"
+    :singleSelect="$props.singleSelect"
+    :selectable="$props.selectable"
     @update:modelValue="$emit('update:modelValue', $event)"
     v-bind="$attrs"
   >
@@ -39,6 +43,7 @@
         height="32px"
         width="32px"
         :imageId="item.imageId"
+        :thumbnail="true"
       />
     </template>
     <template
@@ -46,27 +51,48 @@
     >
       <FSTagGroup
         variant="slide"
-        :editable="false"
         :tags="item.tags"
+        :showRemove="false"
       />
     </template>
     <template
       #item.modelsLabels="{ item }"
     >
       <FSTagGroup
-        :editable="false"
+        variant="slide"
         :tags="item.modelsLabels.map((d: any) => d.label)"
+        :showRemove="false"
       />
     </template>
     <template
-      #item.tile="{ item }"
+      #item.chartType="{ item }"
+    >
+      <FSRow
+        :wrap="false"
+      >
+        <FSIcon
+          :icon="chartIcon(item.chartType)"
+        />
+        <FSText>
+          {{ chartTypeLabel(item.chartType) }}
+        </FSText>
+      </FSRow>
+    </template>
+    <template
+      #item.tile="{ index, item, toggleSelect }"
     >
       <FSChartTileUI
+        :key="index"
         :label="item.label"
+        :singleSelect="$props.singleSelect"
+        :selectable="$props.selectable"
         :categoryLabel="item.chartCategoryLabel"
         :icon="item.icon"
         :imageId="item.imageId"
         :type="item.chartType"
+        :scope="item.scope"
+        :modelValue="isSelected(item.id)"
+        @update:modelValue="toggleSelect(item)"
         :to="$props.itemTo && $props.itemTo(item)"
       />
     </template>
@@ -74,85 +100,123 @@
 </template>
 
 <script lang="ts">
-import { defineComponent, type PropType, watch } from "vue";
+import { computed, defineComponent, type PropType, watch } from "vue";
 import type { RouteLocation } from "vue-router";
 import _ from "lodash";
 
+import { ChartType } from "@dative-gpi/foundation-shared-domain/enums";
+import { getEnumEntries } from "@dative-gpi/foundation-shared-domain/tools";
 import { ColorEnum } from "@dative-gpi/foundation-shared-components/models";
-import { PlotPer } from "@dative-gpi/foundation-shared-domain/enums";
+import { chartTypeLabel, chartIcon } from "@dative-gpi/foundation-shared-components/tools";
 
-import { type ChartOrganisationFilters, type ChartOrganisationInfos } from "@dative-gpi/foundation-core-domain/models";
+import type { ChartModelLabel, ChartOrganisationFilters, ChartOrganisationInfos } from "@dative-gpi/foundation-core-domain/models";
 import { useChartOrganisations } from "@dative-gpi/foundation-core-services/composables";
 
-import FSDataTable from "../FSDataTable.vue";
+import FSRow from "@dative-gpi/foundation-shared-components/components/FSRow.vue";
+import FSText from "@dative-gpi/foundation-shared-components/components/FSText.vue";
 import FSIcon from "@dative-gpi/foundation-shared-components/components/FSIcon.vue";
 import FSImage from "@dative-gpi/foundation-shared-components/components/FSImage.vue";
 import FSTagGroup from "@dative-gpi/foundation-shared-components/components/FSTagGroup.vue";
 import FSChartTileUI from "@dative-gpi/foundation-shared-components/components/tiles/FSChartTileUI.vue";
 
+import FSDataTable from "../FSDataTable.vue";
+
 export default defineComponent({
   name: "FSBaseChartOrganisationsList",
   components: {
+    FSChartTileUI,
     FSDataTable,
-    FSIcon,
-    FSImage,
     FSTagGroup,
-    FSChartTileUI
+    FSImage,
+    FSIcon,
+    FSText,
+    FSRow,
   },
   props: {
-    modelValue: {
-      type: Array as PropType<string[]>,
-      default: () => [],
-      required: false
+    tableCode: {
+      type: String as PropType<string | null>,
+      required: false,
+      default: null
     },
     chartOrganisationFilters: {
       type: Object as PropType<ChartOrganisationFilters>,
       required: false,
       default: null
     },
-    plotPer: {
-      type: Number as PropType<PlotPer>,
-      required: false,
-      default: PlotPer.None
-    },
-    tableCode: {
-      type: String,
-      required: true
-    },
     itemTo: {
       type: Function as PropType<(item: ChartOrganisationInfos) => Partial<RouteLocation>>,
       required: false
-    }
+    },
+    modelValue: {
+      type: Array as PropType<string[]>,
+      default: () => [],
+      required: false
+    },
+    selectable: {
+      type: Boolean,
+      required: false,
+      default: true
+    },
+    singleSelect: {
+      type: Boolean,
+      required: false,
+      default: false
+    },
   },
   emits: ["update:modelValue"],
   setup(props) {
-
     const { entities: chartOrganisations, fetching: fetchingChartOrganisations, getMany: getManyChartOrganisations } = useChartOrganisations();
 
+    const headersOptions = computed(() => ({
+      modelsLabels: {
+        fixedFilters: chartOrganisations.value.map(c => c.modelsLabels).reduce((acc, models) => {
+          for (const m of models) {
+            if (!acc.map((m) => m.id).includes(m.id)) {
+              acc.push(m);
+            }
+          }
+          return acc;
+        }, []).map((m) =>  ({
+          value: m.id,
+          text: m.label
+        })).concat({
+          value: '',
+          text: '--'
+        }),
+        methodFilter: (value: string, items: ChartModelLabel[]) => (items.length == 0 && value == '') || (items.length  > 0 && items.some(ml => ml.id == value))
+      },
+      chartType: {
+        fixedFilters: getEnumEntries(ChartType).map(e => ({
+          value: e.value,
+          text: chartTypeLabel(e.value)
+        })),
+        methodFilter: (value: ChartType, item: ChartType) => value == item
+      }
+    }));
+
+
     const isSelected = (id: string): boolean => {
       return props.modelValue.includes(id);
     };
 
     const fetch = () =>{
-      if(props.plotPer === PlotPer.None) {
-        getManyChartOrganisations(props.chartOrganisationFilters);
-      } else {
-        getManyChartOrganisations({...props.chartOrganisationFilters, plotPer: props.plotPer});
-      }
+      getManyChartOrganisations(props.chartOrganisationFilters);
     }
  
-    watch(() => [props.chartOrganisationFilters, props.plotPer], (next, previous) => {
+    watch(() => [props.chartOrganisationFilters], (next, previous) => {
       if ((!next && !previous) || !_.isEqual(next, previous)) {
         fetch();
       }
     }, { immediate: true });
-    
 
     return {
-      ColorEnum,
       fetchingChartOrganisations,
       chartOrganisations,
-      isSelected
+      headersOptions,
+      ColorEnum,
+      chartTypeLabel,
+      isSelected,
+      chartIcon
     };
   }
 });

package/components/lists/charts/FSBaseChartsList.vue

@@ -1,7 +1,11 @@
 <template>
   <FSDataTable
+    defaultMode="iterator"
     :loading="fetchingChartOrganisationTypes || fetchingChartOrganisations"
+    :headersOptions="headersOptions"
     :items="charts"
+    :selectable="$props.selectable"
+    :singleSelect="$props.singleSelect"
     :tableCode="$props.tableCode"
     :modelValue="$props.modelValue"
     @update:modelValue="onSelect"
@@ -38,6 +42,7 @@
         height="32px"
         width="32px"
         :imageId="item.imageId"
+        :thumbnail="true"
       />
     </template>
     <template
@@ -45,29 +50,55 @@
     >
       <FSTagGroup
         variant="slide"
-        :editable="false"
+        :showRemove="false"
         :tags="item.tags"
       />
     </template>
+    <template
+      #item.chartType="{ item }"
+    >
+      <FSRow
+        :wrap="false"
+      >
+        <FSIcon
+          :icon="chartIcon(item.chartType)"
+        />
+        <FSText>
+          {{ chartTypeLabel(item.chartType) }}
+        </FSText>
+      </FSRow>
+    </template>
     <template
       #item.modelsLabels="{ item }"
     >
       <FSTagGroup
-        :editable="false"
+        :showRemove="false"
         :tags="item.modelsLabels.map((d: any) => d.label)"
       />
     </template>
     <template
-      #item.tile="{ item }"
+      #item.scope="{ item }"
+    >
+      <FSChip
+        :label="applicationScopeLabel(item.scope)"
+        :color="ColorEnum.Light"
+      />
+    </template>
+    <template
+      #item.tile="{ index, item }"
     >
       <FSChartTileUI
+        :key="index"
         :label="item.label"
         :categoryLabel="item.chartCategoryLabel"
         :icon="item.icon"
         :imageId="item.imageId"
         :type="item.chartType"
-        :color="isSelected(item.id) ? ColorEnum.Primary : ColorEnum.Dark"
-        @click="update(item.id)"
+        :scope="item.scope"
+        :singleSelect="$props.singleSelect"
+        :selectable="$props.selectable"
+        :modelValue="isSelected(item.id)"
+        @update:modelValue="update(item.id)"
       />
     </template>
   </FSDataTable>
@@ -77,16 +108,22 @@
 import { defineComponent, type PropType, watch, computed } from "vue";
 import _ from "lodash";
 
-import {ColorEnum } from "@dative-gpi/foundation-shared-components/models";
-
-import type { ChartOrganisationFilters, ChartOrganisationTypeFilters } from "@dative-gpi/foundation-core-domain/models";
+import { chartTypeLabel, chartIcon, applicationScopeLabel } from "@dative-gpi/foundation-shared-components/tools";
+import { ChartOrigin, ChartType } from "@dative-gpi/foundation-shared-domain/enums";
+import { getEnumEntries } from "@dative-gpi/foundation-shared-domain/tools";
+import { ColorEnum } from "@dative-gpi/foundation-shared-components/models";
 
+import type { ChartModelLabel, ChartOrganisationFilters, ChartOrganisationTypeFilters } from "@dative-gpi/foundation-core-domain/models";
 import { useChartOrganisations, useChartOrganisationTypes } from "@dative-gpi/foundation-core-services/composables";
 
 import FSChartTileUI from "@dative-gpi/foundation-shared-components/components/tiles/FSChartTileUI.vue";
 import FSTagGroup from "@dative-gpi/foundation-shared-components/components/FSTagGroup.vue";
 import FSImage from "@dative-gpi/foundation-shared-components/components/FSImage.vue";
 import FSIcon from "@dative-gpi/foundation-shared-components/components/FSIcon.vue";
+import FSChip from '@dative-gpi/foundation-shared-components/components/FSChip.vue';
+import FSText from '@dative-gpi/foundation-shared-components/components/FSText.vue';
+import FSRow from "@dative-gpi/foundation-shared-components/components/FSRow.vue";
+
 import FSDataTable from "../FSDataTable.vue";
 
 export default defineComponent({
@@ -96,13 +133,16 @@ export default defineComponent({
     FSDataTable,
     FSTagGroup,
     FSImage,
-    FSIcon
+    FSText,
+    FSChip,
+    FSIcon,
+    FSRow
   },
   props: {
-    modelValue: {
-      type: Array as PropType<string[]>,
-      default: () => [],
-      required: false
+    tableCode: {
+      type: String as PropType<string | null>,
+      required: false,
+      default: null
     },
     chartOrganisationFilters: {
       type: Object as PropType<ChartOrganisationFilters>,
@@ -114,14 +154,24 @@ export default defineComponent({
       required: false,
       default: null
     },
-    tableCode: {
-      type: String,
-      required: true
+    modelValue: {
+      type: Array as PropType<string[]>,
+      default: () => [],
+      required: false
+    },
+    selectable: {
+      type: Boolean,
+      required: false,
+      default: true
+    },
+    singleSelect: {
+      type: Boolean,
+      required: false,
+      default: false
     }
   },
-  emits: ["update:modelValue", "update:scope"],
+  emits: ["update", "update:modelValue", "update:scope"],
   setup(props, { emit }) {
-
     const { entities: chartOrganisations, fetching: fetchingChartOrganisations, getMany: getManyChartOrganisations } = useChartOrganisations();
     const { entities: chartOrganisationTypes, fetching: fetchingChartOrganisationTypes, getMany: getManyChartOrganisationTypes } = useChartOrganisationTypes();
 
@@ -135,65 +185,100 @@ export default defineComponent({
     }
 
     const charts = computed(() => {
-      return chartOrganisations.value.map(c => {
-        return {
-          id: c.id,
-          imageId: c.imageId,
-          chartId: c.chartId,
-          chartCategoryId: c.chartCategoryId,
-          chartCategoryLabel: c.chartCategoryLabel,
-          scope: c.scope,
-          label: c.label,
-          title: c.title,
-          code: c.code,
-          icon: c.icon,
-          tags: c.tags,
-          multiple: c.multiple,
-          chartType: c.chartType,
-          modelsLabels: c.modelsLabels
-        }
-      })
-        .concat(chartOrganisationTypes.value.map(c => {
-          return {
-            id: c.id,
-            imageId: c.imageId,
-            chartId: c.chartId,
-            chartCategoryId: c.chartCategoryId,
-            chartCategoryLabel: c.chartCategoryLabel,
-            scope: c.scope,
-            label: c.label,
-            title: c.title,
-            code: c.code,
-            icon: c.icon,
-            tags: c.tags,
-            multiple: c.multiple,
-            chartType: c.chartType,
-            modelsLabels: c.modelsLabels
+      return chartOrganisations.value.map(c => ({
+        id: c.id,
+        imageId: c.imageId,
+        chartId: c.chartId,
+        chartCategoryId: c.chartCategoryId,
+        chartCategoryLabel: c.chartCategoryLabel,
+        scope: c.scope,
+        label: c.label,
+        title: c.title,
+        code: c.code,
+        icon: c.icon,
+        tags: c.tags,
+        multiple: c.multiple,
+        chartType: c.chartType,
+        modelsLabels: c.modelsLabels
+      })).concat(chartOrganisationTypes.value.map(c => ({
+        id: c.id,
+        imageId: c.imageId,
+        chartId: c.chartId,
+        chartCategoryId: c.chartCategoryId,
+        chartCategoryLabel: c.chartCategoryLabel,
+        scope: c.scope,
+        label: c.label,
+        title: c.title,
+        code: c.code,
+        icon: c.icon,
+        tags: c.tags,
+        multiple: c.multiple,
+        chartType: c.chartType,
+        modelsLabels: c.modelsLabels
+      })));
+    });
+
+    const headersOptions = computed(() => ({
+      modelsLabels: {
+        fixedFilters: chartOrganisationTypes.value.map(c => c.modelsLabels).reduce((acc, models) => {
+          for(const m of models){
+            if(!acc.map((m) => m.id).includes(m.id)){
+              acc.push(m);
+            }
           }
-        }))
-    })
+          return acc;
+        }, []).map((m) =>  ({
+          value: m.id,
+          text: m.label
+        })).concat({
+          value: '',
+          text: '--'
+        }),
+        methodFilter: (value: string, items: ChartModelLabel[]) => (items.length == 0 && value == '') || (items.length  > 0 && items.some(ml => ml.id == value))
+      },
+      chartType: {
+        fixedFilters: getEnumEntries(ChartType).map(e => ({
+          value: e.value,
+          text: chartTypeLabel(e.value)
+        })),
+        methodFilter: (value: ChartType, item: ChartType) => value == item
+      },
+      scope: {
+        fixedFilters: getEnumEntries(ChartOrigin).filter(e => e.value != ChartOrigin.None).map(e => ({
+          value: e.value,
+          text: applicationScopeLabel(e.value)
+        })),
+        methodFilter: (value: ChartOrigin, item: ChartOrigin) => value == item
+      }
 
-    const update = (value : string) =>
-    {
-      const item = isSelected(value);
+    }));
 
-      if(item){
-        onSelect(props.modelValue.filter(m => m != value))
+    const update = (value : string) => {
+      const isAlreadySelected = isSelected(value);
+      if (isAlreadySelected) {
+        onSelect(props.modelValue.filter(m => m != value));
+      }
+      else if(props.singleSelect){
+        onSelect([value]);
       }
       else{
-        onSelect([...props.modelValue, value])
+        onSelect([...props.modelValue, value]);
       }
     }
 
     const onSelect = (values: string[] | null) => {
       if(!values){
-        emit("update:modelValue", [])
-        emit("update:scope", [])
+        emit("update:modelValue", []);
+        emit("update:scope", []);
+        emit("update", { modelValue: [], scope: [] });
         return;
       }
       const selectedItems = charts.value.filter(i => values.includes(i.id));
-      emit("update:modelValue", selectedItems.map(i => i.id));
-      emit("update:scope", selectedItems.map(i => i.scope));
+      const newModelValue = selectedItems.map(i => i.id);
+      const newScope = selectedItems.map(i => i.scope);
+      emit("update:modelValue", newModelValue);
+      emit("update:scope", newScope);
+      emit("update", { modelValue: newModelValue, scope: newScope });
     };
  
     watch(() => [props.chartOrganisationFilters,props.chartOrganisationTypeFilters], (next, previous) => {
@@ -207,9 +292,13 @@ export default defineComponent({
       fetchingChartOrganisations,
       chartOrganisationTypes,
       chartOrganisations,
+      headersOptions,
       ColorEnum,
       charts,
+      applicationScopeLabel,
+      chartTypeLabel,
       isSelected,
+      chartIcon,
       onSelect,
       update
     };

package/components/lists/comments/FSBaseCommentsList.vue

@@ -21,25 +21,30 @@
         :userImageId="currentUser?.imageId"
       />
     </FSRow>
-    <FSCommentTileUI
-      v-for="comment in orderedComments"
-      :key="comment.id"
-      :timestamp="epochToLongTimeFormat(comment.timestamp)"
-      :userName="comment.userName"
-      :userImageId="comment.userImageId"
-      :canEditRemove="currentUser?.id === comment.userId"
-      :comment="comment.comment"
-      :edited="comment.edited"
-      :id="comment.id"
-      @edit="updateComment"
-      @remove="removeComment(comment.id)"
-    />
+    <FSCol
+      gap="12px"
+    >
+      <FSCommentTileUI
+        v-for="comment in orderedComments"
+        :key="comment.id"
+        :timestamp="epochToLongTimeFormat(comment.timestamp)"
+        :userName="comment.userName"
+        :userImageId="comment.userImageId"
+        :canEditRemove="currentUser?.id === comment.userId"
+        :comment="comment.comment"
+        :edited="comment.edited"
+        :removing="removing"
+        :id="comment.id"
+        @edit="updateComment"
+        @remove="removeComment(comment.id)"
+      />
+    </FSCol>
   </FSCol>
 </template>
 
 <script lang="ts">
 import type { PropType} from "vue";
-import { computed, defineComponent, onMounted, watch } from "vue";
+import { computed, defineComponent, onMounted, ref, watch } from "vue";
 import _ from "lodash";
 
 import { useDateFormat, useCurrentUser } from "@dative-gpi/foundation-shared-services/composables";
@@ -73,13 +78,15 @@ export default defineComponent({
     }
   },
   setup(props) {
-    const {fetch : fetchCurrentUser, entity: currentUser} = useCurrentUser();
+    const { fetch : fetchCurrentUser, entity: currentUser } = useCurrentUser();
     const { create: createComment, creating : creatingComment } = useCreateComment();
     const { getMany: fetchComments, entities: comments } = useComments();
-    const {update  } = useUpdateComment();
-    const {remove  } = useRemoveComment();
+    const { update } = useUpdateComment();
+    const { remove, removing } = useRemoveComment();
     const { epochToLongTimeFormat } = useDateFormat();
 
+    const error = ref<string | null>(null);
+
     const orderedComments = computed(()  => {
       return _.orderBy(comments.value, ['timestamp'], ['desc']);
     });
@@ -101,8 +108,14 @@ export default defineComponent({
       update(payload.commentId, {comment : payload.comment})
     }
 
-    const removeComment = (commentId : string) => {
-      remove(commentId)
+    const removeComment = async (commentId : string) => {
+      try {
+        error.value = null;
+        await remove(commentId);
+      }
+      catch (exception: any) {
+        error.value = exception.response.data;
+      }
     }
 
     watch(() => props.commentFilters, (next, previous) => {
@@ -112,15 +125,18 @@ export default defineComponent({
     }, { immediate: true });
 
     return {
-      comments,
-      ColorEnum,
       creatingComment,
-      currentUser,
       orderedComments,
+      currentUser,
+      ColorEnum,
+      comments,
+      removing,
+      error,
+      epochToLongTimeFormat,
       createNewComment,
       updateComment,
       removeComment,
-      epochToLongTimeFormat
+      
     };
   }
 });