This code automates the process of connecting with LinkedIn contacts using Selenium to control a web browser. It takes a list of connections or a single connection as input and attempts to connect with a random subset of them.

Run example

npm run import -- "connect add friends linkedin"

connect add friends linkedin

var importer = require('../Core');
var glob = require('glob');
var path = require('path');
var fs = require('fs');
var runSeleniumCell = importer.import("run selenium cell");

var PROFILE_PATH = process.env.HOME || process.env.HOMEPATH || process.env.USERPROFILE;
var project = PROFILE_PATH + '/Conversations';


var listAllConnections, connectLinkedin, loginLinkedIn;
function addLinkedinConnections(conn, list) {
    var pages;
    return runSeleniumCell(['log in linkedin', 'connect on linkedin'])
        .then(r => {
            listAllConnections = r[1].listAllConnections;
            connectLinkedin = r[1].connectLinkedin;
            loginLinkedIn = r.loginLinkedIn;
            return loginLinkedIn();
        })
        .then(() => typeof conn === 'string' ? [conn] : (typeof conn !== 'undefined' ? conn : listAllConnections(list)))
        .then(pages => {
            const rand = Math.round(pages.length / 30 * Math.random()) * 30;
            console.log(pages.slice(rand, rand + 30));
            return importer.runAllPromises(pages.slice(rand, rand + 30).map(page => resolve => {
                return connectLinkedin(page, true)
                    .then(() => resolve(page))
                    .catch(e => resolve(e))
            }));
        })
        .then(r => {
            console.log(r);
            return r;
        })
}
module.exports = addLinkedinConnections;

// Import required modules
const { resolve, reject } = require('bluebird');
const glob = require('glob');
const path = require('path');
const fs = require('fs');
const { runSeleniumCell } = require('../Core');

// Define constants
const PROFILE_PATH = process.env.HOME
 ? process.env.HOME
  : (process.env.HOMEPATH? process.env.HOMEPATH : process.env.USERPROFILE);
const PROJECT_PATH = path.join(PROFILE_PATH, 'Conversations');

// Define functions
function addLinkedinConnections(conn, list) {
  return runSeleniumCell(['log in linkedin', 'connect on linkedin'])
   .then(result => {
      const { listAllConnections, connectLinkedin, loginLinkedIn } = result[1];
      return loginLinkedIn();
    })
   .then(() => {
      const connections = typeof conn ==='string'? [conn] : conn || listAllConnections();
      return connections;
    })
   .then((pages) => {
      // TODO: Calculate a more robust random offset
      const offset = Math.round(pages.length / 30 * Math.random()) * 30;
      const linksToConnect = pages.slice(offset, offset + 30);

      // TODO: Add logging for the connected links
      return runAllPromises(linksToConnect.map((page) => () => connectLinkedin(page, true)));
    })
   .then((results) => {
      console.log(results);
      return results;
    })
   .catch((error) => {
      console.error(error);
      throw error;
    });
}

// Helper function to run all promises
function runAllPromises(promises) {
  return Promise.map(promises, (promise) => promise(), { concurrency: 5 });
}

module.exports = addLinkedinConnections;

This code defines a function addLinkedinConnections that automates connecting with LinkedIn contacts.

Here's a breakdown:

1. Setup:

   • It imports necessary modules like runSeleniumCell for interacting with a web browser, glob for file handling, and fs for file system operations.
   • It defines paths for storing project data.

2. Function Logic:

   • addLinkedinConnections takes a conn (connection) and an optional list (list of connections) as input.
   • It first runs a Selenium cell to log in to LinkedIn and retrieve functions for listing connections (listAllConnections) and connecting with them (connectLinkedin).
   • It then either uses the provided conn or calls listAllConnections to get a list of connections.
   • It randomly selects a subset of connections and uses connectLinkedin to attempt to connect with each one.
   • Finally, it logs the results and returns them.

3. Key Points:

   • The code relies on Selenium to automate browser interactions.
   • It handles different input scenarios: a single connection or a list of connections.
   • It includes error handling and logging.

Let me know if you'd like a deeper dive into any specific part of the code!