2523 lines
72 KiB
TypeScript
Executable File
2523 lines
72 KiB
TypeScript
Executable File
import { defineStore } from 'pinia';
|
|
|
|
import type {
|
|
ICircuit,
|
|
IMyCircuit,
|
|
IMsgGlobParam,
|
|
ISigninOptions,
|
|
ISignupOptions,
|
|
IUserFields,
|
|
IUserNotifType,
|
|
IUserProfile,
|
|
IUserState,
|
|
IAccount,
|
|
IColGridTable,
|
|
ISignupIscrizioneConacreisOptions,
|
|
ISignupIscrizioneArcadeiOptions,
|
|
IMovQuery,
|
|
} 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,
|
|
noFoto: false,
|
|
asked_circuits: [],
|
|
refused_circuits: [],
|
|
last_my_transactions: [],
|
|
manage_mycircuits: [],
|
|
useraccounts: [],
|
|
calc: { numGoodsAndServices: 0 },
|
|
resid_province: '',
|
|
resid_card: '',
|
|
},
|
|
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,
|
|
noFoto: false,
|
|
asked_circuits: [],
|
|
refused_circuits: [],
|
|
last_my_transactions: [],
|
|
manage_mycircuits: [],
|
|
useraccounts: [],
|
|
calc: { numGoodsAndServices: 0 },
|
|
resid_province: '',
|
|
resid_card: '',
|
|
};
|
|
|
|
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,
|
|
isGrafico: false,
|
|
isTeacher: false,
|
|
usersList: [],
|
|
countusers: 0,
|
|
lastparamquery: {},
|
|
updateTables: false,
|
|
lista_editori: null,
|
|
}),
|
|
|
|
getters: {
|
|
isServerError(): boolean {
|
|
return this.servercode === toolsext.ERR_SERVERFETCH;
|
|
},
|
|
|
|
listaEditori: (state: IUserState): any => {
|
|
return state.lista_editori;
|
|
},
|
|
|
|
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.showAlways) {
|
|
arrfinale.push(circuitname);
|
|
}
|
|
}
|
|
|
|
// Poi aggiungi i Circuiti ITALIA
|
|
for (const circuitname of arrout) {
|
|
const circuit = circuitStore.getCircuitByName(circuitname);
|
|
if (circuit && circuit.transactionsEnabled && circuit.showAlways) {
|
|
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(): boolean {
|
|
const globalStore = useGlobalStore();
|
|
|
|
if (
|
|
globalStore.site.confpages &&
|
|
globalStore.site.confpages?.enableRegMultiChoice
|
|
) {
|
|
return (
|
|
((this.isTelegIdOk() && this.isUsernameTelegOk()) || this.my.verified_email!) &&
|
|
this.my.verified_by_aportador!
|
|
);
|
|
} else {
|
|
//if (tools.getAskToVerifyReg()) {
|
|
if (
|
|
globalStore.site.confpages &&
|
|
globalStore.site.confpages?.enabledRegNeedTelegram
|
|
) {
|
|
return (
|
|
this.isTelegIdOk() &&
|
|
this.my.verified_by_aportador! &&
|
|
this.isUsernameTelegOk()
|
|
);
|
|
} else {
|
|
return this.my.verified_email!;
|
|
}
|
|
}
|
|
// 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 = '';
|
|
|
|
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 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 savenoCircIta(val: boolean) {
|
|
const mydata = {
|
|
_id: this.my._id,
|
|
dbop: 'noCircIta',
|
|
value: val,
|
|
};
|
|
if (this.my.profile.noCircIta !== val) {
|
|
this.my.profile.noCircIta = 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.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;
|
|
this.refreshToken = refreshToken;
|
|
if (!this.my.tokens) {
|
|
this.my.tokens = [];
|
|
}
|
|
this.my.tokens.push({
|
|
access: 'auth',
|
|
token: x_auth_token,
|
|
refreshToken,
|
|
data_login: tools.getDateNow(),
|
|
});
|
|
},
|
|
|
|
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 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: 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 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;
|
|
},
|
|
},
|
|
});
|