1341 lines
39 KiB
TypeScript
Executable File
1341 lines
39 KiB
TypeScript
Executable File
import { defineStore } from 'pinia'
|
|
|
|
import {
|
|
ICircuit,
|
|
IMyCircuit,
|
|
IFriends,
|
|
IMsgGlobParam,
|
|
ISigninOptions,
|
|
ISignupOptions,
|
|
IUserFields,
|
|
IUserNotifType,
|
|
IUserProfile,
|
|
IUserState,
|
|
IAccount,
|
|
IColGridTable,
|
|
ISignupIscrizioneConacreisOptions,
|
|
ISignupIscrizioneArcadeiOptions,
|
|
} from '@src/model'
|
|
import { tools } from '@store/Modules/tools'
|
|
import translate from '@src/globalroutines/util'
|
|
import { ICallResult, ILinkReg, IResult, IToken } from '@model/other'
|
|
|
|
import * as Types from '@src/store/Api/ApiTypes'
|
|
import { useGlobalStore } from '@store/globalStore'
|
|
import { serv_constants } from '@store/Modules/serv_constants'
|
|
import { Api } from '@api'
|
|
import { toolsext } from '@store/Modules/toolsext'
|
|
import { static_data } from '@src/db/static_data'
|
|
|
|
|
|
import bcrypt from 'bcryptjs'
|
|
|
|
import { useTodoStore } from '@store/Todos'
|
|
import { Router } from 'vue-router'
|
|
import { useProjectStore } from '@store/Projects'
|
|
import { shared_consts } from '@/common/shared_vuejs'
|
|
import { costanti } from '@costanti'
|
|
import { IMyGroup } from '@model/UserStore'
|
|
|
|
import globalroutines from '../globalroutines/index'
|
|
import { useNotifStore } from '@store/NotifStore'
|
|
|
|
export const DefaultUser: IUserFields = {
|
|
_id: '',
|
|
email: '',
|
|
username: '',
|
|
name: '',
|
|
surname: '',
|
|
password: '',
|
|
tokens: [],
|
|
verified_email: false,
|
|
verified_by_aportador: false,
|
|
aportador_solidario: '',
|
|
made_gift: false,
|
|
profile: {
|
|
img: '',
|
|
teleg_id: 0,
|
|
saw_zoom_presentation: false,
|
|
ask_zoom_partecipato: false,
|
|
saw_and_accepted: false,
|
|
qualified: false,
|
|
qualified_2invitati: false,
|
|
socio: false,
|
|
socioresidente: false,
|
|
myshares: [],
|
|
friends: [],
|
|
req_friends: [],
|
|
mygroups: [],
|
|
mycircuits: [],
|
|
manage_mygroups: [],
|
|
asked_friends: [],
|
|
asked_groups: [],
|
|
refused_groups: [],
|
|
notifs: [],
|
|
notif_idCities: [],
|
|
notif_provinces: [],
|
|
notif_regions: [],
|
|
notif_sectors: [],
|
|
notif_sector_goods: [],
|
|
asked_circuits: [],
|
|
refused_circuits: [],
|
|
manage_mycircuits: [],
|
|
useraccounts: [],
|
|
calc: { numGoodsAndServices: 0 },
|
|
},
|
|
cart: {
|
|
userId: '',
|
|
items: [],
|
|
totalPrice: 0,
|
|
department: '',
|
|
totalQty: 0,
|
|
note: '',
|
|
},
|
|
}
|
|
|
|
export const DefaultProfile: IUserProfile = {
|
|
img: '',
|
|
nationality: '',
|
|
intcode_cell: '',
|
|
cell: process.env.TEST_CELL || '',
|
|
dateofbirth: null,
|
|
sex: 0,
|
|
country_pay: '',
|
|
email_paypal: '',
|
|
payeer_id: '',
|
|
advcash_id: '',
|
|
revolut: '',
|
|
link_payment: '',
|
|
note_payment: '',
|
|
username_telegram: '',
|
|
teleg_id: 0,
|
|
teleg_checkcode: 0,
|
|
my_dream: '',
|
|
manage_telegram: false,
|
|
saw_zoom_presentation: false,
|
|
ask_zoom_partecipato: false,
|
|
saw_and_accepted: false,
|
|
socio: false,
|
|
socioresidente: false,
|
|
paymenttypes: [],
|
|
qualified: false,
|
|
qualified_2invitati: false,
|
|
myshares: [],
|
|
friends: [],
|
|
req_friends: [],
|
|
mygroups: [],
|
|
mycircuits: [],
|
|
manage_mygroups: [],
|
|
asked_friends: [],
|
|
asked_groups: [],
|
|
refused_groups: [],
|
|
notifs: [],
|
|
notif_idCities: [],
|
|
notif_provinces: [],
|
|
notif_regions: [],
|
|
notif_sectors: [],
|
|
notif_sector_goods: [],
|
|
|
|
asked_circuits: [],
|
|
refused_circuits: [],
|
|
manage_mycircuits: [],
|
|
useraccounts: [],
|
|
calc: { numGoodsAndServices: 0 },
|
|
}
|
|
|
|
export const useUserStore = defineStore('UserStore', {
|
|
state: () => ({
|
|
my: { ...DefaultUser },
|
|
groups: [],
|
|
lang: process.env.LANG_DEFAULT ? process.env.LANG_DEFAULT : 'it',
|
|
repeatPassword: '',
|
|
categorySel: 'personal',
|
|
servercode: 0,
|
|
resStatus: 0,
|
|
x_auth_token: '',
|
|
isLogged: false,
|
|
isAdmin: false,
|
|
isManager: false,
|
|
isDepartment: false,
|
|
isFacilitatore: false,
|
|
isZoomeri: false,
|
|
isTratuttrici: false,
|
|
isEditor: false,
|
|
isTeacher: false,
|
|
usersList: [],
|
|
countusers: 0,
|
|
lastparamquery: {},
|
|
updateTables: false,
|
|
}),
|
|
|
|
getters: {
|
|
|
|
isServerError(): boolean {
|
|
return (this.servercode === toolsext.ERR_SERVERFETCH)
|
|
},
|
|
|
|
getServerCode: (state: IUserState): number => (state.servercode ? state.servercode : 0),
|
|
getMsg: (state: IUserState): string => (state.msg ? state.msg : ''),
|
|
|
|
getUsersList: (mystate: IUserState) => {
|
|
return mystate.usersList
|
|
},
|
|
|
|
IsMyFriend: (mystate: IUserState) => (userIdOwner: string): boolean => {
|
|
// ++TODO Check if userIdOwner is my friend
|
|
// userIdOwner is my friend ?
|
|
return true
|
|
},
|
|
|
|
|
|
IsMyGroup: (mystate: IUserState) => (userIdOwner: string): boolean => {
|
|
// ++TODO Check if userIdOwner is on my groups
|
|
// userIdOwner is on my groups ?
|
|
return true
|
|
},
|
|
|
|
|
|
isTokenInvalid: (state: IUserState) => {
|
|
try {
|
|
return (state.my.tokens!.length <= 0)
|
|
} catch (e) {
|
|
return true
|
|
}
|
|
},
|
|
|
|
isUserInvalid: (state: IUserState): boolean => {
|
|
try {
|
|
return (state.my._id === undefined) || (state.my._id.trim() === '')
|
|
} catch (e) {
|
|
return true
|
|
}
|
|
},
|
|
|
|
},
|
|
|
|
actions: {
|
|
IsMyFriendByUsername(username: string): boolean {
|
|
if (this.my.profile.friends)
|
|
return this.my.profile.friends.findIndex((rec) => rec.username === username) >= 0
|
|
else
|
|
return false
|
|
},
|
|
|
|
IsMyGroupByGroupname(groupname: string): boolean {
|
|
if (this.my.profile.mygroups)
|
|
return this.my.profile.mygroups.findIndex((rec) => rec.groupname === groupname) >= 0
|
|
else
|
|
return false
|
|
},
|
|
|
|
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: IMyGroup) => 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: IMyGroup) => rec.groupname === groupname) >= 0
|
|
else
|
|
return false
|
|
},
|
|
|
|
getUserByUsername(username: string): IUserFields | null {
|
|
// Check if is this User!
|
|
if (this.my.username === username) return this.my
|
|
|
|
let trovato: any = null
|
|
if (this.usersList) trovato = this.usersList.find((item: any) => item.username === username)
|
|
|
|
if (trovato) {
|
|
if (trovato.surname === 'undefined')
|
|
trovato.surname = ''
|
|
if (trovato.name === 'undefined')
|
|
trovato.name = ''
|
|
}
|
|
|
|
return (trovato) || null
|
|
},
|
|
|
|
getImgByUsername(username: string): string {
|
|
if (username === '') return ''
|
|
// Check if is this User!
|
|
const myrec = this.getUserByUsername(username)
|
|
if (myrec && myrec.profile && !!myrec.profile.img && myrec.profile.img !== '' && myrec.profile.img !== 'undefined') {
|
|
return costanti.DIR_UPLOAD + 'profile/' + this.my.username + '/' + myrec.profile.img
|
|
}
|
|
return ''
|
|
},
|
|
|
|
getImgUserByUsername(username: string): string {
|
|
const img = this.getImgByUsername(username)
|
|
return img ? img : 'images/noimg-user.svg'
|
|
},
|
|
|
|
getImgUserByRow(row: any, col: IColGridTable): string {
|
|
let value = ''
|
|
|
|
if (row.hasOwnProperty(col.name)) {
|
|
value = row[col.name]
|
|
}
|
|
let img = this.getImgByUsername(value)
|
|
if (row) {
|
|
const mycol = col.name + '.img'
|
|
if (row.hasOwnProperty(mycol)) {
|
|
img = row[mycol]
|
|
}
|
|
}
|
|
return img ? img : 'images/noimg-user.svg'
|
|
},
|
|
|
|
getImgByProfile(userparam: any, reale: any = false, col: any = null): string {
|
|
try {
|
|
let myrec = this.getRecByCol(userparam, col)
|
|
|
|
if (myrec.profile && myrec.profile.img) {
|
|
return costanti.DIR_UPLOAD + 'profile/' + myrec.username + '/' + myrec.profile.img
|
|
} else {
|
|
return 'images/noimg-user.svg'
|
|
}
|
|
} catch (e) {
|
|
//
|
|
}
|
|
if (!reale)
|
|
return 'images/noimg-user.svg'
|
|
else
|
|
return ''
|
|
},
|
|
|
|
|
|
IsAskedCircuitByName(name: string): boolean {
|
|
if (this.my.profile.asked_circuits)
|
|
return this.my.profile.asked_circuits.findIndex((rec: ICircuit) => rec.name === name) >= 0
|
|
else
|
|
return false
|
|
},
|
|
|
|
|
|
IsMyCircuitByName(circuitname: string): boolean {
|
|
|
|
if (this.my.profile.mycircuits)
|
|
return this.my.profile.mycircuits.findIndex((rec: IMyCircuit) => rec.circuitname === circuitname) >= 0
|
|
else
|
|
return false
|
|
|
|
},
|
|
|
|
IsMyCircuitByUser(user: IUserFields): any[] {
|
|
|
|
if (!this.my.profile.mycircuits || (!user || !user.profile || !user.profile.mycircuits))
|
|
return []
|
|
return tools.getCommon([...this.my.profile.mycircuits], [...user.profile.mycircuits], 'circuitname')
|
|
},
|
|
|
|
|
|
getAccountByCircuitId(circuitId: string): any {
|
|
if (this.my.profile.useraccounts) {
|
|
return this.my.profile.useraccounts.find((rec: IAccount) => rec.circuitId === circuitId)
|
|
}
|
|
return null
|
|
},
|
|
|
|
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): string {
|
|
|
|
try {
|
|
if (circ.photos && circ.photos.length > 0)
|
|
return costanti.DIR_UPLOAD + 'circuits/' + circ.path + '/' + circ.photos[0].imagefile
|
|
} catch (e) {
|
|
//
|
|
}
|
|
return 'images/noimg.png'
|
|
},
|
|
|
|
getImgByGroup(group: IMyGroup): string {
|
|
|
|
try {
|
|
// ++Todo: Sistemare!
|
|
return costanti.DIR_UPLOAD + 'mygroups/' + group.groupname + '/' + group.photos[0].imagefile
|
|
} catch (e) {
|
|
//
|
|
}
|
|
return 'images/noimg.png'
|
|
},
|
|
|
|
getRefLink(username: string): string {
|
|
if (username === '')
|
|
username = this.my.username
|
|
return tools.getUrlSite() + '/signup/' + username
|
|
},
|
|
|
|
isUserOk(): boolean {
|
|
const globalStore = useGlobalStore()
|
|
|
|
if (globalStore.site.confpages.enableRegMultiChoice) {
|
|
return ((this.my.profile.teleg_id! > 0 && this.isUsernameTelegOk()) || this.my.verified_email!) && this.my.verified_by_aportador!
|
|
} else {
|
|
return this.my.profile.teleg_id! > 0 && this.my.verified_by_aportador! && this.isUsernameTelegOk()
|
|
}
|
|
// return this.my.verified_email! && this.my.profile.teleg_id! > 0 && this.my.verified_by_aportador!
|
|
},
|
|
|
|
isUserWaitingVerifAportador(): boolean {
|
|
return !this.my.verified_by_aportador
|
|
},
|
|
|
|
isOldRegNotFinished(): boolean {
|
|
return tools.isLogged() && ((!this.my.profile.teleg_id || this.my.profile.teleg_id <= 0) || !this.isUsernameTelegOk())
|
|
// return this.my.verified_email! && this.my.profile.teleg_id! > 0 && this.my.verified_by_aportador!
|
|
},
|
|
|
|
isTelegOk(): boolean {
|
|
return this.my.profile.teleg_id! > 0
|
|
// return this.my.verified_email! && this.my.profile.teleg_id! > 0 && this.my.verified_by_aportador!
|
|
},
|
|
|
|
isUsernameTelegOk(): boolean {
|
|
return !!this.my.profile.username_telegram
|
|
// return this.my.verified_email! && this.my.profile.teleg_id! > 0 && this.my.verified_by_aportador!
|
|
},
|
|
|
|
getNameSurnameByUserId(userId: string): string {
|
|
|
|
const user = this.getUserByUserId(userId)
|
|
if (user) return `${user.name} ` + !!user.surname ? user.surname : ''
|
|
return `(${userId})`
|
|
},
|
|
|
|
getNameSurnameByUsername(username: string): string {
|
|
const user = this.getUserByUsername(username)
|
|
if (user) return `${user.name} ` + !!user.surname ? user.surname : ''
|
|
return `(${username})`
|
|
},
|
|
|
|
getRecByCol(user: any, col: any = null) {
|
|
let myrec = user
|
|
if (col && col.field === 'userto')
|
|
myrec = user.userto
|
|
if (col && col.field === 'userfrom')
|
|
myrec = user.userfrom
|
|
|
|
return myrec
|
|
},
|
|
|
|
getNameToShow(user: any, col: any = null): string {
|
|
let name = ''
|
|
let myrec = this.getRecByCol(user, col)
|
|
|
|
if (!!myrec.name)
|
|
name = myrec.name + ' '
|
|
if (!!myrec.surname)
|
|
name += myrec.surname + ' '
|
|
|
|
if (!name) {
|
|
name += myrec.username + ' '
|
|
}
|
|
if (col && col.field === 'extrarec' && !name) {
|
|
name = myrec.dest
|
|
}
|
|
|
|
return name
|
|
},
|
|
|
|
getUserNameOnlyIfToShow(user: any, col: any = null): string {
|
|
let myrec = this.getRecByCol(user, col)
|
|
|
|
if (myrec.name || myrec.surname) {
|
|
return myrec.username
|
|
}
|
|
|
|
return ''
|
|
},
|
|
|
|
getUserByUserId(userId: string): IUserFields | null {
|
|
// Check if is this User!
|
|
if (this.my._id === userId) return this.my
|
|
|
|
let trovato: any = null
|
|
|
|
if (this.usersList) trovato = this.usersList.find((item: any) => item._id === userId)
|
|
|
|
if (trovato) {
|
|
if (trovato.surname === undefined)
|
|
trovato.surname = ''
|
|
if (trovato.name === undefined)
|
|
trovato.name = ''
|
|
}
|
|
|
|
return (trovato) || null
|
|
},
|
|
|
|
getMsgError(err: number): string {
|
|
let msgerrore = ''
|
|
if (err !== tools.OK) {
|
|
msgerrore = `Error [${this.servercode}]: `
|
|
if (this.servercode === toolsext.ERR_SERVERFETCH) {
|
|
msgerrore = translate('fetch.errore_server')
|
|
} else {
|
|
msgerrore = translate('fetch.errore_generico')
|
|
}
|
|
|
|
if (process.env.DEV) {
|
|
console.log('ERROREEEEEEEEE: ', msgerrore, ' (', err, ')')
|
|
}
|
|
}
|
|
|
|
// return { code: this.servercode, msg: msgerrore }
|
|
return msgerrore
|
|
},
|
|
|
|
|
|
clearAuthData() {
|
|
this.my = DefaultUser
|
|
// resetArrToken(mystate.my.tokens)
|
|
|
|
this.categorySel = 'personal'
|
|
|
|
this.servercode = 0
|
|
this.resStatus = 0
|
|
this.isLogged = false
|
|
this.x_auth_token = ''
|
|
|
|
return true
|
|
},
|
|
|
|
async resetpwd(paramquery: any) {
|
|
|
|
const mydata = { ...paramquery }
|
|
|
|
return bcrypt.hash(mydata.password, bcrypt.genSaltSync(12))
|
|
.then((hashedPassword: string) => {
|
|
mydata.repeatPassword = ''
|
|
mydata.password = String(hashedPassword)
|
|
|
|
return Api.SendReq('/updatepwd', 'POST', mydata, true)
|
|
.then((res) => {
|
|
return { code: res.data.code, msg: res.data.msg }
|
|
})
|
|
.catch((error: Types.AxiosError) => {
|
|
this.setErrorCatch(error)
|
|
return { code: this.getServerCode, msg: error.getMsgError() }
|
|
})
|
|
})
|
|
|
|
},
|
|
|
|
setErrorCatch(axerr: Types.AxiosError) {
|
|
try {
|
|
if (this.servercode !== toolsext.ERR_SERVERFETCH) {
|
|
this.servercode = axerr.getCode()
|
|
}
|
|
// this.msg = axerr.getMsg()
|
|
console.log('Err catch: (servercode:', axerr.getCode(), axerr.getMsgError(), ')')
|
|
} catch (e) {
|
|
console.log('Err catch:', axerr)
|
|
}
|
|
},
|
|
|
|
async setLangServer() {
|
|
const mydata = {
|
|
username: this.my.username,
|
|
lang: this.lang,
|
|
}
|
|
|
|
return Api.SendReq('/setlang', 'PATCH', { data: mydata })
|
|
.then((res) => {
|
|
if (res) {
|
|
return (res.data.code === serv_constants.RIS_CODE_OK)
|
|
}
|
|
return false
|
|
})
|
|
.catch((error: any) => false)
|
|
},
|
|
|
|
async requestpwd(paramquery: any) {
|
|
const usertosend = {
|
|
email: paramquery.email,
|
|
codetocheck: paramquery.tokenforgot_code,
|
|
}
|
|
console.log(usertosend)
|
|
|
|
this.setServerCode(tools.CALLING)
|
|
|
|
return Api.SendReq('/requestnewpwd', 'POST', usertosend)
|
|
.then((res) => ({ code: res.data.code, msg: res.data.msg, link: res.data.link })).catch((error) => {
|
|
this.setErrorCatch(error)
|
|
return this.getServerCode
|
|
})
|
|
},
|
|
|
|
async vreg(paramquery: ILinkReg) {
|
|
const usertosend = {
|
|
idlink: paramquery.idlink,
|
|
}
|
|
console.log(usertosend)
|
|
|
|
this.setServerCode(tools.CALLING)
|
|
|
|
return Api.SendReq('/vreg', 'POST', usertosend)
|
|
.then((res) => {
|
|
// console.log("RITORNO 2 ");
|
|
// mutations.setServerCode(myres);
|
|
if (res.data.code === serv_constants.RIS_CODE_EMAIL_VERIFIED) {
|
|
console.log('VERIFICATO !!')
|
|
tools.localStSetItem(toolsext.localStorage.verified_email, String(true))
|
|
} else {
|
|
console.log('Risultato di vreg: ', res.data.code)
|
|
}
|
|
return { code: res.data.code, msg: res.data.msg }
|
|
}).catch((error) => {
|
|
this.setErrorCatch(error)
|
|
return { code: this.getServerCode, msg: error.getMsgError() }
|
|
})
|
|
},
|
|
|
|
async unsubscribe(paramquery: any) {
|
|
return Api.SendReq('/news/unsubscribe', 'POST', paramquery)
|
|
.then((res) => {
|
|
// console.log("RITORNO 2 ");
|
|
// mutations.setServerCode(myres);
|
|
if (res.data.code === serv_constants.RIS_UNSUBSCRIBED_OK) {
|
|
console.log('DESOTTOSCRITTO ALLA NEWSLETTER !!')
|
|
} else {
|
|
console.log('Risultato di unsubscribe: ', res.data.code)
|
|
}
|
|
return { code: res.data.code, msg: res.data.msg }
|
|
}).catch((error) => this.getServerCode)
|
|
},
|
|
|
|
async importemail(paramquery: any) {
|
|
return Api.SendReq('/news/import', 'POST', paramquery)
|
|
.then((res) => res).catch((error) => ({ numtot: 0, numadded: 0, numalreadyexisted: 0 }))
|
|
},
|
|
|
|
async importExtraList(paramquery: any) {
|
|
|
|
return Api.SendReq('/users/import_extralist', 'POST', paramquery)
|
|
.then((res) => {
|
|
return res
|
|
}).catch((error) => {
|
|
return { numtot: 0, numadded: 0, numalreadyexisted: 0 }
|
|
})
|
|
},
|
|
|
|
async execDbOp(paramquery: any) {
|
|
return Api.SendReq('/users/dbop', 'POST', paramquery)
|
|
.then((res) => {
|
|
return res.data
|
|
}).catch((error) => {
|
|
return false
|
|
})
|
|
},
|
|
|
|
async newsletterload(paramquery: any) {
|
|
|
|
return Api.SendReq('/news/load', 'POST', paramquery)
|
|
.then((res) => {
|
|
// console.log('res', res)
|
|
return res.data
|
|
}).catch((error) => {
|
|
return null
|
|
})
|
|
},
|
|
|
|
async reportload(paramquery: any) {
|
|
|
|
return Api.SendReq('/report/load', 'POST', paramquery)
|
|
.then((res) => {
|
|
// console.log('res', res)
|
|
return res.data
|
|
}).catch((error) => {
|
|
return null
|
|
})
|
|
},
|
|
|
|
async newsletter_setactivate(paramquery: any) {
|
|
|
|
return Api.SendReq('/news/setactivate', 'POST', paramquery)
|
|
.then((res) => {
|
|
// console.log('res', res)
|
|
return res.data
|
|
}).catch((error) => {
|
|
return null
|
|
})
|
|
},
|
|
|
|
authUser(data: IUserFields) {
|
|
try {
|
|
this.my = { ...data }
|
|
// console.log('**** my', this.my)
|
|
if (!this.my.profile) {
|
|
this.my.profile = DefaultProfile
|
|
|
|
// Memory
|
|
this.my.profile.manage_mygroups = []
|
|
this.my.profile.asked_friends = []
|
|
this.my.profile.asked_groups = []
|
|
this.my.profile.refused_groups = []
|
|
}
|
|
|
|
this.isAdmin = tools.isBitActive(this.my.perm, shared_consts.Permissions.Admin.value)
|
|
this.isManager = tools.isBitActive(this.my.perm, shared_consts.Permissions.Manager.value)
|
|
this.isFacilitatore = tools.isBitActive(this.my.perm, shared_consts.Permissions.Facilitatore.value)
|
|
this.isZoomeri = tools.isBitActive(this.my.perm, shared_consts.Permissions.Zoomeri.value)
|
|
this.isDepartment = tools.isBitActive(this.my.perm, shared_consts.Permissions.Department.value)
|
|
this.isTeacher = tools.isBitActive(this.my.perm, shared_consts.Permissions.Teacher.value)
|
|
this.isEditor = tools.isBitActive(this.my.perm, shared_consts.Permissions.Editor.value)
|
|
|
|
this.my.tokens = []
|
|
this.resetArrToken(this.my.tokens)
|
|
this.my.tokens.push({ access: 'auth', token: this.x_auth_token, data_login: tools.getDateNow() })
|
|
|
|
} catch (e) {
|
|
console.log('Error authUser: ' + e)
|
|
}
|
|
|
|
},
|
|
|
|
updateLocalStorage(myuser: IUserFields) {
|
|
const globalStore = useGlobalStore()
|
|
|
|
const now = tools.getDateNow()
|
|
|
|
// const expirationDate = new Date(now.getTime() + myres.data.expiresIn * 1000);
|
|
const expirationDate = new Date(now.getTime() * 1000)
|
|
tools.localStSetItem(toolsext.localStorage.lang, this.lang)
|
|
tools.localStSetItem(toolsext.localStorage.userId, myuser._id)
|
|
tools.localStSetItem(toolsext.localStorage.username, myuser.username)
|
|
tools.localStSetItem(toolsext.localStorage.name, myuser.name)
|
|
tools.localStSetItem(toolsext.localStorage.surname, myuser.surname)
|
|
tools.localStSetItem(toolsext.localStorage.perm, String(myuser.perm) || '')
|
|
if (myuser.profile !== undefined) tools.localStSetItem(toolsext.localStorage.img, (myuser.profile.img) ? String(myuser.profile.img) || '' : '')
|
|
else tools.localStSetItem(toolsext.localStorage.img, '')
|
|
localStorage.setItem(toolsext.localStorage.token, this.x_auth_token)
|
|
localStorage.setItem(toolsext.localStorage.expirationDate, expirationDate.toString())
|
|
tools.localStSetItem(toolsext.localStorage.isLogged, String(true))
|
|
tools.localStSetItem(toolsext.localStorage.verified_email, String(myuser.verified_email))
|
|
tools.localStSetItem(toolsext.localStorage.verified_by_aportador, String(myuser.verified_by_aportador))
|
|
tools.localStSetItem(toolsext.localStorage.teleg_id, String(myuser.profile.teleg_id))
|
|
tools.localStSetItem(toolsext.localStorage.made_gift, String(myuser.made_gift))
|
|
tools.localStSetItem(toolsext.localStorage.wasAlreadySubOnDb, String(globalStore.wasAlreadySubOnDb))
|
|
},
|
|
|
|
setusersList(usersList: IUserFields[]) {
|
|
// console.log('setusersList', usersList)
|
|
// @ts-ignore
|
|
this.usersList = [...usersList]
|
|
},
|
|
|
|
setlang($q: any, $router: Router, newstr: string) {
|
|
console.log('SETLANG', newstr)
|
|
this.lang = newstr
|
|
toolsext.setLangAtt($q, $router, newstr)
|
|
tools.localStSetItem(toolsext.localStorage.lang, this.lang)
|
|
},
|
|
|
|
signup(authData: ISignupOptions) {
|
|
console.log('SIGNUP')
|
|
const mylang = this.lang
|
|
console.log('MYLANG: ' + mylang)
|
|
|
|
return bcrypt.hash(authData.password!, bcrypt.genSaltSync(12))
|
|
.then((hashedPassword: string) => {
|
|
authData.lang = mylang
|
|
authData.password = String(hashedPassword)
|
|
|
|
this.setServerCode(tools.CALLING)
|
|
|
|
return Api.SendReq('/users', 'POST', authData)
|
|
.then((res) => {
|
|
|
|
const newuser = res.data
|
|
|
|
// console.log('newuser', newuser)
|
|
|
|
this.setServerCode(res.status)
|
|
|
|
if (res.status === 200) {
|
|
if (process.env.DEV) {
|
|
console.log('USERNAME = ' + newuser.username)
|
|
console.log('IDUSER= ' + newuser._id)
|
|
}
|
|
|
|
this.authUser(newuser)
|
|
|
|
const now = tools.getDateNow()
|
|
// const expirationDate = new Date(now.getTime() + myres.data.expiresIn * 1000);
|
|
const expirationDate = new Date(now.getTime() * 1000)
|
|
tools.localStSetItem(toolsext.localStorage.lang, this.lang)
|
|
tools.localStSetItem(toolsext.localStorage.userId, newuser._id)
|
|
tools.localStSetItem(toolsext.localStorage.username, newuser.username)
|
|
tools.localStSetItem(toolsext.localStorage.name, newuser.name)
|
|
tools.localStSetItem(toolsext.localStorage.surname, newuser.surname)
|
|
localStorage.setItem(toolsext.localStorage.token, this.x_auth_token)
|
|
localStorage.setItem(toolsext.localStorage.expirationDate, expirationDate.toString())
|
|
tools.localStSetItem(toolsext.localStorage.verified_email, String(false))
|
|
tools.localStSetItem(toolsext.localStorage.verified_by_aportador, String(false))
|
|
|
|
// Even if you has registered, you have to SignIn first
|
|
this.isLogged = false
|
|
// dispatch('storeUser', authData);
|
|
// dispatch('setLogoutTimer', myres.data.expiresIn);
|
|
console.log('OK')
|
|
return { code: tools.OK, msg: '' }
|
|
} else {
|
|
console.log('ERR GENERICO')
|
|
return { code: toolsext.ERR_GENERICO, msg: '' }
|
|
}
|
|
})
|
|
.catch((error) => {
|
|
console.log('Err', error)
|
|
this.setErrorCatch(error)
|
|
return { code: this.getServerCode, msg: this.getMsg }
|
|
})
|
|
})
|
|
},
|
|
|
|
UpdatePwd(x_auth_token: string) {
|
|
this.x_auth_token = x_auth_token
|
|
if (!this.my.tokens) {
|
|
this.my.tokens = []
|
|
}
|
|
this.my.tokens.push({ access: 'auth', token: x_auth_token, data_login: tools.getDateNow() })
|
|
},
|
|
|
|
setServerCode(num: number) {
|
|
this.servercode = num
|
|
},
|
|
|
|
setResStatus(status: number) {
|
|
this.resStatus = status
|
|
},
|
|
|
|
setAuth(x_auth_token: string) {
|
|
this.x_auth_token = x_auth_token
|
|
},
|
|
|
|
resetArrToken(arrtokens: IToken[]) {
|
|
if (!arrtokens) {
|
|
arrtokens = []
|
|
}
|
|
|
|
// Take only the others access (from others Browser)
|
|
return arrtokens.filter((token: IToken) => token.access !== 'auth')
|
|
},
|
|
|
|
async iscrivitiConacreis(authData: ISignupIscrizioneConacreisOptions) {
|
|
console.log('iscrivitiConacreis')
|
|
|
|
this.setServerCode(tools.CALLING)
|
|
|
|
authData.userId = this.my._id
|
|
|
|
return Api.SendReq('/iscritti_conacreis', 'POST', authData)
|
|
.then((res) => {
|
|
if (res.status === 200) {
|
|
return { code: serv_constants.RIS_ISCRIZIONE_OK, msg: '' }
|
|
} else {
|
|
return { code: toolsext.ERR_GENERICO, msg: '' }
|
|
}
|
|
}).catch((error) => {
|
|
console.log('Err', error)
|
|
this.setErrorCatch(error)
|
|
return { code: this.getServerCode, msg: this.getMsg }
|
|
})
|
|
|
|
},
|
|
|
|
async iscrivitiArcadei(authData: ISignupIscrizioneArcadeiOptions) {
|
|
console.log('iscrivitiArcadei')
|
|
|
|
this.setServerCode(tools.CALLING)
|
|
|
|
authData.userId = this.my._id
|
|
|
|
return Api.SendReq('/iscritti_arcadei', 'POST', authData)
|
|
.then((res) => {
|
|
if (res.status === 200) {
|
|
return { code: serv_constants.RIS_ISCRIZIONE_OK, msg: '' }
|
|
} else {
|
|
return { code: toolsext.ERR_GENERICO, msg: '' }
|
|
}
|
|
}).catch((error) => {
|
|
console.log('Err', error)
|
|
this.setErrorCatch(error)
|
|
return { code: this.getServerCode, msg: this.getMsg }
|
|
})
|
|
|
|
},
|
|
|
|
async signin($router: Router, authData: ISigninOptions) {
|
|
console.log('LOGIN signin')
|
|
const globalStore = useGlobalStore()
|
|
|
|
const options = {
|
|
title: tools.translate('notification.title_subscribed', [{
|
|
strin: 'sitename',
|
|
strout: translate('ws.sitename'),
|
|
}]),
|
|
content: translate('notification.subscribed'),
|
|
openUrl: '/',
|
|
}
|
|
|
|
const usertosend = {
|
|
username: authData.username.trim(),
|
|
password: authData.password.trim(),
|
|
lang: this.lang,
|
|
options,
|
|
}
|
|
|
|
if (process.env.DEBUG === '1') {
|
|
console.log(usertosend)
|
|
}
|
|
|
|
this.setServerCode(tools.CALLING)
|
|
|
|
let myres: any
|
|
|
|
console.log('executing login...')
|
|
|
|
return await Api.SendReq('/users/login', 'POST', usertosend, true)
|
|
.then((res) => {
|
|
|
|
myres = res
|
|
|
|
if (myres.status !== 200) {
|
|
return Promise.reject(toolsext.ERR_GENERICO)
|
|
}
|
|
return myres
|
|
|
|
}).then((res) => {
|
|
console.log(' Login res', res)
|
|
|
|
if (res.success) {
|
|
globalStore.SetwasAlreadySubOnDb(res.data.subsExistonDb)
|
|
|
|
const myuser: IUserFields = res.data.usertosend
|
|
if (myuser) {
|
|
// console.table(myuser)
|
|
|
|
this.authUser(myuser)
|
|
|
|
this.updateLocalStorage(myuser)
|
|
|
|
// globalStore.loadSite()
|
|
|
|
}
|
|
}
|
|
|
|
return tools.OK
|
|
|
|
}).then((code) => {
|
|
if (code === tools.OK) {
|
|
return this.setGlobal($router, true)
|
|
.then(() => {
|
|
return code
|
|
})
|
|
} else {
|
|
return code
|
|
}
|
|
})
|
|
.catch((error) => {
|
|
console.log('error', error)
|
|
this.setErrorCatch(error)
|
|
return this.getServerCode
|
|
})
|
|
},
|
|
|
|
async logout() {
|
|
const globalStore = useGlobalStore()
|
|
// const $router = useRouter()
|
|
|
|
console.log('logout')
|
|
|
|
localStorage.removeItem(toolsext.localStorage.expirationDate)
|
|
localStorage.removeItem(toolsext.localStorage.token)
|
|
localStorage.removeItem(toolsext.localStorage.userId)
|
|
localStorage.removeItem(toolsext.localStorage.username)
|
|
localStorage.removeItem(toolsext.localStorage.name)
|
|
localStorage.removeItem(toolsext.localStorage.surname)
|
|
localStorage.removeItem(toolsext.localStorage.img)
|
|
localStorage.removeItem(toolsext.localStorage.perm)
|
|
localStorage.removeItem(toolsext.localStorage.isLogged)
|
|
// localStorage.removeItem(rescodes.localStorage.leftDrawerOpen)
|
|
localStorage.removeItem(toolsext.localStorage.verified_email)
|
|
localStorage.removeItem(toolsext.localStorage.verified_by_aportador)
|
|
localStorage.removeItem(toolsext.localStorage.teleg_id)
|
|
localStorage.removeItem(toolsext.localStorage.made_gift)
|
|
localStorage.removeItem(toolsext.localStorage.categorySel)
|
|
localStorage.removeItem(toolsext.localStorage.wasAlreadySubOnDb)
|
|
|
|
this.isLogged = false
|
|
this.my = { ...DefaultUser }
|
|
|
|
await globalStore.clearDataAfterLogout()
|
|
|
|
tools.checkApp()
|
|
|
|
return Api.SendReq('/users/me/token', 'DELETE', null)
|
|
.then((res) => {
|
|
console.log(res)
|
|
}).then(() => this.clearAuthData()).catch((error) => {
|
|
this.setErrorCatch(error)
|
|
return this.getServerCode
|
|
})
|
|
},
|
|
|
|
async setGlobal($router: Router, isLogged: boolean) {
|
|
console.log('setGlobal', isLogged)
|
|
|
|
const globalStore = useGlobalStore()
|
|
const todos = useTodoStore()
|
|
const projects = useProjectStore()
|
|
try {
|
|
// this.isLogged = true
|
|
if (isLogged) {
|
|
// console.log('this.isLogged', this.isLogged)
|
|
|
|
if (!tools.isMobile)
|
|
globalStore.setleftDrawerOpen(localStorage.getItem(toolsext.localStorage.leftDrawerOpen) === 'true')
|
|
globalStore.setCategorySel(localStorage.getItem(toolsext.localStorage.categorySel))
|
|
|
|
globalStore.checkUpdates()
|
|
}
|
|
|
|
const isok = await globalStore.loadAfterLogin()
|
|
|
|
this.isLogged = isok && isLogged
|
|
|
|
// console.log('this.isLogged', this.isLogged, 'isok', isok, 'isLogged', isLogged)
|
|
|
|
if (globalStore.site.confpages.enableTodos)
|
|
await todos.dbLoad({ checkPending: true })
|
|
|
|
if (globalStore.site.confpages.enableProj)
|
|
await projects.dbLoad({ checkPending: true, onlyiffirsttime: true })
|
|
|
|
globalStore.addDynamicPages($router)
|
|
|
|
static_data.lang_available = globalStore.getLangAvailable()
|
|
|
|
static_data.arrLangUsed = tools.getLangUsed()
|
|
|
|
// console.log('$router', $router)
|
|
|
|
globalStore.finishLoading = true
|
|
if (tools.isDebug()) console.log('finishLoading', globalStore.finishLoading)
|
|
|
|
// document.dispatchEvent(new Event('custom-post-render-event'))
|
|
} catch (e) {
|
|
console.error('Error', e)
|
|
globalStore.finishLoading = true
|
|
}
|
|
|
|
return true
|
|
// console.log('setGlobal: END')
|
|
},
|
|
|
|
async autologin_FromLocalStorage($router: Router, $q: any) {
|
|
try {
|
|
const globalStore = useGlobalStore()
|
|
|
|
// console.log('*** autologin_FromLocalStorage ***')
|
|
// INIT
|
|
|
|
let isLogged = false
|
|
|
|
this.lang = tools.getItemLS(toolsext.localStorage.lang)
|
|
|
|
const token = localStorage.getItem(toolsext.localStorage.token)
|
|
|
|
if (token) {
|
|
const expirationDateStr = localStorage.getItem(toolsext.localStorage.expirationDate)
|
|
const expirationDate = new Date(String(expirationDateStr))
|
|
const now = tools.getDateNow()
|
|
if (now < expirationDate) {
|
|
this.setAuth(token)
|
|
isLogged = true
|
|
|
|
} else {
|
|
// ++ ?? che fare qui
|
|
}
|
|
} else {
|
|
isLogged = tools.isLogged()
|
|
}
|
|
|
|
return await this.setGlobal($router, isLogged)
|
|
.then((loadstorage: any) => {
|
|
// console.log('RISULT setGlobal:', loadstorage)
|
|
if (loadstorage) {
|
|
|
|
globalroutines('loadapp', '')
|
|
|
|
// Create Subscription to Push Notification
|
|
globalStore.createPushSubscription()
|
|
}
|
|
})
|
|
|
|
} catch (e: any) {
|
|
console.error('ERR autologin ', e.message)
|
|
return false
|
|
}
|
|
},
|
|
|
|
async loadUserProfile({ username, idnotif }: { username: string, idnotif?: string }) {
|
|
const data = {
|
|
username,
|
|
idnotif
|
|
}
|
|
|
|
return Api.SendReq('/users/profile', 'POST', data)
|
|
.then((ris) => {
|
|
this.my.profile.friends = ris.data.friends.listFriends ? ris.data.friends.listFriends : []
|
|
this.my.profile.req_friends = ris.data.friends.listRequestFriends ? ris.data.friends.listRequestFriends : []
|
|
this.my.profile.asked_friends = ris.data.friends.listSentRequestFriends ? ris.data.friends.listSentRequestFriends : []
|
|
|
|
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 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 data = {
|
|
path,
|
|
idnotif,
|
|
}
|
|
|
|
return Api.SendReq('/circuit/load', 'POST', data)
|
|
.then((res) => {
|
|
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) => {
|
|
return res.data
|
|
}).catch((error) => {
|
|
return {}
|
|
})
|
|
|
|
},
|
|
|
|
async loadGeneric(table: string, id: number, idnotif: string) {
|
|
const data = {
|
|
table,
|
|
id,
|
|
idnotif
|
|
}
|
|
|
|
return Api.SendReq('/mygen/page', 'POST', data)
|
|
.then((res) => {
|
|
return res.data
|
|
}).catch((error) => {
|
|
return {}
|
|
})
|
|
|
|
},
|
|
|
|
async loadFriends(username: string) {
|
|
return Api.SendReq('/users/friends', 'POST', null)
|
|
.then((ris) => {
|
|
this.my.profile.friends = ris.data.listFriends ? ris.data.listFriends : []
|
|
this.my.profile.req_friends = ris.data.listRequestFriends ? ris.data.listRequestFriends : []
|
|
this.my.profile.asked_friends = ris.data.listSentRequestFriends ? ris.data.listSentRequestFriends : []
|
|
return ris.data
|
|
}).catch((error) => {
|
|
return {}
|
|
})
|
|
|
|
},
|
|
|
|
async loadGroups(username: string) {
|
|
return Api.SendReq('/users/groups', 'POST', null)
|
|
.then((res) => {
|
|
return res.data
|
|
}).catch((error) => {
|
|
return {}
|
|
})
|
|
|
|
},
|
|
|
|
async loadCircuits() {
|
|
return Api.SendReq('/users/circuits', 'POST', null)
|
|
.then((res) => {
|
|
return res.data
|
|
}).catch((error) => {
|
|
return {}
|
|
})
|
|
|
|
},
|
|
|
|
async setFriendsCmd($q: any, t: any, usernameOrig: string, usernameDest: string, cmd: number, value: any) {
|
|
return Api.SendReq('/users/friends/cmd', 'POST', { usernameOrig, usernameDest, cmd, value })
|
|
.then((res) => {
|
|
this.updateTables = true
|
|
return res.data
|
|
}).catch((error) => {
|
|
tools.showNegativeNotif($q, t('db.recfailed'))
|
|
return {}
|
|
})
|
|
|
|
},
|
|
|
|
async setGroupsCmd($q: any, t: any, usernameOrig: string, groupnameDest: string, cmd: number, value: any) {
|
|
return Api.SendReq('/users/groups/cmd', 'POST', { usernameOrig, groupnameDest, cmd, value })
|
|
.then((res) => {
|
|
this.updateTables = true
|
|
return res.data
|
|
}).catch((error) => {
|
|
tools.showNegativeNotif($q, t('db.recfailed'))
|
|
return {}
|
|
})
|
|
|
|
},
|
|
|
|
async setCircuitCmd($q: any, t: any, usernameOrig: string, circuitname: string, cmd: number, value: any, extrarec?: any) {
|
|
return await Api.SendReq('/users/circuits/cmd', 'POST', { usernameOrig, circuitname, cmd, value, extrarec })
|
|
.then((res) => {
|
|
this.updateTables = true
|
|
if (res.data.recnotif) {
|
|
const notifStore = useNotifStore()
|
|
|
|
notifStore.updateRecNotif(res.data.recnotif)
|
|
}
|
|
return res.data
|
|
}).catch((error) => {
|
|
tools.showNegativeNotif($q, t('db.recfailed'))
|
|
return {}
|
|
})
|
|
|
|
},
|
|
|
|
async sendMsgToBotTelegram($q: any, t: any, mydata: IMsgGlobParam, showmsgsent: boolean) {
|
|
const globalStore = useGlobalStore()
|
|
|
|
return Api.SendReq('/users/mgt', 'POST', { mydata })
|
|
.then((res) => {
|
|
console.log('res', res)
|
|
|
|
let msgok = (res.data.nummsgsent === 1) ? res.data.nummsgsent + ' ' + t('cal.sendmsg_sent') : res.data.nummsgsent + ' ' + t('cal.sendmsgs_sent')
|
|
if (mydata.cmd === shared_consts.MsgTeleg.SHARE_MSGREG) {
|
|
if (tools.isTelegOk()) {
|
|
msgok = t('cal.sendmsg_sent_sharedlink') + ' ' + tools.getBotName()
|
|
} else {
|
|
msgok = t('cal.sendmsg_sent_sharedlink_copied')
|
|
}
|
|
showmsgsent = true
|
|
}
|
|
|
|
if (showmsgsent && res.data.nummsgsent >= 0) {
|
|
tools.showPositiveNotif($q, msgok)
|
|
if (mydata.cmd === shared_consts.MsgTeleg.SHARE_MSGREG) {
|
|
if (!tools.isTelegOk()) {
|
|
// console.log('text', res.data.text)
|
|
tools.copyStringToClipboardSilent(res.data.text)
|
|
}
|
|
if (res.data.textsent) {
|
|
return res.data.textsent
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
return false
|
|
}).catch((error) => {
|
|
tools.showNegativeNotif($q, t('cal.err_sendmsg'))
|
|
return {}
|
|
})
|
|
},
|
|
|
|
async importToServerCmd($q: any, t: any, cmd: number, data: any) {
|
|
return Api.SendReq('/admin/import', 'POST', { cmd, data })
|
|
.then((res) => {
|
|
if (res) {
|
|
tools.showPositiveNotif($q, t('db.recupdated'))
|
|
}
|
|
}).catch((error) => {
|
|
tools.showNegativeNotif($q, t('db.recfailed'))
|
|
return {}
|
|
})
|
|
|
|
}
|
|
},
|
|
})
|