userModel.ts

/**
 * @file Fonctions qui implémentent les requetes relatives aux utilisateurs
 * @author ofacklam
 * @memberof GraphQL
 */

import { User } from "../object_resolvers/users";
import { User as UT, userData } from "../../ldap/export/user"
import { searchTOLArgs, editProfileArgs } from "../typeDefs/queries";
import { ApolloError } from "apollo-server-core";

export class UserModel {

    /**
     * @memberof GraphQL
     * @class UserModel
     * @summary Requetes relatives aux utilisateurs.
     * @classdesc Cette classe contient les méthodes implémentant les requetes relatives aux utilisateurs.
     * @arg {string} contextUser - L'identifiant de l'utilisateur du 'context'
     */
    constructor(contextUser: string) {
        this.contextUser = contextUser;
    }

    protected contextUser: string;

    /**
     * @memberof GraphQL.UserModel#
     * @function getUser
     * @summary Fonction qui renvoit un utilisateur donné.
     * @arg {string} uid - Identifiant demandé.
     * @return {Promise(User)} Renvoie l'utilisateur dont l'identifiant est 'uid'
     * @async
     * @rights connectedOrOnplatal
     */
    async getUser(uid: string): Promise<User> {
        return User.tryCreate(uid);
    }

    /**
     * @memberof GraphQL.UserModel#
     * @function searchTOL
     * @summary Fonction qui recherche dans le TOL
     * @arg {searchTOLArgs} args - les données de recherche
     * @return {Promise(User[])} Renvoie une liste d'utilisateurs
     * @async
     * @rights connectedOrOnplatal
     */
    async searchTOL(args: searchTOLArgs): Promise<User[]> {
        //TODO : correctly handle groups (in LDAP, a member can be stored as member, speaker or admin...)

        const searchData = new userData();
        searchData.givenName = args.givenName;
        searchData.lastName = args.lastName;
        searchData.nickname = args.nickname;
        searchData.nationality = args.nationality;
        searchData.members = args.groups;
        searchData.phone = args.phone;
        searchData.mail = args.mail;
        searchData.address = args.address;

        const userList = await UT.search(searchData);
        return userList.map((uid) => new User(uid));
    }

    /**
     * @memberof GraphQL.UserModel#
     * @function editProfile
     * @summary Fonction qui modifie le profil et renvoie l'utilisateur
     * @arg {editProfileArgs} args - les données a modifier 
     * @return {Promise(User)} Renvoie l'utilisateur mis a jour
     * @async
     * @rights authenticated
     */
    async editProfile(args: editProfileArgs): Promise<User> {
        let data = await UT.peek(this.contextUser);

        //Modify some fields, keep the others
        let editArgs = new userData();
        editArgs.uid = data.uid;
        editArgs.password = data.password;
        editArgs.givenName = data.givenName;
        editArgs.lastName = data.lastName;
        editArgs.nickname = args.nickname; // <- this field is modified by user
        editArgs.gender = data.gender;
        editArgs.photo = data.photo;
        editArgs.phone = args.phone; // <- this field is modified
        editArgs.address = data.address; // WTF why can't this be changed ????
        editArgs.mail = args.mail; // <- this field is modified
        editArgs.birthdate = data.birthdate;
        editArgs.nationality = data.nationality;
        editArgs.admins = data.admins;
        editArgs.speakers = data.speakers;
        editArgs.members = data.members;
        editArgs.followers = data.followers;

        if(await UT.edit(editArgs)) {
            return new User(data.uid);
        }
        else {
            throw new ApolloError("Edit failed");
        }
    }

}