spee.ch/controllers/serveController.js

const lbryApi = require('../helpers/libraries/lbryApi.js');
const db = require('../models');

const getAllFreePublicClaims = require('../helpers/functions/getAllFreePublicClaims.js');
const isFreePublicClaim = require('../helpers/functions/isFreePublicClaim.js');

function getClaimAndHandleResponse (claimUri, resolve, reject) {
  lbryApi
    .getClaim(claimUri)
    .then(({ file_name, download_path, mime_type }) => {
      resolve({
        file_name,
        file_path: download_path,
        file_type: mime_type,
      });
    })
    .catch(error => {
      reject(error);
    });
}

module.exports = {
  getClaimByName (claimName) {
    const deferred = new Promise((resolve, reject) => {
      console.log('>> lbryHelpers >> getClaim BasedOnNameOnly:', claimName);
      // get all free public claims
      getAllFreePublicClaims(claimName)
        .then(freePublicClaimList => {
          const claimId = freePublicClaimList[0].claim_id;
          const name = freePublicClaimList[0].name;
          const freePublicClaimOutpoint = `${freePublicClaimList[0].txid}:${freePublicClaimList[0].nout}`;
          const freePublicClaimUri = name + '#' + claimId;
          console.log('>> Decided on public claim id:', claimId);
          // check to see if the file is available locally
          db.File
            .findOne({ where: { name: name, claim_id: claimId } })
            .then(claim => {
              // if a matching claim is found locally...
              if (claim) {
                console.log('>> A matching claim_id was found locally');
                // if the outpoint's match return it
                if (claim.dataValues.outpoint === freePublicClaimOutpoint) {
                  console.log('>> Local outpoint matched');
                  resolve(claim.dataValues);
                  // if the outpoint's don't match, fetch updated claim
                } else {
                  console.log('>> local outpoint did not match');
                  getClaimAndHandleResponse(freePublicClaimUri, resolve, reject);
                }
                // ... otherwise use daemon to retrieve it
              } else {
                // 'get' the claim
                getClaimAndHandleResponse(freePublicClaimUri, resolve, reject);
              }
            })
            .catch(error => {
              reject(error);
            });
        })
        .catch(error => {
          reject(error);
        });
    });
    return deferred;
  },
  getClaimByClaimId (claimName, claimId) {
    const deferred = new Promise((resolve, reject) => {
      const uri = `${claimName}#${claimId}`;
      console.log('>> lbryHelpers >> getClaimBasedOnUri:', uri);
      // resolve the Uri
      lbryApi
        .resolveUri(uri) // note: use 'spread' and make parallel with db.File.findOne()
        .then(result => {
          // note should just be 'result' returned.
          // get the outpoint
          const resolvedOutpoint = `${result[uri].claim.txid}:${result[uri].claim.nout}`;
          // check locally for the claim
          db.File
            .findOne({ where: { claim_id: claimId } })
            .then(claim => {
              // if a found locally...
              if (claim) {
                console.log('>> A matching claim_id was found locally');
                // if the outpoint's match return it
                if (claim.dataValues.outpoint === resolvedOutpoint) {
                  console.log('>> Local outpoint matched');
                  resolve(claim.dataValues);
                  // if the outpoint's don't match, fetch updated claim
                } else {
                  console.log('>> Local outpoint did not match');
                  getClaimAndHandleResponse(uri, resolve, reject);
                }
                // ... otherwise use daemon to retrieve it
              } else {
                // check to make sure it is free and public  (note: no need for another resolve?)
                if (isFreePublicClaim(result[uri].claim)) {
                  // 'get' the claim
                  getClaimAndHandleResponse(uri, resolve, reject);
                } else {
                  reject('NO_FREE_PUBLIC_CLAIMS');
                }
              }
            })
            .catch(error => {
              reject(error);
            });
        })
        .catch(error => {
          reject(error);
        });
    });
    return deferred;
  },
};