crf/web/crf/crfVisitNew.js

var crfVisit={};

//crfVisit.config=new Object();

crfVisit.setDebug=
function(debug=null){
   if (debug){
      this.print=function(msg){debug.this.print(msg);};
      this.clear=function(){debug.clear();}
      return;
   }
   //provide default functions if not debug object is available
   this.print=function(msg){console.log(msg);}
   this.clear=function(){;}
}

crfVisit.setDebug();


crfVisit.init=
function(cb=null){
   let that=this;
   let action=function(){that.scriptsLoaded(cb);};
   let dependencies=new Array();
   dependencies.push('crf/runQuery.js');
   dependencies.push("crf/crfReviewSection.js");
   dependencies.push("crf/participantIdManager.js");
   dependencies.push("crf/variableList.js");
   dependencies.push("crf/webdav.js");
   dependencies.push("crf/crfPrint.js");
   dependencies.push("crf/crfSetup.js");
   dependencies.push("crf/crfData.js");
   dependencies.push("crf/crfHTML.js");
   dependencies.push("crf/generateRegistration.js");
   dependencies.push("crf/formPortalNew.js");
   LABKEY.Utils.requiresScript(dependencies,action);
}

crfVisit.scriptsLoaded=
function(cb=null){
   participantIdManager.set(crfSetup,crfData);
   webdav.set(this);
   crfReviewSection.set(this);
   crfPrint.set(this);
   crfData.setSetup(crfSetup);
   crfHTML.init();
   //generateRegistration.init();
   let initRegistration=function(){generateRegistration.init(cb);};
   let initIdManager=function(){participantIdManager.init(initRegistration);};
   let initCrfData=function(){crfData.init(initIdManager)};
   let initFormPortal=function(){formPortal.init(initCrfData);};
   crfSetup.init(initFormPortal);
}


crfVisit.getContainer=
function(label){
	return crfSetup.getContainer(label);
}

crfVisit.getCrfRefFirst=
function(){
	//crfRef is part of html call and gets stored in the page
	return this.crfRef;
}

crfVisit.getCrfRef=
function (){
	//'crfRefId'
	return crfData.getCrfEntry()['entryId'];
}

crfVisit.getCrfRefData=
function(){
	let parentCrf=crfData.getCrfEntry()['parentCrf'];
	if (parentCrf!=undefined) return parentCrf;
	return this.getCrfRef();
}

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

crfVisit.doNothing=
function (){
	this.print('doNothing called');
}

crfVisit.getIdManager=
function(){
   if (!("masterForm" in participantIdManager)){
      participantIdManager.siteNumber=crfData.getCrfEntry()['Site'];
      participantIdManager.masterForm=this.masterForm;
      participantIdManager.generateTable();
   }
   return participantIdManager;
}

crfVisit.getSetupObject=
function(){
   if (!("setups" in this))
      this.setups=new Object();
   return this.setups;
}

crfVisit.getStoredSetup=
function(sectionId){
   let sObj=this.getSetupObject();
   if (sectionId in sObj) return sObj[sectionId];
   return null;
}

crfVisit.addSetup=
function(sectionId,setup){
   let sObj=this.getSetupObject();
   sObj[sectionId]=setup;
}
   
crfVisit.makeSetup=
function(sectionId,listName){
	//generate setup object whcih should contain fields:
	//readonlyFlag - whether the dataset is writeable
	//filters - selection fields that allow creation of LABKEY.Filter.create()
	//getInputId - formating of unique ids for html elements
   //

   let fName='[Setup]';
	this.print(fName+' '+sectionId+'/'+listName);
   let setup=new Object();
	setup.queryName=listName;
	setup.readonlyFlag=function(vName){return false};
	setup.filters=new Object();
	setup.filters['crfRef']=this.getCrfRef();
	setup.getInputId=function(vName){return sectionId+"_"+vName;}
   setup.sectionId=sectionId;
	setup.isReview=false;
   this.addSetup(sectionId,setup);
   setup.setVariables=new Object();
   return setup;
	
}

crfVisit.makeFullAccessSetup=
function(sectionId,listName){
	//addApply - whether a submit/Save button is generated
	let setup=this.makeSetup(sectionId,listName);
	setup.addApply="Save";
	return setup;

}

crfVisit.makeReadonlySetup=
function(sectionId,listName){
   let setup=this.makeSetup(sectionId,listName);
	//see definition of setup object above, change readonly flag
	setup.readonlyFlag=function(vName){return true};
	return setup;
}

crfVisit.getSetup=
function(sectionId,listName,writeAccess=true){
	//change to section granulated permission of type EDIT, COMMENT, READ
	//let formStatus=config.formConfig.formStatus;
	//equivalent to READ
   let setup=this.getStoredSetup(sectionId);
   if (setup) return setup;


	if (!writeAccess)
	//if (formStatus=="Submitted")
		return this.makeReadonlySetup(sectionId,listName);
	//if (formStatus=="Approved")
	//	return readonlySetup(listName);
	return this.makeFullAccessSetup(sectionId,listName);
}

crfVisit.generateSection=
function(formSetupEntry){
   let that=this;
	let listName=crfSetup.getMap('inputLists')[formSetupEntry['queryName']];
   let sectionId="section"+formSetupEntry['Key'];
   //if (!listName) is for debugSection
   if (!listName){
      listName="debugSection";
   }
	let fName='[generateSection/'+listName+']';
	let sectionTitle=formSetupEntry['title'];	
	let accessModeColumn=this.role+'Mode';
	let accessMode=formSetupEntry[accessModeColumn];
	//this will fix it for later use as well
	this.print(fName+' title '+sectionTitle);

	let tb=crfHTML.createTable(this.masterForm);
	tb.className='t2';
	let row=tb.insertRow();
	let cell=crfHTML.createTblHeader(null,row);
	cell.setAttribute("colspan","4");
	cell.style.fontSize="20px";
	cell.style.textAlign="center";
   crfHTML.createTextNode(sectionTitle,null,cell);
	cell=row.insertCell();
	let input=crfHTML.createButton(null,cell);
	input.value="Show";
	input.id="toggle"+sectionId+"VisbilityButton";
	input.onclick=function(){that.toggleVisibility(sectionId,input.id)};

	let div=crfHTML.createDiv(sectionId,this.masterForm);
	div.style.display="none";

   //here divert for debugArea
   if (listName=="debugSection"){
      let debugArea=crfHTML.createTextArea(null,div);
      debugArea.rows=10;
      debugArea.cols=95;
      debugArea.id=this.debugId;
      return;
   }

	let additionalData=crfSetup.getAdditionalData(listName);
	let divTable=crfHTML.createDiv(sectionId+"Table",null,div);
	
	if ("showFlag" in additionalData) {
		additionalData.divName=sectionId+"SubDiv";
		additionalData.divQueryName=sectionId+"SubDivList";

		let div1=crfHTML.createDiv(additionalData.divName,null,div);
		div1.style.display="none";
		let div2=crfHTML.createDiv(additionalData.divQueryName,null,div1);

	}
	this.print(fName+" generate master table");

	let writeMode=accessMode=="EDIT";	
	let setup=this.getSetup(sectionId,listName,writeMode);
   setup.setVariables=variableList.parseVariables(formSetupEntry['variableDefinition']);
	

   if	("isReview" in additionalData){
      crfReviewSection.set(this);
      let action=function(){crfReviewSection.CB();};
		crfReviewSection.generateSection(listName,div.id,action);
		return;	
	}
	//master table is unique per visit

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

	let generateSubTable=true;
	//generateSubTable equivalent to read/write access to section
	if (accessMode != "EDIT")
		generateSubTable=false;
	
	if (! ("showFlag" in additionalData) ) generateSubTable=false;
	
	if (generateSubTable){
		let qName=additionalData.queryName;
		let dName=additionalData.divName;
		
      let subsectionId='sub'+sectionId;
		let xsetup=this.makeFullAccessSetup(subsectionId,qName);
		//only set master query for additionalData
		xsetup.masterQuery=listName;
		//if (readonly) setup=readonlySetup(config);
      xsetup.subTable=true;
      this.generateTable(qName,dName,additionalData,xsetup);
		//generateTable(formSetupEntry,qName,dName,additionalData,setup);
	}

	this.print("generate review");

	let divReviewList=crfHTML.createDiv(sectionId+"ReviewList",null,div);
	let divReview=crfHTML.createDiv(sectionId+"Review",null,div);


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

	if (accessMode!='GENERATE') return;
	this.print('Adding generate button');	
	//add generateButton
	let divGenerateButton=crfHTML.createDiv(listName+"GenerateButton",null,div);
	this.print('Adding generate button completed to here');	
   let cb=function(){that.onGenerateQuery(listName);};
	this.generateButton(divGenerateButton.id,'Generate','Generate '+listName,'onGenerateQuery',cb);
	this.print(fName+' adding generate button completed');	
}

crfVisit.generateReview=
function(divReviewId,divReviewListId, listName, accessMode){
   let qMapInvert=crfSetup.invertMap(crfSetup.getMap('inputLists'));
	let listId=qMapInvert[listName]

	//listId is a number->should it be queryName?
	
   let fName='[generateReview]';
   this.print(fName+" list "+listId+'/'+listName);
	let reviewSetup=new Object();
   reviewSetup.setVariables=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";
   reviewSetup.reviewTable=true;

	let generateTableFlag=true;
	let formStatus=crfData.getCrfEntry()['FormStatus'];
	//COMMENTS allowed or not
	//three levels of access: EDIT, COMMENT, READ
	if (accessMode == "READ"){
	//if (formStatus == "Approved" ){
		delete reviewSetup.addApply;
		reviewSetup.readonlyFlag=function(vName){return false;}
		generateTableFlag=false;
	}
	
	reviewSetup.filters=new Object();
	reviewSetup.filters["crfRef"]=this.crfRef;
   if (crfData.getCrfEntry()['parentCrf']){
      let parentCrf=crfData.getCrfEntry()['parentCrf'];
      reviewSetup.filters["crfRef"]=this.crfRef+";"+parentCrf;
   }
 	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;
	reviewSetup.isReview=true;	
   this.addSetup(divReviewId,reviewSetup);

   let msg="Review: divId: "+divReviewId;
   msg+=" inputId: "+reviewSetup.getInputId;
   this.print(msg);
	
	this.updateListDisplay(divReviewListId,"reviewComments",reviewSetup.filters,true);

	if (! generateTableFlag) return;

	
   this.generateTable("reviewComments",divReviewId,new Object(),reviewSetup);
}	

//>>>>>>>>>>trigger visibility of additional lists

crfVisit.setListVisibility=
function(input,setup,readonlyFlag){
	let fName="[setListVisibility/"+setup.queryName+"]";
	this.print(fName);
	let additionalData=crfSetup.getAdditionalData(setup.queryName);
	
	let x = crfHTML.getElement(additionalData.divName);
	this.print(fName+": Div: "+x);
	x.style.display="none";

	let sText;
	if (readonlyFlag) sText=input.innerText;
	else sText=input.options[input.selectedIndex].text;
			
	this.print(fName+": Selected option text: "+sText);

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

//>>have list refresh when data is added (not optimal yet)
//

crfVisit.updateListDisplay=
function(divName,queryName,filters,readonlyFlag){
	//use Labkey.QueryWebPart to show list

	let fName="[updateListDisplay]";

   this.print(fName+": UpdateListDisplay: Query - "+queryName
      +" div - "+divName);

	if (divName=="NONE") return;

	let crfRef=this.getCrfRef();
	let div=crfHTML.getElement(divName);

   this.print(fName+": generating WebPart: "+queryName);
	
	var qconfig=new Object();
	qconfig.renderTo=divName;
	//point to data container
	qconfig.containerPath=this.getContainer('data');
	qconfig.schemaName='lists'; 
	qconfig.queryName=queryName;
	qconfig.buttonBarPosition='top';
	qconfig.filters=[];
	for (f in filters){
      let fType=LABKEY.Filter.Types.EQUAL;
      this.print(fName+' filter ['+f+'] '+filters[f]+'/'+typeof(filters[f])+' ['+fType+']');
     
      if (variableList.isFilterList(filters[f])){
         fType=LABKEY.Filter.Types.IN;
      }
		qconfig.filters.push(LABKEY.Filter.create(f, filters[f],fType));
	}
   let that=this;
	qconfig.success=function(data){that.updateSuccess(data);};
	qconfig.failure=function(errorInfo,options,responseObj){that.onFailure(errorInfo,options,responseObj);};
	//show only print button
	if (readonlyFlag){
		qconfig.buttonBar=new Object();
		qconfig.buttonBar.items=["print"];
	}

	LABKEY.QueryWebPart(qconfig);
	
}

crfVisit.updateSuccess=
function(data){
	this.print("Update success");
}

//TODO: this should trigger a data refresh on section, ie populateData(field)
crfVisit.toggleVisibility=
function(sectionId,buttonName){
	let fName='[toggleVisibility/'+sectionId+']';
	this.print(fName);
	let x = crfHTML.getElement(sectionId);
	if (x.style.display === "none") {
		//exclude non data sections (like debug)...
		this.print(fName+': issuing setData(populateSection)');
    		x.style.display = "block";
		crfHTML.getElement(buttonName).value="Hide";
      let that=this;
		let cb=function(){that.populateSection(sectionId);};
		crfData.setData(crfData.getCrfRefForData(),cb);

  	} else {
    		x.style.display = "none";
		   crfHTML.getElement(buttonName).value="Show";

  	}
}

crfVisit.generateButton=
function(divName,caption,label,callbackLabel,callback=null){
	this.print("generateButtonX");
	
	let tb=crfHTML.createTable(divName);
	tb.className="t2";
	
	let r1=tb.insertRow();
   let th=crfHTML.createTblHeader(null,r1);
	th.innerHTML=caption;
	//*!*
	let c2=r1.insertCell();
	let i1=crfHTML.createButton(null,c2);
	i1.value=label;
	i1.style.fontSize="20px";
   let that=this;
   if (callback)
      i1.onclick=callback;
   else
	   i1.onclick=function(){that[callbackLabel]();};
	i1.id='button_'+callbackLabel;

	let c1=r1.insertCell();
	c1.setAttribute("colspan","1");
	//this is only for saveReview?
	c1.id=divName+'_reportField';
	//c1.id=config.submitReportId;
	
}

crfVisit.generateSubQuery=
function(input, setup, readonlyFlag){
	let fName="[generateSubQuery]";
	if (setup.isReview) return;

	if (!(setup.queryName in crfSetup.getAdditionalDataObject())){
		this.print(fName+': no additionalData entry (probably a subquery)');
		return;
	}

	let additionalData=crfSetup.getAdditionalData(setup.queryName);
	if (!("showFlag" in additionalData))
		return;

	this.print(fName);
		
	let expId=setup.getInputId(additionalData.showFlag);
	if (expId!=input.id) {
		this.print(fName+": ignoring field "+input.id+"/"+expId);
		return;
	}

	this.print(fName+": Setting onChange to "+input.id);
	if (readonlyFlag)
      return;

   let that=this;
	input.onchange=function(){that.setListVisibility(input,setup,readonlyFlag)};
}


//>>populate fields
//
//
//split to field generation and field population
//
crfVisit.addFieldRow=
function(tb,field,setup,additionalData){

	let fName="[addFieldRow/"+setup.queryName+':'+field.name+']';

	let vName=field.name;
	let vType=field.type;
	let isLookup=("lookup" in field);
	this.print(fName+": ["+vName+"/"+vType+'/'+isLookup+"]");

	let row=tb.insertRow();
	let cell=crfHTML.createTblHeader(null,row);
   cell.style.width='300px';
	
	let text = crfHTML.createTextNode(field.shortCaption,null,cell);
		
	
	let input=null;
   let colSpan="3";
	let cell1=row.insertCell();
	cell1.colSpan=colSpan;
	let readonlyFlag=setup.readonlyFlag(vName);


	//set the html input object
	while (1){

		if (readonlyFlag){
         input=crfHTML.createLabel('Loading',null,cell1);
			break;
		}
	

		//lookup
		if (isLookup){
	      let lookup=field["lookup"];
	      //get all values from config.formConfig.lookup[X]
	      let lObject=crfData.getLookup(lookup.queryName);
         input = crfHTML.createSelect(lObject.LUT,null,cell1);
			break;
		}

		//date
	   if (vType=="date"){
         input = crfHTML.createDate(null,cell1);
			break;
		}

		//string
		if (vType=="string"){
			//we have to make sure UNDEF is carried to below
			//since we are adapting file to either show
			//current file or allow user to select a file
			//
			//TODO change this so one can always select file
			//but also show the selected file

			if(vName.search("reviewComment")>-1){
				input = crfHTML.createTextArea(null,cell1);
				input.cols="65";
				input.rows="5";
				break;
			}

			input=crfHTML.createTextInput(null,cell1);
			
			if (vName.search('_file_')<0) break;
			cell1.setAttribute('colspan',"1");
			let cell2=row.insertCell();
			cell2.setAttribute('colspan',"2");
			let input1=crfHTML.createFileInput(null,cell2);
			input1.id=setup.getInputId(vName)+'_file_';
			break;
				
		}


		if (vType=="float"){
			input = crfHTML.createTextInput(null,cell1);
			break;
		}	
		
		
		if (vType=="boolean"){
			input = crfHTML.createCheckbox(null,cell1);
			this.print("Creating checkbox");
			break;
		}
		break;
	}
	
   input.id=setup.getInputId(vName);
   this.print(fName+': adding element '+input.id);
   this.print(fName+': listing element '+crfHTML.getElement(input.id));
	

	//connect associated list
	this.generateSubQuery(input,setup,readonlyFlag);	

	if (readonlyFlag) {
		this.print(fName+': exiting(readonlyFlag)');
		return;
	}
	
}

crfVisit.addSpecialFieldRows=
function(tb,field,specFieldSetup,setup){
   //tb is the table, specFieldSetup is a row from the table where special fields are being setup
   //the first column is fieldUID, which is a colon joined amalgation of queryName:fieldName
   let fieldUID=specFieldSetup["fieldUID"];
   let x=fieldUID.split(':');
   let fieldName=x[1];
   let fName="[addSpecialFieldRow/"+fieldUID+"]";
   let q=variableList.parseVariables(specFieldSetup['actionParameters']);
   this.print(fName);
   let type=specFieldSetup['actionType'];
   this.print(fName+' type '+type);
   if (type=='textArea' || type=="textAreaFromVariableDefinition"){
      let row=tb.insertRow();
      let cell1=row.insertCell();
      cell1.colSpan="4";
      cell1.style.textAlign="justify";
      cell1.style.padding="10px";
      cell1.style.backgroundColor="#e0e0e0";
      cell1.innerText=q['description'];
      if (type!='textAreaFromVariableDefinition') return;
      let varName=q['varName'];
      //get the value. But sometimes and particularly in this case, there are two rows for the same query
      //one should rely on formSetup variable definition
      let value=setup.setVariables[varName];
      let code=q['pattern'];
      code=code.replace(varName,value);
      this.print(fName+' using ['+varName+'] '+value+' pattern '+q['pattern']+' code '+code);
      cell1.innerText=q[code];
   
   }
   //copyCrfEntry in populateSpecialField
   if (specFieldSetup['actionType']=='generationObject'){
      //only in EDIT mode!!
      let ro=setup.readonlyFlag(fieldName);
      if (ro) return;
      generateRegistration.set(this);
      q['setup']=setup;
      let gc=generateRegistration.getObject(q,setup.getInputId(fieldName));
      let that=this;
      let action=function(){that.doNothing();};
      if ('mailRecipient' in q){
         gc.callback=function(data){that.sendEmail(data,q['mailRecipient'],action,q['subject']);};
      }
      else 
         gc.callback=function(data){that.doNothing();};
      if ("addData" in q){
         vars=q["addData"].split(',');
         gc.addData=new Array();
         for (let v in vars){
            let s=vars[v]
            //variable name can be written as A/B where A is the name in addData and B is the variable name in crfEntry
            //useful for mocking up crfId from daughter crf-s such as registration
            let sArray=s.split('/');
            let sTarget=sArray[0];
            let sSource=sArray[sArray.length-1];
            gc.addData[sTarget]=crfData.getCrfEntry()[sSource];
            this.print(fName+" addData ["+sTarget+"]: "+gc.addData[sTarget]);
         }
      }
      let row=tb.insertRow();
      let cell=crfHTML.createTblHeader(null,row);
      crfHTML.createTextNode("Automatic ID generator",null,cell);
      let cell1=row.insertCell();
      cell1.colSpan="3";
      let b=crfHTML.createButton(null,cell1);
      b.id="generateIdButton";
      b.onclick=function(){generateRegistration.execute(gc);};
      b.value="Generate ID";

   }
   if (specFieldSetup['actionType']=='multiChoiceButtonRow'){
      //need all options for the field
      if (!("lookup" in field)) {
         this.print(fieldUID+" only enabled for lookup fields");
         return;
      }
	   let lookup=field["lookup"];
      let lObject=crfData.getLookup(lookup.queryName);
      let row=tb.insertRow();
      let cell=crfHTML.createTblHeader(null,row);
      crfHTML.createTextNode("All options",null,cell);
      let cell1=row.insertCell();
      cell1.colSpan="3";
      for (let x in lObject.LUT){
         let b=crfHTML.createButton(null,cell1);
         b.id=fieldUID+':'+x;
         b.value=lObject.LUT[x];
         input=crfHTML.getElement(setup.getInputId(field.name));
         b.onclick=function(){crfHTML.updateSelect(input,cell1,x,b.value);}
      }
      

   }
}

crfVisit.populateFieldRow=		
function(entry,field,setup){
	this.populateField(entry,field,setup);
	this.populateSubQuery(entry,field,setup);
   this.populateSpecialFields(entry,field,setup);
}

crfVisit.populateSubQuery=
function(entry,field,setup){
	let fName='[populateSubQuery/'+setup.queryName+':'+field.name+']';
	if (setup.isReview) return;
	
	if (!(setup.queryName in crfSetup.getAdditionalDataObject())){
		let msg=fName+': no additionalData entry for '+setup.queryName;
		msg+=' (probably a subquery)';
		this.print(msg);
		return;
	}
	//find if field is connected to a sub array
	//find queryName
	//
	let additionalData=crfSetup.getAdditionalData(setup.queryName);
	this.print(fName);
	//let flag=additionalData.showFlag;
	
	if (!("showFlag" in additionalData)) return;
	let eId=setup.getInputId(additionalData.showFlag);
	let id=setup.getInputId(field.name);
	
	if (eId!=id) {
		this.print(fName+": ignoring field "+id+"/"+eId);
		return;
	}
	
	this.print(fName+': id '+id);
	//hard to estimate readonlyFlag
	//
	let input=crfHTML.getElement(id);
	let eType=input.nodeName.toLowerCase();
	let readonlyFlag=eType!="select";
	this.setListVisibility(input,setup,readonlyFlag);

}

crfVisit.clearField=
function(field,setup){
   let foo=new Object();
   this.populateField(foo,field,setup);
}

crfVisit.populateField=
function(entry,field,setup){

	let vName=field.name;
	let fName='[populateFieldName/'+vName+']';

	let varValue="UNDEF";

	//if (vName in setup.filters) varValue=setup.filters[vName];
	if (vName in entry) varValue=entry[vName];
	//if part of the filter, set it to value
	if (vName in setup.filters) varValue=setup.filters[vName];
	
	let isLookup=("lookup" in field);
	
	this.print(fName+' v='+varValue+'/'+isLookup+' ['+
		setup.getInputId(field.name)+']');
	
	let vType=field.type;
	let id=setup.getInputId(vName);
	let input=crfHTML.getElement(id);

		
	//date
	if (vType=="date"){
		if (varValue=="UNDEF") varValue=new Date();
		else varValue=new Date(varValue);
	}
	
	//lookup for readonly
	if (isLookup && varValue!="UNDEF"){
		let lookup=field["lookup"];
		//get all values from config.formConfig.lookup[X]
		let lObject=crfData.getLookup(lookup.queryName);
		varValue=lObject.LUT[varValue];
	}

	this.print('Element: '+id+'/'+input);
	//figure out the element type
	let eType=input.nodeName.toLowerCase();
	this.print('Element type: '+eType);

	//change varValue for printing
	if (varValue=="UNDEF") varValue="";
	//HTMLTextArea, createElement(textArea)
	if (eType==="textarea"){
		input.value=varValue;
		return;
	}
	//Text, createTextNode
	if (eType==="#text"){
		input.nodeValue=varValue;
		return;
	}
	//HTMLLabelElement, createElement('label')
	if (eType==="label"){
		input.innerText=varValue;
		return;
	}

	//HTMLSelectElement, createElement('select')
	if (eType==="select"){
		input.selectedIndex=0;
		for (let i=0;i<input.options.length;i++){
			let v=input.options[i].text;
			if (v!=varValue) continue;
			input.selectedIndex=i;
			break;
		}
		return;
	}

	if (eType!="input"){
		this.print('Unknown type: '+eType+' encountered, igonring');
		return;
	}
	
	//HTMLInputElement
	let type=input.type;

	if (type=="date"){
		input.valueAsDate=varValue;
		return;
	}
	//string,float
	if (type=="text"){
		input.value=varValue;
		return;
	}
	//boolean
	if (type=="checkbox"){
		input.checked=varValue;
		return;
	}
	this.print('Unknown input type: '+type+'. Ignoring.');
}

crfVisit.populateSpecialFields=
function(entry,field,setup){
   let fName='[populateSpecialFields]';

   let fieldUID=setup.queryName+':'+field.name;
   let specialFields=crfSetup.getEntryMap('specialFields:fieldUID');

   if (!(fieldUID in specialFields)) return;

   let specFieldSetup=specialFields[fieldUID];
   //q is not used by copyCrfEntry, keeping it here for future reference
   let q=variableList.parseVariables(specFieldSetup['actionParameters']);
   let type=specFieldSetup['actionType'];
   if (type=='copyCrfEntry'){
      let el=crfHTML.getElement(setup.getInputId(field.name));
      let varName=field.name;
      if ("varName" in q)  varName=q["varName"];
      let id=crfData.getCrfEntry()[varName];
      el.value=id;
      this.print(fName+' specialFields ['+field.name+'] '+id+'/'+el.value);
   }


}

crfVisit.populateTable=
function(listName,writeMode,setup){
//function populateTable(formSetupEntry){
	//let listName=config.formConfig.queryMap[formSetupEntry['queryName']];
	//let accessMode=config.formConfig.operator+'Mode';
	//let writeMode=formSetupEntry[accessMode]=='EDIT';

	let fName='[populateTable/'+listName+']';

   //should contain formSetup key
   

	
	//data snapshot
	let fQuery=crfData.getQuerySnapshot(listName);
   let queryLayout=crfData.getQueryLayout(listName);

	//here I assume that listName was parsed during setDataLayout and setData 
	//so that rows was set (even if they are empty)
	this.print(fName+"]: nrows "+fQuery.rows.length);
	
	let entry=this.selectEntry(fQuery.rows,setup);
	
   if (!entry) entry=new Object();
	let fields=queryLayout.fields;
		
	for (f in fields){	
		let field=fields[f];
		//each field is a new row
		this.print(fName+": Adding field: "+f+'/'+field.name+' hidden: '+field.hidden+' type:'+field.type);
		if (field.hidden) continue;
		if (field.name=="crfRef") continue;
      if (field.name in setup.setVariables) continue;
		this.populateFieldRow(entry,field,setup);
		
	}

}

crfVisit.generateTable=
function(listName,divName,additionalData,setup){
	let fName="[generateTable/"+listName+"]";	
	this.print(fName);

	//is listName and setup.queryName a duplicate of the same value
	this.print(fName+': setup.queryName '+setup.queryName);	
	//assume data is set in config.formConfig.dataQueries[data.queryName].rows;
   let populateData=true;
   if ("subTable" in setup){
      this.print(fName+" is subTable");
      populateData=false;
   }

	let entry=new Object();



	//data snapshot
	let fQuerySnapshot=crfData.getQuerySnapshot(listName);
   let queryLayout=crfData.getQueryLayout(listName);
	//here I assume that listName was parsed during setDataLayout and setData 
	//so that rows was set (even if they are empty)
	this.print(fName+": Nrows "+fQuerySnapshot.rows.length);
	
	if (fQuerySnapshot.rows.length>0)
		entry=fQuerySnapshot.rows[0];

   
   if ("reviewTable" in setup){
      entry['reviewComment']='';
      delete entry["ModifiedBy"];
   }
	
	let tb=crfHTML.createTable(divName);
	tb.className="t2";

	//this are the fields (probably constant)
	let fields=queryLayout.fields;
		
	for (f in fields){
		let field=fields[f];
      let fieldUID=listName+":"+field.name;
		//each field is a new row
		this.print(fName+": Adding field: "+f+'/'+field.name+' ('+fieldUID+').');
      //unique name
		if (field.hidden) continue;
		if (field.name=="crfRef") continue;
      if (field.name in setup.setVariables) continue;
		this.addFieldRow(tb,field,setup,additionalData);
		if (populateData) this.populateFieldRow(entry,field,setup);
      let specialFields=crfSetup.getEntryMap('specialFields:fieldUID');
      if (fieldUID in specialFields){
         let specFieldSetup=specialFields[fieldUID];
         this.addSpecialFieldRows(tb,field,specFieldSetup,setup);
      }

		
	}
   //finish of if apply button is not required
	if (!("addApply" in setup)) {
		this.print(fName+"populateTable: done");
		return;
	}
	
	let row=tb.insertRow();

	let th=crfHTML.createTblHeader(null,row);
	th.innerHTML=setup.addApply; 
	let cell=row.insertCell();
	//cell.setAttribute("colspan","2");
	let input=crfHTML.createButton(null,cell);
	input.value=setup.addApply;
	let cell1=row.insertCell();
	cell1.setAttribute("colspan","2");
	cell1.id=setup.getInputId("rerviewLastSave");
	cell1.innerHTML="No recent update";
	//saveReview is a generic name for saving content of the html page to a list entry
   let that=this;
	input.onclick=function(){that.saveReview(listName,cell1.id,setup)};
}	

crfVisit.setEntryFromElement=
function(entry,elementId, field){
   //set value to entry from element using representation (field) from labkey
   //
   //
   
   let fName='setEntryFromElement';

   let el=crfHTML.getElement(elementId);
				
   if (!el) {
      this.print(fName+" element: "+elementId+" not found");
      return;
   }
   this.print(fName+" element: "+elementId);
      

   let vName=field.name;
   let vType=field.type;

   let eType=el.nodeName.toLowerCase();

   if (eType==="select"){
      entry[vName]=el.options[el.selectedIndex].value;
      return;
   }

   if (eType==="td"){
      entry[vName]=el.innerText;
      return;
   }
   
   if (vType=="date"){
      let date=el.valueAsDate;
      if (!date) return;

      date.setUTCHours(12);
      entry[vName]=date.toString();
      this.print(fName+" setting date to "+entry[vName]);
      return;
   }

   if (vType=="string"){
      entry[vName]=el.value;
      
      if (vName.search('_file_')<0) 
         return;
      
      //upload file
      let id1=elementId+'_file_';
      let input1=crfHTML.getElement(id1);
      this.print(fName+' attachment field: '+input1.value);
      //entry[vName]=el.files[0].stream();
      let ctx=new Object();
      ctx['dirName']='consent';
      ctx['ID']=entry['crfRef'];
      //should point to data container
      ctx['project']=getContainer('data');
      //need ID->crf!
      //assume crfRef will get set before this
      //element is encountered
      this.uploadFile(input1,ctx);
      let fv=el.value;
      let suf=fv.split('.').pop();
      entry[vName]=entry['crfRef']+'.'+suf;
      return;
      
   }	
   if (vType=="float" || vType=="int"){
      entry[vName]=el.value;
      
      if (vName=="queryName") {
         this.print(fName+' parsing queryName: '+el.innerText);
         let qMapInverse=crfSetup.invertMap(crfSetup.getMap('inputLists'));
         entry[vName]=qMapInverse[el.innerText];
         //use queryMap lookup
      }
      return;
   }	
   if (vType=="boolean"){
      entry[vName]=el.checked;
      return;
	}
   return;
}

crfVisit.selectEntry=
function(fRows,setup){
   let fName='[selectEntry]';

   if (!("unique" in setup)) return null;
   if (fRows.length==0) return null;

   keys=Object.keys(setup.setVariables);
   
   if (keys.length==0)
      return fRows[0];
   
   for (let i=0;i<fRows.length;i++){
      for (let v in setup.setVariables){
         this.print(fName+' row '+i+' ['+v+'] '+fRows[i][v]+'/'+setup.setVariables[v]);
         if (fRows[i][v]==setup.setVariables[v]){
            this.print(fName+' using '+i);
            return fRows[i];
         }
      }
   }
   return null;

}

crfVisit.saveReview=
function(queryName,elementId,setup){
	//loads any queryName

   let fName='[saveReview/'+queryName+']';
	this.print(fName+" elementId "+elementId);


   let unique=("unique" in setup);
	
   //data snapshot
	let fQuerySnapshot=crfData.getQuerySnapshot(queryName);
   let nRows=fQuerySnapshot.rows.length;
   
   //data layout 
	let queryLayout=crfData.getQueryLayout(queryName);

   //determine mode based on entry uniqueness and presence of data
   let entry=this.selectEntry(fQuerySnapshot.rows,setup);
   let mode='update';

   if (!entry){
      entry=new Object();
      mode='insert';
   }
   this.print(fName+' unique '+unique+' mode '+mode+' nRows '+nRows);

	entry.crfRef=this.getCrfRefData();

	this.print(fName+" set crfRef="+entry.crfRef);


	let fields=queryLayout.fields;
	for (f in fields){

		let field=fields[f];
		this.print(fName+" saveReview field: "+field.name);
		if (field.hidden) continue;
      if (field.name in setup.setVariables){
         entry[field.name]=setup.setVariables[field.name];
         continue;
      }
		
		let vName=field.name;
		let vType=field.type;

		this.print(fName+" vType: "+vType);
		
		if (vName=="crfRef") continue;
		//need to save queryName for reviewComments
		
		let eId=setup.getInputId(vName);
      //copy values from form to entry
      this.setEntryFromElement(entry,eId,field,setup);

      //clear field value
      if (!unique) this.clearField(field,setup);

	}
   let that=this;
	let updateFlag=function(data){that.updateLastSavedFlag(data,setup,elementId)};
   let cPath=crfSetup.getContainer('data');
   
   let action=updateFlag;
   if (crfSetup.getSettings("updateRegistration")){
      let pars=variableList.parseVariables(crfSetup.getSettings("updateRegistration"));
      if (pars['query']==queryName){
         action=function(data){that.updateRegistration(updateFlag,data);}
      } 
   }

   runQuery.modifyRows(mode,'lists',queryName,[entry],action,cPath);

}

crfVisit.updateLastSavedFlag=
function(data,setup,elementId){
   let fName='[updateLastSavedFlag]';
   this.print(fName+" update last saved flag to "+elementId);
	let el=crfHTML.getElement(elementId);
	let dt=new Date();
	el.innerHTML="Last saved "+dt.toString();
	if (data.queryName=="reviewComments"){
		this.updateListDisplay(setup.divReviewListId,"reviewComments",setup.filters,true);
	}	
	//refresh stored data!
	let writeMode=!setup.readonlyFlag();
   let that=this;
   let cb=function(){that.populateTable(data.queryName,writeMode,setup);};
	if ("unique" in setup)
		crfData.setData(crfData.getCrfRefForData(),cb);
	if ("masterQuery" in setup){
		let ad=crfSetup.getAdditionalData(setup.masterQuery);
		this.print('Updating list display: '+setup.queryName+'/'+ad.queryName);
		this.updateListDisplay(ad.divQueryName,ad.queryName,ad.filters,false);
   }
}

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//generic form status switch statementes

crfVisit.changeFormStatusAndNotify=
function(actionName){
   let fName='[changeStatusAndNotify]';
   this.print(fName);
   let targetStatus=crfSetup.getTargetStatus(actionName);
   let targetRecipient=crfSetup.getTargetRecipient(actionName);
   let actionSettings=crfSetup.getActionSettings(actionName);
   let action=new Object();
   action.name=actionName;

   let finalStep=function(){that.redirect();};
	if (variableList.hasVariable(actionSettings,"finalStep")){
      this.print(fName+' adjusting finalStep');
		//set to doNothing to remain on submit window
		if (actionSettings.finalStep=="doNothing"){
			finalStep=function(){that.doNothing();};
		}
	}
   this.print(fName+' action '+actionName+' targetStatus '+targetStatus);
   let that=this;	
   action.cb=function(data){that.sendEmail(data,targetRecipient,finalStep,actionName);}
   this.updateFlag(targetStatus,action);//Approved
}

crfVisit.updateFlag=
function(flag,action){
	let fName='[updateFlag]';

	let entry=crfData.getCrfEntry();
	entry.FormStatus=flag;
	let uId=LABKEY.Security.currentUser.id;
	entry[this.role]=uId;

	this.print(fName+': Form: '+entry.Form);
	this.print(fName+": set form status to "+entry.FormStatus);

   let that=this;	
	let cb=function(data){that.completeWithFlag(data,action);};
   runQuery.modifyRows('update','lists','crfEntry',[entry],cb,crfSetup.getContainer('data'));
		
}


crfVisit.completeWithFlag=
function(data,action){
	let fName='[completeWithFlag]';
	this.print(fName+': nrows '+data.rows.length);

	let fentry=data.rows[0];
	this.print(fName+': form status '+fentry.FormStatus);
	this.print(fName+': form '+fentry.Form);

	let crfStatus=crfData.createCrfStatus(fentry);
	crfStatus.operator=this.role;
	crfStatus.action=action.name;
   let that=this;
   let cb=function(){that.doNothing();};
   if (action.cb) cb=action.cb;

   runQuery.insertRows('lists','crfStatus',[crfStatus],cb,crfSetup.getContainer('data'));

}

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

crfVisit.onDatabaseUpload=
function(){
   let actionName='onDatabaseUpload';
	let fName='['+actionName+']';
	this.print(fName);
   let pM=this.getIdManager();
   let participantId=participantIdManager.getParticipantIdFromCrfEntry('STUDY');
  
   let that=this;
   let crfRefForData=crfData.getCrfRefForData();
   
   //load lists and study data
   //check what needs to be updated and upload
   //a (reverse) sequence of functions
   let completeUpload=function(){that.changeFormStatusAndNotify(actionName);};
   let uploadData=function(){crfData.uploadData(participantId,crfRefForData,completeUpload);};
   let loadStudy=function(){crfData.setData(crfRefForData,uploadData,'study');}
   crfData.setData(crfRefForData,loadStudy,'lists');
}


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

crfVisit.onUpdateForReview=
function(){
   let actionName='onUpdateForReview';
   this.changeFormStatusAndNotify(actionName);
}

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

crfVisit.onSubmit=
function(){
	//update list storage and change status

	this.hideErr();
	this.clearErr();
	this.printErr("onSubmit");
   let that=this;
   let actionName='onSubmit';
   let action=function(){that.verifyData(actionName);};
	crfData.setData(crfData.getCrfRefForData(),action);
	


}

crfVisit.verifyData=
function(actionName){
	let fName='[verifyData/'+actionName+']';
   let qList=crfData.getActiveQueries();
   let that=this;
   let doNothing=function(data){that.doNothing();};

   let pM=this.getIdManager();
   let fieldName=pM.getCrfEntryFieldName(pM.getMode());
   let setId=crfData.getCrfEntry()[fieldName];

   this.print(fName+' crfEntry ['+fieldName+'] '+crfData.getCrfEntry()[fieldName]);
   
   if (!setId){
      this.printErr('Missing ID !');
      return false;
   }

	for (let qId in qList){
      let entry=qList[qId];
      let q=entry['queryName'];
		let qData=crfData.getQuerySnapshot(q);
		if (q=="reviewComments") continue;
		//copy snapshot to history
      if (qData.rows.length==0){
         this.print(fName+' no rows for '+q);
      }
      else
		   runQuery.insertRows('lists',q+'History',qData.rows,doNothing,this.getContainer('data'));
		//if it doesn't have additionalData, it is a sub query
		if (!(q in crfSetup.getAdditionalDataObject())){
			continue;
		}
		if (qData.rows.length<1){
			this.printErr('Missing entry for query '+q);
			return false;
		}
	}
	//this is necessary only for Generated to Generation completed step
	//let actionSettings=crfSetup.getActionSettings(actionName);	
	//if (variableList.hasVariable(actionSettings,"updateRegistration")){
      //if updateRegistrationFormId is set, only update when submit is used on that form
     // if (variableList.hasVariable(actionSettings,"updateRegistrationFormId")){
       //  let formId=crfData.getCrfEntry()['Form'];
         //if (actionSettings['updateRegistrationFormId']==formId)
           // this.updateRegistration();
      //}
      //else
		  // this.updateRegistration();
	//}
   this.changeFormStatusAndNotify(actionName);

}

crfVisit.getEmail=
function(recipientCode){

	this.print('getEmail w/'+recipientCode);
	let recipients=new Array();
	let typeTo=LABKEY.Message.recipientType.to;
	let create=LABKEY.Message.createRecipient;
   let userMap=crfSetup.getEntryMap('users');
	let currentUser=userMap[LABKEY.Security.currentUser.id];
	let currentSite=this.siteEntry;
	let formCreator=userMap[crfData.getCrfEntry()['UserId']];


	let userRows=crfSetup.getRows('users');
	let parentUser=null;
   if ("parentCrfData" in crfSetup){
		let parentCrf=crfSetup.getRows('parentCrfData');
		parentUser=userMap[parentCrf[0].UserId];
	}
	

	let recipientCategories=recipientCode.split(',');
	for (let i=0;i<recipientCategories.length;i++){

		let recipient=recipientCategories[i];
		this.print('Checking '+recipient);
		if (recipient=='crfEditor'){
			this.print('Adding :'+formCreator.Email);
			recipients.push(create(typeTo,formCreator.Email));
			if (!parentUser) continue;
			this.print('Adding :'+parentUser.Email);
			recipients.push(create(typeTo,parentUser.Email));
			continue;
		}
		//Monitor or Sponsor
		let fList=recipient+'s';
		let fRows=crfSetup.getRows(fList);
		for (let i=0;i<fRows.length;i++){
			this.print('Checking '+fRows[i].User+'/'+fRows[i].Site);
			if (fRows[i].Site!=currentSite.siteNumber) continue;
         let targetUser=userMap[fRows[i].User];
         if (!targetUser) continue;
			recipients.push(create(typeTo,targetUser.Email));
		}
	}

	return recipients;
}

crfVisit.sendEmail=
function(data,recipient='crfEditor',cb=null,subj='Form submitted'){

	this.print('sendEmail; recipient: '+recipient);
   let that=this;

   if (!cb)
      cb=function(){that.redirect();};

   let cvar='sendEmail';
	let cval=crfSetup.getSettings(cvar);
	if (cval){

		this.print(cvar+' set to '+cval);
		if (cval=='FALSE'){
			this.print('Skipping sending emails');
			cb();
			return;
		}
	}
	if (recipient==null){
      this.print('Skipping sending emails w/ no recipients');
      cb();
      return;
   }


	this.print('send email '+data.rows.length);
	let crf=data.rows[0]['entryId'];
	let formId=data.rows[0]['Form'];
	let link=LABKEY.ActionURL.getBaseURL();
	link+=LABKEY.ActionURL.getContainer();
	link+='/crf_tecant-visit.view?';
	link+='entryId='+crf;
	link+='&formId='+formId;
	link+='&role='+recipient;

	//debug
	let recipients=this.getEmail(recipient);
	//from crfManagers list
	
	let typeHtml=LABKEY.Message.msgType.html;
	let typePlain=LABKEY.Message.msgType.plain;
	let msg1=LABKEY.Message.createMsgContent(typePlain,link);

	//let cb=doNothing;
	//let cb=redirect;
	LABKEY.Message.sendMessage({
		msgFrom:'labkey@fmf.uni-lj.si',
		msgSubject:subj,
		msgRecipients:recipients,
		msgContent:[msg1],
		success: cb
	});

}

crfVisit.hideErr=
function(){
	let el=crfHTML.getElement("errorDiv");
	el.style.display="none";
}

crfVisit.clearErr=
function(){
	let el=crfHTML.getElement("errorTxt");
	el.value="";
}

crfVisit.showErr=
function(){
	let el=crfHTML.getElement("errorDiv");
	el.style.display="block";
}

crfVisit.printErr=
function(msg){
	this.showErr();
	el=crfHTML.getElement("errorTxt");
	el.style.color="red";
	el.value+="\n"+msg;
}


//**************************************************
//
crfVisit.onRemoveCRF=
function(){
   let fName='[onRemoveCRF]';
   let crfRef=this.crfRef;
   let crfRefForData=crfData.getCrfRefForData();
   this.print(fName+' starting loop');
   let actionName='onRemoveCRF';
   let that=this;
   let notify=function(){that.changeFormStatusAndNotify(actionName);};
   //let removeCrfEntry=function(){crfData.removeCrfEntry(notify);}; 
   let removeData=function(){crfData.removeData(notify);};
   let setStudyData=function(){crfData.setData(crfRefForData,removeData,'study');};
   let action=setStudyData;
   let actionSettings=crfSetup.getActionSettings(actionName);
   if (variableList.hasVariable(actionSettings,'removeWithParentCrf')){
      //if some query needs to be deleted with parent crf, insert this as an intermediate action
      let q=actionSettings['removeWithParentCrf'];
      let parentCrf=crfData.getCrfEntry()['parentCrf'];
      if (parentCrf){
         let setParentStudyData=function(){crfData.setDataForQuery(q,parentCrf,removeData,'study');};
         let setStudyData1=function(){crfData.setData(crfRef,setParentStudyData);}
         action=function(){crfData.setDataForQuery(q,parentCrf,setStudyData1);};
      }
   }
   crfData.setData(crfRefForData,action);
}


crfVisit.redirect=
function(){
	let formUrl="participantPortal";
	let params=new Object();
	params.name=formUrl;
   params.role=this.role;
   let crfEntry=crfData.getCrfEntry();
   params.site=crfEntry['Site'];
   let participantLabel=crfSetup.getParticipantLabel(crfEntry);
   params['participantLabel']=participantLabel;

	//params.pageId="CRF";

	//points to crf container
	let containerPath=crfSetup.getContainer('CRF');
        
	// This changes the page after building the URL. 
	//Note that the wiki page destination name is set in params.
        
	//let homeURL = LABKEY.ActionURL.buildURL("project", formUrl , containerPath, params);
	let homeURL = LABKEY.ActionURL.buildURL("crf", formUrl , containerPath, params);
   this.print("Redirecting to "+homeURL);
	window.location = homeURL;

}

//master section, entry point from html files
crfVisit.generateMasterForm=
function(){
   let that=this;
   let action=function(){that.setFormConfig();}
   this.init(action);
}


//helper function to set basic parameters on web page 
//(fields defined in html file)
crfVisit.populateBasicData=
function(){

   let staticData=new Object();
   let titles=new Object();
   staticData['version']='0.16.3'	
   titles['version']='Software version';
   let varRows=crfSetup.getRows('crfStaticVariables');
   for (let i=0;i<varRows.length;i++){
      let vName=varRows[i].staticVariable;
      let val=crfData.getCrfEntry()[vName];
      if (val==undefined) continue;
      staticData[vName]=val;
      titles[vName]=varRows[i].Title;
   }
	staticData['investigatorName']=this.userEntry['DisplayName'];
   titles['investigatorName']='Investigator';
   staticData['email']=this.userEntry['Email'];
   titles['email']='Email';
   staticData['siteName']=this.siteEntry['siteName'];
   titles['siteName']='Site';
   staticData['sitePhone']=this.siteEntry['sitePhone'];
   titles['sitePhone']='Telephone(site)';

   for (f in staticData){
      this.addStaticData(f,titles[f],staticData[f]);
   }
   let formId=crfData.getCrfEntry()['Form'];
   let formEntry=crfSetup.getEntryMap('dataForms')[formId];
   crfHTML.getElement('formTitle').innerText=formEntry['formName'];
}

crfVisit.addStaticData=
function(f,title,value){
   let el=crfHTML.getElement(f);

   //populate only
   if (el!=undefined){
      el.innerText=value;
      return;
   }
   
   //add row to table if element cannot be found
   let table=crfHTML.getElement('staticTable');
   let row=table.insertRow();
   let cell=row.insertCell();
   cell.innerText=title;
   let cell1=row.insertCell();
   cell1.id=f;
   cell1.style.fontWeight='bold';

   //populate
   cell1.innerText=value;
}

//come here after the layout is read from labkey page
//
crfVisit.generateErrorMsg=
function(msg){
	let txt=crfHTML.createParagraph(msg,this.masterForm);
	this.generateButton("submitDiv",'Exit','Exit','redirect');
}

crfVisit.checkPermissions=
function(){
	//check if user has permission on the form
   let userMap=crfSetup.getEntryMap('users');
	let currentUser=userMap[LABKEY.Security.currentUser.id];
	let currentSite=this.siteEntry;
	let formCreator=userMap[crfData.getCrfEntry()['UserId']];
	let formCreatorId=formCreator.UserId;


   //get list of sites the user can work on
	let fList=this.role+'s';
	let fRows=crfSetup.getRows(fList);
   let operatorSites=new Array();
	for (let i=0;i<fRows.length;i++){
		if (fRows[i].User!=currentUser.UserId) continue;
		operatorSites.push(fRows[i].Site);
	}
	this.print('operator Site: '+operatorSites.length);
	if (operatorSites.length==0){
      let msg='User '+currentUser.DisplayName;
      msg+=' is not a '+operator;
      this.generateErrorMsg(msg);
      return false;
   }

	
	//depending on operator mode, we should decide what is right
	let operator=this.role;
	if (this.role=='crfEditor'){
		//editor can only edit its own forms
		if (currentUser.UserId==formCreatorId){
         return true;
      }
      //here we are if UserId and formCreatorId are not equal
      let allowR=crfSetup.getSettings("allowFormReassignment");
      //form reassignment is not allowed
      if (!allowR){
         let msg='User '+currentUser.DisplayName;
         msg+=' has no permission on this form';
         this.generateErrorMsg(msg);
         return false;
      }
      //this is for allowed form reassignments
      //site should still match
      if (!operatorSites.includes(currentSite.siteNumber)){
         let msg='User '+currentUser.DisplayName;
         msg+=' has no permission for site '+currentSite.siteName;
         this.generateErrorMsg(msg);
         return false;
      }
      //re-assign form, leave a trace in crfStatus and change creator in crfEntry
      let that=this;
      let action=new Object();
      action.name="formReassignement";
      action.cb=function(){that.doNothing();}
      crfData.getCrfEntry()['UserId']=currentUser.UserId;
      let status=crfData.getCrfEntry()['FormStatus'];
      this.updateFlag(status,action);
      return true;
	}
	if (operator=='crfMonitor' || operator=='crfSponsor'){
		//monitor can look at forms based on his site
		//find monitor line
      //implementation of currentSite in operatorSites
      if (!operatorSites.includes(currentSite.siteNumber)){

			let msg='User '+currentUser.DisplayName;
			msg+=' is not a '+operator+' for site ';
			msg+=currentSite.siteName+'('+currentSite.siteNumber+')';
			msg+='/'+operatorSites.join(',');
			this.generateErrorMsg(msg);
			return false;
		}
	}


	this.print('User '+currentUser.DisplayName+'/'+
		currentSite['siteName']+
		' acting as '+this.role);	
   return true;
}

crfVisit.afterConfig=
function(){
   let fName='[afterConfig]';
	this.print(fName);	
   
	this.populateBasicData();

   if (!this.checkPermissions()) return;
   crfSetup.parseButtons();
   
   let formStatus=crfSetup.getRows('formStatus')[0]['formStatus'];

	//let functionArray=new Array();

	this.print(fName+" generating buttons for formStatus \""+ formStatus+"\"");

   let allButtonRows=crfSetup.getRows('crfButtons');
	let buttonRows=new Array();
   
   //specifying role=X in actionSettings will limit button to that role
   for (let i=0;i<allButtonRows.length;i++){
      let action=allButtonRows[i]['action'];
      //filter on actionSettings
      let as=crfSetup.getActionSettings[action];
      if (variableList.hasVariable(as,'role')){
         this.print('Role['+this.role+'/'+as['role']+'] limited for action '+action);
         //mismatch skips addition of button to buttonRows
         if (this.role!=as['role']) continue;
      }
      buttonRows.push(allButtonRows[i]);
   }



	for (let i=0;i<buttonRows.length;i++){
		let bt=buttonRows[i];
		//if (typeof window[bt.action]==="function"){
		this.generateButton("submitDiv",bt.caption,bt.label,bt.action,null);
		//}
		//else{
		//	this.print('No match for function :'+bt.action+
		//		' obj: '+window[bt.action]);
		//}
	}

	this.print(fName+' buttons generated.');


	//here we should get data. For now, just initialize objects that will hold data
   let that=this;
   let action=function(){that.afterDataLayout();};
   let formId=crfData.getCrfEntry()['Form'];
	crfData.setDataLayout(formId,this.role,action);//callback is afterDataLayout
}

crfVisit.afterDataLayout=
function(){

   let that=this;
   let action=function(){that.afterData();};
   //let action=function(){that.doNothing();};
	crfData.setData(crfData.getCrfRefForData(),action);//callback is afterData
}

crfVisit.updateRegistration=
function(cb=null,data){
   //data is just inserted/updated registration row
   
	let fName="[updateRegistration]";
	this.print(fName);
   let pM=this.getIdManager();
	let idFieldName=pM.getCrfEntryFieldName('STUDY');
	//have to reload query data
	let regEntry=data.rows[0];

	for (x in regEntry){
		this.print(fName+" ["+x+"] "+regEntry[x]);
	}


	let studyId=data.rows[0][idFieldName];
	if (!studyId) {
		this.print(fName+" study id not set ("+idFieldName+'/'+studyId+")");
		return; //study id not set
	}
	
	//set 
	pM.setParticipantIdToCrfEntry("STUDY",studyId);
   pM.updateCrfEntry();
	//this will only update crfEntry in memory, but not on LabKey, 
	//we are counting on updateFlag to follow updateRegistration

	//update parentCRF as well, here we schedule update of data entry as well
	if ("parentCrfData" in crfSetup){
		let parentCrfEntry=crfSetup.getRows('parentCrfData')[0];
		parentCrfEntry[idFieldName]=studyId;
      let that=this;
      let doNothing=function(){that.doNothing();};
      let action={name:"updateRegistration",cb:doNothing};
		let complete=function(data){that.completeWithFlag(data,action);};
      runQuery.modifyRows('update','lists','crfEntry',[parentCrfEntry],complete,crfSetup.getContainer('CRF'));
	}
   if (cb) cb(data);

}

crfVisit.afterData=
function(){
	let fName='afterData';
   this.configureIdManager();
   this.generateSections();
}


crfVisit.configureIdManager=
function(){
   let fName='[configureIdManager]';
   let idMode=this.formEntry['idMode'];
   //set default value if no value is in the list (read value is null)
   if (!idMode) idMode="STUDY:EDIT";

   this.print(fName+': idMode '+idMode);
   //add print to config so participantManager can use it
   let pM=this.getIdManager();
   //extend object
   let that=this;
   let action=new Object();
   action.name='updateCrfEntry';
   action.cb=function(){that.doNothing();};
   let formStatus=crfData.getCrfEntry()['FormStatus'];
   participantIdManager.updateCrfEntry=function(){that.updateFlag(formStatus,action);};   

   let idModeArray=idMode.split(':');
   pM.setMode("STUDY");
   if (idModeArray.includes("LOCAL")) {
      pM.setMode("LOCAL");
   }
   //OK, but check if CRF or registration indicate that study id is already set
   pM.verifyCrfStudyId();
   //still local
   if (pM.getMode()=='LOCAL'){
      if (idModeArray.includes("READONLY")){
         pM.setReadonly(pM.getMode());
         let id=pM.getParticipantIdFromCrfEntry(pM.getMode());
         pM.setLabelMode(pM.getMode(),id);
      }

      let localId=pM.getParticipantIdFromCrfEntry('LOCAL');
      if (localId) pM.setLabelMode('LOCAL',localId);
      else pM.setEditMode(pM.getMode());
      pM.setReadonly('STUDY');
      pM.setLabelMode('STUDY','NOT SET');
   }

}

crfVisit.generateSections=
function(){
	let accessMode=this.role+'Mode';
   let formId=crfData.getCrfEntry()['Form'];
   let rowsSetup=crfSetup.selectFormSetupRows(formId);
	for (let i=0;i<rowsSetup.length;i++){
		let entry=rowsSetup[i];

      //debug
		let queryName=crfSetup.getMap('inputLists')[entry['queryName']];
		this.print(fName+" ["+queryName+"]: showFlag: "+entry["showFlag"]);
		this.print(fName+" ["+queryName+"]: accessMode: "+entry[accessMode]);
		const nData=crfData.getQuerySnapshot(queryName).rows.length;
		this.print(fName+" ["+queryName+"]: nData: "+nData);

		//skip sections
		//also from fields
		if (entry[accessMode]=="NONE") continue;
			
		//section fits one dataset/list
		this.generateSection(entry);
	}

}

crfVisit.populateSection=
function(sectionId){
	let fName='[populateSection/'+sectionId+']';
	this.print(fName);

   //old setting
	let entry=crfSetup.findSetupRow(sectionId);

	//ignore names without associated entry in formSetup
	if (!entry){
		this.print(fName+': no matching FormSetup entry found');
		return;
	}
	//populate comes after generate, we should be pretty safe in taking
	//already generated additionalData
	let queryName=crfSetup.getMap('inputLists')[entry['queryName']];

	if (!(queryName in crfSetup.getAdditionalDataObject())){
		this.print(fName+': no additionalData generated for '+queryName);
		return;
	}
	
	let additionalData=crfSetup.getAdditionalData(queryName);
	this.print(fName+': using additionalData '+additionalData);
	if ("isReview" in additionalData){
      let action=function(){crfReviewSection.CB();};
		crfReviewSection.generateSection(queryName,queryName,action);
		return;	
	}

	let accessMode=this.role+'Mode';
	let aM=entry[accessMode];
	this.print(fName+': accessMode '+aM);

	if (aM!='GENERATE'){
		let writeMode=entry[accessMode]=='EDIT';
		this.print(fName+': mode='+writeMode);
      let setup=this.getStoredSetup(sectionId);
	   this.populateTable(queryName,writeMode,setup);
		return;
	}

	//deal with generate
	//
	//already available -> shift to READ mode
	let divTable=sectionId+'Table';
	let divObj=crfHTML.getElement(divTable);
	let divRev=crfHTML.getElement(sectionId+'Review');
	let divRLi=crfHTML.getElement(sectionId+'ReviewList');
	let divGBu=crfHTML.getElement(sectionId+'GenerateButton');

	this.print('div GBU: '+divGBu);
	divObj.style.display="block";
	divRev.style.display="block";
	divRLi.style.display="block";
	if (divGBu!=undefined) divGBu.style.display="none";

	let nData=crfData.getQuerySnapshot(queryName).rows.length;
   let setup=this.getSetup(sectionId,queryName,0);
	this.print('['+queryName+']: nrows '+nData);
	if (nData>0){
		this.populateTable(queryName,0,setup);
		return;
	}
	//hide table
	divObj.style.display="none";
	divRev.style.display="none";
	divRLi.style.display="none";
	if (divGBu!=undefined) divGBu.style.display="block";
	//add buttons?
	//is button already generated?
	
	//populateTable(entry);
	
}		

//*******    generateQuery infrastructure *********************

crfVisit.onGenerateQuery=
function(queryName){

   let fName='[onGenerateQuery]';
	this.print(fName+' '+queryName);
//
	let cfgRows=crfSetup.getRows('generateConfigData');
//	//queryName to queryId?
   let qMapInverse=crfSetup.invertMap(crfSetup.getMap('inputLists'));
	let queryId=qMapInverse[queryName];


	let cfgRow=crfSetup.getEntryMap('generateConfigData:queryId')[queryId];
	
   if (!cfgRow){
		this.print('generateConfig for queryName['+queryId+']='+queryName+' not found');
		return;
	}

	//let formRows=crfSetup.selectFormSetupRows(cfgRow.formId);
//
//	//check if all required datasets were at least saved
	this.checkGenerationFields(cfgRow);
}

crfVisit.checkGenerationFields=
function(entry){
   //entry is generateConfig row
   let fName='[checkGenerationFields]';
	let mailRecipient=entry.emailRecipient;
	let qMap=crfSetup.getMap('inputLists');
   let qName=qMap[entry['queryId']];
	//list of queries that are part of Registration form
	this.print(fName);	
	this.print(fName+' setRecipient: '+mailRecipient);
	let formId=entry['formId'];
	this.print(fName+" Checking form w/id "+formId);
	
   let formRows=crfSetup.selectFormSetupRows(formId);
	//registration rows
	for (let i=0;i<formRows.length;i++){
		let row=formRows[i];
		let queryId=row.queryName;
		if (queryId==entry.queryId) continue;
		let fQuery=crfData.getQuerySnapshot(qMap[queryId]);
		this.print('Checking '+qMap[queryId]+' nrows: '+fQuery.rows.length);
      //this is to check whether sufficient data was provided for monitor 
      //to make an informed decision whether registration is in order
		if (fQuery.rows.length==0){ 
			this.generateError(qName,qMap[queryId]);
			return;
		}
	}
	this.generateMessage(qName,'Vailidation OK');
   let that=this;
	let cb=function(){that.prepareForm(entry);};
	this.generateListEntry(entry.formId,qName,cb);
}


crfVisit.prepareForm=
function(entry){
   //entry is generateConfig row
   let fName="[prepareForm]";
   let formId=entry['formId'];

	//this.print(fName+' recipient '+mailRecipient);

	//look for existing registration entry
   let that=this;
	let action=function(data){that.generateForm(data,entry);};
	let formFilter=LABKEY.Filter.create('Form',formId);
	let parentCrfFilter=LABKEY.Filter.create('parentCrf',this.crfRef);
   let filters=[formFilter,parentCrfFilter];
   runQuery.selectRows('lists','crfEntry',filters,action,crfSetup.getContainer('data'));

}

crfVisit.generateError=
function(queryName,fQueryName){
	let elName=queryName+'GenerateButton'+'_reportField';
	let el=crfHTML.getElement(elName);
	el.innerText='Error: '+fQueryName+' was not set';
	el.style.color='red';
}

crfVisit.generateMessage=
function(queryName,msg){
	let elName=queryName+'GenerateButton'+'_reportField';
	let el=crfHTML.getElement(elName);
	el.innerText=msg;
	el.style.color='green';
}

crfVisit.generateForm=
function(data,entry){
   //entry is generateConfig entry
   //data is a crfEntry row

   let fName='[generateForm]';

	const nData=data.rows.length;

	let formId=entry['formId'];
   let formEntry=crfSetup.getEntryMap('dataForms')[formId];
   let formName=formEntry['formName'];
	this.print(fName+' crfEntry ('+formName+'): '+nData+' rows');

	//we have to generate masterQuery with parentCrf and crfRef 
	//and crfEntry with new entryId and parentCrf equal to crfRef
   let queryName=crfSetup.getMap('inputLists')[entry['queryId']];
	if (nData>0) {
		this.generateMessage(queryName,formName+' already generated.');
		return;
	}
   //use current crfEntry as base
   let crfBase=crfData.getCrfEntry();


   let idLabel=crfSetup.getParticipantLabel(crfBase);
   //role will appear in crfStatus and will be validated agains crfCreator entry of the form
   let roleAndSite='generate:'+crfBase.Site;

   //have to overload crfEntry
   // - parentCrf
   // - formStatus
   // - UserId (set to sponsor UserId)
   //
   // should provide mail recipient and/or modified cb
   //
   //
   let crfEntryOverload=new Object();

   //parentCrf
   crfEntryOverload.parentCrf=crfBase.entryId;

   //formStatus
	crfEntryOverload.formStatus=1;//In progress
   //checks for both field presence (if not in query, undefined) and field value (if not set, null)
   this.print(fName+' setup status: '+entry.formStatus);
   if (entry.formStatus){
      crfEntryOverload.formStatus=entry.formStatus;
   }

   //	UserId
   //find sponsor for site
	let site=crfBase.Site;
	let crfSponsors=crfSetup.getRows('crfSponsors');
	let userMap=crfSetup.getEntryMap('users');
   let sponsorId=null;
	for (let i=0;i<crfSponsors.length;i++){
		//take first matching sponsor
		if (crfSponsors[i].Site!=site) continue;
		sponsorId=crfSponsors[i].User;
		//finds first
		break;
	}
   let sponsor=userMap[sponsorId];
	this.print('Selecting '+sponsor.DisplayName+' as sponsor');
	//different user than the original form...
	//should be set to the study sponsor
	crfEntryOverload.UserId=sponsor.UserId;

   let mailRecipient=entry.mailRecipient;
   let that=this;
   let action=function(){that.doNothing();};
	let cb=function(data,_crfEntry){that.sendEmail(data,mailRecipient,action,formName+' generated');}
   formPortal.createForm(formId,roleAndSite,cb,idLabel,crfEntryOverload);
   
}

crfVisit.generateListEntry=
function(formId,queryName,cb){
	//check if registration was already generated

	let formRows=crfSetup.selectFormSetupRows(formId);

	let nData=crfData.getQuerySnapshot(queryName).rows.length;

   if (nData>0) return;


   //create new list entry
   let pM=this.getIdManager();
   

	let e2=new Object();
	e2.crfRef=this.getCrfRef();
	e2.registrationStatus=0;
	e2.submissionDate=new Date();
   let idLabel=crfSetup.getParticipantLabel(crfData.getCrfEntry());
   e2[crfSetup.getLocalIdLabel()]=crfSetup.getLocalId(idLabel);
   e2[crfSetup.getStudyIdLabel()]=crfSetup.getStudyId(idLabel);
	this.print('set values');
   e2.site=crfData.getCrfEntry()['Site'];
   runQuery.insertRows('lists',queryName,[e2],cb,crfSetup.getContainer('data'));

}
		
// ******************** end form generator (Registration) ********************

//jump to populate table/generate review, etc defined at the begining of the file

//entry point from generateMasterForm
crfVisit.setFormConfig=
function(){
   let fName="[setFormConfig]";
   let crfRef=this.crfRef;
   let that=this;
   let afterCrfEntry=function(){that.afterCrfEntry();};
   let action=function(){crfData.setCrfEntry(crfRef,afterCrfEntry);};//afterCrfEntry
   crfSetup.setContainers(action);
}

crfVisit.afterCrfEntry=
function(){
   let fName='[afterCRFEntry]';
	this.print(fName+" setting crfEntry (x) to "+crfData.getCrfEntry()["entryId"]);
	//for empty records or those with parentCrf not set, parentCrf comes up as null
	//nevertheless, with two equal signs, check against undefined also works
   crfSetup.formStatus=crfData.getCrfEntry()['FormStatus'];
   let parentCrf=crfData.getCrfEntry()['parentCrf'];
	this.print(fName+' parentCrf set to '+parentCrf);
   if (parentCrf) crfSetup.parentCrf=parentCrf;
   let that=this;
   let action=function(){that.parseSetup();};
   crfSetup.parseSetup(action);
}

crfVisit.parseSetup=
function(){

   //debug
   let fName='[parseSetup]';
   let varRows=crfSetup.getRows('crfStaticVariables');
   let studyVars=crfSetup.getRows('studyData')[0];
   for (let i=0;i<varRows.length;i++){
      let vName=varRows[i].staticVariable;
      this.print(fName+' '+vName+': '+studyVars[vName]);
   }

	//parse site
	this.siteEntry=crfSetup.getEntryMap('siteData')[crfData.getCrfEntry()['Site']];
	this.print("Setting site name to "+this.siteEntry['siteName']);
	//study
	this.print("XSetting participantField to "+studyVars["SubjectColumnName"]);
	
   //parse user
   this.userEntry=crfSetup.getEntryMap('users')[crfData.getCrfEntry()['UserId']];
	this.print("Setting user to "+this.userEntry["DisplayName"]);

	this.print('Setting operator to: '+this.role);


	
   //point formId to point to form set in crfEntry
   let formId=crfData.getCrfEntry()['Form'];
	this.formEntry=crfSetup.getEntryMap('dataForms')[formId];

	let accessModeColumn=this.role+'Status';
   let targetStatus=this.formEntry[accessModeColumn];
   let formStatus=crfData.getCrfEntry()['FormStatus'];

   this.print(fName+' comparing status '+formStatus+'/'+targetStatus);

   if (targetStatus!=formStatus){
      let statusMap=crfSetup.getEntryMap('formStatusAll');
      let targetEntry=statusMap[targetStatus];
      let actualEntry=statusMap[formStatus];
      alert('Form status ['+actualEntry.formStatus+'] not suitable to be operated by '+this.role+' targeting status ['+targetEntry.formStatus+']');
      this.redirect();
   }


   crfSetup.setAdditionalData(this.crfRef,formId);
	
	this.afterConfig();

}

crfVisit.uploadFile=
function(inputElement,context){
	//context should have ID and dirName attributes; 
	//path will be dirName/ID/fieldName_ID.suf
	//where suf is identical to localPath content picked from
	//inputElement
	this.print('uploadFile: '+inputElement.value+'/');
	if (inputElement.type=="text") return;
	this.print('uploadFile: '+inputElement.files+'/');
	this.print('uploadFile: '+inputElement.files.length+'/');
	if (inputElement.files.length>0){
		let file=inputElement.files[0];
		this.print('uploadFile: '+inputElement.value+'/'+file.size);
      webdav.uploadFile(file,context);
   }
}

crfVisit.printForm=
function(){
   crfPrint.printForm();
}