Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • geocontrib/geocontrib-frontend
  • ext_matthieu/geocontrib-frontend
  • fnecas/geocontrib-frontend
  • MatthieuE/geocontrib-frontend
4 results
Show changes
Hide whitespace changes
Inline Side-by-side
Showing
with 2964 additions and 1426 deletions
src/components/Projects/ProjectsMenu.vue
View file @ ee17a921
<template> <template>
<div class="filters-container"> <div
<div class="ui styled accordion"> v-if="chunkedNsortedFilters.length > 0"
id="filters-container"
>
<div
class="ui styled accordion"
@click="displayFilters = !displayFilters"
>
<div <div
id="filters"
class="title collapsible-filters" class="title collapsible-filters"
> >
FILTRES FILTRES
<i <i
class="ui icon caret right down" :class="['ui icon customcaret', { 'collapsed': !displayFilters }]"
aria-hidden="true"
/> />
</div> </div>
</div> </div>
<div class="ui menu filters hidden"> <div :class="['full-width', 'filters', { 'hidden': displayFilters }]">
<div class="item"> <div
<label> v-for="(chunkedFilters, index) in chunkedNsortedFilters"
Niveau d'autorisation requis :key="index"
</label> class="ui menu filter-row"
<DropdownMenuItem >
:options="accessLevelOptions" <div
v-on="$listeners" v-for="filter in chunkedFilters"
/> :key="filter.name"
</div> class="item"
<div class="item"> >
<label> <label>
Mon niveau d'autorisation {{ filter.label }}
</label> </label>
<DropdownMenuItem <search-projects
:options="userAccessLevelOptions" v-if="filter.name === 'search'"
v-on="$listeners" v-on="$listeners"
/> />
</div> <DropdownMenuItem
<div class="item"> v-else-if="!filter.id"
<label> :options="filter.options"
Modération :loading="loading"
</label> v-on="$listeners"
<DropdownMenuItem />
:options="moderationOptions" <DropdownMenuItem
v-on="$listeners" v-else
/> :options="filter.options"
</div> :loading="loading"
<div class="right item"> :multiple="isMultiple(filter)"
<label> :current-selection="attributesFilter[filter.id]"
Recherche par nom :default-filter="filter.default_filter_enabled ? filter.default_filter_value : null"
</label> @filter="updateAttributeFilter"
<search-projects @remove="removeAttributeFilter"
:search-function="SEARCH_PROJECTS" />
v-on="$listeners" </div>
/>
</div> </div>
</div> </div>
</div> </div>
</template> </template>
<script> <script>
import { mapState, mapActions } from 'vuex'; import { mapState, mapMutations } from 'vuex';
import DropdownMenuItem from '@/components/Projects/DropdownMenuItem.vue'; import DropdownMenuItem from '@/components/Projects/DropdownMenuItem.vue';
import SearchProjects from '@/components/Projects/SearchProjects.vue'; import SearchProjects from '@/components/Projects/SearchProjects.vue';
...@@ -65,116 +72,322 @@ export default { ...@@ -65,116 +72,322 @@ export default {
SearchProjects, SearchProjects,
}, },
props: {
loading: {
type: Boolean,
default: false
},
},
data() { data() {
return { return {
moderationOptions: [ displayFilters: false,
{ classicFilters: [
label: 'Tous',
filter: 'moderation',
value: null
},
{
label: 'Projet modéré',
filter: 'moderation',
value: 'true'
},
{
label: 'Projet non modéré',
filter: 'moderation',
value: 'false'
},
],
accessLevelOptions: [
{ {
label: 'Tous', name: 'access_level',
filter: 'access_level', label: 'Niveau d\'autorisation requis',
value: null options: [
{
label: 'Utilisateur anonyme',
value: 'anonymous'
},
{
label: 'Utilisateur connecté',
value: 'logged_user'
},
{
label: 'Contributeur',
value: 'contributor'
},
],
}, },
{ {
label: 'Utilisateur anonyme', name: 'user_access_level',
filter: 'access_level', label: 'Mon niveau d\'autorisation',
value: 'anonymous' options: [
{
label: 'Utilisateur connecté',
value: '1'
},
{
label: 'Contributeur',
value: '2'
},
{
label: 'Super contributeur',
value: '3'
},
{
label: 'Modérateur',
value: '4'
},
{
label: 'Administrateur projet',
value: '5'
},
],
}, },
{ {
label: 'Utilisateur connecté', name: 'moderation',
filter: 'access_level', label: 'Modération',
value: 'logged_user' options: [
{
label: 'Projet modéré',
value: 'true'
},
{
label: 'Projet non modéré',
value: 'false'
},
]
}, },
{ {
label: 'Contributeur', name: 'search',
filter: 'access_level', label: 'Recherche par nom',
value: 'contributor' }
},
], ],
userAccessLevelOptions: [ attributesFilter: {},
{
label: 'Tous',
filter: 'user_access_level',
value: null
},
{
label: 'Utilisateur connecté',
filter: 'user_access_level',
value: '1'
},
{
label: 'Contributeur',
filter: 'user_access_level',
value: '2'
},
{
label: 'Super contributeur',
filter: 'user_access_level',
value: '3'
},
{
label: 'Modérateur',
filter: 'user_access_level',
value: '4'
},
{
label: 'Administrateur projet',
filter: 'user_access_level',
value: '5'
},
]
}; };
}, },
computed: { computed: {
...mapState(['user']) ...mapState([
'user',
'configuration',
'projectAttributes'
]),
...mapState('projects', [
'filters',
]),
/**
* Processes project filters to prepare them for display.
* It also adds a global 'Tous' (All) option to each attribute's options for filtering purposes.
*
* @returns {Array} An array of filter objects with modified options for display.
*/
displayedClassicFilters() {
if (!this.configuration.VUE_APP_PROJECT_FILTERS) return [];
const projectFilters = this.configuration.VUE_APP_PROJECT_FILTERS.split(',');
// Filter filters to be displayed according to configuration and process filters
return this.classicFilters.filter(filter => projectFilters.includes(filter.name))
.map(filter => {
if (filter.options) {
// if user is not connected display its user access level corresponding to anonymous user
if (!this.user && filter.name ==='user_access_level') {
filter.options.unshift({
label: 'Utilisateur anonyme',
value: '0'
});
}
// Format the options to be displayed by dropdowns
const options = this.generateFilterOptions(filter);
// Add the global option at beginning
options.unshift({
label: 'Tous',
filter: filter.name,
value: null,
});
return { ...filter, options };
} else { // Search input field doesn't take options
return filter;
}
});
},
/**
* Processes project attributes to prepare them for display, adjusting the options based on the attribute type.
* For boolean attributes, it creates specific options for true and false values.
* It also adds a global 'Tous' (All) option to each attribute's options for filtering purposes.
* Finally, it chunks the array of attributes into multiple arrays, each containing up to 4 elements.
*
* @returns {Array} An array of arrays, where each sub-array contains up to 4 project attributes with modified options for display.
*/
displayedAttributeFilters() {
// Filter displayed filters & filter only attribute of boolean type (no need for option property) or list type with options
return this.projectAttributes.filter(attribute => attribute.display_filter && (attribute.field_type === 'boolean' || attribute.options))
// Process attributes for display
.map(attribute => {
// Format the options to be displayed by dropdowns
const options = this.generateFilterOptions(attribute);
// Add the global option at beginning
options.unshift({
label: 'Tous',
filter: attribute.id,
value: null,
});
return { ...attribute, options };
});
},
/**
* Merge all filters and place the search filters at the end of the array
* Then chunks the array into rows of 4 filters to display each chunk in a row
*/
chunkedNsortedFilters() {
const allFilters = [...this.displayedClassicFilters, ...this.displayedAttributeFilters];
const sortedFilters = [
...allFilters.filter(el => el.name !== 'search'),
...allFilters.filter(el => el.name === 'search'),
];
// Chunk the filters into arrays of up to 4 elements
return this.chunkArray(sortedFilters, 4);
},
}, },
created() { created() {
if (!this.user) { // parse all project attributes to find default value and set filters in store before updating project list results
this.userAccessLevelOptions.splice(1, 0, { for (const attribFilter of this.displayedAttributeFilters) {
label: 'Utilisateur anonyme', this.setDefaultFilters(attribFilter);
filter: 'user_access_level',
value: '0'
});
} }
// When all the default filters are set, fetch projects list data
this.$emit('getData');
}, },
mounted() { methods: {
const el = document.getElementsByClassName('collapsible-filters'); ...mapMutations('projects', [
'SET_PROJECTS_FILTER'
]),
/**
* Helper function to chunk an array into smaller arrays of a specified size.
*
* @param {Array} array - The original array to be chunked.
* @param {Number} size - The maximum size of each chunk.
* @returns {Array} An array of chunked arrays.
*/
chunkArray(array, size) {
const chunkedArr = [];
for (let i = 0; i < array.length; i += size) {
chunkedArr.push(array.slice(i, i + size));
}
return chunkedArr;
},
/**
* Generates options for a given filter.
* It handles boolean attributes specially by creating explicit true/false options.
* Other attribute types use their predefined options.
*
* @param {Object} attribute - The project attribute for which to generate options.
* @returns {Array} An array of options for the given attribute.
*/
generateFilterOptions(filter) {
// Handle boolean attributes specially by creating true/false options
if (filter.field_type === 'boolean') {
return [
{ filter: filter.id, label: 'Oui', value: 'true' },
{ filter: filter.id, label: 'Non', value: 'false' },
];
} else if (filter.options) {
// For other filter types, map each option to the expected format
return filter.options.map(option => ({
filter: filter.id || filter.name,
label: option.name || option.label || option,
value: option.id || option.value || option,
}));
}
return [];
},
/**
* Retrieves a project attribute by its ID.
* Returns an empty object if not found to prevent errors from undefined access.
*
* @param {Number|String} id - The ID of the attribute to find.
* @returns {Object} The found attribute or an empty object.
*/
getProjectAttribute(id) {
// Search for the attribute by ID, default to an empty object if not found
return this.projectAttributes.find(el => el.id === id) || {};
},
el[0].addEventListener('click', function() { /**
const icon = document.getElementsByClassName('caret'); * Emits an updated filter event with the current state of attributesFilter.
icon[0].classList.toggle('right'); * This method serializes the attributesFilter object to a JSON string and emits it,
const content = document.getElementsByClassName('filters'); * allowing the parent component to update the query parameters.
content[0].classList.toggle('hidden'); */
if (content[0].style.maxHeight){ emitUpdatedFilter() {
content[0].style.maxHeight = null; // Emit an 'filter' event with the updated attributes filter as a JSON string
this.$emit('filter', { filter: 'attributes', value: JSON.stringify(this.attributesFilter) });
},
/**
* Updates or adds a new attribute value to the attributesFilter.
* Handles both single-choice and multi-choice attribute types.
* @param {Object} newFilter - The new filter to be added, containing the attribute key and value.
*/
updateAttributeFilter({ filter, value, noUpdate }) {
// Retrieve the attribute type information to determine how to handle the update
const attribute = this.getProjectAttribute(filter);
// Check if the attribute allows multiple selections
const isMultiChoice = attribute.field_type.includes('list');
if (isMultiChoice) {
// For multi-choice attributes, manage the values as an array to allow multiple selections
let arrayValue = this.attributesFilter[filter] ? this.attributesFilter[filter].split(',') : [];
if (value) {
// If a value is provided, add it to the array, ensuring no duplicates and removing null corresponding to "Tous" default option
arrayValue.push(value);
arrayValue = [...new Set(arrayValue)].filter(el => el !== null);
// Convert the array back to a comma-separated string to store in the filter object
this.attributesFilter[filter] = arrayValue.join(',');
} else {
// If null value is provided "Tous" is selected, it indicates removal of the attribute filter
delete this.attributesFilter[filter];
}
} else { } else {
content[0].style.maxHeight = content[0].scrollHeight + 5 + 'px'; // For single-choice attributes, directly set or delete the value
value ? this.attributesFilter[filter] = value : delete this.attributesFilter[filter];
} }
}); if (noUpdate) {
}, this.SET_PROJECTS_FILTER({ filter: 'attributes', value: JSON.stringify(this.attributesFilter) });
} else {
// After updating the filter object, emit the updated filter for application-wide use
this.emitUpdatedFilter();
}
},
methods: { /**
...mapActions('projects', [ * Removes a specified value from a project attribute filter.
'SEARCH_PROJECTS' * Particularly useful for multi-choice attributes where individual values can be deselected.
]) * @param {Object} removedFilter - The filter to be removed, containing the attribute key and value.
*/
removeAttributeFilter({ filter, value }) {
// Retrieve attribute information to determine if it's a multi-choice attribute
const attribute = this.getProjectAttribute(filter);
const isMultiChoice = attribute.field_type.includes('list');
if (isMultiChoice) {
// For multi-choice attributes, convert the current filter value to an array for manipulation
let arrayValue = this.attributesFilter[filter] ? this.attributesFilter[filter].split(',') : [];
// Remove the specified value from the array
arrayValue = arrayValue.filter(val => val !== value);
// Update the attributesFilter with the new array, converted back to a string
this.attributesFilter[filter] = arrayValue.join(',');
} else {
// For single-choice attributes, directly update the filter to remove the value
delete this.attributesFilter[filter];
}
// Emit the updated filter after removal
this.emitUpdatedFilter();
},
isMultiple(filter) {
return filter.field_type.includes('list');
},
setDefaultFilters(filter) {
const defaultFilter = filter.default_filter_enabled ? filter.default_filter_value : null;
if (defaultFilter) {
// make an array from the string in case of a list
const filtersArray = defaultFilter.split(',');
// for each value update the filter
filtersArray.forEach(defaultValue => {
const defaultOption = filter.options.find(option => option.value === defaultValue);
if (defaultOption) {
this.updateAttributeFilter({ ...defaultOption, noUpdate: true });
}
});
}
},
} }
}; };
</script> </script>
...@@ -187,7 +400,7 @@ export default { ...@@ -187,7 +400,7 @@ export default {
transition: @arguments; transition: @arguments;
} }
.filters-container { #filters-container {
width: 100%; width: 100%;
display: flex; display: flex;
flex-direction: column; flex-direction: column;
...@@ -196,26 +409,49 @@ export default { ...@@ -196,26 +409,49 @@ export default {
.accordion { .accordion {
width: fit-content; width: fit-content;
.collapsible-filters { .collapsible-filters {
cursor: pointer;
font-size: 1.25em; font-size: 1.25em;
padding-right: 0; padding-right: 0;
.customcaret{
transition: transform .2s ease;
&.collapsed {
transform: rotate(180deg);
}
&::before{
position: relative;
right: 0;
top: 65%;
color: #999;
margin-top: 4px;
border-color: #999 transparent transparent;
border-style: solid;
border-width: 5px 5px 0;
content: "";
}
}
} }
} }
.filters { .filters {
width: 100%; width: 100%;
height:auto; height:auto;
min-height: 0; max-height:100vh;
max-height:75px; opacity: 1;
margin: 0 0 1em 0; z-index: 1001;
border: none; .transition-properties(all 0.2s ease;);
box-shadow: none; .filter-row {
.transition-properties(max-height 0.2s ease-out;); border: none;
box-shadow: none;
}
.item { .item {
display: flex; display: flex;
flex-direction: column; flex-direction: column;
align-items: flex-start !important; align-items: flex-start !important;
padding: 0.5em;
padding: 0.4em 0.6em 0.4em 0; &:first-child {
padding-left: 0;
}
&:last-child {
padding-right: 0;
}
label { label {
margin-bottom: 0.2em; margin-bottom: 0.2em;
...@@ -229,17 +465,43 @@ export default { ...@@ -229,17 +465,43 @@ export default {
.item::before { .item::before {
width: 0; width: 0;
} }
.right.item { #search-projects {
padding-right: 0; width: 100%;
} }
.right.item::before {
width: 0;
}
} }
.filters.hidden { .filters.hidden {
max-height: 0;
overflow: hidden; overflow: hidden;
border: none; opacity: 0;
max-height: 0;
} }
} }
@media screen and (min-width: 701px) {
.item {
&:first-child {
padding-left: 0;
}
&:last-child {
padding-right: 0;
}
}
}
@media screen and (max-width: 700px) {
#filters-container {
.filter-row {
display: flex;
flex-direction: column;
max-height: 275px;
.transition-properties(all 0.2s ease-out;);
.item {
width: 100%;
padding-right: 0;
padding-left: 0;
}
}
}
}
</style> </style>
src/components/Projects/SearchProjects.vue
View file @ ee17a921
<template> <template>
<div id="search-projects"> <div id="search-projects">
<input <input
v-model="text"
type="text" type="text"
placeholder="Rechercher un projet ..." placeholder="Rechercher un projet ..."
@input="searchProjects"
> >
</div> </div>
</template> </template>
<script> <script>
import _ from 'lodash'; import { debounce } from 'lodash';
import { mapMutations } from 'vuex'; import { mapActions, mapMutations } from 'vuex';
export default { export default {
name: 'SearchProjects', name: 'SearchProjects',
props: {
searchFunction: {
type: Function,
default: () => { return {}; }
}
},
data() {
return {
text: null
};
},
watch: {
text: _.debounce(function(newValue) {
this.$emit('loading', true);
this.SET_CURRENT_PAGE(1);
this.searchFunction(newValue)
.then(() => {
this.$emit('loading', false);
})
.catch((err) => {
if (err.message) this.$emit('loading', false);
});
}, 100)
},
methods: { methods: {
...mapMutations('projects', [ ...mapMutations('projects', [
'SET_CURRENT_PAGE' 'SET_CURRENT_PAGE'
]) ]),
...mapActions('projects', [
'SEARCH_PROJECTS'
]),
searchProjects:
debounce(function(e) {
this.$emit('loading', true);
this.SET_CURRENT_PAGE(1);
this.SEARCH_PROJECTS({ text: e.target.value })
.then(() => {
this.$emit('loading', false);
})
.catch((err) => {
if (err.message) {
this.$emit('loading', false);
}
});
}, 100)
} }
}; };
</script> </script>
<style lang="less" scoped> <style lang="less" scoped>
#search-projects { #search-projects {
display: block;
height: 100%; height: 100%;
min-height: 40px; min-height: 40px;
display: flex; display: flex;
...@@ -68,11 +58,11 @@ export default { ...@@ -68,11 +58,11 @@ export default {
padding: 8px 40px 8px 8px; padding: 8px 40px 8px 8px;
border: 1px solid #ced4da; border: 1px solid #ced4da;
font-size: 1rem; font-size: 1rem;
font-family: 'Roboto Condensed', Lato, 'Helvetica Neue', Arial, Helvetica, sans-serif !important; font-family: var(--font-family, 'Roboto Condensed', 'Lato', 'Helvetica Neue', Arial, Helvetica, sans-serif);
} }
input:focus { input:focus {
outline: none !important; outline: none !important;
box-shadow: 0 0 1px grey; box-shadow: 0 0 1px grey;
} }
} }
</style> </style>
\ No newline at end of file
src/components/SearchFeature.vue
View file @ ee17a921
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
<div> <div>
<Multiselect <Multiselect
v-model="selection" v-model="selection"
:options="results" :options="options"
:options-limit="10" :options-limit="10"
:allow-empty="true" :allow-empty="true"
track-by="feature_id" track-by="feature_id"
...@@ -12,7 +12,7 @@ ...@@ -12,7 +12,7 @@
selected-label="" selected-label=""
deselect-label="" deselect-label=""
:searchable="true" :searchable="true"
:placeholder="'Rechercher un signalement ...'" :placeholder="placeholder"
:show-no-results="true" :show-no-results="true"
:loading="loading" :loading="loading"
:clear-on-select="false" :clear-on-select="false"
...@@ -27,7 +27,10 @@ ...@@ -27,7 +27,10 @@
class="multiselect__clear" class="multiselect__clear"
@click.prevent.stop="selection = null" @click.prevent.stop="selection = null"
> >
<i class="close icon" /> <i
class="close icon"
aria-hidden="true"
/>
</div> </div>
</template> </template>
<span slot="noResult"> <span slot="noResult">
...@@ -52,19 +55,36 @@ export default { ...@@ -52,19 +55,36 @@ export default {
Multiselect Multiselect
}, },
props: {
currentSelection : {
type: Object,
default: null,
}
},
data() { data() {
return { return {
loading: false, loading: false,
selection: null, selection: null,
text: null, text: null,
results: [] results: [],
placeholder: 'Rechercher un signalement ...'
}; };
}, },
computed: { computed: {
...mapState('feature', [ ...mapState('feature', [
'features' 'features'
]) ]),
options() {
return this.results.map((el) => {
return {
featureId: el.id,
title: el.properties.title
};
});
},
}, },
watch: { watch: {
...@@ -77,12 +97,16 @@ export default { ...@@ -77,12 +97,16 @@ export default {
limit: '10' limit: '10'
}) })
.then(() => { .then(() => {
if (newValue) { if (newValue) { // filter out current feature
this.results = this.features; this.results = this.features.filter((el) => el.id !== this.$route.params.slug_signal);
} else { } else {
this.results.splice(0); this.results.splice(0);
} }
this.loading = false; this.loading = false;
})
.catch((err) => {
console.error(err);
this.loading = false;
}); });
} }
}, },
...@@ -91,6 +115,12 @@ export default { ...@@ -91,6 +115,12 @@ export default {
this.RESET_CANCELLABLE_SEARCH_REQUEST(); this.RESET_CANCELLABLE_SEARCH_REQUEST();
}, },
mounted() {
if (this.currentSelection && this.currentSelection.feature_to) {
this.placeholder = this.currentSelection.feature_to.title;
}
},
methods: { methods: {
...mapMutations(['RESET_CANCELLABLE_SEARCH_REQUEST']), ...mapMutations(['RESET_CANCELLABLE_SEARCH_REQUEST']),
...mapActions('feature', [ ...mapActions('feature', [
...@@ -100,15 +130,29 @@ export default { ...@@ -100,15 +130,29 @@ export default {
this.text = text; this.text = text;
}, },
select(e) { select(e) {
this.$emit('select', e); this.$emit('select', e.featureId);
}, },
close() { close() { // close calls as well selectFeatureTo, in case user didn't select a value
this.$emit('close', this.selection); this.$emit('close', this.selection && this.selection.featureId ?
this.selection.featureId : this.selection);
} }
} }
}; };
</script> </script>
<style scoped> <style>
.multiselect input {
line-height: 1em !important;
padding: 0 !important;
}
.multiselect__placeholder {
margin: 0;
padding: 0;
}
.multiselect__input {
min-height: auto !important;
line-height: 1em !important;
}
</style> </style>
src/components/feature/FeatureExtraForm.vue deleted 100644 → 0
View file @ bcd7b6bb
<template>
<div
v-if="field.field_type === 'char'"
v-frag
>
<label for="field.name">{{ field.label }}</label>
<input
:id="field.name"
:value="field.value"
type="text"
:name="field.name"
@blur="updateStore_extra_form"
>
</div>
<div
v-else-if="field.field_type === 'list'"
v-frag
>
<label for="field.name">{{ field.label }}</label>
<Dropdown
:options="field.options"
:selected="selected_extra_form_list"
:selection.sync="selected_extra_form_list"
/>
</div>
<div
v-else-if="field.field_type === 'integer'"
v-frag
>
<label for="field.name">{{ field.label }}</label>
<div class="ui input">
<!-- //* si click sur fléche dans champ input, pas de focus, donc pas de blur, donc utilisation de @change -->
<input
:id="field.name"
:value="field.value"
type="number"
:name="field.name"
@change="updateStore_extra_form"
>
</div>
</div>
<div
v-else-if="field.field_type === 'boolean'"
v-frag
>
<div class="ui checkbox">
<input
:id="field.name"
class="hidden"
type="checkbox"
:checked="field.value"
:name="field.name"
@change="updateStore_extra_form"
>
<label for="field.name">{{ field.label }}</label>
</div>
</div>
<div
v-else-if="field.field_type === 'date'"
v-frag
>
<label for="field.name">{{ field.label }}</label>
<input
:id="field.name"
:value="field.value"
type="date"
:name="field.name"
@blur="updateStore_extra_form"
>
</div>
<div
v-else-if="field.field_type === 'decimal'"
v-frag
>
<label for="field.name">{{ field.label }}</label>
<div class="ui input">
<input
:id="field.name"
:value="field.value"
type="number"
step=".01"
:name="field.name"
@change="updateStore_extra_form"
>
</div>
</div>
<div
v-else-if="field.field_type === 'text'"
v-frag
>
<label :for="field.name">{{ field.label }}</label>
<textarea
:value="field.value"
:name="field.name"
rows="3"
@blur="updateStore_extra_form"
/>
</div>
</template>
<script>
import frag from 'vue-frag';
import Dropdown from '@/components/Dropdown.vue';
export default {
name: 'FeatureExtraForm',
directives: {
frag,
},
components: {
Dropdown,
},
props: {
field: {
type: Object,
default: null,
}
},
computed: {
selected_extra_form_list: {
get() {
return this.field.value || '';
},
set(newValue) {
//* set the value selected in the dropdown
let newExtraForm = this.field;
newExtraForm['value'] = newValue;
this.$store.commit('feature/UPDATE_EXTRA_FORM', newExtraForm);
},
},
},
methods: {
updateStore_extra_form(evt) {
let newExtraForm = this.field;
if (this.field.field_type === 'boolean') {
newExtraForm['value'] = evt.target.checked; //* if checkbox use "checked"
} else {
newExtraForm['value'] = evt.target.value;
}
this.$store.commit('feature/UPDATE_EXTRA_FORM', newExtraForm);
},
},
};
</script>
\ No newline at end of file
src/components/feature/FeatureListTable.vue deleted 100644 → 0
View file @ bcd7b6bb
<template>
<div
data-tab="list"
class="dataTables_wrapper no-footer"
>
<table
id="table-features"
class="ui compact table dataTable"
>
<thead>
<tr>
<th class="dt-center">
<div
class="switch-buttons pointer"
:data-tooltip="`Passer en mode ${mode === 'modify' ? 'suppression':'édition'}`"
@click="switchMode"
>
<div><i :class="['icon pencil', {disabled: mode !== 'modify'}]" /></div>
<span class="grey">|&nbsp;</span>
<div><i :class="['icon trash', {disabled: mode !== 'delete'}]" /></div>
</div>
</th>
<th class="dt-center">
<div
class="pointer"
@click="changeSort('status')"
>
Statut
<i
:class="{
down: isSortedAsc('status'),
up: isSortedDesc('status'),
}"
class="icon sort"
/>
</div>
</th>
<th class="dt-center">
<div
class="pointer"
@click="changeSort('feature_type')"
>
Type
<i
:class="{
down: isSortedAsc('feature_type'),
up: isSortedDesc('feature_type'),
}"
class="icon sort"
/>
</div>
</th>
<th class="dt-center">
<div
class="pointer"
@click="changeSort('title')"
>
Nom
<i
:class="{
down: isSortedAsc('title'),
up: isSortedDesc('title'),
}"
class="icon sort"
/>
</div>
</th>
<th class="dt-center">
<div
class="pointer"
@click="changeSort('updated_on')"
>
Dernière modification
<i
:class="{
down: isSortedAsc('updated_on'),
up: isSortedDesc('updated_on'),
}"
class="icon sort"
/>
</div>
</th>
<th
v-if="user"
class="dt-center"
>
<div
class="pointer"
@click="changeSort('display_creator')"
>
Auteur
<i
:class="{
down: isSortedAsc('display_creator'),
up: isSortedDesc('display_creator'),
}"
class="icon sort"
/>
</div>
</th>
<th
v-if="user"
class="dt-center"
>
<div
class="pointer"
@click="changeSort('display_last_editor')"
>
Dernier éditeur
<i
:class="{
down: isSortedAsc('display_last_editor'),
up: isSortedDesc('display_last_editor'),
}"
class="icon sort"
/>
</div>
</th>
</tr>
</thead>
<tbody>
<tr
v-for="(feature, index) in paginatedFeatures"
:key="index"
>
<td class="dt-center">
<div
:class="['ui checkbox', {disabled: !checkRights(feature)}]"
>
<input
:id="feature.id"
v-model="checked"
type="checkbox"
:value="feature.id"
:disabled="!checkRights(feature)"
name="select"
@input="storeClickedFeature(feature)"
>
<label for="select" />
</div>
</td>
<td class="dt-center">
<div
v-if="feature.properties.status.value === 'archived'"
data-tooltip="Archivé"
>
<i class="grey archive icon" />
</div>
<div
v-else-if="feature.properties.status.value === 'pending'"
data-tooltip="En attente de publication"
>
<i class="teal hourglass outline icon" />
</div>
<div
v-else-if="feature.properties.status.value === 'published'"
data-tooltip="Publié"
>
<i class="olive check icon" />
</div>
<div
v-else-if="feature.properties.status.value === 'draft'"
data-tooltip="Brouillon"
>
<i class="orange pencil alternate icon" />
</div>
</td>
<td class="dt-center">
<router-link
:to="{
name: 'details-type-signalement',
params: {
feature_type_slug: feature.properties.feature_type.slug,
},
}"
>
{{ feature.properties.feature_type.title }}
</router-link>
</td>
<td class="dt-center">
<router-link
:to="{
name: 'details-signalement',
params: {
slug_type_signal: feature.properties.feature_type.slug,
slug_signal: feature.properties.slug || feature.id,
},
}"
>
{{ getFeatureDisplayName(feature) }}
</router-link>
</td>
<td class="dt-center">
{{ feature.properties.updated_on }}
</td>
<td
v-if="user"
class="dt-center"
>
{{ getUserName(feature) }}
</td>
<td
v-if="user"
class="dt-center"
>
{{ feature.properties.display_last_editor }}
</td>
</tr>
<tr
v-if="featuresCount === 0"
class="odd"
>
<td
colspan="5"
class="dataTables_empty"
valign="top"
>
Aucune donnée disponible
</td>
</tr>
</tbody>
</table>
<div
v-if="pageNumbers.length > 1"
id="table-features_info"
class="dataTables_info"
role="status"
aria-live="polite"
>
Affichage de l'élément {{ pagination.start + 1 }} à
{{ displayedPageEnd }}
sur {{ featuresCount }} éléments
</div>
<div
v-if="pageNumbers.length > 1"
id="table-features_paginate"
class="dataTables_paginate paging_simple_numbers"
>
<a
id="table-features_previous"
:class="[
'paginate_button previous',
{ disabled: pagination.currentPage === 1 },
]"
aria-controls="table-features"
data-dt-idx="0"
tabindex="0"
@click="$emit('update:page', 'previous')"
>Précédent</a>
<span>
<span v-if="pagination.currentPage >= 5">
<a
key="page1"
class="paginate_button"
aria-controls="table-features"
data-dt-idx="1"
tabindex="0"
@click="$emit('update:page', 1)"
>{{ 1 }}</a>
<span class="ellipsis">…</span>
</span>
<a
v-for="pageNumber in displayedPageNumbers"
:key="'page' + pageNumber"
:class="[
'paginate_button',
{ current: pageNumber === pagination.currentPage },
]"
aria-controls="table-features"
data-dt-idx="1"
tabindex="0"
@click="$emit('update:page', pageNumber)"
>{{ pageNumber }}</a>
<span v-if="(lastPageNumber - pagination.currentPage) >= 4">
<span class="ellipsis">…</span>
<a
:key="'page' + lastPageNumber"
class="paginate_button"
aria-controls="table-features"
data-dt-idx="1"
tabindex="0"
@click="$emit('update:page', lastPageNumber)"
>{{ lastPageNumber }}</a>
</span>
</span>
<a
id="table-features_next"
:class="[
'paginate_button next',
{ disabled: pagination.currentPage === pageNumbers.length },
]"
aria-controls="table-features"
data-dt-idx="7"
tabindex="0"
@click="$emit('update:page', 'next')"
>Suivant</a>
</div>
</div>
</template>
<script>
import { mapState, mapGetters } from 'vuex';
export default {
name: 'FeatureListTable',
props: {
paginatedFeatures: {
type: Array,
default: null,
},
checkedFeatures: {
type: Array,
default: null,
},
clickedFeatures: {
type: Array,
default: null,
},
featuresCount: {
type: Number,
default: 0,
},
pagination: {
type: Object,
default: null,
},
sort: {
type: Object,
default: null,
},
mode: {
type: String,
default: null,
}
},
computed: {
...mapGetters(['permissions']),
...mapState(['user', 'USER_LEVEL_PROJECTS']),
...mapState('projects', ['project']),
userStatus() {
return this.USER_LEVEL_PROJECTS[this.$route.params.slug];
},
checked: {
get() {
return this.checkedFeatures;
},
set(newChecked) {
this.$store.commit('feature/UPDATE_CHECKED_FEATURES', newChecked);
},
},
displayedPageEnd() {
return this.featuresCount <= this.pagination.end
? this.featuresCount
: this.pagination.end;
},
pageNumbers() {
const totalPages = Math.ceil(
this.featuresCount / this.pagination.pagesize
);
return [...Array(totalPages).keys()].map((pageNumb) => {
++pageNumb;
return pageNumb;
});
},
lastPageNumber() {
return this.pageNumbers.slice(-1)[0];
},
displayedPageNumbers() {
//* s'il y a moins de 5 pages, renvoyer toutes les pages
if (this.lastPageNumber < 5) return this.pageNumbers;
//* si la page courante est inférieur à 5, la liste commence à l'index 0 et on retourne 5 pages
let firstPageInList = 0;
let pagesQuantity = 5;
//* à partir de la 5ième page et jusqu'à la 4ième page avant la fin : n'afficher que 3 page entre les ellipses et la page courante doit être au milieu
if (this.pagination.currentPage >= 5 && !((this.lastPageNumber - this.pagination.currentPage) < 4)) {
firstPageInList = this.pagination.currentPage - 2;
pagesQuantity = 3;
}
//* à partir de 4 résultat avant la fin afficher seulement les 5 derniers résultats
if ((this.lastPageNumber - this.pagination.currentPage) < 4) {
firstPageInList = this.lastPageNumber - 5;
}
return this.pageNumbers.slice(firstPageInList, firstPageInList + pagesQuantity);
},
},
destroyed() {
this.$store.commit('feature/UPDATE_CHECKED_FEATURES', []);
},
methods: {
storeClickedFeature(feature) {
this.$emit('update:clickedFeatures', [...this.clickedFeatures, { feature_id: feature.id, feature_type: feature.properties.feature_type.slug }]);
},
canDeleteFeature(feature) {
if (this.userStatus === 'Administrateur projet') return true; //* can delete all
//* others can delete only their own features
return feature.properties.creator.username === this.user.username;
},
canEditFeature(feature) {
const permissions = {
'Administrateur projet' : ['draft', 'pending', 'published', 'archived'],
Modérateur : ['draft', 'pending', 'published'],
'Super Contributeur' : ['draft', 'pending', 'published'],
Contributeur : ['draft', 'pending', 'published'],
};
if (this.userStatus === 'Contributeur' && feature.properties.creator.username !== this.user.username) {
return false;
} else if (permissions[this.userStatus]) {
return permissions[this.userStatus].includes(feature.properties.status.value);
} else {
return false;
}
},
checkRights(feature) {
switch (this.mode) {
case 'modify':
return this.canEditFeature(feature);
case 'delete':
return this.canDeleteFeature(feature);
}
},
switchMode() {
this.$emit('update:mode', this.mode === 'modify' ? 'delete' : 'modify');
this.$emit('update:clickedFeatures', []);
this.$store.commit('feature/UPDATE_CHECKED_FEATURES', []);
},
getUserName(feature) {
if (!feature.properties.creator) {
return ' ---- ';
}
return feature.properties.creator.username || ' ---- ';
},
getFeatureDisplayName(feature) {
return feature.properties.title || feature.id;
},
isSortedAsc(column) {
return this.sort.column === column && this.sort.ascending;
},
isSortedDesc(column) {
return this.sort.column === column && !this.sort.ascending;
},
changeSort(column) {
if (this.sort.column === column) {
//changer only order
this.$emit('update:sort', {
column: this.sort.column,
ascending: !this.sort.ascending,
});
} else { // change column and reset order
this.$emit('update:sort', { column, ascending: true });
}
},
},
};
</script>
<style scoped>
/* datatables */
.dataTables_wrapper {
position: relative;
clear: both;
}
table.dataTable th.dt-center, table.dataTable td.dt-center, table.dataTable td.dataTables_empty {
text-align: center;
}
.dataTables_wrapper .dataTables_length,
.dataTables_wrapper .dataTables_filter,
.dataTables_wrapper .dataTables_info,
.dataTables_wrapper .dataTables_processing,
.dataTables_wrapper .dataTables_paginate {
color: #333;
}
.dataTables_wrapper .dataTables_info {
clear: both;
float: left;
padding-top: 0.755em;
}
.dataTables_wrapper .dataTables_paginate {
float: right;
text-align: right;
padding-top: 0.25em;
}
.dataTables_wrapper .dataTables_paginate .paginate_button.current,
.dataTables_wrapper .dataTables_paginate .paginate_button.current:hover {
color: #333 !important;
border: 1px solid #979797;
background-color: white;
background: -webkit-gradient(
linear,
left top,
left bottom,
color-stop(0%, #fff),
color-stop(100%, #dcdcdc)
);
background: -webkit-linear-gradient(top, #fff 0%, #dcdcdc 100%);
background: -moz-linear-gradient(top, #fff 0%, #dcdcdc 100%);
background: -ms-linear-gradient(top, #fff 0%, #dcdcdc 100%);
background: -o-linear-gradient(top, #fff 0%, #dcdcdc 100%);
background: linear-gradient(to bottom, #fff 0%, #dcdcdc 100%);
}
.dataTables_wrapper .dataTables_paginate .paginate_button {
box-sizing: border-box;
display: inline-block;
min-width: 1.5em;
padding: 0.5em 1em;
margin-left: 2px;
text-align: center;
text-decoration: none !important;
cursor: pointer;
color: #333 !important;
border: 1px solid transparent;
border-radius: 2px;
}
.dataTables_wrapper .dataTables_paginate .paginate_button:hover {
color: white !important;
border: 1px solid #111;
background-color: #585858;
background: -webkit-gradient(
linear,
left top,
left bottom,
color-stop(0%, #585858),
color-stop(100%, #111)
);
background: -webkit-linear-gradient(top, #585858 0%, #111 100%);
background: -moz-linear-gradient(top, #585858 0%, #111 100%);
background: -ms-linear-gradient(top, #585858 0%, #111 100%);
background: -o-linear-gradient(top, #585858 0%, #111 100%);
background: linear-gradient(to bottom, #585858 0%, #111 100%);
}
.dataTables_wrapper .dataTables_paginate .paginate_button.disabled,
.dataTables_wrapper .dataTables_paginate .paginate_button.disabled:hover,
.dataTables_wrapper .dataTables_paginate .paginate_button.disabled:active {
cursor: default;
color: #666 !important;
border: 1px solid transparent;
background: transparent;
box-shadow: none;
}
.dataTables_wrapper .dataTables_paginate .ellipsis {
padding: 0 1em;
}
i.icon.sort:not(.down):not(.up) {
color: rgb(220, 220, 220);
}
.pointer:hover {
cursor: pointer;
}
.switch-buttons {
display: flex;
justify-content: center;
align-items: baseline;
}
.grey {
color: #bbbbbb;
}
.ui.dropdown .menu .left.menu, .ui.dropdown > .left.menu .menu {
margin-right: 0 !important;
}
/*
Max width before this PARTICULAR table gets nasty
This query will take effect for any screen smaller than 760px
and also iPads specifically.
*/
@media only screen and (max-width: 760px),
(min-device-width: 768px) and (max-device-width: 1024px) {
/* Force table to not be like tables anymore */
table,
thead,
tbody,
th,
td,
tr {
display: block;
}
/* Hide table headers (but not display: none;, for accessibility) */
thead tr {
position: absolute;
top: -9999px;
left: -9999px;
}
tr {
border: 1px solid #ccc;
}
td {
/* Behave like a "row" */
border: none;
border-bottom: 1px solid #eee;
position: relative;
padding-left: 50%;
}
td:before {
/* Now like a table header */
position: absolute;
/* Top/left values mimic padding */
/* top: 6px; */
left: 6px;
/* width: 45%; */
padding-right: 10px;
white-space: nowrap;
}
/*
Label the data
*/
td:nth-of-type(1):before {
content: "";
}
td:nth-of-type(2):before {
content: "Statut";
}
td:nth-of-type(3):before {
content: "Type";
}
td:nth-of-type(4):before {
content: "Nom";
}
td:nth-of-type(5):before {
content: "Dernière modification";
}
td:nth-of-type(6):before {
content: "Auteur";
}
table.dataTable th.dt-center, table.dataTable td.dt-center, table.dataTable td.dataTables_empty {
text-align: right;
}
#table-features {
margin-left: 1em;
width: calc(100% - 1em);
}
.ui.checkbox {
position: absolute;
left: -1.75em;
top: 5em;
}
}
</style>
\ No newline at end of file
src/main.js
View file @ ee17a921
const axios = require('axios'); // Importing necessary libraries and components
import Vue from 'vue'; const axios = require('axios'); // Axios for HTTP requests
import Vue from 'vue'; // Vue.js framework
import App from './App.vue';
import './registerServiceWorker'; import App from './App.vue'; // Main Vue component
import router from '@/router'; import './registerServiceWorker'; // Service worker registration
import store from '@/store'; import router from '@/router'; // Application router
import 'leaflet/dist/leaflet.css'; import store from '@/store'; // Vuex store for state management
import 'leaflet-draw/dist/leaflet.draw.css';
import '@/assets/resources/leaflet-control-geocoder-1.13.0/Control.Geocoder.css'; import * as Sentry from '@sentry/vue';
import '@fortawesome/fontawesome-free/css/all.css';
import '@fortawesome/fontawesome-free/js/all.js'; // Importing CSS for styling
import './assets/styles/base.css'; // Base styles
import './assets/resources/semantic-ui-2.4.2/semantic.min.css'; // Semantic UI for UI components
import '@fortawesome/fontawesome-free/css/all.css'; // Font Awesome for icons
import '@fortawesome/fontawesome-free/js/all.js'; // Font Awesome JS
import 'ol/ol.css'; // OpenLayers CSS for maps
import '@/assets/styles/openlayers-custom.css'; // Custom styles for OpenLayers
import '@/assets/styles/sidebar-layers.css'; // Styles for sidebar layers
// Font Awesome library setup
import { library } from '@fortawesome/fontawesome-svg-core'; import { library } from '@fortawesome/fontawesome-svg-core';
import { fas } from '@fortawesome/free-solid-svg-icons'; import { fas } from '@fortawesome/free-solid-svg-icons'; // Importing solid icons
import { FontAwesomeIcon } from '@fortawesome/vue-fontawesome'; import { FontAwesomeIcon } from '@fortawesome/vue-fontawesome'; // Font Awesome component
// Multiselect installation
import 'vue-multiselect/dist/vue-multiselect.min.css';
// Vue Multiselect CSS
import 'vue-multiselect/dist/vue-multiselect.min.css'; // Multiselect component styles
Sentry.init({
Vue,
dsn: 'https://de982b53ff2a58de08749f46c3f7f830@sentry.neogeo.fr/32',
integrations: [
Sentry.browserTracingIntegration({ router }),
Sentry.replayIntegration(),
],
// Tracing
tracesSampleRate: 1.0, // Capture 100% of the transactions
// Set 'tracePropagationTargets' to control for which URLs distributed tracing should be enabled
tracePropagationTargets: ['localhost', /^https:\/\/yourserver\.io\/api/],
// Session Replay
replaysSessionSampleRate: 0.1, // This sets the sample rate at 10%. You may want to change it to 100% while in development and then sample at a lower rate in production.
replaysOnErrorSampleRate: 1.0, // If you're not already sampling the entire session, change the sample rate to 100% when sampling sessions where errors occur.
beforeSend(event) {
console.log('Event about to be sent to Sentry:', event);
return event;
}
});
// Adding Font Awesome icons to the library
library.add(fas); library.add(fas);
Vue.component(FontAwesomeIcon); // Registering Font Awesome as a Vue component for use in templates
Vue.component('FontAwesomeIcon', FontAwesomeIcon);
// Setting Vue's production tip configuration
Vue.config.productionTip = false; Vue.config.productionTip = false;
Vue.config.ignoredElements = ['geor-header'];
// gestion mise à jour du serviceWorker et du precache // Handling service worker updates and precaching
var refreshing=false; var refreshing = false; // Flag to prevent multiple refreshes
if(navigator.serviceWorker){ if (navigator.serviceWorker) {
navigator.serviceWorker.addEventListener('controllerchange', () => { navigator.serviceWorker.addEventListener('controllerchange', () => {
// We'll also need to add 'refreshing' to our data originally set to false. // Check if the page is already refreshing to prevent duplicate refreshes
if (refreshing) return; if (refreshing) {
return;
}
refreshing = true; refreshing = true;
// Here the actual reload of the page occurs // Reload the page to activate the new service worker
window.location.reload(); window.location.reload();
}); });
} }
/**
* Dynamically loads a font from Google Fonts and sets CSS variables.
* @param {string} fontNames - A comma-separated list of font names, where the first font is the one to be imported and others are fallbacks.
* @param {string} headerColor - The color to be used for headers.
* @param {string} primaryColor - The primary color for the application.
* @param {string} primaryHighlightColor - The primary color to highlight elements in the application.
*/
const setAppTheme = (fontNames, headerColor, primaryColor, primaryHighlightColor) => {
// Set CSS variables for header and primary color.
if (headerColor) {
document.documentElement.style.setProperty('--header-color', headerColor);
}
if (primaryColor) {
document.documentElement.style.setProperty('--primary-color', primaryColor);
}
if (primaryHighlightColor) {
document.documentElement.style.setProperty('--primary-highlight-color', primaryHighlightColor);
}
// Proceed to load the font if fontNames is provided.
if (fontNames) {
const fontNameToImport = fontNames.split(',')[0].trim();
const link = document.createElement('link');
link.href = `https://fonts.googleapis.com/css?family=${fontNameToImport.replace(/ /g, '+')}:400,700&display=swap`;
link.rel = 'stylesheet';
document.head.appendChild(link);
let onConfigLoaded = function(config){ // Set the CSS variable for font family.
store.commit('SET_CONFIG', config); document.documentElement.style.setProperty('--font-family', fontNames);
}
};
// set title and favico /**
document.title= config.VUE_APP_APPLICATION_NAME+' '+config.VUE_APP_APPLICATION_ABSTRACT; * Sets the favicon of the application.
let link = document.createElement('link'); * @param {string} favicoUrl - The URL of the favicon to be set.
*/
const setFavicon = (favicoUrl) => {
const link = document.createElement('link');
link.id = 'dynamic-favicon'; link.id = 'dynamic-favicon';
link.rel = 'shortcut icon'; link.rel = 'shortcut icon';
link.href = config.VUE_APP_APPLICATION_FAVICO; link.href = favicoUrl;
document.head.appendChild(link); document.head.appendChild(link);
};
/**
* Regularly updates the online status of the application.
*/
const updateOnlineStatus = () => {
setInterval(() => {
store.commit('SET_IS_ONLINE', navigator.onLine);
}, 2000);
};
window.proxy_url=config.VUE_APP_DJANGO_API_BASE+'proxy/'; /**
axios.all([ * Regularly updates the user status if using external auth to keep the frontend updated with backend.
store.dispatch('USER_INFO'), */
store.dispatch('projects/GET_PROJECTS'), function handleLogout() {
if (store.state.user) {
store.commit('SET_USER', false);
store.commit('SET_USER_PERMISSIONS', null);
store.commit('SET_USER_LEVEL_PROJECTS', null);
store.commit('DISPLAY_MESSAGE', {
level: 'negative',
comment: `Vous avez été déconnecté du service d'authentification.
Reconnectez-vous ou continuez en mode anonyme.`
});
store.dispatch('projects/GET_PROJECTS');
store.dispatch('GET_USER_LEVEL_PERMISSIONS');
store.dispatch('GET_USER_LEVEL_PROJECTS');
}
}
const updateUserStatus = () => {
setInterval(() => {
if (navigator.onLine) {
axios
.get(`${store.state.configuration.VUE_APP_DJANGO_API_BASE}user_info/`)
.then((response) => {
const user = response.data?.user || null;
// Cas où l'utilisateur a changé
if (store.state.user?.username !== user.username) {
store.commit('SET_USER', user);
// Cas où l'utilisateur est bien authentifié
if (user) {
store.commit('DISPLAY_MESSAGE', {
level: 'positive',
comment: 'Bienvenue à nouveau ! Vous êtes reconnecté au service d\'authentification'
});
store.dispatch('projects/GET_PROJECTS');
store.dispatch('GET_USER_LEVEL_PERMISSIONS');
store.dispatch('GET_USER_LEVEL_PROJECTS');
} else {
// On force la suppression de l'utilisateur au cas où le serveur SSO ne permet pas à la requête API d'aboutir (ex: redirection si non authentifié SSO)
handleLogout();
}
}
})
.catch(() => {
handleLogout();
});
}
}, 10000);
};
/**
* Fetches initial data for the application and initializes the Vue instance.
*/
const fetchDataAndInitializeApp = async () => {
await Promise.all([
store.dispatch('GET_USER_INFO'),
store.dispatch('GET_STATIC_PAGES'), store.dispatch('GET_STATIC_PAGES'),
store.dispatch('GET_USER_LEVEL_PROJECTS'),
store.dispatch('map/GET_AVAILABLE_LAYERS'), store.dispatch('map/GET_AVAILABLE_LAYERS'),
store.dispatch('GET_USER_LEVEL_PERMISSIONS'),
store.dispatch('GET_LEVELS_PERMISSIONS'), store.dispatch('GET_LEVELS_PERMISSIONS'),
]).then(axios.spread(function () { store.dispatch('GET_PROJECT_ATTRIBUTES'),
new Vue({ ]);
router,
store, new Vue({
render: h => h(App) router,
}).$mount('#app'); store,
})); render: h => h(App)
}).$mount('#app');
};
/**
* Initializes the application configuration.
* @param {object} config - Configuration object with application settings.
*/
const onConfigLoaded = async (config) => {
// Set application configuration in the store.
store.commit('SET_CONFIG', config);
// Update the online status at regular intervals.
updateOnlineStatus();
// Update the user status at regular intervals to check if backend session expired.
updateUserStatus();
// Set the document title and favicon from the configuration.
document.title = `${config.VUE_APP_APPLICATION_NAME} ${config.VUE_APP_APPLICATION_ABSTRACT}`;
setFavicon(config.VUE_APP_APPLICATION_FAVICO);
// Apply the application theme settings using values specified in the configuration.
setAppTheme(
config.VUE_APP_FONT_FAMILY,
config.VUE_APP_HEADER_COLOR,
config.VUE_APP_PRIMARY_COLOR,
config.VUE_APP_PRIMARY_HIGHLIGHT_COLOR
);
// Set a global proxy URL based on the configuration.
window.proxy_url = config.VUE_APP_DJANGO_API_BASE + 'proxy/';
// Fetch initial data and initialize the Vue application.
await fetchDataAndInitializeApp();
}; };
// Attempt to load the application configuration from an external JSON file.
axios.get('./config/config.json') axios.get('./config/config.json')
.catch((error)=>{ .catch((error) => {
// Log an error if the configuration file cannot be loaded.
console.error(error); console.error(error);
console.log('try to get From Localstorage'); console.log('Attempting to get config from Localstorage');
let conf=localStorage.getItem('geontrib_conf');
if(conf){ // Attempt to retrieve the configuration from local storage as a fallback.
const conf = localStorage.getItem('geontrib_conf');
if (conf) {
// If a configuration is found in local storage, parse it and load the config.
onConfigLoaded(JSON.parse(conf)); onConfigLoaded(JSON.parse(conf));
} }
}) })
.then((response) => { .then((response) => {
// Check if the response is valid and the request was successful.
if (response && response.status === 200) { if (response && response.status === 200) {
localStorage.setItem('geontrib_conf',JSON.stringify(response.data)); // Store the retrieved configuration in local storage for future use.
localStorage.setItem('geontrib_conf', JSON.stringify(response.data));
// Load the configuration into the application.
onConfigLoaded(response.data); onConfigLoaded(response.data);
} }
}) })
.catch((error) => { .catch((error) => {
// Throw an error if there are issues processing the response.
throw error; throw error;
}); });
src/registerServiceWorker.js
View file @ ee17a921
...@@ -26,13 +26,19 @@ if (process.env.NODE_ENV === 'production') { ...@@ -26,13 +26,19 @@ if (process.env.NODE_ENV === 'production') {
console.log('New content is downloading.'); console.log('New content is downloading.');
}, },
updated (registration) { updated (registration) {
alert('Une nouvelle version de l\'application est disponible, l\'application va se recharger'); if (!navigator.webdriver) {
console.log('New content is available; please refresh.'); alert('Une nouvelle version de l\'application est disponible, l\'application va se recharger');
// console.log('New content is available; please refresh.');
if (!registration || !registration.waiting) return; //
// Send message to SW to skip the waiting and activate the new SW if (!registration || !registration.waiting) {
registration.waiting.postMessage({ type: 'SKIP_WAITING' }); return;
//window.location.reload(true); }
// Send message to SW to skip the waiting and activate the new SW
registration.waiting.postMessage({ type: 'SKIP_WAITING' });
//window.location.reload(true);
} else {
console.log('Execution dans un navigateur controlé par un agent automatisé, la mise à jour n\'est pas appliqué pendant le test.');
}
}, },
offline () { offline () {
console.log('No internet connection found. App is running in offline mode.'); console.log('No internet connection found. App is running in offline mode.');
......
src/router/index.js
View file @ ee17a921
import Vue from 'vue'; import Vue from 'vue';
import VueRouter from 'vue-router'; import VueRouter from 'vue-router';
import Projects from '../views/Projects.vue'; import ProjectsList from '../views/Projects/ProjectsList.vue';
import store from '@/store';
import featureAPI from '@/services/feature-api';
Vue.use(VueRouter); Vue.use(VueRouter);
...@@ -13,120 +15,198 @@ const routes = [ ...@@ -13,120 +15,198 @@ const routes = [
{ {
path: '/', path: '/',
name: 'index', name: 'index',
component: Projects component: ProjectsList
}, },
{ {
path: '/connexion/', path: `${projectBase === 'projet' ? '': `/${projectBase}/:slug`}/connexion/`,
name: 'login', name: 'login',
// route level code-splitting props: true,
// this generates a separate chunk (login.[hash].js) for this route component: () => import('../views/Login.vue')
// which is lazy-loaded when the route is visited. },
component: () => import(/* webpackChunkName: "login" */'../views/registration/Login.vue') {
path: `${projectBase === 'projet' ? '': `/${projectBase}/:slug`}/inscription/`,
name: 'signup',
component: () => import('../views/Login.vue')
},
{
path: `${projectBase === 'projet' ? '': `/${projectBase}/:slug`}/inscription/succes`,
name: 'sso-signup-success',
props: true,
component: () => import('../views/Login.vue')
}, },
{ {
path: `${projectBase === 'projet' ? '': '/' + projectBase + '/:slug'}/my_account/`, path: `${projectBase === 'projet' ? '': `/${projectBase}/:slug`}/my_account/`,
name: 'my_account', name: 'my_account',
component: () => import('../views/My_account.vue') component: () => import('../views/Account.vue')
}, },
{ {
path: `${projectBase === 'projet' ? '': '/' + projectBase}/mentions/`, path: `${projectBase === 'projet' ? '': '/' + projectBase}/mentions/`,
name: 'mentions', name: 'mentions',
component: () => import('../views/flatpages/with_right_menu.vue') component: () => import('../views/FlatPages/LegalMentions.vue')
}, },
{ {
path: `${projectBase === 'projet' ? '': '/' + projectBase}/aide/`, path: `${projectBase === 'projet' ? '': '/' + projectBase}/aide/`,
name: 'aide', name: 'aide',
component: () => import('../views/flatpages/Default.vue') component: () => import('../views/FlatPages/Help.vue')
}, },
// * PROJECT // * PROJECT
{ {
path: '/creer-projet/', path: '/creer-projet/',
name: 'project_create', name: 'project_create',
component: () => import('../views/project/Project_edit.vue') component: () => import('../views/Project/ProjectEdit.vue')
}, },
{ {
path: `/${projectBase}/:slug`, path: `/${projectBase}/:slug`,
name: 'project_detail', name: 'project_detail',
props: true, props: true,
component: () => import('../views/project/Project_detail.vue'), component: () => import('../views/Project/ProjectDetail.vue'),
},
{
path: `/${projectBase}/:slug/signalement/lister/`,
name: 'liste-signalements',
component: () => import('../views/Project/FeaturesListAndMap.vue')
}, },
{ {
path: `/${projectBase}/:slug/editer`, path: `/${projectBase}/:slug/editer`,
name: 'project_edit', name: 'project_edit',
component: () => import('../views/project/Project_edit.vue') component: () => import('../views/Project/ProjectEdit.vue')
}, },
{ {
path: '/projet-type/', path: '/projet-type/',
name: 'project_type_list', name: 'project_type_list',
component: () => import('../views/project/Project_type_list.vue') component: () => import('../views/Projects/ProjectsTypes.vue')
}, },
{ {
path: '/creer-projet/create_from/:slug/', path: '/creer-projet/create_from/:slug/',
name: 'project_create_from', name: 'project_create_from',
component: () => import('../views/project/Project_edit.vue') component: () => import('../views/Project/ProjectEdit.vue')
}, },
{ {
path: `/${projectBase}/:slug/administration-carte/`, path: `/${projectBase}/:slug/administration-carte/`,
name: 'project_mapping', name: 'project_mapping',
component: () => import('../views/project/Project_mapping.vue') component: () => import('../views/Project/ProjectBasemaps.vue')
}, },
{ {
path: `/${projectBase}/:slug/membres/`, path: `/${projectBase}/:slug/membres/`,
name: 'project_members', name: 'project_members',
component: () => import('../views/project/Project_members.vue') component: () => import('../views/Project/ProjectMembers.vue')
},
{
path: `/${projectBase}/:slug/signalement-filtre/`,
name: 'details-signalement-filtre',
component: () => import('../views/Feature/FeatureDetail.vue')
}, },
// * FEATURE TYPE // * FEATURE TYPE
{ {
path: `/${projectBase}/:slug/type-signalement/ajouter/`, path: `/${projectBase}/:slug/type-signalement/ajouter/`,
name: 'ajouter-type-signalement', name: 'ajouter-type-signalement',
props: true, props: true,
component: () => import('../views/feature_type/Feature_type_edit.vue') component: () => import('../views/FeatureType/FeatureTypeEdit.vue')
}, },
{ {
path: `/${projectBase}/:slug/type-signalement/ajouter/create_from/:slug_type_signal`, path: `/${projectBase}/:slug/type-signalement/ajouter/create_from/:slug_type_signal`,
name: 'dupliquer-type-signalement', name: 'dupliquer-type-signalement',
component: () => import('../views/feature_type/Feature_type_edit.vue') component: () => import('../views/FeatureType/FeatureTypeEdit.vue')
}, },
{ {
path: `/${projectBase}/:slug/type-signalement/:feature_type_slug/`, path: `/${projectBase}/:slug/type-signalement/:feature_type_slug/`,
name: 'details-type-signalement', name: 'details-type-signalement',
component: () => import('../views/feature_type/Feature_type_detail.vue') component: () => import('../views/FeatureType/FeatureTypeDetail.vue')
}, },
{ {
path: `/${projectBase}/:slug/type-signalement/:slug_type_signal/editer/`, path: `/${projectBase}/:slug/type-signalement/:slug_type_signal/editer/`,
name: 'editer-type-signalement', name: 'editer-type-signalement',
component: () => import('../views/feature_type/Feature_type_edit.vue') component: () => import('../views/FeatureType/FeatureTypeEdit.vue')
}, },
{ {
path: `/${projectBase}/:slug/type-signalement/:slug_type_signal/symbologie/`, path: `/${projectBase}/:slug/type-signalement/:slug_type_signal/affichage/`,
name: 'editer-symbologie-signalement', name: 'editer-affichage-signalement',
component: () => import('../views/feature_type/Feature_type_symbology.vue') component: () => import('../views/FeatureType/FeatureTypeDisplay.vue')
}, },
// * FEATURE // * FEATURE
{
path: `/${projectBase}/:slug/signalement/lister/`,
name: 'liste-signalements',
component: () => import('../views/feature/Feature_list.vue')
},
{ {
path: `/${projectBase}/:slug/type-signalement/:slug_type_signal/signalement/ajouter/`, path: `/${projectBase}/:slug/type-signalement/:slug_type_signal/signalement/ajouter/`,
name: 'ajouter-signalement', name: 'ajouter-signalement',
component: () => import('../views/feature/Feature_edit.vue') component: () => import('../views/Feature/FeatureEdit.vue')
}, },
{ {
path: `/${projectBase}/:slug/type-signalement/:slug_type_signal/signalement/:slug_signal`, path: `/${projectBase}/:slug/type-signalement/:slug_type_signal/signalement/:slug_signal`,
name: 'details-signalement', name: 'details-signalement',
component: () => import('../views/feature/Feature_detail.vue') component: () => import('../views/Feature/FeatureDetail.vue'),
/**
* Handles routing logic before entering the details-signalement route.
* This function manages access and navigation based on user permissions and feature data.
*/
beforeEnter: async (to, from, next) => {
try {
const { slug, slug_type_signal, slug_signal } = to.params;
// Retrieve the project details from the store
const project = await store.dispatch('projects/GET_PROJECT', slug);
// Prepare query based on the project settings for feature browsing
const query = { ordering: project.feature_browsing_default_sort };
// Check if the default filter of the project is set to feature_type and apply it
if (project.feature_browsing_default_filter) { // when feature_type is the default filter of the project,
query['feature_type_slug'] = slug_type_signal; // set feature_type slug in query
}
// Get the feature's position based on the feature slug and query settings
const offset = await featureAPI.getFeaturePosition(slug, slug_signal, query);
// Decide next routing based on the offset result
if (offset >= 0) {
next({
name: 'details-signalement-filtre',
params: { slug },
query: { ...query, offset }
});
} else if (offset === 'No Content') {
// API return no content when user is not allowed to see the feature or isn't connected
if (store.state.user) {
// If the user is connected, display information that he's not allowed to view the feature
store.commit('DISPLAY_MESSAGE', { comment: 'Vous n\'avez pas accès à ce signalement avec cet utilisateur', level: 'negative' });
// and redirect to main page
next({ path: '/' });
} else {
// If the user is not connected, remove other messages to avoid displaying twice that the user is not connected
store.commit('CLEAR_MESSAGES');
// display information that user need to be connected
store.commit('DISPLAY_MESSAGE', { comment: 'Vous n\'avez pas accès à ce signalement hors connexion, veuillez-vous connecter au préalable', level: 'negative' });
// Then redirect to login page
if (store.state.configuration.VUE_APP_LOGIN_URL) {
// If the login is through SSO, redirect to external login page (if the instance accepts a redirect_url it would be caught before when requesting user_info with GET_USER_INFO)
setTimeout(() => { // delay switching page to allow the info message to be read by user
window.open(store.state.configuration.VUE_APP_LOGIN_URL);
}, 1500);
} else {
// In a classic installation, redirect to the login page of this application
next({ name: 'login' });
}
}
} else {
store.commit('DISPLAY_MESSAGE', { comment: 'Désolé, une erreur est survenue pendant la recherche du signalement', level: 'negative' });
next({ path: '/' });
}
} catch (error) {
console.error('error', error);
store.commit('DISPLAY_MESSAGE', { comment: `Désolé, une erreur est survenue pendant la recherche du signalement - ${error}`, level: 'negative' });
next({ path: '/' });
}
}
}, },
{ {
path: `/${projectBase}/:slug/type-signalement/:slug_type_signal/offline`, path: `/${projectBase}/:slug/type-signalement/:slug_type_signal/offline`,
name: 'offline-signalement', name: 'offline-signalement',
component: () => import('../views/feature/Feature_offline.vue') component: () => import('../views/Feature/FeatureOffline.vue')
}, },
{ {
path: `/${projectBase}/:slug/type-signalement/:slug_type_signal/signalement/:slug_signal/editer/`, path: `/${projectBase}/:slug/type-signalement/:slug_type_signal/signalement/:slug_signal/editer/`,
name: 'editer-signalement', name: 'editer-signalement',
component: () => import('../views/feature/Feature_edit.vue') component: () => import('../views/Feature/FeatureEdit.vue')
},
{
path: `/${projectBase}/:slug/type-signalement/:slug_type_signal/editer-signalements-attributs/`,
name: 'editer-attribut-signalement',
component: () => import('../views/Feature/FeatureEdit.vue')
}, },
{ {
...@@ -135,16 +215,21 @@ const routes = [ ...@@ -135,16 +215,21 @@ const routes = [
component: () => import('../views/Catalog.vue') component: () => import('../views/Catalog.vue')
}, },
{
path: '/projet/:slug/type-signalement/:slug_type_signal/signalement/:slug_signal/attachment-preview/',
name: 'attachment-preview',
component: () => import('../views/AttachmentPreview.vue')
},
{ path: '/:pathMatch(.*)*', name: 'NotFound', component: () => import('../views/NotFound.vue') }, { path: '/:pathMatch(.*)*', name: 'NotFound', component: () => import('../views/NotFound.vue') },
]; ];
//let routerHistory = [];
const router = new VueRouter({ const router = new VueRouter({
mode: 'history', mode: 'history',
base: '/geocontrib/', base: '/geocontrib/',
routes, routes,
routerHistory: [], routerHistory: [],
scrollBehavior(to, from, savedPosition) { //* record each route change to turn back to origin after redirect scrollBehavior(to, from, savedPosition) { //* record each route change to keep scroll position
const fromHistory = Boolean(savedPosition); const fromHistory = Boolean(savedPosition);
if (fromHistory && this.options.routerHistory.length > 0) { if (fromHistory && this.options.routerHistory.length > 0) {
......
src/service-worker.js
View file @ ee17a921
...@@ -5,7 +5,7 @@ if (workbox) { ...@@ -5,7 +5,7 @@ if (workbox) {
//workbox.core.setLogLevel(workbox.core.LOG_LEVELS.debug) //workbox.core.setLogLevel(workbox.core.LOG_LEVELS.debug)
// apply precaching. In the built version, the precacheManifest will // apply precaching. In the built version, the precacheManifest will
// be imported using importScripts (as is workbox itself) and we can // be imported using importScripts (as is workbox itself) and we can
// precache this. This is all we need for precaching // precache this. This is all we need for precaching
workbox.precaching.precacheAndRoute(self.__precacheManifest); workbox.precaching.precacheAndRoute(self.__precacheManifest);
...@@ -29,10 +29,15 @@ if (workbox) { ...@@ -29,10 +29,15 @@ if (workbox) {
new RegExp('.*/api/.*'), new RegExp('.*/api/.*'),
new workbox.strategies.NetworkFirst({ new workbox.strategies.NetworkFirst({
cacheName: 'api', cacheName: 'api',
plugins: [
new workbox.cacheableResponse.Plugin({
statuses: [0, 200],
}),
],
}) })
); );
workbox.routing.registerRoute( workbox.routing.registerRoute(
/^https:\/\/c\.tile\.openstreetmap\.fr/, /^https:\/\/[a-zA-Z]\.tile\.openstreetmap\.fr/,
new workbox.strategies.CacheFirst({ new workbox.strategies.CacheFirst({
cacheName: 'osm', cacheName: 'osm',
plugins: [ plugins: [
...@@ -46,6 +51,21 @@ if (workbox) { ...@@ -46,6 +51,21 @@ if (workbox) {
], ],
}) })
); );
workbox.routing.registerRoute(
new RegExp('.*/service=WMS&request=GetMap/.*'),
new workbox.strategies.CacheFirst({
cacheName: 'wms',
plugins: [
new workbox.cacheableResponse.Plugin({
statuses: [0, 200],
}),
new workbox.expiration.Plugin({
maxAgeSeconds: 60 * 60 * 24 * 365,
// maxEntries: 30, pour limiter le nombre d'entrée dans le cache
}),
],
})
);
} }
...@@ -54,7 +74,6 @@ self.addEventListener('message', (e) => { ...@@ -54,7 +74,6 @@ self.addEventListener('message', (e) => {
if (!e.data) { if (!e.data) {
return; return;
} }
//console.log(e.data);
switch (e.data.type) { switch (e.data.type) {
case 'SKIP_WAITING': case 'SKIP_WAITING':
self.skipWaiting(); self.skipWaiting();
......
src/services/edition-service.js 0 → 100644
View file @ ee17a921
import { Draw, Snap } from 'ol/interaction';
import Modify from 'ol/interaction/Modify';
import { Collection } from 'ol';
import MultiPoint from 'ol/geom/MultiPoint';
import {
Fill, Stroke, Style, Circle, Text //RegularShape, Circle as CircleStyle, Text,Icon
} from 'ol/style';
import VectorSource from 'ol/source/Vector';
import VectorLayer from 'ol/layer/Vector';
import mapService from '@/services/map-service';
import { buffer } from 'ol/extent';
const editionService = {
drawnFeature: null,
featureToEdit: null,
editing_feature: {},
geom_type: 'linestring',
// Création d'une collection filtrée
filteredFeatures: new Collection(),
// Méthode pour créer un style basé sur la couleur actuelle
createDrawStyle(isEditing) {
return [
new Style({
// Style principal pour le polygone
fill: new Fill({
color: isEditing ? 'rgba(255, 145, 0, .2)' : 'rgba(255, 255, 255, .2)',
}),
// Style principal pour la ligne et le tour du polygone
stroke: new Stroke({
color: isEditing ? 'rgba(255, 145, 0, .9)' : 'rgba(255, 45, 0, 0.5)',
lineDash: [],
width: 2,
}),
// Style principal pour le point
image: new Circle({
radius: 7,
stroke: new Stroke({
color: 'rgba(255, 0, 0, 0.5)',
lineDash: [],
width: 2
}),
fill: new Fill({
color: isEditing ? 'rgba(255, 145, 0, 0.9)' : 'rgba(255, 255, 255, 0.5)'
})
}),
// Style pour le texte, pas utilisé mais peut être conservé au cas où
text: new Text({
font: '12px Calibri,sans-serif',
fill: new Fill({ color: '#000' }),
stroke: new Stroke({
color: '#fff',
width: 1
}),
text: ''
}),
zIndex: 50
}),
// Style pour afficher des points sur les sommets de ligne ou polygone (seulement en mode édition)
...(isEditing
? [
// Définition du style de point
new Style({
image: new Circle({
radius: 5,
stroke: new Stroke({
color: 'rgba(255, 145, 0, .9)',
width: 2,
}),
fill: new Fill({
color: 'rgba(255, 145, 0, .5)',
}),
}),
// Récupération des sommets où afficher les points uniquement pour ligne et polygone
geometry: function (feature) {
const geometry = feature.getGeometry();
if (geometry.getType() === 'LineString') {
return new MultiPoint(geometry.getCoordinates()); // Sommets de la ligne
} else if (geometry.getType() === 'Polygon') {
return new MultiPoint(geometry.getCoordinates()[0]); // Sommets du premier anneau
}
return null;
},
}),
]
: []),
];
},
// Méthode pour changer la couleur de la géométrie existante en passant en mode édition
toggleEditionColor(isEditing) {
const drawStyle = this.createDrawStyle(isEditing); // Re-crée le style
this.drawnItems.setStyle(drawStyle); // Applique le style à la couche
},
setEditingFeature(feature) {
this.editing_feature = feature;
},
initFeatureToEdit(feature) {
this.editing_feature = feature;
this.draw.setActive(false);
this.drawSource.addFeature(feature);
this.drawnItems.setZIndex(50);
mapService.fitExtent(buffer(this.drawSource.getExtent(),200));
},
addEditionControls(geomType) {
this.geom_type = geomType;
this.drawSource = new VectorSource();
this.drawnItems = new VectorLayer({
source: this.drawSource,
style: this.createDrawStyle(),
zIndex: 4000
});
mapService.getMap().addLayer(this.drawnItems);
if (this.draw) {
mapService.getMap().removeInteraction(this.draw);
}
let gType = 'Point';
if (geomType.toUpperCase().indexOf('POLYGON') >= 0) {
gType = 'Polygon';
}
else if (geomType.toUpperCase().indexOf('LINE') >= 0) {
gType = 'LineString';
}
this.draw = new Draw({
source: this.drawSource,
type: gType,
style: this.createDrawStyle()
});
mapService.getMap().addInteraction(this.draw);
this.setEditingFeature(undefined);
this.draw.on('drawend', (evt) => {
var feature = evt.feature;
this.drawnFeature = feature;
this.setEditingFeature(feature);
this.draw.setActive(false);
});
this.modify = new Modify({
style: this.createDrawStyle(),
features: this.filteredFeatures, // Limite la modification aux entités filtrées
});
// This workaround allows to avoid the ol freeze
// referenced bug : https://github.com/openlayers/openlayers/issues/6310
// May be corrected in a future version
this.modify.handleUpEvent_old = this.modify.handleUpEvent;
this.modify.handleUpEvent = function (evt) {
try {
this.handleUpEvent_old(evt);
} catch (ex) {
console.log(ex);
}
};
mapService.getMap().addInteraction(this.modify);
// Supprime dynamiquement la feature des entités modifiables
this.drawSource.on('removefeature', (event) => {
const feature = event.feature;
this.filteredFeatures.remove(feature);
});
},
resetAllTools() {
if (this.draw) {
this.draw.setActive(false);
}
if (this.modify) {
this.modify.setActive(false);
}
},
removeSelectInteraction(interaction) {
interaction.getFeatures().clear();
interaction.setActive(false);
},
activeUpdateFeature(isEditing) {
this.resetAllTools();
if (isEditing) {
// Mise à jour des entités modifiables
this.drawSource.forEachFeature((feature) => {
if (
(this.featureToEdit && feature.id_ === this.featureToEdit.id) ||
(this.drawnFeature && feature.ol_uid === this.drawnFeature.ol_uid) ||
(!this.drawnFeature && !this.featureToEdit)
) {
this.filteredFeatures.push(feature);
}
});
this.modify.setActive(true);
}
this.toggleEditionColor(isEditing);
},
/**
* Deletes the currently displayed feature from the map.
* This method removes the feature directly from the source without additional selection steps.
* It assumes that there is only one feature present in the source.
* Resets the color for future drawings to the default to ensure that the editing color
* is not displayed if the edit mode was active prior to deletion.
*/
removeFeatureFromMap() {
// Access the source where the features are stored
const source = this.drawSource; // Replace with the correct reference to your OpenLayers source
// Get all features from the source
const features = source.getFeatures();
// Check if there is a feature to delete
if (features.length > 0 && confirm('Etes-vous sur de vouloir supprimer cet objet ?')) {
try {
// Reset all other tools to ensure only the delete feature functionality is active
this.resetAllTools();
// Remove the feature from the source
const featureToRemove = features[0];
source.removeFeature(featureToRemove);
// Reinitialize the feature edited on the map
this.editing_feature = undefined;
// Toggle draw mode to create a new feature
this.draw.setActive(true);
// Reset color to default
this.toggleEditionColor(false);
// Return operation result after user confirmed to remove the feature
return true;
} catch (error) {
// Log an error if the feature cannot be removed
console.error('Error while deleting the feature: ', error);
}
}
return false;
},
setFeatureToEdit(feature) {
this.featureToEdit = feature;
},
removeActiveFeatures() {
this.drawnFeature = null;
this.featureToEdit = null;
},
addSnapInteraction(map) {
// The snap interaction must be added after the Modify and Draw interactions
// in order for its map browser event handlers to be fired first. Its handlers
// are responsible of doing the snapping.
// Since we can't give a list of source to snap,
// we use this workaround, an interaction collection: https://github.com/openlayers/openlayers/issues/7100
let interactions = [];
map.getLayers().forEach((layer) => {
if (layer instanceof VectorLayer) {
let interaction = new Snap({
source: layer.getSource()
});
interactions.push(interaction);
}
});
for(let snap of interactions ) {
map.addInteraction(snap);
}
},
removeSnapInteraction(map) {
// Find the double click interaction that is on the map.
let interactions = [];
map.getInteractions().forEach(function (interaction) {
if (interaction instanceof Snap) {
interactions.push(interaction);
}
});
// Remove the interaction from the map.
for(let snap of interactions ) {
map.removeInteraction(snap);
}
}
};
export default editionService;
src/services/feature-api.js
View file @ ee17a921
import axios from '@/axios-client.js'; import axios from '@/axios-client.js';
import store from '../store'; import store from '../store';
const baseUrl = store.state.configuration.VUE_APP_DJANGO_API_BASE;
const featureAPI = { const featureAPI = {
async getFeaturesBbox(project_slug, queryParams) { async getFeaturesBbox(project_slug, queryString) {
const baseUrl = store.state.configuration.VUE_APP_DJANGO_API_BASE;
const response = await axios.get( const response = await axios.get(
`${baseUrl}projects/${project_slug}/feature-bbox/${queryParams ? '?' + queryParams : ''}` `${baseUrl}projects/${project_slug}/feature-bbox/${queryString ? '?' + queryString : ''}`
); );
if ( if (
response.status === 200 && response.status === 200 &&
...@@ -22,8 +21,28 @@ const featureAPI = { ...@@ -22,8 +21,28 @@ const featureAPI = {
} }
}, },
async getProjectFeature(project_slug, feature_id) {
const baseUrl = store.state.configuration.VUE_APP_DJANGO_API_BASE;
const response = await axios.get(
`${baseUrl}v2/features/${feature_id}/?project__slug=${project_slug}`
);
if (
response.status === 200 &&
response.data
) {
return response.data;
} else {
return null;
}
},
async getPaginatedFeatures(url) { async getPaginatedFeatures(url) {
const response = await axios.get(url); // Cancel any ongoing search request.
store.dispatch('CANCEL_CURRENT_SEARCH_REQUEST');
// Prepare the cancel token for the new request and store it.
const cancelToken = axios.CancelToken.source();
store.commit('SET_CANCELLABLE_SEARCH_REQUEST', cancelToken);
const response = await axios.get(url, { cancelToken: cancelToken.token });
if ( if (
response.status === 200 && response.status === 200 &&
response.data response.data
...@@ -35,6 +54,7 @@ const featureAPI = { ...@@ -35,6 +54,7 @@ const featureAPI = {
}, },
async getFeatureEvents(featureId) { async getFeatureEvents(featureId) {
const baseUrl = store.state.configuration.VUE_APP_DJANGO_API_BASE;
const response = await axios.get( const response = await axios.get(
`${baseUrl}features/${featureId}/events/` `${baseUrl}features/${featureId}/events/`
); );
...@@ -49,6 +69,7 @@ const featureAPI = { ...@@ -49,6 +69,7 @@ const featureAPI = {
}, },
async getFeatureAttachments(featureId) { async getFeatureAttachments(featureId) {
const baseUrl = store.state.configuration.VUE_APP_DJANGO_API_BASE;
const response = await axios.get( const response = await axios.get(
`${baseUrl}features/${featureId}/attachments/` `${baseUrl}features/${featureId}/attachments/`
); );
...@@ -62,8 +83,58 @@ const featureAPI = { ...@@ -62,8 +83,58 @@ const featureAPI = {
} }
}, },
async getFeatureLinks(featureId) {
const baseUrl = store.state.configuration.VUE_APP_DJANGO_API_BASE;
const response = await axios.get(
`${baseUrl}features/${featureId}/feature-links/`
);
if (
response.status === 200 &&
response.data
) {
return response.data;
} else {
return null;
}
},
async getFeaturesBlob(url) {
const response = await axios
.get(url, { responseType: 'blob' });
if (
response.status === 200 &&
response.data
) {
return response.data;
} else {
return null;
}
},
async postOrPutFeature({ method, feature_id, feature_type__slug, project__slug, data }) {
const baseUrl = store.state.configuration.VUE_APP_DJANGO_API_BASE;
let url = `${baseUrl}v2/features/`;
if (method === 'PUT') {
url += `${feature_id}/?
feature_type__slug=${feature_type__slug}
&project__slug=${project__slug}`;
}
const response = await axios({
url,
method,
data,
});
if ((response.status === 200 || response.status === 201) && response.data) {
return response;
} else {
return null;
}
},
async updateFeature({ feature_id, feature_type__slug, project__slug, newStatus }) { async updateFeature({ feature_id, feature_type__slug, project__slug, newStatus }) {
let url = `${baseUrl}features/${feature_id}/?feature_type__slug=${feature_type__slug}&project__slug=${project__slug}`; const baseUrl = store.state.configuration.VUE_APP_DJANGO_API_BASE;
const url = `${baseUrl}v2/features/${feature_id}/?feature_type__slug=${feature_type__slug}&project__slug=${project__slug}`;
const response = await axios({ const response = await axios({
url, url,
...@@ -77,7 +148,39 @@ const featureAPI = { ...@@ -77,7 +148,39 @@ const featureAPI = {
} }
}, },
async projectFeatureBulkUpdateStatus(projecSlug, queryString, newStatus) {
const baseUrl = store.state.configuration.VUE_APP_DJANGO_API_BASE;
const url = `${baseUrl}projects/${projecSlug}/feature-bulk-modify/?${queryString}`;
const response = await axios({
url,
method: 'PUT',
data: { status: newStatus }
});
if (response.status === 200 && response.data) {
return response;
} else {
return null;
}
},
async projectFeatureBulkDelete(projecSlug, queryString) {
const baseUrl = store.state.configuration.VUE_APP_DJANGO_API_BASE;
const url = `${baseUrl}projects/${projecSlug}/feature-bulk-modify/?${queryString}`;
const response = await axios({
url,
method: 'DELETE'
});
if (response.status === 200 && response.data) {
return response;
} else {
return null;
}
},
async postComment({ featureId, comment }) { async postComment({ featureId, comment }) {
const baseUrl = store.state.configuration.VUE_APP_DJANGO_API_BASE;
const response = await axios.post( const response = await axios.post(
`${baseUrl}features/${featureId}/comments/`, { comment } `${baseUrl}features/${featureId}/comments/`, { comment }
); );
...@@ -91,10 +194,12 @@ const featureAPI = { ...@@ -91,10 +194,12 @@ const featureAPI = {
} }
}, },
async postCommentAttachment({ featureId, file, fileName, commentId, title }) { async postCommentAttachment({ featureId, file, fileName, title, isKeyDocument, commentId }) {
let formdata = new FormData(); const baseUrl = store.state.configuration.VUE_APP_DJANGO_API_BASE;
const formdata = new FormData();
formdata.append('file', file, fileName); formdata.append('file', file, fileName);
formdata.append('title', title); formdata.append('title', title);
formdata.append('is_key_document', isKeyDocument);
const response = await axios.put( const response = await axios.put(
`${baseUrl}features/${featureId}/comments/${commentId}/upload-file/`, formdata `${baseUrl}features/${featureId}/comments/${commentId}/upload-file/`, formdata
...@@ -108,32 +213,17 @@ const featureAPI = { ...@@ -108,32 +213,17 @@ const featureAPI = {
return null; return null;
} }
}, },
async getFeatureLinks(featureId) { async getFeaturePosition(projectSlug, featureId, query) {
const response = await axios.get( const searchParams = new URLSearchParams(query);
`${baseUrl}features/${featureId}/feature-links/` const baseUrl = store.state.configuration.VUE_APP_DJANGO_API_BASE;
); const response = await axios.get(`${baseUrl}projects/${projectSlug}/feature/${featureId}/position-in-list/?${searchParams.toString()}`);
if ( if (response && response.status === 200) {
response.status === 200 &&
response.data
) {
return response.data;
} else {
return null;
}
},
async getFeaturesBlob(url) {
const response = await axios
.get(url, { responseType: 'blob' });
if (
response.status === 200 &&
response.data
) {
return response.data; return response.data;
} else { } else if (response.status === 204) {
return null; return response.statusText;
} }
return null;
}, },
}; };
......
src/services/featureType-api.js
View file @ ee17a921
import axios from '@/axios-client.js'; import axios from '@/axios-client.js';
import store from '../store'; import store from '@/store';
const baseUrl = store.state.configuration.VUE_APP_DJANGO_API_BASE; const baseUrl = store.state.configuration.VUE_APP_DJANGO_API_BASE;
const featureTypeAPI = { const featureTypeAPI = {
async deleteFeatureType(featureType_slug) { async deleteFeatureType(featureType_slug) {
const response = await axios.delete( const response = await axios.delete(
`${baseUrl}feature-types/${featureType_slug}` `${baseUrl}v2/feature-types/${featureType_slug}/`
); );
if ( if (
response.status === 204 response.status === 204
......
src/services/map-api.js
View file @ ee17a921
...@@ -10,14 +10,14 @@ const mapAPI = { ...@@ -10,14 +10,14 @@ const mapAPI = {
basemap['project'] = projectSlug; basemap['project'] = projectSlug;
if (newBasemapIds.includes(basemap.id)) { if (newBasemapIds.includes(basemap.id)) {
return axios return axios
.post(`${baseUrl}base-maps/`, basemap) .post(`${baseUrl}v2/base-maps/`, basemap)
.then((response) => response) .then((response) => response)
.catch((error) => { .catch((error) => {
throw error; throw error;
}); });
} else { } else {
return axios return axios
.put(`${baseUrl}base-maps/${basemap.id}/`, basemap) .put(`${baseUrl}v2/base-maps/${basemap.id}/`, basemap)
.then((response) => response) .then((response) => response)
.catch((error) => { .catch((error) => {
throw error; throw error;
......
src/services/map-service.js 0 → 100644
View file @ ee17a921
import TileWMS from 'ol/source/TileWMS';
import { View, Map } from 'ol';
import { ScaleLine, Zoom, Attribution, FullScreen } from 'ol/control';
import TileLayer from 'ol/layer/Tile';
import { transform, transformExtent, fromLonLat } from 'ol/proj';
import { defaults } from 'ol/interaction';
import XYZ from 'ol/source/XYZ';
import VectorTileLayer from 'ol/layer/VectorTile';
import VectorTileSource from 'ol/source/VectorTile';
import { MVT, GeoJSON } from 'ol/format';
import { boundingExtent } from 'ol/extent';
import Overlay from 'ol/Overlay';
import { Fill, Stroke, Style, Circle } from 'ol/style';
import { asArray } from 'ol/color';
import VectorSource from 'ol/source/Vector';
import VectorLayer from 'ol/layer/Vector';
import WMTSTileGrid from 'ol/tilegrid/WMTS';
import WMTS, { optionsFromCapabilities } from 'ol/source/WMTS';
import WMTSCapabilities from 'ol/format/WMTSCapabilities';
import Geolocation from 'ol/Geolocation.js';
import Feature from 'ol/Feature.js';
import Point from 'ol/geom/Point.js';
import { applyStyle } from 'ol-mapbox-style';
import { isEqual } from 'lodash';
import axios from '@/axios-client.js';
import router from '@/router';
import store from '@/store';
import { retrieveFeatureProperties } from '@/utils';
const parser = new WMTSCapabilities();
let dictLayersToMap = {};
let layersCount = 0;
const geolocationStyle = new Style({
image: new Circle({
radius: 6,
fill: new Fill({
color: '#3399CC',
}),
stroke: new Stroke({
color: '#fff',
width: 2,
}),
}),
});
const mapService = {
layers: [],
mvtLayer: undefined,
content: {},
overlay: {},
map: undefined,
queryParams: {},
geolocation: undefined, // for geolocation
geolocationSource: null, // for geolocation
positionFeature: null, // for geolocation
lastPosition: null, // for geolocation
getMap() {
return this.map;
},
destroyMap() {
this.map = undefined;
},
createMap(el, options) {
const {
lat,
lng,
mapDefaultViewCenter,
mapDefaultViewZoom,
maxZoom,
zoom,
zoomControl = true,
fullScreenControl = false,
geolocationControl = false,
interactions = { doubleClickZoom: false, mouseWheelZoom: false, dragPan: true },
controls = [
new Attribution({ collapsible: false }),
new ScaleLine({
units: 'metric',
}),
],
} = options;
if (fullScreenControl) {
controls.push(new FullScreen({ tipLabel: 'Mode plein écran' }));
}
const mapOptions = {
layers: [],
target: el,
controls,
interactions: defaults(interactions),
view: new View({
center: transform([ //* since 0 is considered false, check for number instead of just defined (though boolean will pass through)
Number(lng) ? lng : mapDefaultViewCenter[1],
Number(lat) ? lat : mapDefaultViewCenter[0],
], 'EPSG:4326', 'EPSG:3857'),
zoom: Number(mapDefaultViewZoom) ? mapDefaultViewZoom : zoom,
maxZoom
}),
};
this.map = new Map(mapOptions);
if (zoomControl) {
this.map.addControl(new Zoom({ zoomInTipLabel: 'Zoomer', zoomOutTipLabel: 'Dézoomer' }));
}
if (geolocationControl) {
this.initGeolocation();
}
this.map.once('rendercomplete', () => {
this.map.updateSize();
});
const container = document.getElementById('popup');
this.content = document.getElementById('popup-content');
const closer = document.getElementById('popup-closer');
this.overlay = new Overlay({
element: container,
autoPan: true,
autoPanAnimation: {
duration: 500,
},
});
let overlay = this.overlay;
if (closer) {
closer.onclick = function () {
overlay.setPosition(undefined);
closer.blur();
return false;
};
}
this.map.addOverlay(this.overlay);
this.map.on('click', this.onMapClick.bind(this));
// catch event from sidebarLayer to update layers order (since all maps use it now)
document.addEventListener('change-layers-order', (event) => {
// Reverse is done because the first layer in order has to be added in the map in last.
// Slice is done because reverse() changes the original array, so we make a copy first
this.updateOrder(event.detail.layers.slice().reverse());
});
return this.map;
},
addRouterToPopup({ featureId, featureTypeSlug, index }) {
const getFeaturePosition = async (searchParams) => {
const response = await axios.get(`${store.state.configuration.VUE_APP_DJANGO_API_BASE}projects/${router.history.current.params.slug}/feature/${featureId}/position-in-list/?${searchParams.toString()}`);
return response.data;
};
const goToBrowseFeatureDetail = async () => {
const currentQuery = { ...this.queryParams };
if (this.queryParams && this.queryParams.filter === 'feature_type_slug') { // when feature_type is the default filter of the project,
currentQuery['feature_type_slug'] = featureTypeSlug; // get its slug for the current feature
}
const searchParams = new URLSearchParams(currentQuery); // urlSearchParams allow to get rid of undefined values
if (!index >= 0) { // with mvt feature, there can't be an index
index = await getFeaturePosition(searchParams);
}
router.push({
name: 'details-signalement-filtre',
query: {
...Object.fromEntries(searchParams.entries()), // transform search params into object and spread it into query
offset: index
}
});
};
function goToFeatureDetail() {
router.push({
name: 'details-signalement',
params: {
slug_type_signal: featureTypeSlug,
slug_signal: featureId,
},
});
}
const goToFeatureTypeDetail = () => {
router.push({
name: 'details-type-signalement',
params: {
feature_type_slug: featureTypeSlug,
},
});
};
const isFeatureBrowsing = (router.history.current.name === 'project_detail' || router.history.current.name === 'liste-signalements');
const featureEl = document.getElementById('goToFeatureDetail');
if (featureEl) featureEl.onclick = isFeatureBrowsing ? goToBrowseFeatureDetail : goToFeatureDetail;
const featureTypeEl = document.getElementById('goToFeatureTypeDetail');
if (featureTypeEl) featureTypeEl.onclick = goToFeatureTypeDetail;
},
async onMapClick (event) {
//* retrieve features under pointer
const features = this.map.getFeaturesAtPixel(event.pixel, {
layerFilter: (l) => l === this.mvtLayer || this.olLayer
});
//* prepare popup content
if (features && features.length > 0 && this.content) {
const featureId = features[0].properties_ ? features[0].properties_.feature_id : features[0].id_;
const isEdited = router.history.current.name === 'editer-signalement' &&
router.history.current.params.slug_signal === featureId; //* avoid opening popup on feature currently edited
if (featureId && !isEdited) {
const popupContent = await this._createContentPopup(features[0]);
this.content.innerHTML = popupContent.html;
this.overlay.setPosition(event.coordinate);
this.addRouterToPopup({
featureId,
featureTypeSlug: popupContent.feature_type ? popupContent.feature_type.slug : '',
index: popupContent.index,
});
}
} else if (this.layers) { // If no feature under the mouse pointer, attempt to find a query layer
const queryLayer = this.layers.find(x => x.query);
if (queryLayer) {
// pour compatibilité avec le proxy django
const proxyparams = [
'request',
'service',
'srs',
'version',
'bbox',
'height',
'width',
'layers',
'query_layers',
'info_format', 'x', 'y', 'i', 'j',
];
const url = this.getFeatureInfoUrl(event, queryLayer);
const urlInfos = url ? url.split('?') : [];
const urlParams = new URLSearchParams(urlInfos[1]);
const params = {};
Array.from(urlParams.keys()).forEach(param => {
if (proxyparams.indexOf(param.toLowerCase()) >= 0) {
params[param.toLowerCase()] = urlParams.get(param);
}
});
params.url = urlInfos[0];
axios.get(
window.proxy_url,
{ params }
).then(response => {
const data = response.data;
const err = typeof data === 'object' ? null : data;
if (data.features || err) this.showGetFeatureInfo(err, event, data, queryLayer);
}).catch(error => {
throw error;
});
}
}
},
showGetFeatureInfo: function (err, event, data, layer) {
let content;
if (err) {
content = `
<h4>${layer.options.title}</h4>
<p>Données de la couche inaccessibles</p>
`;
this.content.innerHTML = content;
this.overlay.setPosition(event.coordinate);
} else { // Otherwise show the content in a popup
const contentLines = [];
let contentTitle;
if (data.features.length > 0) {
Object.entries(data.features[0].properties).forEach(entry => {
const [key, value] = entry;
if (key !== 'bbox') {
contentLines.push(`<div>${key}: ${value}</div>`);
}
});
contentTitle = `<h4>${layer.options.title}</h4>`;
content = contentTitle.concat(contentLines.join(''));
this.content.innerHTML = content;
this.overlay.setPosition(event.coordinate);
}
}
},
getFeatureInfoUrl(event, layer) {
const olLayer = dictLayersToMap[layer.id];
const source = olLayer.getSource();
const viewResolution = this.map.getView().getResolution();
let url;
const wmsOptions = { info_format: 'application/json', query_layers: layer.options.layers };
if (source && source.getFeatureInfoUrl) {
url = source.getFeatureInfoUrl(event.coordinate, viewResolution, 'EPSG:3857', wmsOptions);
}
return url;
},
fitBounds(bounds) {
let ext = boundingExtent([[bounds[0][1], bounds[0][0]], [bounds[1][1], bounds[1][0]]]);
ext = transformExtent(ext, 'EPSG:4326', 'EPSG:3857');
this.map.getView().fit(ext, { padding: [25, 25, 25, 25], maxZoom: 16 });
},
fitExtent(ext) {
//ext = transformExtent(ext, 'EPSG:4326', 'EPSG:3857');
this.map.getView().fit(ext, { padding: [25, 25, 25, 25] });
},
/**
* Add multiple layers to the map. If custom layers are defined, they will be added using `addConfigLayer`.
* If no custom layers are defined, a default basemap will be added based on the schema type (WMS, WMTS, or XYZ).
*
* @param {Array} layers - Array of layer configurations to be added.
* @param {string} serviceMap - URL or service for the map base layer.
* @param {Object} optionsMap - Options for the base layer (e.g., attribution, noWrap).
* @param {string} schemaType - Type of the base layer (either 'wms', 'wmts', or fallback to XYZ).
*
* @returns {void}
*/
addLayers: function (layers, serviceMap, optionsMap, schemaType) {
// Set the current layers to the provided layers array
this.layers = layers;
// Check if custom layers are defined (admin-defined basemaps)
if (layers) {
// Reset the layer count for managing Z-index
layersCount = 0;
// Loop through each layer and add it using the addConfigLayer method
layers.forEach((layer) => {
if (!layer) {
console.error('Layer is missing in the provided layers array.');
} else {
this.addConfigLayer(layer);
}
});
}
// If no custom layers are defined, fall back to the base map
else {
// Ensure that options for the base map are provided
if (!optionsMap) {
console.error('Options for the base map are missing.');
return;
}
// Set noWrap to true to prevent map wrapping around the globe
optionsMap.noWrap = true;
// Handle the base map based on the schema type (WMS, WMTS, or fallback)
if (schemaType === 'wms') {
// Add WMS layer if the schema type is 'wms'
if (!serviceMap) {
console.error('Service URL is missing for WMS base layer.');
} else {
this.addWMSLayer(serviceMap, optionsMap);
}
} else if (schemaType === 'wmts') {
// Add WMTS layer if the schema type is 'wmts'
if (!serviceMap) {
console.error('Service URL is missing for WMTS base layer.');
} else {
this.addWMTSLayerFromCapabilities(serviceMap, optionsMap);
}
} else {
// Default to XYZ tile layer if the schema type is not WMS or WMTS
if (!serviceMap) {
console.error('Service URL is missing for XYZ base layer.');
} else {
const layer = new TileLayer({
source: new XYZ({
attributions: optionsMap.attribution, // Attribution for the layer
url: serviceMap.replace('{s}', '{a-c}') // Handle subdomains in the URL
})
});
this.map.addLayer(layer); // Add the layer to the map
}
}
}
},
/**
* Add a configuration layer (WMS, WMTS, or TMS) to the map based on the layer's schema type.
* The function handles multiple types of map layers and applies the necessary configurations.
*
* @param {Object} layer - The layer configuration object.
* @param {Object} layer.options - Options for the layer (e.g., opacity, noWrap).
* @param {string} layer.schema_type - Type of the layer ('wms', 'wmts', or 'tms').
* @param {string} layer.service - URL or service for the layer.
* @param {number} layer.opacity - Opacity of the layer.
*
* @returns {void}
*/
addConfigLayer: async function (layer) {
// Check if the layer object is provided
if (!layer) {
console.error('Layer object is missing');
return;
}
// Increment the layers count (to manage Z-index)
layersCount += 1;
// Extract options from the layer
const options = layer.options;
// Check if options are provided for the layer
if (!options) {
console.error(`Options are missing for layer: ${layer.id}`);
return;
}
// Set default layer options (noWrap and opacity)
options.noWrap = true; // Prevent wrapping of the layer around the globe
options['opacity'] = layer.opacity; // Set opacity based on the layer's configuration
// Handle WMS layers
if (layer.schema_type === 'wms') {
// Add title for queryable WMS layers
if (layer.queryable) options['title'] = layer.title;
dictLayersToMap[layer.id] = this.addWMSLayer(layer.service, options); // Add WMS layer
}
// Handle WMTS layers
else if (layer.schema_type === 'wmts') {
try {
const newLayer = await this.addWMTSLayerFromCapabilities(layer.service, options); // Add WMTS layer asynchronously
dictLayersToMap[layer.id] = newLayer;
} catch (error) {
console.error(`Error adding WMTS layer: ${layer.id}`, error);
}
}
// Handle TMS layers
else if (layer.schema_type === 'tms') {
try {
const newLayer = await this.addTMSLayer(layer.service, options); // Add TMS layer asynchronously
dictLayersToMap[layer.id] = newLayer;
} catch (error) {
console.error(`Error adding TMS layer: ${layer.id}`, error);
}
} else {
console.error(`Unsupported schema type: ${layer.schema_type}`);
}
// Set Z-index for the layer if it was successfully added to the map
if (dictLayersToMap[layer.id]) {
dictLayersToMap[layer.id].setZIndex(layersCount);
} else {
console.error(`Failed to add layer to map: ${layer.id}`);
}
},
addWMSLayer: function (url, options) {
options.VERSION = options.version || '1.3.0'; // pour compatibilité avec le proxy django
const source = new TileWMS({
attributions: options.attribution,
url: url,
crossOrigin: 'anonymous',
params: options
});
const layer = new TileLayer({
source: source,
opacity: parseFloat(options.opacity),
});
this.map.addLayer(layer);
return layer;
},
getWMTSLayerCapabilities: async function (url) {
// adapted from : https://openlayers.org/en/latest/examples/wmts-layer-from-capabilities.html
// get capabilities with request to the service
try {
const response = await fetch(url);
const text = await response.text();
const capabilities = parser.read(text);
return capabilities;
} catch (error) {
console.error(error);
}
},
addWMTSLayerFromCapabilities: async function (url, options) {
// adapted from : https://git.neogeo.fr/onegeo-suite/sites/onegeo-suite-site-maps-vuejs/-/blob/draft/src/services/MapService.ts
const wmtsCapabilities = await this.getWMTSLayerCapabilities(url);
const { layer, opacity, attributions, format, ignoreUrlInCapabiltiesResponse } = options;
let sourceOptions;
try {
if (format) {
sourceOptions = optionsFromCapabilities(wmtsCapabilities, { layer, format });
} else {
sourceOptions = optionsFromCapabilities(wmtsCapabilities, { layer });
}
}
catch (e) {
console.error(e);
if (e.message == 'projection is null') {
return 'Projection non reconnue';
}
else {
return 'Problème d\'analyse du getCapabilities';
}
}
if (ignoreUrlInCapabiltiesResponse) {
var searchMask = 'request(=|%3D)getCapabilities';
var regEx = new RegExp(searchMask, 'ig');
var replaceMask = '';
sourceOptions.urls[0] = url.replace(regEx, replaceMask);
}
sourceOptions.attributions = attributions;
sourceOptions.crossOrigin= 'anonymous';
if (layer === 'ORTHOIMAGERY.ORTHOPHOTOS') {
// un peu bourrin mais il semble y avoir qq chose de spécifique avec cette couche ORTHO
// https://geoservices.ign.fr/documentation/services/utilisation-web/affichage-wmts/openlayers-et-wmts
sourceOptions.tileGrid = new WMTSTileGrid({
origin: [-20037508,20037508],
resolutions: [
156543.03392804103,
78271.5169640205,
39135.75848201024,
19567.879241005125,
9783.939620502562,
4891.969810251281,
2445.9849051256406,
1222.9924525628203,
611.4962262814101,
305.74811314070485,
152.87405657035254,
76.43702828517625,
38.218514142588134,
19.109257071294063,
9.554628535647034,
4.777314267823517,
2.3886571339117584,
1.1943285669558792,
0.5971642834779396,
0.29858214173896974,
0.14929107086948493,
0.07464553543474241
],
matrixIds: ['0','1','2','3','4','5','6','7','8','9','10','11','12','13','14','15','16','17','18','19'],
});
}
const newLayer = new TileLayer({
opacity: parseFloat(opacity) || 1,
source: new WMTS(sourceOptions),
});
this.map.addLayer(newLayer);
return newLayer;
},
/**
* Add a TMS (Tile Map Service) layer to the map.
* If the URL includes `.pbf` (vector tiles), it will apply a style from the provided options.
* The layer will be added to the map, and the style will be applied asynchronously if needed.
*
* @param {string} url - The URL of the TMS layer service.
* @param {Object} options - Configuration options for the TMS layer, including opacity and style.
* @param {string} options.style - URL to the style JSON (required for vector tiles).
* @param {number} options.opacity - Opacity of the layer (optional).
*
* @returns {VectorTileLayer} - The TMS layer added to the map.
*/
async addTMSLayer(url, options) {
// Check if the URL is missing
if (!url) {
console.error('TMS layer service URL is missing');
// Check if the options object is missing
} else if (!options) {
console.error('TMS layer options object is missing');
} else {
let layerTms;
// Check if the URL refers to PBF (vector tiles)
if (url.includes('pbf')) {
// Ensure that a style is provided for vector tiles
if (!options.style) {
console.error('TMS layer from PBF requires a style in the options');
} else {
// Handle PBF vector tiles
layerTms = new VectorTileLayer({
source: new VectorTileSource({
format: new MVT(), // Format for vector tiles (Mapbox Vector Tiles)
url: url.replace('{s}', '{a-c}'), // Handle subdomain pattern in the URL if present
attributions: options.attribution,
})
});
try {
// Fetch the style JSON from the provided URL
const response = await fetch(options.style);
const json = await response.json();
// Apply the fetched style to the layer (asynchronous)
await applyStyle(layerTms, json);
} catch (error) {
// Handle any errors during the fetch process
console.error('Error loading the style JSON:', error);
}
}
} else {
// Handle PNG raster tiles
layerTms = new TileLayer({
source: new XYZ({
url: url.replace('{s}', '{a-c}'), // Use the PNG TMS URL pattern
attributions: options.attribution,
})
});
}
// Set the opacity for the layer (default to 1.0 if not specified)
layerTms.setOpacity(parseFloat(options.opacity || 1.0));
// Add the TMS layer to the map
this.map.addLayer(layerTms);
// Return the TMS layer for further manipulation if needed
return layerTms;
}
},
// Remove the base layers (not the features)
removeLayers: function () {
Object.values(dictLayersToMap).forEach(element => {
this.map.removeLayer(element);
});
dictLayersToMap = {};
},
updateOpacity(layerId, opacity) {
const layer = dictLayersToMap[layerId];
if (layer) {
layer.setOpacity(parseFloat(opacity));
} else {
console.error(`Layer with id: ${layerId} couldn't be found for opacity update`);
}
},
updateOrder(layers) {
// First remove existing layers undefined
layers = layers.filter(function (x) {
return x !== undefined;
});
this.removeLayers();
// Redraw the layers
this.addLayers(layers);
},
retrieveFeatureStyle: function (featureType, properties) {
const { colors_style, customfield_set } = featureType;
let { color, opacity } = featureType;
if (colors_style && colors_style.custom_field_name && customfield_set) {
const customField = customfield_set.find((el) => el.name === colors_style.custom_field_name);
if (customField) {
const fieldType = customField.field_type;
let currentValue = properties[colors_style.custom_field_name];
if (currentValue && typeof currentValue === 'string') currentValue = currentValue.trim(); // remove leading and trailing whitespaces
switch (fieldType) {
case 'list':
if (currentValue) {
color = colors_style.colors && colors_style.colors[currentValue];
opacity = colors_style.opacities && colors_style.opacities[currentValue];
}
break;
case 'char': //* if the custom field is supposed to be a string
//* check if its current value is empty or not, to select a color | https://redmine.neogeo.fr/issues/14048
color = colors_style.value.colors && colors_style.value.colors[currentValue ? 'Non vide' : 'Vide'];
opacity = colors_style.value.opacities && colors_style.value.opacities[currentValue ? 'Non vide' : 'Vide'];
break;
case 'boolean':
color = colors_style.value.colors && colors_style.value.colors[currentValue ? 'Coché' : 'Décoché'];
opacity = colors_style.value.opacities && colors_style.value.opacities[currentValue ? 'Coché' : 'Décoché'];
break;
}
}
}
return { color, opacity };
},
addVectorTileLayer: function ({ url, project_slug, featureTypes, formFilters = {}, queryParams = {} }) {
const projectId = project_slug.split('-')[0];
const format_cfg = {/*featureClass: Feature*/ };
const mvt = new MVT(format_cfg);
function customLoader(tile, src) {
tile.setLoader(function(extent, resolution, projection) {
const token = () => {
const re = new RegExp('csrftoken=([^;]+)');
const value = re.exec(document.cookie);
return (value != null) ? unescape(value[1]) : null;
};
fetch(src, {
credentials: 'include',
headers: {
'X-CSRFToken': token()
},
}).then(function(response) {
response.arrayBuffer().then(function(data) {
const format = tile.getFormat(); // ol/format/MVT configured as source format
const features = format.readFeatures(data, {
extent: extent,
featureProjection: projection
});
tile.setFeatures(features);
});
});
});
}
const options = {
urls: [],
matrixSet: 'EPSG:3857',
tileLoadFunction: customLoader,
};
options.format = mvt;
const layerSource = new VectorTileSource(options);
layerSource.setTileUrlFunction((p0) => {
return `${url}/?tile=${p0[0]}/${p0[1]}/${p0[2]}&project_id=${projectId}`;
});
const styleFunction = (feature) => this.getStyle(feature, featureTypes, formFilters);
this.mvtLayer = new VectorTileLayer({
style: styleFunction,
source: layerSource
});
this.featureTypes = featureTypes; // store featureTypes for popups
this.projectSlug = project_slug; // store projectSlug for popups
this.queryParams = queryParams; // store queryParams for popups
this.mvtLayer.setZIndex(30);
this.map.addLayer(this.mvtLayer);
window.layerMVT = this.mvtLayer;
},
/**
* Determines the style for a given feature based on its type and applicable filters.
*
* @param {Object} feature - The feature to style.
* @param {Array} featureTypes - An array of available feature types.
* @param {Object} formFilters - Filters applied through the form.
* @returns {ol.style.Style} - The OpenLayers style for the feature.
*/
getStyle: function (feature, featureTypes, formFilters) {
const properties = feature.getProperties();
let featureType;
// Determine the feature type. Differentiate between GeoJSON and MVT sources.
if (properties && properties.feature_type) {
// Handle GeoJSON feature type
featureType = featureTypes
.find((ft) => ft.slug === (properties.feature_type.slug || properties.feature_type));
} else {
// Handle MVT feature type
featureType = featureTypes.find((x) => x.slug.split('-')[0] === '' + properties.feature_type_id);
}
if (featureType) {
// Retrieve the style (color, opacity) for the feature.
const { color, opacity } = this.retrieveFeatureStyle(featureType, properties);
let colorValue = '#000000'; // Default color
// Determine the color value based on the feature type.
if (color && color.value && color.value.length) {
colorValue = color.value;
} else if (typeof color === 'string' && color.length) {
colorValue = color;
}
// Convert the color value to RGBA and apply the opacity.
const rgbaColor = asArray(colorValue);
rgbaColor[3] = opacity || 0.5; // Default opacity
// Define the default style for the feature.
const defaultStyle = new Style({
image: new Circle({
fill: new Fill({ color: rgbaColor }),
stroke: new Stroke({ color: colorValue, width: 2 }),
radius: 5,
}),
stroke: new Stroke({ color: colorValue, width: 2 }),
fill: new Fill({ color: rgbaColor }),
});
// Define a hidden style to apply when filters are active.
const hiddenStyle = new Style();
// Apply filters based on feature type, status, and title.
if (formFilters) {
if (formFilters.type && formFilters.type.length > 0 && !formFilters.type.includes(featureType.slug)) {
return hiddenStyle;
}
if (formFilters.status && formFilters.status.length > 0 && !formFilters.status.includes(properties.status)) {
return hiddenStyle;
}
if (formFilters.title && !properties.title.toLowerCase().includes(formFilters.title.toLowerCase())) {
return hiddenStyle;
}
}
// Return the default style if no filters are applied or if the feature passes the filters.
return defaultStyle;
} else {
console.error('No corresponding featureType found.');
return new Style();
}
},
addFeatures: function ({ features, filter = {}, featureTypes, addToMap = true, project_slug, queryParams = {} }) {
console.log('addToMap', addToMap);
const drawSource = new VectorSource();
let retour;
let index = 0;
features.forEach((feature) => {
try {
if (feature.properties) {
feature.properties['index'] = index;
index += 1;
}
retour = new GeoJSON().readFeature(feature, { dataProjection: 'EPSG:4326', featureProjection: 'EPSG:3857' }, featureTypes);
drawSource.addFeature(retour);
} catch (err) {
console.error(err);
}
});
const styleFunction = (feature) => this.getStyle(feature, featureTypes, filter);
const olLayer = new VectorLayer({
source: drawSource,
style: styleFunction,
});
olLayer.setZIndex(29);
this.map.addLayer(olLayer);
this.olLayer = olLayer;
this.drawSource = drawSource;
this.featureTypes = featureTypes; // store featureTypes for popups
this.projectSlug = project_slug; // store projectSlug for popups
this.queryParams = queryParams; // store queryParams for popup routes
return drawSource;
},
removeFeatures: function () {
this.drawSource.clear();
},
addMapEventListener: function (eventName, callback) {
this.map.on(eventName, callback);
},
createCustomFiedsContent(featureType, feature) {
const { customfield_set } = featureType;
// generate html for each customField configured to be displayed
let rows = '';
for (const { label, name } of customfield_set) {
const value = feature.getProperties()[name];
// check if the value is not null nor undefined (to allow false value if boolean)
if (featureType.displayed_fields.includes(name) && value !== null && value !== undefined) {
rows += `<div class="customField-row">${label} : ${value}</div>`;
}
}
// wrap all rows into customFields container
return rows.length > 0 ?
`<div id="customFields">
<div class="ui divider"></div>
<h5>Champs personnalisés</h5>
${rows}
</div>` : '';
},
_createContentPopup: async function (feature) {
const properties = await retrieveFeatureProperties(feature, this.featureTypes, this.projectSlug);
const { feature_type, index, status, updated_on, created_on, creator, display_last_editor } = properties; // index is used to retrieve feature by query when browsing features
const { displayed_fields } = feature_type;
// generate html for each native fields
const statusHtml = `<div>Statut : ${status}</div>`;
const featureTypeHtml = `<div>Type de signalement : ${feature_type ? '<a id="goToFeatureTypeDetail" class="pointer">' + feature_type.title + '</a>' : 'Type de signalement inconnu'}</div>`;
const updatedOnHtml = `<div>Dernière mise à jour : ${updated_on}</div>`;
const createdOnHtml = `<div>Date de création : ${created_on}</div>`;
const creatorHtml = creator ? `<div>Auteur : ${creator}</div>` : '';
const lastEditorHtml = display_last_editor ? `<div>Dernier éditeur : ${display_last_editor}</div>` : '';
// wrapping up finale html to fill popup, filtering native fields to display and adding filtered customFields
const html = `<h4>
<a id="goToFeatureDetail" class="pointer">${feature.getProperties ? feature.getProperties().title : feature.title}</a>
</h4>
<div class="fields">
${displayed_fields.includes('status') ? statusHtml : ''}
${displayed_fields.includes('feature_type') ? featureTypeHtml : ''}
${displayed_fields.includes('updated_on') ? updatedOnHtml : ''}
${displayed_fields.includes('created_on') ? createdOnHtml : ''}
${displayed_fields.includes('display_creator') ? creatorHtml : ''}
${displayed_fields.includes('display_last_editor') ? lastEditorHtml : ''}
${this.createCustomFiedsContent(feature_type, feature)}
</div>`;
return { html, feature_type, index };
},
zoom(zoomlevel) {
this.map.getView().setZoom(zoomlevel);
},
zoomTo(location, zoomlevel, lon, lat) {
if (lon && lat) {
location = [+lon, +lat];
}
this.map.getView().setCenter(transform(location, 'EPSG:4326', 'EPSG:3857'));
this.zoom(zoomlevel);
},
animateTo(center, zoom) {
this.map.getView().animate({ center, zoom });
},
addOverlay(loc, zoom) {
const pos = fromLonLat(loc);
const marker = new Overlay({
position: pos,
positioning: 'center',
element: document.getElementById('marker'),
stopEvent: false,
});
this.map.addOverlay(marker);
this.animateTo(pos, zoom);
},
initGeolocation() {
this.geolocation = new Geolocation({
// enableHighAccuracy must be set to true to have the heading value.
trackingOptions: {
enableHighAccuracy: true,
},
projection: this.map.getView().getProjection(),
});
// handle this.geolocation error.
this.geolocation.on('error', (error) => {
console.error(error.message);
});
this.positionFeature = new Feature();
this.positionFeature.setStyle( geolocationStyle );
this.geolocation.on('change:position', () => {
const currentPosition = this.geolocation.getPosition();
if (!currentPosition || !isEqual(this.lastPosition, currentPosition)) {
console.log('current position: ', currentPosition); // keeping this console.log for debug purpose in case needed
}
this.lastPosition = currentPosition;
this.changeTrackerPosition();
});
this.geolocationSource = new VectorSource({
features: [this.positionFeature],
});
new VectorLayer({
map: this.map,
source: this.geolocationSource,
});
},
changeTrackerPosition() {
if (this.lastPosition) {
this.positionFeature.setGeometry(new Point(this.lastPosition));
this.animateTo(this.lastPosition, 16);
}
},
displayGeolocationPoint(isVisible) {
let features = this.geolocationSource.getFeatures();
if (!features) return;
const hiddenStyle = new Style(); // hide the feature
for (let i = 0; i < features.length; i++) {
features[i].setStyle(isVisible ? geolocationStyle : hiddenStyle);
}
},
toggleGeolocation(isTracking) {
if (this.geolocation) {
this.geolocation.setTracking(isTracking);
if (this.geolocationSource) {
this.displayGeolocationPoint(isTracking);
if (isTracking) {
this.changeTrackerPosition();
}
}
}
},
getMapCenter() {
const location = this.map.getView().getCenter();
if (location) {
return transform(location, 'EPSG:3857', 'EPSG:4326');
}
return null;
}
};
export default mapService;
\ No newline at end of file
src/services/misc-api.js
View file @ ee17a921
...@@ -38,6 +38,17 @@ const miscAPI = { ...@@ -38,6 +38,17 @@ const miscAPI = {
} }
}, },
async getUserEvents(project_slug) {
const response = await axios.get(`${baseUrl}events/${project_slug ? '?project_slug=' + project_slug : ''}`);
if (
response.status === 200 &&
response.data
) {
return response.data;
} else {
return null;
}
},
}; };
export default miscAPI; export default miscAPI;
src/services/project-api.js
View file @ ee17a921
...@@ -4,7 +4,7 @@ const projectAPI = { ...@@ -4,7 +4,7 @@ const projectAPI = {
async getProject( baseUrl, projectSlug ) { async getProject( baseUrl, projectSlug ) {
const response = await axios.get( const response = await axios.get(
`${baseUrl}projects/${projectSlug}/` `${baseUrl}v2/projects/${projectSlug}/`
); );
if ( if (
response.status === 200 && response.status === 200 &&
...@@ -45,21 +45,28 @@ const projectAPI = { ...@@ -45,21 +45,28 @@ const projectAPI = {
} }
}, },
async getProjects(baseUrl, filters, page) { async getProjects({ baseUrl, filters, page, projectSlug, myaccount, text }) {
let url = `${baseUrl}v2/projects/`;
if (projectSlug) {
url += `${projectSlug}/`;
}
url += `?page=${page}`;
if (myaccount) {
url += '&myaccount=true';
}
// Append search text if provided.
if (text) {
url += `&search=${encodeURIComponent(text)}`;
}
try { try {
const url = `${baseUrl}projects/?page=${page}`;
let filteredUrl;
if (Object.values(filters).some(el => el && el.length > 0)) { if (Object.values(filters).some(el => el && el.length > 0)) {
filteredUrl = url;
for (const filter in filters) { for (const filter in filters) {
if (filters[filter]) { if (filters[filter]) {
filteredUrl = filteredUrl.concat('', `&${filter}=${filters[filter]}`); url = url.concat('', `&${filter}=${filters[filter]}`);
} }
} }
} }
const response = await axios.get(url);
const response = await axios.get(filteredUrl ? filteredUrl : url);
if (response.status === 200 && response.data) { if (response.status === 200 && response.data) {
return response.data; return response.data;
} }
...@@ -69,9 +76,9 @@ const projectAPI = { ...@@ -69,9 +76,9 @@ const projectAPI = {
} }
}, },
async getProjectTypes( baseUrl ) { async getProjectUsers( baseUrl, projectSlug) {
const response = await axios.get( const response = await axios.get(
`${baseUrl}project-types/` `${baseUrl}projects/${projectSlug}/utilisateurs/`
); );
if ( if (
response.status === 200 && response.status === 200 &&
...@@ -83,9 +90,23 @@ const projectAPI = { ...@@ -83,9 +90,23 @@ const projectAPI = {
} }
}, },
async getProjectTypes( baseUrl ) {
const response = await axios.get(
`${baseUrl}v2/projects/?is_project_type=true`
);
if (
response.status === 200 &&
response.data
) {
return response.data.results;
} else {
return null;
}
},
async deleteProject(baseUrl, projectSlug) { async deleteProject(baseUrl, projectSlug) {
const response = await axios.delete( const response = await axios.delete(
`${baseUrl}projects/${projectSlug}/` `${baseUrl}v2/projects/${projectSlug}/`
); );
if ( response.status === 204 ) { if ( response.status === 204 ) {
return 'success'; return 'success';
......
src/services/user-api.js 0 → 100644
View file @ ee17a921
import axios from '@/axios-client.js';
import store from '../store';
const baseUrl = store.state.configuration.VUE_APP_DJANGO_API_BASE;
const userAPI = {
async signup(data, url) {
try {
const response = await axios.post(url || `${baseUrl}v2/users/`, data);
return response; // Retourne directement la réponse si succès
} catch (err) {
console.error('Erreur lors de l\'inscription :', err.response || err);
return err.response || { status: 500, data: { detail: 'Erreur inconnue' } }; // 👈 Retourne la réponse d'erreur si disponible
}
},
};
export default userAPI;
src/store/index.js
View file @ ee17a921
...@@ -23,66 +23,76 @@ const noPermissions = { ...@@ -23,66 +23,76 @@ const noPermissions = {
export default new Vuex.Store({ export default new Vuex.Store({
modules, modules,
state: { state: {
logged: false, cancellableSearchRequest: [],
user: false,
configuration: null, configuration: null,
staticPages: null, isOnline: true,
USER_LEVEL_PROJECTS: null,
user_permissions: null,
levelsPermissions: [], levelsPermissions: [],
messages: [],
events: null,
loader: { loader: {
isLoading: false, isLoading: false,
message: 'En cours de chargement' message: 'En cours de chargement'
}, },
cancellableSearchRequest: [], logged: false,
reloadIntervalId: null messageCount: 0,
messages: [],
projectAttributes: [],
reloadIntervalId: null,
staticPages: null,
user: false,
usersGroups: [],
USER_LEVEL_PROJECTS: null,
user_permissions: null,
userToken: null
}, },
mutations: { mutations: {
SET_IS_ONLINE(state, payload) {
state.isOnline = payload;
},
SET_USER(state, payload) { SET_USER(state, payload) {
state.user = payload; state.user = payload;
}, },
SET_CONFIG(state, payload) { SET_CONFIG(state, payload) {
state.configuration = payload; state.configuration = payload;
}, },
SET_USERS(state, payload) {
state.users = payload;
},
SET_COOKIE(state, cookie) {
state.cookie = cookie;
},
SET_STATIC_PAGES(state, staticPages) { SET_STATIC_PAGES(state, staticPages) {
state.staticPages = staticPages; state.staticPages = staticPages;
}, },
SET_USERS_GROUPS(state, usersGroups) {
state.usersGroups = usersGroups;
},
SET_USER_LEVEL_PROJECTS(state, USER_LEVEL_PROJECTS) { SET_USER_LEVEL_PROJECTS(state, USER_LEVEL_PROJECTS) {
state.USER_LEVEL_PROJECTS = USER_LEVEL_PROJECTS; state.USER_LEVEL_PROJECTS = USER_LEVEL_PROJECTS;
}, },
SET_LOGGED(state, value) { SET_LOGGED(state, value) {
state.logged = value; state.logged = value;
}, },
SET_USER_TOKEN(state, payload) {
state.userToken = payload;
},
SET_USER_PERMISSIONS(state, userPermissions) { SET_USER_PERMISSIONS(state, userPermissions) {
state.user_permissions = userPermissions; state.user_permissions = userPermissions;
}, },
SET_LEVELS_PERMISSIONS(state, levelsPermissions) { SET_LEVELS_PERMISSIONS(state, levelsPermissions) {
state.levelsPermissions = levelsPermissions; state.levelsPermissions = levelsPermissions;
}, },
SET_EVENTS(state, events) { SET_PROJECT_ATTRIBUTES(state, userPermissions) {
state.events = events; state.projectAttributes = userPermissions;
}, },
DISPLAY_MESSAGE(state, message) { DISPLAY_MESSAGE(state, message) {
state.messages = [message, ...state.messages]; message['counter'] = state.messageCount;
if (document.getElementById('content')) document.getElementById('content').scrollIntoView({ block: 'start', inline: 'nearest' }); state.messageCount += 1;
state.messages = [message, ...state.messages]; // add new message at the beginning of the list
if (document.getElementById('scroll-top-anchor')) {
document.getElementById('scroll-top-anchor').scrollIntoView({ block: 'start', inline: 'nearest' });
}
setTimeout(() => { setTimeout(() => {
state.messages = []; state.messages = state.messages.slice(0, -1); // remove one message from the end of the list
}, 3000); }, 3000);
}, },
DISCARD_MESSAGE(state, message) { DISCARD_MESSAGE(state, messageCount) {
state.messages = state.messages.filter((el) => el.comment !== message.comment); state.messages = state.messages.filter((mess) => mess.counter !== messageCount);
}, },
CLEAR_MESSAGES(state) { CLEAR_MESSAGES(state) {
state.messages = []; state.messages = [];
...@@ -103,6 +113,10 @@ export default new Vuex.Store({ ...@@ -103,6 +113,10 @@ export default new Vuex.Store({
RESET_CANCELLABLE_SEARCH_REQUEST(state) { RESET_CANCELLABLE_SEARCH_REQUEST(state) {
state.cancellableSearchRequest = []; state.cancellableSearchRequest = [];
}, },
REMOVE_LAST_CANCELLABLE_SEARCH_REQUEST(state) {
const updatedCancellableSearchRequest = state.cancellableSearchRequest.slice(0, -1);
state.cancellableSearchRequest = updatedCancellableSearchRequest;
},
SET_RELOAD_INTERVAL_ID(state, payload) { SET_RELOAD_INTERVAL_ID(state, payload) {
state.reloadIntervalId = payload; state.reloadIntervalId = payload;
...@@ -110,13 +124,18 @@ export default new Vuex.Store({ ...@@ -110,13 +124,18 @@ export default new Vuex.Store({
CLEAR_RELOAD_INTERVAL_ID(state) { CLEAR_RELOAD_INTERVAL_ID(state) {
clearInterval(state.reloadIntervalId); clearInterval(state.reloadIntervalId);
state.reloadIntervalId = null; state.reloadIntervalId = null;
} },
}, },
getters: { getters: {
permissions: state => state.user_permissions && state.projects.project ? permissions: state => state.user_permissions && state.projects.project ?
state.user_permissions[state.projects.project.slug] : state.user_permissions[state.projects.project.slug] : noPermissions,
noPermissions usersGroupsOptions: state => state.usersGroups.map((group) => ({
name: group.display_name,
value: group.codename,
isGlobal: group.is_global,
})),
usersGroupsFeatureOptions: (state, getters) => getters.usersGroupsOptions.filter((group) => !group.isGlobal)
}, },
actions: { actions: {
...@@ -138,15 +157,8 @@ export default new Vuex.Store({ ...@@ -138,15 +157,8 @@ export default new Vuex.Store({
}) })
.then((response) => { .then((response) => {
if (response.status === 200 && response.data) { if (response.status === 200 && response.data) {
// * use stored previous route to go back after login if page not open on login at first
let routerHistory = '';
if (router.options.routerHistory[0] !== undefined) {
routerHistory = router.options.routerHistory[0].name !== 'login' ? router.options.routerHistory : '/';
} else {
routerHistory = '/';
}
commit('SET_USER', response.data.user); commit('SET_USER', response.data.user);
router.push(routerHistory[routerHistory.length - 1] || '/'); dispatch('REDIRECT_AFTER_LOGIN');
dispatch('GET_USER_LEVEL_PROJECTS'); dispatch('GET_USER_LEVEL_PROJECTS');
dispatch('GET_USER_LEVEL_PERMISSIONS'); dispatch('GET_USER_LEVEL_PERMISSIONS');
return response.status; return response.status;
...@@ -159,57 +171,156 @@ export default new Vuex.Store({ ...@@ -159,57 +171,156 @@ export default new Vuex.Store({
} }
}, },
USER_INFO({ state, commit }) { REDIRECT_AFTER_LOGIN() {
if (!state.user) { // * use stored previous route to go back after login if page not open on login at first
axios let routerHistory = '';
.get(`${this.state.configuration.VUE_APP_DJANGO_API_BASE}user_info/`) if (router.options.routerHistory[0] !== undefined) {
routerHistory = router.options.routerHistory[0].name !== 'login' ? router.options.routerHistory : '/';
} else {
routerHistory = '/';
}
const slug = router.history.current.params.slug;
if (slug) {
router.push({ name: 'project_detail', params: { slug } }).catch(() => { // prevent redundant navigation error
console.error('Not critic: caught error from vue-router -> redundant navigation to same url.');
});
} else { //* not working at page load, routerHistory filled afterwards, could try history.back()
router.push(routerHistory[routerHistory.length - 1] || '/').catch(() => { // prevent redundant navigation error
console.error('Not critic: caught error from vue-router -> redundant navigation to same url.');
});
}
},
/**
* Action to retrieve user information.
* - If a token is present in the URL, it indicates a Single Sign-On (SSO) attempt,
* in which case it logs out the user (if logged in) and connects via SSO with the token.
* - Otherwise, it fetches user information from the Django API endpoint:
* - If no user is logged in AND if the login should be done through SSO with a redirect,
* it navigates to the login platform. Afterward, the user will be redirected with the token and the original URL to open in Geocontrib.
* - Else if the response contains a login_url (to connect with OGS), the user is redirected to this url which will redirect the user
* to geocontrib after login, which will check again if the OGS session is activated
* - Otherwise, it displays a message that the user is not logged in but can still access the app as an anonymous user.
* A 'next' parameter is added to transfer to the OGS login page for redirection.
*/
async GET_USER_INFO({ state, commit, dispatch }) {
// Extract token from URL query parameters
const searchParams = new URLSearchParams(window.location.search);
const token = searchParams.get('token');
const url_redirect = searchParams.get('url_redirect');
const currentUrl = window.location.href;
// Check if token exists and SSO login URL is configured
if (token && state.configuration.VUE_APP_LOGIN_URL) {
// If user was previously connected through SSO, ensure they are logged out before reconnecting through SSO, in case user changed
await dispatch('LOGOUT');
dispatch('CONNECT_SSO_WITH_TOKEN', { token, url_redirect });
} else if (!state.user) {
// If user infos are not set, try to fetch them
return axios
.get(`${state.configuration.VUE_APP_DJANGO_API_BASE}user_info/`)
.then((response) => { .then((response) => {
// Update the user state with received user data
if (response && response.status === 200) { if (response && response.status === 200) {
const user = response.data.user; const user = response.data.user;
commit('SET_USER', user); commit('SET_USER', user);
// Fetch user related data
dispatch('GET_USER_LEVEL_PERMISSIONS');
dispatch('GET_USER_LEVEL_PROJECTS');
dispatch('projects/GET_PROJECTS');
return;
} }
}) })
.catch(() => { .catch(() => {
//* if an url to redirect to an external authentification system is present, do not redirect to the login page // If the instance is set to accept login with redirection
if (!state.configuration.VUE_APP_LOGIN_URL) { if (state.configuration.VUE_APP_SSO_LOGIN_URL_WITH_REDIRECT) {
router.push({ name: 'login' }); commit('DISPLAY_MESSAGE', {
comment: 'Vous allez être redirigé vers la plateforme de connexion.'
});
// Call the SSO login plateform with url to redirect after login
window.open(`${state.configuration.VUE_APP_SSO_LOGIN_URL_WITH_REDIRECT}/?url_redirect=${encodeURIComponent(currentUrl)}`, '_self');
} }
// If the user is not logged in, display an info message
commit('DISPLAY_MESSAGE', {
comment: `Vous n'êtes pas connecté actuellement.
Vous pouvez accéder à l'application en tant qu'utilisateur anonyme`
});
return;
}); });
} }
}, },
/**
USER_EVENTS({ commit }) { * Action to connect user through SSO with a token.
return new Promise((resolve, reject) => { * If the app was opened with a token in the url, it attempts a login,
axios * if the login is succesfull, it set the user in the state
.get(`${this.state.configuration.VUE_APP_DJANGO_API_BASE}events/`) * and retrieve information that would have been retrieved in GET_USER_INFO when logged.
.then((response) => { * If the url contained a url to redirect, it calls the router to open this page.
if (response && response.status === 200) { */
const events = response.data; async CONNECT_SSO_WITH_TOKEN({ state, commit, dispatch }, { token, url_redirect }) {
commit('SET_EVENTS', events); axios
resolve(response.data); .get(`${state.configuration.VUE_APP_DJANGO_API_BASE}login-token/?token=${token}`)
.then((response) => {
if (response && (response.status === 200 || response.status === 201)) {
const user = response.data;
commit('SET_USER', user);
dispatch('GET_USER_LEVEL_PROJECTS');
dispatch('GET_USER_LEVEL_PERMISSIONS');
commit('DISPLAY_MESSAGE', {
comment: `Vous êtes maintenant connecté ${user.first_name} ${user.last_name}`,
level: 'positive'
});
dispatch('projects/GET_PROJECTS');
if (url_redirect) {
// Prepare the url to redirect with vue-router that prefix the url with DOMAIN+BASE_URL
const substringToRemove = state.configuration.BASE_URL;
// Find the index of the string to remove
const index = url_redirect.indexOf(substringToRemove);
// If found, keep only the remaining part after the substring to remove
if (index !== -1) {
url_redirect = url_redirect.substring(index + substringToRemove.length);
}
// catch error from the router, because of second redirection to feature when call with a feature's id
router.push(url_redirect).catch((e) => e);
} }
}) }
.catch(() => { })
reject('Error'); .catch((err) => {
console.error(err);
commit('DISPLAY_MESSAGE', {
comment: 'La connexion a échoué.',
level: 'negative'
}); });
}); });
}, },
LOGOUT({ commit, dispatch }) { async GET_USER_TOKEN({ state, commit }) {
axios const response = await axios.get(`${state.configuration.VUE_APP_DJANGO_API_BASE}get-token`);
.get(`${this.state.configuration.VUE_APP_DJANGO_API_BASE}logout/`) if (
response.status === 200 &&
response.data
) {
commit('SET_USER_TOKEN', response.data);
}
},
LOGOUT({ state, commit, dispatch }) {
return axios
.get(`${state.configuration.VUE_APP_DJANGO_API_BASE}logout/`)
.then((response) => { .then((response) => {
if (response && response.status === 200) { if (response && response.status === 200) {
commit('SET_USER', false); commit('SET_USER', false);
commit('SET_USER_LEVEL_PROJECTS', null); commit('SET_USER_LEVEL_PROJECTS', null);
dispatch('GET_USER_LEVEL_PERMISSIONS'); dispatch('GET_USER_LEVEL_PERMISSIONS');
if (router.history.current.name !== 'index' && !window.location.pathname.includes('projet-partage')) { if (router.history.current.name !== 'index' &&
!window.location.pathname.includes('projet-partage') &&
!state.configuration.VUE_APP_LOGIN_URL
) {
router.push('/'); router.push('/');
} }
} }
}) })
.catch((error) => { .catch((error) => {
throw error; console.error(error);
}); });
}, },
...@@ -226,6 +337,19 @@ export default new Vuex.Store({ ...@@ -226,6 +337,19 @@ export default new Vuex.Store({
}); });
}, },
GET_USERS_GROUPS({ commit }) {
return axios
.get(`${this.state.configuration.VUE_APP_DJANGO_API_BASE}users-groups/`)
.then((response) => {
if (response && response.status === 200) {
commit('SET_USERS_GROUPS', response.data);
}
})
.catch((error) => {
throw error;
});
},
GET_USER_LEVEL_PROJECTS({ commit }) { GET_USER_LEVEL_PROJECTS({ commit }) {
return axios return axios
.get(`${this.state.configuration.VUE_APP_DJANGO_API_BASE}user-level-projects/`) .get(`${this.state.configuration.VUE_APP_DJANGO_API_BASE}user-level-projects/`)
...@@ -253,7 +377,7 @@ export default new Vuex.Store({ ...@@ -253,7 +377,7 @@ export default new Vuex.Store({
}, },
GET_LEVELS_PERMISSIONS({ commit }) { GET_LEVELS_PERMISSIONS({ commit }) {
return axios return axios
.get(`${this.state.configuration.VUE_APP_DJANGO_API_BASE}levels-permissions/`) .get(`${this.state.configuration.VUE_APP_DJANGO_API_BASE}v2/levels-permissions/`)
.then((response) => { .then((response) => {
if (response && response.status === 200) { if (response && response.status === 200) {
commit('SET_LEVELS_PERMISSIONS', response.data); commit('SET_LEVELS_PERMISSIONS', response.data);
...@@ -263,6 +387,26 @@ export default new Vuex.Store({ ...@@ -263,6 +387,26 @@ export default new Vuex.Store({
throw error; throw error;
}); });
}, },
GET_PROJECT_ATTRIBUTES({ commit }) {
return axios
.get(`${this.state.configuration.VUE_APP_DJANGO_API_BASE}project-attributes/`)
.then((response) => {
if (response && response.status === 200) {
commit('SET_PROJECT_ATTRIBUTES', response.data);
}
})
.catch((error) => {
throw error;
});
},
CANCEL_CURRENT_SEARCH_REQUEST({ state, commit }) {
if (state.cancellableSearchRequest.length > 0) {
const currentRequestCancelToken =
state.cancellableSearchRequest[state.cancellableSearchRequest.length - 1];
currentRequestCancelToken.cancel('Current search request was canceled');
commit('REMOVE_LAST_CANCELLABLE_SEARCH_REQUEST');
}
},
} }
}); });
src/store/modules/feature_type.store.js → src/store/modules/feature-type.store.js
View file @ ee17a921
import axios from '@/axios-client.js'; import axios from '@/axios-client.js';
import Vue from 'vue';
const getColorsStyles = (customForms) => customForms const getColorsStyles = (customForms) => customForms
.filter(customForm => customForm.options && customForm.options.length) .filter(customForm => customForm.options && customForm.options.length)
...@@ -8,18 +9,20 @@ const getColorsStyles = (customForms) => customForms ...@@ -8,18 +9,20 @@ const getColorsStyles = (customForms) => customForms
}); });
const pending2draftFeatures = (features) => { const pending2draftFeatures = (features) => {
let result = []; for (const el of features) {
for (let el of features) { if (el.properties && el.properties.status === 'pending') {
if (el.properties.status === 'pending') {
el.properties.status = 'draft'; el.properties.status = 'draft';
} else if (el.status === 'pending') {
el.status = 'draft';
} }
result.push(el);
} }
return result; return features;
}; };
const feature_type = { const feature_type = {
namespaced: true, namespaced: true,
state: { state: {
form: null, form: null,
colorsStyleList: [], colorsStyleList: [],
...@@ -28,6 +31,14 @@ const feature_type = { ...@@ -28,6 +31,14 @@ const feature_type = {
feature_types: [], feature_types: [],
fileToImport: null, fileToImport: null,
importFeatureTypeData: [], importFeatureTypeData: [],
preRecordedLists: [],
selectedPrerecordedListValues: {}
},
getters: {
feature_type: state => state.feature_types.find(
(el) => el.slug === state.current_feature_type_slug
),
}, },
mutations: { mutations: {
...@@ -75,19 +86,21 @@ const feature_type = { ...@@ -75,19 +86,21 @@ const feature_type = {
SET_FILE_TO_IMPORT(state, payload) { SET_FILE_TO_IMPORT(state, payload) {
state.fileToImport = payload; state.fileToImport = payload;
}, },
SET_PRERECORDED_LISTS(state, payload) {
state.preRecordedLists = payload;
},
SET_SELECTED_PRERECORDED_LIST_VALUES(state, { name, values }) {
Vue.set(state.selectedPrerecordedListValues, name, values.slice(0, 10).map(el => { return { label: el };}));
}
}, },
getters: {
feature_type: state => state.feature_types.find(
(el) => el.slug === state.current_feature_type_slug
),
},
actions: { actions: {
GET_PROJECT_FEATURE_TYPES({ commit }, project_slug) { GET_PROJECT_FEATURE_TYPES({ commit }, project_slug) {
return axios return axios
.get(`${this.state.configuration.VUE_APP_DJANGO_API_BASE}projects/${project_slug}/feature-types/`) .get(`${this.state.configuration.VUE_APP_DJANGO_API_BASE}v2/feature-types/?project__slug=${project_slug}`)
.then((response) => { .then((response) => {
if (response.status === 200 && response.data) { if (response.status === 200 && response.data) {
commit('SET_FEATURE_TYPES', response.data.feature_types); commit('SET_FEATURE_TYPES', response.data);
return response; return response;
} }
}) })
...@@ -96,63 +109,75 @@ const feature_type = { ...@@ -96,63 +109,75 @@ const feature_type = {
}); });
}, },
async GET_PRERECORDED_LISTS({ commit }) {
try {
const response = await axios.get(
`${this.state.configuration.VUE_APP_DJANGO_API_BASE}prerecorded-list-values/`
);
if (response.status === 200) {
commit('SET_PRERECORDED_LISTS', response.data.map(el => el.name));
}
} catch (err) {
console.error(err);
}
},
async GET_SELECTED_PRERECORDED_LIST_VALUES({ commit }, { name, pattern }) {
try {
let url = `${this.state.configuration.VUE_APP_DJANGO_API_BASE}prerecorded-list-values/${name}/`;
if (pattern) {
url += `?pattern=${pattern}`;
}
const response = await axios.get(url);
if (response.status === 200) {
commit('SET_SELECTED_PRERECORDED_LIST_VALUES', {
name,
values: response.data
});
}
} catch (err) {
console.error(err);
}
return;
},
async SEND_FEATURE_TYPE({ state, getters, rootState }, requestType) { async SEND_FEATURE_TYPE({ state, getters, rootState }, requestType) {
const data = { const data = {
title: state.form.title.value, title: state.form.title.value,
title_optional: state.form.title_optional.value, title_optional: state.form.title_optional.value,
enable_key_doc_notif: state.form.enable_key_doc_notif.value,
disable_notification: state.form.disable_notification.value,
geom_type: state.form.geom_type.value, geom_type: state.form.geom_type.value,
color: state.form.color.value, color: state.form.color.value,
colors_style: state.form.colors_style.value, colors_style: state.form.colors_style.value,
project: rootState.projects.project.slug, project: rootState.projects.project.slug,
customfield_set: state.customForms.map(el => { customfield_set: state.customForms
return {
position: el.position,
label: el.label,
name: el.name,
field_type: el.field_type,
options: el.options,
};
}),
//'is_editable': true,
}; };
if (requestType === 'post') { let url = `${this.state.configuration.VUE_APP_DJANGO_API_BASE}v2/feature-types/`;
return axios if (requestType === 'put') url += `${getters.feature_type.slug}/`;
.post(`${this.state.configuration.VUE_APP_DJANGO_API_BASE}feature-types/`, data) return axios({
.then((response) => { url,
if (response) { method: requestType,
const feature_type_slug = response.data.slug; data,
const status = response.status; }).then((response) => {
return { feature_type_slug, status }; if (response) {
} const feature_type_slug = response.data.slug;
}) const status = response.status;
.catch((error) => { return { feature_type_slug, status };
throw (error); }
}); })
} else if (requestType === 'put') { .catch((error) => error.response);
return axios
.put(`${this.state.configuration.VUE_APP_DJANGO_API_BASE}feature-types/${getters.feature_type.slug}/`, data)
.then((response) => {
if (response) {
const feature_type_slug = response.data.slug;
const status = response.status;
return { feature_type_slug, status };
}
})
.catch((error) => {
throw (error);
});
}
}, },
async SEND_FEATURE_SYMBOLOGY({ getters, rootState }, symbology) { async SEND_FEATURE_DISPLAY_CONFIG({ getters, rootState }, displayConfig) {
const data = { const data = {
title: getters.feature_type.title, title: getters.feature_type.title,
project: rootState.projects.project.slug, project: rootState.projects.project.slug,
...symbology ...displayConfig
}; };
return axios return axios
.put(`${this.state.configuration.VUE_APP_DJANGO_API_BASE}feature-types/${getters.feature_type.slug}/`, data) .put(`${this.state.configuration.VUE_APP_DJANGO_API_BASE}v2/feature-types/${getters.feature_type.slug}/`, data)
.then((response) => { .then((response) => {
if (response) { if (response) {
const feature_type_slug = response.data.slug; const feature_type_slug = response.data.slug;
...@@ -168,29 +193,62 @@ const feature_type = { ...@@ -168,29 +193,62 @@ const feature_type = {
async SEND_FEATURES_FROM_GEOJSON({ state, dispatch, rootState }, payload) { async SEND_FEATURES_FROM_GEOJSON({ state, dispatch, rootState }, payload) {
let { feature_type_slug, geojson } = payload; let { feature_type_slug, geojson } = payload;
//* check if geojson then build a file //* check if geojson then build a file
if(!geojson && !state.fileToImport && state.fileToImport.size === 0 ) return; if(!geojson && !state.fileToImport && state.fileToImport.size === 0 ) {
let formData = new FormData(); return;
let fileToImport; }
const formData = new FormData();
let { name, type } = geojson || state.fileToImport; let { name, type } = geojson || state.fileToImport;
if (!name && state.fileToImport) name = state.fileToImport.name; if (!name && state.fileToImport) {
name = state.fileToImport.name;
}
if (rootState.projects.project.moderation) { if (rootState.projects.project.moderation) {
if (state.fileToImport && state.fileToImport.size > 0) { //* if data in a binary file, read it as text if (state.fileToImport && state.fileToImport.size > 0) { //* if data in a binary file, read it as text
const textFile = await state.fileToImport.text(); const textFile = await state.fileToImport.text();
geojson = JSON.parse(textFile); geojson = JSON.parse(textFile);
} }
const unmoderatedFeatures = pending2draftFeatures(geojson.features); const unmoderatedFeatures = pending2draftFeatures(geojson.features || geojson);
geojson= { geojson = geojson.features ? {
type: 'FeatureCollection', features: unmoderatedFeatures type: 'FeatureCollection', features: unmoderatedFeatures
}; } : unmoderatedFeatures;
} }
fileToImport = new File([JSON.stringify(geojson)], name, { type }); const fileToImport = new File([JSON.stringify(geojson)], name, { type });
formData.append('json_file', geojson ? fileToImport : state.fileToImport); formData.append('json_file', geojson ? fileToImport : state.fileToImport);
formData.append('feature_type_slug', feature_type_slug); formData.append('feature_type_slug', feature_type_slug);
let url = const url =
this.state.configuration.VUE_APP_DJANGO_API_BASE + this.state.configuration.VUE_APP_DJANGO_API_BASE +
'import-tasks/'; 'v2/import-tasks/';
return axios
.post(url, formData, {
headers: {
'Content-Type': 'multipart/form-data',
},
})
.then((response) => {
if (response && response.status === 200) {
return dispatch('GET_IMPORTS', {
feature_type: feature_type_slug
});
}
return response;
})
.catch((error) => {
throw (error);
});
},
async SEND_FEATURES_FROM_CSV({ state, dispatch }, payload) {
const { feature_type_slug, csv } = payload;
if (!csv && !state.fileToImport && state.fileToImport.size === 0 ) {
return;
}
const formData = new FormData();
formData.append('csv_file', state.fileToImport);
formData.append('feature_type_slug', feature_type_slug);
const url = `${this.state.configuration.VUE_APP_DJANGO_API_BASE}v2/import-tasks/`;
return axios return axios
.post(url, formData, { .post(url, formData, {
headers: { headers: {
...@@ -210,8 +268,8 @@ const feature_type = { ...@@ -210,8 +268,8 @@ const feature_type = {
}); });
}, },
GET_IMPORTS({ commit }, { project_slug, feature_type }) { GET_IMPORTS({ state, commit, dispatch }, { project_slug, feature_type }) {
let url = `${this.state.configuration.VUE_APP_DJANGO_API_BASE}import-tasks/`; let url = `${this.state.configuration.VUE_APP_DJANGO_API_BASE}v2/import-tasks/`;
if (project_slug) { if (project_slug) {
url = url.concat('', `${url.includes('?') ? '&' : '?'}project_slug=${project_slug}`); url = url.concat('', `${url.includes('?') ? '&' : '?'}project_slug=${project_slug}`);
} }
...@@ -222,6 +280,31 @@ const feature_type = { ...@@ -222,6 +280,31 @@ const feature_type = {
.get(url) .get(url)
.then((response) => { .then((response) => {
if (response) { if (response) {
const diffStatus = [];
if (state.importFeatureTypeData) {
for (const data of response.data) {
const index =
state.importFeatureTypeData
.findIndex(el => el.geojson_file_name === data.geojson_file_name);
if (index !== -1 && state.importFeatureTypeData[index].status !== data.status && data.status === 'finished') {
diffStatus.push(data);
}
}
}
if (diffStatus.length > 0 && project_slug && feature_type) {
try {
dispatch(
'feature/GET_PROJECT_FEATURES',
{
project_slug: project_slug,
feature_type__slug: feature_type,
},
{ root: true }
);
} catch (err) {
console.error(err);
}
}
commit('SET_IMPORT_FEATURE_TYPES_DATA', response.data); commit('SET_IMPORT_FEATURE_TYPES_DATA', response.data);
} }
return response; return response;
...@@ -233,4 +316,4 @@ const feature_type = { ...@@ -233,4 +316,4 @@ const feature_type = {
} }
}; };
export default feature_type; export default feature_type;
\ No newline at end of file
src/store/modules/feature.store.js
View file @ ee17a921
import axios from '@/axios-client.js'; import axios from '@/axios-client.js';
import router from '../../router'; import router from '../../router';
import { objIsEmpty, findXformValue, activateFieldsNforceValues } from'@/utils';
const feature = { const feature = {
namespaced: true, namespaced: true,
...@@ -8,31 +8,15 @@ const feature = { ...@@ -8,31 +8,15 @@ const feature = {
attachmentFormset: [], attachmentFormset: [],
attachmentsToDelete: [], attachmentsToDelete: [],
checkedFeatures: [], checkedFeatures: [],
extra_form: [], clickedFeatures: [],
extra_forms: [],
features: [], features: [],
features_count: 0, features_count: 0,
current_feature: [], currentFeature: null,
form: null, form: null,
linkedFormset: [], linkedFormset: [], //* used to edit in feature_edit
linked_features: [], linked_features: [], //* used to display in feature_detail
statusChoices: [ massMode: 'edit-status',
{
name: 'Brouillon',
value: 'draft',
},
{
name: 'En attente de publication',
value: 'pending',
},
{
name: 'Publié',
value: 'published',
},
{
name: 'Archivé',
value: 'archived',
},
],
}, },
mutations: { mutations: {
SET_FEATURES(state, features) { SET_FEATURES(state, features) {
...@@ -44,29 +28,44 @@ const feature = { ...@@ -44,29 +28,44 @@ const feature = {
state.features_count = features_count; state.features_count = features_count;
}, },
SET_CURRENT_FEATURE(state, feature) { SET_CURRENT_FEATURE(state, feature) {
state.current_feature = feature; state.currentFeature = feature;
}, },
UPDATE_FORM(state, payload) { UPDATE_FORM(state, payload) {
state.form = payload; state.form = payload;
}, },
UPDATE_EXTRA_FORM(state, extra_form) { INIT_FORM(state) {
const index = state.extra_form.findIndex(el => el.label === extra_form.label); state.form = {
if (index !== -1) { title: state.currentFeature.properties.title,
state.extra_form[index] = extra_form; description: { value: state.currentFeature.properties.description },
status: { value: state.currentFeature.properties.status },
assigned_member: { value: state.currentFeature.properties.assigned_member },
};
},
UPDATE_FORM_FIELD(state, field) {
if (state.form[field.name].value !== undefined) {
state.form[field.name].value = field.value;
} else {
state.form[field.name] = field.value;
} }
}, },
SET_EXTRA_FORM(state, extra_form) { UPDATE_EXTRA_FORM(state, extra_form) {
state.extra_form = extra_form; const updatedExtraForms = state.extra_forms.map((field) => field.name === extra_form.name ? extra_form : field);
state.extra_forms = activateFieldsNforceValues(updatedExtraForms);
},
SET_EXTRA_FORMS(state, extra_forms) {
state.extra_forms = extra_forms;
}, },
CLEAR_EXTRA_FORM(state) { CLEAR_EXTRA_FORM(state) {
state.extra_form = []; state.extra_forms = [];
}, },
ADD_ATTACHMENT_FORM(state, attachmentFormset) { ADD_ATTACHMENT_FORM(state, attachmentFormset) {
state.attachmentFormset = [...state.attachmentFormset, attachmentFormset]; state.attachmentFormset = [...state.attachmentFormset, attachmentFormset];
}, },
UPDATE_ATTACHMENT_FORM(state, payload) { UPDATE_ATTACHMENT_FORM(state, payload) {
const index = state.attachmentFormset.findIndex((el) => el.dataKey === payload.dataKey); const index = state.attachmentFormset.findIndex((el) => el.dataKey === payload.dataKey);
if (index !== -1) state.attachmentFormset[index] = payload; if (index !== -1) {
state.attachmentFormset[index] = payload;
}
}, },
REMOVE_ATTACHMENT_FORM(state, payload) { REMOVE_ATTACHMENT_FORM(state, payload) {
state.attachmentFormset = state.attachmentFormset.filter(form => form.dataKey !== payload); state.attachmentFormset = state.attachmentFormset.filter(form => form.dataKey !== payload);
...@@ -79,7 +78,9 @@ const feature = { ...@@ -79,7 +78,9 @@ const feature = {
}, },
UPDATE_LINKED_FORM(state, payload) { UPDATE_LINKED_FORM(state, payload) {
const index = state.linkedFormset.findIndex((el) => el.dataKey === payload.dataKey); const index = state.linkedFormset.findIndex((el) => el.dataKey === payload.dataKey);
if (index !== -1) state.linkedFormset[index] = payload; if (index !== -1) {
state.linkedFormset[index] = payload;
}
}, },
REMOVE_LINKED_FORM(state, payload) { REMOVE_LINKED_FORM(state, payload) {
state.linkedFormset = state.linkedFormset.filter(form => form.dataKey !== payload); state.linkedFormset = state.linkedFormset.filter(form => form.dataKey !== payload);
...@@ -100,30 +101,30 @@ const feature = { ...@@ -100,30 +101,30 @@ const feature = {
}, },
UPDATE_CHECKED_FEATURES(state, checkedFeatures) { UPDATE_CHECKED_FEATURES(state, checkedFeatures) {
state.checkedFeatures = checkedFeatures; state.checkedFeatures = checkedFeatures;
} },
}, UPDATE_CLICKED_FEATURES(state, clickedFeatures) {
getters: { state.clickedFeatures = clickedFeatures;
},
TOGGLE_MASS_MODE(state, payload) {
state.massMode = payload;
},
}, },
actions: { actions: {
async GET_PROJECT_FEATURES({ commit, rootState }, { async GET_PROJECT_FEATURES({ commit, dispatch, rootState }, {
project_slug, project_slug,
feature_type__slug, feature_type__slug,
ordering, ordering,
search, search,
limit, limit,
geojson = false geojson = false
}) { }) {
if (rootState.cancellableSearchRequest.length > 0) { dispatch('CANCEL_CURRENT_SEARCH_REQUEST', null, { root: true });
const currentRequestCancelToken =
rootState.cancellableSearchRequest[rootState.cancellableSearchRequest.length - 1];
currentRequestCancelToken.cancel();
}
const cancelToken = axios.CancelToken.source(); const cancelToken = axios.CancelToken.source();
commit('SET_CANCELLABLE_SEARCH_REQUEST', cancelToken, { root: true }); commit('SET_CANCELLABLE_SEARCH_REQUEST', cancelToken, { root: true });
commit('SET_FEATURES', []); commit('SET_FEATURES', []);
commit('SET_FEATURES_COUNT', 0); commit('SET_FEATURES_COUNT', 0);
let url = `${rootState.configuration.VUE_APP_DJANGO_API_BASE}projects/${project_slug}/feature/`; let url = `${rootState.configuration.VUE_APP_DJANGO_API_BASE}v2/features/?project__slug=${project_slug}`;
if (feature_type__slug) { if (feature_type__slug) {
url = url.concat('', `${url.includes('?') ? '&' : '?'}feature_type__slug=${feature_type__slug}`); url = url.concat('', `${url.includes('?') ? '&' : '?'}feature_type__slug=${feature_type__slug}`);
} }
...@@ -136,7 +137,9 @@ const feature = { ...@@ -136,7 +137,9 @@ const feature = {
if (limit) { if (limit) {
url = url.concat('', `${url.includes('?') ? '&' : '?'}limit=${limit}`); url = url.concat('', `${url.includes('?') ? '&' : '?'}limit=${limit}`);
} }
if (geojson) url = url.concat('', '&output=geojson'); if (geojson) {
url = url.concat('', '&output=geojson');
}
try { try {
const response = await axios.get(url, { cancelToken: cancelToken.token }); const response = await axios.get(url, { cancelToken: cancelToken.token });
...@@ -148,144 +151,213 @@ const feature = { ...@@ -148,144 +151,213 @@ const feature = {
} }
return response; return response;
} catch (error) { } catch (error) {
console.error(error); if (error.message) {
return error; console.error(error);
}
throw error; // 'throw' instead of 'return', in order to pass inside the 'catch' error instead of 'then', to avoid initiating map in another component after navigation
} }
}, },
GET_PROJECT_FEATURE({ commit, rootState }, { project_slug, feature_id }) { GET_PROJECT_FEATURE({ commit, dispatch, rootState }, { project_slug, feature_id }) {
if (rootState.cancellableSearchRequest.length > 0) { dispatch('CANCEL_CURRENT_SEARCH_REQUEST', null, { root: true });
const currentRequestCancelToken =
rootState.cancellableSearchRequest[rootState.cancellableSearchRequest.length - 1];
currentRequestCancelToken.cancel();
}
const cancelToken = axios.CancelToken.source(); const cancelToken = axios.CancelToken.source();
commit('SET_CANCELLABLE_SEARCH_REQUEST', cancelToken, { root: true }); commit('SET_CANCELLABLE_SEARCH_REQUEST', cancelToken, { root: true });
commit('SET_CURRENT_FEATURE', null); const url = `${rootState.configuration.VUE_APP_DJANGO_API_BASE}v2/features/${feature_id}/?project__slug=${project_slug}`;
let url = `${rootState.configuration.VUE_APP_DJANGO_API_BASE}projects/${project_slug}/feature/?id=${feature_id}`;
return axios return axios
.get(url, { cancelToken: cancelToken.token }) .get(url, { cancelToken: cancelToken.token })
.then((response) => { .then((response) => {
if (response.status === 200 && response.data.features) { if (response.status === 200 && response.data) {
const feature = response.data.features[0]; commit('SET_CURRENT_FEATURE', response.data);
commit('SET_CURRENT_FEATURE', feature);
} }
return response; return response;
}) })
.catch((error) => { .catch((error) => {
console.error('Error while getting feature for id = ', feature_id, error);
throw error; throw error;
}); });
}, },
SEND_FEATURE({ state, rootState, commit, dispatch }, routeName) { /**
commit('DISPLAY_LOADER', 'Le signalement est en cours de création', { root: true }); * Handles the entire lifecycle of a feature submission, from sending data to handling additional forms
function redirect(featureId) { * and managing redirections based on the operation performed (create or update).
dispatch( * @param {Object} context - Vuex action context, including state and dispatch functions.
'GET_PROJECT_FEATURE', * @param {Object} payload - Contains parameters like routeName, query, and extraForms for form handling.
*/
SEND_FEATURE({ state, rootState, rootGetters, commit, dispatch }, { routeName, query, extraForms }) {
/**
* Handles redirection after a feature operation, updating URL queries or navigating to new routes.
* @param {string} featureName - The name of the feature being handled.
* @param {Object} response - The server response object.
* @return {Object} - Either the server response or a string to trigger page reload.
*/
function redirect(featureName, response) {
// when modifying more than 2 features, exit this function (to avoid conflict with next feature call to GET_PROJECT_FEATURE)
if (routeName === 'editer-attribut-signalement') return response;
let newQuery = { ...query }; // create a copy of query from the route to avoid redundant navigation error since the router object would be modified
// Display a success message in the UI.
commit(
'DISPLAY_MESSAGE',
{ {
project_slug: rootState.projects.project.slug, comment: routeName === 'ajouter-signalement' ?
feature_id: featureId 'Le signalement a été crée' :
`Le signalement ${featureName} a été mis à jour`,
level: 'positive'
},
{ root: true },
);
// Construct the query for navigation based on the current state and feature details.
const slug_type_signal = rootState['feature-type'].current_feature_type_slug;
const project = rootState.projects.project;
if (routeName === 'ajouter-signalement' && !query.ordering) {
newQuery = {
ordering: project.feature_browsing_default_sort,
offset: 0,// if feature was just created, in both ordering it would be the first in project features list
};
if (project.feature_browsing_default_filter === 'feature_type_slug') {
newQuery['feature_type_slug'] = slug_type_signal;
} }
) }
.then(() => { if (query && query.ordering === '-updated_on') { // if the list is ordered by update time
commit('DISCARD_LOADER', null, { root: true }); newQuery.offset = 0;// it would be in first position (else, if ordered by creation, the position won't change anyway)
router.push({ }
name: 'details-signalement', // in fast edition avoid redundant navigation if query didn't change
params: { if (routeName === 'details-signalement-filtre' && parseInt(query.offset) === parseInt(newQuery.offset)) {
slug_type_signal: rootState.feature_type.current_feature_type_slug, return 'reloadPage';
slug_signal: featureId, }
message: routeName === 'editer-signalement' ? 'Le signalement a été mis à jour' : 'Le signalement a été crée'
}, // Perform the actual route navigation if needed.
}); if (!objIsEmpty(newQuery)) {
dispatch('projects/GET_ALL_PROJECTS', null, { root:true }); //* & refresh project list router.push({
name: 'details-signalement-filtre',
params: { slug_type_signal },
query: newQuery,
});
} else {
router.push({
name: 'details-signalement',
params: { slug_type_signal },
}); });
}
return response;
} }
async function handleOtherForms(featureId) { /**
* Manages the uploading of attachments and linked features after the main feature submission.
* @param {number} featureId - The ID of the feature to which attachments and linked features relate.
* @param {string} featureName - The name of the feature for messaging purposes.
* @param {Object} response - The server response from the main feature submission.
* @return {Object} - Redirect response or a string to trigger page reload.
*/
async function handleOtherForms(featureId, featureName, response) {
await dispatch('SEND_ATTACHMENTS', featureId); await dispatch('SEND_ATTACHMENTS', featureId);
await dispatch('PUT_LINKED_FEATURES', featureId); await dispatch('PUT_LINKED_FEATURES', featureId);
redirect(featureId); return redirect(featureName, response);
} }
/**
* Prepares a GeoJSON object from the current state and extra forms provided in the payload.
* @return {Object} - A GeoJSON object representing the feature with additional properties.
*/
function createGeojson() { //* prepare feature data to send function createGeojson() { //* prepare feature data to send
let extraFormObject = {}; //* prepare an object to be flatten in properties of geojson const extraFormObject = {}; //* prepare an object to be flatten in properties of geojson
for (const field of state.extra_form) { // use extraForms from argument if defined, overiding data from the store, in order to not use mutation (in case of multiple features)
extraFormObject[field.name] = field.value; for (const field of extraForms || state.extra_forms) {
// send extra form only if there is a value defined or if no value, if there was a value before, in order to avoid sending empty value when user didn't touch the extraform
if (field.value !== null ||
(state.currentFeature.properties && state.currentFeature.properties[field.name])) {
extraFormObject[field.name] = field.value;
}
} }
return { let geojson = {
id: state.form.feature_id, id: state.form.feature_id || state.currentFeature.id,
type: 'Feature', type: 'Feature',
geometry: state.form.geometry,
properties: { properties: {
title: state.form.title, title: state.form.title,
description: state.form.description.value, description: state.form.description.value,
status: state.form.status.value, status: state.form.status.value.value || state.form.status.value,
project: rootState.projects.project.slug, project: rootState.projects.project.slug,
feature_type: rootState.feature_type.current_feature_type_slug, feature_type: rootState['feature-type'].current_feature_type_slug,
assigned_member: state.form.assigned_member.value,
...extraFormObject ...extraFormObject
} }
}; };
// if not in the case of a non geographical feature type, add geometry to geojson, else send without geometry
if (rootGetters['feature-type/feature_type'].geom_type !== 'none') {
geojson['geometry'] = state.form.geometry || state.form.geom ||
state.currentFeature.geometry || state.currentFeature.properties.geom;
}
return geojson;
} }
const geojson = createGeojson(); const geojson = createGeojson(); // Construct the GeoJSON from current state.
let url = `${rootState.configuration.VUE_APP_DJANGO_API_BASE}features/`; let url = `${rootState.configuration.VUE_APP_DJANGO_API_BASE}v2/features/`;
if (routeName === 'editer-signalement') { if (routeName !== 'ajouter-signalement') {
url += `${state.form.feature_id}/? url += `${geojson.id}/?
feature_type__slug=${rootState.feature_type.current_feature_type_slug} feature_type__slug=${rootState['feature-type'].current_feature_type_slug}
&project__slug=${rootState.projects.project.slug}`; &project__slug=${rootState.projects.project.slug}`;
} }
//* postOrPutFeature function from service featureAPI could be used here, but because configuration is in store,
//* projectBase would need to be sent with each function which imply to modify all function from this service,
//* which could create regression
return axios({ return axios({
url, url,
method: routeName === 'editer-signalement' ? 'PUT' : 'POST', method: routeName === 'ajouter-signalement' ? 'POST' : 'PUT',
data: geojson data: geojson
}).then((response) => { }).then((response) => {
if ((response.status === 200 || response.status === 201) && response.data) { if ((response.status === 200 || response.status === 201) && response.data) {
const featureId = response.data.id;
const featureName = response.data.properties.title;
// Handle additional forms if needed.
if (state.attachmentFormset.length > 0 || if (state.attachmentFormset.length > 0 ||
state.linkedFormset.length > 0 || state.linkedFormset.length > 0 ||
state.attachmentsToDelete.length > 0) { state.attachmentsToDelete.length > 0) {
handleOtherForms(response.data.id); return handleOtherForms(featureId, featureName, response);
} else { } else {
redirect(response.data.id); return redirect(featureName, response);
} }
} }
}) }).catch((error) => {
.catch((error) => { // If offline, store the edited feature in localeStorage to send them when back online
commit('DISCARD_LOADER', null, { root: true }); if (error.message === 'Network Error' || !rootState.isOnline) {
if (error.message === 'Network Error' || window.navigator.onLine === false) { let arraysOffline = [];
let arraysOffline = []; const localStorageArray = localStorage.getItem('geocontrib_offline');
let localStorageArray = localStorage.getItem('geocontrib_offline'); if (localStorageArray) {
if (localStorageArray) { arraysOffline = JSON.parse(localStorageArray);
arraysOffline = JSON.parse(localStorageArray);
}
let updateMsg = {
project: rootState.projects.project.slug,
type: routeName === 'editer-signalement' ? 'put' : 'post',
featureId: state.form.feature_id,
geojson: geojson
};
arraysOffline.push(updateMsg);
localStorage.setItem('geocontrib_offline', JSON.stringify(arraysOffline));
router.push({
name: 'offline-signalement',
params: {
slug_type_signal: rootState.feature_type.current_feature_type_slug
},
});
}
else {
console.error(error);
throw error;
} }
throw error; const updateMsg = {
}); project: rootState.projects.project.slug,
type: routeName === 'ajouter-signalement' ? 'post' : 'put',
featureId: geojson.id,
geojson: geojson
};
arraysOffline.push(updateMsg);
localStorage.setItem('geocontrib_offline', JSON.stringify(arraysOffline));
router.push({
name: 'offline-signalement',
params: {
slug_type_signal: rootState['feature-type'].current_feature_type_slug
},
});
} else {
console.error('Error while sending feature', error);
throw error; // Re-throw the error for further handling.
}
throw error; // Ensure any error is thrown to be handled by calling code.
});
}, },
async SEND_ATTACHMENTS({ state, rootState, dispatch }, featureId) { async SEND_ATTACHMENTS({ state, rootState, dispatch }, featureId) {
const DJANGO_API_BASE = rootState.configuration.VUE_APP_DJANGO_API_BASE; const DJANGO_API_BASE = rootState.configuration.VUE_APP_DJANGO_API_BASE;
function addFile(attachment, attchmtId) { /**
let formdata = new FormData(); * Adds a file to an existing attachment by uploading it to the server.
* @param {Object} attachment - The attachment object containing the file and other details.
* @param {number} attchmtId - The ID of the attachment to which the file is being added.
* @return {Promise<Object>} - The server's response to the file upload.
*/
function addFileToRequest(attachment, attchmtId) {
const formdata = new FormData();
formdata.append('file', attachment.fileToImport, attachment.fileToImport.name); formdata.append('file', attachment.fileToImport, attachment.fileToImport.name);
return axios return axios
.put(`${DJANGO_API_BASE}features/${featureId}/attachments/${attchmtId}/upload-file/`, formdata) .put(`${DJANGO_API_BASE}features/${featureId}/attachments/${attchmtId}/upload-file/`, formdata)
...@@ -298,10 +370,16 @@ const feature = { ...@@ -298,10 +370,16 @@ const feature = {
}); });
} }
/**
* Handles creating or updating an attachment, optionally uploading a file if included.
* @param {Object} attachment - The attachment data, including title, info, and optional file.
* @return {Promise<Object>} - The server response, either from creating/updating the attachment or from file upload.
*/
function putOrPostAttachement(attachment) { function putOrPostAttachement(attachment) {
let formdata = new FormData(); const formdata = new FormData();
formdata.append('title', attachment.title); formdata.append('title', attachment.title);
formdata.append('info', attachment.info); formdata.append('info', attachment.info);
formdata.append('is_key_document', attachment.is_key_document);
let url = `${DJANGO_API_BASE}features/${featureId}/attachments/`; let url = `${DJANGO_API_BASE}features/${featureId}/attachments/`;
if (attachment.id) { if (attachment.id) {
...@@ -314,18 +392,23 @@ const feature = { ...@@ -314,18 +392,23 @@ const feature = {
data: formdata data: formdata
}).then((response) => { }).then((response) => {
if (response && (response.status === 200 || response.status === 201) && attachment.fileToImport) { if (response && (response.status === 200 || response.status === 201) && attachment.fileToImport) {
return addFile(attachment, response.data.id); return addFileToRequest(attachment, response.data.id);
} }
return response; return response;
}) }).catch((error) => {
.catch((error) => { console.error(error);
console.error(error); return error;
return error; });
});
} }
/**
* Deletes attachments by dispatching a Vuex action.
* @param {number[]} attachmentsId - The IDs of the attachments to be deleted.
* @param {number} featureId - The ID of the feature related to the attachments.
* @return {Promise<Object>} - The server response to the deletion request.
*/
function deleteAttachement(attachmentsId, featureId) { function deleteAttachement(attachmentsId, featureId) {
let payload = { const payload = {
attachmentsId: attachmentsId, attachmentsId: attachmentsId,
featureId: featureId featureId: featureId
}; };
...@@ -336,15 +419,13 @@ const feature = { ...@@ -336,15 +419,13 @@ const feature = {
const promisesResult = await Promise.all([ const promisesResult = await Promise.all([
...state.attachmentFormset.map((attachment) => putOrPostAttachement(attachment)), ...state.attachmentFormset.map((attachment) => putOrPostAttachement(attachment)),
...state.attachmentsToDelete.map((attachmentsId) => deleteAttachement(attachmentsId, featureId)) ...state.attachmentsToDelete.map((attachmentsId) => deleteAttachement(attachmentsId, featureId))
] ]);
);
state.attachmentsToDelete = []; state.attachmentsToDelete = [];
return promisesResult; return promisesResult;
}, },
DELETE_ATTACHMENTS({ commit }, payload) { DELETE_ATTACHMENTS({ commit }, payload) {
let url = `${this.state.configuration.VUE_APP_DJANGO_API_BASE}features/${payload.featureId}/attachments/${payload.attachmentsId}/`; const url = `${this.state.configuration.VUE_APP_DJANGO_API_BASE}features/${payload.featureId}/attachments/${payload.attachmentsId}/`;
return axios return axios
.delete(url) .delete(url)
.then((response) => { .then((response) => {
...@@ -372,10 +453,13 @@ const feature = { ...@@ -372,10 +453,13 @@ const feature = {
}); });
}, },
DELETE_FEATURE({ rootState }, feature_id) { DELETE_FEATURE({ rootState }, payload) {
const url = `${rootState.configuration.VUE_APP_DJANGO_API_BASE}features/${feature_id}/?` + const { feature_id, noFeatureType } = payload;
`feature_type__slug=${rootState.feature_type.current_feature_type_slug}` + let url = `${rootState.configuration.VUE_APP_DJANGO_API_BASE}v2/features/${feature_id}/?` +
`&project__slug=${rootState.projects.project.slug}`; `project__slug=${rootState.projects.project.slug}`;
if (!noFeatureType) {
url +=`&feature_type__slug=${rootState['feature-type'].current_feature_type_slug}`;
}
return axios return axios
.delete(url) .delete(url)
.then((response) => response) .then((response) => response)
...@@ -383,8 +467,36 @@ const feature = { ...@@ -383,8 +467,36 @@ const feature = {
return false; return false;
}); });
}, },
}, /**
* Initializes extra forms based on the current feature type and its custom fields.
* This function retrieves custom fields for the current feature type, assigns values to them based on the current feature's properties,
* and commits them to the store to be displayed in the form.
*
* @param {Object} context - The Vuex action context, including state, rootGetters, and commit function.
*/
INIT_EXTRA_FORMS({ state, rootGetters, commit }) {
const feature = state.currentFeature; // Current feature being edited or viewed.
const featureType = rootGetters['feature-type/feature_type']; // Retrieves the feature type from root getters.
const customFields = featureType.customfield_set; // Custom fields defined for the feature type.
if (customFields) {
commit('SET_EXTRA_FORMS',
activateFieldsNforceValues( // A hypothetical function to activate fields and enforce their values.
customFields.map((field) => {
// Determines the initial value for the field
let value = feature.properties ? feature.properties[field.name] : findXformValue(feature, field);
// If the field is a boolean and the value is null, sets it to false
if (field.field_type === 'boolean' && value === null) {
value = false;
}
// Returns a new object with the updated value and the rest of the field's properties
return { ...field, value };
})
).sort((a, b) => a.position - b.position) // Sorts fields by their user-defined position.
);
}
},
},
}; };
export default feature; export default feature;