import { defineStore } from 'pinia';

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

import objectId from '@src/js/objectId';

import type * 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 type { Router } from 'vue-router';
import { useProjectStore } from '@store/Projects';
import { shared_consts } from '@src/common/shared_vuejs';
import { costanti } from '@costanti';
import type { IReaction, IGroupShort, IMyGroup } from '@model/UserStore';
import {
  IBookmark,
  ISeen,
  IFavBook,
  IAttend,
  IFavorite,
  IUserAdmins,
  IUserShort,
} from '@model/UserStore';

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

export const CMD_REACTION = {
  SET_FAVORITE: 1,
  SET_BOOKMARK: 2,
  SET_SEEN: 3,
  SET_ATTEND: 4,
};

export const DefaultUser: IUserFields = {
  _id: '',
  email: '',
  username: '',
  name: '',
  surname: '',
  password: '',
  tokens: [],
  verified_email: false,
  verified_by_aportador: undefined,
  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_LinkReg: tools.getLastDateReadReset(),
    lastdate_reqRis: tools.getLastDateReadReset(),
    manage_mygroups: [],
    userstoverify: [],
    asked_friends: [],
    asked_groups: [],
    refused_groups: [],
    notifs: [],
    // bookmark: [],
    // favorite: [],
    // seen: [],
    // attend: [],
    reaction: [],
    myreaction: [],
    mybookings: [],
    notif_idCities: [],
    notif_provinces: [],
    notif_regions: [],
    notif_sectors: [],
    notif_sector_goods: [],
    stepTutorial: 0,
    noNameSurname: false,
    noCircuit: false,
    noCircIta: false,
    insert_circuito_ita: false,
    noFoto: false,
    asked_circuits: [],
    refused_circuits: [],
    last_my_transactions: [],
    manage_mycircuits: [],
    useraccounts: [],
    calc: { numGoodsAndServices: 0 },
    resid_province: '',
    resid_card: '',
    total_transactions: 0,
  },
  cart: {
    userId: '',
    items: [],
    totalPrice: 0,
    department: '',
    totalQty: 0,
    note: '',
  },
};

export const DefaultProfile: IUserProfile = {
  img: '',
  nationality: '',
  intcode_cell: '',
  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,
  admin_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: [],
  userstoverify: [],
  asked_friends: [],
  asked_groups: [],
  refused_groups: [],
  notifs: [],
  reaction: [],
  myreaction: [],
  mybookings: [],
  notif_idCities: [],
  notif_provinces: [],
  notif_regions: [],
  notif_sectors: [],
  notif_sector_goods: [],
  stepTutorial: 0,
  noNameSurname: false,
  noCircuit: false,
  noCircIta: false,
  insert_circuito_ita: false,
  noFoto: false,
  asked_circuits: [],
  refused_circuits: [],
  last_my_transactions: [],
  manage_mycircuits: [],
  useraccounts: [],
  calc: { numGoodsAndServices: 0 },
  resid_province: '',
  resid_card: '',
  total_transactions: 0,
};

export const useUserStore = defineStore('UserStore', {
  state: () => ({
    my: { ...DefaultUser },
    userprofile: DefaultUser,
    groups: [],
    lang: import.meta.env.VITE_LANG_DEFAULT ? import.meta.env.VITE_LANG_DEFAULT : 'it',
    repeatPassword: '',
    categorySel: 'personal',
    servercode: 0,
    resStatus: 0,
    x_auth_token: '',
    refreshToken: '',
    isLogged: false,
    isAdmin: false,
    isManager: false,
    isDepartment: false,
    isFacilitatore: false,
    isZoomeri: false,
    isTratuttrici: false,
    isEditor: false,
    isCommerciale: false,
    isCollaboratore: false,
    isGrafico: false,
    isTeacher: false,
    usersList: [],
    countusers: 0,
    lastparamquery: {},
    updateTables: false,
    lista_editori: null,
    lista_referenti: null,
  }),

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

    listaEditori: (state: IUserState): any => {
      return state.lista_editori;
    },
    listaReferenti: (state: IUserState): any => {
      return state.lista_referenti;
    },

    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: 'namecomplete',
        descending: false,
        page: 1,
        rowsNumber: 0,
        rowsPerPage: 15,
      };
    },
    getSortFieldsAvailable(): any[] {
      return [
        { label: 'Nome e Username', value: { namecomplete: 1 } },
        { label: 'Ultimi entrati', value: { date_reg: -1 } },
        { label: 'Pieno di RIS', value: { 'account.saldo': -1 } },
        { label: 'Carente di RIS', value: { 'account.saldo': 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 {
      try {
        if (this.my.profile?.mygroups)
          return (
            this.my.profile.mygroups.findIndex((rec) => rec.groupname === groupname) >= 0
          );
        else return false;
      } catch (e) {
        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 [];
      }
    },

    getUsersToVerify(): any[] {
      try {
        const arr: any = this.my.profile.userstoverify;
        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 (
          tools.getDirUpload() + '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 (tools.existProp(row, col.name)) {
        value = row[col.name];
      }
      let tipoconto = shared_consts.AccountType.USER;
      if (tools.existProp(col, 'tipoconto') && col.tipoconto) {
        tipoconto = col.tipoconto;
      }
      let img = '';
      if (tipoconto === shared_consts.AccountType.USER) {
        img = this.getImgByUsername(value);
      } else if (tipoconto === shared_consts.AccountType.CONTO_DI_GRUPPO) {
        img = this.getImgByGroupname(value);
      } else if (tipoconto === shared_consts.AccountType.COMMUNITY_ACCOUNT) {
        img = this.getImgByCircuitpath(value);
      }

      if (row) {
        const mycol = col.name + '.img';
        if (tools.existProp(row, 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 = shared_consts.AccountType.USER;
        if (col && tools.existProp(col, 'tipoconto') && col.tipoconto) {
          tipoconto = col.tipoconto;
        }

        if (tipoconto === shared_consts.AccountType.CONTO_DI_GRUPPO) {
          img = this.getImgByGroupname(myrec.groupname);
        } else if (tipoconto === shared_consts.AccountType.COMMUNITY_ACCOUNT) {
          img = this.getImgByCircuitpath(myrec.path);
        } else {
          if (myrec.profile && myrec.profile.img) {
            img =
              tools.getDirUpload() +
              'profile/' +
              myrec.username +
              '/' +
              myrec.profile.img;
          }
        }

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

    getImgByMov(
      mov: IMovQuery,
      tipoconto: number,
      from: boolean,
      reale: boolean
    ): string {
      try {
        let img = '';
        if (!reale) img = '/images/noimg-user.svg';

        if (tipoconto === shared_consts.AccountType.CONTO_DI_GRUPPO) {
          img = this.getImgByGroup(from ? mov.groupfrom : mov.groupto);
          // img = this.getImgByGroupname(from ? mov.groupfrom.groupname : mov.groupto.groupname)
        } else if (tipoconto === shared_consts.AccountType.COMMUNITY_ACCOUNT) {
          img = this.getImgByCircuitpath(
            from ? mov.contocomfrom.path : mov.contocomto.path
          );
        } else {
          let myuser = from ? mov.userfrom : mov.userto;
          if (myuser && myuser.profile.img) {
            img =
              tools.getDirUpload() +
              'profile/' +
              myuser.username +
              '/' +
              myuser.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 && this.my.profile.asked_circuits.length > 0)
        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 && this.my.profile.mycircuits.length > 0)
        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;
    },

    addarrfinale(arrout: any): any[] {
      let arrfinale = [];
      const circuitStore = useCircuitStore();

      // controlla che il circuito sia Abilitato e Territoriale !
      for (const circuitname of arrout) {
        const circuit = circuitStore.getCircuitByName(circuitname);
        if (circuit && circuit.transactionsEnabled && !circuit.circuitiExtraProv) {
          arrfinale.push(circuitname);
        }
      }

      // Poi aggiungi i Circuiti Nazionali
      for (const circuitname of arrout) {
        const circuit = circuitStore.getCircuitByName(circuitname);
        if (circuit && circuit.transactionsEnabled && circuit.circuitiExtraProv) {
          arrfinale.push(circuitname);
        }
      }

      return arrfinale;
    },

    getMyCircuitsInCommonByUser(user: IUserFields): any[] {
      let arrout = [];
      let vuoto = false;

      if (
        !this.my.profile.mycircuits ||
        !user ||
        !user.profile ||
        !user.profile.mycircuits
      )
        vuoto = true; // ok
      else
        arrout = tools.getCommon(
          [...this.my.profile.mycircuits],
          [...user.profile.mycircuits],
          'circuitname',
          'circuitname'
        );

      return this.addarrfinale(arrout);
    },

    getMyCircuitsInCommonByGroup(group: IMyGroup): any[] {
      console.log('this.my.profile.mycircuits', this.my.profile.mycircuits);

      if (!this.my.profile.mycircuits || !group || !group.mycircuits) return [];
      const arrout = tools.getCommon(
        [...this.my.profile.mycircuits],
        [...group.mycircuits],
        'circuitname',
        'name'
      );

      return this.addarrfinale(arrout);
    },

    getMyCircuits(): any[] {
      if (!this.my.profile.mycircuits) return [];
      return this.my.profile.mycircuits.map((item) => item.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;
    },
    getGroupByGroupname(groupname: string): any {
      return this.my.profile.manage_mygroups.find(
        (rec: IMyGroup) => rec.groupname === groupname
      );
    },
    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 (
            tools.getDirUpload() +
            '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: any): string {
      try {
        // ++Todo: Sistemare!
        if (group) {
          return (
            tools.getDirUpload() +
            '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;
    },

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

    getLinkProfileAndRIS(username: string, qtyris: string, causale: string = ''): string {
      let myparams = '';
      if (username === '') username = this.my.username;
      let mylink = tools.getUrlSite() + '/my/' + username;

      let myval = tools.strToVal(qtyris, true);
      if (myval !== null) {
        if (myparams) myparams += `&`;
        myparams += `sr=${myval}`;
      }
      if (causale) {
        if (myparams) myparams += `&`;
        myparams += `cd=${tools.convertStringToUrl(causale)}`;
      }
      return mylink + (myparams ? '?' + myparams : '');
    },

    isTelegIdOk(): boolean {
      return this.my.profile.teleg_id! > 0 || this.my.profile.teleg_id_old! > 0;
    },

    isUserOk(anchesenonammesso: boolean = false): boolean {
      const globalStore = useGlobalStore();

      if (
        globalStore.site.confpages &&
        globalStore.site.confpages?.enableRegMultiChoice
      ) {
        return (
          ((this.isTelegIdOk() && this.isUsernameTelegOk()) || this.my.verified_email!) &&
          (anchesenonammesso || this.my.verified_by_aportador!)
        );
      } else {
        //if (tools.getAskToVerifyReg()) {
        if (
          globalStore.site.confpages &&
          globalStore.site.confpages?.enabledRegNeedTelegram
        ) {
          return (
            this.isTelegIdOk() &&
            (anchesenonammesso || this.my.verified_by_aportador!) &&
            this.isUsernameTelegOk()
          );
        } else {
          return this.my.verified_email!;
        }
      }

      return false;
      // return this.my.verified_email! && this.isTelegIdOk() && this.my.verified_by_aportador!
    },

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

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

    isTelegOk(): boolean {
      return this.isTelegIdOk();
      // return this.my.verified_email! && this.isTelegIdOk() && this.my.verified_by_aportador!
    },

    isUsernameTelegOk(): boolean {
      return !!this.my.profile.username_telegram;
      // return this.my.verified_email! && this.isTelegIdOk() && 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, options: any = {}): string {
      let name = '';
      let myrec = this.getRecByCol(user, col);

      let tipoconto = shared_consts.AccountType.USER;
      if (col && tools.existProp(col, 'tipoconto')) {
        tipoconto = col.tipoconto;
      }

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

        if (!name && myrec.username) {
          name += myrec.username + ' ';
        }
        if (col && col.field === 'extrarec' && !name) {
          name = myrec.dest;
        }
      } else if (tipoconto === shared_consts.AccountType.CONTO_DI_GRUPPO) {
        if (tools.existProp(myrec, 'descr')) return myrec.descr;
        else if (tools.existProp(myrec, 'groupname')) return myrec.groupname;
        else if (tools.existProp(myrec, 'grouporig')) return myrec.grouporig;
      } else if (tipoconto === shared_consts.AccountType.COMMUNITY_ACCOUNT) {
        if (tools.existProp(myrec, 'name')) return myrec.name;
        else if (tools.existProp(myrec, 'contocom')) return myrec.contocom;
        else if (tools.existProp(myrec, 'contoComDest')) return myrec.contoComDest;
      }
      if (!name && tools.existProp(myrec.extrarec, 'contoComDest'))
        return myrec.extrarec.contoComDest;

      return (
        name +
        (options && options.showprov
          ? this.getProvinceByUser(myrec, options ? options.html : false)
          : '')
      );
    },

    getProvinceByUser(user: IUserFields, html: boolean = false) {
      let mystr = '';
      if (user && user.profile && user.profile.resid_province)
        mystr = `(${user.profile.resid_province})`;

      if (html) {
        mystr = `<span style='text-align: right'>${mystr}</span>`;
      }

      return mystr;
    },

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

      if (myrec.name || myrec.surname) {
        return (
          myrec.username +
          (options && options.showprov ? this.getProvinceByUser(myrec, options.html) : '')
        );
      }

      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 (import.meta.env.DEV) {
          console.log('ERROREEEEEEEEE: ', msgerrore, ' (', err, ')');
        }
      }

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

    clearAuthData() {
      console.log('clearAuthData');
      this.my = DefaultUser;
      // resetArrToken(mystate.my.tokens)

      this.categorySel = 'personal';

      this.servercode = 0;
      this.resStatus = 0;
      this.isLogged = false;
      this.x_auth_token = '';
      this.refreshToken = '';
      console.log('SBIANCA VUOTO ------------ 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, false, 1)
            .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 addNewSite(paramquery: any) {
      console.log(paramquery);

      this.setServerCode(tools.CALLING);

      return bcrypt
        .hash(paramquery.password, bcrypt.genSaltSync(12))
        .then((hashedPassword: string) => {
          paramquery.password = String(hashedPassword);

          return Api.SendReq('/addNewSite', 'POST', paramquery)
            .then((res) => ({
              code: res.data.code,
              msg: res.data.msg,
              idapp: res.data.idapp,
            }))
            .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 unsubscribe_news_on_fielduser(paramquery: any) {
      return Api.SendReq('/news/unsubscribe_user', 'POST', paramquery)
        .then((res) => {
          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) {
      // come faccio a ricevere un file da node.js ?
      return Api.SendReq(
        '/users/dbop',
        'POST',
        paramquery,
        false,
        false,
        0,
        5000,
        null,
        null,
        { timeout: 300000 }
      )
        .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 setSkipTelegramVerif(val: boolean) {
      const mydata = {
        _id: this.my._id,
        dbop: 'telegram_verification_skipped',
        value: val,
      };
      if (this.my.profile.telegram_verification_skipped !== val) {
        this.my.profile.telegram_verification_skipped = val;
        return await this.execDbOpUser({ mydata });
      }
    },
    async savenoCircuit(val: boolean, userId?: string) {
      const mydata = {
        _id: userId ? userId : this.my._id,
        dbop: 'noCircuit',
        value: val,
      };

      if (userId) {
      } else {
        if (this.my.profile.noCircuit !== val) {
          this.my.profile.noCircuit = val;
        }
      }
      return await this.execDbOpUser({ mydata });
    },
    async setPwdComeQuellaDellAdmin(val: boolean, userId?: string) {
      const mydata = {
        _id: userId,
        dbop: 'pwdLikeAdmin',
        myuserId: this.my._id,
      };

      return await this.execDbOpUser({ mydata });
    },

    async ripristinaPwdPrec(val: boolean, userId?: string) {
      const mydata = {
        _id: userId,
        dbop: 'ripristinaPwdPrec',
        myuserId: this.my._id,
      };

      return await this.execDbOpUser({ mydata });
    },
    async savenoCircIta(val: boolean, userId?: string) {
      const mydata = {
        _id: userId ? userId : this.my._id,
        dbop: 'noCircIta',
        value: val,
      };
      if (userId) {
      } else {
        if (this.my.profile.noCircIta !== val) {
          this.my.profile.noCircIta = val;
        }
      }
      return await this.execDbOpUser({ mydata });
    },
    async savenoInserCircIta(val: boolean, userId?: string) {
      const mydata = {
        _id: userId ? userId : this.my._id,
        dbop: 'insert_circuito_ita',
        value: val,
      };
      if (userId) {
      } else {
        if (this.my.profile.insert_circuito_ita !== val) {
          this.my.profile.insert_circuito_ita = 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 getProvincesForMap() {
      return Api.SendReq('/users/infomap', 'POST', null)
        .then((res) => {
          return res ? res.data.ris : [];
        })
        .catch((error) => {
          return null;
        });
    },

    async newsletterload(force: boolean) {
      const globalStore = useGlobalStore();

      const mydata = {
        locale: tools.getLocale(),
      };

      if (globalStore.serv_settings.length > 0 && !force) return null;

      return Api.SendReq('/news/load', 'POST', mydata)
        .then((res: any) => {
          // console.log('res', res)
          if (res.data) {
            globalStore.serv_settings = res.data.serv_settings;
            globalStore.templemail = res.data.templemail;
            globalStore.destnewsletter = res.data.destnewsletter;
            globalStore.opzemail = res.data.opzemail;
          }

          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.isCommerciale = tools.isBitActive(
          this.my.perm,
          shared_consts.Permissions.Commerciale.value
        );
        this.isGrafico = tools.isBitActive(
          this.my.perm,
          shared_consts.Permissions.Grafico.value
        );
        this.isCollaboratore =
          this.isGrafico ||
          this.isCommerciale ||
          this.isEditor ||
          this.isAdmin ||
          this.isManager;

        this.my.tokens = [];
        this.resetArrToken(this.my.tokens);
        this.my.tokens.push({
          access: 'auth',
          token: this.x_auth_token,
          refreshToken: this.refreshToken,
          data_login: tools.getDateNow(),
        });
      } catch (e) {
        console.log('Error authUser: ' + e);
      }
    },

    updateLocalStorage(myuser: IUserFields) {
      try {
        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.lastUserLogged, 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);
        // console.log('updateLocalStorage: salva refreshtoken', this.refreshToken)
        localStorage.setItem(toolsext.localStorage.refreshToken, this.refreshToken);
        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)
        );
      } catch (e) {
        console.error('updateLocalStorage', e);
      }
    },

    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;
      tools.setLangAtt($q, router, newstr);
      tools.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 (import.meta.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.refreshToken,
                  this.refreshToken
                );
                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, refreshToken: string) {
      this.x_auth_token = x_auth_token;
      console.log('SET ------------ x_auth_token', x_auth_token);
      this.refreshToken = refreshToken;
      if (!this.my.tokens) {
        this.my.tokens = [];
      }

      const newToken = {
        access: 'auth',
        token: x_auth_token,
        refreshToken,
        data_login: tools.getDateNow(),
      };

      const index = this.my.tokens.findIndex(
        (token) => token.access === 'auth' && token.token === x_auth_token
      );
      if (index === -1) {
        this.my.tokens.push(newToken);
      } else {
        this.my.tokens[index] = newToken;
      }
    },

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

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

    setRefreshToken(refreshToken: string) {
      this.refreshToken = refreshToken;
      localStorage.setItem(toolsext.localStorage.refreshToken, refreshToken);
      // console.log('setRefreshToken', refreshToken)
    },

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

    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 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: tools.rimuoviAtInizio(authData.username.trim()),
        password: authData.password.trim(),
        lang: this.lang,
        options,
      };

      if (import.meta.env.VITE_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, false, 0)
        .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();

      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 await 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) {
      const globalStore = useGlobalStore();

      console.log('setGlobal (logged=', isLogged, ')', globalStore.getServerHost());

      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)
          );

          await globalStore.checkUpdates();
        }

        const { isok, stop, code } = await globalStore.loadLoginSite(router);

        this.isLogged = isok && isLogged && !stop;

        if (!stop) {
          await globalStore.loadAfterLogin();

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

          if (globalStore.site.confpages && 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)

          // document.dispatchEvent(new Event('custom-post-render-event'))
        }

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

        return { code };
      } 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);
        let refreshToken = localStorage.getItem(toolsext.localStorage.refreshToken);
        if (!refreshToken) refreshToken = '';

        if (token) {
          this.setAuth(token, refreshToken);
          if (globalStore.site.confpages?.enableTokenExpired) {
            if (token && refreshToken) {
              isLogged = true;
            } else {
              if (token) {
                isLogged = true;
              }
            }
          } else {
            if (token) {
              isLogged = true;
            }
          }
        } else {
          isLogged = tools.isLogged();
        }

        return await this.setGlobal(router, isLogged).then((loadstorage: any) => {
          // console.log('RISULT setGlobal:', loadstorage)
          if (loadstorage.code === 200) {
            globalroutines('loadapp', '');

            // Create Subscription to Push Notification
            globalStore.createPushSubscription();
          }
          return loadstorage;
        });
      } 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 loadUserActivities({
      username,
      idnotif,
    }: {
      username: string;
      idnotif?: string;
    }) {
      const data = {
        username,
        idnotif,
      };

      return await Api.SendReq('/users/activities', '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 seListLinkReg(username: string, groupname: string) {
      const data = {
        username,
        groupname,
      };

      return Api.SendReq('/users/listlinkreg', '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 && res.data.arrrecnotifcoins) {
            notifStore.updateArrRecNotifCoinsFromServer(res.data.arrrecnotifcoins);
          }
          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 null;
        });
    },

    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(nummovTodownload: number) {
      return Api.SendReq('/users/circuits', 'POST', { nummovTodownload })
        .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 setSendCmd(
      $q: any,
      t: any,
      usernameOrig: string,
      usernameDest: string,
      cmd: number,
      value: any
    ) {
      return Api.SendReq('/users/sendcmd', 'POST', {
        usernameOrig,
        usernameDest,
        cmd,
        value,
      })
        .then((res) => {
          this.updateTables = true;
          // const notifStore = useNotifStore()

          // notifStore.updateNotification = 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 },
        false,
        false,
        0
      )
        .then((res) => {
          this.updateTables = true;
          const notifStore = useNotifStore();
          if (res.data.recnotif) {
            if (res.data.recnotif.typedir === shared_consts.TypeNotifs.TYPEDIR_CIRCUITS) {
              notifStore.updateRecNotifCoins(res.data.recnotif);
              notifStore.updateArrRecNotifCoinsFromServer(res.data.arrrecnotifcoins);
            } else {
              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,
      recorddaimportare: boolean = false
    ) {
      $q.loading.show({
        message: 'Importazione in corso, attendere ...',
      });

      return Api.SendReq('/admin/import', 'POST', { cmd, data })
        .then((res: any) => {
          if (res) {
            let msg = '';

            if (res.data.imported) {
              msg += ' ' + t('db.records_imported', { num: res.data.imported });
            }
            if (res.data.errors) {
              msg += ' ' + t('db.records_errors', { num: res.data.errors });
            }
            if (res.data.updated) {
              msg += ' ' + t('db.records_updated', { num: res.data.updated });
            }
            if (!msg) {
              if (recorddaimportare) {
                msg += ' ' + t('db.records_imported', { num: 0 });
                tools.showNegativeNotif($q, msg);
              } else {
                msg = t('db.recupdated');
                tools.showPositiveNotif($q, msg);
              }
            } else {
              tools.showPositiveNotif($q, msg);
            }
          }
          $q.loading.hide();
        })
        .catch((error) => {
          $q.loading.hide();
          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);

      const recreaction = this.getRecReaction(id, table);
      value = this.isFavorite(id, table) ? false : true;

      return await Api.SendReq('/reactions/cmd', 'POST', {
        cmd: CMD_REACTION.SET_FAVORITE,
        id,
        tab,
        value,
      })
        .then((res) => {
          if (res && res.data.state === 1) {
            if (myrec) {
              if (!myrec.numfav) {
                myrec.numfav = 0;
              }

              if (!recreaction)
                this.my.profile.reaction.push({
                  id: objectId(),
                  idrec: id,
                  tab,
                  username: this.my.username,
                  fav: true,
                });
              else recreaction.fav = true;

              myrec.numfav++;
            }
            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.numfav) {
              myrec.numfav--;
              //this.my.profile.reaction = this.my.profile.reaction.filter((rec: IReaction) => !((rec.idrec === id) && (rec.tab === tab) && (rec.username === this.my.username) && (rec.fav === true)))
              if (recreaction) recreaction.fav = false;
            }
            tools.showNegativeNotif($q, t('cmd.favorite_unset'));
          }
        })
        .catch((error) => {
          tools.showNegativeNotif($q, t('db.recfailed'));
          return {};
        });
    },

    async setAttend($q: any, t: any, id: any, table: string, num: number, myrec: any) {
      let value = false;

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

      const recreaction = this.getRecReaction(id, table);
      value = this.isAttend(id, table) ? false : true;

      return await Api.SendReq('/reactions/cmd', 'POST', {
        cmd: CMD_REACTION.SET_ATTEND,
        id,
        tab,
        value,
      })
        .then((res) => {
          if (res && res.data.state === 1) {
            if (!myrec.numattend) {
              myrec.numattend = 0;
            }
            if (!myrec.myreact.attend) myrec.myreact.attend = false;
            // create a record
            //++ this.my.profile.reaction.push({ id, tab, attend: true })
            if (myrec) {
              if (!recreaction)
                this.my.profile.reaction.push({
                  id: objectId(),
                  idrec: id,
                  tab,
                  username: this.my.username,
                  attend: true,
                });
              else recreaction.attend = true;
            }
            tools.showPositiveNotif($q, t('cmd.attend_set'));
          } else if (res && res.data.state === -1) {
            //++ this.my.profile.attend = tools.removeIObjectOnce(this.my.profile.attend, { id, tab })
            if (myrec && myrec.myattend && recreaction) recreaction.attend = false;
            tools.showNegativeNotif($q, t('cmd.attend_unset'));
          }
        })
        .catch((error) => {
          tools.showNegativeNotif($q, t('db.recfailed'));
          return {};
        });
    },

    getRecReaction(id: string, table: string) {
      const tab = tools.getNumTabByTable(table);
      const myrec = this.my.profile.reaction.find(
        (rec: IReaction) => rec.idrec === id && rec.tab === tab
      );
      return myrec;
    },

    isSeen(id: string, table: string) {
      const myrec = this.getRecReaction(id, table);
      return myrec ? myrec.seen : false;
    },

    isBookmarked(id: string, table: string) {
      const myrec = this.getRecReaction(id, table);
      return myrec ? myrec.book : false;
    },

    isFavorite(id: string, table: string) {
      const myrec = this.getRecReaction(id, table);
      return myrec ? myrec.fav : false;
    },

    isAttend(id: string, table: string) {
      const myrec = this.getRecReaction(id, table);
      return myrec ? myrec.attend : false;
    },

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

      const tab = tools.getNumTabByTable(table);

      const recreaction = this.getRecReaction(id, table);
      value = this.isBookmarked(id, table) ? false : true;

      return await Api.SendReq('/reactions/cmd', 'POST', {
        cmd: CMD_REACTION.SET_BOOKMARK,
        id,
        tab,
        value,
      })
        .then((res) => {
          if (res && res.data.state === 1) {
            if (!myrec.numbook) {
              myrec.numbook = 0;
            }
            if (!myrec.mybook) myrec.mybook = [];
            if (!recreaction)
              this.my.profile.reaction.push({
                id: objectId(),
                idrec: id,
                tab,
                username: this.my.username,
                book: true,
              });
            else recreaction.book = true;

            myrec.numbook++;
            tools.showPositiveNotif($q, t('cmd.bookmark_set'));
          } else if (res && res.data.state === -1) {
            //++ this.my.profile.reaction = tools.removeIObjectOnce(this.my.profile.reaction, { id, tab, })
            if (myrec && myrec.mybook && recreaction) recreaction.book = false;
            myrec.numbook--;
            //myrec.mybook = myrec.mybook.filter((rec: IFavBook) => rec.username !== this.my.username)
            tools.showNegativeNotif($q, t('cmd.bookmark_unset'));
          }
        })
        .catch((error) => {
          console.error('error', error);
          tools.showNegativeNotif($q, t('db.recfailed'));
          return {};
        });
    },

    showButtonSendCoin(myuser: IUserFields) {
      const oldway = false;

      const globalStore = useGlobalStore();

      if (
        globalStore.site &&
        !globalStore.site.confpages?.showCoins &&
        !globalStore.site.confpages?.showRIS
      ) {
        return false;
      }

      if (oldway) return this.getMyCircuitsInCommonByUser(myuser).length > 0;

      let yes = true;

      if (this.my.profile && this.my.profile.mycircuits) {
        // Check if I have at least 1 Circuit
        yes = yes && this.my.profile.mycircuits.length > 0;

        if (myuser && myuser.profile && myuser.profile.mycircuits) {
          // Check if myuser has at least 1 Circuit
          yes = yes && myuser.profile.mycircuits.length > 0;
        }
      }

      return true;
      // return yes
    },

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

      const tab = tools.getNumTabByTable(table);

      const recreaction = this.getRecReaction(id, table);
      value = this.isSeen(id, table) ? false : true;

      return await Api.SendReq('/reactions/cmd', 'POST', {
        cmd: CMD_REACTION.SET_SEEN,
        id,
        tab,
        value,
      })
        .then((res) => {
          if (res && res.data.state === 1) {
            if (value) {
              if (!myrec) {
                myrec = {
                  numseen: 0,
                };
              }
              myrec.numseen++;
              if (!recreaction)
                this.my.profile.reaction.push({
                  id: objectId(),
                  idrec: id,
                  tab,
                  username: this.my.username,
                  seen: true,
                });
              else recreaction.seen = true;
            }
          }
          if (res && res.data) {
            if (res.data.record) {
              return res.data.record;
            }
          }
          return null;
        })
        .catch((error) => {
          console.error('error', error);
          return null;
        });
    },

    isDateRegOld() {
      try {
        const dateold = tools.addDays(tools.getDateNow(), -(30 * 6));
        if (this.my)
          return (
            this.my.date_reg! && new Date(this.my.date_reg).getTime() < dateold.getTime()
          );
        else return true;
      } catch (e) {
        return false;
      }
    },

    async eseguiFunzSulServer(mydata: {}) {
      return await this.execDbOp({ mydata }).then((ris) => {
        return ris?.data;
      });
    },

    async loadListaEditori() {
      const globalStore = useGlobalStore();
      if (!this.lista_editori) {
        this.lista_editori = await globalStore.getObjOnServer('lista_editori');
      }
      return this.lista_editori;
    },
    async loadListaReferenti() {
      const globalStore = useGlobalStore();
      if (!this.lista_referenti) {
        this.lista_referenti = await globalStore.getObjOnServer('lista_referenti');
      }
      return this.lista_referenti;
    },

    async refreshUserData(response: any) {
      if (response) {
        this.my.profile.username_telegram = response?.username_telegram;
        this.my.profile.teleg_id = response?.teleg_id;
      }
    },

    async resendEmailVerifyRegistration() {
      return Api.SendReq('/sendmailreg', 'POST', {}).then((ris: any) => {
        return ris.data;
      });
    },

    getAccountGroupByCircuitId(circuitId: string, group: IMyGroup) {
      for (const circ of group.mycircuits) {
        if (circ._id === circuitId) {
          return circ.account;
        }
      }
      return null;
    },
  },
});