ValidationMessageMapping

package com.savvis.spirits.domain;

import javax.persistence.*;

import static javax.persistence.GenerationType.IDENTITY;

@Entity
@Table(name = "validation_message")
public class ValidationMessageMapping implements java.io.Serializable {

private Integer id;
private String mwCase;
private String mwType;
private String message;
private String apiMessage;
private Integer moduleCode;
private Integer categorymoduleCode;
private Integer componentmoduleCode;
private Integer errorCode;
private Integer httpCode;
private String status;

public ValidationMessageMapping() {
}

public ValidationMessageMapping(Integer id, String mwCase, String apiMessage, String message, Integer moduleCode, Integer httpCode, String mwType, Integer categorymoduleCode, Integer componentmoduleCode, String status) {
this.id = id;
this.mwCase = mwCase;
this.apiMessage = apiMessage;
this.message = message;
this.moduleCode = moduleCode;
this.httpCode = httpCode;
this.mwType = mwType;
this.categorymoduleCode = categorymoduleCode;
this.componentmoduleCode = componentmoduleCode;
this.status = status;
}

@Id
@GeneratedValue(strategy = IDENTITY)
@Column(name = "id", unique = true, nullable = false)
public Integer getId() {
return id;
}

public void setId(Integer id) {
this.id = id;
}

@Column(name = "mw_case", length = 200, nullable = false)
public String getMwCase() {
return mwCase;
}

public void setMwCase(String mwCase) {
this.mwCase = mwCase;
}

@Column(name = "mw_type", length = 200)
public String getMwType() {
return mwType;
}

public void setMwType(String mwType) {
this.mwType = mwType;
}

@Column(name = "message", nullable = false)
public String getMessage() {
return message;
}

public void setMessage(String message) {
this.message = message;
}

@Column(name = "api_message")
public String getApiMessage() {
return apiMessage;
}

public void setApiMessage(String apiMessage) {
this.apiMessage = apiMessage;
}

@Column(name = "module_code", length = 10, nullable = false)
public Integer getModuleCode() {
return moduleCode;
}

public void setModuleCode(Integer moduleCode) {
this.moduleCode = moduleCode;
}

@Column(name = "category_code", length = 10, nullable = false)
public Integer getCategorymoduleCode() {
return categorymoduleCode;
}

public void setCategorymoduleCode(Integer categorymoduleCode) {
this.categorymoduleCode = categorymoduleCode;
}

@Column(name = "component_code", length = 10, nullable = false)
public Integer getComponentmoduleCode() {
return componentmoduleCode;
}

public void setComponentmoduleCode(Integer componentmoduleCode) {
this.componentmoduleCode = componentmoduleCode;
}

@Column(name = "error_code", length = 10, nullable = false)
public Integer geterrorCode() {
return errorCode;
}

public void seterrorCode(Integer errorCode) {
this.errorCode = errorCode;
}

@Column(name = "http_code", length = 10)
public Integer gethttpCode() {
return httpCode;
}

public void sethttpCode(Integer httpCode) {
this.httpCode = httpCode;
}

@Column(name = "status", length = 50)
public String getStatus() {
return status;
}

public void setStatus(String status) {
this.status = status;
}

@Override
public String toString() {
return "ValidationMessageMapping{" +
"id=" + id +
", mwCase='" + mwCase + '\'' +
", message='" + message + '\'' +
", apiMessage='" + apiMessage + '\'' +
", modulemoduleCode=" + moduleCode +
", httpCode=" + httpCode +
", categorymoduleCode=" + categorymoduleCode +
", componentmoduleCode=" + componentmoduleCode +
", errorCode=" + errorCode +
", mwType='" + mwType + '\'' +
'}';
}
}


********************************************

package com.savvis.spirits.services.queue.process;

import com.savvis.spirits.businessmodel.servicedesign.Compute;
import com.savvis.spirits.businessmodel.servicedesign.Computes;
import com.savvis.spirits.businessmodel.servicedesign.Drive;
import com.savvis.spirits.businessmodel.servicedesign.VPDCServiceDesign;
import com.savvis.spirits.common.exceptions.SystemException;
import com.savvis.spirits.common.utils.MWConstants;
import com.savvis.spirits.common.utils.MWUtil;
import com.savvis.spirits.dao.VpdcDetailDAO;
import com.savvis.spirits.dao.VpdcQueueProcessDAO;
import com.savvis.spirits.dao.VpdcQueueProcessResultDAO;
import com.savvis.spirits.domain.*;
import com.savvis.spirits.domain.enums.OperationEnum;
import com.savvis.spirits.domain.enums.VpdcQueueProcessStatusEnum;
import com.savvis.spirits.integration.schemas.queueprocess.*;
import com.savvis.spirits.services.xml.parser.ObjectConverter;
import com.savvis.spirits.vcloud.header.VCloudHeader;
import com.savvis.spirits.vcloud.header.VCloudHeaderHolder;
import com.savvis.spirits.vcloud.header.VCloudUser;
import com.savvis.spirits.vcloud.helper.VpdcTemplateHelper;
import com.savvis.spirits.vcloud.proxy.RestProxyAuthenticationService;
import com.savvis.spirits.vcloud.wrapper.VCloudHelper;
import com.savvis.spirits.yfilesconverter.YFilesConverter;
import com.savvis.spirits.yfilesconverter.dataobjects.*;
import java.util.*;
import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.events.StartElement;
import javax.xml.stream.events.XMLEvent;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.oxm.jaxb.Jaxb2Marshaller;
import org.springframework.stereotype.Service;

import javax.xml.bind.JAXBElement;
import javax.xml.namespace.QName;
import javax.xml.transform.Result;
import javax.xml.transform.stream.StreamResult;
import java.io.*;

/**
* Created by IntelliJ IDEA.
* User: ramesh.rajaram
* Date: Jan 12, 2011
* Time: 1:36:38 PM
* To change this template use File | Settings | File Templates.
*/

@Service("vpdcQueueProcessPreEngine")
public class VPDCQueueProcessPreEngine {

private static final Logger log = Logger.getLogger(VPDCQueueProcessPreEngine.class);

@Autowired
VpdcDetailDAO vpdcDetailDAO;
@Autowired
private ObjectConverter objectConverter;
@Autowired
VpdcQueueProcessDAO vpdcQueueProcessDAO;
@Autowired
VpdcQueueProcessResultDAO vpdcQueueProcessResultDAO;
@Autowired
private RestProxyAuthenticationService restProxyAuthenticationService;
@Autowired
@Qualifier("marshaller")
protected Jaxb2Marshaller marshaller;
@Autowired
private VpdcTemplateHelper vpdcTemplateHelper;

public VPDCQueueProcessPreEngine() {

}

public VPDCQueueProcessPreEngine(Object inputRequest, String vpdcCompType) {
addToQueue(inputRequest, vpdcCompType);
}

public TaskInfo addToQueue(Object inputRequest, String vpdcCompType) {

VCloudHeader vCloudHeader = VCloudHeaderHolder.getVcloudHeader();
VCloudUser vCloudUser = restProxyAuthenticationService.getVCloudUser(vCloudHeader.getToken());

//insert record to VPDCQueueProcess
VpdcQueueProcess vpdcQueueProcess = new VpdcQueueProcess();
vpdcQueueProcess.setCreatedBy(vCloudUser.getUserId());
vpdcQueueProcess.setCreateTime(new Date());
vpdcQueueProcess.setProcessType(vpdcCompType);
vpdcQueueProcess.setStatus(VpdcQueueProcessStatusEnum.QUEUED);
vpdcQueueProcess.setInput(convertRequestResponseToString(inputRequest));
TaskInfo taskInfo = new TaskInfo();
taskInfo.setProcessType(vpdcCompType);
taskInfo.setTaskStatus(VpdcQueueProcessStatusEnum.QUEUED.name());

if (inputRequest instanceof VMOperationRequest) {

putVMOperationRequestInQueue(inputRequest, vpdcQueueProcess, taskInfo);

} else if (inputRequest instanceof ChangeTemplateRequest) {

putChangeTemplateRequestInQueue(inputRequest, vpdcQueueProcess, taskInfo);

} else if (inputRequest instanceof CloneVCloudTemplateRequest) {

putCloneVCloudTemplateRequestInQueue(inputRequest, vpdcQueueProcess, taskInfo);

} else if (inputRequest instanceof SaveVCloudTemplateRequest) {

putSaveVCloudTemplateRequestInQueue(inputRequest, vpdcQueueProcess, taskInfo);

} else if (inputRequest instanceof InstantiateVCloudTemplateRequest) {

putInstantiateVCloudTemplateRequestInQueue(inputRequest, vpdcQueueProcess, taskInfo);

} else if (inputRequest instanceof FirewallRequest) {

putFWOperationRequestInQueue(inputRequest, vpdcQueueProcess, taskInfo);

} else if (inputRequest instanceof CloneVCloudvAppRequest) {

putCloneVCloudvAppRequestInQueue(inputRequest, vpdcQueueProcess, taskInfo);

} else if (inputRequest instanceof CloneVCloudMultiplevAppRequest) {

putCloneVCloudMultiplevAppRequestInQueue(inputRequest, vpdcQueueProcess, taskInfo);

} else if (inputRequest instanceof DetachVCloudVMDKRequest) {

putDetachVMDKRequestInQueue(inputRequest, vpdcQueueProcess, taskInfo);

} else if (inputRequest instanceof DeleteVCloudVMDKRequest) {

putDeleteVMDKRequestInQueue(inputRequest, vpdcQueueProcess, taskInfo);

} else if (inputRequest instanceof AttachVCloudVMDKRequest) {

putAttachVMDKRequestInQueue(inputRequest, vpdcQueueProcess, taskInfo);

} else if (inputRequest instanceof CloneVCloudVMDKRequest) {

putCloneVMDKRequestInQueue(inputRequest, vpdcQueueProcess, taskInfo);

}

vpdcQueueProcess.setOutput(convertRequestResponseToString(new JAXBElement<TaskInfo>(new QName("http://www.savvis.com/spirits/services/schemas/queueprocess/types", "TaskInfo"), TaskInfo.class, taskInfo)));
vpdcQueueProcessDAO.update(vpdcQueueProcess);

return taskInfo;
}

private void putVMOperationRequestInQueue(Object inputRequest, VpdcQueueProcess vpdcQueueProcess, TaskInfo taskInfo) {
List<TaskResultInfo> taskResultInfoList = new ArrayList<TaskResultInfo>();
YFilesConverter yFilesConverter = new YFilesConverter();
int nextGuiId = 0;
VMOperationRequest request = (VMOperationRequest) inputRequest;
vpdcQueueProcess.setBillingSiteId(request.getBillingsiteId());
vpdcQueueProcess.setVpdcId(request.getVpdcId());
vpdcQueueProcess.setProcessName("VMOperation");
vpdcQueueProcess.setProcessIdentifier("01");
VpdcDetail vpdcDetail = vpdcDetailDAO.findVpdcDtlLatestByVpdcId(request.getVpdcId());
if (null != vpdcDetail) {
vpdcQueueProcess.setProcessOwnerName(vpdcDetail.getVpdcName());
taskInfo.setOwnerReference(vpdcDetail.getVpdcName());

if (MWUtil.isNotEmptyString(vpdcDetail.getTransientYfiles())) { // todo for what
yFilesConverter.loadGraphML(new ByteArrayInputStream(vpdcDetail.getTransientYfiles().getBytes()));
nextGuiId = yFilesConverter.getNewServerGuiId();
vpdcDetail.setTransientYfiles(yFilesConverter.getGraphML());
} else {
yFilesConverter.loadGraphML(new ByteArrayInputStream(vpdcDetail.getGuiXml().getBytes()));
nextGuiId = yFilesConverter.getNewServerGuiId();
vpdcQueueProcess.setGuiXml(yFilesConverter.getGraphML());
}
vpdcDetailDAO.update(vpdcDetail);
}
vpdcQueueProcessDAO.save(vpdcQueueProcess);
taskInfo.setProcessId(vpdcQueueProcess.getProcessId() + "");
taskInfo.setOrgId(request.getBillingsiteId());
taskInfo.setOwnerId(request.getVpdcId() + "");
taskInfo.setProcessName("VMOperation");
for (VCloudCompute vCloudCompute : request.getVcloudComputes().getCompute()) {
TaskResultInfo taskResultInfo = new TaskResultInfo();
taskResultInfo.setResultReference(vCloudCompute.getCustHostName());
taskResultInfo.setResultStatus("queued");
VpdcQueueProcessResult vpdcQueueProcessResult = new VpdcQueueProcessResult();
vpdcQueueProcessResult.setVpdcQueueProcess(vpdcQueueProcess);
vpdcQueueProcessResult.setProcessResultName(vCloudCompute.getCustHostName());
vpdcQueueProcessResult.setProcessResultStatus("queued");
if (VMAction.ADD.equals(vCloudCompute.getAction())) {
vpdcQueueProcessResult.setProcessResultId(nextGuiId);
taskResultInfo.setResultReferenceId(nextGuiId + "");
nextGuiId++;
} else {
vpdcQueueProcessResult.setProcessResultId(Integer.parseInt(vCloudCompute.getGuiId()));
taskResultInfo.setResultReferenceId(vCloudCompute.getGuiId());
}
vpdcQueueProcessResultDAO.save(vpdcQueueProcessResult);
taskResultInfo.setResultId(vpdcQueueProcessResult.getId() + "");
taskResultInfoList.add(taskResultInfo);
}
taskInfo.getTaskResultInfo().addAll(taskResultInfoList);
}

private void putChangeTemplateRequestInQueue(Object inputRequest, VpdcQueueProcess vpdcQueueProcess, TaskInfo taskInfo) {
List<TaskResultInfo> taskResultInfoList = new ArrayList<TaskResultInfo>();
ChangeTemplateRequest request = (ChangeTemplateRequest) inputRequest;
vpdcQueueProcess.setBillingSiteId(request.getBillingSiteId());
vpdcQueueProcess.setVpdcId(request.getVpdcId());
vpdcQueueProcess.setProcessName("ChangeTemplate");
vpdcQueueProcess.setProcessIdentifier("04");
VpdcDetail vpdcDetail = vpdcDetailDAO.findVpdcDtlLatestByVpdcId(request.getVpdcId());
if (null != vpdcDetail) {
vpdcQueueProcess.setProcessOwnerName(vpdcDetail.getVpdcName());
taskInfo.setOwnerReference(vpdcDetail.getVpdcName());

}
vpdcQueueProcessDAO.save(vpdcQueueProcess);
taskInfo.setProcessId(vpdcQueueProcess.getProcessId() + "");
taskInfo.setOrgId(request.getBillingSiteId());
taskInfo.setOwnerId(request.getVpdcId() + "");
taskInfo.setProcessName("ChangeTemplate");
if (null != request.getTemplate()) {
TaskResultInfo taskResultInfo = new TaskResultInfo();
taskResultInfo.setResultReference(request.getTemplate().getVAppTemplateCustHostName());
taskResultInfo.setResultStatus(VpdcQueueProcessStatusEnum.QUEUED.name());
VpdcQueueProcessResult vpdcQueueProcessResult = new VpdcQueueProcessResult();
vpdcQueueProcessResult.setVpdcQueueProcess(vpdcQueueProcess);
vpdcQueueProcessResult.setProcessResultName(request.getTemplate().getVAppTemplateCustHostName());
vpdcQueueProcessResult.setProcessResultStatus(VpdcQueueProcessStatusEnum.QUEUED.name());
vpdcQueueProcessResult.setProcessResultId(request.getTemplate().getTemplateId());
taskResultInfo.setResultReferenceId(request.getTemplate().getTemplateId() + "");

vpdcQueueProcessResultDAO.save(vpdcQueueProcessResult);
taskResultInfo.setResultId(vpdcQueueProcessResult.getId() + "");
taskResultInfoList.add(taskResultInfo);
}
taskInfo.getTaskResultInfo().addAll(taskResultInfoList);
}

private void putCloneVCloudTemplateRequestInQueue(Object inputRequest, VpdcQueueProcess vpdcQueueProcess, TaskInfo taskInfo) {
List<TaskResultInfo> taskResultInfoList = new ArrayList<TaskResultInfo>();
CloneVCloudTemplateRequest request = (CloneVCloudTemplateRequest) inputRequest;

vpdcQueueProcess.setProcessName("CloneVCloudTemplate");
vpdcQueueProcess.setProcessIdentifier("04");
VpdcDetail repoVpdcDetail = vpdcTemplateHelper.validateSourceAndTargetVpdc(request.getSourceVpdcId(), request.getTargetVpdcId());
if (null != repoVpdcDetail) {
vpdcQueueProcess.setBillingSiteId(repoVpdcDetail.getVpdc().getBillingsiteId());
vpdcQueueProcess.setVpdcId(repoVpdcDetail.getVpdc().getId());
taskInfo.setOrgId(repoVpdcDetail.getVpdc().getBillingsiteId());
taskInfo.setOwnerId(repoVpdcDetail.getVpdc().getId() + "");
}

VpdcDetail targetVpdcDetail = vpdcDetailDAO.findVpdcDtlLatestByVpdcId(request.getTargetVpdcId());
if (null != targetVpdcDetail) {
vpdcQueueProcess.setProcessOwnerName(targetVpdcDetail.getVpdcName());
taskInfo.setOwnerReference(targetVpdcDetail.getVpdcName());
}

vpdcQueueProcessDAO.save(vpdcQueueProcess);
taskInfo.setProcessId(vpdcQueueProcess.getProcessId() + "");
taskInfo.setProcessName("CloneVCloudTemplate");
TaskResultInfo taskResultInfo = new TaskResultInfo();
taskResultInfo.setResultReference(request.getTemplateName());
taskResultInfo.setResultStatus(VpdcQueueProcessStatusEnum.QUEUED.name());
VpdcQueueProcessResult vpdcQueueProcessResult = new VpdcQueueProcessResult();
vpdcQueueProcessResult.setVpdcQueueProcess(vpdcQueueProcess);
vpdcQueueProcessResult.setProcessResultName(request.getTemplateName());
vpdcQueueProcessResult.setProcessResultStatus(VpdcQueueProcessStatusEnum.QUEUED.name());
//todo
vpdcQueueProcessResult.setProcessResultId(0);
taskResultInfo.setResultReferenceId("");

vpdcQueueProcessResultDAO.save(vpdcQueueProcessResult);
taskResultInfo.setResultId(vpdcQueueProcessResult.getId() + "");
taskResultInfoList.add(taskResultInfo);
taskInfo.getTaskResultInfo().addAll(taskResultInfoList);
}

private void putSaveVCloudTemplateRequestInQueue(Object inputRequest, VpdcQueueProcess vpdcQueueProcess, TaskInfo taskInfo) {
List<TaskResultInfo> taskResultInfoList = new ArrayList<TaskResultInfo>();
SaveVCloudTemplateRequest request = (SaveVCloudTemplateRequest) inputRequest;

vpdcQueueProcess.setProcessName("SaveVCloudTemplate");
vpdcQueueProcess.setProcessIdentifier("04");
VpdcDetail repoVpdcDetail = vpdcTemplateHelper.validateSourceAndTargetVpdc(request.getSourceVpdcId(), request.getTargetVpdcId());
if (null != repoVpdcDetail) {
vpdcQueueProcess.setBillingSiteId(repoVpdcDetail.getVpdc().getBillingsiteId());
vpdcQueueProcess.setVpdcId(repoVpdcDetail.getVpdc().getId());
taskInfo.setOrgId(repoVpdcDetail.getVpdc().getBillingsiteId());
taskInfo.setOwnerId(repoVpdcDetail.getVpdc().getId() + "");
}

VpdcDetail targetVpdcDetail = vpdcDetailDAO.findVpdcDtlLatestByVpdcId(request.getTargetVpdcId());
if (null != targetVpdcDetail) {
vpdcQueueProcess.setProcessOwnerName(targetVpdcDetail.getVpdcName());
taskInfo.setOwnerReference(targetVpdcDetail.getVpdcName());
}

vpdcQueueProcessDAO.save(vpdcQueueProcess);
taskInfo.setProcessId(vpdcQueueProcess.getProcessId() + "");
taskInfo.setProcessName("SaveVCloudTemplate");
TaskResultInfo taskResultInfo = new TaskResultInfo();
taskResultInfo.setResultReference(request.getTemplateName());
taskResultInfo.setResultStatus(VpdcQueueProcessStatusEnum.QUEUED.name());
VpdcQueueProcessResult vpdcQueueProcessResult = new VpdcQueueProcessResult();
vpdcQueueProcessResult.setVpdcQueueProcess(vpdcQueueProcess);
vpdcQueueProcessResult.setProcessResultName(request.getTemplateName());
vpdcQueueProcessResult.setProcessResultStatus(VpdcQueueProcessStatusEnum.QUEUED.name());
//todo
vpdcQueueProcessResult.setProcessResultId(0);
taskResultInfo.setResultReferenceId("");

vpdcQueueProcessResultDAO.save(vpdcQueueProcessResult);
taskResultInfo.setResultId(vpdcQueueProcessResult.getId() + "");
taskResultInfoList.add(taskResultInfo);
taskInfo.getTaskResultInfo().addAll(taskResultInfoList);
}

private void putInstantiateVCloudTemplateRequestInQueue(Object inputRequest, VpdcQueueProcess vpdcQueueProcess, TaskInfo taskInfo) {
List<TaskResultInfo> taskResultInfoList = new ArrayList<TaskResultInfo>();
InstantiateVCloudTemplateRequest request = (InstantiateVCloudTemplateRequest) inputRequest;
List<InstantiateTemplateInfo> templateInfoListFromVCloud = request.getInstantiateTemplateList();
vpdcQueueProcess.setProcessName("InstantiateVCloudTemplate");
vpdcQueueProcess.setProcessIdentifier("04");

int targetVpdcId = request.getInstantiateTemplateList().get(0).getTargetVpdcId();
int sourceVpdcId = request.getInstantiateTemplateList().get(0).getSourceVpdcId();

VpdcDetail repoVpdcDetail = vpdcTemplateHelper.validateSourceAndTargetVpdc(sourceVpdcId, targetVpdcId);
if (null != repoVpdcDetail) {
vpdcQueueProcess.setBillingSiteId(repoVpdcDetail.getVpdc().getBillingsiteId());
vpdcQueueProcess.setVpdcId(repoVpdcDetail.getVpdc().getId());
taskInfo.setOrgId(repoVpdcDetail.getVpdc().getBillingsiteId());
taskInfo.setOwnerId(repoVpdcDetail.getVpdc().getId() + "");
}

YFilesConverter yFilesConverter = new YFilesConverter();
int nextGuiId = 0;
VpdcDetail targetVpdcDetail = vpdcDetailDAO.findVpdcDtlLatestByVpdcId(targetVpdcId);
if (null != targetVpdcDetail) {
vpdcQueueProcess.setProcessOwnerName(targetVpdcDetail.getVpdcName());
taskInfo.setOwnerReference(targetVpdcDetail.getVpdcName());

if (MWUtil.isNotEmptyString(targetVpdcDetail.getTransientYfiles())) {
yFilesConverter.loadGraphML(new ByteArrayInputStream(targetVpdcDetail.getTransientYfiles().getBytes()));
nextGuiId = yFilesConverter.getNewServerGuiId();
targetVpdcDetail.setTransientYfiles(yFilesConverter.getGraphML());
} else {
yFilesConverter.loadGraphML(new ByteArrayInputStream(targetVpdcDetail.getGuiXml().getBytes()));
nextGuiId = yFilesConverter.getNewServerGuiId();
targetVpdcDetail.setGuiXml(yFilesConverter.getGraphML());
}
vpdcDetailDAO.update(targetVpdcDetail);
}

vpdcQueueProcessDAO.save(vpdcQueueProcess);
taskInfo.setProcessId(vpdcQueueProcess.getProcessId() + "");
taskInfo.setProcessName("InstantiateVCloudTemplate");
for (InstantiateTemplateInfo templateInfoFromVCloud : templateInfoListFromVCloud) {
TaskResultInfo taskResultInfo = new TaskResultInfo();
taskResultInfo.setResultReference(templateInfoFromVCloud.getTargetComputeName());
taskResultInfo.setResultStatus(VpdcQueueProcessStatusEnum.QUEUED.name());
VpdcQueueProcessResult vpdcQueueProcessResult = new VpdcQueueProcessResult();
vpdcQueueProcessResult.setVpdcQueueProcess(vpdcQueueProcess);
vpdcQueueProcessResult.setProcessResultName(templateInfoFromVCloud.getTargetComputeName());
vpdcQueueProcessResult.setProcessResultStatus(VpdcQueueProcessStatusEnum.QUEUED.name());

vpdcQueueProcessResult.setProcessResultId(nextGuiId);
taskResultInfo.setResultReferenceId(nextGuiId + "");
nextGuiId++;

vpdcQueueProcessResultDAO.save(vpdcQueueProcessResult);
taskResultInfo.setResultId(vpdcQueueProcessResult.getId() + "");
taskResultInfoList.add(taskResultInfo);
}
taskInfo.getTaskResultInfo().addAll(taskResultInfoList);
}

private void putCloneVCloudvAppRequestInQueue(Object inputRequest, VpdcQueueProcess vpdcQueueProcess, TaskInfo taskInfo) {

List<TaskResultInfo> taskResultInfoList = new ArrayList<TaskResultInfo>();
YFilesConverter yFilesConverter = new YFilesConverter();
int nextGuiId = 0;
CloneVCloudvAppRequest request = (CloneVCloudvAppRequest) inputRequest;
vpdcQueueProcess.setBillingSiteId(request.getSourceBillingSiteid());
vpdcQueueProcess.setVpdcId(request.getSourceVpdcId());
vpdcQueueProcess.setProcessName("CloneVCloudvApp");
vpdcQueueProcess.setProcessIdentifier("04");
VpdcDetail vpdcDetail = vpdcDetailDAO.findVpdcDtlLatestByVpdcId(request.getSourceVpdcId());
if (null != vpdcDetail) {
vpdcQueueProcess.setProcessOwnerName(vpdcDetail.getVpdcName());
taskInfo.setOwnerReference(vpdcDetail.getVpdcName());
setGuiXML(vpdcDetail, vpdcQueueProcess, request);

if (MWUtil.isNotEmptyString(vpdcDetail.getTransientYfiles())) {
yFilesConverter.loadGraphML(new ByteArrayInputStream(vpdcDetail.getTransientYfiles().getBytes()));
nextGuiId = yFilesConverter.getNewServerGuiId();
vpdcDetail.setTransientYfiles(yFilesConverter.getGraphML());
} else {
yFilesConverter.loadGraphML(new ByteArrayInputStream(vpdcDetail.getGuiXml().getBytes()));
nextGuiId = yFilesConverter.getNewServerGuiId();
vpdcQueueProcess.setGuiXml(yFilesConverter.getGraphML());
}
vpdcDetailDAO.update(vpdcDetail);
}
vpdcQueueProcessDAO.save(vpdcQueueProcess);
taskInfo.setProcessId(vpdcQueueProcess.getProcessId() + "");
taskInfo.setOrgId(request.getTargetBillingSiteid());
taskInfo.setOwnerId(request.getTargetVpdcId() + "");
taskInfo.setProcessName("CloneVCloudvApp");
TaskResultInfo taskResultInfo = new TaskResultInfo();
taskResultInfo.setResultStatus("queued");
VpdcQueueProcessResult vpdcQueueProcessResult = new VpdcQueueProcessResult();
vpdcQueueProcessResult.setVpdcQueueProcess(vpdcQueueProcess);
vpdcQueueProcessResult.setProcessResultStatus("queued");
vpdcQueueProcessResultDAO.save(vpdcQueueProcessResult);
taskResultInfo.setResultId(vpdcQueueProcessResult.getId() + "");
taskResultInfoList.add(taskResultInfo);
taskInfo.getTaskResultInfo().addAll(taskResultInfoList);
}

private void putCloneVCloudMultiplevAppRequestInQueue(Object inputRequest, VpdcQueueProcess vpdcQueueProcess, TaskInfo taskInfo) {
List<TaskResultInfo> taskResultInfoList = new ArrayList<TaskResultInfo>();
YFilesConverter yFilesConverter = new YFilesConverter();
int nextGuiId = 0;
CloneVCloudMultiplevAppRequest request = (CloneVCloudMultiplevAppRequest) inputRequest;
List<CloneVCloudMultiplevAppsInfo> cloneVCloudMultiplevAppsInfoList = request.getTargetvApps();
for (int i = 0; i < cloneVCloudMultiplevAppsInfoList.size(); i++) {
vpdcQueueProcess.setBillingSiteId(cloneVCloudMultiplevAppsInfoList.get(i).getSourceBillingSiteid());
vpdcQueueProcess.setVpdcId(cloneVCloudMultiplevAppsInfoList.get(i).getSourceVpdcId());
vpdcQueueProcess.setProcessName("CloneVCloudMultiplevApp");
vpdcQueueProcess.setProcessIdentifier("05");
VpdcDetail vpdcDetail = vpdcDetailDAO.findVpdcDtlLatestByVpdcId(cloneVCloudMultiplevAppsInfoList.get(i).getSourceVpdcId());
if (null != vpdcDetail) {
vpdcQueueProcess.setProcessOwnerName(vpdcDetail.getVpdcName());
taskInfo.setOwnerReference(vpdcDetail.getVpdcName());
setGuiXML(vpdcDetail, vpdcQueueProcess, request);

if (MWUtil.isNotEmptyString(vpdcDetail.getTransientYfiles())) {
yFilesConverter.loadGraphML(new ByteArrayInputStream(vpdcDetail.getTransientYfiles().getBytes()));
nextGuiId = yFilesConverter.getNewServerGuiId();
vpdcDetail.setTransientYfiles(yFilesConverter.getGraphML());
} else {
yFilesConverter.loadGraphML(new ByteArrayInputStream(vpdcDetail.getGuiXml().getBytes()));
nextGuiId = yFilesConverter.getNewServerGuiId();
vpdcQueueProcess.setGuiXml(yFilesConverter.getGraphML());
}
vpdcDetailDAO.update(vpdcDetail);
}
vpdcQueueProcessDAO.save(vpdcQueueProcess);
taskInfo.setProcessId(vpdcQueueProcess.getProcessId() + "");
taskInfo.setOrgId(cloneVCloudMultiplevAppsInfoList.get(i).getTargetBillingSiteid());
taskInfo.setOwnerId(cloneVCloudMultiplevAppsInfoList.get(i).getTargetVpdcId() + "");
taskInfo.setProcessName("CloneVCloudMultiplevApp");
TaskResultInfo taskResultInfo = new TaskResultInfo();
taskResultInfo.setResultStatus("queued");
VpdcQueueProcessResult vpdcQueueProcessResult = new VpdcQueueProcessResult();
vpdcQueueProcessResult.setVpdcQueueProcess(vpdcQueueProcess);
vpdcQueueProcessResult.setProcessResultStatus("queued");
vpdcQueueProcessResultDAO.save(vpdcQueueProcessResult);
taskResultInfo.setResultId(vpdcQueueProcessResult.getId() + "");
taskResultInfoList.add(taskResultInfo);
taskInfo.getTaskResultInfo().addAll(taskResultInfoList);
}
}

/**
* Method convertRequestResponseToString ...
*
* @param request of type Object
* @return String
*/
public String convertRequestResponseToString(Object request) {
StringBuilder design = new StringBuilder();
try {
ByteArrayOutputStream outStream = new ByteArrayOutputStream();
Result result = new StreamResult(outStream);
marshaller.marshal(request, result);

ByteArrayInputStream metaDataInput = new ByteArrayInputStream(outStream.toByteArray());
InputStreamReader reader = new InputStreamReader(metaDataInput);
BufferedReader bReader = new BufferedReader(reader);
String readLine = "";
while ((readLine = bReader.readLine()) != null) {
design.append(readLine).append("\n");
}
} catch (IOException ex) {
log.error("IOException occured in VPDCQueueProcessPreEngine.convertRequestResponseToString:" + ex.getMessage(), ex);
} catch (Exception ex) {
log.error("Exception occured in VPDCQueueProcessPreEngine.convertRequestResponseToString:" + ex.getMessage(), ex);
}
return design.toString();
}

private void putFWOperationRequestInQueue(Object inputRequest, VpdcQueueProcess vpdcQueueProcess, TaskInfo taskInfo) {
List<TaskResultInfo> taskResultInfoList = new ArrayList<TaskResultInfo>();
YFilesConverter yFilesConverter = new YFilesConverter();
FirewallRequest request = (FirewallRequest) inputRequest;
vpdcQueueProcess.setBillingSiteId(request.getBillingsiteId());
vpdcQueueProcess.setVpdcId(request.getVpdcId());
vpdcQueueProcess.setProcessName("FWOperation");
vpdcQueueProcess.setProcessIdentifier("03");
VpdcDetail vpdcDetail = vpdcDetailDAO.findVpdcDtlLatestByVpdcId(request.getVpdcId());
if (null != vpdcDetail) {
vpdcQueueProcess.setProcessOwnerName(vpdcDetail.getVpdcName());
taskInfo.setOwnerReference(vpdcDetail.getVpdcName());
setGuiXML(vpdcDetail, vpdcQueueProcess, request);
}
vpdcQueueProcessDAO.save(vpdcQueueProcess);
taskInfo.setProcessId(vpdcQueueProcess.getProcessId() + "");
taskInfo.setOrgId(request.getBillingsiteId());
taskInfo.setOwnerId(request.getVpdcId() + "");
if (null != request.getPfwRules().getPfwRules() && request.getPfwRules().getPfwRules().size() > 0) {
taskInfo.setProcessName("PFWOperation");
for (VCloudFirewallRule vCloudFirewallRule : request.getPfwRules().getPfwRules()) {
TaskResultInfo taskResultInfo = new TaskResultInfo();
taskResultInfo.setResultReference("");
taskResultInfo.setResultStatus("queued");
VpdcQueueProcessResult vpdcQueueProcessResult = new VpdcQueueProcessResult();
vpdcQueueProcessResult.setVpdcQueueProcess(vpdcQueueProcess);
vpdcQueueProcessResult.setProcessResultName("");
vpdcQueueProcessResult.setProcessResultStatus("queued");
vpdcQueueProcessResult.setProcessResultId(0);
vpdcQueueProcessResultDAO.save(vpdcQueueProcessResult);
taskResultInfo.setResultId(vpdcQueueProcessResult.getId() + "");
taskResultInfoList.add(taskResultInfo);
}
}
if (null != request.getPfwRules().getPfwRules() && request.getStwfRules().getStwfRules().size() > 0) {
taskInfo.setProcessName("STFWOperation");
for (VCloudFirewallRule vCloudFirewallRule : request.getStwfRules().getStwfRules()) {
TaskResultInfo taskResultInfo = new TaskResultInfo();
taskResultInfo.setResultReference("");
taskResultInfo.setResultStatus("queued");
VpdcQueueProcessResult vpdcQueueProcessResult = new VpdcQueueProcessResult();
vpdcQueueProcessResult.setVpdcQueueProcess(vpdcQueueProcess);
vpdcQueueProcessResult.setProcessResultName("");
vpdcQueueProcessResult.setProcessResultStatus("queued");
vpdcQueueProcessResult.setProcessResultId(0);
vpdcQueueProcessResultDAO.save(vpdcQueueProcessResult);
taskResultInfo.setResultId(vpdcQueueProcessResult.getId() + "");
taskResultInfoList.add(taskResultInfo);
}
}
taskInfo.getTaskResultInfo().addAll(taskResultInfoList);
}

private void setGuiXML(VpdcDetail vpdcDetail, VpdcQueueProcess vpdcQueueProcess, CloneVCloudMultiplevAppRequest request) {

}

private void setGuiXML(VpdcDetail vpdcDetail, VpdcQueueProcess vpdcQueueProcess, CloneVCloudvAppRequest request) {

migrationDHCPInfo(vpdcDetail, vpdcQueueProcess, request.getSourceVpdcId());

}

private void migrationDHCPInfo(VpdcDetail vpdcDetail, VpdcQueueProcess vpdcQueueProcess, int VpdcId) {
Map<Integer, String[]> cloneVMInfo = getClonedVMInfo(vpdcDetail.getId(), VpdcId);
List<Integer> guiIdList = new ArrayList<Integer>();
String apiName = Thread.currentThread().getStackTrace()[1].getMethodName();
String vpdcFinalXML = vpdcDetail.getDesignFinalXml().replaceAll("(\r\n|\r|\n|\n\r)", "");
VPDCServiceDesign vpdcServiceDesign = objectConverter.convertStringToDesign(vpdcFinalXML);
// retrieve a list of VMs defined inside yfiles
Computes computes = vpdcServiceDesign.getComputes();
for (Compute compute : computes.getCompute()) {
guiIdList.add(compute.getGuiId());
if (null != cloneVMInfo.get(compute.getGuiId()) && MWConstants.TRUE.equalsIgnoreCase(vpdcDetail.getVpdc().getUseDhcpForCloneTemplate())) {
compute.setDhcp(true);
} else {
compute.setDhcp(false);
// compute.sets
}
}
if (MWUtil.isNotEmptyString(vpdcDetail.getGuiXml())) {
YFilesConverter yFilesConverter = new YFilesConverter();
yFilesConverter.loadGraphML(new ByteArrayInputStream(vpdcDetail.getGuiXml().getBytes()));
VPDCSpec vpdcSpec = yFilesConverter.getVPDCSpec();
List<ServerDataObject> serverList = vpdcSpec.getServers();
for (ServerDataObject vm : serverList) {
if (guiIdList.contains(vm.getGuiId())) {
if (null != cloneVMInfo.get(vm.getGuiId()) && MWConstants.TRUE.equalsIgnoreCase(vpdcDetail.getVpdc().getUseDhcpForCloneTemplate())) {
vm.setDHCP(true);
} else {
vm.setDHCP(false);
}
yFilesConverter.updateCustomObject(vm);
}
}
vpdcQueueProcess.setGuiXml(yFilesConverter.getGraphML());
}
}

private Map<Integer, String[]> getClonedVMInfo(int vpdcSessionId,int vpdcId) {

Map<Integer,String[]> cloneVMInfo = new HashMap<Integer,String[]>();
VpdcDetail vpdcDetail = null;
List<VpdcDetail> vpdcDetails = null;

if (0 == vpdcId && 0 != vpdcSessionId) {
vpdcDetail = vpdcDetailDAO.findById(vpdcSessionId);
vpdcDetails = vpdcDetailDAO.findVpdcDetailByVpdcIdAndOperation(vpdcDetail.getVpdc().getId(), OperationEnum.CloneVM);
} else if (0 != vpdcId && 0 == vpdcSessionId) {
vpdcDetails = vpdcDetailDAO.findVpdcDetailByVpdcIdAndOperation(vpdcId, OperationEnum.CloneVM);
}

if(!vpdcDetails.isEmpty()) {
for (VpdcDetail detail : vpdcDetails) {
YFilesConverter yFilesConverter = new YFilesConverter();
yFilesConverter.loadGraphML(new ByteArrayInputStream(detail.getGuiXml().getBytes()));
if (detail.getSpecXml() != null) {
for (String custHostName : getClonedVMFromSpecXML(detail.getSpecXml())) {
ServerDataObject serverDataObject = VCloudHelper.getInstance().getYComputeByComputeCustHostName(yFilesConverter.
getVPDCSpec(), custHostName);
cloneVMInfo.put(serverDataObject.getGuiId(),
new String[]{custHostName, serverDataObject.getNodeStatus()});
}
}
}
}
log.info("The return CloneVM info is : " + cloneVMInfo.toString());

return cloneVMInfo;
}

private List<String> getClonedVMFromSpecXML(String specXML){

XMLEventReader eventReader = null;
List<String> cloneVMInfo = new ArrayList<String>();
StringReader stringReader = new StringReader(specXML);
XMLInputFactory inputFactory = XMLInputFactory.newInstance();
String apiName = Thread.currentThread().getStackTrace()[1].getMethodName();

try {
boolean inTargetCompute = false;
eventReader = inputFactory.createXMLEventReader(stringReader);
while (eventReader.hasNext()) {
XMLEvent event = eventReader.nextEvent();
if (event.isStartElement()) {
StartElement startElement = event.asStartElement();
String localPart = startElement.getName().getLocalPart();
if ("targetCompute".equals(localPart)) {
inTargetCompute = true;
} else if (inTargetCompute && "custHostname".equals(localPart)) {
cloneVMInfo.add(eventReader.getElementText());
inTargetCompute = false;
}
}
}
} catch (Exception e) {
throw new SystemException(e.getMessage(), e);
} finally {
if (eventReader != null) {
try {
eventReader.close();
} catch (Exception e) {
}
}
}
return cloneVMInfo;

}

private void setGuiXML(VpdcDetail vpdcDetail, VpdcQueueProcess vpdcQueueProcess, FirewallRequest request) {
log.info("create a new gui xml for getFirewall api");
YFilesConverter yFilesConverter = new YFilesConverter();
List<FWRule> pfwRules = null;
List<SFWRule> stfwRules = null;
List<VCloudFirewallRule> vCloudPfwRules = null;
List<VCloudFirewallRule> vCloudStfwRules = null;
if (MWUtil.isNotEmptyString(vpdcDetail.getGuiXml())) {
yFilesConverter.loadGraphML(new ByteArrayInputStream(vpdcDetail.getGuiXml().getBytes()));
VPDCSpec vpdcSpec = yFilesConverter.getVPDCSpec();
PerimeterFWDataObject perimeterFWDataObject = vpdcSpec.getPerimeterFW();
SFWDataObject sfwDataObject = vpdcSpec.getServerTierFW();
if (null != vpdcSpec && null != vpdcSpec.getPerimeterFW().getFwRules() && vpdcSpec.getPerimeterFW().getFwRules().size() > 0) {
pfwRules = perimeterFWDataObject.getFwRules();
}
if (null != vpdcSpec && null != vpdcSpec.getServerTierFW().getSFwRules() && vpdcSpec.getServerTierFW().getSFwRules().size() > 0) {
stfwRules = sfwDataObject.getSFwRules();
}
vCloudPfwRules = request.getPfwRules().getPfwRules();
vCloudStfwRules = request.getStwfRules().getStwfRules();
if (null != vCloudPfwRules && vCloudStfwRules.size() > 0) {
for (VCloudFirewallRule vCloudFirewallRule : vCloudPfwRules) {
FWRule fwRule = new FWRule();
fwRule.setAction(vCloudFirewallRule.getAction().toString());
fwRule.setDestination(vCloudFirewallRule.getDestination());
fwRule.setDestinationPort(vCloudFirewallRule.getDestinationPort());
fwRule.setLog(vCloudFirewallRule.getLog().toString());
fwRule.setNodeStatus(vCloudFirewallRule.getStatus());
fwRule.setProtocol(vCloudFirewallRule.getProtocol());
fwRule.setSource(vCloudFirewallRule.getSource());
pfwRules.add(fwRule);
}
}
if (null != vCloudStfwRules && vCloudStfwRules.size() > 0) {
for (VCloudFirewallRule vCloudFirewallRule : vCloudStfwRules) {
SFWRule fwRule = new SFWRule();
fwRule.setAction(vCloudFirewallRule.getAction().toString());
fwRule.setDestination(vCloudFirewallRule.getDestination());
fwRule.setDestinationPort(vCloudFirewallRule.getDestinationPort());
fwRule.setLog(vCloudFirewallRule.getLog().toString());
fwRule.setNodeStatus(vCloudFirewallRule.getStatus());
fwRule.setProtocol(vCloudFirewallRule.getProtocol());
fwRule.setSource(vCloudFirewallRule.getSource());
stfwRules.add(fwRule);
}
}

perimeterFWDataObject.setFwRules(pfwRules);
sfwDataObject.setSFwRules(stfwRules);
yFilesConverter.updateCustomObject(perimeterFWDataObject);
yFilesConverter.updateCustomObject(sfwDataObject);

String newGuiXML = yFilesConverter.getGraphML();
log.info("new gui xml generated++++++++" + newGuiXML);

vpdcQueueProcess.setGuiXml(newGuiXML);

}
}

private void putDetachVMDKRequestInQueue(Object inputRequest, VpdcQueueProcess vpdcQueueProcess, TaskInfo taskInfo) {
List<TaskResultInfo> taskResultInfoList = new ArrayList<TaskResultInfo>();
DetachVCloudVMDKRequest request = (DetachVCloudVMDKRequest) inputRequest;
vpdcQueueProcess.setBillingSiteId(request.getSourceBillingSiteid());
vpdcQueueProcess.setVpdcId(request.getSourceVpdcId());
vpdcQueueProcess.setProcessName("DetachVCloudVMDK");
vpdcQueueProcess.setProcessIdentifier("02");
VpdcDetail vpdcDetail = vpdcDetailDAO.findVpdcDtlLatestByVpdcId(request.getSourceVpdcId());
if (null != vpdcDetail) {
vpdcQueueProcess.setProcessOwnerName(vpdcDetail.getVpdcName());
taskInfo.setOwnerReference(vpdcDetail.getVpdcName());
}
vpdcQueueProcessDAO.save(vpdcQueueProcess);
taskInfo.setProcessId(String.valueOf(vpdcQueueProcess.getProcessId()));
taskInfo.setOrgId(request.getSourceBillingSiteid());
taskInfo.setOwnerId(String.valueOf(request.getSourceVpdcId()));
taskInfo.setProcessName("DetachVCloudVMDK");
TaskResultInfo taskResultInfo = new TaskResultInfo();
taskResultInfo.setResultReference(request.getLabelName());
taskResultInfo.setResultStatus(VpdcQueueProcessStatusEnum.QUEUED.name());
VpdcQueueProcessResult vpdcQueueProcessResult = new VpdcQueueProcessResult();
vpdcQueueProcessResult.setVpdcQueueProcess(vpdcQueueProcess);
vpdcQueueProcessResult.setProcessResultName(request.getLabelName());
vpdcQueueProcessResult.setProcessResultStatus(VpdcQueueProcessStatusEnum.QUEUED.name());
vpdcQueueProcessResult.setProcessResultId(request.getSourceVMDKciid());
taskResultInfo.setResultReferenceId(String.valueOf(request.getSourceVMDKciid()));
vpdcQueueProcessResultDAO.save(vpdcQueueProcessResult);
taskResultInfo.setResultId(String.valueOf(vpdcQueueProcessResult.getId()));
taskResultInfoList.add(taskResultInfo);
taskInfo.getTaskResultInfo().addAll(taskResultInfoList);
}

private void putAttachVMDKRequestInQueue(Object inputRequest, VpdcQueueProcess vpdcQueueProcess, TaskInfo taskInfo) {
List<TaskResultInfo> taskResultInfoList = new ArrayList<TaskResultInfo>();
AttachVCloudVMDKRequest request = (AttachVCloudVMDKRequest) inputRequest;
vpdcQueueProcess.setBillingSiteId(request.getSourceBillingSiteid());
vpdcQueueProcess.setVpdcId(request.getSourceVpdcId());
vpdcQueueProcess.setProcessName("AttachVCloudVMDK");
vpdcQueueProcess.setProcessIdentifier("02");
VpdcDetail vpdcDetail = vpdcDetailDAO.findVpdcDtlLatestByVpdcId(request.getSourceVpdcId());
if (null != vpdcDetail) {
vpdcQueueProcess.setProcessOwnerName(vpdcDetail.getVpdcName());
taskInfo.setOwnerReference(vpdcDetail.getVpdcName());
}
vpdcQueueProcessDAO.save(vpdcQueueProcess);
taskInfo.setProcessId(String.valueOf(vpdcQueueProcess.getProcessId()));
taskInfo.setOrgId(request.getSourceBillingSiteid());
taskInfo.setOwnerId(String.valueOf(request.getSourceVpdcId()));
taskInfo.setProcessName("AttachVCloudVMDK");
TaskResultInfo taskResultInfo = new TaskResultInfo();
taskResultInfo.setResultReference(request.getTargetMountPointName());
taskResultInfo.setResultStatus(VpdcQueueProcessStatusEnum.QUEUED.name());
VpdcQueueProcessResult vpdcQueueProcessResult = new VpdcQueueProcessResult();
vpdcQueueProcessResult.setVpdcQueueProcess(vpdcQueueProcess);
vpdcQueueProcessResult.setProcessResultName(request.getTargetMountPointName());
vpdcQueueProcessResult.setProcessResultStatus(VpdcQueueProcessStatusEnum.QUEUED.name());
vpdcQueueProcessResult.setProcessResultId(request.getSourceVMDKciid());
taskResultInfo.setResultReferenceId(String.valueOf(request.getSourceVMDKciid()));
vpdcQueueProcessResultDAO.save(vpdcQueueProcessResult);
taskResultInfo.setResultId(String.valueOf(vpdcQueueProcessResult.getId()));
taskResultInfoList.add(taskResultInfo);
taskInfo.getTaskResultInfo().addAll(taskResultInfoList);
}

private void putDeleteVMDKRequestInQueue(Object inputRequest, VpdcQueueProcess vpdcQueueProcess, TaskInfo taskInfo) {
String driveName = "";
List<TaskResultInfo> taskResultInfoList = new ArrayList<TaskResultInfo>();
DeleteVCloudVMDKRequest request = (DeleteVCloudVMDKRequest) inputRequest;
vpdcQueueProcess.setBillingSiteId(request.getSourceBillingSiteid());
vpdcQueueProcess.setVpdcId(request.getSourceVpdcId());
vpdcQueueProcess.setProcessName("DeleteVCloudVMDK");
vpdcQueueProcess.setProcessIdentifier("02");
VpdcDetail vpdcDetail = vpdcDetailDAO.findVpdcDtlLatestByVpdcId(request.getSourceVpdcId());
if (null != vpdcDetail) {
vpdcQueueProcess.setProcessOwnerName(vpdcDetail.getVpdcName());
taskInfo.setOwnerReference(vpdcDetail.getVpdcName());
String vpdcFinalXML = vpdcDetail.getDesignFinalXml().replaceAll("(\r\n|\r|\n|\n\r)", "");
Drive drive = objectConverter.getDriveByVMDKCiIdFromFinal(request.getSourceVMDKciid(), vpdcFinalXML);
driveName = drive.getMount();
}
vpdcQueueProcessDAO.save(vpdcQueueProcess);
taskInfo.setProcessId(String.valueOf(vpdcQueueProcess.getProcessId()));
taskInfo.setOrgId(request.getSourceBillingSiteid());
taskInfo.setOwnerId(String.valueOf(request.getSourceVpdcId()));
taskInfo.setProcessName("DeleteVCloudVMDK");
TaskResultInfo taskResultInfo = new TaskResultInfo();
taskResultInfo.setResultReference(String.valueOf(request.getSourceVMDKciid()));
taskResultInfo.setResultStatus(VpdcQueueProcessStatusEnum.QUEUED.name());
VpdcQueueProcessResult vpdcQueueProcessResult = new VpdcQueueProcessResult();
vpdcQueueProcessResult.setVpdcQueueProcess(vpdcQueueProcess);
vpdcQueueProcessResult.setProcessResultName(driveName);
vpdcQueueProcessResult.setProcessResultStatus(VpdcQueueProcessStatusEnum.QUEUED.name());
vpdcQueueProcessResult.setProcessResultId(request.getSourceVMDKciid());
taskResultInfo.setResultReferenceId(String.valueOf(request.getSourceVMDKciid()));
vpdcQueueProcessResultDAO.save(vpdcQueueProcessResult);
taskResultInfo.setResultId(String.valueOf(vpdcQueueProcessResult.getId()));
taskResultInfoList.add(taskResultInfo);
taskInfo.getTaskResultInfo().addAll(taskResultInfoList);
}

private void putCloneVMDKRequestInQueue(Object inputRequest, VpdcQueueProcess vpdcQueueProcess, TaskInfo taskInfo) {
List<TaskResultInfo> taskResultInfoList = new ArrayList<TaskResultInfo>();
CloneVCloudVMDKRequest request = (CloneVCloudVMDKRequest) inputRequest;
vpdcQueueProcess.setBillingSiteId(request.getSourceBillingSiteid());
vpdcQueueProcess.setVpdcId(request.getSourceVpdcId());
vpdcQueueProcess.setProcessName("CloneVCloudVMDK");
vpdcQueueProcess.setProcessIdentifier("02");
VpdcDetail vpdcDetail = vpdcDetailDAO.findVpdcDtlLatestByVpdcId(request.getSourceVpdcId());
if (null != vpdcDetail) {
vpdcQueueProcess.setProcessOwnerName(vpdcDetail.getVpdcName());
taskInfo.setOwnerReference(vpdcDetail.getVpdcName());
}
vpdcQueueProcessDAO.save(vpdcQueueProcess);
taskInfo.setProcessId(String.valueOf(vpdcQueueProcess.getProcessId()));
taskInfo.setOrgId(request.getSourceBillingSiteid());
taskInfo.setOwnerId(String.valueOf(request.getSourceVpdcId()));
taskInfo.setProcessName("CloneVCloudVMDK");
TaskResultInfo taskResultInfo = new TaskResultInfo();
taskResultInfo.setResultReference(request.getLabelName());
taskResultInfo.setResultStatus(VpdcQueueProcessStatusEnum.QUEUED.name());
VpdcQueueProcessResult vpdcQueueProcessResult = new VpdcQueueProcessResult();
vpdcQueueProcessResult.setVpdcQueueProcess(vpdcQueueProcess);
vpdcQueueProcessResult.setProcessResultName(request.getLabelName());
vpdcQueueProcessResult.setProcessResultStatus(VpdcQueueProcessStatusEnum.QUEUED.name());
vpdcQueueProcessResultDAO.save(vpdcQueueProcessResult);
taskResultInfo.setResultId(String.valueOf(vpdcQueueProcessResult.getId()));
taskResultInfoList.add(taskResultInfo);
taskInfo.getTaskResultInfo().addAll(taskResultInfoList);
}

}