SFAccountInformationViewHelper

mail@pastecode.io avatar
unknown
plain_text
a month ago
42 kB
2
Indexable
Never
//---------------Copyright (c) 2003 VeriSign, Inc. ----------------------------

//-----------------------------------------------------------------------------
// package
//-----------------------------------------------------------------------------
package com.nsi.storefront.customtag.viewhelper;

//-----------------------------------------------------------------------------
// import
//-----------------------------------------------------------------------------
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Vector;

import javax.servlet.jsp.JspContext;
import javax.servlet.jsp.JspException;

import com.nsi.storefront.beans.*;
import com.nsi.storefront.business.SFDomain;
import com.nsi.storefront.business.SFDotComEmail;
import com.nsi.storefront.business.SFPointsToInfo;
import com.nsi.storefront.business.SFProduct;
import com.nsi.storefront.business.SFProductHolder;
import com.nsi.storefront.business.SFUserAccountManager;
import com.nsi.storefront.constants.SFACHConstant;
import com.nsi.storefront.constants.SFClassNameConstant;
import com.nsi.storefront.constants.SFCreditCardConstant;
import com.nsi.storefront.constants.SFPaymentTypeEnum;
import com.nsi.storefront.customtag.framework.SFOutputAttributes;
import com.nsi.storefront.customtag.framework.SFTagAttributes;
import com.nsi.storefront.customtag.framework.SFViewHelper;
import com.nsi.storefront.exception.SFException;
import com.nsi.storefront.exception.SFFGException;
import com.nsi.storefront.helpers.SFHelperManager;
import com.nsi.storefront.statistics.SFMethodStatistics;
import com.nsi.storefront.utils.CountryHelper;
import com.nsi.storefront.utils.SFArrayUtil;
import com.nsi.storefront.utils.SFLogger;
import com.nsi.storefront.utils.SFStringUtil;
import com.nsi.storefront.utils.SFUtils;
import com.nsi.storefront.utils.SFWalletUtils;
import com.nsi.storefront.xmlschema.logging.types.LogEntryTypeEnum;
import com.nsi.storefront.xmlschema.security.types.RoleEnum;


//-----------------------------------------------------------------------------
// Description
//-----------------------------------------------------------------------------
/**
 * This view helper is to be used by account-info.jhtml
 * to provide information needed to render account details.
 *
 * @author 	Aaron Krebs
 * @version 	1.0
 */
public class SFAccountInformationViewHelper extends SFViewHelper
{
		/**
		 *     SCCS control ID
		 */
		public static final String sccsID = "%TC-INFO%";

		//-------------------------------------
		// constants
		//-------------------------------------
		public static final String PARAMETER_ACCOUNT_ID           = "accountId";
		public static final String PARAMETER_ACCOUNT_ID_DEFAULT   = "0";
		public static final String PARAMETER_ATTRIBUTE_PAGE_NAME = "pageName";

        // -------------------------------------
        // blockname values
        // -------------------------------------
        public static final String OUTPUT_ATTRIBUTE_BLOCK_NAME = "blockName";        
        public static final String BLOCK_NAME_OUTPUT = "output";
        public static final String BLOCK_NAME_ERROR  = "error";
        public static final String OUTPUT_ATTRIBUTE_SHOW_PRI_REG_LINK = "showPrivateRegLink";
        
        
		//-------------------------------------
		// helper/business members
		//-------------------------------------
		private SFAccount mAccount;
		private SFUserProductSnapshot userProductSnapshot = null;
		private String[] prAccountHolderStrings;


		/**
		 * Processes inputs and prepares output for rendering. Called by SFViewHelperTag
		 * through SFViewHelper
		 * 
		 * @param pContext
		 * @param pInputAttributes
		 *            the request to be processed
		 * @param pOutputAttributes
		 *            the response object for this request
		 */
		public void beforeRendering(JspContext pContext,
				SFTagAttributes pInputAttributes,
				SFOutputAttributes pOutputAttributes) throws JspException,
				IOException, SFException {
			
				String method = "SFAccountInformationViewHelper.beforeRendering";
				SFMethodStatistics stat = SFMethodStatistics.getInstance();
				long statId = stat.start(method);


			try
			{
				//TR107113
				String pageName = pInputAttributes.getOptionalStringAttribute(PARAMETER_ATTRIBUTE_PAGE_NAME, null);
				SFLogger.printDebug("beforeRendering() page name is == "+ pageName);
				
				// account id
				setAccountId(pInputAttributes.getOptionalStringAttribute(PARAMETER_ACCOUNT_ID,
																		PARAMETER_ACCOUNT_ID_DEFAULT));

				int nAccountId = Integer.parseInt(getAccountId());

				SFLogger.printDebug("beforeRendering() accountId == "+nAccountId);

				mAccount = mUserAccountManager.getAccount(nAccountId);

				SFAccountViewer accountViewer = new SFAccountViewer();
				accountViewer.setAccount(mAccount);
				
				SFLogger.printDebug("beforeRendering() account == "+mAccount);

				if (SFDomainDetailsViewHelper.getDemoMode() >= 0)
				{
					SFLogger.printDebug("beforeRendering() Using demo account instead.");
					mAccount = SFDomainDetailsViewHelper.getDemoAccount();
				}

				// account name
				setAccountName(mAccount.getAccountName());
				SFLogger.printDebug("beforeRendering() set accountName to "+getAccountName());

				// formatted account name
				String formattedAccountName = "";
				String accountName = getAccountName();
				if ((accountName == null) || (accountName.trim().length() == 0) ||
						accountName.trim().equals("-1"))
				{
					formattedAccountName = ""+getAccountId();
				}
				else
				{
					formattedAccountName = accountName+" ("+getAccountId()+")";
				}
				setFormattedAccountName(formattedAccountName);
				SFLogger.printDebug("beforeRendering() set FormattedAccountName to "+getFormattedAccountName());

				
				// account product limit
				setIsProductExceedLimit(mAccount.isThresholdExceeded());

				// any domain product contained (already pulled from FG) in the account
				setHasAnyDomainProduct(accountViewer.getNumDomains() > 0);
				
				//TR 87850 Display Private Reg link only if supoorted
				boolean foundPRTld = this.getHasPrivRegProducts();		        
		        if ( foundPRTld)
		        	pOutputAttributes.addAttribute(OUTPUT_ATTRIBUTE_SHOW_PRI_REG_LINK, true);
		        else 
		        	pOutputAttributes.addAttribute(OUTPUT_ATTRIBUTE_SHOW_PRI_REG_LINK, false);
		        
								
				// billing information and twiddleable
				setBillingContact(mAccount.getBillingContact());
				SFLogger.printDebug("beforeRendering() BillingContact == "+getBillingContact());

				SFContactInfo contInfo = null;
				String nicHandleId = null;

				if (getBillingContact() != null)
				{
					if (getBillingContact().getUser() == null)
					{
						SFLogger.printError(LogEntryTypeEnum.ERROR_CRITICAL_PROGRAM,
											 "Error!  Contact has null user associated.");
						getBillingContact().setUser(new SFUserUnknown());
					}

					contInfo = getBillingContact().getContactInfo();
					nicHandleId = getBillingContact().getNicHandleId();
				}

				SFLogger.printDebug("beforeRendering() BillingContact info == "+contInfo);
				SFLogger.printDebug("beforeRendering() BillingContact NIC == "+nicHandleId);

				setBillingContactStrings(
						getStringArrayFromContactInfo(contInfo, nicHandleId,
																		 getBillingContact().getFullName(), false, false));

				SFLogger.printDebug("beforeRendering() BillingContact Strings == " + Arrays.toString(getBillingContactStrings()));

				//get default payment method
				setDefaultPaymentType(mAccount.getDefaultPaymentType());
				SFLogger.printDebug("beforeRendering() Default Payment Type == "+getDefaultPaymentType());
				
				// paypal id				
				if (mAccount.getPayPalInfo() != null)
				{
					setPayPalId(mAccount.getPayPalInfo().getEmail());					
				}
				SFLogger.printDebug("beforeRendering() PayPal Id == "+getPayPalId());
				
				// credit card
				setCreditCards(mAccount.getCreditCards());
				SFLogger.printDebug("beforeRendering() Credit Card == "+getCreditCards());

				Map paymentMethods = getHashMapFromPaymentMethods(mAccount);

				setPaymentMethodStrings(paymentMethods);

				SFLogger.printDebug("beforeRendering() Credit Card Strings == "+ getPaymentMethodStrings());

				// admin contacts
				Vector admins = loadUsersByRole(RoleEnum.ADMINCONTACT);
				Vector loadedAdmins = new Vector();
				Vector adminNames = new Vector();

				for (int i=0, size=admins.size(); i<size; i++)
				{
					SFUser loadedUser = (SFUser) admins.elementAt(i);

					if (loadedUser != null)
					{
			String adminContact = loadedUser.getFullName();
			if ( loadedUser.getEmail() != null && loadedUser.getEmail().length() != 0 ) {
				adminContact = adminContact + " " + loadedUser.getEmail();
			}
						SFLogger.printDebug("beforeRendering() Adding ADMINCONTACT: "+adminContact);
						adminNames.addElement(adminContact);
						loadedAdmins.addElement(loadedUser);
					}
					else
					{
						SFLogger.printDebug("beforeRendering() could not pull ADMINCONTACT #"+i);
					}
				}

				if (adminNames.size() == 0)
				{
					adminNames.addElement("None");
				}
				Collections.sort(adminNames);

				setAdminContacts(loadedAdmins);
				setAdminContactStrings(getStringArrayFromStringVector(adminNames));


				// tech contacts
				Vector techs = loadUsersByRole(RoleEnum.TECHCONTACT);
				Vector loadedTechs = new Vector();
				Vector techNames = new Vector();

				for (int i=0, size=techs.size(); i<size; i++)
				{
					SFUser loadedUser = (SFUser) techs.elementAt(i);

					if (loadedUser != null)
					{
						String techContact = loadedUser.getFullName();
						if ( loadedUser.getEmail() != null && loadedUser.getEmail().length() != 0 ) {
							techContact = techContact + " " + loadedUser.getEmail();
						}
						SFLogger.printDebug("beforeRendering() Adding TECHCONTACT: "+techContact);
						techNames.addElement(techContact);
						loadedTechs.addElement(loadedUser);
					}
					else
					{
						SFLogger.printDebug("beforeRendering() could not pull TECHCONTACT #"+i);
					}
				}

				if (techNames.size() == 0)
				{
					techNames.addElement("None");
				}
				Collections.sort(techNames);

				setTechContacts(loadedTechs);
				setTechContactStrings(getStringArrayFromStringVector(techNames));


				// primary user
				Vector primaryVector = loadUsersByRole(RoleEnum.PRIMARYUSER);
				SFUser primaryUser = null;

				if (primaryVector.size() > 0)
				{
					setPrimary((SFUser) primaryVector.elementAt(0));
					SFLogger.printDebug("beforeRendering() Got primary user id "+getPrimary().getUserId());
				}
				else
				{
					SFLogger.printDebug("beforeRendering() Got no primary user information!");
					setPrimary(new SFUserUnknown());
				}

				boolean isPrimary = mUserBean.getUserId()==getPrimary().getUserId();

				SFLogger.printDebug("beforeRendering() isPrimary == "+isPrimary);

				setPrimaryStrings(getStringArrayFromContactInfo(
						getPrimary().getContactInfo(), getPrimary().getNicHandleId(),
						getPrimary().getFullName(), isPrimary, true));


				// account holder
				Vector holderVector = loadUsersByRole(RoleEnum.ACCOUNTHOLDER);
				SFUser holderUser = null;

				if (holderVector.size() > 0)
				{
					setAccountHolder((SFUser) holderVector.elementAt(0));
					SFLogger.printDebug("beforeRendering() Got account holder user id "+getAccountHolder().getUserId());
				}
				else
				{
					setAccountHolder(new SFUserUnknown());
					SFLogger.printDebug("beforeRendering() Got no holder user information!");
				}

				//TR107113 - testing up-sell private reg
				if(pageName!= null && (pageName.equals("prWidget"))) {
					setPrAccountHolderStrings(getWhoisString());
					SFLogger.printDebug("beforeRendering() PR AH Strings == "+ Arrays.toString(getPrAccountHolderStrings()));
					return;
				}
				
				boolean isAcctHolder =
					mUserBean.getUserId()==getAccountHolder().getUserId();

				SFLogger.printDebug("beforeRendering() isAcctHolder == "+isAcctHolder);

				setAccountHolderStrings(getStringArrayFromContactInfo(
						getAccountHolder().getContactInfo(),
						getAccountHolder().getNicHandleId(),
						getAccountHolder().getFullName(), isAcctHolder, true));
				
				SFLogger.printDebug("beforeRendering() AH Strings == "+ Arrays.toString(getAccountHolderStrings()));


				// is organizational account?
				setAccountHolderIsOrg(getAccountHolder() instanceof SFOrg);
				SFLogger.printDebug("beforeRendering() AH ORG? "+getAccountHolderIsOrg());

				// username
				setUserFullName(mUserBean.getUser().getFullName());
				SFLogger.printDebug("beforeRendering() UserFullName == "+getUserFullName());

				// role
				setUserRole(mUserAccountManager.getRelation(mUserBean.getUserId(),nAccountId));
				SFLogger.printDebug("beforeRendering() UserRole == "+getUserRole());

				// role string
				String tempRoleString = "N/A";

				if (getUserRole() != null)
				{
					switch (getUserRole().getType())
					{
						case RoleEnum.ACCOUNTHOLDER_TYPE:
							tempRoleString = "Account Holder";
							break;
						case RoleEnum.ADMINCONTACT_TYPE:
							tempRoleString = "Admin Contact";
							break;
						case RoleEnum.PRIMARYUSER_TYPE:
							tempRoleString = "Primary Contact";
							break;
						case RoleEnum.TECHCONTACT_TYPE:
							tempRoleString = "Tech Contact";
							break;
						case RoleEnum.BILLINGCONTACT_TYPE:
							tempRoleString = "Billing Contact";
							break;
					}
				}

				setUserRoleString(tempRoleString);
				SFLogger.printDebug("beforeRendering() UserRoleString == "+getUserRoleString());
				
				List<SFProduct> hostingProds = mAccount.getProductCollection().getAllProductsByType(
						SFClassNameConstant.HOSTING_PRODUCT_TYPE.getDescription(), false);
				userProductSnapshot.setNoOfHostingPkgInAccount(hostingProds.size());
				
				List<SFProduct> domainProds = mAccount.getProductCollection().getAllProductsByType(
						SFClassNameConstant.DOMAIN_TYPE.getDescription(), false);
				
				List<SFProduct> priRegProds = mAccount.getProductCollection().getAllProductsByType(
						SFClassNameConstant.PRIVATE_REGISTRATION_TYPE.getDescription(), false);
				
				List<SFProduct> emailProds = mAccount.getProductCollection().getAllProductsByType(
						SFClassNameConstant.EMAIL_TYPE.getDescription(), false);
				
				List<SFProduct> depProds = mAccount.getProductCollection().getAllProductsByType(
						SFClassNameConstant.DOM_EXP_PROTECT_TYPE.getDescription(), false);

				userProductSnapshot.setNumOfWebsiteAndHostingInAccount(SFUtils.getNumOfWebsiteAndHostingInAccount(
						mAccount.getProductCollection().getProductList()));

				long tldPrivateRegDomainCount = SFUtils.getTldPrivateRegDomainCount(domainProds);

				if(tldPrivateRegDomainCount > priRegProds.size()) {
					userProductSnapshot.setDomainsMoreThanPrivateReg(true);
				}

				if (tldPrivateRegDomainCount == priRegProds.size() || domainProds.size() == depProds.size()) {
					userProductSnapshot.setAllDomainsHaveDepOrPR(true);
				}
				
				if(domainProds.size() > 2) {
					userProductSnapshot.setNoOfDomainsInAccount(domainProds.size());
				}
				
				//37866
				if(SFUtils.getDEPDomainsCount(domainProds) > depProds.size()){
					userProductSnapshot.setDomainsMoreThanDEP(true);
				}
				
				//37556
				userProductSnapshot.setNumOfSSLsInAccount(SFUtils.getNumOfSSLInAccount(mAccount.getProductCollection().getProductList()));
				
				
				if(domainProds.size() > 0 && emailProds.size() > 0) {
					userProductSnapshot.setAllDomainsHaveEmail(true);
					Iterator<SFProduct> it = domainProds.iterator();
					while(it.hasNext()) {
						SFDomain dom = (SFDomain)it.next();
						Iterator<SFProduct> emailIt = emailProds.iterator();
						boolean found = false;
						while (emailIt.hasNext()) {
							SFDotComEmail email = (SFDotComEmail)emailIt.next();
							if (dom.getName().equalsIgnoreCase(email.getDomainName())) {
								found = true;
								break;
							}
						}
						
						if (!found) {
							userProductSnapshot.setAllDomainsHaveEmail(false);
							break;
						}
					}
				}
				
				if(domainProds.size() > 0) {
					Iterator it = domainProds.iterator();
					while(it.hasNext()) {
						SFDomain dom = (SFDomain)it.next();
						if(null != dom.getPointsToInfo() && (!dom.getPointsToInfo().getHostingType().equals(SFPointsToInfo.HostingType.UNDER_CONSTRUCTION) && 
								!dom.getPointsToInfo().getHostingType().equals(SFPointsToInfo.HostingType.POINTS_TO_BIZ_PROFILE))) {
							userProductSnapshot.setDomainLive(true);
							break;
						}
					}
				}

				if(domainProds.size() > 0) {
					Iterator it = domainProds.iterator();
					while(it.hasNext()) {
						SFDomain dom = (SFDomain)it.next();
						if(null != dom.getPointsToInfo() && (dom.getPointsToInfo().getHostingType().equals(SFPointsToInfo.HostingType.UNDER_CONSTRUCTION) || 
								dom.getPointsToInfo().getHostingType().equals(SFPointsToInfo.HostingType.POINTS_TO_BIZ_PROFILE))) {
							userProductSnapshot.setDomainPointsToUCOrBizProfile(true);
							break;
						}
					}
				}
				
				int ptCnt = 0;
				if(domainProds.size() > 0) {
					Iterator it = domainProds.iterator();
					while(it.hasNext()) {
						SFDomain dom = (SFDomain)it.next();
						if(null != dom.getPointsToInfo() && dom.getPointsToInfo().getHostingType().equals(SFPointsToInfo.HostingType.POINTS_TO_HOSTING_PKG)) {
							ptCnt += 1;
						}
					}
				}
				else {
					userProductSnapshot.setDomainPointsToWebPresencePkg(false);
				}
				if(ptCnt == domainProds.size()) {
					userProductSnapshot.setDomainPointsToWebPresencePkg(true);
				}
				if (ptCnt > 0) {
					userProductSnapshot.setDomainPointsToHostingPkg(true);
				}

			}
			catch (Exception e)
			{
				stat.stop(statId,false);
				SFLogger.printError(LogEntryTypeEnum.ERROR_CRITICAL_PROGRAM, "beforeRendering(): exception found, rethrowing.");
                pOutputAttributes.addAttribute(OUTPUT_ATTRIBUTE_BLOCK_NAME, BLOCK_NAME_ERROR);
				throw new SFException(e.getMessage());
			}
			            
            pOutputAttributes.addAttribute(OUTPUT_ATTRIBUTE_BLOCK_NAME, BLOCK_NAME_OUTPUT);
            stat.stop(statId,true);
		}

		/**
		 *  Double-check to ensure full user
		 *  information is pulled for the users of matching role
		 *
		 *  @param loadRole the role to pull from this account
		 *  @return Vector the vector of guaranteed loaded users
		 */
		private Vector loadUsersByRole(RoleEnum loadRole)
						throws SFException
		{
				String method = "SFAccountInformationViewHelper.loadUsersByRole";
				SFMethodStatistics stat = SFMethodStatistics.getInstance();
				long statId = stat.start(method);

			List userVector = mUserAccountManager.getUsers(mAccount.getAccountId(), loadRole);
			Vector loadedVector = new Vector();

			if ((userVector != null) && (userVector.size() > 0))
			{
				for (int i=0, size=userVector.size(); i<size; i++)
				{
					try
					{
						SFUser user = (SFUser) userVector.get(i);
						SFUser loadedUser = mUserAccountManager.pullUserWithoutRelations(user.getUserId(),
							getHelperManager().getDataRepository().getSfSystemCredential());

						if (loadedUser != null)
						{
							SFLogger.printDebug("Adding user id "+loadedUser.getUserId()+" ("+
												 loadedUser.getFullName()+")");
							loadedVector.addElement(loadedUser);
						}
						else
						{
							SFLogger.printDebug("Could not load user id "+
												 ((user != null) ? user.getUserId() : -1));
						}
					}
					catch (SFFGException sffgE)
					{
						stat.stop(statId,false);
						SFLogger.printError(LogEntryTypeEnum.ERROR_CRITICAL_PROGRAM, "beforeRendering() caught exception when pulling users from FG.\nException: "+sffgE);
						throw new SFException(sffgE.getMessage());
					}
				}
			}
			stat.stop(statId,true);
			return loadedVector;
		}


		//---------------------------------------------
		// viewhelper methods
		//---------------------------------------------

		private String nullCheckString(String s) { return nullCheckString(s,""); }
		private String nullCheckString(String s, String defString)
		{
			if (s == null) return defString;
			return s;
		}

		private String[] getStringArrayFromStringVector(Vector vStrings)
		{
			try
			{
				String[] retArr = new String[vStrings.size()];
				return (String[]) vStrings.toArray(retArr);
			}
			catch (Exception e)
			{
				String[] errArr = new String[1];
				errArr[0] = "Error.";
				return errArr;
			}
		}

		private String[] getStringArrayFromContactInfo(SFContactInfo contInfo,
																									 String nicHandleId,
																									 String uName,
																									 boolean isYou, boolean showVAT)
		{
			if (contInfo == null)
			{
				String[] retErr = new String[1];
				retErr[0] = "Error extracting contact info.";
				return retErr;
			}

			SFAddress acctAddress = contInfo.getAddress();
			if (acctAddress == null) acctAddress = new SFAddress();

			String name = nullCheckString(uName,"n/a");
			Vector v = new Vector();
			if (name.trim().length() > 0)
			{
				if (isYou) name += " (you)";
				v.addElement(name.trim());

				String companyName = contInfo.getCompanyName();
				if ( companyName != null && companyName.length() > 0 &&
			 !companyName.equalsIgnoreCase(name) )
				{
						v.addElement(companyName);
				}

				if ( acctAddress.getStreetAddress() != null && acctAddress.getStreetAddress().length() > 0 )
					 v.addElement(acctAddress.getStreetAddress());

				if ( acctAddress.getStreetAddress2() != null && acctAddress.getStreetAddress2().length() > 0 )
					 v.addElement(acctAddress.getStreetAddress2());

				if ( acctAddress.getStreetAddress3() != null && acctAddress.getStreetAddress3().length() > 0 )
					 v.addElement(acctAddress.getStreetAddress3());

				if ( acctAddress.getStreetAddress4() != null && acctAddress.getStreetAddress4().length() > 0 )
					 v.addElement(acctAddress.getStreetAddress4());

				if ( acctAddress.getStreetAddress5() != null && acctAddress.getStreetAddress5().length() > 0 )
					 v.addElement(acctAddress.getStreetAddress5());

				String addrLine2 = null;
				if ( acctAddress.getCountry() != null )
				{
					if ( acctAddress.getCountry().equalsIgnoreCase("US") )
					{
							addrLine2 = nullCheckString(acctAddress.getCity())+", "+
													 nullCheckString(acctAddress.getState())+" "+
													 nullCheckString(acctAddress.getZip());
													 // TR 25622
													 // display the country in a separate line
													 // nullCheckString(acctAddress.getCountry());
					}
					else
					{
							addrLine2 = nullCheckString(acctAddress.getCity()) + " " +
													 nullCheckString(acctAddress.getState())+" "+
													 nullCheckString(acctAddress.getZip());
													// TR 25622
													// display the country in a separate line
													// nullCheckString(acctAddress.getCountry());
													 
					}
					v.addElement(addrLine2.trim());
					v.addElement(nullCheckString(acctAddress.getCountry()));
				}

				v.addElement("Phone: "+nullCheckString(contInfo.getPhoneNum()));
				v.addElement("Fax: "+nullCheckString(contInfo.getFaxNum()));				
				
	if (!(getAccountHolder() instanceof SFOrg))
	{
				v.addElement("E-mail: "+nullCheckString(contInfo.getEmail()));
	}
				v.addElement("NIC Handle: "+nullCheckString(nicHandleId));
			}
			else
			{
				v.addElement("N/A");
			}

			//TR101672 - display VAT number for primary user and account holder only
			
			boolean hasCountry = !SFStringUtil.isEmpty(contInfo.getCountry());
			boolean belongsToVatSupportingCountry = false;
			
			if (hasCountry) {
				belongsToVatSupportingCountry = CountryHelper.isVatSupported(contInfo.getCountry());	
			}
			
			if (showVAT && hasCountry && belongsToVatSupportingCountry)
			{
				boolean hasVatId = !SFStringUtil.isEmpty(contInfo.getVat());
				if (hasVatId) {
					v.addElement("VAT Number: " + CountryHelper.getVatIdPrefix(contInfo.getCountry()) + " " + contInfo.getVat());
					
				} else {
					
					v.addElement("VAT number not provided");					
				}
				
			}
			
			return getStringArrayFromStringVector(v);
		}

		private Map getHashMapFromPaymentMethods(SFAccount account){
			
			Map resultMap = new HashMap();
			String[] levels = SFCreditCardConstant.getPriorityLevels();

			if (account.getCreditCards() != null) {
				List<String> levelKeyList = SFWalletUtils.buildCreditCardKeyList(account.getCreditCards(), levels);
				if(SFWalletUtils.isUseWalletForPurchase(account)){
					populateWalletsResultMap(account.getCreditCards(), resultMap, levels, levelKeyList);
				}
				else{
					populateResultMap(account.getCreditCards(), resultMap, levels);
				}

			}

			levels = SFACHConstant.getPriorityLevels();
			if (account.getACHMap() != null) {
				List<String> levelKeyList = SFWalletUtils.buildACHKeyList(account.getACHMap(), levels);
				if(SFWalletUtils.isUseWalletForPurchase(account)){
					populateWalletsResultMap(account.getACHMap(), resultMap, levels, levelKeyList);
				}
				else{
					populateResultMap(account.getACHMap(), resultMap, levels);
				}

			}


			return resultMap;
		}
		
		/**
		 * this will perform the default logic based on current netsol
		 * @param paymentMethods
		 * @param map
		 */
		private void populateResultMap(Map paymentMethods, Map<String,String[]> map, String levels[]){

			boolean hasPrimaryCC = true;
			boolean hasPrimaryACH = true;
			
			for (int i = 0; i < paymentMethods.size(); i++) {

				if (paymentMethods.get(levels[i]) instanceof SFUserCreditCard)
				{
					SFUserCreditCard creditCard = (SFUserCreditCard)paymentMethods.get(levels[i]);

					if (levels[i].equalsIgnoreCase(SFCreditCardConstant.PRIMARY.getDescription()) ||
							(levels[i].equalsIgnoreCase(SFCreditCardConstant.SECONDARY.getDescription()) &&
									hasPrimaryCC)) {
						if (creditCard!= null) {
							map.put(levels[i], getStringArrayFromCreditCard(creditCard));
						} else {
//							Vector v = new Vector();
//							v.addElement("N/A");
//							map.put(levels[i], getStringArrayFromStringVector(v));
						}
						if (levels[i].equalsIgnoreCase(SFCreditCardConstant.PRIMARY.getDescription())) {
							String value[] = (String[])map.get(levels[i]);
							if (value.length == 1 && value[0].equalsIgnoreCase("N/A")) {
								hasPrimaryCC = false;
							}
						}
					}
				}
				else if (paymentMethods.get(levels[i]) instanceof SFACHInfo)
				{
					SFACHInfo sfachInfo = (SFACHInfo)paymentMethods.get(levels[i]);

					if (levels[i].equalsIgnoreCase(SFACHConstant.PRIMARY.getDescription()) ||
							(levels[i].equalsIgnoreCase(SFACHConstant.SECONDARY.getDescription()) &&
									hasPrimaryACH))
					{
						if (sfachInfo!= null) {
							map.put(levels[i], getStringArrayFromACHInfo(sfachInfo));
						} else {
//							Vector v = new Vector();
//							v.addElement("N/A");
//							map.put(levels[i], getStringArrayFromStringVector(v));
						}

						if (levels[i].equalsIgnoreCase(SFACHConstant.PRIMARY.getDescription())) {
							String value[] = map.get(levels[i]);
							if (value.length == 1 && value[0].equalsIgnoreCase("N/A")) {
								hasPrimaryACH = false;
							}
						}
					}
				}

			}
		}
		
		/**
		 * this will perform the default logic based on wallets logic
		 * @param paymentMethods
		 * @param resultMap
		 */
		private void populateWalletsResultMap(Map paymentMethods, Map<String,String[]> resultMap, String levels[], List<String> levelKeyList){

			for (int i = 0; i < levelKeyList.size(); i++)
			{
				String currentLevel = levelKeyList.get(i);

				if (paymentMethods.get(currentLevel) instanceof SFUserCreditCard)
				{
					SFUserCreditCard creditCard = (SFUserCreditCard)paymentMethods.get(currentLevel);

					if (creditCard!= null) {
						resultMap.put(currentLevel, getStringArrayFromCreditCard(creditCard));
					} else {
//						Vector v = new Vector();
//						v.addElement("N/A");
//						resultMap.put(currentLevel, getStringArrayFromStringVector(v));
					}
				}
				else if (paymentMethods.get(currentLevel) instanceof SFACHInfo)
				{
					SFACHInfo achInfo = (SFACHInfo)paymentMethods.get(currentLevel);

					if (achInfo!= null) {
						resultMap.put(currentLevel, getStringArrayFromACHInfo(achInfo));
					} else {
//						Vector v = new Vector();
//						v.addElement("N/A");
//						resultMap.put(currentLevel, getStringArrayFromStringVector(v));
					}
				}

			}
		}

	private String[] getStringArrayFromACHInfo(SFACHInfo sfachInfo)
	{
		Vector v = new Vector();
		StringBuffer temp = new StringBuffer("");

		// worst case will read "n/a"
		temp.append(nullCheckString(sfachInfo.getEcAccountType()));

		if (temp.toString().trim().length() > 0)
		{
			v.addElement(temp.toString().trim());

			temp = new StringBuffer("");
			temp.append(nullCheckString(sfachInfo.getBankAccountNumber()));
			if (temp.toString().trim().length() > 0)
				v.addElement(temp.toString().trim());

			temp = new StringBuffer("");
			temp.append(nullCheckString(sfachInfo.getLastName() + ", " +  sfachInfo.getFirstName()));
			if (temp.toString().trim().length() > 0)
				v.addElement(temp.toString().trim());

			temp = new StringBuffer("");
			temp.append(nullCheckString(sfachInfo.getAddress1() ));
			if (temp.toString().trim().length() > 0 && sfachInfo.getAddress2() != null && sfachInfo.getAddress2().trim().length() > 0)
			{
				temp.append(". ");
				temp.append(sfachInfo.getAddress2());
			}

			if (temp.toString().trim().length() > 0)
				v.addElement(temp.toString().trim());

			temp = new StringBuffer("");
			temp.append(nullCheckString(sfachInfo.getCity()));
			if (temp.toString().trim().length() > 0) temp.append(", ");
			temp.append(nullCheckString(sfachInfo.getState()));
			if (temp.toString().trim().length() > 1)
				temp.append(" ");
			else
				temp = new StringBuffer("");
			temp.append(nullCheckString(sfachInfo.getCountry()));
			if (temp.toString().trim().length() > 0)
				v.addElement(temp.toString().trim());
		}
		else
		{
//			v.addElement("N/A");
		}

		return getStringArrayFromStringVector(v);
	}


		private String[] getStringArrayFromCreditCard(SFUserCreditCard creditCard)
		{
			Vector v = new Vector();
			StringBuffer temp = new StringBuffer("");

			// worst case, card type will read "n/a"
			temp.append(nullCheckString(creditCard.getCreditCardType()));
			temp.append(" ");
			temp.append(nullCheckString(creditCard.getForcedMaskedCreditCardNumber()));

			if (temp.toString().trim().length() > 0)
			{
				v.addElement(temp.toString().trim());

				temp = new StringBuffer("");
				temp.append(nullCheckString(creditCard.getExpirationMonth()));
				temp.append(" ");
				temp.append(nullCheckString(creditCard.getExpirationYear()));
				if (temp.toString().trim().length() > 0)
					v.addElement(temp.toString().trim());

				temp = new StringBuffer("");
				temp.append(nullCheckString(creditCard.getCardholdersName()));
				if (temp.toString().trim().length() > 0)
					v.addElement(temp.toString().trim());

				temp = new StringBuffer("");
				temp.append(nullCheckString(creditCard.getStreetAddress()));
				if (temp.toString().trim().length() > 0)
					v.addElement(temp.toString().trim());

				temp = new StringBuffer("");
				temp.append(nullCheckString(creditCard.getCity()));
				if (temp.toString().trim().length() > 0) temp.append(", ");
				temp.append(nullCheckString(creditCard.getStateprov()));
				if (temp.toString().trim().length() > 1)
					temp.append(" ");
				else
					temp = new StringBuffer("");
				temp.append(nullCheckString(creditCard.getCountry()));
				if (temp.toString().trim().length() > 0)
					v.addElement(temp.toString().trim());
			}
			else
			{
//				v.addElement("N/A");
			}

			return getStringArrayFromStringVector(v);
		}


		//---------------------------------------------
		// viewhelper convenience members and get/set
		//---------------------------------------------

		/**
		 *  The account id
		 */

		private String mAccountId;

		public String getAccountId()
		{
			return mAccountId;
		}

		public void setAccountId(String pAccountId)
		{
			mAccountId = pAccountId;
		}


		/**
		 *  The account name
		 */

		private String mAccountName;

		public String getAccountName()
		{
			return mAccountName;
		}

		public void setAccountName(String pAccountName)
		{
			mAccountName = pAccountName;
		}


		/**
		 *  The formatted account name (e.g. "<name> (<id>)" or "<id>")
		 */

		private String mFormattedAccountName;

		public String getFormattedAccountName()
		{
			return mFormattedAccountName;
		}

		public void setFormattedAccountName(String pFormattedAccountName)
		{
			mFormattedAccountName = pFormattedAccountName;
		}

		/**
		 *  The boolean indicating if the account has a number of products exceeds the limit
		 */
		
		private boolean mIsProductExceedLimit;
		
		public boolean getIsProductExceedLimit()
		{
			return mIsProductExceedLimit;
		}
		
		public void setIsProductExceedLimit(boolean pIsProductExceedLimit)
		{
			mIsProductExceedLimit = pIsProductExceedLimit;
		}
	
		/**
		 *  The boolean indicating if the account has a number of products exceeds the limit
		 */
			
		private boolean mHasAnyDomainProduct;
			
		public boolean getHasAnyDomainProduct()
		{
			return mHasAnyDomainProduct;
		}
			
		public void setHasAnyDomainProduct(boolean pHasAnyDomainProduct)
		{
			mHasAnyDomainProduct = pHasAnyDomainProduct;
		}
	
		/**
		 *  The account owner
		 */

		private SFUser mPrimary;

		public SFUser getPrimary()
		{
			return mPrimary;
		}

		public void setPrimary(SFUser pPrimary)
		{
			mPrimary = pPrimary;
		}


		/**
		 *  The account owner string-array
		 */

		private String[] mPrimaryStrings;

		public String[] getPrimaryStrings()
		{
			return mPrimaryStrings;
		}

		public void setPrimaryStrings(String[] pPrimaryStrings)
		{
			mPrimaryStrings = pPrimaryStrings;
		}


		/**
		 *  The account holder
		 */

		private SFUser mAccountHolder;

		public SFUser getAccountHolder()
		{
			return mAccountHolder;
		}

		public void setAccountHolder(SFUser pAccountHolder)
		{
			mAccountHolder = pAccountHolder;
		}


		/**
		 *  The account holder display strings
		 */

		private String[] mAccountHolderStrings;

		public String[] getAccountHolderStrings()
		{
			return mAccountHolderStrings;
		}

		public void setAccountHolderStrings(String[] pAccountHolderStrings)
		{
			mAccountHolderStrings = pAccountHolderStrings;
		}


		/**
		 *  The account holder's org status
		 */

		private boolean mAccountHolderIsOrg;

		public boolean getAccountHolderIsOrg()
		{
			return mAccountHolderIsOrg;
		}

		public void setAccountHolderIsOrg(boolean pAccountHolderIsOrg)
		{
			mAccountHolderIsOrg = pAccountHolderIsOrg;
		}


		/**
		 *  The account billing information
		 */

		private SFContact mBillingContact;

		public SFContact getBillingContact()
		{
			return mBillingContact;
		}

		public void setBillingContact(SFContact pBillingContact)
		{
			mBillingContact = pBillingContact;
		}


		/**
		 *  The account billing information strings
		 */

		private String[] mBillingContactStrings;

		public String[] getBillingContactStrings()
		{
			return mBillingContactStrings;
		}

		public void setBillingContactStrings(String[] pBillingContactStrings)
		{
			mBillingContactStrings = pBillingContactStrings;
		}


		/**
		 *  The account credit card info
		 */

		private Map mCreditCards;

		public Map getCreditCards()
		{
			return mCreditCards;
		}

		public void setCreditCards(Map map)
		{
			mCreditCards = (Map) map;
		}


		/**
		 *  The account credit card info string-array
		 */

		private Map paymentMethodStrings;

		public Map getPaymentMethodStrings()
		{
			return paymentMethodStrings;
		}

		public void setPaymentMethodStrings(Map map)
		{
			paymentMethodStrings = map;
		}

		// for backwards compatibility
		public Map getCreditCardsStrings()
		{
			return paymentMethodStrings;
		}

		/*
		 * The account paypal id
		 */
		private String mPayPalId;
		
		public String getPayPalId()
		{
			return mPayPalId;
		}
		
		public void setPayPalId(String pPayPalId)
		{
			mPayPalId = pPayPalId;
		}
		
		/*
		 * account payment default method
		 */
		private SFPaymentTypeEnum mDefaultPaymentType;
		
		public SFPaymentTypeEnum getDefaultPaymentType()
		{
			return mDefaultPaymentType;
		}
		
		public void setDefaultPaymentType(SFPaymentTypeEnum pDefaultPaymentType)
		{
			mDefaultPaymentType = pDefaultPaymentType;
		}

		/**
		 *  The account admin contacts
		 */

		private Vector mAdminContacts;

		public Vector getAdminContacts()
		{
			return mAdminContacts;
		}

		public void setAdminContacts(Vector pAdminContacts)
		{
			mAdminContacts = pAdminContacts;
		}


		/**
		 *  The account admin contacts
		 */

		private String[] mAdminContactStrings;

		public String[] getAdminContactStrings()
		{
			return mAdminContactStrings;
		}

		public void setAdminContactStrings(String[] pAdminContactStrings)
		{
			mAdminContactStrings = pAdminContactStrings;
		}

		// # of contacts
		public int getNumAdminContactStrings()
		{
			return (mAdminContactStrings == null) ? 0 : mAdminContactStrings.length;
		}


		/**
		 *  The account tech contacts
		 */

		private Vector mTechContacts;

		public Vector getTechContacts()
		{
			return mTechContacts;
		}

		public void setTechContacts(Vector pTechContacts)
		{
			mTechContacts = pTechContacts;
		}


		/**
		 *  The account tech contacts
		 */

		private String[] mTechContactStrings;

		public String[] getTechContactStrings()
		{
			return mTechContactStrings;
		}

		public void setTechContactStrings(String[] pTechContactStrings)
		{
			mTechContactStrings = pTechContactStrings;
		}

		// # of contacts
		public int getNumTechContactStrings()
		{
			return (mTechContactStrings == null) ? 0 : mTechContactStrings.length;
		}


		/**
		 *  The user role for this account
		 */

		private RoleEnum mUserRole;

		public RoleEnum getUserRole()
		{
			return mUserRole;
		}

		public void setUserRole(RoleEnum pUserRole)
		{
			mUserRole = pUserRole;
		}


		/**
		 *  The user role for this account
		 */

		private String mUserRoleString;

		public String getUserRoleString()
		{
			return mUserRoleString;
		}

		public void setUserRoleString(String pUserRoleString)
		{
			mUserRoleString = pUserRoleString;
		}


		/**
		 *  The user full name
		 */

		private String mUserFullName;

		public String getUserFullName()
		{
			return mUserFullName;
		}

		public void setUserFullName(String pUserFullName)
		{
			mUserFullName = pUserFullName;
		}


		//-------------------------------------
		// facade components
		//-------------------------------------

		/**
		 *  The user bean
		 */

		private SFUserBean mUserBean;

		public SFUserBean getUserBean()
		{
			return mUserBean;
		}

		public void setUserBean(SFUserBean pUserBean)
		{
			mUserBean = pUserBean;
		}


		/**
		 *  The helper manager
		 */

		private SFHelperManager mHelperManager;

		public SFHelperManager getHelperManager()
		{
			return mHelperManager;
		}

		public void setHelperManager(SFHelperManager pHelperManager)
		{
			mHelperManager = pHelperManager;
		}


		/**
		 *  The user account manager
		 */

		private SFUserAccountManager mUserAccountManager;

		public SFUserAccountManager getUserAccountManager()
		{
			return mUserAccountManager;
		}

		public void setUserAccountManager(SFUserAccountManager pUserAccountManager)
		{
			mUserAccountManager = pUserAccountManager;
		}
		
		
		public boolean getHasPrivRegProducts() {
			boolean result = false;

			SFProductHolder ph= mAccount.getProductCollection();
			if (ph != null) {
				List<SFDomain> domainList = ph.getAllProductByType("com.nsi.storefront.business.SFDomain");
				   				
				for (SFDomain domain : domainList) {
					//Check if the tld supports PR
    				boolean tldSupportedForPR = SFUtils.isTldSupportedForPR(domain.getDomainName());
    				
					if (tldSupportedForPR)
					{
						// upsell PR for tlds that support PR
						result = true;
						break;
					}  					
				}
				
			}
			return result;
		}

		/**
		 * @return the userProductSnapshot
		 */
		public SFUserProductSnapshot getUserProductSnapshot() {
			return userProductSnapshot;
		}

		/**
		 * @param userProductSnapshot the userProductSnapshot to set
		 */
		public void setUserProductSnapshot(SFUserProductSnapshot userProductSnapshot) {
			this.userProductSnapshot = userProductSnapshot;
		}
		
		/**
		 * @return an String array contains info shows on whois
		 */
		private String[] getWhoisString () {
			SFUser user = getAccountHolder();
			List<String> accountHolder = new ArrayList<String>();
			SFAddress address= user.getAddress();
			
			if (user instanceof SFOrg && user.getCompanyName() != null) {
				accountHolder.add(user.getCompanyName());
			} else {
				accountHolder.add(nullCheckString(user.getFullName()));
			}
			
			accountHolder.add(nullCheckString(user.getEmail()));
			accountHolder.add(nullCheckString(address.getStreetAddress()));
			accountHolder.add(nullCheckString(address.getStreetAddress2()));
			accountHolder.add(nullCheckString(address.getStreetAddress3()));
			accountHolder.add(nullCheckString(address.getStreetAddress4()));
			accountHolder.add(nullCheckString(address.getStreetAddress5()));
			String cityStateZip = nullCheckString(address.getCity()) + ", " + nullCheckString(address.getState()) + " " + nullCheckString(address.getZip());
			accountHolder.add(cityStateZip);
			accountHolder.add(nullCheckString(address.getCountry()));
			accountHolder.add(nullCheckString("Phone: " + getAccountHolder().getPhoneNum()));
			
			String[] newStrings = SFArrayUtil.listToArray(accountHolder);
			
			return newStrings;
		}
		
		public String[] getPrAccountHolderStrings() {
			return this.prAccountHolderStrings;
		}
		
		public void setPrAccountHolderStrings (String[] PrAccountHolderStrings) {
			this.prAccountHolderStrings = PrAccountHolderStrings;
		}
}
//-----------------------------------------------------------------------------
// End of the file SFAccountInformationViewHelper
//-------------Copyright (c) 2002 VeriSign, Inc. ------------------------------