//------------------------------- global variables ----------------------------------
var scs_baseRestUrl="http://127.0.0.1/api_resources/";  
var scs_username="public_hggprofiles_activity";
var scs_userpassword="scs_action";  
var scs_user_Type=-1;
var scs_user_code="user";

//--------------------- read file buffer ------------------------
function scs_readFileAsync(fn) {
    return new Promise((resolve, reject) => {
      let reader = new FileReader();
      reader.onload = () => {
        resolve(reader.result);
      };
      reader.onerror = reject;
      reader.readAsArrayBuffer(fn);
    });
  }
  //-------------------------------- uuid -----------------------------------------
function scs_createUUID() {
  // http://www.ietf.org/rfc/rfc4122.txt
  var s = [];
  var hexDigits = "0123456789abcdef";
  for (var i = 0; i < 36; i++) {
      s[i] = hexDigits.substr(Math.floor(Math.random() * 0x10), 1);
  }
  s[14] = "4";  // bits 12-15 of the time_hi_and_version field to 0010
  s[19] = hexDigits.substr((s[19] & 0x3) | 0x8, 1);  // bits 6-7 of the clock_seq_hi_and_reserved to 01
  s[8] = s[13] = s[18] = s[23] = "-";

  var uuid = s.join("");
  uuid=uuid.toUpperCase();
  return uuid;
}
//---------------------------------------- json test ---------------------------
function scs_isEqualJsons(obj1, obj2) {
  var flag=true;
   if(Object.keys(obj1).length==Object.keys(obj2).length){
      for(key in obj1) { 
          if(obj1[key] == obj2[key]) {
              continue;
          }
          else {
              flag=false;
              break;
          }
      }
    }
  else {
      flag=false;    
    }
  return flag;
  }
  //-------------------------  select files dialog ----------------------
function scs_selectFilesDlg(){
  return new Promise(resolve => {
      let input = document.createElement('input');
      input.type = 'file';
      input.multiple = true;        

      input.onchange = () => {
          let files = Array.from(input.files);           
          resolve(files);            
      };
      input.click();
  });
}
//-------------------- scs_resolveAfter2Seconds ----------
function scs_resolveAfter2Seconds(x) {
  return new Promise(resolve => {
    setTimeout(() => {
      resolve(x);
    }, 2000);
  });
}
//----------------------------------------------------------------------------------
function scs_downloadURI(uri) {
  let link = document.createElement("a");    
  link.href = uri;
  link.click();
}
//---------------------------------------------------------------------------------
function scs_timeDifference(d, dd) {
  var minute = 60 * 1000,
      hour = minute * 60,
      day = hour * 24,
      month = day * 30,
      ms = Math.abs(d - dd);
  var months = parseInt(ms / month, 10);
      ms -= months * month;
  var days = parseInt(ms / day, 10);
      ms -= days * day;
  var hours = parseInt(ms / hour, 10);
      ms -= hours * hour;
  var minutes = parseInt(ms / minute, 10);
  return [
      months + " months",
      days + " days",
      hours + " hours",
      minutes + " minutes"
  ].join(", ");
};
//-------------------------------------------------------------------------------
function scs_timeDifferenceMinutes(d, dd) {
  var minute = 60 * 1000;     
      ms = Math.abs(d - dd);
  var minutes = parseInt(ms / minute, 10);
  return minutes;
};
//-------------------------------------------------------------------------------
function scs_isToday(){
   var today = new Date();
   localStorage.getItem("SERPO_PORTAL_datetime",datetime);  
   var tm=new Date(datetime);
   if (today.scs_getDate()===tm.getDate() &&   
       today.getMonth() === tm.getMonth() &&
       today.getFullYear()===tm.getFullYear()){
    return true;
   }
   else
   return false;   
}   
//-------------------------------------------------------------------------------------
function scs_isNowTime(){
  var today = new Date();
  datetime=localStorage.getItem("SERPO_PORTAL_datetime");  
  var tm=new Date(datetime);
  if (today.getDate()===tm.getDate() &&     
      today.getMonth() === tm.getMonth() &&
      today.getFullYear()===tm.getFullYear()){
  if (scs_timeDifferenceMinutes(today,tm)<=15){
       return true;
  }
  }
  else
  return false;   
}   
//-------------------------------------------------------------------------------------
function scs_SetTimeNow(){
  var today = new Date();
  var date = today.getFullYear()+'-'+(today.getMonth()+1)+'-'+today.getDate();
  var time = today.getHours() + ":" + today.getMinutes() + ":" + today.getSeconds();
  var dateTime = date+' '+time;
  localStorage.setItem("SERPO_PORTAL_datetime",dateTime); 
}
//---------------------------------------------------------------------------------------
function scs_resetTimeNow(){
  var today = new Date();
  var date = "1967"+'-'+(today.getMonth()+1)+'-'+today.getDate();
  var time = today.getHours() + ":" + today.getMinutes() + ":" + today.getSeconds();
  var dateTime = date+' '+time;
  localStorage.setItem("SERPO_PORTAL_datetime",dateTime); 
}
//---------------------------------------------------------------------------------------
function scs_StoreDataValue(u,p){
  localStorage.setItem("SERPO_PORTAL_user_email", u.value);
  localStorage.setItem("SERPO_PORTAL_userpassword", p.value);
  localStorage.setItem("SERPO_PORTAL_user_type","-1");  
}
//----------------------------------------------------------------------------------------
function scs_GetUserEmailValue(){
  var em=localStorage.getItem("SERPO_PORTAL_user_email");  
  return em;
}
//---------------------------------------------------------------------------------------
function scs_GetUserPasswordValue(){
  var ep=localStorage.getItem("SERPO_PORTAL_userpassword");  
  return ep;
}
//--------------------------------------------------------------------------------------
function scs_GetUserTypeValue(){
  var et=localStorage.getItem("SERPO_PORTAL_user_type");  
  return et;
}
//-------------------------------------------------------------------------------------
function scs_SetUserLastJobIdValue(job_id){
  localStorage.setItem("SERPO_PORTAL_LAST_JOB_ID",job_id);    
}
//-------------------------------------------------------------------------------------
function scs_GetUserLastJobIdValue(){
  var et=localStorage.getItem("SERPO_PORTAL_LAST_JOB_ID");  
  return et;
}
//--------------------------------------------------------------------------------------
function scs_ShowMyTopToast(mesg) {
	var x = document.getElementById("snackbar");
	if (x!=null & x!=undefined){
	  x.innerText=mesg;
	  x.className = "show";
	  setTimeout(function(){ x.className = x.className.replace("show", ""); }, 3000);
   }
}
//---------------------------------------- show login modal ----------------------------
function scs_ShowLogin(){
  localStorage.setItem("SERPO_PORTAL_user_type",'-1');  
  var loginmodal = document.getElementById('userpassloginform');
  var u = document.getElementById("user_email"); 
  var p = document.getElementById("user_pwd"); 
  u.value=localStorage.getItem("SERPO_PORTAL_user_email");
  p.value=localStorage.getItem("SERPO_PORTAL_userpassword");
  loginmodal.style.display="block";          
 }        
 //-------------------------------------------------------------------------------------
async function  scs_StoreUserNameAndPasword(){
  var u = document.getElementById("user_email"); 
  var p = document.getElementById("user_pwd");    
  var loginmodal = document.getElementById('userpassloginform');
  scs_StoreDataValue(u,p);
  scs_SetTimeNow();
  scs_username=u.value;
  scs_userpassword=p.value;  
  scs_user_Type=-1;
  loginmodal.style.display="none";  
  let json=await scs_getUserType();
  if (json!=null){
    scs_user_Type=parseInt(json.user_type);
    history.back();
   }
   else{
    if (scs_user_Type=-3){
      var secUser = document.getElementById("sectionNewUser");
      secUser.style.display="block";
      var row = fmyEditKVTableID.getRow(3); //email
      var rowData = row.getData();
      rowData.Value=document.getElementById("user_email").value; 
      
      var row = fmyEditKVTableID.getRow(5); //pasword
      var rowData = row.getData();
      rowData.Value=document.getElementById("user_pwd").value; 
      var n=fmyEditKVTableID.getDataCount();
      for (i=n-3; i<=n;i++){
        var row = fmyEditKVTableID.getRow(i); //hide erp rows      
         row.getElement().style.display = "none";
      }      
      fmyEditKVTableID.style.display="block";      
      fmyEditKVTableID.redraw();      
    }
   }
 }     

//--------------------------------------- mandatory user data---------------------------------------
function scs_newuserCheckTableInputData(){
  var ucode=document.getElementById("user_code_id").value;
  if (ucode.length<9 | ucode.includes("-")==false){
    alert(" User code not set!");
        return false
  }
  var  ret=true;
  var data=fmyEditKVTableID.getData();   
  //------------------------- mandatory all --------------------    
  for (i=0; i<data.length-4;i++){
    var rowData = data[i];      
    if (rowData.Value.length>0){
      if (rowData.Value.includes("NOT_SET")==true){
        alert(rowData.Name+" not set!");
        return false
      }

    }
  }
  //-------------------------- specific ------------
  for (i=0; i<data.length-4;i++){
    var rowData = data[i];      
    if (rowData.Value.length>0){
      //------------------- check email ------------- 
     if (rowData.Name=="User EMail"){
      if (rowData.Value.includes("@")==false){
        alert("Missing Email adsdress!");
        return false;
      }
     }
    //----------------------- check 
    //------------------- check password ------------- 
    if (rowData.Name=="User password"){
      if (rowData.Value.includes("NOT_SET")==true){
        alert("Pasword not set!");
        return false;
      }
      else
      {
      var passwd=rowData.Value;
      }
     }
  //------------------- check password ------------- 
  if (rowData.Name=="Reapeat password"){
      if (rowData.Value.includes("NOT_SET")==true){
        alert("Repeat pasword not set!");
        return false;
      }
      else{
        var rpasswd=rowData.Value;
        if (passwd!=rpasswd){
          alert("Wrong input password data");
          return false;
        }
      }
     }
    }
  }  
return ret;            
}
//-------------------------------------------------------------------------------
function scs_GetUserEditedData(){  
var updatedata=[];   
var data = fmyEditKVTableID.getData();  
var item={};  
var userid=document.getElementById("user_code_id").value;
item["USER_ID"]=userid;
for (var i=0;i<data.length;i++){
var r=data[i];    
var rn=r.Name.toUpperCase();
    if (rn.startsWith("ERP_")==true){
      if (r.Value=="NOT_SET"){
        item[rn]="";
      }
      else{
        item[rn]=r.Value;
      }          
    }
    else{
      sname=rn;
      sname=sname.replaceAll(" ","_");
      item[sname]=r.Value; 
    }        
     }                        
  updatedata.push(item);//new item 
return updatedata;//only one row
}
//----------------------------------------------------------------------------------------
async function scs_GetUserCode(){
var data=fmyEditKVTableID.getData();   
var femail='';
//-------------------------- specific ------------
for (i=0; i<data.length-4;i++){
    var rowData = data[i];      
    if (rowData.Value.length>0){
      //------------------- check email ------------- 
     if (rowData.Name=="User EMail"){
       femail=rowData.Value;
      }
     }
    }      
if (femail.length>4 & femail.includes("@")){
if (await scs_scs_GetUserCode(femail)){
  alert("Check your EMail. An user code already sent by email");  
}      
else{
  alert("Connection error.Try again");   
}
}
else
alert("Incorect eMail address!");
}
//----------------------------------------------------------------------------------------
async function scs_SubmitUserData(){
if (scs_newuserCheckTableInputData()==true){
var udata=scs_GetUserEditedData();
if (udata!=[]){    
        var userid=document.getElementById("user_code_id").value;
        if (await scs_UserRegistration(udata,userid)==true){   
           var secUser = document.getElementById("sectionNewUser");
               secUser.style.display="none";            
               fmyEditKVTableID.style.display="none";            
        scs_ShowLogin();
      }   
   }
 }
} 
 //--------------------------------- job id -----------------------------------
function scs_CreateJobID(){
  var job=document.getElementById("scs_job_id");
  var jobt=document.getElementById("JobIdText");
  var stext=job.innerHTML;
      stext=stext.toUpperCase();
      if (stext.includes("NOT ASSIGNED")){
        var uuid=scs_createUUID();
        job.innerHTML="JOB ID : "+uuid;
        jobt.value=uuid;        
      }  
}
//----------------------------------- clear job id ---------------------------
function scs_ClearJobID(){
  var job=document.getElementById("scs_job_id");     
        job.innerHTML="JOB ID : Not assigned"; 
}
//--------------------------------------------------------------------------------------------------
function scs_openInCurrentTab(href) {
  Object.assign(document.createElement('a'), {
    target: '',
    rel: 'noopener noreferrer',
    href: href,
  }).click();
}
//---------------------------------------------------------------------
function scs_openInNewTab(href) {
  Object.assign(document.createElement('a'), {
    target: '_blank',
    rel: 'noopener noreferrer',
    href: href,
  }).click();
}
//-------------------------------------- API functions----------------------------------------------
//-------------------------------------- API user ----------------------------------------------
//------------------------- API REST CMD = scs_getUserType --------------------------- 
async function scs_getUserType() {  
  const murl=scs_baseRestUrl+"scs_getUserType/";
   try{
        const response = await fetch(murl,{     
         method: "GET",    
         headers: {
          "Content-Type": "application/json",    
          "Accept": "application/json",    
          "Authorization": "Basic " + btoa(scs_username + ":" + scs_userpassword),    
         }    
       }
       )
       if (!response.ok) {      
             scs_user_Type=-2 ;
             alert("Looks like there was a problem. Status Code: " +
             response.status);
          return null;
        }     
     const data = await response.json();
     scs_user_Type=parseInt(data[0].user_type); 
     if (scs_user_Type===NaN || scs_user_Type===0){
               scs_user_Type=-1;//not ok user name and pasword
              }   
    localStorage.setItem("SERPO_PORTAL_user_type",scs_user_Type);            
    return data[0];   
  }
  catch (err) {   
     scs_user_Type=-3;//not ok
     console.log(err);        
     return null;
     }       
  }
  //------------------------- API REST CMD = scs_getUserType --------------------------- 
  async function scs_ApplyUpdates(udata,ftablename) {  
  const murl=scs_baseRestUrl+"scs_ApplyUpdates/"+ftablename;
   try{
        const response = await fetch(murl,{     
         method: "PUT",    
         headers: {
          "Content-Type": "application/json",    
          "Accept": "application/json",    
          "Authorization": "Basic " + btoa(scs_username + ":" + scs_userpassword),    
         },
         body: JSON.stringify(udata),
       }
       )
       if (!response.ok) {                 
             alert("Looks like there was a problem. Status Code: " +
             response.status);
          return false;
        }     
     const data = await response.json();
     scs_user_Type=parseInt(data[0].user_type); 
     if (scs_user_Type===NaN){
               scs_user_Type=-1;//not ok user name and pasword
              }              
    return true;
  }
  catch (err) {   
     scs_user_Type=-3;//not ok
     console.log(err);        
     return false;
     }       
  }
//----------------------------------------------------------------------------------------------------------------------  
async function scs_UserRegistration(udata,fscs_user_code) {  
  const murl=scs_baseRestUrl+"scs_ApplyUpdates/"+"users";
   try{
        const response = await fetch(murl,{     
         method: "PUT",    
         headers: {
          "Content-Type": "application/json",    
          "Accept": "application/json",    
          "Authorization": "Basic " + btoa("scs_userregistration"+ ":" + fscs_user_code),    
         },
         body: JSON.stringify(udata),
       }
       )
       if (!response.ok) {                 
             alert("Looks like there was a problem. Status Code: " +
             response.status);
          return false;
        }     
     const data = await response.json();
     console.log(data);    
    return true;
  }
  catch (err) {   
     scs_user_Type=-3;//not ok
     console.log(err);       
     return false;
     }       
  }
//----------------------------------------------------------------------------------------------------------------------  
async function scs_scs_GetUserCode(user_email) {  
  const murl=scs_baseRestUrl+"scs_scs_GetUserCode/"+user_email;
   try{
        const response = await fetch(murl,{     
         method: "GET",    
         headers: {
          "Content-Type": "application/json",    
          "Accept": "application/json",    
          "Authorization": "Basic " + btoa("scs_userregistration"+ ":" + "usercode"),    
         },         
       }
       )
       if (!response.ok) {                 
             alert("Looks like there was a problem. Status Code: " +
             response.status);
          return false;
        }     
     const data = await response.json();
     console.log(data);                  
    return true;
  }
  catch (err) {   
     scs_user_Type=-3;//not ok
     console.log(err);       
     return false;
     }       
  }
//------------------------------------------------------------------------------------------------- 
//--------------------------------------- API profiles --------------------------------------------- 
//-------------------------------------- upload profile file ---------------------------------------
//       API REST CMD = scs_uploadProfile_file , param1=filename , param2=filesize , param3=job uuid
async function scs_uploadProfile_file(fn,uuid) {              
  let entry=fn;
  const data = new FormData();
  data.append('file',entry);
  const murl=scs_baseRestUrl+"scs_uploadProfile_file/"+entry.name+"/"+entry.size+"/"+uuid;
try{ 
  const response= await fetch(murl, {
       method: "POST",
       headers: {                        
        "Authorization": "Basic " + btoa("public_hggprofiles_activity" + ":" + "scs_action"),         
         }, 
       body: data
     }
     )
     if (!response.ok) {            
      return null;
    }           
   const json = await response.json();
   console.log(json);     
   return json;         
 }
catch(err){
   console.log(err);
   return null;
  }
};  
//---------------------------------------------------------------------------------------
//       API REST CMD = scs_getHGGJobRun , param1=job uuid ,param2=options
async function scs_getHGGJobRun(job_id,soptions) {                
  const murl=scs_baseRestUrl+"scs_getHGGJobRun/"+job_id+"/"+soptions;
  try{
  const response=await fetch(murl, {
      method: "GET",
      headers: {                        
        "Authorization": "Basic " + btoa("public_hggprofiles_activity" + ":" + "scs_action"),         
       },              
  }
  )
  if (!response.ok) {            
      return null;
    }     
   const json = await response.json();
   console.log(json);
   return json;             
 }
catch(err){
   console.log(err);
   return null;
}
};  
//---------------------------------------------------------------------------------------
//       API REST CMD = scs_getHGGJobStatus , param1=job uuid ,param2=options
async function scs_getHGGJobStatus(job_id) {                
  const murl=scs_baseRestUrl+"scs_getHGGJobStatus/"+job_id;
  try{
    const response= await fetch(murl, {
      method: "GET",
      headers: {                        
        "Authorization": "Basic " + btoa("public_hggprofiles_activity" + ":" + "scs_action"),         
       },           
  }
  )
  if (!response.ok) {            
      return null;
    }     
   const json = await response.json();
   console.log(json);
   return json;   
 }
catch(err){
   console.log(err);   
   return null;
}
};  
//-------------------------------------------------------------------------------------
//       API REST CMD = scs_getDownloadHGGResultFile, param1=job_id,param2=fname
async function scs_getDownloadHGGResultFile(job_id,fname){
const murl=scs_baseRestUrl+"scs_getDownloadHGGResultFile/"+fname+"/"+job_id;//evit confuzia la apel
  try{
    const response= await fetch(murl, {
      method: "GET",
      headers: {                        
        "Authorization": "Basic " + btoa(scs_username + ":" + scs_userpassword),         
       },           
  }
  )
  if (!response.ok) {            
      return null;
    }     
   const json = await response.json();
   console.log(json);
   var stext=json.INFO;
   stext=decodeURIComponent(stext); 
   if (stext.startsWith("!Download!")){
    const muri=scs_baseRestUrl+stext;
    scs_downloadURI(muri);
   }     
   else{
    alert(stext);
   }
   return json;   
 }
catch (err){
   console.log(err);   
   return null;
}
};  
//------------------------------------------------------------------------------------------------
//       API REST CMD = scs_getJobStatus , param1=job_id,param2=fname
async function scs_getDownloadHGGProductionInfoFile(job_id){
  const murl=scs_baseRestUrl+"scs_getDownloadHGGProductionInfoFile/"+job_id;//evit confuzia la apel
    try{
      const response= await fetch(murl, {
        method: "GET",
        headers: {                        
          "Authorization": "Basic " + btoa(scs_username + ":" + scs_userpassword),         
         },           
    }
    )
    if (!response.ok) {            
        return null;
      }     
     const json = await response.json();
     console.log(json);
     var stext=json.INFO;
     stext=decodeURIComponent(stext); 
     if (stext.startsWith("!Download!")){
      const muri=scs_baseRestUrl+stext;
      scs_downloadURI(muri);
     }     
     else{
      alert(stext);
     }
     return json;   
   }
  catch (err){
     console.log(err);   
     return null;
  }
  };  
  
//----------------------------------------------------------------------------------------------------------------------
//-------------------------------------- API models --------------------------------------------------------------------  
//-------------------------------------- upload model file --------------------
//       API REST CMD = scs_uploadModel_file , param1=filename , param2=filesize , param3=job uuid
async function scs_uploadModel_file(fn,uuid) {              
  let entry=fn;
  const data = new FormData();
  data.append('file',entry);
  const murl=scs_baseRestUrl+"scs_uploadModel_file/"+entry.name+"/"+entry.size+"/"+uuid;
try{ 
  const response= await fetch(murl, {
       method: "POST",
       headers: {                        
        "Authorization": "Basic " + btoa("public_solidmodel_activity" + ":" + "scs_action"),         
         }, 
       body: data
     }
     )
     if (!response.ok) {            
      return null;
    }           
   const json = await response.json();
   console.log(json);     
   return json;         
 }
catch(err){
   console.log(err);
   return null;
  }
};  
//---------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------
//       API REST CMD = scs_getModelJobRun , param1=job uuid ,param2=cmdid,param3=options
async function scs_getModelJobRun(job_id,cmdid,soptions) {                
  const murl=scs_baseRestUrl+"scs_getModelJobRun/"+job_id+"/"+cmdid+"/"+soptions;
  try{
  const response=await fetch(murl, {
      method: "GET",
      headers: {                        
        "Authorization": "Basic " + btoa("public_solidmodel_activity" + ":" + "scs_action"),         
       },              
  }
  )
  if (!response.ok) {            
      return null;
    }     
   const json = await response.json();
   console.log(json);
   return json;             
 }
catch(err){
   console.log(err);
   return null;
}
};  
//------------------------------------------------------------------------------------------
//       API REST CMD = scs_getModelJobStatus , param1=job uuid ,param2=options
async function scs_getModelJobStatus(job_id) {                
  const murl=scs_baseRestUrl+"scs_getModelJobStatus/"+job_id;
  try{
    const response= await fetch(murl, {
      method: "GET",
      headers: {                        
        "Authorization": "Basic " + btoa("public_solidmodel_activity" + ":" + "scs_action"),         
       },           
  }
  )
  if (!response.ok) {            
      return null;
    }     
   const json = await response.json();
   console.log(json);
   return json;   
 }
catch(err){
   console.log(err);   
   return null;
}
};
//------------------------------------------------------------------------------------------
//       API REST CMD = scs_getModelData , param1=job uuid 
async function scs_getModelData(job_id) {                
  const murl=scs_baseRestUrl+"scs_getModelData/"+job_id;
  try{
    const response= await fetch(murl, {
      method: "GET",
      headers: {                        
        "Authorization": "Basic " + btoa("public_solidmodel_activity" + ":" + "scs_action"),         
       },           
  }
  )
  if (!response.ok) {            
      return null;
    }     
   const json = await response.json();
   console.log(json);
   return json;   
 }
catch(err){
   console.log(err);   
   return null;
}
};
//----------------------------------------------------------------------------------------
//       API REST CMD = scs_getDownloadHGGResultFile, param1=job_id,param2=fname
async function scs_getDownloadModelResultFile(job_id,fname){
  const murl=scs_baseRestUrl+"scs_getDownloadModelResultFile/"+fname+"/"+job_id;//evit confuzia la apel
    try{
      const response= await fetch(murl, {
        method: "GET",
        headers: {                        
          "Authorization": "Basic " + btoa(scs_username + ":" + scs_userpassword),         
         },           
    }
    )
    if (!response.ok) {            
        return null;
      }     
     const json = await response.json();
     console.log(json);
     var stext=json.INFO;
     stext=decodeURIComponent(stext); 
     if (stext.startsWith("!Download!")){
      const muri=scs_baseRestUrl+stext;
      scs_downloadURI(muri);
     }     
     else{
      alert(stext);
     }
     return json;   
   }
  catch (err){
     console.log(err);   
     return null;
  }
  };  
  //------------------------------------------------------------------------------------------------
  //       API REST CMD = scs_getDownloadModelProductionInfoFile , param1=job_id
async function scs_getDownloadModelProductionInfoFile(job_id){
  const murl=scs_baseRestUrl+"scs_getDownloadModelProductionInfoFile/"+job_id;//evit confuzia la apel
    try{
      const response= await fetch(murl, {
        method: "GET",
        headers: {                        
          "Authorization": "Basic " + btoa(scs_username + ":" + scs_userpassword),         
         },           
    }
    )
    if (!response.ok) {            
        return null;
      }     
     const json = await response.json();
     console.log(json);
     var stext=json.INFO;
     stext=decodeURIComponent(stext); 
     if (stext.startsWith("!Download!")){
      const muri=scs_baseRestUrl+stext;
      scs_downloadURI(muri);
     }     
     else{
      alert(stext);
     }
     return json;   
   }
  catch (err){
     console.log(err);   
     return null;
  }
  };