Start of Program:

package [Link];

import [Link];

import [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

import [Link];

@SpringBootApplication
@EnableAutoConfiguration

public class OtonomApplication {

static Logger logger = [Link]([Link]);

@Autowired
OtonomHandler handle;

public static void main(String[] args) {

[Link]([Link], args);

[Link]().setup(); // Set up ChromeDriver

[Link]().setup(); // Set up GeckoDriver

// String browser = "chrome";

String browser = "firefox";

WebDriver driver;
if ("firefox".equalsIgnoreCase(browser)) {
driver = new FirefoxDriver();
[Link]("Firefox Driver Run Successfully ");
} else {
driver = new ChromeDriver();
[Link]("Chrome Driver Run Successfully ");
}

[Link]("this is trace message");

[Link]("this is info message");
[Link]("this is error message");
[Link]("this is warning message");
[Link]("this is fatal message");
 }

/*@PostConstruct
public void process() throws FileNotFoundException, DocumentException {
String inputFile = "Otonom_Config_Sanity_FTB_Cash_Position00";
ExecutorService executor = [Link](1);

for (int i = 1; i <= 3; i++) {

String fileName = inputFile + i + ".xlsx";
[Link](() -> {
try {
[Link](fileName);
} catch (Exception e) {
[Link]("Error processing file: " + fileName,
e);
}
});
}

}
*/

@PostConstruct void process() throws FileNotFoundException,

DocumentException { //String
// inputFile="Otonom_Config_Sanity_FTB_I2I_Sweep_Tran_10St_QHDCT00";

//String inputFile="Otonom_Config_Sanity_FTB_I2I_Sweep_Tran_10St_AWS00";
String inputFile="Otonom_Config_Sanity_FTB_Cash_Position00";

for(int i=2; i<=3; i++){ [Link](inputFile+i+".xlsx");

[Link](1);

otonam handleer:

package [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

import [Link];

@Component
public class OtonomHandler {
@Autowired
LoadConfigService config;
@Autowired
ResultService rs;

@Autowired
Environment environment;

@SuppressWarnings("rawtypes")

public void process(String inputfile) throws FileNotFoundException,

DocumentException {

String fileName;
String filePath;
String browser;
String driverPath;
try {

//driverPath = [Link]("chrome_driver_path");
//filePath = [Link]("otonom_home");
//filePath = ([Link]("[Link]")+"\\");
// filePath = "D:\\Otonom_New\\Otonom\\DEV_AUTOMATON_FILE\\";
//filePath = "D:\\Otonom_New\\Otonom\\SIT_Atomation_File\\";
// filePath = "D:\\Automation\\Daily_Sanity_DEV_SIT_UAT\\";
filePath = "D:\\Automation\\Otonom_new\\SANITY\\";
//filePath ="D:\\Otonom_New\\Otonom\\SCRIPT_WRITE\\";

// filePath="D:\\Otonom_New\\Otonom\\TEST_DATA\\";

//filePath = "D:\\Otonom_New\\Otonom\\SANITY\\";
Scanner myObj = new Scanner([Link]); // Create a Scanner
object
[Link]("Enter Config sheet");
// fileName = [Link](); // Read user input
fileName = inputfile;
[Link]("fileName is: " + fileName); // Output user
input

// fileName = [Link]("config_file_name");
browser = [Link]("browser");

// browser = ([Link]("[Link]")+"\\Driver\\
[Link]");
driverPath = [Link]("[Link]") + "\\Driver\\
[Link]";
//driverPath = [Link]("[Link]") + "\\Driver\\
[Link]";

//change 26sep
[Link]("[Link]", driverPath);
//[Link]("[Link]", driverPath);

//[Link]("driverPath::>>> " + driverPath + " filePath " + filePath

+ " fileName " + fileName+" browser " + browser);
} catch (Exception e) {
filePath = "D:\\Otonom_2.0\\Otonom";
fileName = "Otonom_sanity_sheet.xlsx";
browser = "chrome";
}

HashMap excelData = loadConfig(filePath, fileName);

HashMap resultMap = execute(excelData, filePath, browser);
writeResult(resultMap, filePath, fileName);
}

@SuppressWarnings("rawtypes")

private HashMap loadConfig(String filePath, String fileName) {

HashMap excelData = new HashMap();
// LoadConfigService config = new LoadConfigService();
try {
excelData = [Link](filePath, fileName);
} catch (IOException e) {
[Link]();
}
return excelData;
}

@SuppressWarnings("rawtypes")
private HashMap execute(HashMap mapConfig, String filePath, String browser)
throws FileNotFoundException, DocumentException {
HashMap resultMap;
OtonomService os = new OtonomService(mapConfig, filePath, browser);
resultMap = [Link]();
return resultMap;
}

@SuppressWarnings("rawtypes")
private void writeResult(HashMap resultMap, String filePath, String fileName)
{
// ResultService rs = new ResultService();
[Link](resultMap, filePath, fileName);
}
}

branding service:
package [Link];

import [Link];
import [Link];
public class BrandingService {

private ArrayList<String> brandingHeader;

private ArrayList<ArrayList<String>> brandingList;
private ArrayList<String> brandingKeys;
private HashMap<String, String> definedBranding;
private String bv;

public BrandingService(ArrayList<ArrayList<String>> brandingList) {

[Link] = brandingList;
[Link] = new ArrayList<String>();

brandingHeader = (ArrayList<String>) [Link](0);

for (int j = 0; j < [Link](); j++) {
[Link](((String) [Link](j)).trim());
}
}

public HashMap<String, String> getBrandingSpecs(String brandingRef, String

brandingType) {
ArrayList<String> brandingWorkList;
definedBranding = new HashMap<String, String>();
for (int i = 1; i < [Link](); i++) {
brandingWorkList = [Link](i);
if
([Link](([Link](0)).trim()) && brandingType
.equalsIgnoreCase("check_branding_" +
([Link](1)).trim().toLowerCase())) {
for (int j = 2; j < [Link](); j++) {
bv = ([Link](j)).trim();
if ([Link]() > 0)
[Link]([Link](j), bv);
}
break;
}
}
return definedBranding;
}

httpsservice:
package [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

public class HttpService {

RestTemplate restTemplate = new RestTemplate();

private ArrayList<ArrayList<String>> httpList;

public HttpService(ArrayList<ArrayList<String>> httpList) {

[Link] = httpList;
}

public int makeHttpCall(String callingApiCode) throws URISyntaxException {

[Link]("-----------------------------------");
ArrayList<String> httpWorkList;
ArrayList<String> parametersList = null;
ArrayList<String> headersList = null;
URI uri;
String httpUrl = null;
String httpMethod = " ";
String httpHeaders = null;
String httpBody = " ";
int responseStatus = 0;
ResponseEntity<String> response = null;
HttpHeaders headers;
String apiCode;
String responseJsonPath = null;
String responseJsonPathValue = null;
String parameters = null;
String holder;

int semicolonPosition = [Link](";");

int semicolonPositionSecond = 0;
if (semicolonPosition < 1) {
apiCode = callingApiCode;
} else {
semicolonPositionSecond = [Link](";",
semicolonPosition + 1);
[Link]("semicolonPositionSecond:" +
semicolonPositionSecond);
apiCode = [Link](0, semicolonPosition);
if (semicolonPositionSecond < 1) {
parameters = [Link](semicolonPosition +
1);
} else {
parameters = [Link](semicolonPosition +
1, semicolonPositionSecond);
responseJsonPath =
[Link](semicolonPositionSecond + 1).trim();
[Link]("responseJsonPath:" + responseJsonPath);
}
parametersList = new
ArrayList<>([Link]([Link](",")));
}

for (int i = 1; i < [Link](); i++) {

httpWorkList = [Link](i);
if ([Link](([Link](0)).trim())) {
httpUrl = ([Link](1)).trim();
httpMethod = ([Link](2)).trim();
httpHeaders = ([Link](3)).trim();
httpBody = ([Link](4)).trim();
break;
}
}

if (parametersList != null) {
for (int i = 0; i < [Link](); i++) {
httpBody = [Link]("##PARAM" + i + "##",
[Link](i).trim());
}
}
httpBody = replaceKeywords(httpBody);

uri = new URI(httpUrl);

headers = new HttpHeaders();
[Link](MediaType.APPLICATION_JSON);
headersList = new ArrayList<>([Link]([Link](",")));
for (int i = 0; i < [Link](); i++) {
if (!"Content-Type"
.equalsIgnoreCase([Link](i).substring(0,
[Link](i).indexOf(":")).trim())) {
holder = [Link](i);
holder = replaceKeywords(holder);
if (parametersList != null) {
for (int i1 = 0; i1 < [Link](); i1++) {
holder = [Link]("##PARAM" + i1 +
"##", [Link](i1).trim());
}
}
[Link]([Link](0,
[Link](":")).trim(),
[Link]([Link](":") +
1).trim());

}
}

try {
HttpEntity<String> request = new HttpEntity<>(httpBody, headers);
[Link]("apiCode: " + apiCode + " : request: " +
request);

if ("POST".equalsIgnoreCase([Link]()))
response = [Link](uri, [Link],
request, [Link]);
 if ("GET".equalsIgnoreCase([Link]()))
response = [Link](uri, [Link],
request, [Link]);

if (null != response) {
responseStatus = [Link]();
if (null != responseJsonPath &&
[Link]().length() > 0) {
try {
responseJsonPathValue =
[Link]([Link](), responseJsonPath).toString();
} catch (Exception e) {
responseJsonPathValue = "";
}
[Link]("--> responseJsonPathValue:" +
responseJsonPathValue);
}
}
} catch (HttpClientErrorException httperr) {
responseStatus = [Link]();
} catch (Exception e) {
[Link]();
}
[Link]("responseStatus:" + responseStatus);

[Link]("-------------------------------------------------------------")
;
return responseStatus;
}

private String replaceKeywords(String inputString) {

String replacedString = inputString;

replacedString = [Link]("##TODAY_YYYYMMDD##",

[Link]().format([Link]("yyyyMMdd")));
replacedString = [Link]("##TODAY_YYYY-MM-DD##",
[Link]().format([Link]("yyyy-
MM-dd")));
replacedString = [Link]("##TODAY_DD-MMM-YYYY##",
[Link]().format([Link]("dd-MMM-
yyyy")));
replacedString = [Link]("##TODAY_DD/MM/YYYY##",

[Link]().format([Link]("dd/MM/yyyy")));
replacedString = [Link]("##TODAY_DATE_TIME##",
[Link]()
.format([Link]("yyyy-MM-dd
HH:mm:[Link]").withZone([Link]())));

replacedString = [Link]("##YESTERDAY_YYYYMMDD##",

[Link]().minus([Link](1)).format([Link]("yyyyMMd
d")));
replacedString = [Link]("##YESTERDAY_YYYY-MM-DD##",
[Link]().minus([Link](1)).format([Link]("yyyy-
MM-dd")));
replacedString = [Link]("##YESTERDAY_DD-MMM-YYYY##",

[Link]().minus([Link](1)).format([Link]("dd-MMM-
yyyy")));
replacedString = [Link]("##YESTERDAY_DD/MM/YYYY##",

[Link]().minus([Link](1)).format([Link]("dd/MM/
yyyy")));
replacedString = [Link]("##YESTERDAY_DATE_TIME##",
[Link]().minus([Link](1)).format(
[Link]("yyyy-MM-dd
HH:mm:[Link]").withZone([Link]())));

replacedString = [Link]("##UID##", getUID());

return replacedString;
}

public String getUID() {

Random rnd = new Random();
int number = [Link](999999);

return [Link]().format([Link]("yyMMdd-
HHmmss-SSS"))
+ [Link]("%06d", number);
}
}

load config:
package [Link];

import [Link];
import [Link];
import [Link];
import [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

@Component
public class LoadConfigService {

@SuppressWarnings({ "rawtypes", "unchecked" })

public HashMap getExcelData(String filePath, String fileName) throws
IOException {

File f = new File(filePath + fileName);

HashMap mapExcelData = new HashMap();
 ArrayList dynamicSheet;
ArrayList scopeSheet;
ArrayList storySheet;
ArrayList sketchSheet;
ArrayList routineSheet;
ArrayList brandingSheet;
ArrayList guideSheet;
ArrayList readmeSheet;

try (ReadableWorkbook wb = new ReadableWorkbook(f)) {

dynamicSheet = getSingleSheetData(0, wb);

[Link]("Dynamic", dynamicSheet);
// printSingleSheetData(dynamicSheet);

scopeSheet = getSingleSheetData(1, wb);

[Link]("Scope", scopeSheet);
// printSingleSheetData(scopeSheet);

storySheet = getSingleSheetData(2, wb);

[Link]("Story", storySheet);
// printSingleSheetData(storySheet);

sketchSheet = getSingleSheetData(3, wb);

[Link]("Sketch", sketchSheet);
// printSingleSheetData(sketchSheet);

routineSheet = getSingleSheetData(4, wb);

[Link]("Routine", routineSheet);
// printSingleSheetData(routineSheet);

brandingSheet = getSingleSheetData(5, wb);

[Link]("Branding", brandingSheet);
// printSingleSheetData(brandingSheet);

guideSheet = getSingleSheetData(6, wb);

[Link]("Guide", guideSheet);
// printSingleSheetData(guideSheet);

readmeSheet = getSingleSheetData(7, wb);

[Link]("Readme", readmeSheet);
// printSingleSheetData(readmeSheet);

guideSheet = getSingleSheetData(8, wb);

[Link]("Database", guideSheet);
// printSingleSheetData(guideSheet);

readmeSheet = getSingleSheetData(9, wb);

[Link]("Http", readmeSheet);
// printSingleSheetData(readmeSheet);
}
return mapExcelData;
}

@SuppressWarnings({ "unchecked", "rawtypes" })

public ArrayList getSingleSheetData(int sheetIndex, ReadableWorkbook wb) {
Sheet sheet = null;
Row row = null;
ArrayList listKeys = new ArrayList();
 ArrayList listValues = new ArrayList();
ArrayList dataRows = new ArrayList();

try {
Optional<Sheet> optSheet = [Link](sheetIndex);
if ([Link]()) {
sheet = [Link]();
}

try (Stream<Row> rows = [Link]()) {

Iterator<Row> it = [Link]();
int i = 0;
while ([Link]()) {
[Link]();
row = [Link]();
if (i == -10) { // temporarily making it -10... need
to revisit this
[Link]().forEach(cell -> {
[Link]([Link]());
});
} else { // data rows.. not any more.. this holds
header row also
if ([Link](0).getText().length() > 0) {
[Link]().forEach(cell ->
[Link]([Link]()));
[Link]([Link]());
}
}
i++;
}
} catch (NullPointerException en) {
ArrayList tempList = new ArrayList();
[Link]("1"); // revisit this
[Link]([Link]());
} catch (IOException e) {
[Link]();
}
} catch (Exception e) {
[Link]();
}
return dataRows;
}

/*@SuppressWarnings("rawtypes")
public void printSingleSheetData(ArrayList sheetData) {
[Link](" ** ----------------");
ArrayList li2;
for (int i = 0; i < [Link](); i++) {
[Link](" Row " + i + " ----------------");
li2 = (ArrayList) [Link](i);
for (int p = 0; p < [Link](); p++) {
[Link](p + " - " + [Link](p) + " ::: ");
}
[Link](" ");
}
}*/
}
otonam service:
package [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

import [Link];
import [Link];
import [Link];

import [Link];
import [Link];

import [Link];

public class OtonomService {

Logger logger = [Link]([Link]);

SelenideService selenideService;
private HashMap<String, String> taskMap;
private String labelScope;
private String brandingScope;

@SuppressWarnings("rawtypes")
private HashMap inputConfigMap;
@SuppressWarnings("rawtypes")
private HashMap resultMap;

public ArrayList<ArrayList<String>> dynamicValuesList;

public ArrayList<ArrayList<String>> storyResultList = new
ArrayList<ArrayList<String>>();
public ArrayList<ArrayList<String>> sketchResultList = new
ArrayList<ArrayList<String>>();
public ArrayList<ArrayList<String>> routineResultList = new
ArrayList<ArrayList<String>>();

@SuppressWarnings({ "rawtypes", "unchecked" })

public OtonomService(HashMap configMap, String filePath, String browser) {
ArrayList brandingList = (ArrayList) [Link]("Branding");
ArrayList httpList = (ArrayList) [Link]("Http");
ArrayList databaseList = (ArrayList) [Link]("Database");

[Link] = configMap;
[Link] = new HashMap();
[Link] = new SelenideService(brandingList, httpList,
databaseList, filePath, browser);

ArrayList headerRow = new ArrayList();

ArrayList innerResultList;
dynamicValuesList = (ArrayList) [Link]("Dynamic");

ArrayList scopeList = (ArrayList) [Link]("Scope");

 innerResultList = (ArrayList) [Link](1); // Row-2 of Excel

ArrayList storyList = (ArrayList) [Link]("Story");

headerRow = (ArrayList) [Link](0);
[Link]("Result_Functionality");
[Link](headerRow); // Story Header Row

ArrayList sketchList = (ArrayList) [Link]("Sketch");

headerRow = (ArrayList) [Link](0);
[Link]("Result_Functionality");
[Link](headerRow); // Sketch Header Row

ArrayList routineList = (ArrayList) [Link]("Routine");

headerRow = (ArrayList) [Link](0);
[Link]("Result_Task");
[Link]("Result_Expected");
[Link]("Result_Actual");
[Link]("Sketch");
[Link]("Routine");
[Link]("Flavour");
[Link]("Audit_Timestamp");
[Link](headerRow); // Routine Header Row

if ("Labels".equals([Link](0))) {
[Link] = (String) [Link](1);
} else {
[Link] = "Y";
}

innerResultList = (ArrayList) [Link](2); // Row-3 of Excel

if ("Branding".equals([Link](0))) {
[Link] = (String) [Link](1);
} else {
[Link] = "Y";
}
}

@SuppressWarnings({ "unchecked", "rawtypes" })

public HashMap executeStories() throws FileNotFoundException,
DocumentException {

String sketchResult;
ArrayList storyWorkList = new ArrayList();
ArrayList storyData = (ArrayList) [Link]("Story");
ArrayList localStoryResultList = null;

for (int i = 0; i < [Link](); i++) {

storyWorkList = (ArrayList) [Link](i);
localStoryResultList = (ArrayList) [Link]();

if ("Y".equalsIgnoreCase(((String) [Link](2)).trim())
|| "YES".equalsIgnoreCase(((String)
[Link](2)).trim())) {

sketchResult = executeSketch(((String)
[Link](1)).trim()); // sketch
if (!"Pass".equalsIgnoreCase(sketchResult))
[Link]("Fail");
 [Link](sketchResult);
[Link](localStoryResultList);
}
}
resultMap = inputConfigMap;
[Link]("Story", storyResultList);
[Link]("Sketch", sketchResultList);
[Link]("Routine", routineResultList);
return resultMap;
}

@SuppressWarnings({ "rawtypes", "unchecked" })

private String executeSketch(String sketch) throws FileNotFoundException,
DocumentException {

String routineResult = null;

String sketchAllClear = "Pass";

ArrayList<String> sketchWorkList;
ArrayList sketchData = (ArrayList) [Link]("Sketch");
ArrayList<String> localSketchResultList = null;

[Link](" ");
[Link]("===> Executing Sketch (" + sketch + ")");
[Link]("inside OtonomService");
[Link](" ");
for (int i = 1; i < [Link](); i++) {
sketchWorkList = (ArrayList) [Link](i);
localSketchResultList = (ArrayList) [Link]();

if ([Link](((String) [Link](0)).trim())) {
if ("Y".equalsIgnoreCase(((String)
[Link](3)).trim())
|| "YES".equalsIgnoreCase(((String)
[Link](3)).trim())) {

ItextpdfhealperUtil itextpdf = new

ItextpdfhealperUtil();
[Link]("itextpdf ::::: "+itextpdf);

String Screenshot_path=[Link]("[Link]")
+ "\\reports";
// [Link]([Link](1),
[Link]().getProperty("screenshot_location"));

[Link]([Link](1),Screenshot_path);

// sketch, routine, flavour

try {
routineResult = executeRoutine(sketch, (String)
[Link](1),
(String)
[Link](2),itextpdf);
} catch (Exception e) {
[Link]();
}finally {
[Link]();
}
// routineResult = "Pass";

if (!"Pass".equalsIgnoreCase(routineResult))
sketchAllClear = "Fail";

[Link](routineResult);
[Link](localSketchResultList);
}
}
}

return sketchAllClear; // configMap;

}

@SuppressWarnings({ "rawtypes", "unchecked" })

private String executeRoutine(String sketch, String routine, String flavour,
ItextpdfhealperUtil itextpdf) {
[Link](" => Routine (" + routine + ") & flavour (" +
flavour + ")");
[Link](" ");
[Link]("inside OtonomService");
HashMap taskResultMap = new HashMap();
String taskResult = "Pass";
String routineResult = "Pass";
String flavourValue;
ArrayList routineWorkList;
ArrayList localRoutineResultList = null;
ArrayList routineData = (ArrayList) [Link]("Routine");

for (int i = 1; i < [Link](); i++) {

[Link]();
routineWorkList = (ArrayList) [Link](i);
localRoutineResultList = (ArrayList) [Link]();

if ([Link](((String) [Link](0)).trim())) {

if (((String) [Link](5)).startsWith("##")) {
flavourValue = getFlavourValue(flavour, (String)
[Link](5));
} else {
flavourValue = (String) [Link](5);
}

[Link]("labelScope", labelScope);
[Link]("brandingScope", brandingScope);
[Link]("routine", routine);
[Link]("flavour", flavour);
[Link]("sketch", sketch);
[Link]("task", (String) [Link](1));
[Link]("taskType", (String) [Link](2));
[Link]("xpath", (String) [Link](3));
[Link]("id", (String) [Link](4));
[Link]("value", flavourValue);
[Link]("timeout", (String) [Link](6));
[Link]("externalRef", (String)
[Link](7));
[Link]("externalRef1", (String)
[Link](8));
 [Link]("collectVariables", (String)
[Link](9));

if (!"Ignore".equalsIgnoreCase((String)
[Link](2))) {
taskResultMap =
[Link](taskMap,itextpdf);
taskResult = (String)
[Link]("Result_Task");
} else {
taskResult = "Pass";
[Link]("Result_Expected", " ");
[Link]("Result_Actual", " ");
}

if ("Fail".equalsIgnoreCase(taskResult) ||
"TechFail".equalsIgnoreCase(taskResult)) {
[Link](" Task Result Failed- " +
(String) [Link](1));
[Link]("inside OtonomService");
routineResult = "Fail";
}

[Link](taskResult);

[Link]([Link]("Result_Expected"));

[Link]([Link]("Result_Actual"));
[Link](sketch);
[Link](routine);
[Link](flavour);

[Link]([Link]("Result_Timestamp"));

[Link](localRoutineResultList);

}
} // loop of tasks in a routine
[Link](" ");
return routineResult;

@SuppressWarnings("rawtypes")
private String getFlavourValue(String flavour, String value) {
ArrayList dynamicWorkList;
for (int i = 0; i < [Link](); i++) {
dynamicWorkList = (ArrayList) [Link](i);
if ([Link](((String)
[Link](0)).trim())
|| [Link]("##" + ((String)
[Link](0)).trim())) {
if ([Link](((String)
[Link](1)).trim())) {
// return ((String) [Link](2)).trim();
String val = ((String)
[Link](2)).trim();

SimpleDateFormat formatter = null;

 Date date = new Date();
Random random = new Random();

if ("~~RANDOM_NUM~~".equals(val)) // yymmddhhmissmis
+any

// randum number betw

// 10000 and 99999

{
int min = 10000;
int max = 99999;
formatter = new
SimpleDateFormat("yyyyHHmmssSSS");
val = [Link](date) +
[Link](max + min) + 1; // generate

// date

// with

// randum

// number
[Link]([Link](date));
}

if ("~~TODAY_YYMMDD~~".equals(val)) // generate date

with

// YYMMDD
{
formatter = new SimpleDateFormat("yymmdd");
val = [Link](date);
[Link]([Link](date));
}

if ("~~TODAY_DD-MM-YYYY~~".equals(val)) // generate
date

// with DD-MM-YYYY
{
formatter = new SimpleDateFormat("dd-mm-yyyy");
val = [Link](date);
[Link]([Link](date));
}

if ("~~TODAY_MM/dd/yyyy~~".equals(val)) // generate
date
// with MM/dd/yyyy
{
formatter = new SimpleDateFormat("MM/dd/yyyy");
val = [Link](date);
[Link]([Link](date));
}

if ("~~TODAY_YYYY/MM/DD~~".equals(val)) // generate
date
 // with YYYY/MM/DD
{
formatter = new SimpleDateFormat("yyyy/mm/dd");
val = [Link](date);
[Link]([Link](date));
}

if ("~~TOMORROW_MM/dd/yyyy~~".equals(val)) //
generate

// TOMORROW

// date with

// MM/dd/yyyy
{
Calendar calendar = [Link]();
[Link]([Link], 1);
date = [Link]();
formatter = new SimpleDateFormat("MM/dd/yyyy");
val = [Link](date);
[Link]("Tomorrow : " + val);
}

if ("~~RANDOM_STR~~".equals(val)) // generate date

with

// YYYY/MM/DD
{
// Define the static prefix
String prefix = "AS";

// Generate the date component in the format DDMMYY

SimpleDateFormat dateFormatter = new
SimpleDateFormat("ddMMyy");
String dateComponent = [Link](new
Date());

String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

StringBuilder sb = new StringBuilder();
int length = 2; // for length of string
for (int j = 0; j < length; j++) {
int index =
[Link]([Link]());
char randomChar = [Link](index);
[Link](randomChar);
}
val = prefix + dateComponent+ [Link]();
[Link]("Random String is: " + val);
}

if ("~~RANDOM_AMT~~".equals(val)) // generate Random

amount
{
int min = 1000;
int max = 500000;
val = [Link]([Link](max +
min));
[Link]("Random amt is: " + val);
 }

return val;
}
}
}
return value;
}

@SuppressWarnings("rawtypes")
public void printSingleSheetData(ArrayList sheetData) {
[Link]("----------------");
[Link]("---- Result ----");
[Link]("----------------");
[Link]("inside OtonomService");
ArrayList li2;
for (int i = 0; i < [Link](); i++) {
[Link]("Row " + i + " ----------------");
li2 = (ArrayList) [Link](i);
for (int p = 0; p < [Link](); p++) {
[Link](p + " - " + [Link](p) + " ::: ");
}
[Link](" ");
[Link]("inside OtonomService");
}
}
}

result service:
package [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

import [Link];
import [Link];
import [Link];
import [Link];
@Component
public class ResultService {

@SuppressWarnings("rawtypes")
public void writeResult(HashMap resultMap, String filePath, String fileName)
{
ArrayList dynamicResult = (ArrayList) [Link]("Dynamic");
ArrayList scopeResult = (ArrayList) [Link]("Scope");
ArrayList storyResult = (ArrayList) [Link]("Story");
ArrayList sketchResult = (ArrayList) [Link]("Sketch");
ArrayList routineResult = (ArrayList) [Link]("Routine");
ArrayList brandingResult = (ArrayList) [Link]("Branding");
ArrayList guideResult = (ArrayList) [Link]("Guide");
ArrayList readmeResult = (ArrayList) [Link]("Readme");
String timeStamp = new SimpleDateFormat("yyyy-MM-dd-HH-
mm").format([Link]().getTime());
 File f = new File(filePath + "Result_"+timeStamp+"_"+fileName);

try (FileOutputStream fos = new FileOutputStream(f)) {

Workbook wb = new Workbook(fos, "Application", "1.0");
writeSheet("Dynamic_Values", wb, dynamicResult);
writeSheet("Scope", wb, scopeResult);
writeSheet("Result_Story", wb, storyResult);
writeSheet("Result_Sketch", wb, sketchResult);
writeSheet("Result_Routine", wb, routineResult);
writeSheet("Branding_Specs", wb, brandingResult);
writeSheet("Guide_Task", wb, guideResult);
writeSheet("Readme", wb, readmeResult);
[Link]();
} catch (IOException e) {
[Link]();
}
}

@SuppressWarnings("rawtypes")
private void writeSheet(String sheetName, Workbook wb, ArrayList resultSheet)
{
Worksheet ws = [Link](sheetName);
ArrayList workList = new ArrayList();
int i;
int p = 0;
try {
for (i = 0; i < [Link](); i++) {
workList = (ArrayList) [Link](i);
for (p = 0; p < [Link](); p++) {
[Link](i, p, [Link](p).toString());
if ("Pass".equalsIgnoreCase((String)
[Link](p))) {
[Link](i,
p).borderStyle("thin").fillColor(Color.LIGHT_GREEN).set();
}
if ("Fail".equalsIgnoreCase((String)
[Link](p))) {
[Link](i,
p).borderStyle("thin").fillColor(Color.BABY_PINK).set();
}
if ("TechFail".equalsIgnoreCase((String)
[Link](p))) {
[Link](i,
p).borderStyle("thin").fillColor([Link]).set();
}
if ([Link](p).toString().startsWith("ID") ||
[Link](p).toString().startsWith("Value")
||
[Link](p).toString().startsWith("X")
||
[Link](p).toString().startsWith("Param_")
||
[Link](p).toString().startsWith("Flavour")
||
[Link](p).toString().startsWith("Result_E")
||
[Link](p).toString().startsWith("Result_A")) {
[Link](p, 40);
}
 if (i == 0) {
if
([Link](p).toString().startsWith("Result")
||
[Link](p).toString().startsWith("Pass")
||
[Link](p).toString().startsWith("Fail")
||
[Link](p).toString().startsWith("TechFail")) {
[Link](i,
p).borderStyle("thin").bold().fillColor(Color.NAVY_BLUE).fontColor([Link])
.set();
} else {
[Link](i,
p).borderStyle("thin").bold().fillColor([Link]).set();
}
} else {
[Link](i, p).borderStyle("thin").set();
}
}
}
} catch (Exception e) {
[Link](0, 0, " ");
}
}
}

resubale method:
package [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

import [Link];
import [Link];
import [Link];

import [Link];
import [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

//import [Link];
import [Link];
import [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
//import [Link];

public class ReusableMethods {

public static void getDate() {

SimpleDateFormat datetime = new SimpleDateFormat("YYYYMMdd");
Date date = new Date();
[Link]("YYYYMMDD", [Link](date));
SimpleDateFormat time = new SimpleDateFormat("YYYY-MM-dd");

[Link]("YYYY-MM-DD", [Link](date));
}

public static void PostFCR(String SSID, String testcase_no) throws

IOException {

// String FinalPath = "D:\\Otonom\\[Link]";

String FinalPath = [Link]("FCFolder")+"\\" +
testcase_no + ".json";

[Link](FinalPath);
File file1 = new File(FinalPath);
Scanner sc = null;

try {
sc = new Scanner(file1);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
[Link]();
}
String input;
StringBuffer sb = new StringBuffer();
while ([Link]()) {
input = [Link]();
[Link](input + " ");
}

String json = [Link]();

 getDate();
json = [Link]("VAR_YYYYMMDD",
[Link]("YYYYMMDD"))
.replace("VAR_YYY-MM-DD",
[Link]("YYYY-MM-DD")).replace("VAR_SSID", SSID);
[Link](json);

try {
RequestConfig requestConfig =
[Link]().setConnectTimeout(3000).setSocketTimeout(3000).build();
HttpClient httpClient =
[Link]().setDefaultRequestConfig(requestConfig).build();

HttpPost httppost = new HttpPost(

"[Link]
[Link]/digipaytrxmanager/create");

StringEntity userEntity = new StringEntity(json);

[Link](userEntity);

HttpResponse response = [Link](httppost);

} catch (ClientProtocolException e1) {
// TODO Auto-generated catch block
[Link]();
} catch (IOException e1) {
// TODO Auto-generated catch block
// [Link]();
}

public static void PostRTB(String TCNo,String testcase_no) throws IOException

{

String FinalPath = [Link]("RTBFolder")+"\\" +

testcase_no + ".json";

[Link](FinalPath);
File file1 = new File(FinalPath);
Scanner sc = null;

try {
sc = new Scanner(file1);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
[Link]();
}
String input;
StringBuffer sb = new StringBuffer();
while ([Link]()) {
input = [Link]();
[Link](input + " ");
}

String json = [Link]();

getDate();
json = [Link]("VAR_refno",TCNo);
 [Link](json);
try{

[Link]("_________________");
HttpClient httpClient = [Link]().build();

HttpPost httppost = new HttpPost("[Link]

[Link]/generator/rtbinput");

StringEntity userEntity;

userEntity = new StringEntity(json);

[Link](userEntity);

HttpResponse response = [Link](httppost);

}

catch (ClientProtocolException e1) {

// TODO Auto-generated catch block
[Link]();
} catch (IOException e1) {
// TODO Auto-generated catch block
[Link]();
}

public static void PostEarMark(String TCNo,String testcase_no) throws

IOException {

//String FinalPath = "D:\\Otonom\\[Link]";

String FinalPath = [Link]("EMarkFolder")+"\\" +
testcase_no + ".json";
[Link](FinalPath);
File file1 = new File(FinalPath);
Scanner sc = null;

try {
sc = new Scanner(file1);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
[Link]();
}
String input;
StringBuffer sb = new StringBuffer();
while ([Link]()) {
input = [Link]();
[Link](input + " ");
}

String json = [Link]();

getDate();
json = [Link]("VAR_refno",TCNo);

[Link](json);
try{
 //RequestConfig requestConfig =
[Link]().setConnectTimeout(3000).setSocketTimeout(3000).build();
[Link]("_________________");
HttpClient httpClient = [Link]().build();

HttpPost httppost = new HttpPost("[Link]

[Link]/generator/earmarkinput");

StringEntity userEntity;

userEntity = new StringEntity(json);

[Link](userEntity);

HttpResponse response = [Link](httppost);

}

catch (ClientProtocolException e1) {

// TODO Auto-generated catch block
[Link]();
} catch (IOException e1) {
// TODO Auto-generated catch block
[Link]();
}

public static void DeleteStrct(String testcase_no) throws IOException {

//String FinalPath = "D:\\Otonom\\[Link]";

String FinalPath = [Link]("DeleteFolder")+"\\" +
testcase_no + ".json";
[Link](FinalPath);
File file1 = new File(FinalPath);
Scanner sc = null;

try {
sc = new Scanner(file1);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
[Link]();
}
String input;
StringBuffer sb = new StringBuffer();
while ([Link]()) {
input = [Link]();
[Link](input + " ");
}

String json = [Link]();

getDate();

json = json
.replace("VAR_YYY-MM-DD",
[Link]("YYYY-MM-DD"));
 [Link](json);
try{
//RequestConfig requestConfig =
[Link]().setConnectTimeout(3000).setSocketTimeout(3000).build();
[Link]("_________________");
HttpClient httpClient = [Link]().build();

HttpPost httppost = new HttpPost("[Link]

[Link]/TLMCASController/CASProcess");

StringEntity userEntity;

userEntity = new StringEntity(json);

[Link](userEntity);

HttpResponse response = [Link](httppost);

}

catch (ClientProtocolException e1) {

// TODO Auto-generated catch block
[Link]();
} catch (IOException e1) {
// TODO Auto-generated catch block
[Link]();
}

/*public static void PostEarMark(String TCNo) {

RequestConfig requestConfig =
[Link]().setConnectTimeout(3000).setSocketTimeout(3000).build();
HttpClient httpClient =
[Link]().setDefaultRequestConfig(requestConfig).build();

HttpPost httppost = new HttpPost(

"[Link]
[Link]/digipaytrxmanager/create");

[Link] = "[Link]
[Link]/generator/earmarkinput";
RequestSpecification request = [Link]();

String FinalPath = "D:\\Otonom\\[Link]";

[Link](FinalPath);
 File file1 = new File(FinalPath);
Scanner sc = null;

try {
sc = new Scanner(file1);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
[Link]();
}
String input;
StringBuffer sb = new StringBuffer();
while ([Link]()) {
input = [Link]();
[Link](input + " ");
}

String json = [Link]();

getDate();
json = [Link]("VAR_refno",
[Link]("RefNo"));

[Link](json);

[Link](json);

Response response = [Link]();

ResponseBody body = [Link]();
[Link]([Link]());
[Link]([Link]());
}
*/
}

selenoid service:
package [Link];
import static [Link].*;
import static [Link].*;
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import static [Link];

public class SelenideService {

Logger logger = [Link]([Link]);

static WebElement driver = null;
private static List<String> tags =
[Link]("wcag2a","wcag2aa","wcag2aaa");

BrandingService brandingService;
HttpService httpService;
String labelScope;
String brandingScope;
String sketch;
String routine;
String flavour;
String task;
String taskType;
String xpath;
String id;
String value;
Integer timeout;
String externalRef;
String externalRef1;
String taskResult = "Pass";
String expectedResult = " ";
String actualResult = " ";
String holder;
SelenideService hoverElement;
String collectVariables;
HashMap<String, String> resultMap = new HashMap<String, String>();
HashMap<String, String> brandingSpecs;
HashMap<String, String> collectVariablesMap = new HashMap<String, String>();
String filePath;
SelenideConfig con;
 SelenideDriver sd;
[Link] dri; //

@SuppressWarnings({ "rawtypes", "unchecked", "static-access" })

public SelenideService(ArrayList brandingList, ArrayList httpList, ArrayList
databaseList, String filePath,
String browser) {
[Link] = new BrandingService(brandingList);
[Link] = new HttpService(httpList);
[Link] = filePath;

SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");

Date date = new Date();

[Link]("[Link]", "false");

Configuration config = new Configuration();

[Link] = 20000;
[Link] = filePath + "\\reports\\" +
[Link](date);
//[Link] = browser;
[Link] = "firefox"; // Set to Firefox

if ("ie".equalsIgnoreCase(browser))
[Link] = "none";
con = new SelenideConfig();
sd = new SelenideDriver(con);
dri = [Link]();

[Link](dri);

public HashMap<String, String> executeTask(HashMap<String, String> taskMap,

ItextpdfhealperUtil itextpdf) {
labelScope = [Link]("labelScope").trim();
brandingScope = [Link]("brandingScope").trim();
sketch = [Link]("sketch").trim();
routine = [Link]("routine").trim();
flavour = [Link]("flavour").trim();
task = [Link]("task").trim();
taskType = [Link]("taskType").trim();
xpath = [Link]("xpath").trim();
id = [Link]("id").trim();
value = [Link]("value").trim();
externalRef = [Link]("externalRef").trim();
externalRef1 = [Link]("externalRef1").trim();
collectVariables = [Link]("collectVariables").trim();
if (collectVariables == null) {
collectVariables = "defult";
}

expectedResult = "";
actualResult = "";

int rowAffected = 0;
try {
timeout = [Link]([Link]("timeout").trim());
 } catch (Exception e) {
timeout = 20;
}
if ([Link](timeout).orElse(0) < 5) {
timeout = 20;
}

[Link](" Executing routine - " + [Link]("%-40s",

routine) + " : Task - "
+ [Link]("%-40s", task) + " flavour " + flavour);
if ([Link]("$$")) {
[Link]("About to replace $.......");
for (String name : [Link]()) {
String key = [Link]();
String value = [Link](name).toString();
[Link](key + "--" + value);
}

[Link]("Before replace ---->>>>>>" + value);

// value = [Link]([Link]("$$", ""));
for (String name : [Link]()) {
if ([Link]().length() >= 1) {
value = [Link]("$$" + [Link](),
[Link](name));
}
}
[Link]("After replace ---->>>>>>>" + value);

try {
switch ([Link]()) {

case "http_fcr":
[Link]("-----------------------Start
post1------------");
String val1[] = [Link]("\\|");
[Link](value);
[Link](val1[0], val1[1]);
[Link](collectVariables, value);
break;

case "http_rtb":
[Link]("-----------------------Start
post2------------");

[Link](value);
String val2[] = [Link]("\\|");
[Link](val2[0], val2[1]);

[Link](collectVariables, value);
break;

case "http_ecr":
[Link]("-----------------------Start
post3------------");

[Link](value);
String val3[] = [Link]("\\|");
 [Link](val3[0], val3[1]);
[Link](collectVariables, value);
break;

case "delete_structure":
[Link]("-----------------------Start
post4------------");

[Link](value);
[Link](value);
[Link](collectVariables, value);
break;

case "open":
open(value);
taskResult = "Pass";
break;

case "tab":
int go;
try {
go = [Link](value);
} catch (Exception e) {
go = 100;
}
for (int i = 0; i < go; i++) {
actions().sendKeys([Link]).build().perform();
if (getFocusedElement().getText().trim().length() ==
0) {
actualResult = actualResult + ", " + i;
}
}
break;

case "press_tab":
actions().sendKeys([Link]).build().perform();
break;

case "enter":
actions().sendKeys([Link]).build().perform();
break;

case "disable":
try {
$([Link](value)).shouldBe(enabled);
[Link]("disabled");
taskResult = "Fail";
} catch (Exception e) {
[Link]("Enabled");
taskResult = "Pass";
}

break;

case "enable":
try {
$([Link](value)).shouldBe(disabled);
[Link]("enabled");
 taskResult = "Fail";
} catch (Exception e) {
[Link]("disabled");
taskResult = "Pass";
}

break;

case "visible":
try {
$([Link](value)).shouldBe(visible);
[Link]("visible");
taskResult = "Pass";
} catch (Exception e) {
[Link]("not visible");
taskResult = "Pass";
}

break;

case "http_api_call":
int httpResponse = [Link](value);
expectedResult = "Http Response 2XX";
actualResult = "Http Response " + httpResponse;

if (httpResponse >= 200 && httpResponse < 300) {

taskResult = "Pass";
} else {
taskResult = "Fail";
}
break;

case "keydown":

int go1;
try {
go1 = [Link](value);
} catch (Exception e) {
go1 = 100;
}
for (int i = 0; i < go1; i++) {
actions().sendKeys([Link]).build().perform();
if (getFocusedElement().getText().trim().length() ==
0) {
actualResult = actualResult + ", " + i;

}
}

break;

case "keydown_one_time":
actions().sendKeys([Link]).build().perform();
break;

case "click":
if (id != null && ![Link]().isEmpty()) {
$$(id).first().shouldHave(enabled,
[Link](timeout));
 $$(id).first().click();
} else {
$$x(xpath).first().shouldHave(enabled,
[Link](timeout));
$$x(xpath).first().click();
}
taskResult = "Pass";
break;

case"set_reference_currency":

String[] currency = {"AUD","CAD","THB"};

if([Link]("AUD")) {

[Link](currency[1]);
}
else if([Link]("CAD")) {
[Link](currency[2]);
}else{
[Link](currency[0]);
}

case "doubleclick":
if (id != null && ![Link]().isEmpty()) {
$$(id).first().shouldHave(enabled,
[Link](timeout));
$$(id).first().doubleClick();
} else {
$$x(xpath).first().shouldHave(enabled,
[Link](timeout));
$$x(xpath).first().doubleClick();
}
taskResult = "Pass";
break;

// case "close":
//
// [Link]();
// taskResult = "Pass";
// break;

case "close":
[Link]("Attempting to close the current
window...");
try {
[Link]();
[Link]("Window closed successfully.");
taskResult = "Pass";
} catch (Exception e) {
[Link]("Failed to close the window: " +
[Link]());
taskResult = "Fail";
}
 break;

case "clear_field":
if (id != null && ![Link]().isEmpty()) {
$$(id).first().shouldHave(enabled,
[Link](timeout));
$$(id).first().clear();
} else {
$$x(xpath).first().shouldHave(enabled,
[Link](timeout));
$$x(xpath).first().clear();
}
taskResult = "Pass";
break;

case "update_query":
rowAffected = updateQuery(value);
String s = [Link](rowAffected);
[Link](collectVariables, s);
taskResult = "Pass";
break;

case "select_query":
taskResult = selectQuery(value);
[Link](collectVariables, taskResult);
taskResult = "Pass";
break;

case "delete_query":
rowAffected = deleteQuery(value);
String r = [Link](rowAffected);
[Link](collectVariables, r);
taskResult = "Pass";
break;

case "sleep":
sleep(1000 * [Link](value));
taskResult = "Pass";
break;

case "back_space":
actions().sendKeys(Keys.BACK_SPACE).build().perform();
taskResult = "Pass";
break;

case "set_value":
if (id != null && ![Link]().isEmpty()) {
$$(id).first().shouldHave(enabled,
[Link](timeout));
$$(id).first().click();
} else {
$$x(xpath).first().shouldHave(enabled,
[Link](timeout));
$$x(xpath).first().click();
}
actions().sendKeys(value).build().perform();
[Link](collectVariables, value);
taskResult = "Pass";
 break;

case "check_value":
case "check_value_exact":
case "check_value_ignore":
holder = extractText();
expectedResult = value;
actualResult = holder;
[Link](collectVariables, actualResult);
[Link]("collectVariablesMap");
for (String name : [Link]()) {
String key = [Link]();
String value =
[Link](name).toString();
[Link](key + "--" + value);

if ([Link](holder))
taskResult = "Pass";
else
taskResult = "Fail";

if ([Link]("check_value_ignore"))
taskResult = "Pass";
break;

case "check_value_disabled":

String text2 = (String) ((JavascriptExecutor)

driver).executeScript("return arguments[0].value;",
[Link]([Link](
"/html/body/app-root/clr-main-
container/div[2]/main/process-queue-complete/div/transaction-details/div/div/form/
clr-tabs/section/div/table/tr[1]/td[4]/input")));

[Link]("getText----------" + text2);

holder = text2;
expectedResult = value;
actualResult = holder;
[Link](collectVariables, actualResult);
[Link]("collectVariablesMap");
for (String name : [Link]()) {
String key = [Link]();
String value =
[Link](name).toString();
[Link](key + "--" + value);

if ([Link](holder))
taskResult = "Pass";
else
taskResult = "Fail";

break;

case "placeholder":
 expectedResult = value;
if (id != null && ![Link]().isEmpty()) {
$(id).shouldHave([Link]("placeholder",
value));
actualResult = $(id).getAttribute("placeholder");

} else {

$x(xpath).shouldHave([Link]("placeholder", value));
actualResult = $x(xpath).getAttribute("placeholder");
}

if ([Link](actualResult))
taskResult = "Pass";
else
taskResult = "Fail";
break;

case "check_value_begins_with":
holder = extractText();
expectedResult = value;
actualResult = holder;

if ([Link](value))
taskResult = "Pass";
else
taskResult = "Fail";
break;

case "check_value_ends_with":
holder = extractText();
expectedResult = value;
actualResult = holder;

if ([Link](value))
taskResult = "Pass";
else
taskResult = "Fail";
break;

case "check_value_contains":
holder = extractText();
expectedResult = value;
actualResult = holder;

if ([Link](value))
taskResult = "Pass";
else
taskResult = "Fail";
break;

case "refresh_screen":
// Refresh the screen or reload the page
if (id != null && ![Link]().isEmpty()) {
((SelenideDriver) $$
(id).first()).getWebDriver().navigate().refresh();
} else {
((SelenideDriver) $$
(xpath).first()).getWebDriver().navigate().refresh();
 }

// Optionally, you might want to wait for the refresh to

complete
[Link](2000); // sleep for 2 seconds, adjust as needed

// Log or set result

actualResult = "Screen refreshed";
taskResult = "Pass";
break;

case "check_branding_self":
case "check_branding_ignore":
if (id != null && ![Link]().isEmpty()) {
$$(id).first().shouldHave(exist,
[Link](timeout));
} else {
$$x(xpath).first().shouldHave(exist,
[Link](timeout));
}
brandingSpecs =
[Link](value, [Link]());
boolean brandingcheck = true;

for ([Link]<String, String> entry :

[Link]()) {
expectedResult = expectedResult +
[Link]("[Link]") + [Link]() + ":"
+ [Link]();

if (id != null && ![Link]().isEmpty()) {

actualResult = actualResult +
[Link]() + [Link]() + ":"
+ $$
(id).first().getCssValue([Link]());

if ("font-
family".equalsIgnoreCase([Link]())) {
if (!$$
(id).first().getCssValue([Link]()).contains([Link]())) {
brandingcheck = false;
}
} else {
if (![Link]().equals($$
(id).first().getCssValue([Link]()))
&& !($$
(id).first().getCssValue([Link]())).contains("auto")
&& !
[Link]().contains("auto")) {
brandingcheck = false;
}
}
} else {
actualResult = actualResult +
[Link]() + [Link]() + ":"
+ $
$x(xpath).first().getCssValue([Link]());

if ("font-
family".equalsIgnoreCase([Link]())) {
if (!$
$x(xpath).first().getCssValue([Link]()).contains([Link]())) {
brandingcheck = false;
}
} else {
try {
if (![Link]().equals($
$x(xpath).first().getCssValue([Link]()))
&& !($
$x(xpath).first().getCssValue([Link]())).contains("auto")
&& !
[Link]().contains("auto")) {
brandingcheck = false;
}
} catch (Exception e) {
}
}
}
}

if (brandingcheck)
taskResult = "Pass";
else
taskResult = "Fail";
if ([Link]("check_branding_ignore"))
taskResult = "Pass";

break;

case "screenshot":
String screenshot2 = screenshot(sketch + "___" + routine + "___" +
flavour + "___" + task);
[Link]("DDDDDDDD>>>>>>"+screenshot2);
//task
//[Link](task);0000

[Link](getScreenShotNameDetails(task), 2);
[Link](getScreenShotTimeStamp(), 2);
[Link]([Link](6));
[Link]();
actualResult = sketch + "___" + routine + "___" + flavour + "___" +
task;
taskResult = "Pass";
break;

case "check_branding_hover":
if (id != null && ![Link]().isEmpty()) {
$$(id).first().shouldHave(exist,
[Link](timeout)).hover();
} else {
$$x(xpath).first().shouldHave(exist,
[Link](timeout)).hover();
}
brandingSpecs =
[Link](value, [Link]());
for ([Link]<String, String> entry :
[Link]()) {
expectedResult = expectedResult +
[Link]("[Link]") + [Link]() + ":"
+ [Link]();

if (id != null && ![Link]().isEmpty()) {

actualResult = actualResult +
[Link]() + [Link]() + ":"
+ $$
(id).first().getCssValue([Link]());

} else {
actualResult = actualResult +
[Link]() + [Link]() + ":"
+ $
$x(xpath).first().getCssValue([Link]());
}
}

if ([Link](actualResult))
taskResult = "Pass";
else
taskResult = "Fail";
break;

case "check_branding_active":

if (id != null && ![Link]().isEmpty()) {

$$(id).first().shouldHave(exist,
[Link](timeout));
/*
* SelenideElement element = $(".foo");
[Link]()
* .moveToElement(element) .clickAndHold()

* .pause([Link](5)) .release() .perform();

*/
SelenideElement element = (SelenideElement) $
$x("id");
[Link]("before clickAndhold%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%");

WebDriver driver = new ChromeDriver();

Actions builder = new Actions(driver);
Action active =
[Link](element).clickAndHold().build();

[Link]($
(element).getCssValue("background-color"));

[Link]("after clickAndhold%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%");

} else {
$$x(xpath).first().shouldHave(exist,
[Link](timeout));
}

[Link]("1##############################################################
#####");
 brandingSpecs =
[Link](value, [Link]());
[Link]("brandingSpecs :" + brandingSpecs);
for ([Link]<String, String> entry :
[Link]()) {

[Link]("2##############################################################
#####");
expectedResult = expectedResult +
[Link]("[Link]") + [Link]() + ":"
+ [Link]();

if (id != null && ![Link]().isEmpty()) {

actualResult = actualResult +
[Link]() + [Link]() + ":"
+ $$
(id).first().getCssValue([Link]());

} else {
actualResult = actualResult +
[Link]() + [Link]() + ":"
+ $
$x(xpath).first().getCssValue([Link]());
}
}

[Link]("expectedResult :" + expectedResult);

[Link]("actualResult :" + actualResult);

if ([Link](actualResult))
taskResult = "Pass";
else
taskResult = "Fail";
break;

case "check_value_hover": // new

if (id != null && ![Link]().isEmpty()) {
$$(id).first().shouldHave(exist,
[Link](timeout)).hover();
} else {
$$x(xpath).first().shouldHave(exist,
[Link](timeout)).hover();
}

holder = extractText();
expectedResult = value;
actualResult = holder;
[Link](collectVariables, actualResult);
[Link]("collectVariablesMap");
for (String name : [Link]()) {
String key = [Link]();
String value =
[Link](name).toString();
[Link](key + "--" + value);

}
if ([Link](actualResult))
 taskResult = "Pass";
else
taskResult = "Fail";
break;

case "scroll_up":
actions().sendKeys(Keys.PAGE_UP).build().perform();
break;

case "scroll_down":
actions().sendKeys(Keys.PAGE_DOWN).build().perform();

break;

case "target_new_tab":
int tab_val = [Link](value);
switchTo().window(tab_val);
break;
case "check_a11y":
AxeBuilder builder = new AxeBuilder();
[Link](tags);
//Results results = [Link]((WebDriver) driver);
Results results = [Link](dri);
[Link]("results a11y");
List<Rule> violations = [Link]();
[Link]("[Link]() -
"+[Link]());
if ([Link]() == 0) {
actualResult = "No violations found";
taskResult = "Pass";
} else {

//[Link]("no-passes", dri,
violations);
//actualResult = [Link]();
Iterator<Rule> iterator = [Link]();
Rule rule;
String findings = " ";
/*
JSONArray ja = new JSONArray();
JSONObject jo = new JSONObject();
List nodes;
while ([Link]()) {
rule = [Link]();
[Link]();
[Link]("impact", [Link]());
[Link]("tags", [Link]().toString());
[Link]("description", [Link]());
[Link]("node-count", [Link]().size());
[Link]("node-sample",
[Link]().get(0).getFailureSummary()
+ " ~ " +
[Link]().get(0).getHtml());
[Link]("finding --" +
[Link]());
//findings = findings + "~" + [Link]();
[Link](jo);
}
*/
 JsonArray ja = new JsonArray();
JsonObject jo;
List nodes;
while ([Link]()) {
rule = [Link]();
jo = new JsonObject();

[Link]("impact", [Link]());
[Link]("node-count",
[Link]().size());
[Link]("tags",
[Link]().toString());
[Link]("description",
[Link]());
[Link]("node-sample",
[Link]().get(0).getFailureSummary()
+ " ~ " +
[Link]().get(0).getHtml());
[Link](jo);
}

Gson gson = new

GsonBuilder().setPrettyPrinting().create();
JsonElement je =
[Link]([Link]());
actualResult = [Link](je);
taskResult = "Fail";
}
[Link]("a11y findings - ");
[Link](actualResult);

break;
default:
[Link]("Incorrect Task_Type is configured.
Please refer Guide_Task sheet.");
[Link]("inside selenideservice");
break;
}

} catch (Exception ex) {

[Link](" " + [Link]());
taskResult = "TechFail";
} catch (Throwable th) {
[Link](" " + [Link]());
taskResult = "TechFail";
}
Date date = new Date();

[Link]("Result_Task", taskResult);
[Link]("Result_Expected", expectedResult);
[Link]("Result_Actual", actualResult);
[Link]("Result_Timestamp", "" + new Timestamp([Link]()));
return resultMap;
}

private String extractText() {

if (id != null && ![Link]().isEmpty()) {
$$(id).first().shouldHave(exist, [Link](15));
 return $$(id).get(0).getText().trim();
} else {
$$x(xpath).first().shouldHave(exist, [Link](15));
return $$x(xpath).get(0).getText().trim();
}
}

public static int updateQuery(String query) throws Exception {

[Link]("[Link]");
int rowsAffected = 0;
Connection connection = null;
try {
connection =
[Link]([Link]().getProperty("POSTGRES_URL
"),

[Link]().getProperty("POSTGRES_dBUsername"),

[Link]().getProperty("POSTGRES_dBUserPass"));
String schemaName =
[Link]().getProperty("STUB_SCHEMA_NAME");
[Link](schemaName);

Statement statement = [Link]();

[Link]("Updating records!!");

[Link](query);

rowsAffected = [Link](query);
return rowsAffected;
} catch (SQLException ex) {
[Link]([Link]());
return 0;
} finally {
[Link]();
}

public static String selectQuery(String query) throws Exception {

[Link]("[Link]");
boolean rowsAffected;
String value = " ";
Connection connection = null;
ResultSet rslt = null;
try {
connection =
[Link]([Link]().getProperty("POSTGRES_URL
"),

[Link]().getProperty("POSTGRES_dBUsername"),

[Link]().getProperty("POSTGRES_dBUserPass"));
String schemaName =
[Link]().getProperty("STUB_SCHEMA_NAME");
[Link](schemaName);

Statement statement = [Link]();

// [Link]("Updating records!!");
 [Link](query);

rowsAffected = [Link](query);

if (rowsAffected) {

rslt = [Link]();
if ([Link]()) {
value = [Link](1);

}
}
return value;
} catch (SQLException ex) {
[Link]([Link]());

} finally {
[Link]();
}
return value;

public List<List<String>> getScreenShotNameDetails(String ssName) {

List<List<String>> row1 = new ArrayList<List<String>>();

List<String> row1Details = new ArrayList<String>();

[Link](" �ScreenShot Details");
[Link](" �" + ssName);
[Link](row1Details);

return row1;

public List<List<String>> getScreenShotTimeStamp() {

LocalDateTime ldateTime = [Link]();

List<List<String>> row2 = new ArrayList<List<String>>();

List<String> row2Details = new ArrayList<String>();

[Link](" �DateTime");
[Link](" " + [Link]().substring(0,
19).replace("T", " "));
[Link](row2Details);

// writePDF(row1, 2);
return row2;

public static int deleteQuery(String query) throws Exception {

[Link]("[Link]");
int rowsAffected = 0;
Connection connection = null;
try {
connection =
[Link]([Link]("POSTGRES_URL"),
[Link]("POSTGRES_dBUsername"),
[Link]("POSTGRES_dBUserPass"));
String schemaName =
[Link]("STUB_SCHEMA_NAME");
[Link](schemaName);

Statement statement = [Link]();

[Link]("Deleting records!!");

[Link](query);

rowsAffected = [Link](query);
return rowsAffected;
} catch (SQLException ex) {
[Link]([Link]());
return 0;
} finally {
[Link]();
}

}
}

helper utility:
package [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

import [Link];
import [Link];
import [Link];
//import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link].*;

@Service
public class ItextpdfhealperUtil {

static Logger logger = [Link]([Link]);

static Document gPDFDocument = null;
static String gPDFDocumentName = null;
//static PdfWriter lPdfWriter = null;

// @Autowired
// PostgresDBUtils postgresDBUtils;

// @Value("${OUTPUT_FILE_NAME_PREFIX}")
// String OUTPUT_FILE_NAME_PREFIX;
//
// @Value("${OUTPUT_FILE_EXTENSION}")
// String OUTPUT_FILE_EXTENSION;

/* @Value("${POSTGRES_REMREP_SCHEMA_PROP}")
String POSTGRES_REMREP_SCHEMA_PROP;

@Value("${POSTGRES_ISO_SCHEMA_PROP}")
String POSTGRES_ISO_SCHEMA_PROP;

@Value("${DB_CONNECTION_DATABASE}")
String DB_CONNECTION_DATABASE;

@Value("${DB_CONNECTION_SCHEMA}")
String DB_CONNECTION_SCHEMA;*/

// @Value("${OUTPUT_FILE_PATH}")
// String OUTPUT_FILE_PATH;

public void initializePDF(String pTestCaseName, String path) throws

FileNotFoundException, DocumentException {

[Link]("initializePDF called");
if (gPDFDocument == null || ) {
gPDFDocument = new Document([Link]());
//[Link](20, -40, 30, 30);
[Link](-60, -60, 30, 30);
//[Link](marginLeft, marginRight, marginTop,
marginBottom)
gPDFDocumentName = pTestCaseName;
}
LocalDateTime curDateTime = [Link]();
/*PdfWriter lPdfWriter = [Link](gPDFDocument,
new
FileOutputStream(OUTPUT_FILE_PATH+OUTPUT_FILE_NAME_PREFIX + pTestCaseName + "_"
+[Link]().substring(0, 19).replace("T", "").replace(":",
"").replace("-", "") + OUTPUT_FILE_EXTENSION ));
*/
[Link]("Creating PDF a path {}"+ path);
PdfWriter lPdfWriter = [Link](gPDFDocument,
new FileOutputStream(path+"//"+ pTestCaseName + "_"
+[Link]().substring(0, 19).replace("T", "").replace(":",
"").replace("-", "") + ".pdf" ));
[Link]();

// [Link](new Paragraph("lScriptOutput"+lScriptOutput));
}

public void printQueryResulltInPDFTable(ResultSet lRs, String pQuery, String

valueToReplace, String columnToReplace, String step)
throws SQLException, DocumentException {

[Link]("column toreplace :::"+valueToReplace);

if(valueToReplace!=null)pQuery = [Link](columnToReplace,
valueToReplace); // lDetails
// pQuery = [Link](pQuery);

LocalDateTime ldateTime = [Link]();

// [Link]("----- PDF Printing pQuery -------------------{}",

pQuery);

List<String> qList = new ArrayList<String>();

List<String> stepList = new ArrayList<String>();
List<String> executionDetails = new ArrayList<String>();
[Link]("STEP : " + [Link]() + " | Execution Date
Time : "
+ [Link]().substring(0, 19).replace("T", " "));
[Link](pQuery);
List<List<String>> printQList = new ArrayList<List<String>>();
List<List<String>> stepDetails = new ArrayList<List<String>>();
List<List<String>> printDetails = new ArrayList<List<String>>();
//[Link]("DB TABLE DATA");
//[Link](executionDetails);
[Link](stepList);
[Link](qList);
writePDF(stepDetails, 1);
writePDF(printQList, 1);
if(lRs!=null) {
// [Link](executionDetails);

writePDF(printDetails, 1);
int lRowCounter = 0;
ResultSetMetaData lRsMetaData = [Link]();
int lColumnCount = [Link]();
List<List<String>> lFinalResult = new ArrayList<List<String>>();

List<String> lTempRecord = new ArrayList<String>();

while (lColumnCount > 0) {

[Link]([Link](lColumnCount));
 // [Link]("-----header------{}",
[Link](lColumnCount));
lColumnCount--;
}
[Link](lTempRecord);

if (true) {

while ([Link]()) {
lRowCounter++;
lTempRecord = new ArrayList<String>();
lColumnCount = [Link]();
while (lColumnCount > 0) {
[Link]([Link](lColumnCount--));
}
[Link](lTempRecord);
// lColumnCount = [Link]();
}

// [Link]("-----lFinalResult------{}", lFinalResult);
if (lRowCounter > 0) {
writePDF(lFinalResult, [Link]());
} else {
List<List<String>> lNoResult = new
ArrayList<List<String>>();
List<String> lNoRecord = new ArrayList<String>();
[Link]("No Result Found..!!");
[Link](lNoRecord);
// writePDF("", [Link], true);
writePDF(lNoResult, 1);
}

}
else {

}
/*
* if (lRs != null) [Link]();
*/

public void printPDFHeader(String testCaseId,String externalRefNo) throws

DocumentException {

[Link]("Inside header print ----");

LocalDateTime ldateTime = [Link]();

List<List<String>> row1 = new ArrayList<List<String>>();

List<List<String>> row2 = new ArrayList<List<String>>();
List<List<String>> row3 = new ArrayList<List<String>>();
List<List<String>> row4 = new ArrayList<List<String>>();
List<List<String>> row5 = new ArrayList<List<String>>();
 /*List<String> row1Details = new ArrayList<String>();
[Link]([Link]);
[Link](" " + DB_CONNECTION_DATABASE);
[Link](row1Details);

List<String> row2Details = new ArrayList<String>();

[Link]([Link]);
[Link](" " + DB_CONNECTION_SCHEMA);
[Link](row2Details);*/

List<String> row3Details = new ArrayList<String>();

// [Link]([Link]);
[Link](" " + [Link]().substring(0,
19).replace("T", " "));
[Link](row3Details);

List<String> row4Details = new ArrayList<String>();

// [Link]([Link]);
[Link](" " + testCaseId);
[Link](row4Details);

//Chunk linebreak = new Chunk(new LineSeparator());

//[Link](linebreak);
//Chunk linebreak = new Chunk();

//[Link](row2Details);
[Link](row3Details);
[Link](row4Details);
writePDF(row1, 2);

//[Link](linebreak);
/*writePDF(row2, 2);
[Link](linebreak);

writePDF(row3, 2);
[Link](linebreak);

writePDF(row4, 2);
[Link](linebreak);

[Link](linebreak);*/

public static void writePDF(List<List<String>> pDBResults, int

pColumnCounter) throws DocumentException {
//Chunk linebreak = new Chunk(new DottedLineSeparator());
Chunk linebreak = new Chunk();
[Link](linebreak);
PdfPTable table = new PdfPTable(pColumnCounter);
float[] lColumnWidths = new float[pColumnCounter];// {10f, 20f, 30f,
10f};

for (int i = 0; i < pColumnCounter; i++) {

lColumnWidths[i] = 50f;
}

[Link](lRecord -> [Link](lCellItem -> {

 Phrase lPhrase = new Phrase(lCellItem);
PdfPCell lCell = new PdfPCell(lPhrase);
[Link](7);
[Link](lCell);
}));

[Link](40f * pColumnCounter);
[Link](lColumnWidths);

[Link](table);
}

public static void closePDF() {

//[Link]("Called closePDF :: {}", [Link]());
if (gPDFDocument != null) {
[Link]("Called closePDF not null:: {}");

[Link]();
//[Link]();

public static void writePDF(String pResults, BaseColor lColor, boolean

pSkipLineBreak) throws DocumentException {
if (!pSkipLineBreak) {
Chunk linebreak = new Chunk(new LineSeparator());
[Link](linebreak);
}
Font myFonColor = [Link](FontFactory.TIMES_ROMAN, 12,
lColor);// [Link]
Paragraph lPara = new Paragraph(pResults, myFonColor);
[Link](lPara);

public static void writePDF(String pResults) throws DocumentException {

writePDF(pResults, [Link], false);
}

public static void writePDFLine(String pResults) throws DocumentException {

writePDF(pResults, [Link], false);
}

public static void writePDFNewPage() throws DocumentException {

[Link]();
}

public static void insertImageInPDF(String screenshot2) throws

MalformedURLException, IOException, DocumentException {
// Creating an ImageData object
// String imageFile = "C:/itextExamples/[Link]";
// ImageData data = [Link](imageFile);

// Creating an Image object

Image image1 = [Link](screenshot2);
 // [Link]("MERA INSERT PDF CALL");

[Link](Element.ALIGN_CENTER);
[Link]([Link]);
[Link](500, 375);

[Link](image1);

propertyutils:
package Utilities;

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

public class PropertyUtils {

private static final Properties properties;

public static Properties getProperties() {

return properties;
}

static {
properties = new Properties();

try {
ClassLoader classLoader = [Link]();
InputStream applicationPropertiesStream =
[Link]("[Link]");
[Link](applicationPropertiesStream);
} catch (Exception e) {
[Link]();
}

// public static String readProperty(String propertyname) throws IOException

// {
// FileReader fileread;
// String propertyvalue="default";
// String filepath="";
//
// //filepath = "D:\\MYDATA\\ISO_AUTOMATION\\Otonom\\Config\\
[Link]";
// filepath = "src\\main\\resources\\[Link]";
// try {
// fileread = new FileReader(filepath);
//
// Properties prop = new Properties();
// [Link](fileread);
// propertyvalue = [Link](propertyname);
// }
// catch(FileNotFoundException e)
// {
// [Link]("Exception caught: "+[Link]());
// }
//
// return propertyvalue;
//
// }

public static String readProperty(String propertyname) throws IOException {

FileReader fileread;
String propertyvalue = "default";
String filepath = "";

filepath = "D:\\Otonom\\Config\\[Link]";
try {
fileread = new FileReader(filepath);

Properties prop = new Properties();

[Link](fileread);
propertyvalue = [Link](propertyname);
} catch (FileNotFoundException e) {
[Link]("Exception caught: " + [Link]());
}

return propertyvalue;

run time property:

package Utilities;

import [Link];
import [Link];

public class RunTimeProperties {

private static Map<String, String> propertyMap;

static {
propertyMap = new HashMap<String, String>();
}

public static void setProperty(String key,String value){

[Link](key, value);
}

public static String getProperty(String key){

return [Link](key);
}

[Link]
#-----------------------------------------------------------------------
PostgresCofig------------------------
#----------------------Integration-------------

STUB_SCHEMA_NAME=iso_dev1
POSTGRES_URL=jdbc:postgresql://[Link]:5432/cibciso
POSTGRES_dBUsername=cibciso
POSTGRES_dBUserPass=ISOdit@2022

#chrome_driver_path=D:\\MYDATAA\\Softwares\\chromedriver\\[Link]
#otonom_home=D:\\MYDATAA\\ISO_AUTOMATION\\Otonom\\
#config_file_name=[Link]
config_file_name=Otonom_sanity_sheet.xlsx

browser=chrome
browser=firefox

#screenshot_location=D:\\MYDATAA\\ISO_AUTOMATION\\Otonom\\reports

[Link]

##chrome_driver_path=D:\\project_workspace\\ISO_automation_3_sept\\
chromedriver_win32\\[Link]
##otonom_home=D:\\Otonom\\
##config_file_name=Otonom_sanity_sheet.xlsx
##browser=chrome
#
##-----------------------------------------------------------------------
PostgresCofig------------------------
##----------------------Integration-------------
##STUB_SCHEMA_NAME=digipay
##POSTGRES_URL=jdbc:postgresql://[Link]:5432/igtb_k1_irel_fo
##POSTGRES_dBUsername=igtbk1irel_ro
##POSTGRES_dBUserPass=igtbk1irel_ro
#
#
#
#STUB_SCHEMA_NAME=digipay_iso
#POSTGRES_URL=jdbc:postgresql://[Link]:5432/testdb
#POSTGRES_dBUsername=testdb
#POSTGRES_dBUserPass=testdb

[Link]
name=PropertiesConfig
[Link] = logs
appenders = file

[Link] = Console
[Link] = STDOUT
[Link] = PatternLayout
[Link] = [%-5level] %d{yyyy-MM-dd HH:mm:[Link]} [%t] %c{1}
- %msg%n

[Link] = File
[Link] = LOGFILE
[Link]=${filename}/[Link]
[Link]=PatternLayout
[Link]=[%-5level] %d{yyyy-MM-dd HH:mm:[Link]} [%t] %c{1} -
%msg%n
[Link]=true

loggers=file
[Link]=[Link]
[Link] = trace
[Link] = file
[Link] = LOGFILE

[Link] = trace
[Link] = stdout
[Link] = STDOUT