/**
* @file stringGeneration.js
* @module stringGeneration
* @description Contains all business rules for randomly generating strings of all kinds.
* @requires module:ruleParsing
* @requires module:loggers
* @requires {@link https://www.npmjs.com/package/@haystacks/constants|@haystacks/constants}
* @requires {@link https://www.npmjs.com/package/path|path}
* @author Seth Hollingsead
* @date 2022/01/25
* @copyright Copyright © 2022-… by Seth Hollingsead. All rights reserved
*/
// Internal imports
import ruleParsing from './ruleParsing.js';
import loggers from '../../executrix/loggers.js';
// External imports
import hayConst from '@haystacks/constants';
import path from 'path';
const {bas, biz, gen, lng, msg, num, sys, wrd} = hayConst;
const baseFileName = path.basename(import.meta.url, path.extname(import.meta.url));
// framework.businessRules.rules.stringGeneration.
const namespacePrefix = wrd.cframework + bas.cDot + sys.cbusinessRules + bas.cDot + wrd.crules + bas.cDot + baseFileName + bas.cDot;
/**
* @function generateRandomMixedCaseTextByLength
* @description Parse the input string, and determine how many mixed case
* english alphabetic characters should be generated,
* generate them and string them together.
* @param {string} inputData The string that contains a number or how many
* randomly generated mixed case alphabetic characters should be generated.
* @param {string} inputMetaData The name of the language who's alphabet should be used for international characters.
* @return {string} A string of randomly generated mixed case letters where the
* length of the string is defined by the input parameter.
* @author Seth Hollingsead
* @date 2022/01/26
*/
async function generateRandomMixedCaseTextByLength(inputData, inputMetaData) {
let functionName = generateRandomMixedCaseTextByLength.name;
await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
let returnData = '';
if (inputData) {
let numberOfCharactersToGenerate = parseInt(inputData);
for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++) {
returnData = returnData.concat(await ruleParsing.processRulesInternal([inputData, inputMetaData], [biz.crandomlyGenerateMixedCaseAlphabeticCharacter]));
} // End-for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++)
} // End-if (inputData)
await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
return returnData;
}
/**
* @function generateRandomUpperCaseTextByLength
* @description Parse the input string, and determine how many upper case
* english alphabetic characters should be generated, generate them and string them together.
* @param {string} inputData The string that contains a number for how many randomly
* generated upper case english alphabetic characters should be generated.
* @param {string} inputMetaData The name of the language who's alphabet should be used for international characters.
* @return {string} A string of randomly generated upper case letters where the
* length of the string is defined by the input parameter.
* @author Seth Hollingsead
* @date 2022/01/26
*/
async function generateRandomUpperCaseTextByLength(inputData, inputMetaData) {
let functionName = generateRandomUpperCaseTextByLength.name;
await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
let returnData = '';
if (inputData) {
let numberOfCharactersToGenerate = parseInt(inputData);
for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++) {
returnData = returnData.concat(await ruleParsing.processRulesInternal([inputData, inputMetaData], [biz.crandomlyGenerateUpperCaseLetter]));
} // End-for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++)
} // End-if (inputData)
await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
return returnData;
}
/**
* @function generateRandomLowerCaseTextByLength
* @description Parse the input string, and determine how many lower case
* english alphabetic characters should be generated, generate them and string them together.
* @param {string} inputData The string that contains a number for how many randomly
* generated lower case english alphabetic characters that should be generated.
* @param {string} inputMetaData The name of the language who's alphabet should be used for international characters.
* @return {string} A string of randomly generated lower case letters where the
* length of the string is defined by the input parameter.
* @author Seth Hollingsead
* @date 2022/01/26
*/
async function generateRandomLowerCaseTextByLength(inputData, inputMetaData) {
let functionName = generateRandomLowerCaseTextByLength.name;
await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
let returnData = '';
if (inputData) {
let numberOfCharactersToGenerate = parseInt(inputData);
for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++) {
returnData = returnData.concat(await ruleParsing.processRulesInternal([inputData, inputMetaData], [biz.crandomlyGenerateLowerCaseLetter]));
} // End-for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++)
} // End-if (inputData)
await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
return returnData;
}
/**
* @function generateRandomMixedCaseTextWithSpecialCharactersByLength
* @description Generate the specified number of random mixed case letters and/or
* special characters and string them together.
* @param {string} inputData The number of randomly generated mixed case letters and/or
* special characters to generate the output string.
* @param {string} inputMetaData A JSON data structure object that contains the list of special characters that should be used during the generation process,
* and also the name of the language who's alphabet should be used for international characters.
* [
* "!@#$%^&*()_+-=[]{};:',./<>?\|\"", // SpecialCharacters
* "English" // Language
* ]
* @return {string} A string of randomly generated mixed case letters and
* special characters where the length of the string is defined by the input parameter.
* @author Seth Hollingsead
* @date 2022/01/26
*/
async function generateRandomMixedCaseTextWithSpecialCharactersByLength(inputData, inputMetaData) {
let functionName = generateRandomMixedCaseTextWithSpecialCharactersByLength.name;
await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
let returnData = '';
if (inputData && inputMetaData) {
let numberOfCharactersToGenerate = parseInt(inputData);
let specialCharacters = inputMetaData[0];
let language = inputMetaData[1];
for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++) {
returnData = returnData.concat(await ruleParsing.processRulesInternal([specialCharacters, language], [biz.crandomlyGenerateMixedCaseLetterOrSpecialCharacter]));
} // End-for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++)
} // End-if (inputData)
await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
return returnData;
}
/**
* @function generateRandomUpperCaseTextWithSpecialCharactersByLength
* @description Generate the specified number of random upper cae letters and/or special characters and string them together.
* @param {string} inputData The number of randomly generated upper case english letters and/or special characters to generate.
* @param {string} inputMetaData A JSON data structure object that contains the list of special characters that should be used during the generation process,
* and also the name of the language who's alphabet should be used for international characters.
* [
* "!@#$%^&*()_+-=[]{};:',./<>?\|\"", // SpecialCharacters
* "English" // Language
* ]
* @return {string} A string of randomly generated upper case english letters and
* special characters where the length of the string is defined by the input parameter.
* @author Seth Hollingsead
* @date 2022/01/26
*/
async function generateRandomUpperCaseTextWithSpecialCharactersByLength(inputData, inputMetaData) {
let functionName = generateRandomUpperCaseTextWithSpecialCharactersByLength.name;
await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
let returnData = '';
if (inputData && inputMetaData) {
let numberOfCharactersToGenerate = parseInt(inputData);
let specialCharacters = inputMetaData[0];
let language = inputMetaData[1];
for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++) {
returnData = returnData.concat(await ruleParsing.processRulesInternal([specialCharacters, language], [biz.crandomlyGenerateUpperCaseLetterOrSpecialCharacter]));
} // End-for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++)
} // End-if (inputData)
await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
return returnData;
}
/**
* @function generateRandomLowerCaseTextWithSpecialCharactersByLength
* @description Generate the specified number of random lower case english letters and/or
* special characters and string them together.
* @param {string} inputData The number of randomly generated lower case letters and/or
* special characters to generate.
* @param {string} inputMetaData A JSON data structure object that contains the list of special characters that should be used during the generation process,
* and also the name of the language who's alphabet should be used for international characters.
* [
* "!@#$%^&*()_+-=[]{};:',./<>?\|\"", // SpecialCharacters
* "English" // Language
* ]
* @return {string} A string of randomly generated lower case english letters and
* special characters where the length of the string is defined by the input parameter.
* @author Seth Hollingsead
* @date 2022/01/26
*/
async function generateRandomLowerCaseTextWithSpecialCharactersByLength(inputData, inputMetaData) {
let functionName = generateRandomLowerCaseTextWithSpecialCharactersByLength.name;
await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
let returnData = '';
if (inputData && inputMetaData) {
let numberOfCharactersToGenerate = parseInt(inputData);
let specialCharacters = inputMetaData[0];
let language = inputMetaData[1];
for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++) {
returnData = returnData.concat(await ruleParsing.processRulesInternal([specialCharacters, language], [biz.crandomlyGenerateLowerCaseLetterOrSpecialCharacter]));
} // End-for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++)
} // End-if (inputData)
await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
return returnData;
}
/**
* @function generateRandomMixedCaseAlphaNumericCodeByLength
* @description Generate the specified number of random mixed case english letters and/or
* numeric characters and string them together.
* @param {string} inputData The number of randomly generated mixed case letters and/or
* numbers that should be generated.
* @param {string} inputMetaData The name of the language who's alphabet should be used for international characters.
* @return {string} A string of randomly generated mixed case english letters and
* numbers where the length of the string is defined by the input parameter.
* @author Seth Hollingsead
* @date 2022/01/26
*/
async function generateRandomMixedCaseAlphaNumericCodeByLength(inputData, inputMetaData) {
let functionName = generateRandomMixedCaseAlphaNumericCodeByLength.name;
await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
let returnData = '';
if (inputData) {
let numberOfCharactersToGenerate = parseInt(inputData);
for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++) {
returnData = returnData.concat(await ruleParsing.processRulesInternal(['', inputMetaData], [biz.crandomlyGenerateMixedCaseAlphaNumericCharacter]));
} // End-for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++)
} // End-if (inputData)
await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
return returnData;
}
/**
* @function generateRandomUpperCaseAlphaNumericCodeByLength
* @description Generate the specified number of random upper case english letters and/or
* numeric characters and string them together.
* @param {string} inputData The string that contains a number for how many randomly
* generated upper case english letters and/or numbers that should be generated.
* @param {string} inputMetaData The name of the language who's alphabet should be used for international characters.
* @return {string} A string of randomly generated upper case english letters and numbers
* where the length of the string is defined by the input parameter.
* @author Seth Hollingsead
* @date 2022/01/26
*/
async function generateRandomUpperCaseAlphaNumericCodeByLength(inputData, inputMetaData) {
let functionName = generateRandomUpperCaseAlphaNumericCodeByLength.name;
await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
let returnData = '';
if (inputData) {
let numberOfCharactersToGenerate = parseInt(inputData);
for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++) {
returnData = returnData.concat(await ruleParsing.processRulesInternal(['', inputMetaData], [biz.crandomlyGenerateUpperCaseAlphaNumericCharacter]));
} // End-for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++)
} // End-if (inputData)
await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
return returnData;
}
/**
* @function generateRandomLowerCaseAlphaNumericCodeByLength
* @description Generate the specified number of random lower case english letters and/or
* numeric characters and string them together.
* @param {string} inputData The number of randomly generated lower case letters and/or
* numbers that should be generated.
* @param {string} inputMetaData The name of the language who's alphabet should be used for international characters.
* @return {string} A string of randomly generated lower case english letters and
* numbers where the length of the string is defined by the input parameter.
* @author Seth Hollingsead
* @date 2022/01/26
*/
async function generateRandomLowerCaseAlphaNumericCodeByLength(inputData, inputMetaData) {
let functionName = generateRandomLowerCaseAlphaNumericCodeByLength.name;
await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
let returnData = '';
if (inputData) {
let numberOfCharactersToGenerate = parseInt(inputData);
for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++) {
returnData = returnData.concat(await ruleParsing.processRulesInternal(['', inputMetaData], [biz.crandomlyGenerateLowerCaseAlphaNumericCharacter]));
} // End-for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++)
} // End-if (inputData)
await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
return returnData;
}
/**
* @function generateRandomNumericCodeByLength
* @description Generate the specified number of random numeric characters and string them together.
* @param {string} inputData The number of randomly generated numeric characters that should be generated.
* @param {string} inputMetaData Not used for this business rule.
* @return {string} A string of randomly generated numeric characters where the
* length of the string is defined by the input parameter.
* @author Seth Hollingsead
* @date 2022/01/26
*/
async function generateRandomNumericCodeByLength(inputData, inputMetaData) {
let functionName = generateRandomNumericCodeByLength.name;
await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
let returnData = '';
if (inputData) {
let numberOfCharactersToGenerate = parseInt(inputData);
for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++) {
returnData = returnData.concat(await ruleParsing.processRulesInternal(['', inputMetaData], [biz.crandomlyGenerateNumericCharacter]));
} // End-for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++)
} // End-if (inputData)
await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
return returnData;
}
/**
* @function generateRandomMixedCaseAlphaNumericCodeWithSpecialCharactersByLength
* @description Generate a random selection of mixed case english letters,
* numeric characters and special characters from a list of allowable special characters,
* should be generated; generate them and string them together to the specified length.
* @param {string} inputData The number of randomly generated english letters,
* numeric characters and special characters that should be generated.
* @param {string} inputMetaData A JSON data structure object that contains the list of special characters that should be used during the generation process,
* and also the name of the language who's alphabet should be used for international characters.
* [
* "!@#$%^&*()_+-=[]{};:',./<>?\|\"", // SpecialCharacters
* "English" // Language
* ]
* @return {string} A string of randomly generated mixed case alpha numeric characters,
* and special characters where the length of the string is defined by the input parameter.
* @author Seth Hollingsead
* @date 2022/01/26
*/
async function generateRandomMixedCaseAlphaNumericCodeWithSpecialCharactersByLength(inputData, inputMetaData) {
let functionName = generateRandomMixedCaseAlphaNumericCodeWithSpecialCharactersByLength.name;
await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
let returnData = '';
if (inputData && inputMetaData) {
let numberOfCharactersToGenerate = parseInt(inputData);
let specialCharacters = inputMetaData[0];
let language = inputMetaData[1];
for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++) {
returnData = returnData.concat(await ruleParsing.processRulesInternal([specialCharacters, language], [biz.crandomlyGenerateEitherMixedCaseLetterOrNumberOrSpecialCharacter]));
} // End-for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++)
} // End-if (inputData)
await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
return returnData;
}
/**
* @function generateRandomUpperCaseAlphaNumericCodeWithSpecialCharactersByLength
* @description Generate a random selection of upper case english letters,
* numeric characters and special characters from a list of allowable special characters,
* should be generated; generate them and string them together to the specified length.
* @param {string} inputData The number of randomly generated upper case english letters,
* numeric characters and special characters that should be generated.
* @param {string} inputMetaData A JSON data structure object that contains the list of special characters that should be used during the generation process,
* and also the name of the language who's alphabet should be used for international characters.
* [
* "!@#$%^&*()_+-=[]{};:',./<>?\|\"", // SpecialCharacters
* "English" // Language
* ]
* @return {string} A string of randomly generated upper case alpha numeric characters,
* and special characters where the length of the string is defined as one of the input parameters.
* @author Seth Hollingsead
* @date 2022/01/26
*/
async function generateRandomUpperCaseAlphaNumericCodeWithSpecialCharactersByLength(inputData, inputMetaData) {
let functionName = generateRandomUpperCaseAlphaNumericCodeWithSpecialCharactersByLength.name;
await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
let returnData = '';
if (inputData && inputMetaData) {
let numberOfCharactersToGenerate = parseInt(inputData);
let specialCharacters = inputMetaData[0];
let language = inputMetaData[1];
for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++) {
returnData = returnData.concat(await ruleParsing.processRulesInternal([specialCharacters, language], [biz.crandomlyGenerateEitherUpperCaseLetterOrNumberOrSpecialCharacter]));
} // End-for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++)
} // End-if (inputData)
await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
return returnData;
}
/**
* @function generateRandomLowerCaseAlphaNumericCodeWithSpecialCharactersByLength
* @description Generate a random selection of lower case english letters,
* numeric characters and special characters from a list of allowable special characters,
* should be generated; generate them and string them together to the specified length.
* @param {string} inputData The number of randomly generated lower case english letters,
* numeric characters adn special characters that should be generated.
* @param {string} inputMetaData A JSON data structure object that contains the list of special characters that should be used during the generation process,
* and also the name of the language who's alphabet should be used for international characters.
* [
* "!@#$%^&*()_+-=[]{};:',./<>?\|\"", // SpecialCharacters
* "English" // Language
* ]
* @return {string} A string of randomly generated lower case alpha numeric characters,
* and special characters where the length of the string is defined as one of the input parameters.
* @author Seth Hollingsead
* @date 2022/01/26
*/
async function generateRandomLowerCaseAlphaNumericCodeWithSpecialCharactersByLength(inputData, inputMetaData) {
let functionName = generateRandomLowerCaseAlphaNumericCodeWithSpecialCharactersByLength.name;
await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
let returnData = '';
if (inputData && inputMetaData) {
let numberOfCharactersToGenerate = parseInt(inputData);
let specialCharacters = inputMetaData[0];
let language = inputMetaData[1];
for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++) {
returnData = returnData.concat(await ruleParsing.processRulesInternal([specialCharacters, language], [biz.crandomlyGenerateEitherLowerCaseLetterOrNumberOrSpecialCharacter]));
} // End-for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++)
} // End-if (inputData)
await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
return returnData;
}
/**
* @function generateRandomSpecialCharacterCodeByLength
* @description Generate a random selection of characters from the input allowable alphabet of characters,
* generate them and string them together to the specified length.
* @param {string} inputData The number of randomly generated special characters that should be generated.
* @param {string} inputMetaData The list of special characters that should be used during the generation process.
* @return {string} A string of randomly generated characters from the list of
* allowable special characters that are passed in where the length of the string is defined as one of the input parameters.
* @author Seth Hollingsead
* @date 2022/01/26
*/
async function generateRandomSpecialCharacterCodeByLength(inputData, inputMetaData) {
let functionName = generateRandomSpecialCharacterCodeByLength.name;
await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
let returnData = '';
if (inputData) {
let numberOfCharactersToGenerate = parseInt(inputData);
for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++) {
returnData = returnData.concat(await ruleParsing.processRulesInternal([inputMetaData, ''], [biz.crandomlyGenerateSpecialCharacter]));
} // End-for (let counter = 1; counter <= numberOfCharactersToGenerate; counter++)
} // End-if (inputData)
await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
return returnData;
}
/**
* @function generateValidEmail
* @description Generate a valid random email address composed of a random selection of
* mixed case english letters, numeric characters and optionally special characters
* from an optional list of allowable special characters, should be generated;
* generate them and string them together to the specified length.
* Basically this function acts as an input filter to ensure that valid inputs are passed into the functions for doing the word of generating random valid emails.
* @param {string} inputData The string that contains the number of characters to generate.
* @param {array<boolean,string,string>} inputMetaData An array map with multiple input parameters.
* inputMetaData[0] - generateSpecialCharacters - A boolean value to indicate if special characters should be included when randomly generating characters for the output string.
* inputMetaData[1] - allowableSpecialCharacters - The list of allowable special characters as a string, only used if the {@code generateSpecialCharacters} boolean value is set to {@code TRUE}.
* inputMetaData[2] - specifiedSuffixAndDomain - The specified suffix and domain to use after the "@" symbol in the email being generated, example "Yahoo.com".
* inputMetaData[3] - language - The language that should be used to determine the alphabet that should be used for international characters.
* @return {string} A string of randomly generated mixed case alpha numeric characters and optionally special characters
* where the length of the string is also defined as one of the input parameters, formatted as an email: a@b.com".
* @author Seth Hollingsead
* @date 2022/01/26
*/
async function generateValidEmail(inputData, inputMetaData) {
let functionName = generateValidEmail.name;
await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
let returnData = '';
let newInputMetaData = [];
if (!!inputMetaData && inputMetaData !== 'undefined' && inputMetaData !== '') {
if (inputMetaData.length === 4) {
newInputMetaData[0] = await ruleParsing.processRulesInternal([inputMetaData[0], ''], [biz.cstringToBoolean]); // generateSpecialCharacters
newInputMetaData[1] = inputMetaData[1]; // allowableSpecialCharacters
newInputMetaData[2] = inputMetaData[2]; // specifiedSuffixAndDomain
newInputMetaData[3] = inputMetaData[3]; // language
// NOTE: The above function stringParsingUtilities.stringToBoolean will default to False if the input is an empty or undefined string.
// We want to flip it back to True but ony if some special characters are passed in.
if (newInputMetaData[0] === false && newInputMetaData[1] !== '') {
newInputMetaData[0] = true;
}
returnData = await generateValidEmailWithSpecificSuffixAndDomainName(inputData, newInputMetaData);
} else if (inputMetaData.length === 3) {
newInputMetaData[0] = await ruleParsing.processRulesInternal([inputMetaData[0], ''], [biz.cstringToBoolean]); // generateSpecialCharacters
newInputMetaData[1] = inputMetaData[1]; // allowableSpecialCharacters
newInputMetaData[2] = inputMetaData[2]; // specifiedSuffixAndDomain
newInputMetaData[3] = lng.cEnglish; // language
// NOTE: The above function stringParsingUtilities.stringToBoolean will default to False if the input is an empty or undefined string.
// We want to flip it back to True but only if some special characters are passed in.
if (newInputMetaData[0] === false && newInputMetaData[1] !== '') {
newInputMetaData[0] = true;
}
returnData = await generateValidEmailWithSpecificSuffixAndDomainName(inputData, newInputMetaData);
} else if (inputMetaData.length === 2) {
newInputMetaData[0] = await ruleParsing.processRulesInternal([inputMetaData[0], ''], [biz.cstringToBoolean]); // generateSpecialCharacters
newInputMetaData[1] = inputMetaData[1]; // allowableSpecialCharacters
newInputMetaData[2] = ''; // specifiedSuffixAndDomain
newInputMetaData[3] = lng.cEnglish; // language
// NOTE: The above function stringParsingUtilities.stringToBoolean will default to False if the input is an empty or undefined string.
// We want to flip it back to True but only if some special characters are passed in.
if (newInputMetaData[0] === false && newInputMetaData[1] !== '') {
newInputMetaData[0] = true;
}
returnData = await generateRandomValidEmail(inputData, newInputMetaData);
} else if (inputMetaData.length === 1) {
newInputMetaData[0] = await ruleParsing.processRulesInternal([inputMetaData[0], ''], [biz.cstringToBoolean]); // generateSpecialCharacters
newInputMetaData[1] = ''; // allowableSpecialCharacters
newInputMetaData[2] = ''; // specifiedSuffixAndDomain
newInputMetaData[3] = lng.cEnglish; // language
returnData = await generateRandomValidEmail(inputData, newInputMetaData);
} else {
newInputMetaData[0] = false; // generateSpecialCharacters
newInputMetaData[1] = ''; // allowableSpecialCharacters
newInputMetaData[2] = ''; // specifiedSuffixAndDomain
newInputMetaData[3] = lng.cEnglish; // language
returnData = await generateRandomValidEmail(inputData, newInputMetaData);
}
} else { // Else-clause if (!!inputMetaData && inputMetaData !== 'undefined' && inputMetaData !== '')
newInputMetaData[0] = false; // generateSpecialCharacters
newInputMetaData[1] = ''; // allowableSpecialCharacters
newInputMetaData[2] = ''; // specifiedSuffixAndDomain
newInputMetaData[3] = lng.cEnglish; // language
returnData = await generateRandomValidEmail(inputData, newInputMetaData);
} // End-else-clause if (!!inputMetaData && inputMetaData !== 'undefined' && inputMetaData !== '')
await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
return returnData;
}
/**
* @function generateInvalidEmail
* @description Generate an invalid random email address composed of a random selection of mixed case english letters,
* numeric characters adn optionally special characters from an optional list of allowable special characters,
* should be generated; generate them and string them together to the specified length.
* @param {string} inputData The string that contains the number of characters to generate.
* @param {array<boolean,string,string>} inputMetaData An array map with multiple input parameters:
* inputMetaData[0] - generateSpecialCharacters - A boolean value to indicate if special characters should be included when randomly generating characters for the output string.
* inputMetaData[1] - allowableSpecialCharacters - The list of allowable special characters as a string, only used if the {@code generateSpecialCharacters} boolean value is set to {@code TRUE}.
* inputMetaData[2] - specifiedSuffixAndDomain - The specified suffix and domain to use after the "@" symbol in the email being generated, example "Yahoo.com".
* inputMetaData[3] - language - The language that should be used to determine the alphabet that should be used for international characters.
* @return {string} A string of randomly generated mixed case alpha numeric characters and
* optionally special characters where the length of the string is also defined as one
* of the input parameters, formatted as an email: "a@b.com".
* @author Seth Hollingsead
* @date 2022/01/26
*/
async function generateInvalidEmail(inputData, inputMetaData) {
let functionName = generateInvalidEmail.name;
await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
let returnData = '';
let newInputMetaData = [];
if (!!inputMetaData && inputMetaData !== 'undefined' && inputMetaData !== '') {
if (inputMetaData.length === 4) {
newInputMetaData[0] = await ruleParsing.processRulesInternal([inputMetaData[0], ''], [biz.cstringToBoolean]); // generateSpecialCharacters
newInputMetaData[1] = inputMetaData[1]; // allowableSpecialCharacters
newInputMetaData[2] = inputMetaData[2]; // specifiedSuffixAndDomain
newInputMetaData[3] = inputMetaData[3]; // language
// @NOTE The above function stringParsingUtilities.stringToBoolean will default to False if the input is an empty or undefined string.
// We want to flip it back to True but ony if some special characters are passed in.
if (newInputMetaData[0] === false && newInputMetaData[1] !== '') {
newInputMetaData = true;
}
returnData = await generateInvalidEmailWithSpecificSuffixAndDomainName(inputData, newInputMetaData);
} else if (inputMetaData.length === 3) {
newInputMetaData[0] = await ruleParsing.processRulesInternal([inputMetaData[0], ''], [biz.cstringToBoolean]); // generateSpecialCharacters
newInputMetaData[1] = inputMetaData[1]; // allowableSpecialCharacters
newInputMetaData[2] = inputMetaData[2]; // specifiedSuffixAndDomain
newInputMetaData[3] = lng.cEnglish; // language
// @NOTE The above function stringParsingUtilities.stringToBoolean will default to False if the input is an empty or undefined string.
// We want to flip it back to True but ony if some special characters are passed in.
if (newInputMetaData[0] === false && newInputMetaData[1] !== '') {
newInputMetaData[0] = true;
}
returnData = await generateInvalidEmailWithSpecificSuffixAndDomainName(inputData, newInputMetaData);
} else if (inputMetaData.length === 2) {
newInputMetaData[0] = await ruleParsing.processRulesInternal([inputMetaData[0], ''], [biz.cstringToBoolean]); // generateSpecialCharacters
newInputMetaData[1] = inputMetaData[1]; // allowableSpecialCharacters
newInputMetaData[2] = ''; // specifiedSuffixAndDomain
newInputMetaData[3] = lng.cEnglish; // language
// @NOTE The above function stringParsingUtilities.stringToBoolean will default to False if the input is an empty or undefined string.
// We want to flip it back to True but ony if some special characters are passed in.
if (newInputMetaData[0] === false && newInputMetaData[1] !== '') {
newInputMetaData[0] = true;
}
returnData = await generateRandomInvalidEmail(inputData, newInputMetaData);
} else if (inputMetaData.length === 1) {
newInputMetaData[0] = await ruleParsing.processRulesInternal([inputMetaData[0], ''], [biz.cstringToBoolean]); // generateSpecialCharacters
newInputMetaData[1] = ''; // allowableSpecialCharacters
newInputMetaData[2] = ''; // specifiedSuffixAndDomain
newInputMetaData[3] = lng.cEnglish; // language
returnData = await generateRandomInvalidEmail(inputData, newInputMetaData);
} else {
newInputMetaData[0] = false; // generateSpecialCharacters
newInputMetaData[1] = ''; // allowableSpecialCharacters
newInputMetaData[2] = ''; // specifiedSuffixAndDomain
newInputMetaData[3] = lng.cEnglish; // language
returnData = await generateRandomInvalidEmail(inputData, newInputMetaData);
}
} else {
newInputMetaData[0] = false; // generateSpecialCharacters
newInputMetaData[1] = ''; // allowableSpecialCharacters
newInputMetaData[2] = ''; // specifiedSuffixAndDomain
newInputMetaData[3] = lng.cEnglish; // language
returnData = await generateRandomInvalidEmail(inputData, newInputMetaData);
}
await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + returnData);
await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
return returnData;
}
/**
* @function generateValidEmailWithSpecificSuffixAndDomainName
* @description Generate a valid email composed of a random selection of mixed case english letters,
* numeric characters and optionally special characters from an optional list of allowable special characters,
* should be generated; generate them and string them together to the specified length.
* @param {string} inputData The string that contains the number of characters to generate.
* @param {array<string|boolean>} inputMetaData An array with multiple input parameters:
* inputMetaData[0] - generateSpecialCharacters - A boolean value to indicate if special characters should be included when randomly generating characters for the output string.
* inputMetaData[1] - allowableSpecialCharacters - The list of allowable special characters as a string, only used if the {@code generateSpecialCharacters} boolean value is set to {@code TRUE}.
* inputMetaData[2] - specifiedSuffixAndDomain - The specified suffix and domain to use after the "@" symbol in the email being generated, example "Yahoo.com".
* inputMetaData[3] - language - The language that should be used to determine the alphabet that should be used for international characters.
* @return {string} A string of randomly generated mixed case alpha numeric characters and optionally special characters
* where the length of the string is also defined as one of the input parameters, formatted as an email: "a@b.com".
* @NOTE The number of characters in the {@code specifiedSuffixAndDomain} input variable must not
* exceed the {@code numberOfCharactersToGenerate + 2} or the function/rule will return an empty string.
* @author Seth Hollingsead
* @date 2022/01/26
*/
async function generateValidEmailWithSpecificSuffixAndDomainName(inputData, inputMetaData) {
let functionName = generateValidEmailWithSpecificSuffixAndDomainName.name;
await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
let returnData = '';
let prefix = '';
if (inputData && inputMetaData && Array.isArray(inputMetaData) === true && inputMetaData.length === 4) {
let numberOfCharactersToGenerate = inputData;
let generateSpecialCharacters = inputMetaData[0];
let allowableSpecialCharacters = inputMetaData[1];
let specifiedSuffixAndDomain = inputMetaData[2];
let language = inputMetaData[3]
if ((numberOfCharactersToGenerate >= specifiedSuffixAndDomain.length + 2) && numberOfCharactersToGenerate >= 6 &&
specifiedSuffixAndDomain.includes(bas.cDot)) {
// @NOTE we cannot have less then 6 characters, because an e-mail address cannot be shorter than a@b.cc which is 6 characters long.
// We know we have to use an "@" symbol, and a "." symbol, the rest of the characters ust be generated....and the "." should have already been passed in.
// First need to figure out how many characters of each we must generate to et the desired final length.
//
// So lets remove the characters that we know we are already going to be reserved, the "@" symbol.
numberOfCharactersToGenerate = numberOfCharactersToGenerate - 1;
numberOfCharactersToGenerate = numberOfCharactersToGenerate - specifiedSuffixAndDomain.length;
if (generateSpecialCharacters === false) {
prefix = await generateRandomMixedCaseAlphaNumericCodeByLength(numberOfCharactersToGenerate, language);
} else {
prefix = await generateRandomMixedCaseAlphaNumericCodeWithSpecialCharactersByLength(numberOfCharactersToGenerate, [allowableSpecialCharacters, language]);
}
returnData = prefix + bas.cAt + specifiedSuffixAndDomain;
} else {
returnData = '';
}
} else {
returnData = '';
}
await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + returnData);
await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
return returnData;
}
/**
* @function generateRandomValidEmail
* @description Generate a valid email composed of a random selection of mixed case english letters,
* numeric characters and optional special characters from an optional list of allowable special characters,
* should be generated; generate them and string them together to the specified length.
* @param {string} inputData The string that contains the number of characters to generate.
* @param {array<string|boolean>} inputMetaData An array that contains a set of objects, strings and booleans as detailed below.
* inputMetaData[0] - generateSpecialCharacters - A Boolean value to indicate if special characters should be included when randomly generating characters for the output string.
* inputMetaData[1] - allowableSpecialCharacters - The list of allowable special characters as a string, only used if the {@code generateSpecialCharacters} Boolean value is set to {@code TRUE}.
* inputMetaData[2] - specifiedSuffixAndDomain - Not used for this business rule.
* inputMetaData[3] - language - The language that should be used to determine the alphabet that should be used for international characters.
* @return {string} A string of randomly generated mixed case alpha numeric characters adn optionally special characters
* where the length of the string is also defined as one of the input parameters, formatted as an email "a@b.com".
* @author Seth Hollingsead
* @date 2022/01/26
*/
async function generateRandomValidEmail(inputData, inputMetaData) {
let functionName = generateRandomValidEmail.name;
await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
let returnData = '';
let prefix = '';
let suffix = '';
let domainName = '';
let numberOfPrefixCharacters = 0;
let numberOfSuffixCharacters = 0;
if (inputData && inputMetaData && Array.isArray(inputMetaData) === true && inputMetaData.length === 3) {
let numberOfCharactersToGenerate = inputData;
let generateSpecialCharacters = inputMetaData[0];
let allowableSpecialCharacters = inputMetaData[1];
// let specifiedSuffixAndDomain = inputMetaData[2]; NOTE: This array index is not used for this business rule.
let language = inputMetaData[3];
if (numberOfCharactersToGenerate >= 6) {
// @NOTE We cannot have less than 6, because an e-mail address cannot be shorter than a@b.cc which is 6 characters long.
// We know we have to use an "@" symbol, and a "." symbol, the rest of the characters must be generated.
// first need to figure out how many characters of each we must generate to get the desired file length.
//
// So lets remove the characters that we know are already going to be reserved, the "@" symbol and the "." symbol.
numberOfCharactersToGenerate = numberOfCharactersToGenerate - 2;
// Consider that the number of characters in the domain must be either 2 or 3. (according to IpV5, IpV6 is a whole other ball of wax!!)
// So let us first figure that out, then the rest of the available characters that we must provide can be divided up between the prefix and suffix.
if (numberOfCharactersToGenerate === 4) { // Stick with a 2-character domain name.
if (generateSpecialCharacters === false) {
domainName = await generateRandomMixedCaseTextByLength(num.c2, language);
} else {
domainName = await generateRandomMixedCaseAlphaNumericCodeWithSpecialCharactersByLength(num.c2, [allowableSpecialCharacters, language]);
}
} else if (numberOfCharactersToGenerate >= 5) {
// Randomly determine if we should generate a 2-character or 3-character domain name. We can do either one,
// but we need to decide now so we can get it done and be fair.
// (That is generate 2-character domains roughly equal to the times we generate a 3-character domain.)
if (await ruleParsing.processRulesInternal(['', ''], [biz.crandomlyGenerateBooleanValue]) === true) { // Stick with a 2-character domain name.
if (generateSpecialCharacters === false) {
domainName = await generateRandomMixedCaseTextByLength(num.c2, language);
} else {
domainName = await generateRandomMixedCaseAlphaNumericCodeWithSpecialCharactersByLength(num.c2, [allowableSpecialCharacters, language]);
}
numberOfCharactersToGenerate = numberOfCharactersToGenerate - 2;
} else { // Do a 3-character domain name.
if (generateSpecialCharacters === false) {
domainName = await generateRandomMixedCaseTextByLength(num.c3, language);
} else {
domainName = await generateRandomMixedCaseAlphaNumericCodeWithSpecialCharactersByLength(num.c3, [allowableSpecialCharacters, language]);
}
numberOfCharactersToGenerate = numberOfCharactersToGenerate - 3;
}
} else {
// @NOTE We should never actually get here, because the {@code numberOfCharactersToGenerate} cannot be less than 6 and 6-2 must be >=4.
// Just generate the minimum domain and try to proceed as best as possible as a matter of completeness of the code.
if (generateSpecialCharacters === false) {
domainName = await generateRandomMixedCaseTextByLength(num.c2, language);
} else {
domainName = await generateRandomMixedCaseAlphaNumericCodeWithSpecialCharactersByLength(num.c2, [allowableSpecialCharacters, language]);
}
numberOfCharactersToGenerate = numberOfCharactersToGenerate - 2;
}
// Remaining number of characters that we must provide to the e-mail must be divided by 2, or the prefix and suffix.
if (numberOfCharactersToGenerate % 2 === 0) {
// We have a number that is divisible by 2, so just divide it and that will be the number of characters we use for both the prefix and suffix.
numberOfPrefixCharacters = numberOfCharactersToGenerate / 2;
numberOfSuffixCharacters = numberOfPrefixCharacters;
} else if (numberOfCharactersToGenerate % 2 === 1) {
numberOfPrefixCharacters = numberOfCharactersToGenerate / 2;
numberOfSuffixCharacters = numberOfPrefixCharacters - 1;
} else { // Should also never get here, as all numbers are either divisible by 2 or not with a remainder of 1.
// Just do something to see if we can survive, again as a matter of completeness of code logic.
numberOfPrefixCharacters = numberOfCharactersToGenerate / 2;
numberOfSuffixCharacters = numberOfPrefixCharacters;
}
if (generateSpecialCharacters === false) {
prefix = await generateRandomMixedCaseAlphaNumericCodeByLength(numberOfPrefixCharacters, language);
suffix = await generateRandomMixedCaseAlphaNumericCodeByLength(numberOfSuffixCharacters, language);
} else {
prefix = await generateRandomMixedCaseAlphaNumericCodeWithSpecialCharactersByLength(numberOfPrefixCharacters, [allowableSpecialCharacters, language]);
suffix = await generateRandomMixedCaseAlphaNumericCodeWithSpecialCharactersByLength(numberOfSuffixCharacters, [allowableSpecialCharacters, language]);
}
returnData = prefix + bas.cAt + suffix + bas.cDot + domainName;
} else {
returnData = '';
}
} else {
returnData = '';
}
await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + returnData);
await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
return returnData;
}
/**
* @function generateInvalidEmailWithSpecificSuffixAndDomainName
* @description Generate an invalid email composed of a random selection of mixed case english letters,
* numeric characters and optional special characters from an optional list of allowable special characters,
* should be generated; generate them and string them together to the specified length.
* @param {string} inputData The string that contains the number of characters to generate.
* @param {array<string|boolean>} inputMetaData An array that contains a set of objects, strings and booleans as detailed below.
* inputMetaData[0] - generateSpecialCharacters - A Boolean value to indicate if special characters should be included when randomly generating characters for the output string.
* inputMetaData[1] - allowableSpecialCharacters - The list of allowable special characters as a string, only used if the {@code generateSpecialCharacters} Boolean value is set to {@code TRUE}.
* inputMetaData[2] - specifiedSuffixAndDomain - The specified suffix and domain to use after the "@" symbol in the email being generated, example: "Yahoo.com".
* inputMetaData[3] - language - The language that should be used to determine the alphabet that should be used for international characters.
* @return {string} A string of randomly generated mixed case alpha numeric characters and optionally
* special characters where the length of the string is also defined as one of the input parameters, formatted as an email "a@b.com".
* @NOTE The number of characters in the {@code specifiedSuffixAndDomain} input variable must not
* exceed the {@code numberOfCharactersToGenerate + 2} or the function/rule will return an empty string.
* @author Seth Hollingsead
* @date 2022/01/26
*/
async function generateInvalidEmailWithSpecificSuffixAndDomainName(inputData, inputMetaData) {
let functionName = generateInvalidEmailWithSpecificSuffixAndDomainName.name;
await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
let returnData = '';
let prefix = '';
let numberOfPrefixCharacters = 0;
let failureMode = -1;
// NOTE: Cannot have a "." as part of a variable name in a {set}.
failureMode = await ruleParsing.processRulesInternal([num.c1, [num.c3, gen.cTrue, gen.cTrue]], [biz.crandomlyGenerateNumberInRange]);
// failureMode is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cfailureModeIs + failureMode);
// ************************************************************
// Failure Mode Legend:
// ************************************************************
// intFailureMode =
// 1 - Without the "@" symbol
// 2 - Without the prefix
// 3 - Without the "@" & Prefix
// NOTE: Take special note of the code below, and make sure you DO NOT add additional else statements to CYA for various special-use cases.
// adding else statements to the end of existing if-else-if statements will break other logic causing many more problems that you might miss when testing.
// The logic below is pretty much full-proof and will likely not need editing. If you need to handle additional special use cases,
// I suggest you invent your own email generation function/rule.
// Feel free to use this one as a reference as to how to do it, or just leverage the faker tool, which also has a way to generate fake emails.
if (inputData && inputMetaData && Array.isArray(inputMetaData) === true && inputMetaData.length === 4) {
let numberOfCharactersToGenerate = inputData;
let generateSpecialCharacters = inputMetaData[0];
let allowableSpecialCharacters = inputMetaData[1];
let specifiedSuffixAndDomain = inputMetaData[2];
let language = inputMetaData[3];
// numberOfCharactersToGenerate is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cnumberOfCharactersToGenerateIs + numberOfCharactersToGenerate);
// generateSpecialCharacters is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cgenerateSpecialCharactersIs + generateSpecialCharacters);
// allowableSpecialCharacters is:
await loggers.consoleLog(namespacePrefix + functionName, msg.callowableSpecialCharactersIs + allowableSpecialCharacters);
// specifiedSuffixAndDomain is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cspecifiedSuffixAndDomainIs + specifiedSuffixAndDomain);
// language is:
await loggers.consoleLog(namespacePrefix + functionName, msg.clanguageIs + language);
if (numberOfCharactersToGenerate >= 6) {
// We cannot have less then 6, because an e-mail address cannot be shorter than a@b.cc which is 6 characters long.
// We know we have to use an "@" symbol, and a "." symbol, the rest of the characters must be generated.
// First we need to figure out how many characters of each we must generate to get the desired final length.
switch (failureMode) {
case 1: case num.c1:
numberOfCharactersToGenerate = numberOfCharactersToGenerate - (specifiedSuffixAndDomain.length + 1);
break;
case 2: case num.c2:
numberOfCharactersToGenerate = numberOfCharactersToGenerate - specifiedSuffixAndDomain.length;
break;
case 3: case num.c3:
numberOfCharactersToGenerate = 0;
break;
default:
numberOfCharactersToGenerate = 0;
break;
} // End-switch (failureMode)
// This a pretty dumb and stupid way of doing it, but we only have 3 failure modes for this rule.
// There are basically with and without the prefix, and we've refactored in all the other cases already above.
numberOfPrefixCharacters = numberOfCharactersToGenerate;
// numberOfCharactersToGenerate is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cnumberOfCharactersToGenerateIs + numberOfCharactersToGenerate);
if (numberOfPrefixCharacters > 0) {
if (generateSpecialCharacters === false) {
prefix = await generateRandomMixedCaseAlphaNumericCodeByLength(numberOfPrefixCharacters.toString(), language);
} else {
prefix = await generateRandomMixedCaseAlphaNumericCodeWithSpecialCharactersByLength(numberOfPrefixCharacters.toString(), [allowableSpecialCharacters, language]);
}
} // End-if (numberOfPrefixCharacters > 0)
// prefix is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cprefixIs + prefix);
switch (failureMode) {
case 1: case num.c1: // Without the @ symbol.
await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheAtSymbol);
returnData = prefix + specifiedSuffixAndDomain;
break;
case 2: case num.c2: // Without the prefix.
await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutThePrefix);
returnData = bas.cAt + specifiedSuffixAndDomain;
break;
case 3: case num.c3: // Without the @ and prefix.
await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheAtSymbolAndPrefix);
returnData = specifiedSuffixAndDomain;
break;
default: // DEFAULT: Without the @ and prefix
await loggers.consoleLog(namespacePrefix + functionName, msg.cDEFAULTWithoutTheAtSymbolAndPrefix);
returnData = specifiedSuffixAndDomain;
break;
} // End-switch (failureMode)
} // End-if (numberOfCharactersToGenerate >= 6)
}
await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + returnData);
await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
return returnData;
}
/**
* @function generateRandomInvalidEmail
* @description Generate an invalid email composed of a random selection of mixed case english letters,
* numeric characters and optional special characters from an optional list of allowable special characters,
* should be generated; generate them and string them together to the specified length.
* @param {string} inputData The string that contains the number of characters to generate.
* @param {array<string|boolean>} inputMetaData An array that contains a set of objects, strings and booleans as detailed below.
* inputMetaData[0] - generateSpecialCharacters - A Boolean value to indicate if special characters should be included when randomly generating characters for the output string.
* inputMetaData[1] - allowableSpecialCharacters - The list of allowable special characters as a string, only used if the {@code generateSpecialCharacters} Boolean value is set to {@code TRUE}.
* inputMetaData[2] - specifiedSuffixAndDomain - Not used for this business rule.
* inputMetaData[3] - language - The language that should be used to determine the alphabet that should be used for international characters.
* @return {string} A string of randomly generated mixed case alpha numeric characters and optionally special characters
* where the length of the string is also defined as one of the input parameters, formatted as an email "a@b.com".
* @author Seth Hollingsead
* @date 2022/01/26
*/
async function generateRandomInvalidEmail(inputData, inputMetaData) {
let functionName = generateRandomInvalidEmail.name;
await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
let returnData = '';
let prefix = '';
let suffix = '';
let domainName = '';
let numberOfPrefixCharacters = 0;
let numberOfSuffixCharacters = 0;
let numberOfDomainNameCharacters = 0;
let failureMode = -1;
// NOTE Cannot have a "." as part of a variable name in a {set}.
failureMode = await ruleParsing.processRulesInternal([num.c1, [num.c28 + gen.cTrue, gen.cTrue]], [biz.crandomlyGenerateNumberInRange]);
failureMode = parseInt(failureMode);
// failureMode is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cfailureModeIs + failureMode);
// ************************************************************
// Failure Mode Legend:
// ************************************************************
// intFailureMode =
// 1 - Without the "@" symbol
// 2 - Without the "." symbol
// 3 - Without both the "@" & "." symbols
// 4 - Without the domain name
// 5 - Without the "@" & domain name
// 6 - Without the "." & domain name
// 7 - Without the "@", "." & domain name
// 8 - Without the prefix
// 9 - Without the suffix
// 10- Without the "@" & Prefix
// 11- Without the "." & Prefix
// 12- Without the "@" & Suffix
// 13- Without the "." & Suffix
// 14- Without the "@", "." & Prefix
// 15- Without the "@", "." & Suffix
// 16- Without the "@", ".", Prefix, & Suffix
// 17- Without the Prefix & domain name
// 18- Without the Suffix & domain name
// 19- Without the Prefix & Suffix
// 20- Without the Prefix, Suffix & domain name
// 21- Without the "@", Prefix & domain name
// 22- Without the ".", Prefix & domain name
// 23- Without the "@", Suffix & domain name
// 24- Without the ".", Suffix & domain name
// 25- Without the "@", Prefix, Suffix & domain name
// 26- Without the ".", Prefix, Suffix & domain name
// 27- Without the Prefix, Suffix & "@"
// 28- Without the Prefix, Suffix & "."
if (inputData && inputMetaData && Array.isArray(inputMetaData) === true && inputMetaData.length === 4) {
let numberOfCharactersToGenerate = inputData;
let generateSpecialCharacters = inputMetaData[0];
let allowableSpecialCharacters = inputMetaData[1];
// let specifiedSuffixAndDomain = inputMetaData[2]; NOTE: This array index is not used for this business rule.
let language = inputMetaData[3];
// numberOfCharactersToGenerate is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cnumberOfCharactersToGenerateIs + numberOfCharactersToGenerate);
// generateSpecialCharacters is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cgenerateSpecialCharactersIs + generateSpecialCharacters);
// allowableSpecialCharacters is:
await loggers.consoleLog(namespacePrefix + functionName, msg.callowableSpecialCharactersIs + allowableSpecialCharacters);
// specifiedSuffixAndDomain is:
// await loggers.consoleLog(namespacePrefix + functionName, msg.cspecifiedSuffixAndDomainIs + specifiedSuffixAndDomain);
// language is:
await loggers.consoleLog(namespacePrefix + functionName, msg.clanguageIs + language);
// NOTE: Take special note of the code below, and make sure you DO NOT add additional else statements to CYA for various special-use cases.
// Adding else statements to the end of existing if-else-if statements will break other logic causing many more problems that you might miss when testing.
// the logic below is pretty much full-proof and will likely not need editing. If you need to handle additional special use cases,
// I suggest you invent your own email generation function/rule.
// Feel free to use this one as a reference as to how to do it, or just leverage teh faker tool, which also has a way to generate fake emails.
if (numberOfCharactersToGenerate >= 6) {
// We cannot have less than 6, because an email address cannot be shorter than a@b.cc which is 6 characters long.
// We know we have to use an "@" symbol, and a "." symbol, the rest fo the characters must be generated.
// first need to figure out how many characters of each we must generate to get the desired final length.
// So lets remove the characters that we know are already going to be reserved, the "@" symbol and the "." symbol, according to the failure mode.
if (failureMode === 1 || failureMode === 2 || failureMode === 5 || failureMode === 6 ||
failureMode === 10 || failureMode === 11 || failureMode == 12 || failureMode === 13 || failureMode >= 21 ) {
numberOfCharactersToGenerate = numberOfCharactersToGenerate - 1;
} else if (failureMode === 3 || failureMode === 7 || failureMode === 14 || failureMode === 15 || failureMode === 16) {
numberOfCharactersToGenerate = numberOfCharactersToGenerate - 2;
}
// numberOfCharactersToGenerate is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cnumberOfCharactersToGenerateIs + numberOfCharactersToGenerate);
// Only work generating the domain name if we are not going to be building our invalid email on a missing domain name.
if (failureMode === 1 || failureMode === 2 || failureMode === 3 || (failureMode >= 8 && failureMode <= 16) || failureMode === 19 || failureMode > 27) {
// Consider that the number of characters in the domain must be either 2 or 3 (according to IpV5, I'm not going to even try touching IpV6!!)
// So lets first figure that out, then the rest of the available characters that we must provide can be divided up between the prefix and suffix.
if (numberOfCharactersToGenerate === 4) {
// Stick with a 2-character domain name.
if (generateSpecialCharacters === false) {
domainName = await generateRandomMixedCaseTextByLength(num.c2, language);
} else {
if (!!allowableSpecialCharacters && allowableSpecialCharacters !== undefined) {
domainName = await generateRandomMixedCaseAlphaNumericCodeWithSpecialCharactersByLength(num.c2, [allowableSpecialCharacters, language]);
} else {
domainName = await generateRandomMixedCaseTextByLength(num.c2, language);
}
}
numberOfCharactersToGenerate = numberOfDomainNameCharacters - 2;
} else if (numberOfCharactersToGenerate >= 5) {
// Randomly determine if we should generate a 2-character or 3-character domain name. We can do either one,
// but we need to decide now so we can get it done and be fair.
// (That is generate 2-character domains roughly equal to the times we generate a 3-character domain.)
if (await ruleParsing.processRulesInternal(['', ''], [biz.crandomlyGenerateBooleanValue]) === true) { // Stick with a 2-character domain name.
if (generateSpecialCharacters === false) {
domainName = await generateRandomMixedCaseTextByLength(num.c2, language);
} else {
if (!!allowableSpecialCharacters && allowableSpecialCharacters !== undefined) {
domainName = await generateRandomMixedCaseAlphaNumericCodeWithSpecialCharactersByLength(num.c2, [allowableSpecialCharacters, language]);
} else {
domainName = await generateRandomMixedCaseTextByLength(num.c2, language);
}
}
numberOfCharactersToGenerate = numberOfDomainNameCharacters - 2;
} else { // Do a 3-character domain name.
if (generateSpecialCharacters === false) {
domainName = await generateRandomMixedCaseTextByLength(num.c3, language);
} else {
if (!!allowableSpecialCharacters && allowableSpecialCharacters !== undefined) {
domainName = await generateRandomMixedCaseAlphaNumericCodeWithSpecialCharactersByLength(num.c3, [allowableSpecialCharacters, language]);
} else {
domainName = await generateRandomMixedCaseTextByLength(num.c3, language);
}
}
numberOfCharactersToGenerate = numberOfDomainNameCharacters - 3
}
} // End-else-if (numberOfCharactersToGenerate >= 5)
} // End-if (failureMode === 1 || failureMode === 2 || failureMode === 3 || (failureMode >= 8 && failureMode <= 16) || failureMode === 19 || failureMode > 27)
// domainName is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cdomainNameIs + domainName);
// ONLY do suffix and prefix if our failure modes do not exclude both.
if (failureMode >= 1 && failureMode <= 7) {
// Remaining number of characters that we must provide to the e-mail must be divided by 2, for the prefix and suffix.
if (numberOfCharactersToGenerate % 2 === 0) {
// We have a number that is divisible by 2, so just divide it and
// that will be the number of characters we use for both the prefix and suffix.
numberOfPrefixCharacters = numberOfCharactersToGenerate / 2;
numberOfSuffixCharacters = numberOfPrefixCharacters;
} else if (numberOfCharactersToGenerate % 2 === 1) {
numberOfPrefixCharacters = numberOfCharactersToGenerate / 2;
numberOfSuffixCharacters = numberOfPrefixCharacters - 1;
}
} else if (failureMode === 8 || failureMode === 10 || failureMode === 11 || failureMode === 14 || failureMode === 17 || failureMode === 21 || failureMode === 22) {
// Excluding the Prefix
numberOfSuffixCharacters = numberOfCharactersToGenerate; // Suffix get the remainder!
numberOfPrefixCharacters = 0;
} else if (failureMode === 9 || failureMode === 12 || failureMode === 13 || failureMode === 15 || failureMode === 18 || failureMode === 23 || failureMode === 24) {
// Excluding the Suffix
numberOfPrefixCharacters = numberOfCharactersToGenerate; // Prefix gets the remainder!
numberOfSuffixCharacters = 0;
}
// numberOfPrefixCharacters is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cnumberOfPrefixCharactersIs + numberOfPrefixCharacters);
// numberOfSuffixCharacters is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cnumberOfSuffixCharactersIs + numberOfSuffixCharacters);
if (numberOfPrefixCharacters > 0) {
if (generateSpecialCharacters === false) {
prefix = await generateRandomMixedCaseAlphaNumericCodeByLength(numberOfPrefixCharacters.toString(), language);
} else {
if (!!allowableSpecialCharacters && allowableSpecialCharacters !== undefined) {
prefix = await generateRandomMixedCaseAlphaNumericCodeWithSpecialCharactersByLength(numberOfPrefixCharacters.toString(), [allowableSpecialCharacters, language]);
} else {
prefix = await generateRandomMixedCaseAlphaNumericCodeByLength(numberOfPrefixCharacters.toString(), language);
}
}
} // End-if (numberOfPrefixCharacters > 0)
// prefix is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cprefixIs + prefix);
if (numberOfSuffixCharacters > 0) {
if (generateSpecialCharacters === false) {
suffix = await generateRandomMixedCaseAlphaNumericCodeByLength(numberOfSuffixCharacters.toString(), language);
} else {
if (!!allowableSpecialCharacters && allowableSpecialCharacters !== undefined) {
suffix = await generateRandomMixedCaseAlphaNumericCodeWithSpecialCharactersByLength(numberOfSuffixCharacters.toString(), [allowableSpecialCharacters, language]);
} else {
suffix = await generateRandomMixedCaseAlphaNumericCodeByLength(numberOfSuffixCharacters.toString(), language);
}
}
} // End-if (numberOfSuffixCharacters > 0)
// suffix is:
await loggers.consoleLog(namespacePrefix + functionName, msg.csuffixIs + suffix);
} // End-if (numberOfCharactersToGenerate >= 6)
}
switch (failureMode) {
case 1: // Without the @ symbol.
await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheAtSymbol);
returnData = prefix + suffix + bas.cDot + domainName;
break;
case 2: // Without the . symbol.
await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheDotSymbol);
returnData = prefix + bas.cAt + suffix + domainName;
break;
case 3: // Without bot the @ and . symbols
await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheAtAndDotSymbols);
returnData = prefix + suffix + domainName;
break;
case 4: // Without the domain name.
await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheDomainName);
returnData = prefix + bas.cAt + suffix + bas.cDot;
break;
case 5: // Without the @ and domain name.
await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheAtSymbolAndDomainName);
returnData = prefix + suffix + bas.cDot + domainName;
break;
case 6: // Without the . and domain name.
await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheDotAndDomainName);
returnData = prefix + bas.cAt + suffix;
break;
case 7: // Without the @, . and domain name.
await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheAtSymbolDotAndDomainName);
returnData = prefix + suffix;
break;
case 8: // Without the prefix.
await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutThePrefix);
returnData = bas.cAt + suffix + bas.cDot + domainName;
break;
case 9: // Without the suffix.
await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheSuffix);
returnData = prefix + bas.cAt + bas.cDot + domainName;
break;
case 10: // Without the @ and prefix.
await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheAtSymbolAndPrefix);
returnData = suffix + bas.cDot + domainName;
break;
case 11: // Without the . and prefix.
await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheDotAndPrefix);
returnData = bas.cAt + suffix + domainName;
break;
case 12: // Without the @ and suffix.
await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheAtSymbolAndSuffix);
returnData = prefix + bas.cDot + domainName;
break;
case 13: // Without the . and suffix.
await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheDotAndSuffix);
returnData = prefix + bas.cAt + domainName;
break;
case 14: // Without the @, . and prefix.
await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheAtSymbolDotAndPrefix);
returnData = suffix + domainName;
break;
case 15: // Without the @, . and suffix.
await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheAtSymbolDotAndSuffix);
returnData = prefix + domainName;
break;
case 16: // Without the @, ., prefix, and suffix.
await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheAtSymbolDotPrefixAndSuffix);
returnData = domainName;
break;
case 17: // Without the prefix and domain name.
await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutThePrefixAndDomainName);
returnData = bas.cAt + suffix + bas.cDot;
break;
case 18: // Without the suffix and domain name.
await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheSuffixAndDomainName);
returnData = prefix + bas.cAt + bas.cDot;
break;
case 19: // Without the prefix and suffix.
await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutThePrefixAndSuffix);
returnData = bas.cAt + bas.cDot + domainName;
break;
case 20: // Without the prefix, suffix and domain name.
await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutThePrefixSuffixAndDomainName);
returnData = bas.cAt + bas.cDot;
break;
case 21: // Without the @, prefix and domain name.
await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheAtSymbolPrefixAndDomainName);
returnData = suffix + bas.cDot;
break;
case 22: // Without the ., prefix and domain name.
await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheDotPrefixAndDomainName);
returnData = bas.cAt + suffix;
break;
case 23: // Without the @, suffix and domain name.
await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheAtSymbolSuffixAndDomainName);
returnData = prefix + bas.cDot;
break;
case 24: // Without the ., suffix and domain name.
await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheDotSuffixAndDomainName);
returnData = prefix + bas.cAt + bas.cDot;
break;
case 25: // Without the @, prefix, suffix and domain name.
await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheAtSymbolPrefixSuffixAndDomainName);
returnData = bas.cDot;
break;
case 26: // Without the ., prefix, suffix and domain name.
await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutTheDotPrefixSuffixAndDomainName);
returnData = bas.cAt;
break;
case 27: // Without the prefix, suffix and @.
await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutThePrefixSuffixAndAtSymbol);
returnData = bas.cDot + domainName;
break;
case 28: // Without the prefix, suffix and ..
await loggers.consoleLog(namespacePrefix + functionName, msg.cWithoutThePrefixSuffixAndDot);
returnData = bas.cAt + domainName;
break;
} // End-switch (failureMode)
await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + returnData);
await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
return returnData;
}
/**
* @function generateRandomBrightColor
* @description Generates a random set of RGB values in the bright color spectrum range.
* Originally I thought to generate just a bright color, but dividing the spectrum straight in half resulted in mostly drab colors.
* So I adjusted this function to use the inputs to provide a narrow range of bright values that can be generated.
* This makes the function nearly identical to the same function that generates random dark colors.
* Really the only difference is the default values. So this function is refactored to call a generic random color generator business rule.
* @param {string|integer} inputData The number in either numeric or string format that represents the minimum range that should be used to generate the random color.
* @param {string|integer} inputMetaData The number in either numeric or string format that represents the maximum range that should be used to generate the random color.
* @return {array<integer,integer,integer>} An array of RGB values in the bright color spectrum range.
* @author Seth Hollingsead
* @date 2022/01/27
*/
async function generateRandomBrightColor(inputData, inputMetaData) {
let functionName = generateRandomBrightColor.name;
await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
await await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
let returnData = [255,255,255];
let minimumColorRange = 127;
let maximumColorRange = 255;
let parsedColorRangeArray = [];
if (inputData && inputMetaData && inputData !== '' && inputMetaData !== '') {
// Try to parse them as numbers for the range.
parsedColorRangeArray = await ruleParsing.processRulesInternal([inputData, inputMetaData], [biz.cparseColorRangeInputs]);
minimumColorRange = parsedColorRangeArray[0];
maximumColorRange = parsedColorRangeArray[1];
} // End-if (inputData && inputMetaData && inputData !== '' && inputMetaData !== '')
returnData = await generateRandomColor(minimumColorRange, maximumColorRange);
await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
return returnData;
}
/**
* @function generateRandomDarkColor
* @description Generates a random set of RGB values in the dark color spectrum range.
* Originally I thought to generate just a dark color, but dividing the spectrum straight in half resulted in mostly drab colors.
* So I adjusted this function to use the inputs to provide a narrow range of dark values that can be generated.
* This makes the function nearly identical to the same function that generates random bright colors.
* Really the only difference is the default values. So this function is refactored to call a generic random color generator business rule.
* @param {string|integer} inputData The number in either numeric or string format that represents the minimum range that should be used to generate the random color.
* @param {string|integer} inputMetaData The number in either numeric or string format that represents the maximum range that should be used to generate the random color.
* @return {array<integer,integer,integer>} An array of RGB values in the dark color spectrum range.
* @author Seth Hollingsead
* @date 2022/01/27
*/
async function generateRandomDarkColor(inputData, inputMetaData) {
let functionName = generateRandomDarkColor.name;
await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
let returnData = [0,0,0];
let minimumColorRange = 0;
let maximumColorRange = 127;
let parsedColorRangeArray = [];
if (inputData && inputMetaData && inputData !== '' && inputMetaData !== '') {
// Try to parse them as numbers for the range.
parsedColorRangeArray = await ruleParsing.processRulesInternal([inputData, inputMetaData], [biz.cparseColorRangeInputs]);
minimumColorRange = parsedColorRangeArray[0];
maximumColorRange = parsedColorRangeArray[1];
} // End-if (inputData && inputMetaData && inputData !== '' && inputMetaData !== '')
returnData = await generateRandomColor(minimumColorRange, maximumColorRange);
await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
return returnData;
}
/**
* @function generateRandomColor
* @description Generates a random set of RGB values in the given color range.
* @param {string|integer} inputData The number in either numeric or string format that represents the minimum range that should be used to generate the random color.
* @param {string|integer} inputMetaData The number in either numeric or string format that represents the maximum range that should be used to generate the random color.
* @return {array<integer,integer,integer>} An array of RGB values that will be used for a color value.
* @author Seth Hollingsead
* @date 2022/01/27
*/
async function generateRandomColor(inputData, inputMetaData) {
let functionName = generateRandomColor.name;
await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + JSON.stringify(inputMetaData));
let returnData = [0,0,0];
let minimumColorRange = 0;
let maximumColorRange = 255;
let parsedColorRangeArray = [];
if (inputData && inputMetaData && inputData !== '' && inputMetaData !== '') {
// Try to parse them as numbers for the range.
parsedColorRangeArray = await ruleParsing.processRulesInternal([inputData, inputMetaData], [biz.cparseColorRangeInputs]);
minimumColorRange = parsedColorRangeArray[0];
maximumColorRange = parsedColorRangeArray[1];
} // End-if (inputData && inputMetaData && inputData !== '' && inputMetaData !== '')
// minimumColorRange is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cminimumColorRangeIs + minimumColorRange);
// maximumColorRange is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cmaximumColorRangeIs + maximumColorRange);
returnData[0] = await ruleParsing.processRulesInternal([minimumColorRange.toString(), [maximumColorRange.toString(), gen.ctrue, gen.ctrue]], [biz.crandomlyGenerateNumberInRange]); // Red
returnData[1] = await ruleParsing.processRulesInternal([minimumColorRange.toString(), [maximumColorRange.toString(), gen.ctrue, gen.ctrue]], [biz.crandomlyGenerateNumberInRange]); // Green
returnData[2] = await ruleParsing.processRulesInternal([minimumColorRange.toString(), [maximumColorRange.toString(), gen.ctrue, gen.ctrue]], [biz.crandomlyGenerateNumberInRange]); // Blue
await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
return returnData;
}
export default {
generateRandomMixedCaseTextByLength,
generateRandomUpperCaseTextByLength,
generateRandomLowerCaseTextByLength,
generateRandomMixedCaseTextWithSpecialCharactersByLength,
generateRandomUpperCaseTextWithSpecialCharactersByLength,
generateRandomLowerCaseTextWithSpecialCharactersByLength,
generateRandomMixedCaseAlphaNumericCodeByLength,
generateRandomUpperCaseAlphaNumericCodeByLength,
generateRandomLowerCaseAlphaNumericCodeByLength,
generateRandomNumericCodeByLength,
generateRandomMixedCaseAlphaNumericCodeWithSpecialCharactersByLength,
generateRandomUpperCaseAlphaNumericCodeWithSpecialCharactersByLength,
generateRandomLowerCaseAlphaNumericCodeWithSpecialCharactersByLength,
generateRandomSpecialCharacterCodeByLength,
generateValidEmail,
generateInvalidEmail,
generateValidEmailWithSpecificSuffixAndDomainName,
generateRandomValidEmail,
generateInvalidEmailWithSpecificSuffixAndDomainName,
generateRandomInvalidEmail,
generateRandomBrightColor,
generateRandomDarkColor,
generateRandomColor
};