package main_package;

import java.io.BufferedReader;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

import java.security.SecureRandom;
import java.security.cert.X509Certificate;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.Serializable;
import java.math.BigDecimal;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import javax.faces.application.FacesMessage;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ViewScoped;
import javax.faces.context.FacesContext;
import javax.faces.model.SelectItem;
import javax.servlet.http.HttpSession;

import org.primefaces.json.JSONArray;
import org.primefaces.json.JSONObject;

@ManagedBean(name="mandateBean")
@ViewScoped

public class GenerateMandateBean implements Serializable {
	
	
	private static final long serialVersionUID = 1L;
	private String loanNo,userId,address,customerName, customerMobile, email, accountNo, debitFrequency,
    ifsc, authType, accountType, debitAmount,collectionAmount, bankCode, merchantTrxnRefId, shareHolderNo ,uniqueId,bankName;
	String mandateUrl,loanNoF;
	boolean regForm,ismandateUrl;
	int sno;
	ArrayList<SelectItem> bankCodeList = new ArrayList<>();
	ArrayList<SelectItem> loanNumList ;
	
	private String Authorization,key_id,key_secret,url,callbackUrl,redirectUrl;
	 private boolean rd=false;
	 private String customerRdNumber;
	 ArrayList<SelectItem> rdList =new ArrayList<>();
	
	public GenerateMandateBean() {
		HttpSession ss=(HttpSession) FacesContext.getCurrentInstance().getExternalContext().getSession(false);
		userId = (String) ss.getAttribute("username");        
		
    	new DataBaseMethods().fileCreation("Constructor Called Error written successfully");


	}
	
	
	public void resetFlow() {
		    loanNo = null;
		    userId = null;
		    address = null;
		    customerName = null;
		    customerMobile = null;
		    email = null;
		    accountNo = null;
		    debitFrequency = null;
		    ifsc = null;
		    authType = null;
		    accountType = null;
		    debitAmount = null;
		    collectionAmount = null;
		    bankCode = null;
		    merchantTrxnRefId = null;
		    shareHolderNo = null;
		    uniqueId = null;
		    bankName = null;
		    mandateUrl = null;
		    loanNoF = null;

		    regForm = false;
		    ismandateUrl = false;

		    sno = 0;

		 
		    if (loanNumList != null) {
		        loanNumList.clear();
		    } else {
		        loanNumList = new ArrayList<>();
		    }
		

	}
	
	
	private double terms;
    private Date startDate=new Date(), expiryDate=new Date(); 
    ArrayList<String> list;
   
    DataBaseMethods dd = new DataBaseMethods();


 


		public List<String> completeText(String name)
		{
			
			list = new ArrayList<String>();
			HttpSession ss=(HttpSession) FacesContext.getCurrentInstance().getExternalContext().getSession(false);
			int branchId = (int) ss.getAttribute("branchId");        
			
			list= (ArrayList<String>) new DataBaseAutoCompAndDuplicate().loanListFromMemberList(branchId, name);
			System.out.println(list.size());
		 	return list;
		 	
		}

		private String extractShareholderNo(String input) {
		    if (input != null && input.contains("/")) {
		       
		        return input.substring(0, input.indexOf('/')).trim();
		    }
		    return input != null ? input.trim() : null;
		}

	 
		public void checkTotalLoan() {
			
		    loanNumList = new ArrayList<>();
		    String input = shareHolderNo;

		    shareHolderNo = extractShareholderNo(input);
		    System.out.println("ShareholderNo :" + shareHolderNo);

		    
		    try (Connection conn = DataBaseConnection.JAVAConnection()) {
		        
		        // Fetch from personalloan
		        String queryPersonal = "SELECT * FROM personalloan WHERE shareholderno = ? AND status = ?";
		        try (PreparedStatement ps = conn.prepareStatement(queryPersonal)) {
		            ps.setString(1, shareHolderNo);
		            ps.setString(2, "Approve");

		            ResultSet rs = ps.executeQuery();
		            while (rs.next()) {
		                SelectItem si = new SelectItem();
		                si.setLabel(rs.getString("loanNo"));
		                si.setValue(rs.getString("loanNo"));
		                loanNumList.add(si);
		                
		            }
		        }


		        // Fetch from secureloan
		        String querySecur = "SELECT * FROM secure_loan WHERE shareholderno = ? AND status = ?";
		        try (PreparedStatement ps2 = conn.prepareStatement(querySecur)) {
		            ps2.setString(1, shareHolderNo);
		            ps2.setString(2, "Approve");

		            ResultSet rs2 = ps2.executeQuery();
		            while (rs2.next()) {
		                SelectItem si = new SelectItem();
		                si.setLabel(rs2.getString("loanNo"));
		                si.setValue(rs2.getString("loanNo"));
		                loanNumList.add(si);
		                
		            }
		        }

		    } catch (Exception e) {
		        e.printStackTrace();
		    }
		}

	


		public void fetchLoanData() {
		    System.out.println("Loan No: " + loanNoF);
		   String code;
		    if (loanNoF != null) {
		        if (loanNoF.startsWith("PL-")) {
		        	 code="personalloan";
		            dataFromPLSL(code);
		        } else if (loanNoF.startsWith("SL-")) {
		        	 code="secure_loan";
		            dataFromPLSL(code);
		        } else {
		            System.out.println("Unknown Loan Type: " + loanNoF);
		        }
		    } else {
		        System.out.println("Loan No is null!");
		    }
		}


		public void dataFromPLSL(String table) {

			bankCodeList=new DataBaseMethods().fetchBankCodeByNpci();
			String input = shareHolderNo;

			
			shareHolderNo = extractShareholderNo(input);
		    System.out.println("ShareholderNo :" + shareHolderNo);

			
			try(Connection conn = DataBaseConnection.JAVAConnection()){
			
				String query = "select * from " + table + " where shareholderno = ? and loanNo=? and status=? " ;
				
				try(PreparedStatement ps = conn.prepareStatement(query)){
					
					ps.setString(1, shareHolderNo);
					ps.setString(2, loanNoF);
					ps.setString(3, "Approve");
					
					ResultSet rs = ps.executeQuery();
					
					if(rs.next()) {
						
						bankName =rs.getString("app_bank_name"); 
						shareHolderNo = rs.getString("shareholderno");
						accountNo = rs.getString("app_acc_no");
						authType="Aadhaar";
						debitFrequency="MNTH"; 
						terms = rs.getInt("terms");
						int dt =  rs.getInt("emi");
						collectionAmount = Double.toString(dt*terms); 
						debitAmount=Integer.toString(rs.getInt("emi"));
						loanNo = rs.getString("loanNo");
						gatherData(shareHolderNo);
						regForm=true;
					}else {
						regForm=false;
						
						terms = rs.getDouble("terms");
						
						
					}
					
					
					
				}catch(Exception e) {
					
					e.printStackTrace();
					
				}
				
			}catch(Exception e) {
				 
				e.printStackTrace();
				
			}
			
			
		}

	

public void gatherData(String shareHolderNo) {

	String input =  shareHolderNo;
	shareHolderNo = extractShareholderNo(input);

	try(Connection conn = DataBaseConnection.JAVAConnection()){
       
		String query = " select * from shareholder_info where shareholderno= ?";
           
		try(PreparedStatement ps =conn.prepareStatement(query)){
			
			ps.setString(1, shareHolderNo);
			
		 ResultSet rs = ps.executeQuery();
		 
		 if(rs.next()) {
			 
			 customerName = rs.getString("first_applicantName");
			 address = rs.getString("address");
			 customerMobile = rs.getString("mobile");
			 uniqueId =rs.getString("unique_id");
			 userId  = rs.getString("userid");
			
		 }
		
		
		 
		}catch(Exception e) {
			
		}
	}catch(Exception e) {
		
		e.printStackTrace();
		
	}
  
	
}


public void submit() {

	fetchApiDetailsDB();
	boolean isValid = validateFields(url, callbackUrl, redirectUrl, Authorization, key_id, key_secret);

	if (!isValid) {	
	    FacesContext.getCurrentInstance().addMessage(null, 
	    	    new FacesMessage(
	    	        FacesMessage.SEVERITY_ERROR, 
	    	        "Some problem while fetching API credentials from DB."+ 
	    	        "If you use this service, please contact support.",null
	    	    )
	    	);
	} else {
		 createMandate();
		
	}


    

  
}




	 public void fetchApiDetailsDB() {
	    	
	    	try(Connection conn=DataBaseConnection.JAVAConnection()){
	    		
	    		String query = "SELECT * FROM api_keys WHERE id = ? LIMIT 1";
	    		try(PreparedStatement psmt=conn.prepareStatement(query)){
	    		    psmt.setInt(1, 1);

	    			ResultSet rs=psmt.executeQuery();
	    			while(rs.next()) {
	    				url=rs.getString("url");
	    				callbackUrl=rs.getString("callbackUrl");
	    				redirectUrl=rs.getString("redirectUrl");
	    				Authorization=rs.getString("authorization");
	    				key_id=rs.getString("keyid");
	    				key_secret=rs.getString("keySecret");
	    				
	    			}
	    			
	    			
	    		}catch (Exception e) {
	    			e.printStackTrace();
				}
	    	}catch (Exception e) {
				e.printStackTrace();
			}
	    }
   
   
 public void createMandate() {
         		
	 new DataBaseMethods().fileCreation(
			    "\n====== createMandate() START ======\n" +
			    "URL            : " + this.url + "\n" +
			    "Authorization  : " + Authorization + "\n" +
			    "key_id         : " + key_id + "\n" +
			    "key_secret     : " + (key_secret == null ? null : "****") + "\n" +
			    "callbackUrl    : " + callbackUrl + "\n" +
			    "redirectUrl    : " + redirectUrl + "\n"
			);
	  
	 try {
	        TrustManager[] trustAllCerts = new TrustManager[]{
	            new X509TrustManager() {
	                public X509Certificate[] getAcceptedIssuers() {
	                    return new X509Certificate[0];
	                }
	                public void checkClientTrusted(X509Certificate[] certs, String authType) {}
	                public void checkServerTrusted(X509Certificate[] certs, String authType) {}
	            }
	        };

	        SSLContext sc = SSLContext.getInstance("TLS");
	        sc.init(null, trustAllCerts, new java.security.SecureRandom());
	        HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
	        HttpsURLConnection.setDefaultHostnameVerifier((h, s) -> true);
	        
	        new DataBaseMethods().fileCreation("SSL verification disabled successfully.");


	    } catch (Exception e) {
	        e.printStackTrace();
	        new DataBaseMethods().fileCreation(
	                "Error while disabling SSL verification: " + e.toString()
	            );
	    }

	 
    	try {
    		
    	    HttpURLConnection connection;

			URL url= new URL(this.url);
			try {
				connection= (HttpURLConnection) url.openConnection();
				new DataBaseMethods().fileCreation("HTTP connection opened successfully");

				connection.setRequestMethod("POST");
				connection.setReadTimeout(30000);
				connection.setConnectTimeout(25000);
				connection.setRequestProperty("Content-Type", "application/json");
				connection.setRequestProperty("Accept", "application/json");
				connection.setRequestProperty("Authorization", Authorization.trim());
		        connection.setRequestProperty("key-id", key_id.trim());
		        connection.setRequestProperty("key-secret", key_secret.trim());
		        connection.setDoOutput(true);

//				new DataBaseMethods().fileCreation(
//					    "Request Headers Set:\n" +
//					    "Content-Type: application/json\n" +
//					    "Accept: application/json\n" +
//					    "Authorization: " + Authorization + "\n" +
//					    "key-id: " + key_id + "\n" +
//					    "key-secret: ****\n"
//					);

				
				JSONObject jsonBody = new JSONObject();

				jsonBody.put("authType", authType);
				jsonBody.put("bankAccountType", accountType);
				jsonBody.put("bankCode", bankCode);
				jsonBody.put("callbackUrl", callbackUrl);
				jsonBody.put("customerAccountNo", accountNo);
				jsonBody.put("customerbankIFSC", ifsc);
				jsonBody.put("customerEmailId", email);
				jsonBody.put("customerMobile", customerMobile);
				jsonBody.put("customerName", customerName);
				jsonBody.put("mandateCollectionAmount", collectionAmount);
				jsonBody.put("mandateDebitAmount", debitAmount);
				jsonBody.put("mandateDebitFrequency", debitFrequency);
				jsonBody.put("mandateExpiryDate", formatDate(expiryDate));
				jsonBody.put("mandateStartDate", formatDate(startDate));
				jsonBody.put("redirectUrl", redirectUrl);
				
//				new DataBaseMethods().fileCreation(
//					    "Request JSON Body:\n" + jsonBody.toString()
//					);


					
		    	try (OutputStream os = connection.getOutputStream()) {
	                byte[] input = jsonBody.toString().getBytes("utf-8");
	                os.write(input, 0, input.length);
	            }
		    	
		    	// new DataBaseMethods().fileCreation("Request body written successfully");

		    	
		    	 int responseCode = connection.getResponseCode();
//		    	 new DataBaseMethods().fileCreation(
//		    			    "HTTP Response Code: " + responseCode
//		    			);

		         BufferedReader reader = new BufferedReader(
		             new InputStreamReader(
		                 responseCode > 299 ? connection.getErrorStream() : connection.getInputStream()
		             )
		         );
		         
		         

		         

		         StringBuilder content = new StringBuilder();
		         String line;
		         while ((line = reader.readLine()) != null) {
		             content.append(line);
		         }
		         
		         
		         reader.close();
//		         new DataBaseMethods().fileCreation(
//		        		    "Response Body:\n" + content.toString()
//		        		);
		         
		         System.out.println("Response :"+content);
		         JSONObject jsonResponse = new JSONObject(content.toString());

		         String status = jsonResponse.optString("status");
		         String code = jsonResponse.optString("code");
		         String description = jsonResponse.optString("description");                   

		         FacesContext facesContext = FacesContext.getCurrentInstance();
		         if ("Success".equalsIgnoreCase(status) || "0x0200".equals(code)) {
		             String uniqueId = jsonResponse.optString("uniqueId");
		             merchantTrxnRefId=uniqueId; 
		              mandateUrl = jsonResponse.optString("url");
//		             System.out.println("Mandate Initiated Successfully!");
//		             System.out.println("Unique ID: " + uniqueId);
//		             System.out.println("Redirect URL: " + mandateUrl);
//		             
		             
		            int res= insertMandateRecord();
		             
		            if(res>0) {
		            	ismandateUrl=true;
			            regForm=false;
			            facesContext.addMessage(null, new FacesMessage("Mandate Initiated Successfully!"));
			             
		            }else {
			             facesContext.addMessage(null, new FacesMessage("Error inserting data into the database."));

		            }
		             

		         }else if ("BAD_REQUEST".equalsIgnoreCase(status)
		        	        && jsonResponse.has("description")
		        	        && jsonResponse.get("description") instanceof JSONArray) {

		        	    
		        	    JSONArray errors = jsonResponse.getJSONArray("description");

		        	    for (int i = 0; i < errors.length(); i++) {
		        	        String errorMessage = errors.getString(i);
		        	        System.out.println("- " + errorMessage);

		        	        facesContext.addMessage(null, new FacesMessage("Validation Error: "+errorMessage , null));
		        	    }
		        	

		         } else {
		             System.out.println("Mandate Request Failed:");
		            
	        	        facesContext.addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "Mandate Request Failed: "+ description , null));

		         }

				
			} catch (IOException e) {
				
				e.printStackTrace();
				 new DataBaseMethods().fileCreation(
	            		    "IOException in createMandate(): " + e.toString()
	            		);
			}
			
		} catch (MalformedURLException e) {
			e.printStackTrace();
			new DataBaseMethods().fileCreation(e.getMessage());
		}
    }
 
		private static boolean isNullOrEmpty(String str) {
		  return (str == null || str.trim().isEmpty());
		}




		public static boolean validateFields(String url, String callbackUrl,
		        String redirectUrl, String authorization,
		        String key_id, String key_secret) {
		
		StringBuilder debug = new StringBuilder();
		debug.append("\n====== VALIDATION DEBUG ======\n");
		
		if (isNullOrEmpty(url)) {
		debug.append("url is NULL or EMPTY\n");
		new DataBaseMethods().fileCreation(debug.toString());
		return false;
		}
		
		if (isNullOrEmpty(callbackUrl)) {
		debug.append("callbackUrl is NULL or EMPTY\n");
		new DataBaseMethods().fileCreation(debug.toString());
		return false;
		}
		
		if (isNullOrEmpty(redirectUrl)) {
		debug.append("redirectUrl is NULL or EMPTY\n");
		new DataBaseMethods().fileCreation(debug.toString());
		return false;
		}
		
		if (isNullOrEmpty(authorization)) {
		debug.append("authorization is NULL or EMPTY\n");
		new DataBaseMethods().fileCreation(debug.toString());
		return false;
		}
		
		if (isNullOrEmpty(key_id)) {
		debug.append("key_id is NULL or EMPTY\n");
		new DataBaseMethods().fileCreation(debug.toString());
		return false;
		}
		
		if (isNullOrEmpty(key_secret)) {
		debug.append("key_secret is NULL or EMPTY\n");
		new DataBaseMethods().fileCreation(debug.toString());
		return false;
		}
		
		debug.append("ALL FIELDS VALID\n");
		new DataBaseMethods().fileCreation(debug.toString());
		
		return true;
		}


public void process() {
	fetchApiDetailsDB();
	boolean isValid = validateFields(url, callbackUrl, redirectUrl, Authorization, key_id, key_secret);

    System.out.println("Mandate submitted by: " + customerName);
        System.out.println("====== e-NACH Mandate Submission ======");
        System.out.println("Customer Name       : " + customerName);
        System.out.println("Customer Mobile     : " + customerMobile);
        System.out.println("Email               : " + email);
        System.out.println("Account No          : " + accountNo);
        System.out.println("Start Date          : " + formatDate(startDate));
        System.out.println("Expiry Date         : " + formatDate(expiryDate));
        System.out.println("Debit Amount        : " + debitAmount);
        System.out.println("Collection Amount   : " + collectionAmount);
        System.out.println("Debit Frequency     : " + debitFrequency);
        System.out.println("Bank IFSC           : " + ifsc);
        System.out.println("Auth Type           : " + authType);
        System.out.println("Account Type        : " + accountType);
        System.out.println("Callback URL        : " + callbackUrl);
        System.out.println("Redirector URL      : " + redirectUrl);
        System.out.println("Bank Code           : " + bankCode);
        System.out.println("=======================================");
        
        int res= insertMandateRecord();
        
        if(res>1) {
        	System.out.println("data insertred");
        }else {
        	System.out.println("Not data insertred");
        }
}


    
 public int insertMandateRecord() {
	 
	 int i=0;
	    String query = "INSERT INTO nach_mandate_request (" +
	            "customer_name, mobile, email, account_number, ifsc, bank_code, auth_type, " +
	            "mandate_amount, collection_amount, start_date, end_date, frequency, " +
	            "redirect_url, callback_url, merchant_trxn_ref_id, umrn, status, entry_date, updated_at, user_id, loan_no,rd_connected,rd_number) " +
	            "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";

	    try (Connection conn = DataBaseConnection.JAVAConnection();
	         PreparedStatement ps = conn.prepareStatement(query)) {

	        ps.setString(1, customerName);
	        ps.setString(2, customerMobile);
	        ps.setString(3, email);
	        ps.setString(4, accountNo);
	        ps.setString(5, ifsc);
	        ps.setString(6, bankCode);
	        ps.setString(7, authType);

	        ps.setBigDecimal(8, new BigDecimal(debitAmount));
	        ps.setBigDecimal(9, new BigDecimal(collectionAmount));

	        ps.setDate(10, new java.sql.Date(startDate.getTime()));
	        ps.setDate(11, new java.sql.Date(expiryDate.getTime()));

	        ps.setString(12, debitFrequency);
	        ps.setString(13, redirectUrl);
	        ps.setString(14, callbackUrl);
	     
	        ps.setString(15, merchantTrxnRefId);
	       
	        ps.setNull(16, java.sql.Types.VARCHAR);

	        ps.setString(17, "pending");

	        ps.setDate(18,new java.sql.Date(startDate.getTime())); 
	        ps.setDate(19, new java.sql.Date(expiryDate.getTime()));

	        ps.setString(20, userId);
	        ps.setString(21, loanNo);
	        ps.setBoolean(22, rd);
	        ps.setString(23, customerRdNumber);
	        

	        int rowsInserted = ps.executeUpdate();
	        i=rowsInserted;
	        System.out.println(rowsInserted + " row(s) inserted into nach_mandate_request.");

	    } catch (SQLException e) {
	        System.err.println("SQL Error: " + e.getMessage());
	        e.printStackTrace();
	    } catch (Exception e) {
	        System.err.println("Unexpected Error: " + e.getMessage());
	        e.printStackTrace();
	    }
	    
	    
	    return i;
	}
 
 public void fetchRdList() {

	    if (shareHolderNo == null) {
	        return;
	    }

	    rdList = new DataBaseMethods().fetchRdForNachByMemberId(shareHolderNo);

	    if (rdList == null || rdList.isEmpty()) {
	    	rdList=new DataBaseMethods().fetchAllRdForNach();
	        return;
	    }

	    SelectItem ss = rdList.get(0);
	    String rdNumber = (String) ss.getValue();
	    customerRdNumber=rdNumber;
	}


    private String formatDate(Date date) {
	    if (date == null) return null;
	    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
	    return sdf.format(date);
	}


	public String getCustomerName() {
		return customerName;
	}


	public void setCustomerName(String customerName) {
		this.customerName = customerName;
	}


	public String getCustomerMobile() {
		return customerMobile;
	}


	public void setCustomerMobile(String customerMobile) {
		this.customerMobile = customerMobile;
	}


	public String getEmail() {
		return email;
	}


	public void setEmail(String email) {
		this.email = email;
	}


	public String getAccountNo() {
		return accountNo;
	}


	public void setAccountNo(String accountNo) {
		this.accountNo = accountNo;
	}





	public String getDebitFrequency() {
		return debitFrequency;
	}


	public void setDebitFrequency(String debitFrequency) {
		this.debitFrequency = debitFrequency;
	}


	public String getIfsc() {
		return ifsc;
	}


	public void setIfsc(String ifsc) {
		this.ifsc = ifsc;
	}


	public String getAuthType() {
		return authType;
	}


	public void setAuthType(String authType) {
		this.authType = authType;
	}


	public String getAccountType() {
		return accountType;
	}


	public void setAccountType(String accountType) {
		this.accountType = accountType;
	}


	



	public String getBankCode() {
		return bankCode;
	}


	public void setBankCode(String bankCode) {
		this.bankCode = bankCode;
	}


	public String getMerchantTrxnRefId() {
		return merchantTrxnRefId;
	}


	public void setMerchantTrxnRefId(String merchantTrxnRefId) {
		this.merchantTrxnRefId = merchantTrxnRefId;
	}


	public String getShareHolderNo() {
		return shareHolderNo;
	}


	public void setShareHolderNo(String shareHolderNo) {
		this.shareHolderNo = shareHolderNo;
	}


	public Date getStartDate() {
		return startDate;
	}


	public void setStartDate(Date startDate) {
		this.startDate = startDate;
	}


	public Date getExpiryDate() {
		return expiryDate;
	}


	public void setExpiryDate(Date expiryDate) {
		this.expiryDate = expiryDate;
	}





	public String getAddress() {
		return address;
	}





	public void setAddress(String address) {
		this.address = address;
	}





	public String getUniqueId() {
		return uniqueId;
	}





	public void setUniqueId(String uniqueId) {
		this.uniqueId = uniqueId;
	}





	public String getBankName() {
		return bankName;
	}





	public void setBankName(String bankName) {
		this.bankName = bankName;
	}




	


	public double getTerms() {
		return terms;
	}




	public void setTerms(double terms) {
		this.terms = terms;
	}




	


	public ArrayList<String> getList() {
		return list;
	}




	public void setList(ArrayList<String> list) {
		this.list = list;
	}




	public ArrayList<SelectItem> getBankCodeList() {
		return bankCodeList;
	}




	public void setBankCodeList(ArrayList<SelectItem> bankCodeList) {
		this.bankCodeList = bankCodeList;
	}




	public DataBaseMethods getDd() {
		return dd;
	}




	public void setDd(DataBaseMethods dd) {
		this.dd = dd;
	}
	
	public String getDebitAmount() {
		return debitAmount;
	}




	public void setDebitAmount(String debitAmount) {
		this.debitAmount = debitAmount;
	}




	public String getCollectionAmount() {
		return collectionAmount;
	}




	public void setCollectionAmount(String collectionAmount) {
		this.collectionAmount = collectionAmount;
	}




	public String getCallbackUrl() {
		return callbackUrl;
	}




	public void setCallbackUrl(String callbackUrl) {
		this.callbackUrl = callbackUrl;
	}

	public String getMandateUrl() {
		return mandateUrl;
	}
	public void setMandateUrl(String mandateUrl) {
		this.mandateUrl = mandateUrl;
	}
	public boolean isRegForm() {
		return regForm;
	}
	public void setRegForm(boolean regForm) {
		this.regForm = regForm;
	}

	public String getLoanNo() {
		return loanNo;
	}


	public void setLoanNo(String loanNo) {
		this.loanNo = loanNo;
	}









	public boolean isIsmandateUrl() {
		return ismandateUrl;
	}









	public void setIsmandateUrl(boolean ismandateUrl) {
		this.ismandateUrl = ismandateUrl;
	}









	public String getRedirectUrl() {
		return redirectUrl;
	}









	public void setRedirectUrl(String redirectUrl) {
		this.redirectUrl = redirectUrl;
	}









	public int getSno() {
		return sno;
	}









	public void setSno(int sno) {
		this.sno = sno;
	}


	public ArrayList<SelectItem> getLoanNumList() {
		return loanNumList;
	}


	public void setLoanNumList(ArrayList<SelectItem> loanNumList) {
		this.loanNumList = loanNumList;
	}


	public String getLoanNoF() {
		return loanNoF;
	}


	public void setLoanNoF(String loanNoF) {
		this.loanNoF = loanNoF;
	}


	public boolean isRd() {
		return rd;
	}


	public void setRd(boolean rd) {
		this.rd = rd;
	}


	public String getCustomerRdNumber() {
		return customerRdNumber;
	}


	public void setCustomerRdNumber(String customerRdNumber) {
		this.customerRdNumber = customerRdNumber;
	}


	public ArrayList<SelectItem> getRdList() {
		return rdList;
	}


	public void setRdList(ArrayList<SelectItem> rdList) {
		this.rdList = rdList;
	}
	
}