antelope-cli 1.0.0

package/index.js

@@ -0,0 +1,7 @@
+const args = process.argv.slice(2);
+
+if (args[0] === "onboarding") {
+    require('./onboarding');
+} else {
+    console.log("Unknown command");
+}

package/onboarding/brand.js

@@ -0,0 +1,19 @@
+let brand = {
+  brandName: '',
+  kebabCaseName: '',
+  connectedBrandName: '',
+  color: '',
+  languages: null,
+  type: '',
+  FCMSenderId: ''
+};
+
+function updateBrand(updatedBrand) {
+  brand = { ...brand, ...updatedBrand };
+}
+
+function getBrand() {
+  return brand;
+}
+
+module.exports = { updateBrand, getBrand };

package/onboarding/createConfig.js

@@ -0,0 +1,72 @@
+const fs = require('fs');
+const path = require('path');
+const brandModule = require('./brand.js');
+const chalk = require('chalk');
+const configsFilePath = '../../src/configs/configs.ts';
+
+async function start(rl) {
+  try {
+    const configFile = path.join(__dirname, configsFilePath);
+    // Get User FCMSenderId and type
+    let { FCMSenderId, type } = await promptForValues(rl);
+    // Making sure the type is all caps
+    type = type.toUpperCase();
+    // Update brand state
+    brandModule.updateBrand({ FCMSenderId, type });
+    // Generate new config with new values
+    const newConfigContent = updateConfigFile();
+    // Write to file
+    return new Promise((resolve, reject) => {
+      fs.writeFile(configFile, newConfigContent, 'utf8', (error) => {
+        if (error) {
+          reject(error);
+        } else {
+          console.log(chalk.cyan('configs.ts file updated successfully!'));
+          resolve(null);
+        }
+      });
+    });
+  } catch (e) {
+    console.error(e);
+    return start(rl);
+  }
+}
+
+const updateConfigFile = () => {
+  const brand = brandModule.getBrand();
+  return `export const configs: WebCrmConfig = {
+    baseUrl: 'https://dev-apicrm.antelopesystem.com/SignalsCRM/',
+    appId: 0,
+    type: '${brand.type}',
+    defaultLanguage: 'en',
+    gaTrackingID: 'UA-70456753-2',
+    colorTheme: 'theme-${brand.connectedBrandName}',
+    templateTheme: 'theme-template-${brand.connectedBrandName}',
+    title: '${brand.brandName}',
+    favicon: '${brand.connectedBrandName}',
+    affiliatesApiUrl: '',
+    FCMSenderId: '${brand.FCMSenderId}',
+    brandAssetsFolder: '${brand.connectedBrandName}',
+  };`;
+};
+const promptForValues = (rl) => {
+  return new Promise((resolve, reject) => {
+    try {
+      rl.question(
+        'Enter the FCMSenderId value (see https://xsites.atlassian.net/wiki/spaces/IKB/pages/777650347/Onboarding+Branding+Manual+for+devs#Firebase): ',
+        (FCMSenderId) => {
+          rl.question(
+            'Enter the type value (allowed values: CORP_FL, IB_FL, CORP_AFF_FL, CORP_AFF_IB_PORTAL, CORP_AFF_MSQ): ',
+            (type) => {
+              resolve({ FCMSenderId, type });
+            }
+          );
+        }
+      );
+    } catch (error) {
+      reject(error);
+    }
+  });
+};
+
+module.exports = { start };

package/onboarding/favicon.js

@@ -0,0 +1,138 @@
+const fs = require('fs');
+const brandModule = require('./brand.js');
+const chalk = require('chalk');
+const path = require('path');
+const fetch = require('node-fetch');
+const unzipper = require('unzipper');
+
+async function start(rl) {
+  try {
+    const brand = brandModule.getBrand();
+    const faviconDirLocation = `../../src/assets/img/favicon/${brand.connectedBrandName}`;
+
+    // Prompt user for the URL of the logo image
+    const imagePath = await promptUser('Please provide the url to your favicon image: ', rl);
+
+    // Make a POST request to the RealFaviconGenerator API
+    console.log(chalk.inverse('Creating a favicon pack...'));
+    const response = await fetch('https://realfavicongenerator.net/api/favicon', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(getFaviconRequest(brand, imagePath))
+    });
+    const json = await response.json();
+
+    // Handle error responses
+    if (json.favicon_generation_result.result.error_message) {
+      console.error(`Error generating favicon images: ${json.favicon_generation_result.result.error_message}`);
+      return start(rl);
+    }
+
+    // Download and extract the zip file to the favicon directory
+    const faviconDirectory = path.join(__dirname, faviconDirLocation);
+    await fs.promises.mkdir(faviconDirectory, { recursive: true });
+
+    const zipUrl = json.favicon_generation_result.favicon.package_url;
+    const zipResponse = await fetch(zipUrl);
+    const zipBuffer = await zipResponse.buffer();
+    const zipContents = await unzipper.Open.buffer(zipBuffer);
+    await Promise.all(
+      zipContents.files.map(async (file) => {
+        const content = await file.buffer();
+        const dest = path.join(faviconDirectory, file.path);
+        await fs.promises.mkdir(path.dirname(dest), { recursive: true });
+        await fs.promises.writeFile(dest, content);
+      })
+    );
+
+    console.log(chalk.cyan(`Favicon images generated successfully!`));
+  } catch (error) {
+    console.error(`Error generating favicon images: ${error}`);
+  }
+}
+
+/**
+ * Returns an object containing the necessary parameters for the RealFaviconGenerator API.
+ */
+function getFaviconRequest(brand, imagePath) {
+  return {
+    favicon_generation: {
+      api_key: process.env.FAVICON_API_KEY,
+      master_picture: {
+        type: 'url',
+        url: imagePath
+      },
+      favicon_design: {
+        ios: {
+          picture_aspect: 'no_change',
+          margin: '14%',
+          manifest: {
+            name: '',
+            short_name: '',
+            icons: [
+              {
+                src: '/apple-touch-icon-180x180.png',
+                sizes: '192x192',
+                type: 'image/png'
+              }
+            ],
+            theme_color: '#ffffff',
+            background_color: '#ffffff',
+            display: 'standalone'
+          }
+        },
+        desktop_browser: {},
+        windows: {
+          picture_aspect: 'no_change',
+          background_color: brand.color || '#FFF',
+          assets: {
+            windows_80_ie10_tile: true,
+            windows_10_ie11_edge_tiles: {
+              small: true,
+              medium: true,
+              big: true,
+              rectangle: true
+            }
+          },
+          manifest: {
+            name: '',
+            short_name: '',
+            icons: [
+              {
+                src: '/mstile-150x150.png',
+                sizes: '150x150',
+                type: 'image/png'
+              }
+            ],
+            theme_color: '#ffffff',
+            background_color: '#ffffff',
+            display: 'standalone'
+          }
+        },
+        safari_pinned_tab: {
+          picture_aspect: 'silhouette',
+          threshold: 20,
+          theme_color: brand.color || '#FFF'
+        }
+      }
+    }
+  };
+}
+
+/**
+ * Prompts the user for input with the given message.
+ * @param {string} message The message to display to the user.
+ * @param {readline.Interface} rl The readline interface to use for user input.
+ * @returns {Promise<string>} A promise that resolves with the user's input.
+ */
+function promptUser(message, rl) {
+  return new Promise((resolve) => {
+    rl.question(message, (input) => {
+      resolve(input);
+    });
+  });
+}
+
+module.exports = { start };

package/onboarding/index.js

@@ -0,0 +1,62 @@
+const readline = require('readline');
+const variableColors = require('./variablesColors.js');
+const themes = require('./themes.js');
+const favicon = require('./favicon.js');
+const logo = require('./logo.js');
+const translations = require('./translations.js');
+const config = require('./createConfig.js');
+const chalk = require('chalk');
+const { exec } = require('child_process');
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout
+});
+
+const finishOnboarding = () => {
+  console.log(chalk.green('\nOnboarding completed!'));
+  rl.question('Start the application? (yes/no) ', (result) => {
+    if (result.toLowerCase() === 'yes') {
+      rl.close();
+      const startProcess = exec('npm start');
+
+      startProcess.stdout.on('data', (data) => {
+        console.log(data);
+      });
+
+      startProcess.stderr.on('data', (data) => {
+        console.error(data);
+      });
+
+      startProcess.on('close', (code) => {
+        console.log(`Child process exited with code ${code}`);
+      });
+    } else {
+      rl.close();
+    }
+  });
+};
+
+const startOnBoarding = async () => {
+  console.log(chalk.underline(chalk.cyan("Welcome to Antelope's on-boarding bot \n")));
+  try {
+    console.log(chalk.bold(chalk.yellow('\nStep 1: Add to variables-colors.scss')));
+    await variableColors.start(rl);
+    console.log(chalk.bold(chalk.yellow('\nStep 2: Add to themes.scss')));
+    await themes.start(rl);
+    console.log(chalk.bold(chalk.yellow('\nStep 3: Create favicon package')));
+    await favicon.start(rl);
+    console.log(chalk.bold(chalk.yellow('\nStep 4: Adding the logo')));
+    await logo.start(rl);
+    console.log(chalk.bold(chalk.yellow('\nStep 5: Adding translations')));
+    await translations.start(rl);
+    console.log(chalk.bold(chalk.yellow('\nStep 6: Editing the config file')));
+    await config.start(rl);
+    finishOnboarding();
+  } catch (err) {
+    console.error(chalk.red(err) + '\n Please delete files and code added by this fail session.');
+    rl.close();
+  }
+};
+
+startOnBoarding();

package/onboarding/logo.js

@@ -0,0 +1,41 @@
+const chalk = require('chalk');
+const fs = require('fs');
+const https = require('https');
+const brandModule = require('./brand.js');
+const path = require('path');
+
+const downloadLogo = (url, dest) => {
+  const file = fs.createWriteStream(dest);
+  return new Promise((resolve, reject) => {
+    https
+      .get(url, (response) => {
+        response.pipe(file).on('finish', () => {
+          file.close(resolve);
+        });
+      })
+      .on('error', (err) => {
+        reject(err.message);
+        fs.unlink(dest, (error) => reject(error));
+      });
+  });
+};
+
+function start(rl) {
+  const brand = brandModule.getBrand();
+  return new Promise((resolve, reject) => {
+    const logoDirLocation = path.join(__dirname, `../../src/assets/img/logos/${brand.connectedBrandName}.png`);
+    rl.question('Please enter the URL to the logo image suitable for a black background:\n', async (url) => {
+      try {
+        console.log(chalk.inverse('Downloading logo...'));
+        await downloadLogo(url, logoDirLocation, brand.connectedBrandName);
+        console.log(chalk.cyan('Logo downloaded successfully!'));
+        resolve(null);
+      } catch (err) {
+        console.error(err);
+        return start(rl);
+      }
+    });
+  });
+}
+
+module.exports = { start };

package/onboarding/themes.js

@@ -0,0 +1,92 @@
+const fs = require('fs');
+const brandModule = require('./brand.js');
+const chalk = require('chalk');
+const themesPath = 'src/ng1/assets/css/sass/materialism/themes.scss';
+
+function addColorToMap(mapName, key, value, data) {
+  const mapRegex = new RegExp(`\\$${mapName}:\\s*\\(([\\s\\S]*?)\\)`);
+  const match = data.match(mapRegex);
+  if (match) {
+    const mapContent = match[1];
+    const newMapContent = `$${mapName}: (${mapContent}  '${key}': ${value},\n)`;
+    data = data.replace(mapRegex, newMapContent);
+  } else {
+    throw new Error(`Error: Could not find ${mapName} map in the file`);
+  }
+  return data;
+}
+
+function start(rl) {
+  const brand = brandModule.getBrand();
+  return new Promise((resolve, reject) => {
+    try {
+      const themeVar = `
+    .theme-template-${brand.connectedBrandName} {
+      #logo {
+        display: inline-block;
+        width: 240px;
+        height: 120px;
+        background: url('src/assets/img/logos/${brand.connectedBrandName}.png') no-repeat center center;
+        background-size: contain;
+      }
+      .navbar-toggle-container {
+        background: #222C38;
+
+        .icon-bar {
+          background: #fff !important;
+        }
+      }
+      .sidebar {
+        background: #222C38;
+        color: #ffffff;
+
+        ul a,
+        i {
+          color: #ffffff;
+        }
+
+        .brand-logo,
+        .brand-logo-text {
+          display: none;
+        }
+        .user-logged-in:after {
+          background: #26303C;
+        }
+      }
+    }
+    \n`;
+      fs.readFile(themesPath, 'utf8', (err, data) => {
+        if (err) {
+          reject(err);
+        } else {
+          data = addColorToMap(
+            'theme-colors',
+            brand.connectedBrandName,
+            brand.color ? `$${brand.connectedBrandName}` : '$corp',
+            data
+          );
+          data = addColorToMap(
+            'theme-secondary-colors',
+            brand.connectedBrandName,
+            brand.color ? `'${brand.connectedBrandName}'` : "'corp'",
+            data
+          );
+          const insertionPoint = data.lastIndexOf('@each $color-name');
+          const newFileContent = data.slice(0, insertionPoint) + themeVar + data.slice(insertionPoint);
+          fs.writeFile(themesPath, newFileContent, 'utf8', (error) => {
+            if (error) {
+              reject(error);
+            } else {
+              console.log(chalk.cyan('themes.scss file updated successfully!'));
+              resolve(null);
+            }
+          });
+        }
+      });
+    } catch (error) {
+      console.error(error);
+    }
+  });
+}
+
+module.exports = { start };

package/onboarding/translations.js

@@ -0,0 +1,43 @@
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const brandModule = require('./brand.js');
+
+function createTranslationsFolder(translationsDirectory) {
+  const folderPath = path.join(translationsDirectory, 'languages');
+
+  if (!fs.existsSync(folderPath)) {
+    fs.mkdirSync(folderPath, { recursive: true });
+  }
+
+  return folderPath;
+}
+
+function createLanguageFiles(languages, folderPath) {
+  languages.forEach((language) => {
+    const filePath = path.join(folderPath, `${language}.json`);
+    fs.writeFileSync(filePath, '{}', 'utf8');
+  });
+}
+
+function start(rl) {
+  const brand = brandModule.getBrand();
+  const translationsDir = `../../src/assets/brands/${brand.connectedBrandName}`;
+  const translationsDirectory = path.join(__dirname, translationsDir);
+  return new Promise((resolve, reject) => {
+    try {
+      rl.question('Enter the languages (2-letter codes) separated by commas:\n', (languagesInput) => {
+        const languages = languagesInput.trim().split(',');
+        brandModule.updateBrand({ languages });
+        const folderPath = createTranslationsFolder(translationsDirectory);
+        createLanguageFiles(languages, folderPath);
+        console.log(chalk.cyan('Translations added successfully!'));
+        resolve(null);
+      });
+    } catch (error) {
+      reject(error + '\n Please add the translations manually.');
+    }
+  });
+}
+
+module.exports = { start };

package/onboarding/variablesColors.js

@@ -0,0 +1,58 @@
+const fs = require('fs');
+const brandModule = require('./brand.js');
+const chalk = require('chalk');
+const variablesColorsPath = 'src/ng1/assets/css/sass/variables-colors.scss';
+const defaultColor = '$corp';
+
+function start(rl) {
+  return new Promise((resolve, reject) => {
+    rl.question("What is the new brand's name?\n", (brandName) => {
+      const kebabCaseName = brandName.toLowerCase().replace(/ /g, '-');
+      const connectedBrandName = brandName.toLowerCase().replace(/ /g, '');
+      rl.question(
+        `Please set a color for "${kebabCaseName}", use hex value, leave empty for default.\n`,
+        (hexColor) => {
+          let data = fs.readFileSync(variablesColorsPath, 'utf8');
+
+          // Check if $colors map exists in the file
+          const colorsRegex = /\$colors:\s*\(([\s\S]*?)\)/;
+          const match = data.match(colorsRegex);
+          if (match) {
+            const colorsMap = match[1];
+
+            // Append the new brand to the colors map
+            const newColorsMap = `$colors: (${colorsMap}  '${connectedBrandName}': ${
+              hexColor ? '$' + connectedBrandName : defaultColor
+            },\n)`;
+
+            // Replace the $colors map in the file with the new one
+            data = data.replace(colorsRegex, newColorsMap);
+          } else {
+            reject('Error: Could not find $colors map in the file');
+          }
+
+          const brandVar = `\$${connectedBrandName}: (
+        'lighten-5': lighten(${hexColor}, 25%),
+        'lighten-4': lighten(${hexColor}, 20%),
+        'lighten-3': lighten(${hexColor}, 15%),
+        'lighten-2': lighten(${hexColor}, 10%),
+        'lighten-1': lighten(${hexColor}, 5%),
+        'base': ${hexColor},
+        'darken-1': darken(${hexColor}, 5%),
+        'darken-2': darken(${hexColor}, 10%),
+        'darken-3': darken(${hexColor}, 15%),
+        'darken-4': darken(${hexColor}, 20%),
+      );\n`;
+
+          const newData = hexColor ? brandVar + data : data;
+          fs.writeFileSync(variablesColorsPath, newData, 'utf8');
+          brandModule.updateBrand({ brandName, kebabCaseName, connectedBrandName, color: hexColor || '' });
+          console.log(chalk.cyan('\nvariables-colors.scss file updated successfully!'));
+          resolve(null);
+        }
+      );
+    });
+  });
+}
+
+module.exports = { start };

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "antelope-cli",
+  "version": "1.0.0",
+  "description": "CLI-Tool for automating processes for Antelope-Systems ",
+  "main": "index.js",
+  "bin": {
+    "ant-cli": "index.js"
+  },
+  "scripts": {
+    "test": "test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://bitbucket.org/xsitesinc/antelope-cli.git"
+  },
+  "keywords": [
+    "cli"
+  ],
+  "author": "Idan Atias",
+  "license": "ISC",
+  "homepage": "https://bitbucket.org/xsitesinc/antelope-cli#readme",
+  "dependencies": {
+    "dotenv": "^16.4.5",
+    "unzipper": "^0.12.1"
+  }
+}