github.com/muhammedhassanm/blockchain@v0.0.0-20200120143007-697261defd4d/build-blockchain-insurance-app-master/web/www/blockchain/insurancePeer.js (about)

     1  'use strict';
     2  
     3  import config from './config';
     4  import { wrapError } from './utils';
     5  import { insuranceClient as client, isReady } from './setup';
     6  import uuidV4 from 'uuid/v4';
     7  
     8  export async function getContractTypes() {
     9    if (!isReady()) {
    10      return;
    11    }
    12    try {
    13      const contractTypes = await query('contract_type_ls');
    14      return contractTypes;
    15    } catch (e) {
    16      throw wrapError(`Error getting contract types: ${e.message}`, e);
    17    }
    18  }
    19  
    20  export async function createContractType(contractType) {
    21    if (!isReady()) {
    22      return;
    23    }
    24    try {
    25      let ct = contractType.uuid ? contractType :
    26        Object.assign({ uuid: uuidV4() }, contractType);
    27      const successResult = await invoke('contract_type_create', ct);
    28      if (successResult) {
    29        throw new Error(successResult);
    30      }
    31      return ct.uuid;
    32    } catch (e) {
    33      throw wrapError(`Error creating contract type: ${e.message}`, e);
    34    }
    35  }
    36  
    37  export async function setActiveContractType(uuid, active) {
    38    if (!isReady()) {
    39      return;
    40    }
    41    try {
    42      const successResult = await invoke('contract_type_set_active',
    43        { uuid, active });
    44      if (successResult) {
    45        throw new Error(successResult);
    46      }
    47      return successResult;
    48    } catch (e) {
    49      throw wrapError(`Error setting active contract type: ${e.message}`, e);
    50    }
    51  }
    52  
    53  export async function getContracts(username) {
    54    if (!isReady()) {
    55      return;
    56    }
    57    try {
    58      if (typeof username !== 'string') {
    59        username = undefined;
    60      }
    61      const contracts = await query('contract_ls', { username });
    62      return contracts;
    63    } catch (e) {
    64      let errMessage;
    65      if (username) {
    66        errMessage = `Error getting contracts for user ${username}: ${e.message}`;
    67      } else {
    68        errMessage = `Error getting all contracts: ${e.message}`;
    69      }
    70      throw wrapError(errMessage, e);
    71    }
    72  }
    73  
    74  export async function getClaims(status) {
    75    if (!isReady()) {
    76      return;
    77    }
    78    try {
    79      if (typeof status !== 'string') {
    80        status = undefined;
    81      }
    82      const claims = await query('claim_ls', { status });
    83      return claims;
    84    } catch (e) {
    85      let errMessage;
    86      if (status) {
    87        errMessage = `Error getting claims with status ${status}: ${e.message}`;
    88      } else {
    89        errMessage = `Error getting all claims: ${e.message}`;
    90      }
    91      throw wrapError(errMessage, e);
    92    }
    93  }
    94  
    95  export async function fileClaim(claim) {
    96    if (!isReady()) {
    97      return;
    98    }
    99    try {
   100      const c = Object.assign({}, claim, { uuid: uuidV4() });
   101      const successResult = await invoke('claim_file', c);
   102      if (successResult) {
   103        throw new Error(successResult);
   104      }
   105      return c.uuid;
   106    } catch (e) {
   107      throw wrapError(`Error filing a new claim: ${e.message}`, e);
   108    }
   109  }
   110  
   111  export async function processClaim(contractUuid, uuid, status, reimbursable) {
   112    if (!isReady()) {
   113      return;
   114    }
   115    try {
   116      const successResult = await invoke('claim_process', { contractUuid, uuid, status, reimbursable });
   117      if (successResult) {
   118        throw new Error(successResult);
   119      }
   120      return successResult;
   121    } catch (e) {
   122      throw wrapError(`Error processing claim: ${e.message}`, e);
   123    }
   124  }
   125  
   126  export async function authenticateUser(username, password) {
   127    if (!isReady()) {
   128      return;
   129    }
   130    try {
   131      let authenticated = await query('user_authenticate', { username, password });
   132      if (authenticated === undefined || authenticated === null) {
   133        throw new Error('Unknown error, invalid response!');
   134      }
   135      return authenticated;
   136    } catch (e) {
   137      throw wrapError(`Error authenticating user: ${e.message}`, e);
   138    }
   139  }
   140  
   141  export async function getUserInfo(username) {
   142    if (!isReady()) {
   143      return;
   144    }
   145    try {
   146      const user = await query('user_get_info', { username });
   147      return user;
   148    } catch (e) {
   149      throw wrapError(`Error getting user info: ${e.message}`, e);
   150    }
   151  }
   152  
   153  export function getBlocks(noOfLastBlocks) {
   154    return client.getBlocks(noOfLastBlocks);
   155  }
   156  
   157  export const on = client.on.bind(client);
   158  export const once = client.once.bind(client);
   159  export const addListener = client.addListener.bind(client);
   160  export const prependListener = client.prependListener.bind(client);
   161  export const removeListener = client.removeListener.bind(client);
   162  
   163  function invoke(fcn, ...args) {
   164    return client.invoke(
   165      config.chaincodeId, config.chaincodeVersion, fcn, ...args);
   166  }
   167  
   168  function query(fcn, ...args) {
   169    return client.query(
   170      config.chaincodeId, config.chaincodeVersion, fcn, ...args);
   171  }