Class User

constructor

• new User(o: User | UserCfg): User

  User constructor

  Parameters

  • o: User | UserCfg

  Returns User

_attributes

Optionalapi_token

disabled

email

Optionalid

Optionallanguage

Optionallast_mobile_login

password

Optionalreset_password_expiry

Optionalreset_password_token

role_id

Optionalverification_token

Optionalverified_on

session_object

• get session_object(): any

  Create session object for user

  Returns any

Statictable

• get table(): Table

  Returns Table

auth_method_allowed

• auth_method_allowed(method_name: string): boolean

  Parameters

  • method_name: string

  Returns boolean

changePasswordTo

• changePasswordTo(newpw: string, expireToken?: boolean): Promise<void>

  Change password

  Parameters

  • newpw: string

    new password string

  • OptionalexpireToken: boolean

    if true than force reset password token

  Returns Promise<void>

  no result

checkPassword

• checkPassword(pw: string): boolean

  Check password

  Parameters

  • pw: string

    password string

  Returns boolean

delete

• delete(): Promise<void>

  Delete user based on session object

  Returns Promise<void>

destroy_sessions

• destroy_sessions(): Promise<void>

  Returns Promise<void>

getNewAPIToken

• getNewAPIToken(): Promise<string>

  Add new API token to user

  Returns Promise<string>

getNewResetToken

• getNewResetToken(): Promise<string>

  Get new reset token

  Returns Promise<string>

listApiTokens

• listApiTokens(): Promise<
      { created_at: string
      | Date; id: number; token: string }[],
  >

  List API tokens for this user

  Returns Promise<{ created_at: string | Date; id: number; token: string }[]>

relogin

• relogin(req: any): Promise<void>

  Parameters

  • req: any

  Returns Promise<void>

removeAPIToken

• removeAPIToken(): Promise<null>

  Remove API token for user

  Returns Promise<null>

revokeApiToken

• revokeApiToken(tokenId: number): Promise<void>

  Revoke a single API token by id

  Parameters

  • tokenId: number

  Returns Promise<void>

revokeOriginalApiToken

• revokeOriginalApiToken(): Promise<void>

  Revoke original API token stored on users.api_token Also delete any matching row from _sc_api_tokens for this user

  Returns Promise<void>

send_verification_email

• send_verification_email(
      req?: any,
      opts?: { new_verification_token?: string },
  ): Promise<any>

  Parameters

  • Optionalreq: any
  • Optionalopts: { new_verification_token?: string }

  Returns Promise<any>

set_language

• set_language(language: string): Promise<void>

  Set language for User in database

  Parameters

  • language: string

  Returns Promise<void>

set_to_verified

• set_to_verified(): Promise<true>

  Returns Promise<true>

update

• update(row: Partial<User>, plainPassword?: string): Promise<void>

  Update User

  Parameters

  • row: Partial<User>
  • OptionalplainPassword: string

  Returns Promise<void>

updateLastMobileLogin

• updateLastMobileLogin(date: Date | null): Promise<void>

  update 'last_mobile_login' columnwill

  Parameters

  • date: Date | null

    new login_date or null for logout (invalidates all jwts)

  Returns Promise<void>

Staticauthenticate

• authenticate(uo: any): Promise<false | User>

  Authenticate User

  Parameters

  • uo: any

    user object

  Returns Promise<false | User>

Staticcount

• count(where?: Where): Promise<number>

  Count users in database

  Parameters

  • Optionalwhere: Where

  Returns Promise<number>

Staticcreate

• create(uo: GenObj): Promise<User | ErrorMessage>

  Create user

  Parameters

  • uo: GenObj

    user object

  Returns Promise<User | ErrorMessage>

Staticdestroy_all_tenant_sessions

• destroy_all_tenant_sessions(tenant?: string): Promise<void>

  Parameters

  • Optionaltenant: string

  Returns Promise<void>

Staticfind

• find(where: Where, selectopts?: SelectOptions): Promise<User[]>

  Find users list

  Parameters

  • where: Where

    where object

  • Optionalselectopts: SelectOptions

    select options

  Returns Promise<User[]>

StaticfindByApiToken

• findByApiToken(token: string): Promise<User | undefined>

  Find user by API token

  Parameters

  • token: string

  Returns Promise<User | undefined>

StaticfindForSession

• findForSession(where: Where): Promise<false | User>

  Find users list

  Parameters

  • where: Where

    where object

  Returns Promise<false | User>

StaticfindOne

• findOne(where: Where): Promise<User | undefined>

  Find one user

  Parameters

  • where: Where

    where object

  Returns Promise<User | undefined>

StaticfindOrCreateByAttribute

• findOrCreateByAttribute(
      k: string,
      v: any,
      uo?: any,
  ): Promise<false | User | ErrorMessage>

  Find or Create User

  Parameters

  • k: string
  • v: any
  • Optionaluo: any = {}

  Returns Promise<false | User | ErrorMessage>

Staticgenerate_password

• generate_password(): string

  Generate password

  Returns string

Staticget_roles

• get_roles(): Promise<Row[]>

  Get available roles

  Returns Promise<Row[]>

StatichashPassword

• hashPassword(pw: string): Promise<string>

  Get bcrypt hash for Password

  Parameters

  • pw: string

    password string

  Returns Promise<string>

Staticmatches_existing_user

• matches_existing_user(uo: any): Promise<boolean>

  Parameters

  • uo: any

  Returns Promise<boolean>

StaticnonEmpty

• nonEmpty(): Promise<boolean>

  Check that user table is not empty in database

  Returns Promise<boolean>

  true if there are users in db

  Deprecated

  use method count()

StaticresetPasswordWithToken

• resetPasswordWithToken(
      email: {
          confirm_password: string;
          email: string;
          password: string;
          reset_password_token: string;
      },
  ): Promise<ErrorMessage | SuccessMessage>

  Reset password using token

  Parameters

  • email: {
        confirm_password: string;
        email: string;
        password: string;
        reset_password_token: string;
    }

    email address string

  Returns Promise<ErrorMessage | SuccessMessage>

Staticunacceptable_password_reason

• unacceptable_password_reason(pw: string): string | undefined

  Validate password

  Parameters

  • pw: string

  Returns string | undefined

Staticvalid_email

• valid_email(email: string): boolean

  Validate email

  Parameters

  • email: string

  Returns boolean

StaticverifyWithToken

• verifyWithToken(
      email: { email: string; verification_token: string },
  ): Promise<true | ErrorMessage>

  Verification with token

  Parameters

  • email: { email: string; verification_token: string }

    email string

  Returns Promise<true | ErrorMessage>

  true if verification passed, error string if not