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 populateBasicData(config,data){
	let debug=false;
	if (debug)
		print(config,"crfRef matched entries: "+data.rows.length);
	if (data.rows.length!=1) { return;}
	config.document.getElementById('eudraCTNumber').innerHTML=data.rows[0].EudraCTNumber;
	config.document.getElementById('studyCoordinator').innerHTML=data.rows[0].StudyCoordinator;
	config.document.getElementById('studySponsor').innerHTML=data.rows[0].StudySponsor;
	let qconfig=new Object();
	qconfig.containerPath=config.containerPath;
	qconfig.schemaName='lists';
	qconfig.queryName='site';
	qconfig.filterArray=[LABKEY.Filter.create('siteNumber', data.rows[0].Site)];
	qconfig.success=function(data){
		setHTML(config,data,'siteName','siteName');
		setHTML(config,data,'sitePhone','sitePhone');
	};
		
	LABKEY.Query.selectRows(qconfig);


	if (debug)
		print(config,"set user: "+data.rows[0].UserId);
	let qconfig1=new Object();
	qconfig1.containerPath=config.containerPath;
	qconfig1.schemaName='core';
	qconfig1.queryName='Users';
	qconfig1.filterArray= [LABKEY.Filter.create('UserId',data.rows[0].UserId)];
	qconfig1.success= function(data){setHTML(config,data,'investigatorName','DisplayName')};
	qconfig1.failure=onFailure;
	if (debug)
		print(config,"USER select rows");

	LABKEY.Query.selectRows(qconfig1);
}

function setHTML(config,data,elementId,varName){
	print(config,"setHTML "+data.rows.length+" elementId: "+elementId+" varName:"+varName);
	if (data.rows.length>0){
		let entry=data.rows[0];
		let el=config.document.getElementById(elementId);
		
		print(config,"setHTML: Entry[" + varName + "]: " + entry[varName]);
		print(config,"setHTML: Element[" + elementId + "]: " + el);
		el.innerHTML=entry[varName];
	}

}

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 generateForm(config,data){

	let debug=true;
	if (debug) print(config,"generateForm ["+data.rows.length+"]");
	for (let i=0;i<data.rows.length;i++){

		if (debug) print(config,"generateForm ["+i+"/"+data.rows.length+"]");

		let entry=data.rows[i];
		//this is actually a pointer into another list (==lookup)
		//another selectRows is needed to actually get the name for the queryName
		//
		
		
		
		let fields=data.metaData.fields;
		if (debug) print(config,"generateForm ["+i+"]: 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 ["+i+"]: field: "+field);
		let lookup=field.lookup;
		if (debug) print(config,"generateForm ["+i+"]: 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.success=function(data){generateFormLookup(config,data,entry)};
		LABKEY.Query.selectRows(qconfig);
	}
}


function generateFormLookup(config,data,entry){
	//id : entry[queryName]
	//name: dentry[queryName]
	
	let debug=true;
	let queryId=entry['queryName'];

	if (data.rows.length==0){
		alert("No rows found for listId: "+entry['queryName']);
		return;
	}
	let dentry=data.rows[0];
	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);
	generateSection(config,queryName,entry["title"],queryName, additionalData);


}

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

	let formName=config.masterForm;
	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 ("reviewMode" in config) 
		setup=readonlySetup(config);
	//master table is unique per visit
	setup.unique=true;
	generateTable(config,listName,divTable.id,true,additionalData,setup);
	
	if (debug) print(config,"generate master table: done");

	let generateSubTable=true;
	if ("reviewMode" in config) generateSubTable=false;
	if (! ("showFlag" in additionalData) ) generateSubTable=false;
	
	if (generateSubTable){
		let qName=additionalData.queryName;
		let dName=additionalData.divName;
		

		let setup=fullAccessSetup(config,qName);
		if ("reviewMode" in config)
			setup=readonlySetup(config);
		generateTable(config,qName,dName,false,additionalData,setup);
	}

	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
	let qconfig=new Object();	
	qconfig.containerPath=config.containerPath;
	qconfig.schemaName='lists';
	//qconfig.queryName=config.setupQueryName;
	qconfig.queryName="FormSetup";
	qconfig.filterArray=[LABKEY.Filter.create("formName",config.formId)];
	
	qconfig.success=function(data){
		generateReview(config,data,divReview.id,divReviewList.id,listName)};
	LABKEY.Query.selectRows(qconfig);
}

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

	let debug=true;
	if (debug) print(config,"Generate review for: "+listId);
	
	//don't need this
	//let listId=-1;
	//for (let i=0;i<data.rows.length;i++){
	//	let entry=data.rows[i];
	//	if (entry["queryName"]!=listName) continue;
	//	listId=entry["Key"];
	//	break;
	//}
	//if (debug) print(config,"Review: setting listId: "+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 ("reviewMode" in config && config.reviewMode == "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
	//reviewSetup.filters["ModifiedBy"]=LABKEY.Security.currentUser.id;
	//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,"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,listName,divName,unique,additionalData,setup){
	let debug=true;
	
	if (debug) print(config,"generateTable: "+listName);

	//add temp variables
	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,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,data,divName,unique,additionalData,setup){
	//generate and populate table with the first suitable entry
	let debug=true;

	
	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);

	if (data.rows.length > 0) entry=data.rows[0];
	
	let tb=config.document.createElement('table');
	tb.className="t2";
	config.document.getElementById(divName).appendChild(tb);

	let fields=data.metaData.fields;
	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;

	

}

function generateMasterForm(config){

	generateDebugSection(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))];
	selectRows.success=function(data){populateBasicData(config,data)};
	//requires populateBasicData
	LABKEY.Query.selectRows(selectRows);

	config.fields=new Object();	
	config.queryMap=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){generateForm(config,data);};
	configSelectRows.failure=onFailure;//function(errorTxt){print(config,"generateForm fail" + errorTxt)};
	LABKEY.Query.selectRows(configSelectRows);

	if (debug)
		print(config,"Generating buttons");

	//requires onSubmit
	if ("reviewMode" in config){
		if (config.reviewMode=="REVIEW"){
	
			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);
		}
		if (config.reviewMode=="APPROVED"){
			generateButton(config,"submitDiv","Review submission","Restore form for further review",onUpdateForReview,config);

		}
	}	
	else{
		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);

}