@learnpack/learnpack 1.0.0 → 2.0.0

package/src/managers/session.js

@@ -1,83 +0,0 @@
-const Console = require('../utils/console');
-const api = require('../utils/api');
-
-const v = require('validator');
-const { ValidationError, InternalError } = require('../utils/errors');
-const moment = require('moment');
-const fs = require('fs');
-const cli = require("cli-ux").default
-const storage = require('node-persist');
-
-module.exports = {
-    sessionStarted: false,
-    token: null,
-    config: null,
-    currentCohort: null,
-    initialize: async function(){
-      if(!this.sessionStarted){
-
-        if(!this.config) throw InternalError('Configuration not found')
-        if(!fs.existsSync(this.config.dirPath)) fs.mkdirSync(this.config.dirPath)
-        await storage.init({ dir: `${this.config.dirPath}/.session` });
-        this.sessionStarted = true;
-      }
-      return true
-    },
-    setPayload: async function(value){
-      await this.initialize();
-      await storage.setItem('bc-payload', { token: this.token, ...value });
-      Console.debug("Payload successfuly found and set for "+value.email);
-      return true;
-    },
-    getPayload: async function(){
-      await this.initialize();
-      let payload = null;
-      try{
-         payload = await storage.getItem('bc-payload');
-      }
-      catch(err){
-        Console.debug("Error retriving session payload");
-      }
-      return payload;
-    },
-    isActive: function(){
-      if(this.token) return true;
-      else return false;
-    },
-    get: async function(configObj=null){
-      if(configObj) this.config = configObj.config;
-
-      await this.sync();
-      if(!this.isActive()) return null;
-
-      const payload = await this.getPayload();
-      return {
-        payload, token: this.token,
-      };
-    },
-    login: async function(){
-
-      var email = await cli.prompt('What is your email?')
-      if(!v.isEmail(email)) throw ValidationError('Invalid email');
-
-      var password = await cli.prompt('What is your password?', {type: 'hide'})
-
-      const data = await api.login(email, password);
-      if(data) this.start({ token: data.token, payload: data });
-
-    },
-    sync: async function(){
-      const payload = await this.getPayload();
-      if(payload) this.token = payload.token;
-    },
-    start: async function({ token, payload=null }){
-      if(!token) throw new Error("A token and email is needed to start a session");
-      this.token = token;
-      if(payload) if(await this.setPayload(payload)) Console.success(`Successfully logged in as ${payload.email}`);
-    },
-    destroy: async function(){
-        await storage.clear();
-        this.token = null;
-        Console.success('You have logged out');
-    }
-};

package/src/managers/socket.js

@@ -1,185 +0,0 @@
-let connect = require("socket.io");
-let Console = require("../utils/console");
-const queue = require("../utils/fileQueue");
-
-module.exports = {
-  socket: null,
-  config: null,
-  allowedActions: null,
-  isTestingEnvironment: false,
-  actionCallBacks: {
-    clean: (data, s) => {
-      s.logs = [];
-    },
-  },
-  addAllowed: function (actions) {
-    if (!Array.isArray(actions)) actions = [actions];
-
-    //avoid adding the "test" action if grading is disabled
-    if (actions.includes("test") && this.config.disable_grading)
-      actions = actions.filter((a) => a != "test");
-
-    //remove duplicates
-    this.allowedActions = this.allowedActions
-      .filter((a) => !actions.includes(a))
-      .concat(actions);
-  },
-  removeAllowed: function (actions) {
-    if (!Array.isArray(actions)) actions = [actions];
-    this.allowedActions = this.allowedActions.filter(
-      (a) => !actions.includes(a)
-    );
-  },
-  start: function (config, server, isTestingEnvironment = false) {
-    this.config = config;
-    this.isTestingEnvironment = isTestingEnvironment;
-
-    // remove test action if grading is disabled
-    this.allowedActions = config.actions.filter((act) =>
-      config.disable_grading ? act !== "test" : true
-    );
-
-    this.socket = connect(server);
-    this.socket.on("connection", (socket) => {
-      Console.debug(
-        "Connection with client successfully established",
-        this.allowedActions
-      );
-
-      if (!this.isTestingEnvironment) {
-        this.log("ready", ["Ready to compile or test..."]);
-      }
-
-      socket.on("compiler", ({ action, data }) => {
-        this.emit("clean", "pending", ["Working..."]);
-
-        if (typeof data.exerciseSlug == "undefined") {
-          this.log("internal-error", ["No exercise slug specified"]);
-          Console.error("No exercise slug especified");
-          return;
-        }
-
-        if (typeof this.actionCallBacks[action] == "function")
-          this.actionCallBacks[action](data);
-        else this.log("internal-error", ["Uknown action " + action]);
-      });
-    });
-  },
-  on: function (action, callBack) {
-    this.actionCallBacks[action] = callBack;
-  },
-  clean: function (status = "pending", logs = []) {
-    this.emit("clean", "pending", logs);
-  },
-  ask: function (questions = []) {
-    return new Promise((resolve, reject) => {
-      this.emit("ask", "pending", ["Waiting for input..."], questions);
-      this.on("input", ({ inputs }) => {
-        // Workaround to fix issue because null inputs
-        let isNull = false;
-        inputs.forEach((input) => {
-          if (input === null) {
-            isNull = true;
-          }
-        });
-
-        if (!isNull) {
-          resolve(inputs);
-        }
-      });
-    });
-  },
-  reload: function (files = null, exercises = null) {
-    this.emit("reload", files, exercises);
-  },
-  openWindow: function (url = "") {
-    queue.dispatcher().enqueue(queue.events.OPEN_WINDOW, url);
-    this.emit(
-      queue.events.OPEN_WINDOW,
-      (status = "ready"),
-      (logs = [`Opening ${url}`]),
-      (inputs = []),
-      (report = []),
-      (data = url)
-    );
-  },
-  log: function (status, messages = [], report = [], data = null) {
-    this.emit("log", status, messages, [], report, data);
-    Console.log(messages);
-  },
-  emit: function (
-    action,
-    status = "ready",
-    logs = [],
-    inputs = [],
-    report = [],
-    data = null
-  ) {
-    if (
-      ["webpack", "vanillajs", "vue", "react", "css", "html"].includes(
-        this.config.compiler
-      )
-    ) {
-      if (["compiler-success", "compiler-warning"].includes(status))
-        this.addAllowed("preview");
-      if (["compiler-error"].includes(status) || action == "ready")
-        this.removeAllowed("preview");
-    }
-
-    if (this.config.grading === "incremental") {
-      this.removeAllowed("reset");
-    }
-
-    Console.debug("dactions", this.config)
-    this.config.disabledActions.forEach(a => this.removeAllowed(a))
-
-    this.socket.emit("compiler", {
-      action,
-      status,
-      logs,
-      allowed: this.allowedActions,
-      inputs,
-      report,
-      data,
-    });
-  },
-
-  ready: function (message) {
-    this.log("ready", [message]);
-  },
-  success: function (type, stdout = "") {
-    const types = ["compiler", "testing"];
-    if (!types.includes(type))
-      this.fatal(`Invalid socket success type "${type}" on socket`);
-    else {
-      if (stdout === "")
-        this.log(type + "-success", ["No stdout to display on the console"]);
-      else this.log(type + "-success", [stdout]);
-    }
-
-    if (this.isTestingEnvironment) {
-      this.onTestingFinised({
-        result: "success",
-      });
-    }
-  },
-  error: function (type, stdout) {
-    console.error("Socket error: " + type, stdout);
-    this.log(type, [stdout]);
-
-    if (this.isTestingEnvironment) {
-      this.onTestingFinised({
-        result: "failed",
-      });
-    }
-  },
-  fatal: function (msg) {
-    this.log("internal-error", [msg]);
-    throw msg;
-  },
-  onTestingFinised: function (result) {
-    if (this.config.testingFinishedCallback) {
-      this.config.testingFinishedCallback(result);
-    }
-  },
-};

package/src/managers/test.js

@@ -1,77 +0,0 @@
-const path = require('path');
-let shell = require('shelljs');
-const fs = require('fs');
-let { TestingError } = require('./errors');
-let Console = require('../utils/console');
-const color = require('colors');
-const bcActivity = require('./bcActivity.js');
-
-module.exports = async function({ socket, files, config, slug }){
-
-  const configPath = path.resolve(__dirname,`./config/tester/${config.tester}/${config.language}.config.js`);
-  if (!fs.existsSync(configPath)) throw CompilerError(`Uknown testing engine for compiler: '${config.language}'`);
-
-      const testingConfig = require(configPath)(files, config, slug);
-      testingConfig.validate();
-
-      if(config.ignoreTests) throw TestingError('Grading is disabled on learn.json file.');
-
-      if (!fs.existsSync(`${config.dirPath}/reports`)){
-        fs.mkdirSync(`${config.dirPath}/reports`);
-        Console.debug(`Creating the ${config.dirPath}/reports directory`);
-      }
-
-      Console.info('Running tests...');
-
-      const command = await testingConfig.getCommand(socket)
-      const { stdout, stderr, code } = shell.exec(command);
-
-      if(code != 0){
-        const errors = typeof(testingConfig.getErrors === 'function') ? testingConfig.getErrors(stdout || stderr) : [];
-        socket.log('testing-error', errors);
-        console.log(errors.join('\n'))
-
-        Console.error("There was an error while testing");
-        bcActivity.error('exercise_error', {
-          message: errors,
-          name: `${config.tester}-error`,
-          framework: config.tester,
-          language: config.language,
-          data: slug,
-          compiler: config.compiler
-        });
-      }
-      else{
-        socket.log('testing-success',[ stdout || stderr ].concat(["😁Everything is amazing!"]));
-        Console.success("Everything is amazing!");
-
-
-        bcActivity.activity('exercise_success', {
-          language: config.language,
-          slug: slug,
-          editor: config.editor,
-          compiler: config.compiler
-        });
-        config.exercises = config.exercises.map(e => {
-          if(e.slug === slug) e.done = true;
-          return e;
-        });
-      }
-
-
-      if(typeof testingConfig.cleanup !== "undefined"){
-        if(typeof testingConfig.cleanup === 'function' || typeof testingConfig.cleanup === 'object'){
-          const clean = await testingConfig.cleanup(socket);
-          if(clean){
-            const { stdout, stderr, code } = shell.exec(clean);
-            if(code == 0){
-              Console.debug("The cleanup command runned successfully");
-            }
-            else Console.warning("There is an error on the cleanup command for the test");
-          }
-
-        }
-      }
-
-      return true;
-};

package/src/ui/download.js

@@ -1,48 +0,0 @@
-const { prompt } = require("enquirer")
-const Console = require('../utils/console')
-const api = require('../utils/api')
-const fetch = require('node-fetch')
-
-const askPackage = () => new Promise(async (resolve, reject) => {
-    Console.info(`No package was specified`)
-    const languages = await api.getLangs()
-    if(languages.length === 0){
-        reject(new Error("No categories available"))
-        return null;
-    }
-    let packages = []
-    prompt([{
-            type: 'select',
-            name: 'lang',
-            message: 'What language do you want to practice?',
-            choices: languages.map(l => ({ message: l.title, name: l.slug })),
-        }])
-        .then(({ lang }) => {
-            return (async() => {
-                const response = await api.getAllPackages({ lang })
-                const packages = response.results
-                if(packages.length === 0){
-                    const error = new Error(`No packages found for language ${lang}`)
-                    Console.error(error)
-                    return error
-                }
-                return await prompt([{
-                    type: 'select',
-                    name: 'pack',
-                    message: 'Choose one of the packages available',
-                    choices: packages.map(l => ({ 
-                        message: `${l.title}, difficulty: ${l.difficulty}, downloads: ${l.downloads} ${l.skills.length > 0 ? `(Skills: ${l.skills.join(",")})` : ""}`, 
-                        value: l
-                    })),
-                }])
-            })()
-        })
-        .then(resp => {
-            if(!resp) reject(resp.message || resp)
-            else resolve(resp)
-        })
-        .catch(error => {
-            Console.error(error.message || error)
-        })
-})
-module.exports = { askPackage }

package/src/utils/BaseCommand.js

@@ -1,34 +0,0 @@
-const {Command, flags} = require('@oclif/command')
-const Console = require('./console')
-const SessionManager = require('../managers/session.js')
-
-
-class BaseCommand extends Command {
-  constructor(...params){
-    super(...params)
-  }
-  async catch(err) {
-    Console.debug("COMMAND CATCH", err)
-
-    throw err
-  }
-  async init() {
-    const {flags, args} = this.parse(BaseCommand)
-    Console.debug("COMMAND INIT")
-    Console.debug("These are your flags: ",flags);
-    Console.debug("These are your args: ",args);
-
-    // quick fix for listening to the process termination on windows
-    process.on('SIGINT', function() {
-      Console.debug("Terminated (SIGINT)")
-      process.exit();
-    });
-
-  }
-  async finally() {
-    Console.debug("COMMAND FINALLY")
-    // called after run and catch regardless of whether or not the command errored
-  }
-}
-
-module.exports = BaseCommand

package/src/utils/SessionCommand.js

@@ -1,46 +0,0 @@
-const {flags} = require('@oclif/command')
-const BaseCommand = require("./BaseCommand")
-const Console = require('./console')
-const SessionManager = require('../managers/session.js')
-const ConfigManager = require('../managers/config/index.js')
-const { AuthError } = require('./errors.js')
-
-class SessionCommand extends BaseCommand {
-    constructor(...args){
-        super(...args)
-        this.configManager = null
-        this.session = null
-    }
-
-    async initSession(flags, _private){
-      try{
-        if(!this.configManager) await this.buildConfig(flags)
-
-        this.session = await SessionManager.get(this.configManager.get())
-        if(this.session) Console.debug(`Session open for ${this.session.payload.email}.`)
-        else{
-          if(_private) throw AuthError("You need to log in, run the following command to continue: $ learnpack login");
-          Console.debug("No active session available", _private)
-        }
-      }
-      catch(error){
-        Console.error(error.message)
-      }
-    }
-    async buildConfig(flags){
-        Console.debug("Building configuration for the first time")
-        Console.debug("Flags", flags)
-        this.configManager = await ConfigManager(flags)
-    }
-    async catch(err) {
-        Console.debug("COMMAND CATCH", err)
-        throw err
-    }
-}
-
-// SessionCommand.description = `Describe the command here
-// ...
-// Extra documentation goes here
-// `
-
-module.exports = SessionCommand

package/src/utils/api.js

@@ -1,164 +0,0 @@
-const Console = require('../utils/console');
-const _fetch = require('node-fetch');
-const storage = require('node-persist');
-const cli = require("cli-ux").default
-const HOST = "https://learnpack.herokuapp.com";
-
-const fetch = async (url, options={}) => {
-
-  let headers = { "Content-Type": "application/json" }
-  let session = null;
-  try{
-      session = await storage.getItem('bc-payload');
-      if(session.token && session.token != "" && !url.includes("/token")) headers["Authorization"] = "Token "+session.token;
-  }
-  catch(err){}
-
-  try{
-    const resp = await _fetch(url, {
-      ...options,
-      headers: { ...headers, ...options.headers }
-    })
-
-    if(resp.status >= 200 && resp.status < 300) return await resp.json()
-    else if(resp.status === 401) throw APIError("Invalid authentication credentials", 401)
-    else if(resp.status === 404) throw APIError("Package not found", 404)
-    else if(resp.status >= 500) throw APIError("Impossible to connect with the server", 500)
-    else if(resp.status >= 400){
-      const error = await resp.json()
-      if(error.detail || error.error){
-        throw APIError(error.detail || error.error)
-      }else if(error.non_field_errors){
-        throw APIError(non_field_errors[0], error)
-      }else if (typeof error === "object"){
-        for(let key in error){
-          throw APIError(`${key}: ${error[key][0]}`, error)
-        }
-      }else{
-        throw APIError("Uknown error")
-      }
-    }
-    else throw APIError("Uknown error")
-  }
-  catch(error){
-    Console.error(error.message);
-    throw error;
-  }
-}
-const login = async (identification, password) => {
-
-  try{
-    cli.action.start('Looking for credentials...')
-    await cli.wait(1000)
-    const data = await fetch(`${HOST}/v1/auth/token/`, {
-      body: JSON.stringify({ identification, password }),
-      method: 'post'
-    });
-    cli.action.stop('ready')
-    return data
-  }
-  catch(err){
-    Console.error(err.message);
-    Console.debug(err);
-  }
-}
-const publish = async (config) => {
-  
-  const keys = ['difficulty', 'language', 'skills', 'technologies', 'slug', 'repository', 'author', 'title'];
-
-  let payload = {}
-  keys.forEach(k => config[k] ? payload[k] = config[k] : null);
-  try{
-    Console.log("Package to publish: ", payload)
-    cli.action.start('Updating package information...')
-    await cli.wait(1000)
-    const data = await fetch(`${HOST}/v1/package/${config.slug}`,{
-      method: 'PUT',
-      body: JSON.stringify(payload)
-    })
-    cli.action.stop('ready')
-    return data
-  }
-  catch(err){
-    Console.log("payload", payload)
-    Console.error(err.message);
-    Console.debug(err);
-    throw err;
-  }
-}
-
-const update = async (config) => {
-
-  try{
-    cli.action.start('Updating package information...')
-    await cli.wait(1000)
-    const data = await fetch(`${HOST}/v1/package/`,{
-      method: 'POST',
-      body: JSON.stringify(config)
-    })
-    cli.action.stop('ready')
-    return data
-  }
-  catch(err){
-    Console.error(err.message);
-    Console.debug(err);
-    throw err;
-  }
-}
-
-const getPackage = async (slug) => {
-  try{
-    cli.action.start('Downloading package information...')
-    await cli.wait(1000)
-    const data = await fetch(`${HOST}/v1/package/${slug}`)
-    cli.action.stop('ready')
-    return data
-  }
-  catch(err){
-    if(err.status == 404) Console.error(`Package ${slug} does not exist`);
-    else Console.error(`Package ${slug} does not exist`);
-    Console.debug(err);
-    throw err;
-  }
-}
-
-const getLangs = async () => {
-  try{
-    cli.action.start('Downloading language options...')
-    await cli.wait(1000)
-    const data = await fetch(`${HOST}/v1/package/language`)
-    cli.action.stop('ready')
-    return data;
-  }
-  catch(err){
-    if(err.status == 404) Console.error(`Package ${slug} does not exist`);
-    else Console.error(`Package ${slug} does not exist`);
-    Console.debug(err);
-    throw err;
-  }
-}
-
-
-const getAllPackages = async ({ lang='', slug='' }) => {
-  try{
-    cli.action.start('Downloading packages...')
-    await cli.wait(1000)
-    const data = await fetch(`${HOST}/v1/package/all?limit=100&language=${lang}&slug=${slug}`)
-    cli.action.stop('ready')
-    return data;
-  }
-  catch(err){
-    Console.error(`Package ${slug} does not exist`);
-    Console.debug(err);
-    throw err;
-  }
-}
-
-const APIError = (error, code) => {
-  const message = error.message || error;
-  const _err = new Error(message);
-  _err.status = code || 400;
-  return _err;
-}
-
-module.exports = {login, publish, update, getPackage, getLangs, getAllPackages }