How to use imgur - 10 common examples

export default async function () {
  imgur.setClientId(this.config.imgur)

  const screenshot = await this.driver.takeScreenshot()

  return imgur.uploadBase64(screenshot.toString('base64'))
    /* eslint-disable no-console */
    .then((json) => {
      console.log('---------------------------------------------------')
      console.log('SCREEENSHOT URL:', json.data.link)
      console.log('---------------------------------------------------')
      return json.data
    })
    .catch((error) => {
      console.log('---------------------------------------------------')
      console.error('Failed to save screenshot:', error.message)
      console.log('---------------------------------------------------')
    })

export default async function () {
  imgur.setClientId(this.config.imgur)

  const screenshot = await this.driver.takeScreenshot()

  return imgur.uploadBase64(screenshot.toString('base64'))
    /* eslint-disable no-console */
    .then((json) => {
      console.log('---------------------------------------------------')
      console.log('SCREEENSHOT URL:', json.data.link)
      console.log('---------------------------------------------------')
      return json.data
    })
    .catch((error) => {
      console.log('---------------------------------------------------')
      console.error('Failed to save screenshot:', error.message)
      console.log('---------------------------------------------------')
    })
    /* eslint-enable no-console */
}

.then((event) => {
    const newEventInfo = req.body;
    if (newEventInfo.base64Image) {
      // send it up to imgur
      imgur.uploadBase64(newEventInfo.base64Image)
      .then((imgurResponse) => {
        newEventInfo.eventPictureUri = imgurResponse.data.link;
        delete newEventInfo.base64Image;
        event.update(newEventInfo)
        .then(event => res.json(event));
      })
      .catch((err) => {
        res.json({ message: 'error updating user' });
        console.error(err.message);
      });
    } else {
      event.updateEvent(newEventInfo)
      .then((event) => res.json(event));
    }
  })
  .catch(err => {

.then(conflictingUser => {
        if (conflictingUser && conflictingUser.id !== user.id) {
          return next(new HttpError(409, 'Username already taken'));
        }
        // newUser = get updated properties from user
        const newUserInfo = req.body;
        // if we recieved a new base64 encoded profile profile picture
        if (newUserInfo.base64Image) {
          // send it up to imgur
          imgur.uploadBase64(newUserInfo.base64Image)
          .then((imgurResponse) => {
            newUserInfo.profilePictureUri = imgurResponse.data.link;
            delete newUserInfo.base64Image;
            user.update(newUserInfo)
            .then(user => {
              res.json(newUserInfo);
            });
          })
          .catch((err) => {
            res.json({ message: 'error updating user' });
            console.error(err.message);
          });
        } else {
          user.update(newUserInfo)
          .then(user => res.json(newUserInfo));
        }

client.on('message', (t, m) => {
  const size = m.length;
  log(`client on topic ${t}, received ${size} bytes.`)

  if (t === topicDashboardInferenceResult) {
    const result = m.toString();
    LINEClient.pushMessage(targetUserID, { type: 'text', text: result });
    return;
  }

  // save image to file and upload it to imgur for display in LINE message
  const snapshot_path = m.toString();
  imgur.uploadFile(snapshot_path)
    .then((json) => {
      var imgurLink = json.data.link;
      imgurLink = imgurLink.replace('http:\/\/', 'https:\/\/');
      log(`An image has been uploaded to imgur. link: ${imgurLink}`);

      // Image can only be delivered via 'https://' URL, 'http://' doesn't work
      LINEClient.pushMessage(targetUserID, { type: 'image',
                                             originalContentUrl: imgurLink,
                                             previewImageUrl: imgurLink })
        .then((v) => {
          log(`A message sent to ${targetUserID} successfully.`);
        })
        .catch((err) => {
          log(`An error occurred, ${err}.`);
        });
    })

const filePath = await tg.downloadFile(fileId, downloadDirPath);

            const fileContentBuffer = await fs.readFile(filePath);
            const md5Hash = md5(fileContentBuffer);

            if (!linkCache.has(md5Hash)) {

                /* Imgur doesn't allow webp, so convert them to png. */
                let uploadableFilePath = filePath;
                if (path.extname(filePath) === '.webp') {
                    const convertedFilePath = filePath + '.png';
                    uploadableFilePath = await convertWebpToPng(filePath, convertedFilePath);
                }

                const imgurData = await imgur.uploadFile(uploadableFilePath);

                linkCache.set(md5Hash, imgurData.data.link);

                /* Not waiting for this write, because it doesn't matter when it
                * finishes. */
                fs.writeJson(linkCacheFilePath, [...linkCache]);
            }
            const imgurLink = linkCache.get(md5Hash);

            /* Cleanup. Not waiting for this. */
            fs.remove(downloadDirPath);

            return imgurLink;

        } catch (error) {
            logger.error(error);

cwd = process.cwd() + '/build/'
        }
        else {
        	cwd = process.cwd();
        }

        let image_files = []
        let images = []
        await glob.glob(['*.png', '*/*.png', '*.jpg', '*/*.jpg', '*.gif', '*/*.gif'], {cwd: cwd}).then(imgs => {
            for (var i = imgs.length - 1; i >= 0; i--) {
                image_files[i] = `${imgs[i]}`
            }
        })

        for (var i = image_files.length - 1; i >= 0; i--) {
            await imgur.uploadFile(`${cwd}/${image_files[i]}`).then(json => {
                images[i] = {
                    path: image_files[i],
                    url: json.data.link
                }
            })
        }

        // check if pro before pushing files | might use this later
        // let pro = request.post('https://api.1mb.site', {
        //     form: {
        //         action: 'pro',
        //         site: username,
        //         key: key
        //     }
        // }, (error, response, body) => {
        // 	return body.error || error;

const configDir = path.dirname(argv.c || path.join(os.homedir(), '.teleirc', 'config.js'));
const linkCacheFilePath = path.join(configDir, 'imgurLinkCache.json');

let linkCacheData = [];
try {
    if (fs.pathExistsSync(linkCacheFilePath)) {
        linkCacheData = fs.readJsonSync(linkCacheFilePath);
    }
} catch (error) {
    logger.error(error);
}
const linkCache = new LRU(config.imgurLinkCacheSize, linkCacheData);

if (config.uploadToImgur) {
    imgur.setClientId(config.imgurClientId);
}

exports.uploadToImgur = function(fileId, config, tg, callback) {

    /* Kind of a hack to get an async function to complete with a callback. */
    async function impl() {

        try {
            const downloadDirPath = await fs.mkdtemp(path.join(os.tmpdir(), 'teleirc-'));

            const filePath = await tg.downloadFile(fileId, downloadDirPath);

            const fileContentBuffer = await fs.readFile(filePath);
            const md5Hash = md5(fileContentBuffer);

            if (!linkCache.has(md5Hash)) {

const glob = require('glob-gitignore')

const {Command, flags} = require('@oclif/command')
const Configstore = require('configstore')
const fs = require('fs')
const request = require('request')

const conf = new Configstore('1mb-cli')
const parse = require('parse-gitignore')
const {cli} = require('cli-ux')
const path = require('path')
const imgur = require('imgur')

// imgur.setClientId('aCs53GSs4tga0ikp');
imgur.setAPIUrl('https://api.imgur.com/3/')

class DeployCommand extends Command {
    async run() {
        const {flags} = this.parse(DeployCommand)
        const self = this

        if (flags.clearcreds === true) {
            conf.clear()
        }

        let username = conf.get('username')
        if (typeof username === 'undefined') {
            username = await cli.prompt('What is your 1mbsite username?')
        }

        let key = conf.get('key')

files.forEach(function(file){
        imgur.uploadFile(testConfig.comparisonPath + file)
          .then(function (json) {
            $.util.log($.util.colors.red(file) + $.util.colors.cyan(' -> ') + json.data.link);

          })
          .catch(function (err) {
            console.error(err.message);
          });
      });
    }