crf/web/crf/crfVisit.js

function clear(config){
	let el=config.document.getElementById(config.debugId);
	if (el===null) {
		//alert("Debug section not initialized");
		return;
	}
	config.document.getElementById(config.debugId).value="";
}

function print(config,msg){
	let el=config.document.getElementById(config.debugId);
	if (el===null) {
		//alert("Debug section not initialized. Message: "+msg);
		return;
	}
	el.value+="\n"+msg;
}

function getCRFref(config){
	//'crfRefId'
	return config.document.getElementById(config.crfRefId).innerHTML;
}

function onFailure(errorInfo, options, responseObj){
	
	if (errorInfo && errorInfo.exception)
		alert("Failure: " + errorInfo.exception);
	else
		alert("Failure: " + responseObj.statusText);
}

function generateDebugSection(config){
	//let debug=true;
	//if (debug) print(config,"generateDebugSection "+sectionName);

	let formName=config.debugDiv;
	let sectionName="debugSection";
	let sectionTitle="Debug Messages";
	let tb=config.document.createElement('table');
	tb.className='t2';
	let row=tb.insertRow();
	let cell=config.document.createElement('th');
	row.appendChild(cell);	
	cell.setAttribute("colspan","4");
	cell.style.fontSize="20px";
	cell.style.textAlign="center";
	let cellData=config.document.createTextNode(sectionTitle);
	cell.appendChild(cellData);
	cell=row.insertCell();
	let input=config.document.createElement("input");	
	input.type="button";
	input.value="Show";
	input.id="toggle"+sectionName+"VisbilityButton";
	input.onclick=function(){toggleVisibility(config,sectionName,input.id)};
	cell.appendChild(input);
	config.document.getElementById(formName).appendChild(tb);
	

	let div=config.document.createElement('div');
	div.id=sectionName;
	div.style.display="none";
	config.document.getElementById(formName).appendChild(div);	

	let debugArea=config.document.createElement('textarea');
	debugArea.rows=10;
	debugArea.cols=95;
	debugArea.id=config.debugId;
	div.appendChild(debugArea);



}




function setAdditionalData(config, additionalData,entry){
	let debug=true;
	if (debug) print(config,"setAdditionalData");
	if (entry["showFlag"]==="NONE") {
		if (debug) print(config,"Returning empty additionalData");
		return additionalData;
	}
	additionalData.showFlag=entry["showFlag"];
	additionalData.showFlagValue=entry["showFlagValue"];
	additionalData.queryName=entry["showQuery"];
	additionalData.filters=new Object();
	additionalData.filters['crfRef']=getCRFref(config);
	return additionalData;
}

function fullAccessSetup(config,listName){
	let debug=true;
	if (debug) print(config,"fullAccessSetup");

	let setup=new Object();
	setup.readonlyFlag=function(vName){return false};
	setup.filters=new Object();
	setup.filters['crfRef']=getCRFref(config);
	setup.getInputId=function(vName){return listName+"_"+vName;}
	setup.addApply="Save";
	return setup;

}

function readonlySetup(config){
	let debug=true;
	if (debug) print(config,"readonlySetup");

	let setup=new Object();
	setup.readonlyFlag=function(vName){return true};
	setup.filters=new Object();
	setup.filters['crfRef']=getCRFref(config);
	setup.getInputId=function(vName){return vName;}
	return setup;
}

function afterFormSetup(config,formConfig,data){

	let debug=true;
	if (debug) print(config,"afterFormSetup ["+data.rows.length+"]");
	formConfig.formSetup=data;

	//get list of queries
	let fields=formConfig.formSetup.metaData.fields;

	if (debug) print(config,"generateForm: fields: "+fields);
	let field="NONE";
	//if (debug) printTableSetup(config,data);
	for (f in fields){
		if (fields[f]['name']!='queryName') continue;
		field=fields[f];
		break;
	}
	if (debug) print(config,"generateForm: field: "+field);
	let lookup=field.lookup;
	if (debug) print(config,"generateForm: lookup: "+lookup);
	let qconfig=new Object();
	qconfig.containerPath=config.containerPath;
	qconfig.schemaName=lookup.schemaName;
	qconfig.queryName=lookup.queryName;
		
	//qconfig.filterArray=[LABKEY.Filter.create(lookup.keyColumn,entry['queryName'])];
	qconfig.filterArray=[];
	qconfig.success=function(data){afterFormSetupLookup(config,formConfig,data)};
	LABKEY.Query.selectRows(qconfig);
}

function afterFormSetupLookup(config,formConfig,data){
	//walk through the list of datasets/list and generate tables for each list
	let debug=true;

	formConfig.formSetupLookup=data;

	let rows=formConfig.formSetup.rows;
	//extract list of forms from formConfig
	for (let i=0;i<rows.length;i++){

		//each from has multiple lists associated with it
		if (debug) print(config,"generateForm ["+i+"/"+rows.length+"]");

		let entry=rows[i];
		//this is actually a pointer into another list (==lookup)
		//another selectRows is needed to actually get the name for the queryName
		
		//id : entry[queryName]
		//name: dentry[queryName]
	
		let queryId=entry['queryName'];

		//walk over keys to get the right lookup entry
		let lookupRows=formConfig.formSetupLookup.rows;
		let dentry=undefined;
		for (let j=0;j<lookupRows.length;j++){
			
			if (lookupRows[j].Key!=queryId)
				continue;
			dentry=lookupRows[j];
			break;
		}
		if (dentry===undefined){
			print(config,"generateForm ["+i+"] no list found");
			return;
		}
		if (debug)
			for (f in dentry) 
				print(config,"generateFormLookup field: "+f+" value: "+dentry[f]);
	
		let queryName=dentry["queryName"];

		if (debug) print(config,"generateFormLookup: ID: "+queryId+" name: "+queryName);
	
		//update fields for review
		if (!(queryName in config.fields))
			config.fields[queryName]=new Object();
		
		if (!(queryId in config.queryMap))
			config.queryMap[queryId]=queryName;
		
		let field=config.fields[queryName];

		field.title=entry["title"];
		field.queryId=queryId;

		if (debug) print(config,"entry[showFlag]: "+entry["showFlag"]);

		let additionalData=new Object();
		setAdditionalData(config,additionalData,entry);
		//section fits one dataset/list
		generateSection(config,formConfig,queryName,entry["title"],queryName, additionalData);
	}

}

function generateSection(config, formConfig, sectionName, sectionTitle, listName, additionalData){

	let formName=config.masterForm;//this is HTML designator of area on page
	let debug=true;
	if (debug) print(config,"generateSection "+sectionName);
	let tb=config.document.createElement('table');
	tb.className='t2';
	let row=tb.insertRow();
	let cell=config.document.createElement('th');
	row.appendChild(cell);	
	cell.setAttribute("colspan","4");
	cell.style.fontSize="20px";
	cell.style.textAlign="center";
	let cellData=config.document.createTextNode(sectionTitle);
	cell.appendChild(cellData);
	cell=row.insertCell();
	let input=config.document.createElement("input");	
	input.type="button";
	input.value="Show";
	input.id="toggle"+sectionName+"VisbilityButton";
	input.onclick=function(){toggleVisibility(config,sectionName,input.id)};
	cell.appendChild(input);
	config.document.getElementById(formName).appendChild(tb);

	let div=config.document.createElement('div');
	div.id=sectionName;
	div.style.display="none";
	config.document.getElementById(formName).appendChild(div);	

	let divTable=config.document.createElement('div');
	divTable.id=sectionName+"Table";
	div.appendChild(divTable);
	
	if ("showFlag" in additionalData) {

		additionalData.divName=sectionName+"SubDiv";
		additionalData.divQueryName=sectionName+"SubDivList";

		let div1=config.document.createElement('div');
		div1.id=additionalData.divName;
		div1.style.display="none";
		div.appendChild(div1);
	
		let div2=config.document.createElement('div');
		div2.id=additionalData.divQueryName;
		div1.appendChild(div2);

	}
	if (debug) print(config,"generate master table");

		
	let setup=fullAccessSetup(config,listName);
	if (formConfig.formStatus=="Submitted")
		setup=readonlySetup(config);
	if (formConfig.formStatus=="Approved")
		setup=readonlySetup(config);
	
	
	//master table is unique per visit

	
	setup.unique=true;
	generateTable(config,formConfig,listName,divTable.id,true,additionalData,setup);
	
	if (debug) print(config,"generate master table: done");

	let generateSubTable=true;
	if (formConfig.formStatus=="Submitted")
		generateSubTable=false;
	if (formConfig.formStatus=="Approved")
		generateSubTable=false;
	
	if (! ("showFlag" in additionalData) ) generateSubTable=false;
	
	if (generateSubTable){
		let qName=additionalData.queryName;
		let dName=additionalData.divName;
		

		let setup=fullAccessSetup(config,qName);
		//if (readonly) setup=readonlySetup(config);
		generateTable(config,formConfig,qName,dName,false,additionalData,setup);
	}

	print(config,"generate review");

	let divReviewList=config.document.createElement('div');
	divReviewList.id=sectionName+"ReviewList";
	div.appendChild(divReviewList);
	
	let divReview=config.document.createElement('div');
	divReview.id=sectionName+"Review";
	div.appendChild(divReview);


	//assume we already have listId (content of config.setupQueryName is listId)
	//we need listName also
	//qconfig.queryName=config.setupQueryName;
	generateReview(config,formConfig,divReview.id,divReviewList.id,listName);
}

function generateReview(config,formConfig,divReviewId,divReviewListId, listName){
	let listId=config.fields[listName].queryId;

	let debug=true;
	if (debug) print(config,"Generate review for: "+listId);
	
	let reviewSetup=new Object();
	reviewSetup.readonlyFlag=function(vName){
		if (vName=="queryName") return true; 
		if (vName=="queryname") return true; 
		if (vName=="ModifiedBy") return true;
		return false;};
	reviewSetup.addApply="Add Review";

	let generateTableFlag=true;
	if (formConfig.formStatus == "Approved" ){
		delete reviewSetup.addApply;
		reviewSetup.readonlyFlag=function(vName){return false;}
		generateTableFlag=false;
	}
	
	reviewSetup.filters=new Object();
	reviewSetup.filters["crfRef"]=getCRFref(config);
	
 	reviewSetup.filters["queryName"]=listId;//entry in reviewComments list is queryname, all in small caps
	//needs listName, in argument
	
	reviewSetup.getInputId=function(vName){return listName+"_add"+vName};
	reviewSetup.divReviewListId=divReviewListId;
		

	if (debug) {
		let msg="Review: divId: "+divReviewId;
		msg+=" inputId: "+reviewSetup.getInputId;
		print(config,msg);
	}
	updateListDisplay(config,divReviewListId,"reviewComments",reviewSetup.filters,true);
	
	if (! generateTableFlag) return;

	
	generateTable(config, formConfig,"reviewComments",divReviewId,false,new Object(),reviewSetup);
}	

function setListVisibility(config, setup,additionalData,readonlyFlag){
	let debug=true;
	if (debug){
		print(config,"Set list visibility ");
		for (f in additionalData){
			print(config,"AdditionalData["+f+"]: "+additionalData[f]);
		}
	}
	let x = config.document.getElementById(additionalData.divName);
	if (debug) print(config,"\n Div: "+x);
	x.style.display="none";
	let eId=setup.getInputId(additionalData.showFlag);
	let e = config.document.getElementById(eId);
	
	let sText;
	if (readonlyFlag) sText=e.innerHTML;
	else sText=e.options[e.selectedIndex].text;
	
	if (debug) print(config,"\n Selected option text: "+sText);

	if (sText == additionalData.showFlagValue){
		let filters=new Object();
		if ("filters" in additionalData) filters=additionalData.filters;
		x.style.display = "block";
		updateListDisplay(config, 
			additionalData.divQueryName,additionalData.queryName,filters,readonlyFlag);
	}
}

function updateListDisplay(config, divName,queryName,filters,readonlyFlag){
	let debug=true;

	if (debug) print(config,"UpdateListDisplay: Query - "+queryName+" div - "+divName);

	if (divName=="NONE") return;

	let crfRef=getCRFref(config);
	let div=config.document.getElementById(divName);

	if (debug)
		print(config,"Enabling display to queryName: "+queryName);
	
	var qconfig=new Object();
	qconfig.renderTo=divName;
	qconfig.containerPath=config.containerPath;
	qconfig.schemaName='lists'; 
	qconfig.queryName=queryName;
	qconfig.buttonBarPosition='top';
	qconfig.filters=[];
	for (f in filters){
		qconfig.filters.push(LABKEY.Filter.create(f, filters[f]));
	}
	qconfig.success=function(data){updateSuccess(config,data)};
	qconfig.failure=function(data){updateFailure(config,data)};
	//show only print button
	if (readonlyFlag){
		qconfig.buttonBar=new Object();
		qconfig.buttonBar.items=["print"];
	}

	LABKEY.QueryWebPart(qconfig);
	
}

function updateSuccess(config,data){
	print(config,"Update success");
}

function updateFailure(config,data){
	print(config,"Update failed");
}

function toggleVisibility(config, divName,buttonName){

	let x = config.document.getElementById(divName);
	if (x.style.display === "none") {
    		x.style.display = "block";
		config.document.getElementById(buttonName).value="Hide";

  	} else {
    		x.style.display = "none";
		config.document.getElementById(buttonName).value="Show";

  	}
}

function generateButton(config,divName,title,buttonName,callback,callbackParameters){
	let debug=true;
	if (debug) print(config,"generateButton");
	
	let tb=config.document.createElement('table');
	tb.className="t2";
	
	let r1=tb.insertRow();
	th=config.document.createElement('th');
	r1.appendChild(th);
	th.innerHTML=title;
	//*!*
	let c2=r1.insertCell();
	let i1=config.document.createElement("input");	
	i1.type="button";
	i1.value=buttonName;
	i1.style.fontSize="20px";
	i1.onclick=function(){callback(callbackParameters);}
	c2.appendChild(i1);	

	let c1=r1.insertCell();
	c1.setAttribute("colspan","1");
	c1.id=callbackParameters.submitReportId;

	let el=config.document.getElementById(divName);
	if (debug) print(config,"generateButton: element["+divName+"]: "+el);
	
	
	el.appendChild(tb);
	
	
}

function generateTable(config,formConfig,listName,divName,unique,additionalData,setup){
	let debug=true;
	
	if (debug) print(config,"generateTable: "+listName);
	//these objects will contain respective data for the entry

	//add temp variables
	//this will capture the state of the data prior to updating
	let qconfig=new Object();
	qconfig.containerPath=config.containerPath;
	qconfig.schemaName='lists';
	qconfig.queryName=listName;
	//apply filters on data to get right entries
	qconfig.filterArray=[];
	for (f in setup.filters){
		qconfig.filterArray.push(LABKEY.Filter.create(f,setup.filters[f]));
	}
	qconfig.success=function(data){populateTable(config,formConfig, data,divName,unique,additionalData,setup)};
	LABKEY.Query.selectRows(qconfig);
}

function printTableSetup(config,data){
	let obj=data.metaData.fields;
	for (f in obj){	
		print(config,"Data["+f+"]: "+obj[f]);
		for (g in obj[f]){
			print(config,"Data.metaData.fields["+f+"]["+g+"]: "+obj[f][g]);
		}
		if ("lookup" in obj[f]){
			for (h in obj[f]["lookup"]){
				print(config,"Lookup["+h+"]: "+obj[f]["lookup"][h]);
			}
		}
	}
}


function populateTable(config,formConfig, data,divName,unique,additionalData,setup){
	//generate and populate table with the first suitable entry
	let debug=true;
	//avoid resetting of values
	if (!(data.queryName in formConfig.dataFields))
		formConfig.dataFields[data.queryName]=data.metaData.fields;


	if (debug){
		print(config,"populateTable Query: "+data.queryName+" divName: "+divName+" setup: "+setup);


		if (0)  printTableSetup(config,data);
	}
	
	let crfRef=getCRFref(config);
	let entry=new Object();

	if (debug)
		print(config,"Data: nrows "+data.rows.length);
	
	//copy values from queryName to formConfig.entries
	if (data.rows.length > 0) formConfig.entries[data.queryName]=data.rows[0];
	
	//this is the current data snapshot
	if (data.queryName in formConfig.entries)
		entry=formConfig.entries[data.queryName];
	
	
	let tb=config.document.createElement('table');
	tb.className="t2";
	config.document.getElementById(divName).appendChild(tb);

	//this are the fields (probably constant)
	let fields=formConfig.dataFields[data.queryName];
	for (f in fields){
		let field=fields[f];
		if (field.hidden) continue;
		
		let vName=field.name;
		
		if (debug) print(config,"Field ["+vName+"]");
		if (vName=="crfRef") continue;		

		let vType=field.type;
		if (debug) print(config,"Field ["+vName+"/"+vType+"]");
		let row=tb.insertRow();
		let cell=config.document.createElement('th');
		row.appendChild(cell);
		let text = config.document.createTextNode(fields[f].shortCaption);
		cell.appendChild(text);
		cell=row.insertCell();
		
		let varValue="UNDEF";
		if (vName in setup.filters) varValue=setup.filters[vName];
		if (vName in entry) varValue=entry[vName];
		if (vType=="date"){
			if (varValue==="UNDEF") varValue=new Date();
			else varValue=new Date(varValue);
		}
		if (debug) print(config,"value: "+varValue);		
		let input;
		if (setup.readonlyFlag(vName)){
			input=config.document.createTextNode(varValue);
			cell.id=setup.getInputId(vName);
		}
		else{
			cell.colSpan="3";

			let cellClass="input";
			let cellType="text";
			if ("lookup" in field){
				input = config.document.createElement("select");
			}
			if (vType=="date"){ 
				input = config.document.createElement("input");
				input.type="date";
			}
			if (vType=="string" && !("lookup" in field)){
				if(vName.search("reviewComment")>-1){
					input = config.document.createElement("textarea");
					input.cols="65";
					input.rows="5";
				}
				else{
					input = config.document.createElement("input");
					input.type="text";
				}
			}
			if (vType=="float"){
				input = config.document.createElement("input");
				input.type="text";
			}	
			if (vType=="boolean"){
				input = config.document.createElement("input");
				input.type="checkbox";
				print(config,"Creating checkbox");
			}

			input.id=setup.getInputId(vName);
			if (varValue != "UNDEF"){
				if (vType=="string") input.value=varValue;
				if (vType=="float")  input.value=varValue;
				if (vType=="date") input.valueAsDate=varValue;
				if (vType=="boolean") input.checked=varValue;
			}
		}

	
		cell.appendChild(input);
		
		if ("lookup" in field){
			let lookup=field["lookup"];
			let qconfig=new Object();
			if (debug) print(config,"populateTable lookup: Query: "+lookup.queryName);
			qconfig.containerPath=config.containerPath;
			qconfig.schemaName=lookup.schemaName;
			qconfig.queryName=lookup.queryName;
			let parameters= new Object();
			parameters.elementId=setup.getInputId(vName);
			parameters.keyColumn=lookup.keyColumn;
			parameters.displayColumn=lookup.displayColumn;
			
			if (vName in setup.filters) parameters.selectedKey=setup.filters[vName];
			if (vName in entry) parameters.selectedKey=entry[vName];
			
			if ("showFlag" in additionalData) parameters.additionalData=additionalData;
			if (debug) print(config,"Populate select for "+parameters.elementId);
			qconfig.success=function(data){
				populateSelect(config,data,parameters,setup,setup.readonlyFlag(vName))
			};
			LABKEY.Query.selectRows(qconfig);
		}
		
	}
	//add comment field	
	if (!("addApply" in setup)) {
		print(config,"populateTable: done");
		return;
	}
	
	let row=tb.insertRow();

	let th=config.document.createElement('th');
	row.appendChild(th);
	th.innerHTML=setup.addApply; 
	let cell=row.insertCell();
	//cell.setAttribute("colspan","2");
	let input=config.document.createElement("input");	
	input.type="button";
	input.value=setup.addApply;
	cell.appendChild(input);	
	let cell1=row.insertCell();
	cell1.setAttribute("colspan","2");
	cell1.id=setup.getInputId("rerviewLastSave");
	cell1.innerHTML="No recent update";
	input.onclick=function(){saveReview(config,data.queryName,cell1.id,setup)};
}	
	
function populateSelect(config,data,parameters,setup,readonlyFlag){
	let debug=true;
	if (debug)
		print(config,"populateSelect on "+data.queryName);
	let elementId=parameters.elementId;
	let keyColumn=parameters.keyColumn;
	let displayColumn=parameters.displayColumn;
	if (debug){
		print(config,"Query: "+data.queryName);
		print(config,"ElementId: "+elementId);
		print(config,"keyColumn: "+keyColumn);
		print(config,"displayColumn: "+displayColumn);
		print(config,"No of options: " +data.rows.length);
	
		if ("selectedKey" in parameters){
			print(config,"SelectedKey: "+parameters["selectedKey"]);
		}
	}
	let el = config.document.getElementById(elementId);
	
	if (debug)
		print(config,"Element: "+el);
   	
	if (!readonlyFlag){
		//clear options
		for(i = el.options.length; i >= 0; i--) {
			el.remove(i);
   		}
	
		let opt = config.document.createElement("option");
		opt.text = "<Select>";
		opt.value = -1;
		el.options[0] = opt;
		if (debug) print(config, "Adding <Select>");

	}

	for (let i = 0; i < data.rows.length; i++) {
		let displayText = data.rows[i][displayColumn];
		let keyValue = data.rows[i][keyColumn];

		if (!readonlyFlag){
			let opt = config.document.createElement("option");

			opt.text = displayText;
			opt.value = keyValue;
			el.options[el.options.length] = opt;
		
		}
		if (debug) print(config,"Adding: "+keyValue+" : "+displayText);
		
		let t1=checkVariable(config,el,keyValue,displayText,parameters,"selectedKey",readonlyFlag);
		if (t1) setup.keyValue=keyValue;

		
	}
	
	if (!("additionalData" in parameters)) return;

	if (debug) print(config,"\n Parsing additional data ");

	let additionalData=parameters["additionalData"];	

	let expId=setup.getInputId(additionalData.showFlag);
	if (expId!=elementId) {
		print(config,"Element mismatch: got :"+expId+"/"+elementId);
		return;
	}

	if (debug)
		print(config,"Setting onChange to "+el.id);
	
	el.onchange=function(){setListVisibility(config,setup,additionalData,readonlyFlag)};
	setListVisibility(config,setup,additionalData,readonlyFlag);

}	

function checkVariable(config,el,varValue,displayText, parameters,varName,readonlyFlag){
	let debug=true;
	if (!varName in parameters) return false;
	if (debug) print(config,"Comparing: " + varValue  + "/" + parameters[varName]);
			
        if (varValue==parameters[varName]){
		if (readonlyFlag) el.innerHTML=displayText;
		else {
			el.selectedIndex=el.options.length-1;
			if (debug) print(config,"Equal; "+el.selectedIndex);
		}
		return true;
	}
	return false;
	
}

function failureSelect(config,errorInfo,resp,opt){
	print(config,"Error: ");

}

function saveReview(config,queryName,elementId,setup){
	let debug=true;
	if (debug) print(config,"saveReview: elementId "+elementId+" queryName "+queryName);
	let qconfig=new Object();
	qconfig.containerPath=config.containerPath;
	qconfig.schemaName='lists';//could be made more generic
	qconfig.queryName=queryName;
	if ("unique" in setup){
		qconfig.filterArray=[LABKEY.Filter.create("crfRef",getCRFref(config))];

	}
	qconfig.success=function(data){saveReviewToList(config,data,elementId,setup);}
	//to guess the fields, one must do selectRows first?
	LABKEY.Query.selectRows(qconfig);
}

function saveReviewToList(config,data,elementId,setup){
	let debug=true;
	if (debug) {
		let msg="saveReviewToList: "+" elementId "+elementId;
		msg+=" nrows "+data.rows.length;
		print(config,msg);
	}
	let useInsert=false;
	if (!("unique" in setup)) useInsert=true;
	if (data.rows.length==0) useInsert=true;
	let entry=new Object();
	
	if (!useInsert){
		entry=data.rows[0];
 	}
	entry.crfRef=getCRFref(config);

	if (debug) print(config,"Set crfRef="+entry.crfRef);

	if ("queryName" in setup.filters) {
		entry.queryName=setup.filters["queryName"];
		if (debug) print(config,"Setting queryName: "+entry.queryName);
	}
	if ("queryname" in setup.filters) {
		entry.queryname=setup.filters["queryname"];
		if (debug) print(config,"Setting queryname: "+entry.queryname);
	}
	let fields=data.metaData.fields;
	for (f in fields){

		let field=fields[f];
		if (debug) print(config,"saveReview field: "+field.name);
		if (field.hidden) continue;
		
		let vName=fields[f].name;

		if (vName=="crfRef") continue;
		if (vName=="queryName") continue;
		if (vName=="queryname") continue;
		
		let eId=setup.getInputId(vName);
		
		let el=config.document.getElementById(eId);
				
		if (!el) {
			if (debug) print(config,"saveReview element: "+eId+" not found");
			continue;
		}
		if (debug) print(config,"saveReview element: "+eId);
		
		let vType=fields[f].type;

		if (debug) print(config,"vType: "+vType);

		if ("lookup" in fields[f]){
			if (el.nodeName==="SELECT"){
				entry[vName]=el.options[el.selectedIndex].value;
			}
			if (el.nodeName==="TD"){
				entry[vName]=el.innerHTML;	
			}

			print(config,"Setting lookup to "+entry[vName]);
			continue;
		}
		if (vType=="date"){
			var date=el.valueAsDate;
			if (date==="null") continue;
			date.setUTCHours(12);
			entry[vName]=date.toString();
			print(config,"Setting date to "+entry[vName]);
		}	
		if (vType=="string"){
			entry[vName]=el.value;
		}	
		if (vType=="float"){
			entry[vName]=el.value;
		}	
		if (vType=="boolean"){
			entry[vName]=el.checked;
		}


	}
	
	let qconfig=new Object();
	qconfig.rows=[entry];
	qconfig.containerPath=config.containerPath;
	qconfig.schemaName=data.schemaName;
	qconfig.queryName=data.queryName;

	//only update comments
	print(config,"modifyRows: useInsert "+useInsert);
	qconfig.success=function(data){updateLastSavedFlag(config,data,setup,elementId)};
	if (!useInsert){
		LABKEY.Query.updateRows(qconfig);
	}
	else{
		LABKEY.Query.insertRows(qconfig);
	}
}

function updateLastSavedFlag(config,data,setup,elementId){
	let debug=true;
	if (debug) print(config,"Update last saved flag to "+elementId);
	let el=config.document.getElementById(elementId);
	let dt=new Date();
	el.innerHTML="Last saved "+dt.toString();
	if (data.queryName=="reviewComments"){
		updateListDisplay(config,setup.divReviewListId,"reviewComments",setup.filters,true);
	}	
}

//******************************************upload to database *********************


function onDatabaseUpload(config){
	print(config,"Database upload");
	configUpload=new Object();
	//figure out the participantId
	
	let qconfig=new Object();

	qconfig.schemaName="lists";
	qconfig.queryName="Forms";
	qconfig.filterArray=[LABKEY.Filter.create('Key',config.formId)];
	
	//qconfig.filterArray=[LABKEY.Filter.create('formStatus',1)]
	qconfig.success=function(data){afterForms(config,configUpload,data)};
	LABKEY.Query.selectRows(qconfig);

}

function afterForms(config,configUpload,data){	
	let formEntry=data.rows[0];
	configUpload.registrationQueryId=formEntry["masterQuery"];
	let qconfig=new Object();
	qconfig.queryName=config.queryMap[configUpload.registrationQueryId];
	//queryMap holds mapping for queries in visit; 
	//masterQuery should be one of them, so this is safe.
	qconfig.schemaName='lists';
	qconfig.filterArray=[LABKEY.Filter.create('crfRef',getCRFref(config))];
	qconfig.success=function(data){afterRegistration(config,configUpload,data);}
	LABKEY.Query.selectRows(qconfig);
	//waitForCompleteUpload(config);//

}

function afterRegistration(config,configUpload,data){
	print(config,"afterRegistration: rows:"+data.rows.length);
	configUpload.registration=data;
	let registrationData=configUpload.registration;
	clearErr(config);
	if (registrationData.rows.length!=1){
		let msg="ERROR: Found "+registrationData.rows.length;
		msg+=" registration entries for crfrefid "+getCRFref(config);
		print(config,msg);
		return;
	}
	configUpload.participantId=
		registrationData.rows[0][config.registrationParticipantIdField];
	//could be a lookup field
	let fields=registrationData.metaData.fields;
	let field="NONE";
	for (f in fields){
		if (fields[f]["name"]==config.registrationParticipantIdField)
			field=fields[f];
	}
	if ("lookup" in field){
		let pid=configUpload.participantId;
		print(config,"Using lookup for participantId: "+pid);
		let lookup=field["lookup"];
		print(config,"Lookup: "+lookup);
		let qconfig=new Object();
		qconfig.containerPath=config.containerPath;
		qconfig.schemaName=lookup.schemaName;
		qconfig.queryName=lookup.queryName;
		qconfig.filterArray=
			[LABKEY.Filter.create(lookup.keyColumn,pid)];
		qconfig.success=function(data){
			afterRegistrationLookup(config,configUpload,data,lookup.displayColumn)};
		LABKEY.Query.selectRows(qconfig);
	}
	else{
		afterParticipantId(config,configUpload);
	}
}

function afterRegistrationLookup(config,configUpload,data,displayColumn){
	print(config,"afterRegistrationLookup");
	let entry=data.rows[0];
	configUpload.participantId=entry[displayColumn];
	afterParticipantId(config,configUpload);
}


function afterParticipantId(config,configUpload){
	print(config,"Setting participantId to "+configUpload.participantId);
	//another select rows to update all queries from setup
	//just use registration for test
	let qconfig=new Object();
	qconfig.schemaName='lists';
	//qconfig.queryName=config.setupQueryName;
	qconfig.queryName="FormSetup";
	qconfig.filterArray=[LABKEY.Filter.create("formName",config.formId)];
	qconfig.success=function(data){afterSetup(config,configUpload,data);}
	LABKEY.Query.selectRows(qconfig);
}

function afterSetup(config,configUpload,data){

	configUpload.queries=new Array();

	for (let i=0;i<data.rows.length;i++){
		let entry=data.rows[i];
		//use lookup table to convert from id to name
		let queryName=config.queryMap[entry.queryName];
		configUpload.queries.push({queryName:queryName,queryStatus:"QUEUED"});
		if (entry.showQuery=="NONE")
			continue
		configUpload.queries.push({queryName:entry.showQuery,queryStatus:"QUEUED"});
	}
	//add reviews
	configUpload.queries.push({queryName:"reviewComments",queryStatus:"QUEUED"});
	configUpload.queryId=0;
	copyToDataset(config,configUpload);

	//config.upload["start"]=true;
	//for (u in config.upload){
	//	if (u=="start") continue;
	//	if (u=="count") continue;
	//	copyToDataset(config,u,participantId);
	//}
	//
	//print(config,"Database updated");
}



function copyToDataset(config,configUpload){

	if (configUpload.queryId==configUpload.queries.length) {
		updateFlag(config,3);//Approved
		return;
	}

	let queryName=configUpload.queries[configUpload.queryId].queryName;
	print(config,"copyToDataset["+configUpload.queryId+"/"+configUpload.queries.length+"]: "+queryName);
	let qconfig=new Object();
	qconfig.queryName=queryName;
	qconfig.schemaName="lists";
	qconfig.filterArray=[LABKEY.Filter.create('crfRef',getCRFref(config))];
	qconfig.success=function(data){afterListData(config,configUpload,data)};
	LABKEY.Query.selectRows(qconfig);
}

function afterListData(config,configUpload,data){

	let queryName=configUpload.queries[configUpload.queryId].queryName;
	let msg="["+queryName+"/list]: "+data.rows.length+" entries";
	print(config,msg);
	configUpload.listData=data;

	let qconfig=new Object();
	qconfig.queryName=queryName;
	qconfig.schemaName="study";
	qconfig.filterArray=[LABKEY.Filter.create('crfRef',getCRFref(config))];
	qconfig.filterArray.push(LABKEY.Filter.create('ParticipantId',configUpload.participantId));
	qconfig.success=function(data){afterStudyData(config,configUpload,data)};
	LABKEY.Query.selectRows(qconfig);
}


function afterStudyData(config,configUpload,data){
	configUpload.studyData=data;

	let queryName=configUpload.queries[configUpload.queryId].queryName;
	let msg="["+queryName+"/study]: "+data.rows.length+" entries";
	print(config,msg);
	

	let listRows=configUpload.listData.rows;
	//skip uploading an empty set
	if (listRows.length==0){
		printErr(config,"List "+queryName+" empty.");
		configUpload.queries[configUpload.queryId].queryStatus="DONE";
		configUpload.queryId+=1;
		copyToDataset(config,configUpload);
		return;
	}
	

	let studyRows=configUpload.studyData.rows;

	for (let i=0;i<studyRows.length;i++){
		let entry=studyRows[i];
		if (! (i<listRows.length) ) continue;
		let entryList=listRows[i];
		//keeps study only variables (ParticipantId, SequenceNum)
		for (let f in entryList) {
			entry[f]=entryList[f];
			print(config,"Copying ["+f+"]: "+entry[f]+"/"+entryList[f]);
		}
	}
	if (studyRows.length>0) {
		let qconfig=new Object();
		qconfig.queryName=queryName;
		qconfig.schemaName="study";
		qconfig.rows=studyRows;
		qconfig.success=function(data){afterStudyUpload(config,configUpload,data);}
		LABKEY.Query.updateRows(qconfig)
	}
	else{
		let data=new Object();
		data.rows=new Array();
		afterStudyUpload(config,configUpload,data);
	}
}

function afterStudyUpload(config,configUpload,data){
	
	let queryName=configUpload.queries[configUpload.queryId].queryName;
	printErr(config,"Updated "+data.rows.length+" rows to "+queryName);
	
	let studyRows=configUpload.studyData.rows;
	let listRows=configUpload.listData.rows;
	
	let rows=new Array();
	//also updating existing rows, if they exist
	for (let i=studyRows.length;i<listRows.length;i++){
		let entry=listRows[i];
		
		entry.ParticipantId=configUpload.participantId;
		entry.crfRef=getCRFref(config);
		entry.SequenceNum=getCRFref(config);
		entry.SequenceNum=entry.SequenceNum % 1000000000;
		
		if (listRows.length>1){
			entry.SequenceNum+=i/100;
		}
		print(config, "Adding sequence number "+entry.SequenceNum);
		rows.push(entry);
	}
	if (rows.length>0){

		let qconfig=new Object();
		qconfig.queryName=queryName;
		qconfig.schemaName="study";
		qconfig.success=function(data){
			afterListUpload(config,configUpload,data)};
		qconfig.rows=rows;
		LABKEY.Query.insertRows(qconfig);
	}
	else{
		let data=new Object();
		data.rows=rows;
		afterListUpload(config,configUpload,data);
	}
			
}

function afterListUpload(config,configUpload,data){

	let queryName=configUpload.queries[configUpload.queryId].queryName;
	printErr(config,"Inserted "+data.rows.length+" rows to "+queryName);
	configUpload.queries[configUpload.queryId].queryStatus="DONE";
	configUpload.queryId+=1;
	copyToDataset(config,configUpload);

}




//*************************update for further review *************************

function onUpdateForReview(config){
	updateFlag(config,4);//Pending review
}

function updateFlag(config,flag){
	if (flag==4)
		print(config,"Sent to further review");
	let qconfig=new Object();
	qconfig.schemaName='lists';
	qconfig.queryName='crfEntry';
	qconfig.success=function(data){setFlag(config,data,flag);}
	qconfig.filterArray=[LABKEY.Filter.create("entryId",getCRFref(config))];
	LABKEY.Query.selectRows(qconfig);
}

function setFlag(config,data,flag){
	let debug=true;
	if (flag==4) print(config,"setFlagToReview");
	if (data.rows.length!=1){
		let msg="ERROR: Found "+data.rows.length;
		msg+=" entries for crfrefid "+getCRFref(config);
		print(config,msg);
		return;
	}
	let entry=data.rows[0];
	entry.FormStatus=flag;//Pending Review
	if (debug)
		print(config,"Set form status to "+entry.FormStatus);
	
	let qconfig=new Object();
	qconfig.schemaName='lists';
	qconfig.queryName='crfEntry';
	qconfig.rows=[entry];
	qconfig.success=function(data){completeWithFlag(config,data,flag);}
	LABKEY.Query.updateRows(qconfig);
	
}

function completeWithFlag(config,data,flag){

	let debug=true;

	if (debug){
		if (flag==4) print(config,"complete with review");
	}
	redirect(config);

	
	

}

//************************************************ submit *******************************************


function onSubmit(config){
	let debug=true;
	hideErr(config);
	clearErr(config);
	printErr(config,"onSubmit");
	checkForm(config);
	let cb=new Object();
	cb.success=finalValidation;
	cb.failure=function(config){printErr(config,"waitForCheckForm failed")};
	waitForCheckForm(config,cb);
}

function finalValidation(config){
	let debug=true;
	if (debug) print(config,"validate");
	
	let completed=true;
	for (f in config.fields){
		let field=config.fields[f];
		if (field.status!="DONE") {
			printErr(config,"Missing entry for "+field.title);
			completed=false;
		}
	}
	if (debug) print(config,"valid: "+completed);

	if (completed){
		finalRedirect(config);
	}
	else{
		let el=document.getElementById(config.submitReportId);
		el.innerHTML="Form invalid";
	}
}

function finalRedirect(config){
	printErr(config,"Form valid");
	let c1=new Object();
	c1.schemaName='lists';
	c1.queryName='crfEntry';
	c1.filterArray=[LABKEY.Filter.create('entryId',getCRFref(config))];
	c1.success=function(data){uploadData(config,data)};
	LABKEY.Query.selectRows(c1);
}

function uploadData(config,data){
	let entry=data.rows[0];
	entry.formStatus=2;//Submitted
	let el=document.getElementById(config.submitReportId);
	el.innerHTML="Submitting form";
	let c1=new Object();
	c1.schemaName=data.schemaName;
	c1.queryName=data.queryName;
	c1.containerPath=config.containerPath;
	c1.rows=[entry];
	//close window upon success
	c1.success=function(data){redirect(config)};
	LABKEY.Query.updateRows(c1);
}

function hideErr(config){
	let el=config.document.getElementById("errorDiv");
	el.style.display="none";
}

function clearErr(config){
	let el=config.document.getElementById("errorTxt");
	el.value="";
}

function showErr(config){
	let el=config.document.getElementById("errorDiv");
	el.style.display="block";
}

function printErr(config,msg){
	showErr(config);
	el=config.document.getElementById("errorTxt");
	el.style.color="red";
	el.value+="\n"+msg;
}

function checkForm(config){
	let debug=false;
	let crfRef=getCRFref(config)
	
	
	config.status="UNKNOWN";
	for (f in config.fields){
		let field=config.fields[f];
		field.status="UNKNOWN";

		if (debug) 
			print(config,"Setting status for "+f+" to "+ field.status);

		let selectRows=new Object();
		selectRows.containerPath=config.containerPath;
		selectRows.schemaName="lists";
		selectRows.queryName=f;
		selectRows.filterArray=[LABKEY.Filter.create('crfRef',crfRef)];
		selectRows.success=function(data){checkData(data,config)};
		selectRows.failure=function(errorObj){print(config,"checkData failed.")};
		LABKEY.Query.selectRows(selectRows);
	}
}

function waitForCheckForm(config,cb){
	let debug=true;
	if (!("i" in config)) config.i=0;
	if (debug) print(config,"["+config.i+"] checkForm status "+config.status);
	if (config.i>100) {
		if (debug) print(config,"executing failure");	
		cb.failure(config);
		return;
	}
	if (config.status=="DONE") {
		if (debug) print(config,"executing success");	
		cb.success(config);
		if (debug) print(config,"success executed");	
		return;
	}
	config.i+=1;
	setTimeout(function(){waitForCheckForm(config,cb);},1000);
}

function checkData(data,config){
	let debug=false;
	if (debug) print(config,"checkData ");
	let field=config.fields[data.queryName];
	field.status="NONE";
	if (debug) print(config,"Setting status for "+data.queryName+" to "+field.status);
	if (data.rows.length>0)
		field.status="DONE";
	
	if (debug)
		print(config,"checkData set status for "+data.queryName+" to "+field.status);
	
	for (f in config.fields){
		let subField=config.fields[f];
		if (debug) 
			print(config,"checkData status["+f+"]: "+subField.status);	
		if (subField.status=="UNKNOWN") {
			if (debug) print(config,"\t Status for "+f+" not set ["+ subField.status+"]");
			return;
		}
		
	}
	config.status="DONE";
}


//**************************************************
//
function onRemoveCRF(config){
	let debug=true;

	if (debug){
		print(config,"Removing CRF");
	}

	let selectRows=new Object();
	selectRows.containerPath=config.containerPath;
	selectRows.schemaName="lists";
	selectRows.queryName="inputLists";
	selectRows.success=function(data){afterInputLists(data,config)};
	LABKEY.Query.selectRows(selectRows);
}

function afterInputLists(data,config){
	let debug=true;
	if (debug)
		print(config,"After input lists");
	config.inputLists=data;
	config.inputListsIterator=0;

	removeCRFLoop(config);
}

function removeCRFLoop(config){
	let debug=true;

	let i=config.inputListsIterator;
	
	if (debug)
		print(config,"removeCRFLoop ["+i+"/"+config.inputLists.rows.length+"]");

	if (i>config.inputLists.rows.length)
		//return;
		redirect(config);

	let queryName="crfEntry";
	let idVar="entryId";

	
	if (i<config.inputLists.rows.length){
		queryName=config.inputLists.rows[i].queryName;
		idVar="crfRef";
	}
	if (debug)
		print(config,"["+i+"/"+config.inputLists.rows.length+"] "+queryName+"/"+idVar);

	let selectRows=new Object();
	selectRows.containerPath=config.containerPath;
	selectRows.schemaName="lists";
	selectRows.queryName=queryName;
	selectRows.filterArray=[LABKEY.Filter.create(idVar,getCRFref(config))];
	selectRows.success=function(data){removeListCRF(data,config)};
	LABKEY.Query.selectRows(selectRows);
}

function removeListCRF(data,config){
	let debug=true;

	if (debug)
		print(config,data.queryName+": "+data.rows.length);

	config.inputListsIterator+=1;
	
	if (data.rows.length==0){
		removeCRFLoop(config);
		return;
	}

	let deleteRows=new Object();
	deleteRows.containerPath=config.containerPath;
	deleteRows.schemaName=data.schemaName;
	deleteRows.queryName=data.queryName;
	deleteRows.success=function(data){removeCRFLoop(config)};
	deleteRows.rows=data.rows;
	LABKEY.Query.deleteRows(deleteRows);
	
}

function redirect(config){
	let formUrl="begin";
	var params = {
		"name": formUrl, // The destination wiki page. The name of this parameter is not arbitrary.
	};

	let containerPath= config.containerPath;
        
	// This changes the page after building the URL. 
	//Note that the wiki page destination name is set in params.
        
	var homeURL = LABKEY.ActionURL.buildURL("project", formUrl , containerPath, params);
        print(config,"Redirecting to "+homeURL);
		 
	window.location = homeURL;

	

}

var blob;
var blobInterval;

function checkBlob(config){
	print(config,"Blob: "+blob);
	if (blob) {
		clearInterval(blobInterval);
		config.a.href = config.window.URL.createObjectURL(blob);
		print(config,"HREF: "+config.a.href);
		config.a.download = 'test.pdf';
		config.a.click();
		config.window.URL.revokeObjectURL(config.a.href);
	}
	config.count=config.count+1;
	print(config,"Eval: "+config.count);
	if (config.count>100){
		clearInterval(blobInterval);
	}

}

function printForm(config){

	let doc=new PDFDocument();
	doc.fontSize(25).text("Some text with standard font Andrej!", 100, 100);
	doc.end();
	let stream = doc.pipe(blobStream()).on("finish",function(){
		blob=stream.toBlob("application/pdf");});
	
	print(config,"BLob: "+blob);
	config.a = config.document.createElement("a");
	config.document.body.appendChild(config.a);
	config.a.innerHTML="Download PDF";
	config.a.style = "display: none";
	config.count=0;
	blobInterval=setInterval(checkBlob,1000,config);

	//pick data from crfForm list
        print(config,"Printing form");

	for (let i=0;i<config.formConfig.formSetup.rows.length;i++){
		let entry=config.formConfig.formSetup.rows[i];
		let qName=config.formConfig.queryMap[entry['queryName']];
		let selectRows=new Object();
		print(config,'Adding data for '+qName);
		selectRows.containerPath=config.containerPath;
		selectRows.schemaName='lists';
		selectRows.queryName=qName;
		selectRows.filterArray=[LABKEY.Filter.create('crfRef',config.formConfig.crfEntry['entryId'])];
		selectRows.success=function(data){collectFormData(config,data)};
		LABKEY.Query.selectRows(selectRows);
		//deal with additional data
	}
	
}

function collectFormData(config,data){
	config.formConfig.fields[data.queryName].data=data;
	for (f in config.formConfig.fields){
		let field=config.formConfig.fields[f];
		if ("data" in field) continue;
		return;
	}
	print(config,"All done");
	formatFormData(config);
}

function formatFormData(config){
	for (queryName in config.formConfig.fields){
		formatDataset(config,queryName);
	}
}

function formatDataset(config,queryName){
	let data=config.formConfig.fields[queryName].data;
	let fields=data.metaData.fields;
	for (let i=0;i<data.rows.length;i++){
		for (f in fields){
			let field=fields[f];
			if (field.hidden) continue;
			let vName=field.name;
			let vType=field.type;
			print(config,'['+vName+'/'+vType+']: '+data.rows[i][vName]);
		}
	}

}




function generateMasterForm(config){


	generateDebugSection(config);
	setFormConfig(config);
}

function afterConfig(config){

	let debug=true;

	if (debug)
		print(config,"generateMasterForm");	
	
	let selectRows=new Object();
	selectRows.containerPath=config.containerPath;
	selectRows.schemaName='lists';
	selectRows.queryName='crfEntry';
	selectRows.filterArray=[LABKEY.Filter.create('entryId',getCRFref(config))];
	
	let formConfig=new Object();
	//selectRows.success=function(data){populateBasicData(config,data)};
	selectRows.success=function(data){afterCrf(config,formConfig,data)};
	LABKEY.Query.selectRows(selectRows);
}

//requires populateBasicData
function afterCrf(config,formConfig,data){
	formConfig.crfEntry=data.rows[0];
	//schedule basic data for later
	populateBasicData(config,data);

	let selectRows=new Object();
	selectRows.containerPath=config.containerPath;
	selectRows.schemaName='lists';
	selectRows.queryName='FormStatus';
	selectRows.filterArray=[];
	
	selectRows.success=function(data){afterFormStatus(config,formConfig,data)};
	LABKEY.Query.selectRows(selectRows);	


	//use crfEntry['FormStatus'] to determine what configuration to display
	//reviewMode equivalence table:
	//
	//FormStatus	reviewMode
	//In Progress	undefined/EDIT
	//Review Pending undefined/EDIT
	//Submitted	REVIEW
	//Approved	APPROVED
	
	//two level indirect - 
	//
	//1. learn of the FormStatus options by reading in the FormStatus list
	//
	//2. Load the crfEntry for this crfId 
}
	

	
function afterFormStatus(config, formConfig, data){
	print(config,"afterFormStatus: ");
	formConfig.formStatusData=data;
	
	let rows=formConfig.formStatusData.rows;

	for (let i=0; i<rows.length; i++){
		let key=rows[i].Key;
		if (formConfig.crfEntry["FormStatus"]!=key)
			continue;
		formConfig.formStatus=rows[i].formStatus;
		break;
	}

	print(config,"Generating buttons for formStatus \""+formStatus+"\"");
	
	let done="FALSE";
	if (formConfig.formStatus=="Submitted"){
		generateButton(config,"submitDiv","Complete submission",
			"Upload to database",onDatabaseUpload,config);
		generateButton(config,"submitDiv","Review submission",
			"Ask for further review",onUpdateForReview,config);
		generateButton(config,"submitDiv","Remove submission",
			"Remove CRF form",onRemoveCRF,config);
		done="TRUE";
	}
	if (formConfig.formStatus=="Approved"){
		generateButton(config,"submitDiv","Review submission",
			"Restore form for further review",onUpdateForReview,config);
		done="TRUE";
	}
	if (done=="FALSE"){
		generateButton(config,"submitDiv","Complete submission",
			"Submit",onSubmit,config);
		generateButton(config,"submitDiv","Remove submission",
			"Remove CRF form",onRemoveCRF,config);
	
	}

	generateButton(config,"submitDiv","Done","Exit",redirect,config);
	
	//schedule actual forms
	config.fields=new Object();	
	config.queryMap=new Object();

	//data and layout of actual forms
	//filled in generateTable
	formConfig.entries=new Object();
	formConfig.dataFields=new Object();

	let configSelectRows=new Object();
	configSelectRows.containerPath=config.containerPath;
	configSelectRows.schemaName='lists';
	configSelectRows.queryName=config.setupQueryName;
	//this is new
	configSelectRows.queryName="FormSetup";
	configSelectRows.filterArray=[LABKEY.Filter.create("formName",config.formId)];

	configSelectRows.success=function(data){afterFormSetup(config,formConfig,data);};
	configSelectRows.failure=onFailure;//function(errorTxt){print(config,"generateForm fail" + errorTxt)};
	LABKEY.Query.selectRows(configSelectRows);

}

function setFormConfig(config){

	//generateDebugSection(config);

	let debug=true;

	if (debug)
		print(config,"generateMasterForm1");	
	
	let selectRows=new Object();
	selectRows.containerPath=config.containerPath;
	selectRows.schemaName='lists';
	selectRows.queryName='crfEntry';
	selectRows.filterArray=[LABKEY.Filter.create('entryId',getCRFref(config))];
	config.formConfig=new Object();
	//store form related data to this object
	selectRows.success=function(data){afterCRFEntry(config,data)};
	//requires populateBasicData
	LABKEY.Query.selectRows(selectRows);
}

function afterCRFEntry(config,data){
	config.formConfig.crfEntry=data.rows[0];
	print(config,"Setting crfEntry (x) to "+config.formConfig.crfEntry["entryId"]);
	
	let selectRows=new Object();
	selectRows.containerPath=config.containerPath;
	selectRows.schemaName='lists';
	selectRows.queryName='site';
	selectRows.filterArray=[LABKEY.Filter.create('siteNumber',config.formConfig.crfEntry.Site)];
	selectRows.success=function(data){afterSite(config,data)};
	LABKEY.Query.selectRows(selectRows);
}

function afterSite(config,data){
	print(config,"afterSite");
	config.formConfig.site=data.rows[0];
	print(config,"Setting site name to "+config.formConfig.site["siteName"]+" phone: "+config.formConfig.site["sitePhone"]);

	let selectRows=new Object();
	selectRows.containerPath=config.containerPath;
	selectRows.schemaName='core';
	selectRows.queryName='Users';
	selectRows.filterArray=[LABKEY.Filter.create('siteNumber',config.formConfig.crfEntry.UserId)];
	selectRows.success=function(data){afterUser(config,data)};
	LABKEY.Query.selectRows(selectRows);
}

function afterUser(config,data){
	config.formConfig.user=data.rows[0];
	print(config,"Setting user to "+config.formConfig.user["DisplayName"]);

	let selectRows=new Object();
	selectRows.containerPath=config.containerPath;
	selectRows.schemaName='lists';
	selectRows.queryName='FormSetup';
	selectRows.filterArray=[LABKEY.Filter.create('formName',config.formId)];
	selectRows.success=function(data){afterFormSetup(config,data)};
	LABKEY.Query.selectRows(selectRows);

}


function afterFormSetup(config,data){
	config.formConfig.formSetup=data;
	print(config,"Number of datasets for form ["+config.formId+"]: "+config.formConfig.formSetup.rows.length);

	let fields=config.formConfig.formSetup.metaData.fields;
	let formQueryName='queryName';
	let field="NONE";
	for (f in fields){
		if (fields[f]['name']!=formQueryName) continue;
		field=fields[f];
		break;
	}
	let lookup=field.lookup;

	print(config,"Getting dataset names from :"+lookup.queryName);
	let selectRows=new Object();
	selectRows.containerPath=config.containerPath;
	selectRows.schemaName=lookup.schemaName;
	selectRows.queryName=lookup.queryName;
	selectRows.success=function(data){afterFormDatasets(config,data)};
	LABKEY.Query.selectRows(selectRows);

}

function afterFormDatasets(config,data){
	config.formConfig.formDatasets=data;
	config.formConfig.fields=new Object();
	config.formConfig.queryMap=new Object();
	for (let i=0;i<config.formConfig.formSetup.rows.length;i++){
		let entry=config.formConfig.formSetup.rows[i];
		let queryId=entry['queryName'];
		for (let j=0;j<config.formConfig.formDatasets.rows.length;j++){
			if (queryId!=config.formConfig.formDatasets.rows[j]['Key']) continue;
			let qName=config.formConfig.formDatasets.rows[j]['queryName'];
			config.formConfig.fields[qName]=new Object();
			config.formConfig.queryMap[queryId]=qName;
			let field=config.formConfig.fields[qName];
			field.title=entry['title'];
			field.queryId=queryId;
			//print(config,"     "+config.formConfig.formDatasets.rows[j]['queryName']);
			break;
		}
	}
	print(config,"List of datasets in form : ");
	for (f in config.formConfig.fields){
		let field=config.formConfig.fields[f];
		print(config,"\t"+f+" ID: "+field.queryId+' title '+field.title);
	}
	afterConfig(config);

}