25737361825

Committed 12 May 2026 01:23PM UTC coverage: 95.915% (+0.01%) from 95.902%

Build # 25737361825

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #2766 from FAIRsharing/refactoring-processing-notes-2759

Refactoring processing notes 2759

Coverage Stats

3645 of 3816 branches covered (95.52%)

Branch coverage included in aggregate %.

190 of 229 new or added lines in 3 files covered. (82.97%)

2 existing lines in 2 files now uncovered.

38833 of 40471 relevant lines covered (95.95%)

5.44 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

91.04

/src/lib/Client/RESTClient.js

import axios from "axios";

//import {toBase64} from "@/utils/generalUtils"
class RESTClient {
  /**
   * The RESTClient is a singleton class that handles the connection and data exchange from the back-end
   * REST API.
   */
  constructor() {
    if (RESTClient._instance) {
      return RESTClient._instance;
    }
    RESTClient._instance = this;
    this.baseURL = import.meta.env.VITE_API_ENDPOINT;
    this.headers = {
      Accept: "application/json",
      "Content-Type": "application/json",
      "Cache-Control": "no-cache",
    };
    this.headers["X-Client-Id"] = import.meta.env.VITE_CLIENT_ID;
  }

  /* USERS: all methods below related to handling user authentication */

  /**
   * Method to add authorisation to the headers.
   * @param jwt - the user's json web token
   * @return {JSON} - headers with authorisation field added
   */
  auth_headers(jwt) {
    let headers = JSON.parse(JSON.stringify(this.headers));
    headers["Authorization"] = "Bearer " + jwt;
    return headers;
  }

  /**
   * Method to log in the user
   * @param username - name of the user
   * @param password - password of the user
   * @return {Promise} - the response of the server
   */
  async login(username, password) {
    const endpoint = "/users/sign_in";
    const body = {
      user: {
        login: username,
        password: password,
      },
    };
    const request = {
      method: "post",
      baseURL: this.baseURL + endpoint,
      data: body,
      headers: this.headers,
    };
    let response = await this.executeQuery(request);
    return response.data;
  }

  /**
   * Logout the user from the back, expiring the current jwt.
   * @param {String} jwt - the user token to expire.
   * @returns {Promise}
   */
  async logout(jwt) {
    const request = {
      method: "delete",
      baseURL: this.baseURL + "/users/sign_out",
      headers: this.auth_headers(jwt),
    };
    let response = await this.executeQuery(request);
    return response.data;
  }

  /**
   * Delete the user's account (they must be logged in).
   * @param {String} jwt - the user token to expire.
   * @returns {Promise}
   */
  async delete(jwt) {
    const request = {
      method: "delete",
      baseURL: this.baseURL + "/users",
      headers: this.auth_headers(jwt),
    };
    let response = await this.executeQuery(request);
    return response.data;
  }

  /**
   *  Method to create a new user
   * @param {Object} userLogin - the user account to create
   * @returns {Promise} response - server response
   */
  async createAccount(userLogin) {
    const request = {
      method: "post",
      baseURL: this.baseURL + "/users",
      data: { user: userLogin },
      headers: this.headers,
    };
    let response = await this.executeQuery(request);
    return response.data;
  }

  /**
   * Validate the account given the corresponding token
   * @param {String} token - the account token to validate
   * @returns {Promise}
   */
  async confirmAccount(token) {
    const request = {
      method: "get",
      baseURL: this.baseURL + "/users/confirmation?confirmation_token=" + token,
      headers: this.headers,
    };
    let response = await this.executeQuery(request);
    return response.data;
  }

  /**
   * Method to send a reset password link to the given email address
   * @param {String} email to send the link to
   * @returns {Promise}
   */
  async requestResetPwd(email) {
    const request = {
      method: "post",
      baseURL: this.baseURL + "/users/password",
      headers: this.headers,
      data: {
        user: { email: email },
      },
    };
    let response = await this.executeQuery(request);
    return response.data;
  }

  /**
   * Resend the validation link for a given user
   * @param {Object} user - contains the email of the user.
   * @returns {Promise}
   */
  async resendConfirmation(user) {
    const request = {
      method: "post",
      baseURL: this.baseURL + "/users/confirmation",
      headers: this.headers,
      data: { user: user },
    };
    let response = await this.executeQuery(request);
    return response.data;
  }

  /**
   * Reset the password of the given user
   * @param {Object} user - contains the new pwd, repeated pwd and token.
   * @returns {Promise}
   */
  async resetPassword(user) {
    const request = {
      method: "put",
      baseURL: this.baseURL + "/users/password",
      headers: this.headers,
      data: { user: user },
    };
    let response = await this.executeQuery(request);
    return response.data;
  }

  /**
   * Changes the password of the logged in user
   * @param {String} jwt - the user token
   * @param {Object} user - contains the current, new and repeated new password
   * @returns {Promise}
   */
  async resetPasswordWithoutToken(jwt, user) {
    const request = {
      method: "put",
      baseURL: this.baseURL + "/users/",
      headers: this.auth_headers(jwt),
      data: { user: user },
    };
    let response = await this.executeQuery(request);
    return response.data;
  }

  /**
   * Verify the validity of the given password
   * @param {String} password - the password to test
   * @returns {Promise}
   */
  async verifyPassword(password) {
    let headers = JSON.parse(JSON.stringify(this.headers));
    const request = {
      method: "post",
      baseURL: this.baseURL + "/users/check_password",
      headers: headers,
      data: { password: password },
    };
    let response = await this.executeQuery(request);
    return response.data;
  }

  /**
   * Get the current user data
   * @param jwt
   * @returns {Promise}
   */
  async getUser(jwt) {
    const request = {
      method: "get",
      baseURL: this.baseURL + "/users/edit",
      headers: this.auth_headers(jwt),
    };
    let response = await this.executeQuery(request);
    return response.data;
  }

  /**
   * Get the current user data
   * @param jwt
   * @param id
   * @returns {Promise}
   */
  async getPublicUser(jwt, id) {
    const request = {
      method: "get",
      baseURL: this.baseURL + `/user_admin/${id}`,
      headers: this.auth_headers(jwt),
    };
    let response = await this.executeQuery(request);
    return response.data;
  }

  /**
   * Get all users list
   * @param jwt
   * @returns {Promise}
   */
  async getUsersList(jwt) {
    const request = {
      method: "get",
      baseURL: this.baseURL + "/user_admin/",
      headers: this.auth_headers(jwt),
    };
    let response = await this.executeQuery(request);
    return response.data;
  }

  /**
   * Edit the current logged in user profile
   * @param {Object} newUser - the new values for the logged in user
   * @param {String} jwt - JWT of the logged in user
   * @returns {Promise}
   */
  async editUser(newUser, jwt) {
    const request = {
      method: "put",
      baseURL: this.baseURL + "/users",
      headers: this.auth_headers(jwt),
      data: { user: newUser },
    };
    let response = await this.executeQuery(request);
    return response.data;
  }
  /**
   * Edit the current logged in user profile
   * @param {Object} newUser - the new values for the logged in user
   * @param {String} jwt - JWT of the logged in user
   * @returns {Promise}
   */
  async editPublicUser(newUser, jwt) {
    const request = {
      method: "put",
      baseURL: this.baseURL + `/user_admin/${newUser.id}`,
      headers: this.auth_headers(jwt),
      data: { user: newUser },
    };
    let response = await this.executeQuery(request);
    return response.data;
  }
  /**
   * Delete the user
   * @param userID
   * @param {String} jwt - JWT of the logged in user
   * @returns {Promise}
   */
  async deletePublicUser(userID, jwt) {
    const request = {
      method: "delete",
      baseURL: this.baseURL + `/user_admin/${userID}`,
      headers: this.auth_headers(jwt),
    };
    let response = await this.executeQuery(request);
    return response.data;
  }
  /**
   * Verify that the given JWT is still valid
   * @param {String} jwt - the token to validate
   * @returns {Promise}
   */
  async validateToken(jwt) {
    const request = {
      method: "get",
      baseURL: this.baseURL + "/users/valid",
      headers: this.auth_headers(jwt),
    };
    let response = await this.executeQuery(request);
    return response.data;
  }

  /* EDITORS METHODS */

  /**
   * Post the given object to the API to create the corresponding record.
   * @param record
   * @param {String} jwt - JWT of the logged in user
   * @returns {Promise}
   */
  async createRecord(record, jwt) {
    const request = {
      method: "post",
      baseURL: this.baseURL + "/fairsharing_records",
      headers: this.auth_headers(jwt),
      data: { fairsharing_record: record },
    };
    let response = await this.executeQuery(request);
    return response.data;
  }

  /**
   * Update the given record
   * @param {Object} record - the record to update containing the ID to target, the new values
   * and the user token
   * @returns {Promise}
   */
  async updateRecord(record) {
    const request = {
      method: "put",
      baseURL: this.baseURL + "/fairsharing_records/" + record.id,
      headers: this.auth_headers(record.token),
      data: { fairsharing_record: record.record },
    };
    let response = await this.executeQuery(request);
    return response.data;
  }

  /**
   * Determine if a user has permission to edit this record.
   * @param {Integer} recordID - ID for the relevant FairsharingRecord.
   * @param {String} userToken - JWT of the logged in user
   * @returns {Promise}
   */
  async canEdit(recordID, userToken) {
    const request = {
      method: "get",
      baseURL: this.baseURL + "/fairsharing_records/can_edit/" + recordID,
      headers: this.auth_headers(userToken),
    };
    let response = await this.executeQuery(request);
    return response.data;
  }

  /**
   * Attempt to create a MaintenanceRequest for a user for a FairsharingRecord.
   * @param {Integer} recordID - ID for the relevant FairsharingRecord.
   * @param {String} userToken - JWT of the logged in user
   * @returns {Promise}
   */
  async claimRecord(recordID, userToken) {
    const request = {
      method: "post",
      baseURL: this.baseURL + "/maintenance_requests",
      headers: this.auth_headers(userToken),
      data: { maintenance_request: { fairsharing_record_id: recordID } },
    };
    let response = await this.executeQuery(request);
    return response.data;
  }

  /**
   * Determine if a user has permission to create a MaintenanceRequest for a FairsharingRecord.
   * @param {Integer} recordID - ID for the relevant FairsharingRecord.
   * @param {String} userToken - JWT of the logged in user
   * @returns {Promise}
   */
  async canClaim(recordID, userToken) {
    const request = {
      method: "get",
      baseURL: this.baseURL + "/maintenance_requests/existing/" + recordID,
      headers: this.auth_headers(userToken),
    };
    let response = await this.executeQuery(request);
    return response.data;
  }

  /**
   * Remove an existing maintainer from a FairsharingRecord.
   * @param {Integer} recordID - ID for the relevant FairsharingRecord.
   * @param {String} userToken - JWT of the logged in user
   * @returns {Promise}
   */
  // TODO: Coverage steadfastly refuses to see this even though it is mocked and called
  // in a test (see Record.spec.js).
  async removeMaintainer(recordID, userToken) {
    const request = {
      method: "post",
      baseURL: this.baseURL + "/maintenance_requests/remove",
      headers: this.auth_headers(userToken),
      data: { maintenance_request: { fairsharing_record_id: recordID } },
    };
    let response = await this.executeQuery(request);
    return response.data;
  }

  /**
   * Add or remove an watcher to/from a FairsharingRecord.
   * @param {Integer} recordID - ID for the relevant FairsharingRecord.
   * @param {String} operation - 'add' or 'remove'.
   * @param {String} userToken - JWT of the logged in user
   * @returns {Promise}
   */
  // TODO: Mocking this in a test (5c40b02ba3d78a49a088ab6dd5145c9ea10ea24b)
  // caused it to no longer be covered!
  async changeWatcher(recordID, operation, userToken) {
    const request = {
      method: "post",
      baseURL: this.baseURL + "/fairsharing_records/watch",
      headers: this.auth_headers(userToken),
      data: {
        record_id: recordID,
        operation: operation,
      },
    };
    let response = await this.executeQuery(request);
    return response.data;
  }

  /**
   * Attempt to create a RecordReview for a user for a FairsharingRecord.
   * @param {Integer} recordID - ID for the relevant FairsharingRecord.
   * @param {String} userToken - JWT of the logged in user
   * @returns {Promise}
   */
  async reviewRecord(recordID, userToken) {
    const request = {
      method: "post",
      baseURL: this.baseURL + "/record_reviews",
      headers: this.auth_headers(userToken),
      data: { record_review: { fairsharing_record_id: recordID } },
    };
    let response = await this.executeQuery(request);
    return response.data;
  }

  /* USER DEFINED TAGS */

  /**
   * Create a new user defined tag in the database for users to tag their records.
   * @param {String} term - the string value of the term
   * @param {String} token - the user JWT
   * @returns {Promise}
   */
  async createNewUserDefinedTag(term, token) {
    const request = {
      method: "post",
      baseURL: this.baseURL + "/user_defined_tags",
      headers: this.auth_headers(token),
      data: { user_defined_tag: { label: term } },
    };
    let response = await this.executeQuery(request);
    return response.data;
  }

  /* LICENCES */

  /**
   * Create new a licence link
   * @param {Object} licenceLink - the licence link to create
   * @param {String} token - the user token
   * @returns {Promise}
   */
  async createLicenceLink(licenceLink, token) {
    let _client = this;
    const request = {
      method: "post",
      baseURL: _client.baseURL + "/licence_links",
      headers: this.auth_headers(token),
      data: { licence_link: licenceLink },
    };
    let response = await _client.executeQuery(request);
    return response.data;
  }

  /**
   * Delete the given licence
   * @param {Number} id - id of the licence link to delete
   * @param {String} token - the user token
   * @returns {Promise}
   */
  async deleteLicenceLink(id, token) {
    let _client = this;
    const request = {
      method: "delete",
      baseURL: _client.baseURL + "/licence_links/" + id,
      headers: this.auth_headers(token),
    };
    let response = await _client.executeQuery(request);
    return response.data;
  }

  /**
   * Update the licenceLink
   * @param {Object} licenceLink - the new values for the licence link
   * @param {String} token the user token
   * @returns {Promise}
   */
  async updateLicenceLink(licenceLink, token) {
    let _client = this;
    const request = {
      method: "put",
      baseURL: _client.baseURL + "/licence_links/" + licenceLink.id,
      headers: this.auth_headers(token),
      data: { licence_link: licenceLink },
    };
    let response = await _client.executeQuery(request);
    return response.data;
  }

  /* PUBLICATIONS */

  async createPublication(publication, token) {
    let _client = this;
    const request = {
      method: "post",
      baseURL: _client.baseURL + "/publications",
      headers: this.auth_headers(token),
      data: { publication: publication },
    };
    let response = await _client.executeQuery(request);
    return response.data;
  }

  async editPublication(publication, token) {
    let _client = this;
    const request = {
      method: "put",
      baseURL: _client.baseURL + "/publications/" + publication.id,
      headers: this.auth_headers(token),
      data: { publication: publication },
    };
    let response = await _client.executeQuery(request);
    return response.data;
  }

  /* RELATIONSHIPS BETWEEN RECORDS */
  /**
   * Saves the relationships as an array of items containing a targetID, a sourceID and a labelID
   * @param {Object} options - the options to pass as {token: String, relations: Array}
   * @returns {Promise}
   */
  async saveRelations(options) {
    if (options.relations.length > 0) {
      const request = {
        method: "put",
        baseURL: this.baseURL + "/fairsharing_records/" + options.target,
        headers: this.auth_headers(options.token),
        data: {
          fairsharing_record: {
            record_associations_attributes: options.relations,
          },
        },
      };
      let response = await this.executeQuery(request);
      return response.data;
    }
    return {};
  }

  /**
   * Deletes the relationships as an array of items containing a targetID, a sourceID and a labelID
   * @param {Object} options - the options to pass as {token: String, relations: Array}
   * @returns {Promise}
   */
  async deleteRelations(options) {
    if (options.relations.length > 0) {
      const request = {
        method: "put",
        baseURL: this.baseURL + "/fairsharing_records/" + options.target,
        headers: this.auth_headers(options.token),
        data: {
          fairsharing_record: {
            record_associations_attributes: options.relations,
          },
        },
      };
      let response = await this.executeQuery(request);
      return response.data;
    }
    return {};
  }

  /* ORGANISATIONS AND GRANTS */
  /**
   * Create a given organisation
   * @param {Object} organisation
   * @param {String} userToken - the user jwt
   * @returns {Promise}
   */
  async createOrganisation(organisation, userToken) {
    let _client = this;
    const request = {
      method: "post",
      baseURL: _client.baseURL + "/organisations",
      headers: this.auth_headers(userToken),
      data: { organisation: organisation },
    };
    let response = await _client.executeQuery(request);
    return response.data;
  }

  /**
   * Edit a given organisation
   * @param {Object} organisation
   * @param {Number} id
   * @param {String} userToken - the user jwt
   * @returns {Promise}
   */
  async editOrganisation(organisation, id, userToken) {
    let _client = this;
    const request = {
      method: "put",
      baseURL: _client.baseURL + "/organisations/" + id,
      headers: this.auth_headers(userToken),
      data: { organisation: organisation },
    };
    let response = await _client.executeQuery(request);
    return response.data;
  }

  /**
   * Delete the given organisation link
   * @param {Number} organisationId - the id of the link to remove
   * @param {String} userToken - the user jwt
   * @returns {Promise}
   */
  async deleteOrganisation(organisationId, userToken) {
    let _client = this;
    const request = {
      method: "delete",
      baseURL: _client.baseURL + "/organisations/" + organisationId,
      headers: this.auth_headers(userToken),
    };
    let response = await _client.executeQuery(request);
    return response.data;
  }

  /**
   * Create a given grant
   * @param {Object} grant
   * @param {String} userToken - the user jwt
   * @returns {Promise}
   */
  async createGrant(grant, userToken) {
    let _client = this;
    const request = {
      method: "post",
      baseURL: _client.baseURL + "/grants",
      headers: this.auth_headers(userToken),
      data: { grant: grant },
    };
    let response = await _client.executeQuery(request);
    return response.data;
  }

  /**
   * Create a new link between an organisation, a record and an optional grant.
   * @param {Object} organisationLink - the organisation link to create
   * @param {String} userToken - the user jwt
   * @returns {Promise}
   */
  async createOrganisationLink(organisationLink, userToken) {
    let _client = this;
    const request = {
      method: "post",
      baseURL: _client.baseURL + "/organisation_links",
      headers: this.auth_headers(userToken),
      data: { organisation_link: organisationLink },
    };
    let response = await _client.executeQuery(request);
    return response.data;
  }

  /**
   * Update the organisationLink given from linkID input with the given organisationLink
   * @param {Object} organisationLink - the new organisation link value
   * @param {Number} linkID - ID of the organisationLink to update
   * @param {String} userToken - the user jwt
   * @returns {Promise}
   */
  async updateOrganisationLink(organisationLink, linkID, userToken) {
    let _client = this;
    const request = {
      method: "put",
      baseURL: _client.baseURL + "/organisation_links/" + linkID,
      headers: this.auth_headers(userToken),
      data: { organisation_link: organisationLink },
    };
    let response = await _client.executeQuery(request);
    return response.data;
  }

  /**
   * Delete the given organisation link
   * @param {Number} linkID - the id of the link to remove
   * @param {String} userToken - the user jwt
   * @returns {Promise}
   */
  async deleteOrganisationLink(linkID, userToken) {
    let _client = this;
    const request = {
      method: "delete",
      baseURL: _client.baseURL + "/organisation_links/" + linkID,
      headers: this.auth_headers(userToken),
    };
    let response = await _client.executeQuery(request);
    return response.data;
  }

  /**
   * Get the extra metadata fields for a RecordType
   * @param {String} type - name of the record type.
   * @param {String} userToken - the user jwt
   * @returns {Promise}
   */
  async extraMetadataFields(type, userToken) {
    const request = {
      method: "post",
      baseURL: this.baseURL + "/fairsharing_records/metadata_fields",
      headers: this.auth_headers(userToken),
      data: { type: type },
    };
    let response = await this.executeQuery(request);
    return response.data;
  }

  /* METHODS FOR CURATION */
  /**
   * Update the maintenanceRequest given the new status value
   * @param {Number} maintenanceRequest  ID of the maintenanceRequest to update
   * @param {string} newStatus - new status to update
   * @param {String} userToken - the user jwt
   * @returns {Promise}
   */
  async updateStatusMaintenanceRequest(
    maintenanceRequest,
    newStatus,
    userToken,
  ) {
    let _client = this;
    const request = {
      method: "put",
      baseURL: _client.baseURL + "/maintenance_requests/" + maintenanceRequest,
      headers: this.auth_headers(userToken),
      data: { maintenance_request: { status: newStatus } },
    };
    let response = await _client.executeQuery(request);
    return response.data;
  }

  /**
   * Delete Record
   * @param {Number} id - id of the record link to delete
   * @param {String} token - the user token
   * @returns {Promise}
   */
  async deleteRecord(id, token) {
    let _client = this;
    const request = {
      method: "delete",
      baseURL: _client.baseURL + "/fairsharing_records/" + id,
      headers: this.auth_headers(token),
    };
    let response = await _client.executeQuery(request);
    return response.data;
  }

  /**
   * Get the list of allowed relation types for editing record's relationships.
   * @returns {Promise}
   */
  /* EDITOR DATA */
  async getRelationsTypes() {
    let _client = this;
    const request = {
      method: "get",
      baseURL: _client.baseURL + "/record_associations/allowed",
    };
    let response = await _client.executeQuery(request);
    return response.data;
  }

  /**
   * Get the list of available profile types for a user.
   * @returns {Promise}
   */
  async getProfileTypes() {
    const request = {
      method: "get",
      baseURL: this.baseURL + "/users/profile_types",
      headers: this.headers,
    };
    let response = await this.executeQuery(request);
    return response.data;
  }

  /**
   * Get the list of available roles for a user.
   * @returns {Promise}
   * @param {String} token - the user token
   */
  // Coverage steadfastly refuses to see this even though it is mocked and called
  // in a test (see EditPublicProfile.spec.js).
  async getUserRoles(userToken) {
    const request = {
      method: "get",
      baseURL: this.baseURL + "/user_roles",
      headers: this.auth_headers(userToken),
    };
    let response = await this.executeQuery(request);
    return response.data;
  }

  /* SYSTEM MESSAGES */
  /**
   * Update the given message
   * @param {Object} message - the message to update containing the ID to target and the new values
   * @param {String} userToken - the user jwt
   * @returns {Promise}
   */
  async updateMessage(message, userToken) {
    const request = {
      method: "put",
      baseURL: this.baseURL + "/messages/" + message.id,
      headers: this.auth_headers(userToken),
      data: { message: message },
    };
    let response = await this.executeQuery(request);
    return response.data;
  }

  /**
   * Update the given message
   * @param {Object} message - the message to create
   * @param {String} userToken - the user jwt
   * @returns {Promise}
   */
  async createMessage(message, userToken) {
    const request = {
      method: "post",
      baseURL: this.baseURL + "/messages/",
      headers: this.auth_headers(userToken),
      data: { message: message },
    };
    let response = await this.executeQuery(request);
    return response.data;
  }

  /**
   * Update the given message
   * @param {String} messageId - the ID of the message to delete
   * @param {String} userToken - the user jwt
   * @returns {Promise}
   */
  async deleteMessage(messageId, userToken) {
    const request = {
      method: "delete",
      baseURL: this.baseURL + "/messages/" + messageId,
      headers: this.auth_headers(userToken),
    };
    let response = await this.executeQuery(request);
    return response.data;
  }

  /* EXTRA METHODS */

  /**
   * Trigger the given query with Axios
   * @param query
   * @returns {Promise<*>}
   */
  async executeQuery(query) {
    try {
      return await axios(query);
    } catch (e) {
      return { data: { error: e } };
    }
  }

  /**
   * Get records without DOIS
   * @param {String} token - the user token that needs to be a curator
   * @returns {Promise}
   */
  async getRecordsWoDOIs(userToken) {
    let _client = this;
    const request = {
      method: "get",
      baseURL: _client.baseURL + "/files/no_dois",
      headers: this.auth_headers(userToken),
    };
    let response = await _client.executeQuery(request);
    return response.data;
  }

  /**
   * Get count of records created by month
   * @param {String} token - the user token that needs to be a curator
   * @returns {Promise}
   */
  async getRecordCreatedByMonth(userToken) {
    let _client = this;
    const request = {
      method: "get",
      baseURL: _client.baseURL + "/files/creation_dates",
      headers: this.auth_headers(userToken),
    };
    let response = await _client.executeQuery(request);
    return response.data;
  }

  /**
   * Get count of edits by month
   * @param {String} token - the user token that needs to be a curator
   * @returns {Promise}
   */
  async getEditByMonth(userToken) {
    let _client = this;
    const request = {
      method: "get",
      baseURL: _client.baseURL + "/files/edit_dates",
      headers: this.auth_headers(userToken),
    };
    let response = await _client.executeQuery(request);
    return response.data;
  }
  /**
   * Get Zenodo call
   * @param {String} call
   * @param {String} userToken - the user jwt
   * @returns {Promise}
   */
  async getZenodoSearch(text, userToken) {
    let _client = this;
    const request = {
      method: "post",
      baseURL: _client.baseURL + "/zenodo",
      headers: this.auth_headers(userToken),
      data: { doi: text },
    };
    let response = await _client.executeQuery(request);
    return response.data;
  }

  async clearLogo(id, token) {
    let _client = this;
    const request = {
      method: "put",
      baseURL: _client.baseURL + "/fairsharing_records/" + id,
      headers: _client.auth_headers(token),
      data: {
        fairsharing_record: {
          logo: {},
        },
      },
    };
    let response = await _client.executeQuery(request);
    // here the data returned always should be either an array of images or one string of image
    return response.data;
  }

  /**
   * Get statistics data without users
   * @returns {Promise}
   */
  async getStatisticsData() {
    let _client = this;
    const request = {
      method: "get",
      baseURL: _client.baseURL + "/homepage_stats",
    };
    let response = await _client.executeQuery(request);
    return response.data;
  }

  /**
   * Get JSON+LD for homepage.
   * @returns {Promise}
   */
  async getHomepageJsonld() {
    let _client = this;
    const request = {
      method: "get",
      baseURL: _client.baseURL + "/homepage_jsonld",
    };
    let response = await _client.executeQuery(request);
    return response.data;
  }

  /**
   * Send the verification link for a given user
   * @param {Object} user - contains the email, uid, identifier of the user.
   * @returns {Promise}
   */
  async sendOrcidVerification(user) {
    let _client = this;
    const request = {
      method: "post",
      baseURL: this.baseURL + "/users/auth/identify_user",
      headers: this.auth_headers(user),
      data: { user: user },
    };
    let response = await _client.executeQuery(request);
    return response.data;
  }

  /**
   * Save the advancedSearch results to the user
   * @param {Object} saveSearchObj - save search object having required parameters
   * @param {String} jwt - the user jwt
   * @returns {Promise}
   */
  /* Ignoring because of 401 access denied in test case */
  async saveSearch(saveSearchObj, jwt) {
    let _client = this;
    const request = {
      method: "post",
      baseURL: _client.baseURL + "/saved_searches",
      headers: this.auth_headers(jwt),
      data: { saved_search: saveSearchObj },
    };
    let response = await _client.executeQuery(request);
    return response.data;
  }

  /**
   * Delete the saved search
   * @param {Number} savedSearchId - the id of the savedSearch to remove
   * @param {String} userToken - the user jwt
   * @returns {Promise}
   */
  /* Ignoring because of 401 access denied in test case */
  async deleteSavedSearch(savedSearchId, jwt) {
    let _client = this;
    const request = {
      method: "delete",
      baseURL: _client.baseURL + "/saved_searches/" + savedSearchId,
      headers: this.auth_headers(jwt),
    };
    let response = await _client.executeQuery(request);
    return response.data;
  }

  /**
   * Update the saved search
   * @param {Number} saveSearchId - save search id
   * @param {Object} saveSearchObj - save search object having required parameters
   * @param {String} jwt the user token
   * @returns {Promise}
   */
  /* Ignoring because of 401 access denied in test case */
  async updateSaveSearch(saveSearchId, saveSearchObj, jwt) {
    let _client = this;
    const request = {
      method: "put",
      baseURL: _client.baseURL + "/saved_searches/" + saveSearchId,
      headers: this.auth_headers(jwt),
      data: { saved_search: saveSearchObj },
    };
    let response = await _client.executeQuery(request);
    return response.data;
  }

  /**
   * Create processing note of the given record
   * @param noteText {String} Processing Notes
   * @param recordId {Number} FAIRsharing record Id
   * @param jwt {String} the user token
   * @return {Promise<*>}
   */
  async createProcessingNotes(noteText, recordId, jwt) {
    const request = {
      method: "post",
      baseURL: this.baseURL + "/processing_notes/",
      headers: this.auth_headers(jwt),
      data: {
        processing_note: {
          note: noteText,
          fairsharing_record_id: recordId,
        },
      },
    };
    let response = await this.executeQuery(request);
    return response.data;
  }

  /**
   * Update processing note of the given record
   * @param noteId {Number} Processing Note Id
   * @param noteText {String} Processing Notes
   * @param recordId {Number} FAIRsharing record Id
   * @param jwt {String} the user token
   * @return {Promise<*>}
   */
  async updateProcessingNotes(noteId, noteText, recordId, jwt) {
    const request = {
      method: "put",
      baseURL: this.baseURL + "/processing_notes/" + noteId,
      headers: this.auth_headers(jwt),
      data: {
        processing_note: {
          note: noteText,
          fairsharing_record_id: recordId,
        },
      },
    };
    let response = await this.executeQuery(request);
    return response.data;
  }

  /**
   * Delete processing note of the given record
   * @param noteId {Number} Processing Note Id
   * @param jwt {String} the user token
   * @return {Promise<*>}
   */
  async deleteProcessingNote(noteId, jwt) {
    const request = {
      method: "delete",
      baseURL: this.baseURL + "/processing_notes/" + noteId,
      headers: this.auth_headers(jwt),
    };
    return await this.executeQuery(request);
  }
}

export default RESTClient;

FAIRsharing / fairsharing.github.io / 25737361825

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous