import { defineStore } from 'pinia'

import {
  ICircuit,
  IMyCircuit,
  IFriends,
  IMsgGlobParam,
  ISigninOptions,
  ISignupOptions,
  IUserFields,
  IUserNotifType,
  IUserProfile,
  IUserState,
  IAccount,
  IColGridTable,
  ISignupIscrizioneConacreisOptions,
  ISignupIscrizioneArcadeiOptions,
} from '@src/model'
import { tools } from '@store/Modules/tools'
import translate from '@src/globalroutines/util'
import { ICallResult, ILinkReg, IResult, IToken } from '@model/other'

import * as Types from '@src/store/Api/ApiTypes'
import { useGlobalStore } from '@store/globalStore'
import { serv_constants } from '@store/Modules/serv_constants'
import { Api } from '@api'
import { toolsext } from '@store/Modules/toolsext'
import { static_data } from '@src/db/static_data'


import bcrypt from 'bcryptjs'

import { useTodoStore } from '@store/Todos'
import { Router } from 'vue-router'
import { useProjectStore } from '@store/Projects'
import { shared_consts } from '@/common/shared_vuejs'
import { costanti } from '@costanti'
import { IBookmark, IFavBook, IFavorite, IGroupShort, IMyGroup, IUserAdmins } from '@model/UserStore'

import globalroutines from '../globalroutines/index'
import { useNotifStore } from '@store/NotifStore'
import { useCircuitStore } from './CircuitStore'

export const CMD_USER = {
  SET_FAVORITE: 1,
  SET_BOOKMARK: 2,
}

export const DefaultUser: IUserFields = {
  _id: '',
  email: '',
  username: '',
  name: '',
  surname: '',
  password: '',
  tokens: [],
  verified_email: false,
  verified_by_aportador: false,
  aportador_solidario: '',
  made_gift: false,
  profile: {
    img: '',
    teleg_id: 0,
    saw_zoom_presentation: false,
    ask_zoom_partecipato: false,
    saw_and_accepted: false,
    qualified: false,
    qualified_2invitati: false,
    socio: false,
    socioresidente: false,
    myshares: [],
    friends: [],
    req_friends: [],
    handshake: [],
    mygroups: [],
    mycircuits: [],
    last_circuitpath: '',
    lastdate_reqRis: tools.getLastDateReadReset(),
    manage_mygroups: [],
    asked_friends: [],
    asked_groups: [],
    refused_groups: [],
    notifs: [],
    bookmark: [],
    favorite: [],
    myfav: [],
    mybook: [],
    notif_idCities: [],
    notif_provinces: [],
    notif_regions: [],
    notif_sectors: [],
    notif_sector_goods: [],
    stepTutorial: 0,
    noNameSurname: false,
    noCircuit: false,
    noFoto: false,
    asked_circuits: [],
    refused_circuits: [],
    manage_mycircuits: [],
    useraccounts: [],
    calc: { numGoodsAndServices: 0 },
    resid_province: '',
  },
  cart: {
    userId: '',
    items: [],
    totalPrice: 0,
    department: '',
    totalQty: 0,
    note: '',
  },
}

export const DefaultProfile: IUserProfile = {
  img: '',
  nationality: '',
  intcode_cell: '',
  cell: process.env.TEST_CELL || '',
  dateofbirth: null,
  sex: 0,
  country_pay: '',
  email_paypal: '',
  payeer_id: '',
  advcash_id: '',
  revolut: '',
  link_payment: '',
  note_payment: '',
  username_telegram: '',
  teleg_id: 0,
  teleg_checkcode: 0,
  my_dream: '',
  manage_telegram: false,
  saw_zoom_presentation: false,
  ask_zoom_partecipato: false,
  saw_and_accepted: false,
  socio: false,
  socioresidente: false,
  paymenttypes: [],
  qualified: false,
  qualified_2invitati: false,
  myshares: [],
  friends: [],
  req_friends: [],
  handshake: [],
  mygroups: [],
  mycircuits: [],
  last_circuitpath: '',
  manage_mygroups: [],
  asked_friends: [],
  asked_groups: [],
  refused_groups: [],
  notifs: [],
  bookmark: [],
  favorite: [],
  myfav: [],
  mybook: [],
  notif_idCities: [],
  notif_provinces: [],
  notif_regions: [],
  notif_sectors: [],
  notif_sector_goods: [],
  stepTutorial: 0,
  noNameSurname: false,
  noCircuit: false,
  noFoto: false,
  asked_circuits: [],
  refused_circuits: [],
  manage_mycircuits: [],
  useraccounts: [],
  calc: { numGoodsAndServices: 0 },
  resid_province: '',
}

export const useUserStore = defineStore('UserStore', {
  state: () => ({
    my: { ...DefaultUser },
    userprofile: DefaultUser,
    groups: [],
    lang: process.env.LANG_DEFAULT ? process.env.LANG_DEFAULT : 'it',
    repeatPassword: '',
    categorySel: 'personal',
    servercode: 0,
    resStatus: 0,
    x_auth_token: '',
    isLogged: false,
    isAdmin: false,
    isManager: false,
    isDepartment: false,
    isFacilitatore: false,
    isZoomeri: false,
    isTratuttrici: false,
    isEditor: false,
    isTeacher: false,
    usersList: [],
    countusers: 0,
    lastparamquery: {},
    updateTables: false,
  }),

  getters: {

    isServerError(): boolean {
      return (this.servercode === toolsext.ERR_SERVERFETCH)
    },

    getServerCode: (state: IUserState): number => (state.servercode ? state.servercode : 0),
    getMsg: (state: IUserState): string => (state.msg ? state.msg : ''),

    getUsersList: (mystate: IUserState) => {
      return mystate.usersList
    },

    IsMyFriend: (mystate: IUserState) => (userIdOwner: string): boolean => {
      // ++TODO Check if userIdOwner is my friend
      // userIdOwner is my friend ?
      return true
    },


    IsMyGroup: (mystate: IUserState) => (userIdOwner: string): boolean => {
      // ++TODO Check if userIdOwner is on my groups
      // userIdOwner is on my groups ?
      return true
    },


    isTokenInvalid: (state: IUserState) => {
      try {
        return (state.my.tokens!.length <= 0)
      } catch (e) {
        return true
      }
    },

    isUserInvalid: (state: IUserState): boolean => {
      try {
        return (state.my._id === undefined) || (state.my._id.trim() === '')
      } catch (e) {
        return true
      }
    },

  },

  actions: {


    getMypaginationMembers(): any {
      return { sortBy: 'name,username', descending: '1,1', page: 1, rowsNumber: 0, rowsPerPage: 10 }
    },
    getSortFieldsAvailable(): any[] {
      return [{ label: 'Username', value: { 'username': 1, 'name': 1 } }, { label: 'Nome', value: { 'name': 1, 'username': 1 } }, { label: 'Ultimi reg.', value: { 'date_reg': -1, 'username': 1 } }]
    },

    IsMyFriendByUsername(username: string): boolean {
      if (this.my.profile.friends)
        return this.my.profile.friends.findIndex((rec) => rec.username === username) >= 0
      else
        return false
    },
    IsHandShakeByUsername(username: string): boolean {
      if (this.my.profile.handshake)
        return this.my.profile.handshake.findIndex((rec) => rec.username === username) >= 0
      else
        return false
    },

    IsHandShakeByMe(user: IUserFields): boolean {
      if (user && user.profile && user.profile.handshake)
        return user.profile.handshake.findIndex((rec) => rec.username === this.my.username) >= 0
      else
        return false
    },

    IsMyGroupByGroupname(groupname: string): boolean {
      if (this.my.profile.mygroups)
        return this.my.profile.mygroups.findIndex((rec) => rec.groupname === groupname) >= 0
      else
        return false
    },

    getMyGroupByGroupname(groupname: string): IMyGroup | null {
      if (this.my.profile.mygroups) {
        const ris = this.my.profile.mygroups.find((rec) => rec.groupname === groupname)
        return ris ? ris : null
      } else {
        return null
      }
    },

    GroupsListWhereIAmAdmin(): any {
      try {
        return this.my.profile.manage_mygroups
      } catch (e) {
        return []
      }
    },

    GroupsListWhereIAmAdminInTheCircuit(circuitname: string): any {
      try {
        const arr: any = this.my.profile.manage_mygroups.filter((group: IMyGroup) => (group.mycircuits!.findIndex((circ: IMyCircuit) => circ.circuitname === circuitname) >= 0))
        console.log('arr', arr)
        return arr
      } catch (e) {
        return []
      }
    },

    hoContiComunitariDaAmministrare(): boolean {
      try {
        const arr: any = this.my.profile.manage_mygroups.filter((group: IMyGroup) => (group.mycircuits!.length > 0))
        return !!arr
      } catch (e) {
        return false
      }
    },

    hoContiCollettiviDaAmministrare(): boolean {
      const arr = this.my.profile.manage_mygroups.find((group: IMyGroup) => group.account)
      return arr ? true : false
    },

    IsAskedFriendByUsername(username: string): boolean {
      if (this.my.profile.asked_friends)
        return this.my.profile.asked_friends.findIndex((rec) => rec.username === username) >= 0
      else
        return false
    },

    IsReqFriendByUsername(username: string): boolean {
      if (this.my.profile.req_friends)
        return this.my.profile.req_friends.findIndex((rec) => rec.username === username) >= 0
      else
        return false
    },

    IsAskedGroupByGroupname(groupname: string): boolean {
      if (this.my.profile.asked_groups)
        return this.my.profile.asked_groups.findIndex((rec: IGroupShort) => rec.groupname === groupname) >= 0
      else
        return false
    },

    IsRefusedGroupByGroupname(groupname: string): boolean {
      if (this.my.profile.refused_groups)
        return this.my.profile.refused_groups.findIndex((rec: IGroupShort) => rec.groupname === groupname) >= 0
      else
        return false
    },

    getUserByUsername(username: string): IUserFields | null {
      // Check if is this User!
      if (this.my.username === username) return this.my

      let trovato: any = null
      if (this.usersList) trovato = this.usersList.find((item: any) => item.username === username)

      if (trovato) {
        if (trovato.surname === 'undefined')
          trovato.surname = ''
        if (trovato.name === 'undefined')
          trovato.name = ''
      }

      return (trovato) || null
    },

    getImgByUsername(username: string): string {
      if (username === '') return ''
      // Check if is this User!
      const myrec = this.getUserByUsername(username)
      if (myrec && myrec.profile && !!myrec.profile.img && myrec.profile.img !== '' && myrec.profile.img !== 'undefined') {
        return costanti.DIR_UPLOAD + 'profile/' + this.my.username + '/' + myrec.profile.img
      }
      return ''
    },

    getImgUserByUsername(username: string): string {
      const img = this.getImgByUsername(username)
      return img ? img : 'images/noimg-user.svg'
    },

    getImgUserByRow(row: any, col: IColGridTable): string {
      let value = ''

      if (row.hasOwnProperty(col.name)) {
        value = row[col.name]
      }
      let tipoconto = costanti.AccountType.USER
      if (col.hasOwnProperty('tipoconto') && col.tipoconto) {
        tipoconto = col.tipoconto
      }
      let img = ''
      if (tipoconto === costanti.AccountType.USER) {
        img = this.getImgByUsername(value)
      } else if (tipoconto === costanti.AccountType.COLLECTIVE_ACCOUNT) {
        img = this.getImgByGroupname(value)
      } else if (tipoconto === costanti.AccountType.COMMUNITY_ACCOUNT) {
        img = this.getImgByCircuitpath(value)
      }

      if (row) {
        const mycol = col.name + '.img'
        if (row.hasOwnProperty(mycol)) {
          img = row[mycol]
        }
      }

      return img ? img : 'images/noimg-user.svg'
    },

    getImgByProfile(userparam: any, reale: any = false, col: any = null): string {
      try {
        let myrec = this.getRecByCol(userparam, col)
        let img = ''
        if (!reale)
          img = 'images/noimg-user.svg'

        let tipoconto = costanti.AccountType.USER
        if (col && col.hasOwnProperty('tipoconto') && col.tipoconto) {
          tipoconto = col.tipoconto
        }

        if (tipoconto === costanti.AccountType.COLLECTIVE_ACCOUNT) {
          img = this.getImgByGroupname(myrec.groupname)
        } else if (tipoconto === costanti.AccountType.COMMUNITY_ACCOUNT) {
          img = this.getImgByCircuitpath(myrec.path)
        } else {
          if (myrec.profile && myrec.profile.img) {
            img = costanti.DIR_UPLOAD + 'profile/' + myrec.username + '/' + myrec.profile.img
          }
        }

        return img
      } catch (e) {
        //
      }
      if (!reale)
        return 'images/noimg-user.svg'
      else
        return ''
    },


    IsAskedCircuitByName(name: string): boolean {
      if (this.my.profile.asked_circuits)
        return this.my.profile.asked_circuits.findIndex((rec: ICircuit) => rec.name === name) >= 0
      else
        return false
    },



    IsMyCircuitByName(circuitname: string): boolean {

      if (this.my.profile.mycircuits)
        return this.my.profile.mycircuits.findIndex((rec: IMyCircuit) => rec.circuitname === circuitname) >= 0
      else
        return false

    },

    IsMyCircuitByNameAndGroup(circuitname: string, groupname: string): boolean {
      const globalStore = useGlobalStore()

      if (globalStore.mygroups) {
        const group: IMyGroup | undefined = globalStore.mygroups.find((rec: IMyGroup) => rec.groupname === groupname)
        if (group && group.mycircuits) {
          return group.mycircuits.findIndex((rec: any) => rec.circuitname === circuitname) >= 0
        }
        return false
      } else
        return false

    },

    getMyCircuitsInCommonByUser(user: IUserFields): any[] {

      if (!this.my.profile.mycircuits || (!user || !user.profile || !user.profile.mycircuits))
        return []
      return tools.getCommon([...this.my.profile.mycircuits], [...user.profile.mycircuits], 'circuitname')
    },

    getMyCircuits(): any[] {

      if (!this.my.profile.mycircuits)
        return []
      return this.my.profile.mycircuits.map(item => item.circuitname)
    },

    getMyCircuitsInCommonByGroup(group: IMyGroup): any[] {

      if (!this.my.profile.mycircuits || (!group || !group.mycircuits))
        return []
      return tools.getCommon([...this.my.profile.mycircuits], [...group.mycircuits], 'circuitname')
    },

    getMyHandshakeInCommon(myuser: IUserFields): any[] {

      if (!this.my.profile.handshake || (!myuser || !myuser.profile.handshake))
        return []
      return tools.getCommonAllRecord([...this.my.profile.handshake], [...myuser.profile.handshake], 'username')
    },

    getAccountByCircuitId(circuitId: string): any {
      if (this.my.profile.useraccounts) {
        return this.my.profile.useraccounts.find((rec: IAccount) => rec.circuitId === circuitId)
      }
      return null
    },
    getAccountsListNameValue(): any[] {
      let arr = []
      const circuitStore = useCircuitStore()

      if (this.my.profile.useraccounts) {
        for (const acc of this.my.profile.useraccounts) {
          let chi = acc.username ? acc.username : (acc.groupname ? acc.groupname : acc.contocom)
          if (acc.circuit) {
            chi += ' (' + circuitStore.getNameByCircuitId(acc.circuitId) + ')'
          }
          arr.push({ label: chi, value: acc._id })
        }
      }
      return arr
    },

    IsRefusedCircuitByName(circuitname: string): boolean {
      if (this.my.profile.refused_circuits)
        return this.my.profile.refused_circuits.findIndex((rec: ICircuit) => rec.name === circuitname) >= 0
      else
        return false
    },

    getImgByCircuit(circ: ICircuit | null): string {

      try {
        if (circ && circ.photos && circ.photos.length > 0)
          return costanti.DIR_UPLOAD + 'circuits/' + circ.path + '/' + circ.photos[0].imagefile
      } catch (e) {
      }
      return 'images/noimg.png'
    },

    getImgByCircuitpath(circuitpath: string): string {
      const circuitStore = useCircuitStore()

      const mycirc = circuitStore.getCircuitByPath(circuitpath)
      return this.getImgByCircuit(mycirc)
    },

    getImgByGroup(group: IMyGroup | null): string {

      try {
        // ++Todo: Sistemare!
        if (group) {
          return costanti.DIR_UPLOAD + 'mygroups/' + group.groupname + '/' + group.photos[0].imagefile
        }
      } catch (e) {
      }
      return 'images/noimg.png'
    },

    getImgByGroupname(groupname: string): string {
      const mygroup = this.getMyGroupByGroupname(groupname)
      return this.getImgByGroup(mygroup)
    },

    getRefLink(username: string): string {
      if (username === '')
        username = this.my.username
      return tools.getUrlSite() + '/registrati/' + username
    },

    isUserOk(): boolean {
      const globalStore = useGlobalStore()

      if (globalStore.site.confpages.enableRegMultiChoice) {
        return ((this.my.profile.teleg_id! > 0 && this.isUsernameTelegOk()) || this.my.verified_email!) && this.my.verified_by_aportador!
      } else {
        return this.my.profile.teleg_id! > 0 && this.my.verified_by_aportador! && this.isUsernameTelegOk()
      }
      // return this.my.verified_email! && this.my.profile.teleg_id! > 0 && this.my.verified_by_aportador!
    },

    isUserWaitingVerifAportador(): boolean {
      return tools.isLogged() && !this.my.verified_by_aportador
    },

    isOldRegNotFinished(): boolean {
      return tools.isLogged() && ((!this.my.profile.teleg_id || this.my.profile.teleg_id <= 0) || !this.isUsernameTelegOk())
      // return this.my.verified_email! && this.my.profile.teleg_id! > 0 && this.my.verified_by_aportador!
    },

    isTelegOk(): boolean {
      return this.my.profile.teleg_id! > 0
      // return this.my.verified_email! && this.my.profile.teleg_id! > 0 && this.my.verified_by_aportador!
    },

    isUsernameTelegOk(): boolean {
      return !!this.my.profile.username_telegram
      // return this.my.verified_email! && this.my.profile.teleg_id! > 0 && this.my.verified_by_aportador!
    },

    getNameSurnameByUserId(userId: string): string {

      const user = this.getUserByUserId(userId)
      if (user) return `${user.name} ` + !!user.surname ? user.surname : ''
      return `(${userId})`
    },

    getNameSurnameByUsername(username: string): string {
      const user = this.getUserByUsername(username)
      if (user) return `${user.name} ` + !!user.surname ? user.surname : ''
      return `(${username})`
    },

    getRecByCol(user: any, col: any = null) {
      let myrec = user
      if (col && col.field === 'userto')
        myrec = user.userto
      else if (col && col.field === 'groupto')
        myrec = user.groupto
      else if (col && col.field === 'userfrom')
        myrec = user.userfrom
      else if (col && col.field === 'groupfrom')
        myrec = user.groupfrom
      else if (col && col.field === 'contocomfrom')
        myrec = user.contocomfrom
      else if (col && col.field === 'contocomto')
        myrec = user.contocomto

      return myrec
    },

    getNameToShow(user: any, col: any = null): string {
      let name = ''
      let myrec = this.getRecByCol(user, col)

      let tipoconto = costanti.AccountType.USER
      if (col && col.hasOwnProperty('tipoconto')) {
        tipoconto = col.tipoconto
      }

      if (tipoconto === costanti.AccountType.USER) {
        if (!!myrec.name)
          name = myrec.name + ' '
        if (!!myrec.surname)
          name += myrec.surname + ' '

        if (!name) {
          name += myrec.username + ' '
        }
        if (col && col.field === 'extrarec' && !name) {
          name = myrec.dest
        }
      } else if (tipoconto === costanti.AccountType.COLLECTIVE_ACCOUNT) {
        if (myrec.hasOwnProperty('descr'))
          return myrec.descr
        else if (myrec.hasOwnProperty('groupname'))
          return myrec.groupname
      } else if (tipoconto === costanti.AccountType.COMMUNITY_ACCOUNT) {
        if (myrec.hasOwnProperty('name'))
          return myrec.name
        else if (myrec.hasOwnProperty('contocom'))
          return myrec.contocom
      }

      return name
    },

    getUserNameOnlyIfToShow(user: any, col: any = null): string {
      let myrec = this.getRecByCol(user, col)

      if (myrec.name || myrec.surname) {
        return myrec.username
      }

      return ''
    },

    getUserByUserId(userId: string): IUserFields | null {
      // Check if is this User!
      if (this.my._id === userId) return this.my

      let trovato: any = null

      if (this.usersList) trovato = this.usersList.find((item: any) => item._id === userId)

      if (trovato) {
        if (trovato.surname === undefined)
          trovato.surname = ''
        if (trovato.name === undefined)
          trovato.name = ''
      }

      return (trovato) || null
    },

    getMsgError(err: number): string {
      let msgerrore = ''
      if (err !== tools.OK) {
        msgerrore = `Error [${this.servercode}]: `
        if (this.servercode === toolsext.ERR_SERVERFETCH) {
          msgerrore = translate('fetch.errore_server')
        } else {
          msgerrore = translate('fetch.errore_generico')
        }

        if (process.env.DEV) {
          console.log('ERROREEEEEEEEE: ', msgerrore, ' (', err, ')')
        }
      }

      // return { code: this.servercode, msg: msgerrore }
      return msgerrore
    },


    clearAuthData() {
      this.my = DefaultUser
      // resetArrToken(mystate.my.tokens)

      this.categorySel = 'personal'

      this.servercode = 0
      this.resStatus = 0
      this.isLogged = false
      this.x_auth_token = ''

      return true
    },

    async resetpwd(paramquery: any) {

      const mydata = { ...paramquery }

      return bcrypt.hash(mydata.password, bcrypt.genSaltSync(12))
        .then((hashedPassword: string) => {
          mydata.repeatPassword = ''
          mydata.password = String(hashedPassword)

          return Api.SendReq('/updatepwd', 'POST', mydata, true)
            .then((res) => {
              return { code: res.data.code, msg: res.data.msg }
            })
            .catch((error: Types.AxiosError) => {
              this.setErrorCatch(error)
              return { code: this.getServerCode, msg: error.getMsgError() }
            })
        })

    },

    setErrorCatch(axerr: Types.AxiosError) {
      try {
        if (this.servercode !== toolsext.ERR_SERVERFETCH) {
          this.servercode = axerr.getCode()
        }
        // this.msg = axerr.getMsg()
        console.log('Err catch: (servercode:', axerr.getCode(), axerr.getMsgError(), ')')
      } catch (e) {
        console.log('Err catch:', axerr)
      }
    },

    async setLangServer() {
      const mydata = {
        username: this.my.username,
        lang: this.lang,
      }

      return Api.SendReq('/setlang', 'PATCH', { data: mydata })
        .then((res) => {
          if (res) {
            return (res.data.code === serv_constants.RIS_CODE_OK)
          }
          return false
        })
        .catch((error: any) => false)
    },

    async requestpwd(paramquery: any) {
      const usertosend = {
        email: paramquery.email,
        codetocheck: paramquery.tokenforgot_code,
      }
      console.log(usertosend)

      this.setServerCode(tools.CALLING)

      return Api.SendReq('/requestnewpwd', 'POST', usertosend)
        .then((res) => ({ code: res.data.code, msg: res.data.msg, link: res.data.link })).catch((error) => {
          this.setErrorCatch(error)
          return this.getServerCode
        })
    },

    async vreg(paramquery: ILinkReg) {
      const usertosend = {
        idlink: paramquery.idlink,
      }
      console.log(usertosend)

      this.setServerCode(tools.CALLING)

      return Api.SendReq('/vreg', 'POST', usertosend)
        .then((res) => {
          // console.log("RITORNO 2 ");
          // mutations.setServerCode(myres);
          if (res.data.code === serv_constants.RIS_CODE_EMAIL_VERIFIED) {
            console.log('VERIFICATO !!')
            tools.localStSetItem(toolsext.localStorage.verified_email, String(true))
          } else {
            console.log('Risultato di vreg: ', res.data.code)
          }
          return { code: res.data.code, msg: res.data.msg }
        }).catch((error) => {
          this.setErrorCatch(error)
          return { code: this.getServerCode, msg: error.getMsgError() }
        })
    },

    async unsubscribe(paramquery: any) {
      return Api.SendReq('/news/unsubscribe', 'POST', paramquery)
        .then((res) => {
          // console.log("RITORNO 2 ");
          // mutations.setServerCode(myres);
          if (res.data.code === serv_constants.RIS_UNSUBSCRIBED_OK) {
            console.log('DESOTTOSCRITTO ALLA NEWSLETTER !!')
          } else {
            console.log('Risultato di unsubscribe: ', res.data.code)
          }
          return { code: res.data.code, msg: res.data.msg }
        }).catch((error) => this.getServerCode)
    },

    async importemail(paramquery: any) {
      return Api.SendReq('/news/import', 'POST', paramquery)
        .then((res) => res).catch((error) => ({ numtot: 0, numadded: 0, numalreadyexisted: 0 }))
    },

    async importExtraList(paramquery: any) {

      return Api.SendReq('/users/import_extralist', 'POST', paramquery)
        .then((res) => {
          return res
        }).catch((error) => {
          return { numtot: 0, numadded: 0, numalreadyexisted: 0 }
        })
    },

    async execDbOp(paramquery: any) {
      return Api.SendReq('/users/dbop', 'POST', paramquery)
        .then((res) => {

          return res.data
        }).catch((error) => {
          return false
        })
    },

    async execDbOpUser(paramquery: any) {
      return Api.SendReq('/users/dbopuser', 'POST', paramquery)
        .then((res) => {

          tools.updateMyData(res.data.ris)

          return res.data
        }).catch((error) => {
          return false
        })
    },

    async saveStepTutorial(step: number) {
      const mydata = {
        _id: this.my._id,
        dbop: 'saveStepTut',
        value: step,
      }
      this.my.profile.stepTutorial = step
      const ris = await this.execDbOpUser({ mydata })

      return ris
    },
    async savenoNameSurname(val: boolean) {
      const mydata = {
        _id: this.my._id,
        dbop: 'noNameSurname',
        value: val,
      }
      if (this.my.profile.noNameSurname !== val) {
        this.my.profile.noNameSurname = val
        return await this.execDbOpUser({ mydata })
      }
    },
    async savenoCircuit(val: boolean) {
      const mydata = {
        _id: this.my._id,
        dbop: 'noCircuit',
        value: val,
      }
      if (this.my.profile.noCircuit !== val) {
        this.my.profile.noCircuit = val
        return await this.execDbOpUser({ mydata })
      }
    },
    async savenoFoto(val: boolean) {
      const mydata = {
        _id: this.my._id,
        dbop: 'noFoto',
        value: val,
      }
      if (this.my.profile.noFoto !== val) {
        this.my.profile.noFoto = val
        return await this.execDbOpUser({ mydata })
      }
    },

    async newsletterload(paramquery: any) {

      return Api.SendReq('/news/load', 'POST', paramquery)
        .then((res) => {
          // console.log('res', res)
          return res.data
        }).catch((error) => {
          return null
        })
    },

    async reportload(paramquery: any) {

      return Api.SendReq('/report/load', 'POST', paramquery)
        .then((res) => {
          // console.log('res', res)
          return res.data
        }).catch((error) => {
          return null
        })
    },

    async newsletter_setactivate(paramquery: any) {

      return Api.SendReq('/news/setactivate', 'POST', paramquery)
        .then((res) => {
          // console.log('res', res)
          return res.data
        }).catch((error) => {
          return null
        })
    },

    authUser(data: IUserFields) {
      try {
        this.my = { ...data }
        // console.log('**** my', this.my)
        if (!this.my.profile) {
          this.my.profile = DefaultProfile

          // Memory
          this.my.profile.manage_mygroups = []
          this.my.profile.asked_friends = []
          this.my.profile.asked_groups = []
          this.my.profile.refused_groups = []
        }

        this.isAdmin = tools.isBitActive(this.my.perm, shared_consts.Permissions.Admin.value)
        this.isManager = tools.isBitActive(this.my.perm, shared_consts.Permissions.Manager.value)
        this.isFacilitatore = tools.isBitActive(this.my.perm, shared_consts.Permissions.Facilitatore.value)
        this.isZoomeri = tools.isBitActive(this.my.perm, shared_consts.Permissions.Zoomeri.value)
        this.isDepartment = tools.isBitActive(this.my.perm, shared_consts.Permissions.Department.value)
        this.isTeacher = tools.isBitActive(this.my.perm, shared_consts.Permissions.Teacher.value)
        this.isEditor = tools.isBitActive(this.my.perm, shared_consts.Permissions.Editor.value)

        this.my.tokens = []
        this.resetArrToken(this.my.tokens)
        this.my.tokens.push({ access: 'auth', token: this.x_auth_token, data_login: tools.getDateNow() })

      } catch (e) {
        console.log('Error authUser: ' + e)
      }

    },

    updateLocalStorage(myuser: IUserFields) {
      const globalStore = useGlobalStore()

      const now = tools.getDateNow()

      // const expirationDate = new Date(now.getTime() + myres.data.expiresIn * 1000);
      const expirationDate = new Date(now.getTime() * 1000)
      tools.localStSetItem(toolsext.localStorage.lang, this.lang)
      tools.localStSetItem(toolsext.localStorage.userId, myuser._id)
      tools.localStSetItem(toolsext.localStorage.username, myuser.username)
      tools.localStSetItem(toolsext.localStorage.name, myuser.name)
      tools.localStSetItem(toolsext.localStorage.surname, myuser.surname)
      tools.localStSetItem(toolsext.localStorage.perm, String(myuser.perm) || '')
      if (myuser.profile !== undefined) tools.localStSetItem(toolsext.localStorage.img, (myuser.profile.img) ? String(myuser.profile.img) || '' : '')
      else tools.localStSetItem(toolsext.localStorage.img, '')
      localStorage.setItem(toolsext.localStorage.token, this.x_auth_token)
      localStorage.setItem(toolsext.localStorage.expirationDate, expirationDate.toString())
      tools.localStSetItem(toolsext.localStorage.isLogged, String(true))
      tools.localStSetItem(toolsext.localStorage.verified_email, String(myuser.verified_email))
      tools.localStSetItem(toolsext.localStorage.verified_by_aportador, String(myuser.verified_by_aportador))
      tools.localStSetItem(toolsext.localStorage.teleg_id, String(myuser.profile.teleg_id))
      tools.localStSetItem(toolsext.localStorage.made_gift, String(myuser.made_gift))
      tools.localStSetItem(toolsext.localStorage.wasAlreadySubOnDb, String(globalStore.wasAlreadySubOnDb))
    },

    setusersList(usersList: IUserFields[]) {
      // console.log('setusersList', usersList)
      // @ts-ignore
      this.usersList = [...usersList]
    },

    setlang($q: any, $router: Router, newstr: string) {
      console.log('SETLANG', newstr)
      this.lang = newstr
      toolsext.setLangAtt($q, $router, newstr)
      tools.localStSetItem(toolsext.localStorage.lang, this.lang)
    },

    signup(authData: ISignupOptions) {
      console.log('SIGNUP')
      const mylang = this.lang
      console.log('MYLANG: ' + mylang)

      return bcrypt.hash(authData.password!, bcrypt.genSaltSync(12))
        .then((hashedPassword: string) => {
          authData.lang = mylang
          authData.password = String(hashedPassword)

          this.setServerCode(tools.CALLING)

          return Api.SendReq('/users', 'POST', authData)
            .then((res) => {

              const newuser = res.data

              // console.log('newuser', newuser)

              this.setServerCode(res.status)

              if (res.status === 200) {
                if (process.env.DEV) {
                  console.log('USERNAME = ' + newuser.username)
                  console.log('IDUSER= ' + newuser._id)
                }

                this.authUser(newuser)

                const now = tools.getDateNow()
                // const expirationDate = new Date(now.getTime() + myres.data.expiresIn * 1000);
                const expirationDate = new Date(now.getTime() * 1000)
                tools.localStSetItem(toolsext.localStorage.lang, this.lang)
                tools.localStSetItem(toolsext.localStorage.userId, newuser._id)
                tools.localStSetItem(toolsext.localStorage.username, newuser.username)
                tools.localStSetItem(toolsext.localStorage.name, newuser.name)
                tools.localStSetItem(toolsext.localStorage.surname, newuser.surname)
                localStorage.setItem(toolsext.localStorage.token, this.x_auth_token)
                localStorage.setItem(toolsext.localStorage.expirationDate, expirationDate.toString())
                tools.localStSetItem(toolsext.localStorage.verified_email, String(false))
                tools.localStSetItem(toolsext.localStorage.verified_by_aportador, String(false))

                // Even if you has registered, you have to SignIn first
                this.isLogged = false
                // dispatch('storeUser', authData);
                // dispatch('setLogoutTimer', myres.data.expiresIn);
                console.log('OK')
                return { code: tools.OK, msg: '' }
              } else {
                console.log('ERR GENERICO')
                return { code: toolsext.ERR_GENERICO, msg: '' }
              }
            })
            .catch((error) => {
              console.log('Err', error)
              this.setErrorCatch(error)
              return { code: this.getServerCode, msg: this.getMsg }
            })
        })
    },

    UpdatePwd(x_auth_token: string) {
      this.x_auth_token = x_auth_token
      if (!this.my.tokens) {
        this.my.tokens = []
      }
      this.my.tokens.push({ access: 'auth', token: x_auth_token, data_login: tools.getDateNow() })
    },

    setServerCode(num: number) {
      this.servercode = num
    },

    setResStatus(status: number) {
      this.resStatus = status
    },

    setAuth(x_auth_token: string) {
      this.x_auth_token = x_auth_token
    },

    resetArrToken(arrtokens: IToken[]) {
      if (!arrtokens) {
        arrtokens = []
      }

      // Take only the others access (from others Browser)
      return arrtokens.filter((token: IToken) => token.access !== 'auth')
    },

    async iscrivitiConacreis(authData: ISignupIscrizioneConacreisOptions) {
      console.log('iscrivitiConacreis')

      this.setServerCode(tools.CALLING)

      authData.userId = this.my._id

      return Api.SendReq('/iscritti_conacreis', 'POST', authData)
        .then((res) => {
          if (res.status === 200) {
            return { code: serv_constants.RIS_ISCRIZIONE_OK, msg: '' }
          } else {
            return { code: toolsext.ERR_GENERICO, msg: '' }
          }
        }).catch((error) => {
          console.log('Err', error)
          this.setErrorCatch(error)
          return { code: this.getServerCode, msg: this.getMsg }
        })

    },

    async iscrivitiArcadei(authData: ISignupIscrizioneArcadeiOptions) {
      console.log('iscrivitiArcadei')

      this.setServerCode(tools.CALLING)

      authData.userId = this.my._id

      return Api.SendReq('/iscritti_arcadei', 'POST', authData)
        .then((res) => {
          if (res.status === 200) {
            return { code: serv_constants.RIS_ISCRIZIONE_OK, msg: '' }
          } else {
            return { code: toolsext.ERR_GENERICO, msg: '' }
          }
        }).catch((error) => {
          console.log('Err', error)
          this.setErrorCatch(error)
          return { code: this.getServerCode, msg: this.getMsg }
        })

    },

    async signin($router: Router, authData: ISigninOptions) {
      console.log('LOGIN signin')
      const globalStore = useGlobalStore()

      const options = {
        title: tools.translate('notification.title_subscribed', [{
          strin: 'sitename',
          strout: translate('ws.sitename'),
        }]),
        content: translate('notification.subscribed'),
        openUrl: '/',
      }

      const usertosend = {
        username: authData.username.trim(),
        password: authData.password.trim(),
        lang: this.lang,
        options,
      }

      if (process.env.DEBUG === '1') {
        console.log(usertosend)
      }

      this.setServerCode(tools.CALLING)

      let myres: any

      console.log('executing login...')

      return await Api.SendReq('/users/login', 'POST', usertosend, true)
        .then((res) => {

          myres = res

          if (myres.status !== 200) {
            return Promise.reject(toolsext.ERR_GENERICO)
          }
          return myres

        }).then((res) => {
          console.log(' Login res', res)

          if (res.success) {
            globalStore.SetwasAlreadySubOnDb(res.data.subsExistonDb)

            const myuser: IUserFields = res.data.usertosend
            if (myuser) {
              // console.table(myuser)

              this.authUser(myuser)

              this.updateLocalStorage(myuser)

              // globalStore.loadSite()

            }
          }

          return tools.OK

        }).then((code) => {
          if (code === tools.OK) {
            return this.setGlobal($router, true)
              .then(() => {
                return code
              })
          } else {
            return code
          }
        })
        .catch((error) => {
          console.log('error', error)
          this.setErrorCatch(error)
          return this.getServerCode
        })
    },

    async logout() {
      const globalStore = useGlobalStore()
      // const $router = useRouter()

      console.log('logout')

      localStorage.removeItem(toolsext.localStorage.expirationDate)
      localStorage.removeItem(toolsext.localStorage.token)
      localStorage.removeItem(toolsext.localStorage.userId)
      localStorage.removeItem(toolsext.localStorage.username)
      localStorage.removeItem(toolsext.localStorage.name)
      localStorage.removeItem(toolsext.localStorage.surname)
      localStorage.removeItem(toolsext.localStorage.img)
      localStorage.removeItem(toolsext.localStorage.perm)
      localStorage.removeItem(toolsext.localStorage.isLogged)
      // localStorage.removeItem(rescodes.localStorage.leftDrawerOpen)
      localStorage.removeItem(toolsext.localStorage.verified_email)
      localStorage.removeItem(toolsext.localStorage.verified_by_aportador)
      localStorage.removeItem(toolsext.localStorage.teleg_id)
      localStorage.removeItem(toolsext.localStorage.made_gift)
      localStorage.removeItem(toolsext.localStorage.categorySel)
      localStorage.removeItem(toolsext.localStorage.wasAlreadySubOnDb)

      this.isLogged = false
      this.my = { ...DefaultUser }

      await globalStore.clearDataAfterLogout()

      tools.checkApp()

      return Api.SendReq('/users/me/token', 'DELETE', null)
        .then((res) => {
          console.log(res)
        }).then(() => this.clearAuthData()).catch((error) => {
          this.setErrorCatch(error)
          return this.getServerCode
        })
    },

    async setGlobal($router: Router, isLogged: boolean) {
      console.log('setGlobal', isLogged)

      const globalStore = useGlobalStore()
      const todos = useTodoStore()
      const projects = useProjectStore()
      try {
        // this.isLogged = true
        if (isLogged) {
          // console.log('this.isLogged', this.isLogged)

          if (!tools.isMobile)
            globalStore.setleftDrawerOpen(localStorage.getItem(toolsext.localStorage.leftDrawerOpen) === 'true')
          globalStore.setCategorySel(localStorage.getItem(toolsext.localStorage.categorySel))

          globalStore.checkUpdates()
        }

        const isok = await globalStore.loadAfterLogin()

        this.isLogged = isok && isLogged

        // console.log('this.isLogged', this.isLogged, 'isok', isok, 'isLogged', isLogged)

        if (globalStore.site.confpages.enableTodos)
          await todos.dbLoad({ checkPending: true })

        if (globalStore.site.confpages.enableProj)
          await projects.dbLoad({ checkPending: true, onlyiffirsttime: true })

        globalStore.addDynamicPages($router)

        static_data.lang_available = globalStore.getLangAvailable()

        static_data.arrLangUsed = tools.getLangUsed()

        // console.log('$router', $router)

        globalStore.finishLoading = true
        if (tools.isDebug()) console.log('finishLoading', globalStore.finishLoading)

        // document.dispatchEvent(new Event('custom-post-render-event'))
      } catch (e) {
        console.error('Error', e)
        globalStore.finishLoading = true
      }

      return true
      // console.log('setGlobal: END')
    },

    async autologin_FromLocalStorage($router: Router, $q: any) {
      try {
        const globalStore = useGlobalStore()

        // console.log('*** autologin_FromLocalStorage ***')
        // INIT

        let isLogged = false

        this.lang = tools.getItemLS(toolsext.localStorage.lang)

        const token = localStorage.getItem(toolsext.localStorage.token)

        if (token) {
          const expirationDateStr = localStorage.getItem(toolsext.localStorage.expirationDate)
          const expirationDate = new Date(String(expirationDateStr))
          const now = tools.getDateNow()
          if (now < expirationDate) {
            this.setAuth(token)
            isLogged = true

          } else {
            // ++ ?? che fare qui
          }
        } else {
          isLogged = tools.isLogged()
        }

        return await this.setGlobal($router, isLogged)
          .then((loadstorage: any) => {
            // console.log('RISULT setGlobal:', loadstorage)
            if (loadstorage) {

              globalroutines('loadapp', '')

              // Create Subscription to Push Notification
              globalStore.createPushSubscription()
            }
          })

      } catch (e: any) {
        console.error('ERR autologin ', e.message)
        return false
      }
    },

    async loadUserProfile({ username, idnotif }: { username: string, idnotif?: string }) {
      const data = {
        username,
        idnotif
      }

      return await Api.SendReq('/users/profile', 'POST', data)
        .then((ris) => {
          if (this.my.username === ris.data.user.username) {
            // this.updateDataFr(ris.data.friends)
          }

          return ris.data.user
        }).catch((error) => {
          return {}
        })

    },

    async setUserNotifs(notifs: IUserNotifType[]) {
      const data = {
        notifs
      }

      return Api.SendReq('/users/notifs', 'POST', data)
        .then((ris) => {
          return ris.data
        }).catch((error) => {
          return {}
        })


    },

    async loadUserPanel(username: string) {
      const data = {
        username
      }

      return Api.SendReq('/users/panel', 'POST', data)
        .then((ris) => {
          console.log('out:', ris)
          return ris.data
        }).catch((error) => {
          return {}
        })

    },

    async setUserReceiveRIS(username: string, groupname: string) {
      const data = {
        username,
        groupname,
      }

      return Api.SendReq('/users/receiveris', 'POST', data)
        .then((ris) => {
          console.log('out:', ris)
          return ris.data
        }).catch((error) => {
          return {}
        })

    },

    async loadGroup(groupname: string, idnotif: string) {
      const data = {
        groupname,
        idnotif,
      }

      return Api.SendReq('/mygroup/load', 'POST', data)
        .then((res) => {
          return { data: res.data, status: res.status }
        }).catch((error) => {
          return { data: null, status: error.status }
        })

    },

    async loadCircuit(path: string, idnotif: string) {
      const notifStore = useNotifStore()
      const data = {
        path,
        idnotif,
        lastdr: notifStore.getLastDataRead(this.my.username),
      }

      return Api.SendReq('/circuit/load', 'POST', data)
        .then((res) => {
          this.my.profile.last_circuitpath = path
          if (res && res.data.arrrecnotif) {
            notifStore.updateArrRecNotifFromServer(res.data.arrrecnotif)
          }
          if (res.data.useraccounts && res.data.useraccounts.length > 0) {
            this.my.profile.useraccounts = res.data.useraccounts
          }
          return { data: res.data, status: res.status }
        }).catch((error) => {
          return { data: null, status: error.status }
        })

    },

    async loadSkill(idSkill: string) {
      const data = {
        idSkill
      }

      return Api.SendReq('/myskills/page', 'POST', data)
        .then((res) => {
          console.log('res.data', res)
          return res.data
        }).catch((error) => {
          return {}
        })

    },

    async loadGeneric(table: string, id: any, idnotif: string) {
      const data = {
        table,
        id,
        idnotif
      }

      return Api.SendReq('/mygen/page', 'POST', data)
        .then((res) => {
          return res.data
        }).catch((error) => {
          console.error('err', error)
          return {}
        })

    },

    updateDataFr(data: any) {
      console.log('updateDataFr', data)
      this.my.profile.friends = data.listFriends ? data.listFriends : []
      this.my.profile.req_friends = data.listRequestFriends ? data.listRequestFriends : []
      this.my.profile.asked_friends = data.listSentRequestFriends ? data.listSentRequestFriends : []

      this.my.profile.handshake = data.listHandShake ? data.listHandShake : []
    },

    async loadFriends() {
      return Api.SendReq('/users/friends', 'POST', null)
        .then((ris) => {
          this.updateDataFr(ris.data)
          return ris.data
        }).catch((error) => {
          return {}
        })

    },

    async loadGroups(username: string) {
      return Api.SendReq('/users/groups', 'POST', null)
        .then((res) => {
          return res.data
        }).catch((error) => {
          return {}
        })

    },

    async loadCircuits() {
      return Api.SendReq('/users/circuits', 'POST', null)
        .then((res) => {
          return res.data
        }).catch((error) => {
          return {}
        })

    },

    async loadAllAccounts() {
      return Api.SendReq('/account/loadall', 'POST', null)
        .then((res) => {
          return res.data
        }).catch((error) => {
          return {}
        })

    },

    async setFriendsCmd($q: any, t: any, usernameOrig: string, usernameDest: string, cmd: number, value: any) {
      return Api.SendReq('/users/friends/cmd', 'POST', { usernameOrig, usernameDest, cmd, value })
        .then((res) => {
          this.updateTables = true
          return res.data
        }).catch((error) => {
          tools.showNegativeNotif($q, t('db.recfailed'))
          return {}
        })

    },

    async setGroupsCmd($q: any, t: any, usernameOrig: string, groupnameDest: string, cmd: number, value: any) {
      return Api.SendReq('/users/groups/cmd', 'POST', { usernameOrig, groupnameDest, cmd, value })
        .then((res) => {
          this.updateTables = true
          return res.data
        }).catch((error) => {
          tools.showNegativeNotif($q, t('db.recfailed'))
          return {}
        })

    },

    async setCircuitCmd($q: any, t: any, usernameOrig: string, circuitname: string, cmd: number, value: any, extrarec?: any) {
      return await Api.SendReq('/users/circuits/cmd', 'POST', { usernameOrig, circuitname, cmd, value, extrarec })
        .then((res) => {
          this.updateTables = true
          if (res.data.recnotif) {
            const notifStore = useNotifStore()

            notifStore.updateRecNotif(res.data.recnotif)

            notifStore.updateArrRecNotifFromServer(res.data.arrrecnotif)
          }
          return res.data
        }).catch((error) => {
          tools.showNegativeNotif($q, t('db.recfailed'))
          return {}
        })

    },

    async sendMsgToBotTelegram($q: any, t: any, mydata: IMsgGlobParam, showmsgsent: boolean) {
      const globalStore = useGlobalStore()

      return Api.SendReq('/users/mgt', 'POST', { mydata })
        .then((res) => {
          console.log('res', res)

          let msgok = (res.data.nummsgsent === 1) ? res.data.nummsgsent + ' ' + t('cal.sendmsg_sent') : res.data.nummsgsent + ' ' + t('cal.sendmsgs_sent')
          if (mydata.cmd === shared_consts.MsgTeleg.SHARE_MSGREG) {
            if (tools.isTelegOk()) {
              msgok = t('cal.sendmsg_sent_sharedlink') + ' ' + tools.getBotName()
            } else {
              msgok = t('cal.sendmsg_sent_sharedlink_copied')
            }
            showmsgsent = true
          }

          if (showmsgsent && res.data.nummsgsent >= 0) {
            tools.showPositiveNotif($q, msgok)
            if (mydata.cmd === shared_consts.MsgTeleg.SHARE_MSGREG) {
              if (!tools.isTelegOk()) {
                //  console.log('text', res.data.text)
                tools.copyStringToClipboardSilent(res.data.text)
              }
              if (res.data.textsent) {
                return res.data.textsent
              }
            }
            return true
          }
          return false
        }).catch((error) => {
          tools.showNegativeNotif($q, t('cal.err_sendmsg'))
          return {}
        })
    },

    async importToServerCmd($q: any, t: any, cmd: number, data: any) {
      return Api.SendReq('/admin/import', 'POST', { cmd, data })
        .then((res) => {
          if (res) {
            tools.showPositiveNotif($q, t('db.recupdated'))
          }
        }).catch((error) => {
          tools.showNegativeNotif($q, t('db.recfailed'))
          return {}
        })

    },

    async setFavorite($q: any, t: any, id: any, table: string, myrec: any) {
      let value = false

      console.log('table', table)
      const tab = tools.getNumTabByTable(table)

      value = this.isFavorite(id, table) ? false : true

      return await Api.SendReq('/users/cmd', 'POST', { cmd: CMD_USER.SET_FAVORITE, id, tab, value })
        .then((res) => {
          if (res && res.data.state === 1) {
            if (!myrec.myfav)
              myrec.myfav = []
            this.my.profile.favorite.push({ id, tab })
            if (myrec)
              myrec.myfav.push({ username: this.my.username })
            tools.showPositiveNotif($q, t('cmd.favorite_set'))
          } else if (res && res.data.state === -1) {
            this.my.profile.favorite = tools.removeIObjectOnce(this.my.profile.favorite, { id, tab })
            if (myrec && myrec.myfav)
              myrec.myfav = myrec.myfav.filter((rec: IFavBook) => rec.username !== this.my.username)
            tools.showPositiveNotif($q, t('cmd.favorite_unset'))
          }
        }).catch((error) => {
          tools.showNegativeNotif($q, t('db.recfailed'))
          return {}
        })

    },

    isBookmarked(id: string, table: string) {
      const tab = tools.getNumTabByTable(table)
      const mybookmark = this.my.profile.bookmark.find((rec: IBookmark) => ((rec.id === id) && (rec.tab === tab)))
      return mybookmark
    },

    isFavorite(id: string, table: string) {
      const tab = tools.getNumTabByTable(table)
      const myfavorite = this.my.profile.favorite.find((rec: IFavorite) => ((rec.id === id) && (rec.tab === tab)))
      return myfavorite
    },

    async setBookmark($q: any, t: any, id: any, table: string, myrec: any) {
      let value = false

      const tab = tools.getNumTabByTable(table)

      value = this.isBookmarked(id, table) ? false : true

      return await Api.SendReq('/users/cmd', 'POST', { cmd: CMD_USER.SET_BOOKMARK, id, tab, value })
        .then((res) => {
          if (res && res.data.state === 1) {
            if (!myrec.mybook)
              myrec.mybook = []
            this.my.profile.bookmark.push({ id, tab })
            if (myrec)
              myrec.mybook.push({ username: this.my.username })
            tools.showPositiveNotif($q, t('cmd.bookmark_set'))
          } else if (res && res.data.state === -1) {
            this.my.profile.bookmark = tools.removeIObjectOnce(this.my.profile.bookmark, { id, tab })
            if (myrec && myrec.mybook)
              myrec.mybook = myrec.mybook.filter((rec: IFavBook) => rec.username !== this.my.username)
            tools.showPositiveNotif($q, t('cmd.bookmark_unset'))
          }
        }).catch((error) => {
          console.error('error', error)
          tools.showNegativeNotif($q, t('db.recfailed'))
          return {}
        })

    },

  },
})
