@suffolklitlab/alkiln 3.0.9

package/lib/DOM.md.html

@@ -0,0 +1,63 @@
+# Similarities and differences between basic field DOM structures
+
+_Missing structure of buttons with `a` tags_
+
+(SLIDEBAR) TEXT INPUT
+<label
+        <input
+    <label (error text)
+
+TEXTAREA
+<label
+    <textarea
+===================================
+RADIO/CHECKBOXES/YESNO RADIO
+<label
+    <fieldset
+        <legend
+        <input
+        <label
+            <span
+            <span
+            <span
+            <span
+        <input
+        <label
+            <span
+            <span
+            <span
+            <span
+===================================
+SELECT BOXES
+<label
+        <select
+            <option
+            <option
+
+(COMBOBOX) (choices are same)
+<label
+            <input
+                    <button
+    <select
+        <option
+        <option
+========================
+BUTTON (missing the other button structure (with <a>))
+<fieldset
+    <legend
+        <button
+            <span
+
+
+========================
+NON-INPUTS BEFORE BOTTOM BUTTONS
+<input hidden
+
+NON-INPUTS AT THE VERY BOTTOM (hidden and such)
+<input
+<input
+<input
+<input
+<input
+<input
+<input

package/lib/github_integration/install-branch.js

@@ -0,0 +1,84 @@
+const puppeteerutils = require('./puppeteer-utils');
+const env_vars = require('../utils/env_vars');
+
+const setup = async () => {
+  let {page, browser} = await puppeteerutils.login();
+  try {
+    await puppeteerutils.createProject(page);
+    await makeTestYML(page);
+    await puppeteerutils.installRepo(page);
+    await waitForPage(page);  // Ensure server has really restarted
+  }
+  catch (e) {
+    try {
+      await page.screenshot({ path: `error-settingUp.jpg`, type: 'jpeg', fullPage: true });
+    } catch ( error ) {
+      console.log( `Could not take screenshot of repo setup error.\n` );
+      throw e;
+    }
+  }
+  finally {
+    browser.close();
+  }
+};
+
+const takedown = async () => {
+  let {page, browser} = await puppeteerutils.login();
+  try {
+    await puppeteerutils.deleteProject(page);
+  }
+  catch (e) {
+    console.log(e);
+  }
+  finally {
+    browser.close();
+  }
+};
+
+const makeTestYML = async (page) => {
+  // ONLY WORKS WITH A NEWLY CREATED PROJECT
+  // So that we can try to load our interview, we need this file to exist and work
+  // DEVELOPER: Always make sure your test.yml doesn't create an error page
+  let proj_name = env_vars.getProjectName();
+  await page.goto(`${env_vars.BASE_URL}/playground?project=${ proj_name }`, {waitUntil: 'domcontentloaded'});
+};  // Ends makeTestYML
+
+const waitForPage = async (page) => {
+  // Most reliable way we've found to be sure the server finishes restarting
+  // This counts on the fact that docassemble makes a `test.yml` file
+  // for every new project. This method doesn not care if the file errors.
+  const tries = 20;
+
+  // test.yml only exists if the 'developer' (this program) goes to the playground
+  const test_url = `${ env_vars.getBaseInterviewURL() }test.yml`;
+  console.log("\nTest file url:", test_url);
+  console.warn("This is meant to make sure the interview will load. Sometimes it doesn't work. If this test errors because the interview wouldn't load, you can try re-running this test.");
+
+  await page.goto(test_url, {waitUntil: 'domcontentloaded'});
+
+  // Wait till an interview can load
+  for (i=0; i < tries; i++) {
+    const element = await Promise.race([
+      page.$('#daMainQuestion'),
+      page.$x('//*[contains(text(), "History")]'),
+    ]);
+
+    if (element) {
+      console.log("Success! Repo was pulled and test.yml page loaded correctly.");
+      break;
+    } else {
+      let waitTime = 5  // 5 seconds
+      await page.screenshot({ path: './error-noInterview.jpg', type: 'jpeg', fullPage: true });
+      if ( i === tries ) {
+        console.log('Giving up.');
+      } else {
+        console.log(`Attempt ${i + 1} of ${ tries }. Will try again in ${ waitTime } seconds`);
+      }
+      await page.waitFor(waitTime * 1000);  // seconds
+      await page.reload();
+    }
+  }
+};  // Ends waitForPage()
+
+
+module.exports = {setup, takedown};

package/lib/github_integration/puppeteer-utils.js

@@ -0,0 +1,224 @@
+const puppeteer = require('puppeteer');
+const env_vars = require('../utils/env_vars');
+
+const initPuppeteer = async () => {
+  const browser = await puppeteer.launch({headless: !env_vars.DEBUG});
+  const page = await browser.newPage();
+  page.setDefaultTimeout(120 * 1000);
+
+  return {'page': page, 'browser': browser};
+}
+
+const login = async () => {
+  const {page, browser} = await initPuppeteer();
+  // Login
+  await page.goto(`${env_vars.BASE_URL}/user/sign-in?`, {waitUntil: 'domcontentloaded'});
+  const emailElement = await page.$('#email');
+  await emailElement.type(env_vars.PLAYGROUND_EMAIL);
+  const passwordElement = await page.$('#password');
+  await passwordElement.type(env_vars.PLAYGROUND_PASSWORD);
+  await Promise.all([
+    passwordElement.press('Enter'),
+    page.waitForNavigation({waitUntil: 'domcontentloaded'}),
+  ]);
+  return {'page': page, 'browser': browser};
+};
+
+const navigateToManageProject = async (page) => {
+  // Go to manage projects page URL
+  await page.goto(`${env_vars.BASE_URL}/playgroundproject`, {waitUntil: 'domcontentloaded'});
+};
+
+const createProject = async (page) => {
+  /* Create a project with a unique name. Its name will be stored in an ignored file. */
+
+  // Check if a project with this name already exists
+  // If it does, come up with a new project name
+  await navigateToManageProject(page);
+  let projectExists = true;
+  let nameIncrementer = 0;
+  let base_project_name = env_vars.getProjectName();  // Will stay the same so just the number increments
+  let actual_project_name = base_project_name;
+  while ( projectExists ) {
+  if ( env_vars.DEBUG ) { console.log( `Trying the project name "${ actual_project_name }"` ); }
+    let projectLinkSelector = `[href="/playground?project=${ actual_project_name }"]`;
+    // This might be the 'Back to Playground' button because it remembers the last
+    // project you visited, even if it doesn't exist anymore
+    let projectButton = await page.$(projectLinkSelector);
+    if ( projectButton ) {
+      let text = await page.$eval(projectLinkSelector, elem => elem.innerText);
+      // If project already exists, try a new project name
+      if ( text === actual_project_name ) {
+        actual_project_name = base_project_name + nameIncrementer;
+        nameIncrementer++;
+      } else {
+        projectExists = false;
+      }
+    } else {
+      projectExists = false;
+    }
+  }
+
+  // Store the actual name of the project for later deletion
+  safe_project_name = env_vars.setProjectName( actual_project_name );
+
+  // Go to "Add a new project" page
+  await page.goto(`${env_vars.BASE_URL}/playgroundproject?new=1&project=default`, {waitUntil: 'domcontentloaded'});
+  // Enter new project name
+  const projectNameElement = await page.$('#name');
+  await projectNameElement.type( safe_project_name );
+  // Click Save
+  const saveButton = await page.$('[type="submit"]');
+  await Promise.all([
+    saveButton.click(),
+    page.waitForNavigation({waitUntil: 'domcontentloaded'}),
+  ]);
+
+  console.log( `Created the project "${ actual_project_name }" with no contents yet.` );
+};
+
+const deleteProject = async (page) => {
+  await navigateToManageProject(page);
+
+  let proj_name = env_vars.getProjectName();
+  console.log(`Trying to delete "${ proj_name }".`);
+
+  // Click Delete button
+  const deleteLink = `[href="/playgroundproject?delete=1&project=${ proj_name }"]`;
+  const deleteButton = await page.$(deleteLink);
+  if ( !deleteButton ) {
+    console.log(`The project "${ proj_name }" does not seem to exist.`);
+    return;
+  }
+  await Promise.all([
+    deleteButton.click(),
+    page.waitForNavigation({waitUntil: 'domcontentloaded'}),
+  ]);
+  // Click follow-up screen Delete confirmation button
+  const deleteButton2 = await page.$('[type="submit"]');
+  await Promise.all([
+    deleteButton2.click(),
+    page.waitForNavigation({waitUntil: 'domcontentloaded'}),
+  ]);
+
+  // Delete project name file if possible
+  env_vars.cleanUpProjectName();
+  console.log(`Deleted the project "${ proj_name }".`);
+};
+
+const installUrl = function () {
+  // Because of private repo issues (#417), can't use `github` url arg
+  let params_for_url =  urlParams({ project: env_vars.getProjectName() });
+  return `${ env_vars.BASE_URL }/pullplaygroundpackage?${ params_for_url }`;
+};
+
+const urlParams = (params) => urlString = Object.keys(params).map(
+  (key) => `${key}=${params[key]}`
+).join('&')
+
+const tap_pull = async ( page, elem_to_blur ) => {
+  await elem_to_blur.evaluate((elem) => { elem.blur(); });
+
+  try {
+    // Wait for the options to appear after the ajax call
+    let optSelector = '[value="' + env_vars.BRANCH_NAME + '"]';
+    console.log( `Looking for the ${ env_vars.BRANCH_NAME } branch of the repository at ${ env_vars.REPO_URL }.\n` );
+    await page.waitFor( optSelector );  // This is the key
+    console.log( `We found the ${ env_vars.BRANCH_NAME } branch of the repository at ${ env_vars.REPO_URL }. Next, we will try to pull the code.\n` );
+    let html = await page.$eval( optSelector, (elem) => { return elem.innerHTML });  // Why are we doing this?
+  
+    // Tap 'Pull' and wait till the page has finished loading
+    const pullButton = await page.$('button[name=pull]');
+    await Promise.all([
+      pullButton.click(),
+      page.waitForNavigation({waitUntil: 'domcontentloaded'}),
+    ]);
+  } catch ( error ) {
+    return { succeeded: false, error: error };
+  }
+
+  return { succeeded: true, error: null };
+}
+
+const installRepo = async (page) => {
+  // await page.goto(installUrl(), {waitUntil: 'domcontentloaded'});
+  // `https://apps-dev.suffolklitlab.org/playgroundpackages?project=EmptyProject`
+  let package_url = `${ env_vars.BASE_URL }/playgroundpackages?project=${ env_vars.getProjectName() }`;
+  await page.goto(package_url, {waitUntil: 'domcontentloaded'});
+
+  // Without this temporary workaround, a current bug will not
+  // allow you to pull from a private repo if the Project is empty.
+  // For now, we'll make a package first so it's not empty.
+  let package_input = await page.$( `#file_name` );
+  await package_input.type( `TemporaryFix` );
+  let save_button = await page.$( `button[value="Save"]` );
+  Promise.all([
+    save_button.evaluate( (el) => { return el.click(); }),
+    page.waitForNavigation({ waitUntil: 'domcontentloaded' }),
+  ]);
+  // Waiting for navigation isn't enough.
+  await page.waitFor( 1000 );
+  await page.waitForSelector(`#daDelete`, { visible: true });
+
+  await page.goto(installUrl(), {waitUntil: 'domcontentloaded'});
+  // For private repos especially, needs the format
+  // git@github.com:user/docassemble-package.git from original
+  // format https://github.com/user/docassemble-package
+  let user = env_vars.REPO_URL.split("/")[3];
+  let package = env_vars.REPO_URL.split("/")[4];
+  let repo_input = await page.$( `#github_url` );
+  await repo_input.type( `git@github.com:${ user }/${ package }.git` );
+
+  let result = await tap_pull( page, repo_input );
+
+  // if body contains "Could not read from remote repository"
+  let permissions_failed = await page.$eval(`body`, function (elem) {
+    return elem.innerText.includes("Could not read from remote repository");
+  });
+
+  // Try just the regular env_vars.REPO_URL
+  if ( permissions_failed ) {
+    let permissions_msg = `If this is a private repo, pay attention to the following: `
+      + `we tried to pull the package using the testing account's docassemble GitHub `
+      + `integration and the address git@github.com:${ user }/${ package }.git. It `
+      + `looks like the testing account is either not integrated with GitHub or the `
+      + `testing account GitHub account does not have permissions in this private `
+      + `GitHub repo. Try setting up the GitHub permissions for that docassemble `
+      + `testing account. If you're sure you have already done so, make an issue at `
+      + `https://github.com/SuffolkLITLab/ALKiln/issues.\n`
+    console.log( permissions_msg );
+    await page.goto(installUrl(), {waitUntil: 'domcontentloaded'});
+    repo_input = await page.$( `#github_url` );  // new page, new input element
+    await repo_input.type( env_vars.REPO_URL );
+    result = await tap_pull( page, repo_input );
+  } 
+  
+  if ( result.error ) {
+    // If there was a problem, either originally or with the private repo code, throw that error
+    throw result.error;
+  }
+  // What's a better way to handle this in the future?
+  // With the API, check if the user has GitHub integration set up.
+
+  // After all the pulling has been tried that needs to be tried, wait for loading to finish
+  try {
+    // server/module reload. See https://github.com/plocket/docassemble-cucumber/issues/367#issuecomment-892591770
+    // The selector find the 'Package Name' field on the 'Packages' page
+    await page.waitForSelector(`#file_name`, { visible: true })
+  } catch ( error ) {
+    console.log( `It looks like pulling the ${ env_vars.BRANCH_NAME } branch of the repository at ${ env_vars.REPO_URL } failed. Download the error screenshots in the GitHub Action artifacts to see if it tells you more.\n` );
+    throw error ;
+  }
+
+  console.log( `Pulled the GitHub branch "${ env_vars.BRANCH_NAME }" into the project "${ env_vars.getProjectName() }".\n` );
+}
+
+
+
+module.exports = {
+  login: login,
+  createProject: createProject,
+  deleteProject: deleteProject,
+  installRepo: installRepo,
+  initPuppeteer: initPuppeteer,
+};

package/lib/github_integration/setup.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+
+const install_branch = require('./install-branch.js');
+install_branch.setup();

package/lib/github_integration/takedown.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+
+const install_branch = require('./install-branch.js');
+install_branch.takedown();

package/lib/index.js

@@ -0,0 +1,2 @@
+require('./world');
+require('./steps.js');