private static final Logger s_logger = Logger.getLogger(BaseCmd.class.getName());

public static final String USER_ERROR_MESSAGE = "Internal error executing command, please contact your system administrator";

public static final int PROGRESS_INSTANCE_CREATED = 1;

public static final String RESPONSE_TYPE_XML = "xml";

public static final String RESPONSE_TYPE_JSON = "json";

public enum CommandType {

BOOLEAN, DATE, FLOAT, INTEGER, SHORT, LIST, LONG, OBJECT, MAP, STRING, TZDATE, UUID

}

public static final DateFormat INPUT_FORMAT = new SimpleDateFormat("yyyy-MM-dd");

public static final DateFormat NEW_INPUT_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

public static Pattern newInputDateFormat = Pattern.compile("[\\d]+-[\\d]+-[\\d]+ [\\d]+:[\\d]+:[\\d]+");

private static final DateFormat _outputFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ");

private Object _responseObject = null;

private Map<String, String> fullUrlParams;

public enum HTTPMethod {

GET, POST, PUT, DELETE

}

private HTTPMethod httpMethod;

@Parameter(name = "response", type = CommandType.STRING)

private String responseType;

@Inject public ConfigurationService _configService;

@Inject public AccountService _accountService;

@Inject public UserVmService _userVmService;

@Inject public ManagementService _mgr;

@Inject public StorageService _storageService;

@Inject public VolumeApiService _volumeService;

@Inject public ResourceService _resourceService;

@Inject public NetworkService _networkService;

@Inject public TemplateApiService _templateService;

@Inject public SecurityGroupService _securityGroupService;

@Inject public SnapshotApiService _snapshotService;

@Inject public VpcVirtualNetworkApplianceService _routerService;

@Inject public ResponseGenerator _responseGenerator;

@Inject public EntityManager _entityMgr;

@Inject public RulesService _rulesService;

@Inject public AutoScaleService _autoScaleService;

@Inject public LoadBalancingRulesService _lbService;

@Inject public RemoteAccessVpnService _ravService;

@Inject public ProjectService _projectService;

@Inject public FirewallService _firewallService;

@Inject public DomainService _domainService;

@Inject public ResourceLimitService _resourceLimitService;

@Inject public IdentityService _identityService;

@Inject public StorageNetworkService _storageNetworkService;

@Inject public TaggedResourceService _taggedResourceService;

@Inject public ResourceMetaDataService _resourceMetaDataService;

@Inject public VpcService _vpcService;

@Inject public NetworkACLService _networkACLService;

@Inject public Site2SiteVpnService _s2sVpnService;

@Inject public QueryService _queryService;

@Inject public UsageService _usageService;

@Inject public NetworkUsageService _networkUsageService;

@Inject public VMSnapshotService _vmSnapshotService;

@Inject public DataStoreProviderApiService dataStoreProviderApiService;

@Inject public VpcProvisioningService _vpcProvSvc;

@Inject public ApplicationLoadBalancerService _newLbSvc;

@Inject public ApplicationLoadBalancerService _appLbService;

@Inject public AffinityGroupService _affinityGroupService;

@Inject public InternalLoadBalancerElementService _internalLbElementSvc;

@Inject public InternalLoadBalancerVMService _internalLbSvc;

@Inject public NetworkModel _ntwkModel;

public abstract void execute() throws ResourceUnavailableException, InsufficientCapacityException, ServerApiException, ConcurrentOperationException, ResourceAllocationException, NetworkRuleConflictException;

public void configure() {

}

public HTTPMethod getHttpMethod() {

return httpMethod;

}

public void setHttpMethod(String method) {

if (method != null) {

if (method.equalsIgnoreCase("GET"))

httpMethod = HTTPMethod.GET;

else if (method.equalsIgnoreCase("PUT"))

httpMethod = HTTPMethod.PUT;

else if (method.equalsIgnoreCase("POST"))

httpMethod = HTTPMethod.POST;

else if (method.equalsIgnoreCase("DELETE"))

httpMethod = HTTPMethod.DELETE;

} else {

httpMethod = HTTPMethod.GET;

}

}

public String getResponseType() {

if (responseType == null) {

return RESPONSE_TYPE_XML;

}

return responseType;

}

public void setResponseType(String responseType) {

this.responseType = responseType;

}

public abstract String getCommandName();

/**

public abstract long getEntityOwnerId();

public Object getResponseObject() {

return _responseObject;

}

public void setResponseObject(Object responseObject) {

_responseObject = responseObject;

}

public ManagementService getMgmtServiceRef() {

return _mgr;

}

public static String getDateString(Date date) {

if (date == null) {

return "";

}

String formattedString = null;

synchronized (_outputFormat) {

formattedString = _outputFormat.format(date);

}

return formattedString;

}

// FIXME: move this to a utils method so that maps can be unpacked and integer/long values can be appropriately cast

@SuppressWarnings({ "unchecked", "rawtypes" })

public Map<String, Object> unpackParams(Map<String, String> params) {

Map<String, Object> lowercaseParams = new HashMap<String, Object>();

for (String key : params.keySet()) {

int arrayStartIndex = key.indexOf('[');

int arrayStartLastIndex = key.lastIndexOf('[');

if (arrayStartIndex != arrayStartLastIndex) {

throw new ServerApiException(ApiErrorCode.MALFORMED_PARAMETER_ERROR, "Unable to decode parameter " + key

+ "; if specifying an object array, please use parameter[index].field=XXX, e.g. userGroupList[0].group=httpGroup");

}

if (arrayStartIndex > 0) {

int arrayEndIndex = key.indexOf(']');

int arrayEndLastIndex = key.lastIndexOf(']');

if ((arrayEndIndex < arrayStartIndex) || (arrayEndIndex != arrayEndLastIndex)) {

// malformed parameter

throw new ServerApiException(ApiErrorCode.MALFORMED_PARAMETER_ERROR, "Unable to decode parameter " + key

+ "; if specifying an object array, please use parameter[index].field=XXX, e.g. userGroupList[0].group=httpGroup");

}

// Now that we have an array object, check for a field name in the case of a complex object

int fieldIndex = key.indexOf('.');

String fieldName = null;

if (fieldIndex < arrayEndIndex) {

throw new ServerApiException(ApiErrorCode.MALFORMED_PARAMETER_ERROR, "Unable to decode parameter " + key

+ "; if specifying an object array, please use parameter[index].field=XXX, e.g. userGroupList[0].group=httpGroup");

} else {

fieldName = key.substring(fieldIndex + 1);

}

// parse the parameter name as the text before the first '[' character

String paramName = key.substring(0, arrayStartIndex);

paramName = paramName.toLowerCase();

Map<Integer, Map> mapArray = null;

Map<String, Object> mapValue = null;

String indexStr = key.substring(arrayStartIndex + 1, arrayEndIndex);

int index = 0;

boolean parsedIndex = false;

try {

if (indexStr != null) {

index = Integer.parseInt(indexStr);

parsedIndex = true;

}

} catch (NumberFormatException nfe) {

s_logger.warn("Invalid parameter " + key + " received, unable to parse object array, returning an error.");

}

if (!parsedIndex) {

throw new ServerApiException(ApiErrorCode.MALFORMED_PARAMETER_ERROR, "Unable to decode parameter " + key

+ "; if specifying an object array, please use parameter[index].field=XXX, e.g. userGroupList[0].group=httpGroup");

}

Object value = lowercaseParams.get(paramName);

if (value == null) {

// for now, assume object array with sub fields

mapArray = new HashMap<Integer, Map>();

mapValue = new HashMap<String, Object>();

mapArray.put(Integer.valueOf(index), mapValue);

} else if (value instanceof Map) {

mapArray = (HashMap) value;

mapValue = mapArray.get(Integer.valueOf(index));

if (mapValue == null) {

mapValue = new HashMap<String, Object>();

mapArray.put(Integer.valueOf(index), mapValue);

}

}

// we are ready to store the value for a particular field into the map for this object

mapValue.put(fieldName, params.get(key));

lowercaseParams.put(paramName, mapArray);

} else {

lowercaseParams.put(key.toLowerCase(), params.get(key));

}

}

return lowercaseParams;

}

public static boolean isAdmin(short accountType) {

return ((accountType == Account.ACCOUNT_TYPE_ADMIN) ||

(accountType == Account.ACCOUNT_TYPE_RESOURCE_DOMAIN_ADMIN) ||

(accountType == Account.ACCOUNT_TYPE_DOMAIN_ADMIN) || (accountType == Account.ACCOUNT_TYPE_READ_ONLY_ADMIN));

}

public static boolean isRootAdmin(short accountType) {

return ((accountType == Account.ACCOUNT_TYPE_ADMIN));

}

public void setFullUrlParams(Map<String, String> map) {

fullUrlParams = map;

}

public Map<String, String> getFullUrlParams() {

return fullUrlParams;

}

public Long finalyzeAccountId(String accountName, Long domainId, Long projectId, boolean enabledOnly) {

if (accountName != null) {

if (domainId == null) {

throw new InvalidParameterValueException("Account must be specified with domainId parameter");

}

Domain domain = _domainService.getDomain(domainId);

if (domain == null) {

throw new InvalidParameterValueException("Unable to find domain by id");

}

Account account = _accountService.getActiveAccountByName(accountName, domainId);

if (account != null && account.getType() != Account.ACCOUNT_TYPE_PROJECT) {

if (!enabledOnly || account.getState() == Account.State.enabled) {

return account.getId();

} else {

throw new PermissionDeniedException("Can't add resources to the account id=" + account.getId() + " in state=" + account.getState() + " as it's no longer active");

}

} else {

// idList is not used anywhere, so removed it now

//List<IdentityProxy> idList = new ArrayList<IdentityProxy>();

//idList.add(new IdentityProxy("domain", domainId, "domainId"));

throw new InvalidParameterValueException("Unable to find account by name " + accountName + " in domain with specified id");

}

}

if (projectId != null) {

Project project = _projectService.getProject(projectId);

if (project != null) {

if (!enabledOnly || project.getState() == Project.State.Active) {

return project.getProjectAccountId();

} else {

PermissionDeniedException ex = new PermissionDeniedException("Can't add resources to the project with specified projectId in state=" + project.getState() + " as it's no longer active");

ex.addProxyObject(project.getUuid(), "projectId");

throw ex;

}

} else {

throw new InvalidParameterValueException("Unable to find project by id");

}

}

return null;

}