http://git-wip-us.apache.org/repos/asf/airavata/blob/e13d90da/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/WorkerResource.java ---------------------------------------------------------------------- diff --git a/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/WorkerResource.java b/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/WorkerResource.java new file mode 100644 index 0000000..fbf7855 --- /dev/null +++ b/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/WorkerResource.java @@ -0,0 +1,908 @@ +/* + * + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + * + */ + +package org.apache.airavata.persistance.registry.jpa.resources; + +import org.apache.airavata.model.workspace.experiment.ExperimentState; +import org.apache.airavata.persistance.registry.jpa.Resource; +import org.apache.airavata.persistance.registry.jpa.ResourceType; +import org.apache.airavata.persistance.registry.jpa.ResourceUtils; +import org.apache.airavata.persistance.registry.jpa.model.*; +import org.apache.airavata.persistance.registry.jpa.utils.QueryGenerator; +import org.apache.airavata.registry.cpi.ResultOrderType; +import org.apache.airavata.registry.cpi.utils.Constants; +import org.apache.airavata.registry.cpi.utils.StatusType; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.apache.airavata.registry.cpi.RegistryException; + +import javax.persistence.EntityManager; +import javax.persistence.Query; +import java.sql.Timestamp; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.UUID; + +public class WorkerResource extends AbstractResource { + private final static Logger logger = LoggerFactory.getLogger(WorkerResource.class); + private String user; + private GatewayResource gateway; + + /** + * + */ + public WorkerResource() { + } + + /** + * + * @param user username + * @param gateway gatewayResource + */ + public WorkerResource(String user, GatewayResource gateway) { + this.setUser(user); + this.gateway=gateway; + } + + /** + * Gateway worker can create child data structures such as projects and user workflows + * @param type child resource type + * @return child resource + */ + public Resource create(ResourceType type) throws RegistryException{ + Resource result = null; + switch (type) { + case PROJECT: + ProjectResource projectResource = new ProjectResource(); + projectResource.setWorker(this); + projectResource.setGateway(gateway); + result=projectResource; + break; + case EXPERIMENT: + ExperimentResource experimentResource = new ExperimentResource(); + experimentResource.setExecutionUser(user); + experimentResource.setGateway(gateway); + result = experimentResource; + break; + default: + logger.error("Unsupported resource type for worker resource.", new IllegalArgumentException()); + throw new IllegalArgumentException("Unsupported resource type for worker resource."); + + } + return result; + } + + /** + * + * @param type child resource type + * @param name child resource name + */ + public void remove(ResourceType type, Object name) throws RegistryException{ + EntityManager em = null; + try { + em = ResourceUtils.getEntityManager(); + em.getTransaction().begin(); + Query q; + QueryGenerator generator; + switch (type) { + case PROJECT: + generator = new QueryGenerator(PROJECT); + generator.setParameter(ProjectConstants.PROJECT_ID, name); + q = generator.deleteQuery(em); + q.executeUpdate(); + break; + case EXPERIMENT: + generator = new QueryGenerator(EXPERIMENT); + generator.setParameter(ExperimentConstants.EXPERIMENT_ID, name); + q = generator.deleteQuery(em); + q.executeUpdate(); + break; + default: + logger.error("Unsupported resource type for worker resource.", new IllegalArgumentException()); + break; + } + em.getTransaction().commit(); + em.close(); + } catch (Exception e) { + logger.error(e.getMessage(), e); + throw new RegistryException(e.getMessage()); + } finally { + if (em != null && em.isOpen()) { + if (em.getTransaction().isActive()){ + em.getTransaction().rollback(); + } + em.close(); + } + } + } + + /** + * + * @param type child resource type + * @param name child resource name + * @return child resource + */ + public Resource get(ResourceType type, Object name) throws RegistryException{ + Resource result = null; + EntityManager em = null; + try { + em = ResourceUtils.getEntityManager(); + em.getTransaction().begin(); + QueryGenerator generator; + Query q; + switch (type) { + case PROJECT: + generator = new QueryGenerator(PROJECT); + generator.setParameter(ProjectConstants.PROJECT_ID, name); + q = generator.selectQuery(em); + Project project = (Project) q.getSingleResult(); + result = Utils.getResource(ResourceType.PROJECT, project); + break; + case EXPERIMENT: + generator = new QueryGenerator(EXPERIMENT); + generator.setParameter(ExperimentConstants.EXPERIMENT_ID, name); + q = generator.selectQuery(em); + Experiment experiment = (Experiment) q.getSingleResult(); + result = Utils.getResource(ResourceType.EXPERIMENT, experiment); + break; + default: + logger.error("Unsupported resource type for worker resource.", new IllegalArgumentException()); + break; + } + em.getTransaction().commit(); + em.close(); + } catch (Exception e) { + throw new RegistryException(e); + } finally { + if (em != null && em.isOpen()) { + if (em.getTransaction().isActive()){ + em.getTransaction().rollback(); + } + em.close(); + } + } + return result; + } + +// public List<GFacJobDataResource> getGFacJobs(String serviceDescriptionId, String hostDescriptionId, String applicationDescriptionId){ +// List<GFacJobDataResource> result = new ArrayList<GFacJobDataResource>(); +// EntityManager em = ResourceUtils.getEntityManager(); +// em.getTransaction().begin(); +// QueryGenerator generator; +// Query q; +// generator = new QueryGenerator(GFAC_JOB_DATA); +// generator.setParameter(GFacJobDataConstants.SERVICE_DESC_ID, serviceDescriptionId); +// generator.setParameter(GFacJobDataConstants.HOST_DESC_ID, hostDescriptionId); +// generator.setParameter(GFacJobDataConstants.APP_DESC_ID, applicationDescriptionId); +// q = generator.selectQuery(em); +// for (Object o : q.getResultList()) { +// GFac_Job_Data gFacJobData = (GFac_Job_Data)o; +// result.add((GFacJobDataResource)Utils.getResource(ResourceType.GFAC_JOB_DATA, gFacJobData)); +// } +// em.getTransaction().commit(); +// em.close(); +// return result; +// } +// +// public List<GFacJobStatusResource> getGFacJobStatuses(String jobId){ +// List<GFacJobStatusResource> resourceList = new ArrayList<GFacJobStatusResource>(); +// EntityManager em = ResourceUtils.getEntityManager(); +// em.getTransaction().begin(); +// QueryGenerator generator; +// Query q; +// generator = new QueryGenerator(GFAC_JOB_STATUS); +// generator.setParameter(GFacJobStatusConstants.LOCAL_JOB_ID, jobId); +// q = generator.selectQuery(em); +// for (Object result : q.getResultList()) { +// GFac_Job_Status gFacJobStatus = (GFac_Job_Status) result; +// GFacJobStatusResource gFacJobStatusResource = +// (GFacJobStatusResource)Utils.getResource(ResourceType.GFAC_JOB_STATUS, gFacJobStatus); +// resourceList.add(gFacJobStatusResource); +// } +// return resourceList; +// } + + /** + * Method getExperiment all results of the given child resource type + * + * @param type child resource type + * @return list of child resources + */ + public List<Resource> get(ResourceType type) throws RegistryException{ + return get(type, -1, -1, null, null); + } + + /** + * Method getExperiment all results of the given child resource type with paginaltion and ordering + * + * @param type child resource type + * @param limit + * @param offset + * @param orderByIdentifier + * @param resultOrderType + * @return list of child resources + * @throws RegistryException + */ + public List<Resource> get(ResourceType type, int limit, int offset, Object orderByIdentifier, + ResultOrderType resultOrderType) throws RegistryException{ + List<Resource> result = new ArrayList<Resource>(); + EntityManager em = null; + try { + em = ResourceUtils.getEntityManager(); + em.getTransaction().begin(); + QueryGenerator generator; + Query q; + switch (type) { + case PROJECT: + generator = new QueryGenerator(PROJECT); + Users users = em.find(Users.class, getUser()); + Gateway gatewayModel = em.find(Gateway.class, gateway.getGatewayId()); + generator.setParameter("users", users); + generator.setParameter("gateway", gatewayModel); + + //ordering - only supported only by CREATION_TIME + if(orderByIdentifier != null && resultOrderType != null + && orderByIdentifier.equals(Constants.FieldConstants.ProjectConstants.CREATION_TIME)) { + q = generator.selectQuery(em, ProjectConstants.CREATION_TIME, resultOrderType); + }else{ + q = generator.selectQuery(em); + } + + //pagination + if(limit>0 && offset>=0){ + q.setFirstResult(offset); + q.setMaxResults(limit); + } + + for (Object o : q.getResultList()) { + Project project = (Project) o; + ProjectResource projectResource = (ProjectResource) Utils.getResource(ResourceType.PROJECT, project); + result.add(projectResource); + } + break; + case EXPERIMENT: + generator = new QueryGenerator(EXPERIMENT); + generator.setParameter(ExperimentConstants.EXECUTION_USER, getUser()); + + //ordering - only supported only by CREATION_TIME + if(orderByIdentifier != null && resultOrderType != null + && orderByIdentifier.equals(Constants.FieldConstants.ProjectConstants.CREATION_TIME)) { + q = generator.selectQuery(em, ExperimentConstants.CREATION_TIME, resultOrderType); + }else{ + q = generator.selectQuery(em); + } + + //pagination + if(limit>0 && offset>=0){ + q.setFirstResult(offset); + q.setMaxResults(limit); + } + for (Object o : q.getResultList()) { + Experiment experiment = (Experiment) o; + ExperimentResource experimentResource = (ExperimentResource) Utils.getResource(ResourceType.EXPERIMENT, experiment); + result.add(experimentResource); + } + + break; + default: + logger.error("Unsupported resource type for worker resource.", new IllegalArgumentException()); + break; + } + em.getTransaction().commit(); + em.close(); + } catch (Exception e) { + logger.error(e.getMessage(), e); + throw new RegistryException(e); + } finally { + if (em != null && em.isOpen()) { + if (em.getTransaction().isActive()){ + em.getTransaction().rollback(); + } + em.close(); + } + } + return result; + } + + /** + * saveExperiment gateway worker to database + */ + public void save() throws RegistryException{ + EntityManager em = null; + try { + em = ResourceUtils.getEntityManager(); + Gateway_Worker existingWorker = em.find(Gateway_Worker.class, new Gateway_Worker_PK(gateway.getGatewayId(), user)); + em.close(); + + em = ResourceUtils.getEntityManager(); + em.getTransaction().begin(); + Gateway_Worker gatewayWorker = new Gateway_Worker(); + Users existingUser = em.find(Users.class, this.user); + gatewayWorker.setUser(existingUser); + gatewayWorker.setUser_name(existingUser.getUser_name()); + Gateway gatewaymodel = em.find(Gateway.class, gateway.getGatewayId()); + gatewayWorker.setGateway(gatewaymodel); + gatewayWorker.setGateway_id(gatewaymodel.getGateway_id()); + if (existingWorker != null) { + existingWorker.setUser_name(existingUser.getUser_name()); + existingWorker.setUser(existingUser); + existingWorker.setGateway(gatewaymodel); + existingWorker.setGateway_id(gatewaymodel.getGateway_id()); + gatewayWorker = em.merge(existingWorker); + } else { + em.persist(gatewayWorker); + } + em.getTransaction().commit(); + em.close(); + } catch (Exception e) { + logger.error(e.getMessage(), e); + throw new RegistryException(e); + } finally { + if (em != null && em.isOpen()) { + if (em.getTransaction().isActive()){ + em.getTransaction().rollback(); + } + em.close(); + } + } + } + + /** + * + * @return user name + */ + public String getUser() { + return user; + } + + /** + * + * @param user user name + */ + public void setUser(String user) { + this.user = user; + } + + /** + * + * @return gateway resource + */ + public GatewayResource getGateway() { + return gateway; + } + + /** + * + * @param gateway gateway resource + */ + public void setGateway(GatewayResource gateway) { + this.gateway = gateway; + } + + /** + * + * @param id project id + * @return whether the project is available under the user + */ + public boolean isProjectExists(String id) throws RegistryException{ + return isExists(ResourceType.PROJECT, id); + } + + /** + * + * @param projectId project id + * @return project resource for the user + */ + public ProjectResource createProject(String projectId) throws RegistryException{ + ProjectResource project=(ProjectResource)create(ResourceType.PROJECT); + project.setId(projectId); + return project; + } + + public String getProjectId(String projectName) { + String pro = projectName.replaceAll("\\s", ""); + return pro + "_" + UUID.randomUUID(); + } + + /** + * + * @param id project id + * @return project resource + */ + public ProjectResource getProject(String id) throws RegistryException{ + return (ProjectResource)get(ResourceType.PROJECT, id); + } + + /** + * + * @param id project id + */ + public void removeProject(String id) throws RegistryException{ + remove(ResourceType.PROJECT, id); + } + + /** + * Get projects list of user + * @return list of projects for the user + */ + public List<ProjectResource> getProjects() throws RegistryException{ + return getProjects(-1, -1, null, null); + } + + + /** + * Get projects list of user with pagination and ordering + * + * @return list of projects for the user + */ + public List<ProjectResource> getProjects(int limit, int offset, Object orderByIdentifier, + ResultOrderType resultOrderType) throws RegistryException{ + List<ProjectResource> result=new ArrayList<ProjectResource>(); + List<Resource> list = get(ResourceType.PROJECT, limit, offset, orderByIdentifier, resultOrderType); + for (Resource resource : list) { + result.add((ProjectResource) resource); + } + return result; + } + + /** + * + * @param name experiment name + * @return whether experiment is already exist for the given user + */ + public boolean isExperimentExists(String name) throws RegistryException{ + return isExists(ResourceType.EXPERIMENT, name); + } + + + /** + * + * @param name experiment name + * @return experiment resource + */ + public ExperimentResource getExperiment(String name) throws RegistryException{ + return (ExperimentResource)get(ResourceType.EXPERIMENT, name); + } +// +// public GFacJobDataResource getGFacJob(String jobId){ +// return (GFacJobDataResource)getExperiment(ResourceType.GFAC_JOB_DATA,jobId); +// } + + /** + * Method to getExperiment list of expeirments of user + * @return list of experiments for the user + */ + public List<ExperimentResource> getExperiments() throws RegistryException{ + return getExperiments(-1, -1, null, null); + } + + /** + * Method to getExperiment list of experiments of user with pagination and ordering + * @param limit + * @param offset + * @param orderByIdentifier + * @param resultOrderType + * @return + * @throws RegistryException + */ + public List<ExperimentResource> getExperiments(int limit, int offset, Object orderByIdentifier, + ResultOrderType resultOrderType) throws RegistryException{ + List<ExperimentResource> result=new ArrayList<ExperimentResource>(); + List<Resource> list = get(ResourceType.EXPERIMENT, limit, offset, orderByIdentifier, resultOrderType); + for (Resource resource : list) { + result.add((ExperimentResource) resource); + } + return result; + } + + /** + * + * @param experimentId experiment name + */ + public void removeExperiment(String experimentId) throws RegistryException{ + remove(ResourceType.EXPERIMENT, experimentId); + } + + /** + * To search projects of user with the given filter criteria. All the matching results will be sent. + * Results are not ordered in any order + * @param filters + * @return + * @throws RegistryException + */ + public List<ProjectResource> searchProjects (Map<String, String> filters) throws RegistryException{ + return searchProjects(filters, -1, -1, null, null); + } + + /** + * To search the projects of user with the given filter criteria and retrieve the results with + * pagination support. Results can be ordered based on an identifier (i.e column) either ASC or + * DESC. But in the current implementation ordering is only supported based on the project + * creation time + * + * @param filters + * @param limit + * @param offset + * @param orderByIdentifier + * @param resultOrderType + * @return + * @throws RegistryException + */ + public List<ProjectResource> searchProjects(Map<String, String> filters, int limit, + int offset, Object orderByIdentifier, ResultOrderType resultOrderType) throws RegistryException { + List<ProjectResource> result = new ArrayList<ProjectResource>(); + EntityManager em = null; + try { + String query = "SELECT p from Project p WHERE "; + if (filters != null && filters.size() != 0) { + for (String field : filters.keySet()) { + String filterVal = filters.get(field); + if (field.equals(ProjectConstants.USERNAME)) { + query += "p." + field + "= '" + filterVal + "' AND "; + }else if (field.equals(ProjectConstants.GATEWAY_ID)) { + query += "p." + field + "= '" + filterVal + "' AND "; + }else { + if (filterVal.contains("*")){ + filterVal = filterVal.replaceAll("\\*", ""); + } + query += "p." + field + " LIKE '%" + filterVal + "%' AND "; + } + } + } + query = query.substring(0, query.length() - 5); + + //ordering + if( orderByIdentifier != null && resultOrderType != null + && orderByIdentifier.equals(Constants.FieldConstants.ProjectConstants.CREATION_TIME)){ + String order = (resultOrderType == ResultOrderType.ASC) ? "ASC" : "DESC"; + query += " ORDER BY p." + ProjectConstants.CREATION_TIME + " " + order; + } + + em = ResourceUtils.getEntityManager(); + em.getTransaction().begin(); + Query q; + + //pagination + if(offset>=0 && limit >=0){ + q = em.createQuery(query).setFirstResult(offset).setMaxResults(limit); + }else{ + q = em.createQuery(query); + } + + List resultList = q.getResultList(); + for (Object o : resultList) { + Project project = (Project) o; + ProjectResource projectResource = + (ProjectResource) Utils.getResource(ResourceType.PROJECT, project); + result.add(projectResource); + } + em.getTransaction().commit(); + em.close(); + } catch (Exception e) { + logger.error(e.getMessage(), e); + throw new RegistryException(e); + } finally { + if (em != null && em.isOpen()) { + if (em.getTransaction().isActive()){ + em.getTransaction().rollback(); + } + em.close(); + } + } + return result; + } + + /** + * To search experiments of user with the given filter criteria. All the matching results will be sent. + * Results are not ordered in any order + * @param filters + * @return + * @throws RegistryException + */ + public List<ExperimentResource> searchExperiments (Map<String, String> filters) throws RegistryException{ + return searchExperiments(filters, -1, -1, null, null); + } + + /** + * To search the experiments of user with the given filter criteria and retrieve the results with + * pagination support. Results can be ordered based on an identifier (i.e column) either ASC or + * DESC. But in the current implementation ordering is only supported based on creationTime + * + * @param filters + * @param limit + * @param offset + * @param orderByIdentifier + * @param resultOrderType + * @return + * @throws RegistryException + */ + public List<ExperimentResource> searchExperiments(Map<String, String> filters, int limit, + int offset, Object orderByIdentifier, ResultOrderType resultOrderType) throws RegistryException { + + List<ExperimentResource> result = new ArrayList<ExperimentResource>(); + EntityManager em = null; + try { + String query = "SELECT e from Experiment e WHERE "; + if (filters != null && filters.size() != 0) { + for (String field : filters.keySet()) { + String filterVal = filters.get(field); + if (field.equals(ExperimentConstants.EXECUTION_USER)) { + query += "e." + field + "= '" + filterVal + "' AND "; + }else if (field.equals(ExperimentConstants.GATEWAY_ID)) { + query += "e." + field + "= '" + filterVal + "' AND "; + } else if (field.equals(ExperimentConstants.PROJECT_ID)) { + query += "e." + field + "= '" + filterVal + "' AND "; + } else { + if (filterVal.contains("*")){ + filterVal = filterVal.replaceAll("\\*", ""); + } + query += "e." + field + " LIKE '%" + filterVal + "%' AND "; + } + } + } + query = query.substring(0, query.length() - 5); + + //ordering + if( orderByIdentifier != null && resultOrderType != null + && orderByIdentifier.equals(Constants.FieldConstants.ExperimentConstants.CREATION_TIME)){ + String order = (resultOrderType == ResultOrderType.ASC) ? "ASC" : "DESC"; + query += " ORDER BY e." + ExperimentConstants.CREATION_TIME + " " + order; + } + + em = ResourceUtils.getEntityManager(); + em.getTransaction().begin(); + Query q; + + //pagination + if(offset>=0 && limit >=0){ + q = em.createQuery(query).setFirstResult(offset).setMaxResults(limit); + }else{ + q = em.createQuery(query); + } + + List resultList = q.getResultList(); + for (Object o : resultList) { + Experiment experiment = (Experiment) o; + ExperimentResource experimentResource = + (ExperimentResource) Utils.getResource(ResourceType.EXPERIMENT, experiment); + result.add(experimentResource); + } + em.getTransaction().commit(); + em.close(); + } catch (Exception e) { + logger.error(e.getMessage(), e); + throw new RegistryException(e); + } finally { + if (em != null && em.isOpen()) { + if (em.getTransaction().isActive()){ + em.getTransaction().rollback(); + } + em.close(); + } + } + return result; + } + + /** + * Method to getExperiment experiments by state + * @param filters + * @return + * @throws RegistryException + */ + public List<ExperimentResource> searchExperimentsByState (Map<String, String> filters) throws RegistryException{ + return searchExperimentsByState(filters, -1, -1, null, null); + } + + /** + * Method to getExperiment experiments of the given state with pagination and ordering + * @param filters + * @param limit + * @param offset + * @param orderByIdentifier + * @param resultOrderType + * @return + * @throws RegistryException + */ + public List<ExperimentResource> searchExperimentsByState (Map<String, String> filters, int limit, int offset, + Object orderByIdentifier, ResultOrderType resultOrderType) throws RegistryException{ + List<ExperimentResource> result = new ArrayList<ExperimentResource>(); + EntityManager em = null; + try { + String experimentState = ExperimentState.valueOf(filters.get(StatusConstants.STATE)).toString(); + String query = "SELECT e FROM Status s " + + "JOIN s.experiment e " + + "WHERE s.state='" + experimentState + "' " + + "AND s.statusType='" + StatusType.EXPERIMENT + "' AND "; + + filters.remove(StatusConstants.STATE); + if (filters.size() != 0) { + for (String field : filters.keySet()) { + String filterVal = filters.get(field); + if (field.equals(ExperimentConstants.EXECUTION_USER)) { + query += "e." + field + "= '" + filterVal + "' AND "; + }else if (field.equals(ExperimentConstants.GATEWAY_ID)) { + query += "e." + field + "= '" + filterVal + "' AND "; + } else if (field.equals(ExperimentConstants.PROJECT_ID)) { + query += "e." + field + "= '" + filterVal + "' AND "; + } else { + if (filterVal.contains("*")){ + filterVal = filterVal.replaceAll("\\*", ""); + } + query += "e." + field + " LIKE '%" + filterVal + "%' AND "; + } + } + } + query = query.substring(0, query.length() - 5); + + //ordering + if( orderByIdentifier != null && resultOrderType != null + && orderByIdentifier.equals(Constants.FieldConstants.ExperimentConstants.CREATION_TIME)){ + String order = (resultOrderType == ResultOrderType.ASC) ? "ASC" : "DESC"; + query += " ORDER BY e." + ExperimentConstants.CREATION_TIME + " " + order; + } + + em = ResourceUtils.getEntityManager(); + em.getTransaction().begin(); + Query q; + + //pagination + if(offset>=0 && limit >=0){ + q = em.createQuery(query).setFirstResult(offset).setMaxResults(limit); + }else{ + q = em.createQuery(query); + } + + List resultList = q.getResultList(); + for (Object o : resultList) { + Experiment experiment = (Experiment) o; + ExperimentResource experimentResource = (ExperimentResource) Utils.getResource(ResourceType.EXPERIMENT, experiment); + result.add(experimentResource); + } + em.getTransaction().commit(); + em.close(); + } catch (Exception e) { + logger.error(e.getMessage(), e); + throw new RegistryException(e); + } finally { + if (em != null && em.isOpen()) { + if (em.getTransaction().isActive()){ + em.getTransaction().rollback(); + } + em.close(); + } + } + return result; + } + + /** + * Search experiments from creation time between interval. Returns all results + * @param fromTime + * @param toTime + * @return + * @throws RegistryException + */ + public List<ExperimentResource> searchExperimentsByCreationTime (Timestamp fromTime, Timestamp toTime) throws RegistryException{ + return searchExperimentsByCreationTime(fromTime, toTime, -1, -1, null, null); + } + + + /** + * Search experiments from creation time between interval. Results are ordered creation time DESC. + * Supports pagination + * + * @param fromTime + * @param toTime + * @param limit + * @param offset + * @param orderByIdentifier + * @param resultOrderType + * @return + * @throws RegistryException + */ + public List<ExperimentResource> searchExperimentsByCreationTime( + Timestamp fromTime, Timestamp toTime, int limit, int offset, Object orderByIdentifier, + ResultOrderType resultOrderType) throws RegistryException{ + + List<ExperimentResource> result = new ArrayList<ExperimentResource>(); + EntityManager em = null; + try { + String query = "SELECT e FROM Experiment e " + + "WHERE e.creationTime > '" + fromTime + "' " + + "AND e.creationTime <'" + toTime + "'"; + + //ordering + if( orderByIdentifier != null && resultOrderType != null + && orderByIdentifier.equals(Constants.FieldConstants.ExperimentConstants.CREATION_TIME)){ + String order = (resultOrderType == ResultOrderType.ASC) ? "ASC" : "DESC"; + query += " ORDER BY e." + ExperimentConstants.CREATION_TIME + " " + order; + } + + em = ResourceUtils.getEntityManager(); + em.getTransaction().begin(); + Query q; + + //pagination + if(offset>=0 && limit >=0){ + q = em.createQuery(query).setFirstResult(offset).setMaxResults(limit); + }else{ + q = em.createQuery(query); + } + + List resultList = q.getResultList(); + for (Object o : resultList) { + Experiment experiment = (Experiment) o; + ExperimentResource experimentResource = (ExperimentResource) Utils.getResource(ResourceType.EXPERIMENT, experiment); + result.add(experimentResource); + } + em.getTransaction().commit(); + em.close(); + } catch (Exception e) { + logger.error(e.getMessage(), e); + throw new RegistryException(e); + } finally { + if (em != null && em.isOpen()) { + if (em.getTransaction().isActive()){ + em.getTransaction().rollback(); + } + em.close(); + } + } + return result; + } + + /** + * + * @return list of experiments for the user + */ + public List<ExperimentResource> getExperimentsByCaching(String user) throws RegistryException{ + List<ExperimentResource> result = new ArrayList<ExperimentResource>(); + EntityManager em = null; + try { + String query = "SELECT e from Experiment e WHERE e.executionUser = '" + user + "'"; + em = ResourceUtils.getEntityManager(); +// OpenJPAEntityManagerFactory oemf = OpenJPAPersistence.cast(em.getEntityManagerFactory()); +// QueryResultCache qcache = oemf.getQueryResultCache(); + // qcache.evictAll(Experiment.class); + em.getTransaction().begin(); + Query q = em.createQuery(query); + List resultList = q.getResultList(); + for (Object o : resultList) { + Experiment experiment = (Experiment) o; + ExperimentResource experimentResource = (ExperimentResource) Utils.getResource(ResourceType.EXPERIMENT, experiment); + result.add(experimentResource); + } + em.getTransaction().commit(); + em.close(); + } catch (Exception e) { + logger.error(e.getMessage(), e); + throw new RegistryException(e); + } finally { + if (em != null && em.isOpen()) { + if (em.getTransaction().isActive()){ + em.getTransaction().rollback(); + } + em.close(); + } + } + return result; + } +}
http://git-wip-us.apache.org/repos/asf/airavata/blob/e13d90da/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/WorkflowNodeDetailResource.java ---------------------------------------------------------------------- diff --git a/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/WorkflowNodeDetailResource.java b/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/WorkflowNodeDetailResource.java new file mode 100644 index 0000000..9d2869d --- /dev/null +++ b/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/WorkflowNodeDetailResource.java @@ -0,0 +1,473 @@ +/* + * + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + * + */ + +package org.apache.airavata.persistance.registry.jpa.resources; + +import org.apache.airavata.persistance.registry.jpa.Resource; +import org.apache.airavata.persistance.registry.jpa.ResourceType; +import org.apache.airavata.persistance.registry.jpa.ResourceUtils; +import org.apache.airavata.persistance.registry.jpa.model.*; +import org.apache.airavata.persistance.registry.jpa.utils.QueryGenerator; +import org.apache.airavata.registry.cpi.utils.StatusType; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.apache.airavata.registry.cpi.RegistryException; + +import javax.persistence.EntityManager; +import javax.persistence.Query; +import java.sql.Timestamp; +import java.util.ArrayList; +import java.util.List; + +public class WorkflowNodeDetailResource extends AbstractResource { + private static final Logger logger = LoggerFactory.getLogger(WorkflowNodeDetailResource.class); + private ExperimentResource experimentResource; + private String nodeInstanceId; + private Timestamp creationTime; + private String nodeName; + private String executionUnit; + private String executionUnitData; + + public ExperimentResource getExperimentResource() { + return experimentResource; + } + + public void setExperimentResource(ExperimentResource experimentResource) { + this.experimentResource = experimentResource; + } + + public String getNodeInstanceId() { + return nodeInstanceId; + } + + public void setNodeInstanceId(String nodeInstanceId) { + this.nodeInstanceId = nodeInstanceId; + } + + public Timestamp getCreationTime() { + return creationTime; + } + + public void setCreationTime(Timestamp creationTime) { + this.creationTime = creationTime; + } + + public String getNodeName() { + return nodeName; + } + + public void setNodeName(String nodeName) { + this.nodeName = nodeName; + } + + public Resource create(ResourceType type) throws RegistryException{ + switch (type){ + case TASK_DETAIL: + TaskDetailResource taskDetailResource = new TaskDetailResource(); + taskDetailResource.setWorkflowNodeDetailResource(this); + return taskDetailResource; + case ERROR_DETAIL: + ErrorDetailResource errorDetailResource = new ErrorDetailResource(); + errorDetailResource.setNodeDetail(this); + return errorDetailResource; + case NODE_INPUT: + NodeInputResource nodeInputResource = new NodeInputResource(); + nodeInputResource.setNodeDetailResource(this); + return nodeInputResource; + case NODE_OUTPUT: + NodeOutputResource nodeOutputResource = new NodeOutputResource(); + nodeOutputResource.setNodeDetailResource(this); + return nodeOutputResource; + case STATUS: + StatusResource statusResource = new StatusResource(); + statusResource.setWorkflowNodeDetail(this); + return statusResource; + default: + logger.error("Unsupported resource type for workflow node detail resource.", new IllegalArgumentException()); + throw new IllegalArgumentException("Unsupported resource type for workflow node detail resource."); + } + } + + public void remove(ResourceType type, Object name) throws RegistryException{ + EntityManager em = null; + try { + em = ResourceUtils.getEntityManager(); + em.getTransaction().begin(); + Query q; + QueryGenerator generator; + switch (type) { + case TASK_DETAIL: + generator = new QueryGenerator(TASK_DETAIL); + generator.setParameter(TaskDetailConstants.TASK_ID, name); + q = generator.deleteQuery(em); + q.executeUpdate(); + break; + case ERROR_DETAIL: + generator = new QueryGenerator(ERROR_DETAIL); + generator.setParameter(ErrorDetailConstants.NODE_INSTANCE_ID, name); + q = generator.deleteQuery(em); + q.executeUpdate(); + break; + case NODE_INPUT: + generator = new QueryGenerator(NODE_INPUT); + generator.setParameter(NodeInputConstants.NODE_INSTANCE_ID, name); + q = generator.deleteQuery(em); + q.executeUpdate(); + break; + case NODE_OUTPUT: + generator = new QueryGenerator(NODE_OUTPUT); + generator.setParameter(NodeOutputConstants.NODE_INSTANCE_ID, name); + q = generator.deleteQuery(em); + q.executeUpdate(); + break; + case STATUS: + generator = new QueryGenerator(STATUS); + generator.setParameter(StatusConstants.NODE_INSTANCE_ID, name); + generator.setParameter(StatusConstants.STATUS_TYPE, StatusType.WORKFLOW_NODE.toString()); + q = generator.deleteQuery(em); + q.executeUpdate(); + break; + default: + logger.error("Unsupported resource type for experiment resource.", new IllegalArgumentException()); + break; + } + em.getTransaction().commit(); + em.close(); + } catch (Exception e) { + logger.error(e.getMessage(), e); + throw new RegistryException(e); + } finally { + if (em != null && em.isOpen()) { + if (em.getTransaction().isActive()){ + em.getTransaction().rollback(); + } + em.close(); + } + } + } + + public Resource get(ResourceType type, Object name) throws RegistryException{ + EntityManager em = null; + try { + em = ResourceUtils.getEntityManager(); + em.getTransaction().begin(); + QueryGenerator generator; + Query q; + switch (type) { + case TASK_DETAIL: + generator = new QueryGenerator(TASK_DETAIL); + generator.setParameter(TaskDetailConstants.TASK_ID, name); + q = generator.selectQuery(em); + TaskDetail taskDetail = (TaskDetail) q.getSingleResult(); + TaskDetailResource taskDetailResource = (TaskDetailResource) Utils.getResource(ResourceType.TASK_DETAIL, taskDetail); + em.getTransaction().commit(); + em.close(); + return taskDetailResource; + case ERROR_DETAIL: + generator = new QueryGenerator(ERROR_DETAIL); + generator.setParameter(ErrorDetailConstants.NODE_INSTANCE_ID, name); + q = generator.selectQuery(em); + ErrorDetail errorDetail = (ErrorDetail) q.getSingleResult(); + ErrorDetailResource errorDetailResource = (ErrorDetailResource) Utils.getResource(ResourceType.ERROR_DETAIL, errorDetail); + em.getTransaction().commit(); + em.close(); + return errorDetailResource; + case NODE_INPUT: + generator = new QueryGenerator(NODE_INPUT); + generator.setParameter(NodeInputConstants.NODE_INSTANCE_ID, name); + q = generator.selectQuery(em); + NodeInput nodeInput = (NodeInput) q.getSingleResult(); + NodeInputResource nodeInputResource = (NodeInputResource) Utils.getResource(ResourceType.NODE_INPUT, nodeInput); + em.getTransaction().commit(); + em.close(); + return nodeInputResource; + case NODE_OUTPUT: + generator = new QueryGenerator(NODE_OUTPUT); + generator.setParameter(NodeOutputConstants.NODE_INSTANCE_ID, name); + q = generator.selectQuery(em); + NodeOutput nodeOutput = (NodeOutput) q.getSingleResult(); + NodeOutputResource nodeOutputResource = (NodeOutputResource) Utils.getResource(ResourceType.NODE_OUTPUT, nodeOutput); + em.getTransaction().commit(); + em.close(); + return nodeOutputResource; + case STATUS: + generator = new QueryGenerator(STATUS); + generator.setParameter(StatusConstants.NODE_INSTANCE_ID, name); + generator.setParameter(StatusConstants.STATUS_TYPE, StatusType.WORKFLOW_NODE.toString()); + q = generator.selectQuery(em); + Status status = (Status) q.getSingleResult(); + StatusResource statusResource = (StatusResource) Utils.getResource(ResourceType.STATUS, status); + em.getTransaction().commit(); + em.close(); + return statusResource; + default: + em.getTransaction().commit(); + em.close(); + logger.error("Unsupported resource type for workflow node resource.", new IllegalArgumentException()); + throw new IllegalArgumentException("Unsupported resource type for workflow node resource."); + } + } catch (Exception e) { + throw new RegistryException(e); + } finally { + if (em != null && em.isOpen()) { + if (em.getTransaction().isActive()){ + em.getTransaction().rollback(); + } + em.close(); + } + } + } + + public List<Resource> get(ResourceType type) throws RegistryException{ + List<Resource> resourceList = new ArrayList<Resource>(); + EntityManager em = null; + try { + em = ResourceUtils.getEntityManager(); + em.getTransaction().begin(); + Query q; + QueryGenerator generator; + List results; + switch (type) { + case TASK_DETAIL: + generator = new QueryGenerator(TASK_DETAIL); + generator.setParameter(TaskDetailConstants.NODE_INSTANCE_ID, nodeInstanceId); + q = generator.selectQuery(em); + results = q.getResultList(); + if (results.size() != 0) { + for (Object result : results) { + TaskDetail taskDetail = (TaskDetail) result; + TaskDetailResource taskDetailResource = + (TaskDetailResource) Utils.getResource(ResourceType.TASK_DETAIL, taskDetail); + resourceList.add(taskDetailResource); + } + } + break; + case ERROR_DETAIL: + generator = new QueryGenerator(ERROR_DETAIL); + generator.setParameter(ErrorDetailConstants.NODE_INSTANCE_ID, nodeInstanceId); + q = generator.selectQuery(em); + results = q.getResultList(); + if (results.size() != 0) { + for (Object result : results) { + ErrorDetail errorDetail = (ErrorDetail) result; + ErrorDetailResource errorDetailResource = + (ErrorDetailResource) Utils.getResource(ResourceType.ERROR_DETAIL, errorDetail); + resourceList.add(errorDetailResource); + } + } + break; + case NODE_INPUT: + generator = new QueryGenerator(NODE_INPUT); + generator.setParameter(NodeInputConstants.NODE_INSTANCE_ID, nodeInstanceId); + q = generator.selectQuery(em); + results = q.getResultList(); + if (results.size() != 0) { + for (Object result : results) { + NodeInput nodeInput = (NodeInput) result; + NodeInputResource nodeInputResource = + (NodeInputResource) Utils.getResource(ResourceType.NODE_INPUT, nodeInput); + resourceList.add(nodeInputResource); + } + } + break; + case NODE_OUTPUT: + generator = new QueryGenerator(NODE_OUTPUT); + generator.setParameter(NodeOutputConstants.NODE_INSTANCE_ID, nodeInstanceId); + q = generator.selectQuery(em); + results = q.getResultList(); + if (results.size() != 0) { + for (Object result : results) { + NodeOutput nodeOutput = (NodeOutput) result; + NodeOutputResource nodeOutputResource = + (NodeOutputResource) Utils.getResource(ResourceType.NODE_OUTPUT, nodeOutput); + resourceList.add(nodeOutputResource); + } + } + break; + case STATUS: + generator = new QueryGenerator(STATUS); + generator.setParameter(StatusConstants.NODE_INSTANCE_ID, nodeInstanceId); + q = generator.selectQuery(em); + results = q.getResultList(); + if (results.size() != 0) { + for (Object result : results) { + Status status = (Status) result; + StatusResource statusResource = + (StatusResource) Utils.getResource(ResourceType.STATUS, status); + resourceList.add(statusResource); + } + } + break; + default: + em.getTransaction().commit(); + em.close(); + logger.error("Unsupported resource type for workflow node details resource.", new UnsupportedOperationException()); + throw new UnsupportedOperationException(); + } + em.getTransaction().commit(); + em.close(); + } catch (Exception e) { +// logger.error(e.getMessage(), e); + throw new RegistryException(e); + } finally { + if (em != null && em.isOpen()) { + if (em.getTransaction().isActive()){ + em.getTransaction().rollback(); + } + em.close(); + } + } + return resourceList; + } + + public void save() throws RegistryException{ + EntityManager em = null; + try { + em = ResourceUtils.getEntityManager(); + WorkflowNodeDetail existingNode = em.find(WorkflowNodeDetail.class, nodeInstanceId); + em.close(); + + em = ResourceUtils.getEntityManager(); + em.getTransaction().begin(); + WorkflowNodeDetail workflowNodeDetail = new WorkflowNodeDetail(); + workflowNodeDetail.setNodeId(nodeInstanceId); + Experiment experiment = em.find(Experiment.class, experimentResource.getExpID()); + workflowNodeDetail.setExperiment(experiment); + workflowNodeDetail.setExpId(experimentResource.getExpID()); + workflowNodeDetail.setCreationTime(creationTime); + workflowNodeDetail.setNodeName(nodeName); + workflowNodeDetail.setExecutionUnit(getExecutionUnit()); + workflowNodeDetail.setExecutionUnitData(getExecutionUnitData()); + + if (existingNode != null) { + existingNode.setExperiment(experiment); + existingNode.setExpId(experimentResource.getExpID()); + existingNode.setCreationTime(creationTime); + existingNode.setNodeName(nodeName); + existingNode.setExecutionUnit(getExecutionUnit()); + existingNode.setExecutionUnitData(getExecutionUnitData()); + workflowNodeDetail = em.merge(existingNode); + } else { + em.persist(workflowNodeDetail); + } + em.getTransaction().commit(); + em.close(); + } catch (Exception e) { + logger.error(e.getMessage(), e); + throw new RegistryException(e); + } finally { + if (em != null && em.isOpen()) { + if (em.getTransaction().isActive()){ + em.getTransaction().rollback(); + } + em.close(); + } + } + } + + public List<NodeInputResource> getNodeInputs() throws RegistryException{ + List<NodeInputResource> nodeInputResourceList = new ArrayList<NodeInputResource>(); + List<Resource> resources = get(ResourceType.NODE_INPUT); + for (Resource resource : resources) { + NodeInputResource nodeInputResource = (NodeInputResource) resource; + nodeInputResourceList.add(nodeInputResource); + } + return nodeInputResourceList; + } + + public List<NodeOutputResource> getNodeOutputs() throws RegistryException{ + List<NodeOutputResource> outputResources = new ArrayList<NodeOutputResource>(); + List<Resource> resources = get(ResourceType.NODE_OUTPUT); + for (Resource resource : resources) { + NodeOutputResource nodeOutputResource = (NodeOutputResource) resource; + outputResources.add(nodeOutputResource); + } + return outputResources; + } + + public StatusResource getWorkflowNodeStatus() throws RegistryException{ + List<Resource> resources = get(ResourceType.STATUS); + for (Resource resource : resources) { + StatusResource nodeStatus = (StatusResource) resource; + if(nodeStatus.getStatusType().equals(StatusType.WORKFLOW_NODE.toString())){ + if (nodeStatus.getState() == null || nodeStatus.getState().equals("") ){ + nodeStatus.setState("UNKNOWN"); + } + return nodeStatus; + } + } + return null; + } + + public StatusResource getTaskStatus(String taskId) throws RegistryException{ + List<Resource> resources = get(ResourceType.STATUS); + for (Resource resource : resources) { + StatusResource taskStatus = (StatusResource) resource; + if(taskStatus.getStatusType().equals(StatusType.TASK.toString()) && taskStatus.getTaskDetailResource().getTaskId().equals(taskId)){ + if (taskStatus.getState() == null || taskStatus.getState().equals("") ){ + taskStatus.setState("UNKNOWN"); + } + return taskStatus; + } + } + return null; + } + + public List<TaskDetailResource> getTaskDetails() throws RegistryException{ + List<TaskDetailResource> taskDetailResources = new ArrayList<TaskDetailResource>(); + List<Resource> resources = get(ResourceType.TASK_DETAIL); + for (Resource resource : resources) { + TaskDetailResource taskDetailResource = (TaskDetailResource) resource; + taskDetailResources.add(taskDetailResource); + } + return taskDetailResources; + } + + public List<ErrorDetailResource> getErrorDetails() throws RegistryException{ + List<ErrorDetailResource> errorDetails = new ArrayList<ErrorDetailResource>(); + List<Resource> resources = get(ResourceType.ERROR_DETAIL); + for (Resource resource : resources) { + ErrorDetailResource errorDetailResource = (ErrorDetailResource) resource; + errorDetails.add(errorDetailResource); + } + return errorDetails; + } + + public TaskDetailResource getTaskDetail(String taskId) throws RegistryException{ + return (TaskDetailResource)get(ResourceType.TASK_DETAIL, taskId); + } + + public String getExecutionUnit() { + return executionUnit; + } + + public void setExecutionUnit(String executionUnit) { + this.executionUnit = executionUnit; + } + + public String getExecutionUnitData() { + return executionUnitData; + } + + public void setExecutionUnitData(String executionUnitData) { + this.executionUnitData = executionUnitData; + } +} http://git-wip-us.apache.org/repos/asf/airavata/blob/e13d90da/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/utils/QueryGenerator.java ---------------------------------------------------------------------- diff --git a/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/utils/QueryGenerator.java b/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/utils/QueryGenerator.java new file mode 100644 index 0000000..b0ebe45 --- /dev/null +++ b/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/utils/QueryGenerator.java @@ -0,0 +1,128 @@ +/* + * + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + * + */ + +package org.apache.airavata.persistance.registry.jpa.utils; + +import org.apache.airavata.registry.cpi.ResultOrderType; + +import javax.persistence.EntityManager; +import javax.persistence.Query; +import java.util.HashMap; +import java.util.Map; + +public class QueryGenerator { + private String tableName; + private Map<String,Object> matches=new HashMap<String, Object>(); + private static final String SELECT_OBJ="p"; + private static final String DELETE_OBJ="p"; + private static final String TABLE_OBJ="p"; +// +// public QueryGenerator(String tableName) { +// setTableName(tableName); +// } + + public QueryGenerator(String tableName, Object[]...params) { + setTableName(tableName); + for (Object[] param : params) { + addMatch(param[0].toString(), param[1]); + } + } + + public String getTableName() { + return tableName; + } + public void setTableName(String tableName) { + this.tableName = tableName; + } + public void addMatch(String colName, Object matchValue){ + matches.put(colName, matchValue); + } + + public void setParameter(String colName, Object matchValue){ + addMatch(colName, matchValue); + } + + /** + * Select query + * @param entityManager + * @return + */ + public Query selectQuery(EntityManager entityManager){ + String queryString="SELECT "+ SELECT_OBJ + " FROM " +getTableName()+" "+TABLE_OBJ; + return generateQueryWithParameters(entityManager, queryString); + } + + /** + * Select query with pagination + * @param entityManager + * @param orderByColumn + * @param resultOrderType + * @return + */ + public Query selectQuery(EntityManager entityManager, String orderByColumn, + ResultOrderType resultOrderType){ + String order = (resultOrderType == ResultOrderType.ASC) ? "ASC" : "DESC"; + String orderByClause = " ORDER BY " + SELECT_OBJ + "." + orderByColumn + " " + order; + String queryString="SELECT "+ SELECT_OBJ + " FROM " +getTableName()+" "+TABLE_OBJ; + return generateQueryWithParameters(entityManager, queryString, orderByClause); + } + +// public Query countQuery(EntityManager entityManager){ +// SELECT COUNT(p.host_descriptor_ID) FROM Host_Descriptor p WHERE p.gateway_name =:gate_ID and p.host_descriptor_ID =:host_desc_name") +// String queryString="SELECT COUNT("+ SELECT_OBJ + " FROM " +getTableName()+" "+TABLE_OBJ; +// return generateQueryWithParameters(entityManager, queryString); +// } + + public Query deleteQuery(EntityManager entityManager){ + String queryString="Delete FROM "+getTableName()+" "+TABLE_OBJ; + return generateQueryWithParameters(entityManager, queryString); + } + + private Query generateQueryWithParameters(EntityManager entityManager, + String queryString) { + return generateQueryWithParameters(entityManager, queryString, ""); + } + + private Query generateQueryWithParameters(EntityManager entityManager, + String queryString, String orderByClause) { + Map<String,Object> queryParameters=new HashMap<String, Object>(); + if (matches.size()>0){ + String matchString = ""; + int paramCount=0; + for (String colName : matches.keySet()) { + String paramName="param"+paramCount; + queryParameters.put(paramName, matches.get(colName)); + if (!matchString.equals("")){ + matchString+=" AND "; + } + matchString+=TABLE_OBJ+"."+colName+" =:"+paramName; + paramCount++; + } + queryString+=" WHERE "+matchString; + } + queryString += orderByClause; + Query query = entityManager.createQuery(queryString); + for (String paramName : queryParameters.keySet()) { + query.setParameter(paramName, queryParameters.get(paramName)); + } + return query; + } +}
