library-ts/browser/users/UserSystem.ts

import { Property } from "../events/Property";
import { DataMessage } from "../messages/DataMessage";
import { Message } from "../messages/Message";
import { MessageTypes } from "../messages/MessageType";
import { Request } from "../xhttp/Request";

export class EmailData
{
  email:string;
}

export class EmailPasswordData extends EmailData
{
  password:string;
}

export class TokenData
{
  token:string;
}

export class PageTokenData
{
  pageToken:string;
}

export class LinkUserData extends PageTokenData
{
  userToken:string;
  renewal:string;
}

export class LocationData
{
  country:string;
  city:string;
  km_range:number;
}

export class UserLoginDataInfo
{
  time:string;
  location:LocationData;
  app:string;
  os:string;
  deviceType:string;
}

export class UserData
{
  email:string;
  id:string;
  name:string;
  lastLogins:UserLoginDataInfo[];
}

export class SessionData
{
  token:string;
  renewal:string;
}

export class UserAppData
{
  token:string;
  appID:string;
}

export class UserSavingAppData extends UserAppData
{
  appData:any;
}

export class UserTaskDeletionData extends UserAppData
{
  taskID:string;
}


export class UserSystem
{
  static productionURL = "https://backend.rokojori.com:1712";
  static localURL      = "http://192.168.178.51:1712";

  _isLocal = false;
  _loggedIn = false;
  _userData:UserData;

  readonly userID = new Property<string>( null );

  _sessionData:SessionData;

  get sessionToken(){ return this._sessionData?.token || null };

  get isLoggedIn()
  {
    return this._loggedIn; 
  }

  get userName()
  {
    return this._userData?.name || null;
  }

  get url()
  {
    return this._isLocal ? UserSystem.localURL : UserSystem.productionURL;
  }

  
  constructor( isLocal:boolean )
  {
    this._isLocal = isLocal;
  }
 

  async renew():Promise<void>
  {
    if ( ! this._sessionData )
    {
      return Promise.resolve();
    }

    let functionURL = this.url + `/renew`;

    let oldSessionData = this._sessionData;

    try
    {      

      let result = await Request.post<SessionData,DataMessage<SessionData>>( functionURL, oldSessionData ); 

      if ( MessageTypes.Error === result.type )
      {        
        this._sessionData = null;
      }
      else
      {
        this._sessionData = result.data;
        this._userData = await this.info();
      }

    }
    catch ( e ) 
    {
      console.error( e );
    }
    

    return Promise.resolve();
  }
  


  async confirmSignup( id:string, token:string ):Promise<boolean>
  {
    let functionURL = this.url + `/confirm-signup?id=${id}&token=${token}` ;

    try
    {
      let result = await Request.get<Message>( functionURL ); 

      return Promise.resolve( result.type !== MessageTypes.Error );
    }
    catch ( e ) 
    {
      console.error( e );
    }
    

    return Promise.resolve( false );
  }

  async signup( email:string, password:string ):Promise<boolean>
  {
    let functionURL = this.url + "/signup";

    let input:EmailPasswordData =
    {
      email: email,
      password: password
    };

    try
    {
      let result = await Request.post<EmailPasswordData,Message>( functionURL, input ); 

      return Promise.resolve( result.type !== MessageTypes.Error );
    }
    catch ( e ) 
    {
      console.error( e );
    }
    

    return Promise.resolve( false );
  }

  async info():Promise<UserData>
  {
    if ( this._sessionData === null )
    {
      return Promise.resolve( null );
    }

    let functionURL = this.url + "/info";
    
    try
    {
      let result = await Request.post<TokenData,DataMessage<UserData>>( functionURL, { token: this.sessionToken } ); 
      return Promise.resolve( result.data );
    } 
    catch( e )
    {
      return Promise.resolve( null );
    }    
  }


  async login( email:string, password:string, debugOutput:string[] = undefined ):Promise<boolean>
  {
    let functionURL = this.url + "/login";
    
    let input:EmailPasswordData =
    {
      email: email,
      password: password
    };

    try
    {
      let result = await Request.post<EmailPasswordData,DataMessage<SessionData>>( functionURL, input ); 
      
      if ( debugOutput )
      {
        debugOutput.push( JSON.stringify( result ) );
      }
  

      if ( result.type === MessageTypes.Error )
      {
        return Promise.resolve( false );
      }

      console.log( "Login Result:", result );

      
      this._sessionData = result.data;
      
      let userData = await this.info();

      console.log( "userData Result:", userData );

      this._loggedIn = true;
      this._userData = userData;
      this.userID.value = this._userData.id;

      return Promise.resolve( true );
    }
    catch ( e ) 
    {
      console.error( e );

      if ( debugOutput )
      {
        debugOutput.push( JSON.stringify( e.message ) );
      }
    }
    

    return Promise.resolve( false );
  }

  async logout():Promise<void>
  {
    if ( ! this._loggedIn )
    {
      return;
    }

    let functionURL = this.url + "/logout";
    
    await Request.post<TokenData,DataMessage<TokenData>>( functionURL, { token: this.sessionToken } ); 
    
    this._loggedIn = false;
    this._sessionData = null;
    this._userData = null;

    this.userID.value = null;

    return Promise.resolve();

  }

  async requestPasswordChange( email:string ):Promise<boolean>
  {
    let functionURL = this.url + "/request-password-change";

    let result = await Request.post<EmailData,Message>( functionURL, { email: email } );

    return Promise.resolve( MessageTypes.Error !== result.type );
  }

  protected _getAppsURL( name:string )
  {
    return this.url + "/apps" + name;
  }

  async canUseApp( appID:string ):Promise<boolean>
  {

    let url = this._getAppsURL( "/can-use" );

    let input = { token:this.sessionToken, appID: appID };

    let result = await Request.post<UserAppData,Message>( url, input ); 

    if ( MessageTypes.Error == result.type )
    {
      console.log( result );
      return Promise.resolve( false );
    }

    return Promise.resolve( true );
  }

  async loadAppData<T>( appID:string ):Promise<T>
  {
    let url = this._getAppsURL( "/load" );

    let input = { token:this.sessionToken, appID: appID };

    let result = await Request.post<UserAppData,DataMessage<T>>( url, input ); 

    if ( MessageTypes.Error == result.type )
    {
      console.log( result );
      return Promise.resolve( null );
    }

    return Promise.resolve( result.data );
  }

  async saveAppData<T>( appID:string, data:T ):Promise<boolean>
  {
    let url = this._getAppsURL( "/save" );

    let input = { token:this.sessionToken, appID: appID, appData:data };

    let result = await Request.post<UserSavingAppData,DataMessage<T>>( url, input ); 

    if ( MessageTypes.Error == result.type )
    {
      console.log( result );
      return Promise.resolve( false );
    }

    return Promise.resolve( true );
  }

  async deleteAppTask( appID:string, taskID:string ):Promise<boolean>
  {
    let url = this._getAppsURL( "/delete-task" );

    let input = { token:this.sessionToken, appID: appID, taskID:taskID };

    let result = await Request.post<UserTaskDeletionData,Message>( url, input ); 

    if ( MessageTypes.Error == result.type )
    {
      console.log( result );
      return Promise.resolve( false );
    }

    return Promise.resolve( true );
  }
}