importPackage(java.util);
importPackage(java.lang);
importPackage(com.cloupia.lib.cIaaS.ucs.model);
importPackage(com.cloupia.lib.cIaaS.ucs.model.generated);
importPackage(com.cloupia.lib.cIaaS.ucs);
importPackage(com.cloupia.feature.ucsController);
importPackage(com.cloupia.model.cIM);
importPackage(com.cloupia.feature.cluster);
importPackage(com.cloupia.feature.accounts);
importPackage(com.cloupia.service.cIM.inframgr);
importPackage(com.cloupia.lib.cIaaS.network.model);
importPackage(com.cloupia.lib.connector.account.credential);
importPackage(com.cloupia.feature.networkController.model);
importPackage(com.cloupia.fw.objstore);
importPackage(com.cloupia.service.cIM.inframgr.syslimits);

		 
		//COMMON PROPERTIES 
		var useDefaultPort = input.useDefaultPort;
		var protocol ;
		var port ; 
		
		if(useDefaultPort != null && useDefaultPort == true) {
			protocol = "ssh";
		    port = "22";
			copyFlag = 1;
		}
		else{
		protocol = input.protocol;
		port = input.port;
		}
		var pod; 
		var credPolicyOfA ;
		var copyFlag;
		var category = DeviceCategoryLOVProvider.CATEGORY_NXOS_DEVICE_ID;
		
		//FOR PRIMARY ACCOUNT
		var userId = input.userName;
		var password = input.password;
		var enablePassword = input.enablePassword;		

		var serverAddress = input.serverAddress;
		var policyName = input.saveCreds;
		
		var useDefaultPort2 = input.useDefaultPort2;
		var protocol2 ;
		var port2 ; 
		
		if(useDefaultPort2 != null && useDefaultPort2 == true) {
			protocol2 = "ssh";
		    port2 = "22";
		}
		else{
		protocol2 = input.protocol2;
		port2 = input.port2;
		}		
		
		//FOR FAILOVER ACCOUNT
		var userId2 = input.userName2;
		var password2 = input.password2;
		var enablePassword2 = input.enablePassword2;		
		var serverAddress2 = input.serverAddress2;
		var policyName2 = input.saveCreds2;

		var id = ctxt.getUserId();
		
		
		var newPodName = input.podName//ctxt.getInput(custom_FlexPodSitePod13.podName);
		logger.addInfo("PodName Obtained from SitePod Task: "+newPodName);
		
		  if(newPodName.length() > 1) {
			pod = "Default Pod";
		   }
		   else {
			pod = newPodName;
		 }	
		
	
		logger.addInfo("Pod name is: "+pod);
			
	
		//var logger = Logger.getLogger("my logger"); 
		logger.addInfo("Nexus5k Page is sumbitted");
				
		var primaryAccountCheck = input.addAccount;
		var useCredPolicyCheck = input.useCredPolicy;
		var saveCredsCheck = input.saveCreds;

		logger.addInfo("PRIMARY: ACCOUNT CHECKED?: "+primaryAccountCheck);
		logger.addInfo("PRIMARY: IS EXISTING CRED USED FOR PRIMARY?: "+useCredPolicyCheck);
		logger.addInfo("PRIMARY: ARE CREDDENTIALS BEING SAVED: "+saveCredsCheck);
		
		if(primaryAccountCheck != null && primaryAccountCheck == true)
		{
		logger.addInfo("Primary Account Exists");
	/*	if(useCredPolicyCheck != null && useCredPolicyCheck == true){
			//save the primary account with the credential Policy
			logger.addInfo("PRIMARY Account: Existing Cred Policy used to persist account");
			credPolicyOfA = input.credPolicyLov;
			
			var config = PersistenceUtil.getCredentialPolicyByName(credPolicyOfA);
			if (config!=null){
    				userId = config.getUserName();
    				password=config.getPassword();
    				protocol=config.getProtocal();
    				port=config.getPort()+"";
					copyFlag = 1;
    			}
				else{
				logger.addInfo("PRIMARY Account: Manual inputs used to persist account");
				copyFlag = 2;	
				}
				policyName = null;
			}*/
			
			//Save the primary account with user inputs
			var flexPodAccountPersist = new DeviceCredential();
			flexPodAccountPersist.setDatacenter(pod);
			flexPodAccountPersist.setDeviceCategory(category);
			flexPodAccountPersist.setDeviceIp(serverAddress);
			flexPodAccountPersist.setProtocol(protocol)
			flexPodAccountPersist.setPort(port);
			
			if (userId != null)
				{
			flexPodAccountPersist.setLogin(userId);
			}
			else {
			logger.addInfo("Login is empty");
			}
			
			if (password != null)
				{
			flexPodAccountPersist.setPassword(password);
			}
			else {
			logger.addInfo("Password is empty");
			}
			
			if (enablePassword != null)
				{
			flexPodAccountPersist.setEnablePassword(enablePassword);
			}
			else {
			logger.addInfo("Enable Password is empty");
			}
			
			logger.addInfo("NWing Info : "+flexPodAccountPersist.getDatacenter()+" "+
			flexPodAccountPersist.getDeviceCategory()+" "+
			flexPodAccountPersist.getDeviceIp()+" "+
			flexPodAccountPersist.getProtocol()+" "+
			flexPodAccountPersist.getPort()+" "+
			flexPodAccountPersist.getLogin()
			//flexPodAccountPersist.getPassword()+" "+
			//flexPodAccountPersist.getEnablePassword()
			);


			//License Check
			var respMsg = new StringBuffer("");
			validDC = DatacenterLicChecker.getInstance().canAddComponentToDC(pod, InfraAccountTypes.CAT_NETWORK + "", DeviceCategoryLOVProvider.CATEGORY_NXOS_DEVICE_ID, respMsg, true);
			if(!validDC){
						ctxt.setFailed("Cannot add new Physical Account : License is invalid or has expired");
						ctxt.exit();
			}
			
			//Validity check
			var deviceType = "";
        	var deviceTypeNumeric = -1
        	var errMsg = new StringBuffer("");
			
        	try 
        	{
        		deviceTypeNumeric = DeviceCategoryLOVProvider.DeviceTypeMp.get(DeviceCategoryLOVProvider.CATEGORY_NXOS_DEVICE_ID);
        		deviceType = deviceTypeNumeric + "";
        	}catch(e)
        	{
        		deviceType = category;
        	}
			
			logger.addInfo("DEVICE NUMBERIC IS:  "+deviceTypeNumeric);
			var validConnection = InfrastructureDataUtil.isValidNetworkDeviceForDC(flexPodAccountPersist, 3, DeviceCategoryLOVProvider.CATEGORY_NXOS_DEVICE_ID, errMsg, true, true);

			if(!validConnection){
						ctxt.setFailed("Cannot Reach the account "+serverAddress);
						ctxt.exit();
			}
			
			//Persistence
			logger.addInfo("Persist Primary Account");
			try {
				 NetworkPersistenceUtil.addDeviceCredential(flexPodAccountPersist);
				//RestAPIBackend.persistNetworkDevice(flexPodAccountPersist);
				logger.addInfo("Task Done");
				}
			catch (ex) {
				logger.addError("The error is:  " + ex);
				}
            
			
	
	/*		if(policyName != null && policyName.length() > 1) {
				logger.addInfo("PRIMARY: Policy Name EXISTS: "+policyName);
				logger.addInfo("Creating a new policy");
				var newObj = new CredentialPolicyConfig();
						newObj.setName(policyName);
						newObj.setUserName(userId);
						newObj.setPassword(password);
						newObj.setProtocal(protocol);
						newObj.setPort(port);
						
			var policy = PersistenceUtil.getCredentialPolicyByName(policyName.trim());
			if (policy!=null)
			{
				ctxt.setFailed("Policy Name "+policyName+" already exists, Policy name should be unique");
				ctxt.exit();
			}
						
				//save that credential policy with the user provided name
				try {
						logger.addInfo("PRIMARY: Persisting NEW POLICY");
						var store = ObjStoreHelper.getStore(new CredentialPolicyConfig().getClass());
						//logger.addInfo("Persist new policy for primary account");
						store.insert(newObj);
					} catch (e) {

						logger.addInfo("PRIMARY: Error while persisting credential policy."+e);

					}
			
			}*/
			
		logger.addInfo("Category: "+category);
		logger.addInfo("ID: "+id);
		logger.addInfo("Pod Name: "+pod);
		logger.addInfo("Server Address: "+serverAddress);
		logger.addInfo("User Id: "+userId);
		logger.addInfo("Password: Hidden");//+password
		//logger.addInfo("Password: "+enablePassword);		
		logger.addInfo("Transport Type: "+protocol);
		logger.addInfo("Port: "+port);
		
		}
		else{
		logger.addInfo("PRIMARY: Account NOT Existing");
		}
		
		
		
		
		
		
		


			
			

		
		
		var failoverAccountCheck = input.addFailoverAccount;
		var failoverCredPolicyCheck = input.useCredPolicy2;
		var failoverSaveCredsCheck = input.saveCreds2;
		var copyCredtoBCheck = input.copyCredtoB;
		

		
		logger.addInfo("FAILOVER: ACCOUNT CHECK: "+failoverAccountCheck);
		logger.addInfo("FAILOVER: EXISTING CRED CHECK: "+failoverCredPolicyCheck);
		logger.addInfo("FAILOVER: SAVE CREDS CHECK CHECK: "+failoverSaveCredsCheck);
		logger.addInfo("FAILOVER: COPY CREDS FROM A CHECK: "+copyCredtoBCheck);		
			
		
		if(failoverAccountCheck != null && failoverAccountCheck == false){
		logger.addInfo("FAILOVER:  Account Exists");
				
		if(copyCredtoBCheck != null && copyCredtoBCheck == true){
	/*	logger.addInfo("FAILOVER: copying cred Policy from A ??");
		//save failover account with same creds as that of Account A
		if(copyFlag == 1){
			//use existing cred policy from A
			logger.addInfo("FAILOVER: use existing cred policy from A");
			var config = PersistenceUtil.getCredentialPolicyByName(credPolicyOfA);
			if (config!=null){
    				userId2 = config.getUserName();
    				password2 = config.getPassword();
    				protocol2 = config.getProtocal();
    				port2 = config.getPort()+"";
    			}
		}
		else if(copyFlag == 2){*/
			logger.addInfo("FAILOVER: use input creds from A");
			//use input creds from A
			userId2 = userId;
			password2 = password;
			if(copyFlag == 1) {
				protocol2 = "ssh";
				port2 = "22";
			}
			else{
    		protocol2 = protocol;
    		port2 = port;
			}
		}
	/*	policyName2 = null;
		}
		else if(failoverCredPolicyCheck != null && failoverCredPolicyCheck == true){
			logger.addInfo("FAILOVER: use Existing Cred policy for B");
			//save the primary account with the credential Policy
			var credPolicy = input.credPolicyLov2;
			
			var config = PersistenceUtil.getCredentialPolicyByName(credPolicy);
			if (config!=null){
    				userId2 = config.getUserName();
    				password2=config.getPassword();
    				protocol2=config.getProtocal();
    				port2=config.getPort()+"";
    			}
				policyName2 = null;
		}*/
		

		
			
			//Save the failover account with user inputs
			var flexPodAccountPersist2 = new DeviceCredential();
			flexPodAccountPersist2.setDatacenter(pod);
			flexPodAccountPersist2.setDeviceCategory(category);
			flexPodAccountPersist2.setDeviceIp(serverAddress2);
			flexPodAccountPersist2.setProtocol(protocol2)
			flexPodAccountPersist2.setPort(port2);
			
			if (userId2 != null)
				{
			flexPodAccountPersist2.setLogin(userId2);
			}
			else {
			logger.addInfo("Login is empty");
			}
			
			if (password2 != null)
				{
			flexPodAccountPersist2.setPassword(password2);
			}
			else {
			logger.addInfo("Password is empty");
			}
			
			if (enablePassword2 != null)
				{
			flexPodAccountPersist2.setEnablePassword(enablePassword2);
			}
			else {
			logger.addInfo("Enable Password is empty");
			}
			
			logger.addInfo("NWing Info : "+flexPodAccountPersist2.getDatacenter()+" "+
			flexPodAccountPersist2.getDeviceCategory()+" "+
			flexPodAccountPersist2.getDeviceIp()+" "+
			flexPodAccountPersist2.getProtocol()+" "+
			flexPodAccountPersist2.getPort()+" "+
			flexPodAccountPersist2.getLogin()
			//flexPodAccountPersist2.getPassword()+" "+
			//flexPodAccountPersist2.getEnablePassword()
			);
			
			
			
			
			
			//License Check
			var respMsg = new StringBuffer("");
			validDC = DatacenterLicChecker.getInstance().canAddComponentToDC(pod, InfraAccountTypes.CAT_NETWORK + "", DeviceCategoryLOVProvider.CATEGORY_NXOS_DEVICE_ID, respMsg, true);
			if(!validDC){
						ctxt.setFailed("Cannot add new Physical Account : License is invalid or has expired");
						ctxt.exit();
			}
			
			//Validity check
			var deviceType2 = "";
        	var deviceTypeNumeric2 = -1;
        	var errMsg2 = new StringBuffer("");
			
        	try 
        	{
        		deviceTypeNumeric2 = DeviceCategoryLOVProvider.DeviceTypeMp.get(DeviceCategoryLOVProvider.CATEGORY_NXOS_DEVICE_ID);
        		deviceType2 = deviceTypeNumeric2 + "";
        	}catch(e)
        	{
        		deviceType2 = category;
        	}
			
			
			var validConnection2 = InfrastructureDataUtil.isValidNetworkDeviceForDC(flexPodAccountPersist2, 3, DeviceCategoryLOVProvider.CATEGORY_NXOS_DEVICE_ID, errMsg2, true, true);

			if(!validConnection2){
						ctxt.setFailed("Cannot Reach the account "+validConnection2+"          "+serverAddress2);
						ctxt.exit();
			}
			
			//Persistence
			logger.addInfo("Persist Failover Account");
			try {
				 NetworkPersistenceUtil.addDeviceCredential(flexPodAccountPersist2);
				//RestAPIBackend.persistNetworkDevice(flexPodAccountPersist2);
				logger.addInfo("Task Done");
				}
			catch (ex) {
				logger.addError("The error is:  " + ex);
				}
			

		
		
			//Save the failover account with user inputs
			if(policyName2 != null && policyName2.length() > 1) {
				logger.addInfo("FAILOVER: Policy Name for Failover Account Exists: "+policyName2);
				//save that credential policy with the user provided name
				logger.addInfo("FAILOVER: SAVE that NEW credential policy with the user provided name for B");
				var newObj = new CredentialPolicyConfig();
						newObj.setName(policyName2);
						newObj.setUserName(userId2);
						newObj.setPassword(password2);
						newObj.setProtocal(protocol2);
						newObj.setPort(port2);
						
				//Check if Policy name exists already		
				var policy = PersistenceUtil.getCredentialPolicyByName(policyName2.trim());
				if (policy!=null)
				{
				    ctxt.setFailed("Policy Name "+policyName2+" already exists, Policy name should be unique");
					ctxt.exit();
				}
			
				//save that credential policy with the user provided name
				try {
						logger.addInfo("FAILOVER: persistInstance credential policy for B.");
						var store = ObjStoreHelper.getStore(new CredentialPolicyConfig().getClass());
						store.insert(newObj);
					} catch (e) {

						logger.addInfo("FAILOVER: Error while persisting credential policy.");

					}
			}
			logger.addInfo("Category: "+category);
		logger.addInfo("ID: "+id);
		logger.addInfo("Pod Name: "+pod);
		logger.addInfo("Server Address: "+serverAddress2);
		logger.addInfo("User Id: "+userId2);
		logger.addInfo("Password: Hidden");//+password2
		//logger.addInfo("Password: "+enablePassword2);		
		logger.addInfo("Transport Type: "+protocol2);
		logger.addInfo("Port: "+port2);
		
		}
		else {
			logger.addInfo("FAILOVER:  account was not added");
		}

		
 


		

Additional Links: