materio-d8/web/themes/custom/materiotheme/vuejs/store/modules/user.js

import { REST } from 'vuejs/api/rest-axios'
import { JSONAPI } from 'vuejs/api/json-axios'
import { MA } from 'vuejs/api/ma-axios'
import qs from 'querystring-es3'

export default {
  namespaced: true,

  // initial state
  state: {
    uid: null,
    // username: '',
    mail: '',
    csrf_token: null,
    logout_token: null,
    isloggedin: false,
    isAdmin: false,
    isAdherent: false,
    canSearch: false,
    roles: [],
    flagcolls: false,
    openedCollid: null
  },

  // getters
  getters: {},

  // mutations
  mutations: {
    SetCsrftoken (state, token) {
      console.log('SetCsrftoken', token)
      state.csrf_token = token
    },
    setToken (state, data) {
      state.uid = data.current_user.uid
      // state.username = data.username;
      state.mail = data.current_user.mail
      state.csrf_token = data.csrf_token
      state.isloggedin = true
      state.logout_token = data.logout_token
    },
    setUid (state, uid) {
      state.uid = uid
      state.isloggedin = true
    },
    setUser (state, data) {
      state.mail = data.mail[0].value
      state.uuid = data.uuid[0].value
    },
    setRoles (state, roles) {
      console.log('User setRoles', roles)
      state.roles = []
      for (let i = 0; i < roles.length; i++) {
        state.roles.push(roles[i].target_id)
      }
      // check if admin
      if (
        state.roles.indexOf('admin') !== -1 ||
        state.roles.indexOf('root') !== -1
      ) {
        // console.log('is admin');
        state.isAdmin = true
      }
      // check if has access to search
      if (state.roles.indexOf('adherent') !== -1) {
        // console.log('is admin');
        state.canSearch = true
        state.isAdherent = true
      }
    },
    setLoggedOut (state) {
      console.log('setLoggedOut state', state)
      state.uid = null
      state.mail = ''
      state.csrf_token = null
      state.isloggedin = false
      state.logout_token = null
      if (state.isAdmin) {
        // TODO: what if on a page where login is needed (as commerce checkout and cart)
        window.location.reload(true)
      }
      state.asAdmin = false
      state.canSearch = false
    },
    setFlagColls (state, flagcolls) {
      console.log('User setFlagColls', flagcolls)
      state.flagcolls = flagcolls
    },
    openFlagColl (state, collid) {
      state.openedCollid = collid
    },
    setLoadedCollItems (state, data) {
      console.log('setLoadedCollItems', data)
      state.flagcolls[data.collid].loadedItems = data.items
    }
  },

  // actions
  actions: {
    userRegister ({ dispatch, commit, state }, credentials) {
      return new Promise((resolve) => {
        REST.get('/session/token').then(({ token }) => {
          commit('SetCsrftoken', token)
          REST.post('/user/register?_format=json', credentials, {
            'X-CSRF-Token': state.csrftoken
          })
            .then(({ data }) => {
              console.log('user REST registered', data)
              dispatch('userLogin', credentials).then(() => {
                resolve()
              })
            })
            .catch(error => {
              console.warn('Issue with register', error)
              Promise.reject(error)
            })
        })
      })
    },
    userLogin ({ dispatch, state }, credentials) {
      return new Promise((resolve, reject) => {
        dispatch('getToken', credentials).then(() => {
          dispatch('getUser').then(userdata => {
            console.log('User Loggedin')
            if (state.isAdmin) {
              window.location.reload(true)
            }
            resolve()
          })
        })
      })
    },
    getToken ({ dispatch, commit, state }, credentials) {
      return REST.post('/user/login?_format=json', credentials)
        .then(({ data }) => {
          console.log('user REST getToken data', data)
          commit('setToken', data)
        })
        .catch(error => {
          console.warn('Issue with getToken', error)
          Promise.reject(error)
        })
    },
    getUser ({ dispatch, commit, state }) {
      return new Promise((resolve, reject) => {
        REST.get('/session/token').then(({ data }) => {
          console.log('csrftoken', data)
          commit('SetCsrftoken', data)
          console.log('state.csrf_token', state.csrf_token)
          const params = {
            token: state.csrf_token
          }
          REST.get(`/user/${state.uid}?_format=json`, params)
            .then(({ data }) => {
              console.log('user REST getUser data', data)
              console.log('roles', data.roles)
              commit('setUser', data)
              if (data.roles) {
                commit('setRoles', data.roles)
              }
              dispatch('getUserFlagColls')
              resolve()
            })
            .catch(error => {
              console.warn('Issue with getUser', error)
              Promise.reject(error)
            })
        })
      })
    },
    getUserFlagColls ({ dispatch, commit, state }) {
      // flags
      // REST.get('/flagging_collection/1?_format=json')
      //   .then(( data ) => {
      //     console.log('TEST FLAG REST data', data)
      //   })
      //   .catch(error => {
      //       console.warn('Issue USER TEST FLAG REST', error)
      //       Promise.reject(error)
      //   })

      return MA.get('materio_flag/user_flagging_collections')
        .then(({ data }) => {
          console.log('user MA getFlags data', data)
          commit('setFlagColls', data)
        })
        .catch(error => {
          console.warn('Issue USER MA getFlags', error)
          Promise.reject(error)
        })
    },
    // https://drupal.stackexchange.com/questions/248539/cant-get-flagging-api-to-accept-post-request
    createFlagColl ({ dispatch, commit, state }, new_collection_name) {
      console.log('user createFlagColl', new_collection_name)
      return new Promise((resolve, reject) => {
        const params = {
          name: new_collection_name
        }
        MA.post('materio_flag/create_user_flagging_collection', params)
          .then(({ data }) => {
            console.log('user MA createFlagColl data', data)
            if (data.status) {
              dispatch('getUserFlagColls').then(() => {
                resolve()
              })
            }
          })
          .catch(error => {
            console.warn('Issue USER MA createFlag', error)
            reject(error)
          })
      })
    },
    deleteFlagColl ({ dispatch, commit, state }, flagcollid) {
      console.log('user deleteFlagColl', flagcollid)
      return new Promise((resolve, reject) => {
        const params = {
          flagcollid: flagcollid
        }
        MA.post('materio_flag/delete_user_flagging_collection', params)
          .then(({ data }) => {
            console.log('user MA deleteFlagColl data', data)
            dispatch('getUserFlagColls').then(() => {
              resolve()
            })
          })
          .catch(error => {
            console.warn('Issue USER MA createFlag', error)
            reject(error)
          })
      })
    },
    flag ({ dispatch, commit, state }, args) {
      console.log('user flag', args.uuid, args.collid)
      return new Promise((resolve, reject) => {
        const params = {
          flagid: state.flagcolls[args.collid].flag_id,
          uuid: args.uuid,
          flagcollid: args.collid
        }
        return MA.post('materio_flag/flag', params)
          .then(({ data }) => {
            console.log('user MA flag', data)
            dispatch('getUserFlagColls').then(() => {
              resolve()
            })
          })
          .catch(error => {
            console.warn('Issue USER MA flag', error)
          })
      })
    },
    unFlag ({ dispatch, commit, state }, args) {
      console.log('user unFlag', args.uuid, args.collid)
      return new Promise((resolve, reject) => {
        const params = {
          flagid: state.flagcolls[args.collid].flag_id,
          uuid: args.uuid,
          flagcollid: args.collid
        }
        return MA.post('materio_flag/unflag', params)
          .then(({ data }) => {
            console.log('user MA unFlag', data)
            dispatch('getUserFlagColls').then(() => {
              resolve()
            })
          })
          .catch(error => {
            console.warn('Issue USER MA unFlag', error)
          })
      })
    },
    openFlagColl ({ commit, dispatch }, collid) {
      console.log('user openFlagColl', collid)
      commit('openFlagColl', collid)
      dispatch('loadFlagCollItems', collid)
    },
    loadFlagCollItems ({ commit, state }, collid) {
      console.log('loadFlagCollItems', state.flagcolls[collid].items_uuids)
      const params = {
        'filter[uuids-groupe][group][conjunction]': 'OR'
      }
      const uuids = state.flagcolls[collid].items_uuids
      // console.log('uuids', uuids)
      for (let i = 0; i < uuids.length; i++) {
        let uuid = uuids[i]
        // console.log('uuid', uuid)
        params[`filter[${uuid}][condition][path]`] = 'id'
        params[`filter[${uuid}][condition][value]`] = uuid
        params[`filter[${uuid}][condition][operator]`] = '='
        params[`filter[${uuid}][condition][memberOf]`] = 'uuids-groupe'
      }
      console.log('search JSONAPI params', params);
      const q = qs.stringify(params)
      return JSONAPI.get('node/materiau?' + q)
        .then(({ data }) => {
          console.log('user loadFlagCollItems data', data)
          // dispatch('parseItems', { data: data.data, uuids: uuids })
          commit('setLoadedCollItems', {collid: collid, items: data.data})
        })
        .catch((error) => {
          console.warn('Issue with loadFlagCollItems', error)
          Promise.reject(error)
        })
    },
    userLogout ({ commit, state }) {
      const credentials = qs.stringify({
        token: state.csrf_token
      })
      REST.post('/user/logout', credentials)
        .then(resp => {
          console.log('userLogout resp', resp)
          commit('setLoggedOut')
        })
        .catch(error => {
          console.warn('Issue with logout', error)
          Promise.reject(error)
        })
    }
  }
}