Example usage for org.hibernate.criterion Restrictions disjunction

List of usage examples for org.hibernate.criterion Restrictions disjunction

  1. HOME
  2. Java
  3. org.hibernate
  4. org.hibernate.criterion.*
  5. Restrictions
  6. disjunction

Introduction

In this page you can find the example usage for org.hibernate.criterion Restrictions disjunction.

Prototype

public static Disjunction disjunction()

Source Link

Document

Group expressions together in a single disjunction (A or B or C...).

Usage

From source file:org.dcm4chee.arr.cdi.ejb.AuditRecordQueryBean.java

License:LGPL

/**
 * Gets the code string criteria.//from w  ww .j a va2 s.c  om
 * 
 * @param alias
 *            the alias
 * @param codeStrings
 *            the code strings
 * @return the code string criteria
 */
private static Disjunction getCodeStringCriteria(String alias, String[][] codeStrings) {
    Disjunction disjuncation = Restrictions.disjunction();
    for (String codeString[] : codeStrings) {
        disjuncation.add(Restrictions.conjunction().add(Restrictions.eq(alias + ".value", codeString[0]))
                .add(Restrictions.eq(alias + ".designator", codeString[1])));
    }
    return disjuncation;
}

From source file:org.egov.egf.web.actions.masters.JQueryGridActionSupport.java

License:Open Source License

/**
 * This will get invoked only if user uses search on jqgrid. This is capable applying jqgrid single and group filtering
 * searches.//from   ww  w.j a  v  a  2 s  . c  o  m
 **/
private void applySearchCriteriaIfAny(final Criteria criteria) {
    if (_search)
        if (StringUtils.isBlank(filters))
            criteria.add(applyRestriction());
        else {
            final MultipleSearchFilter multipleSearchFilter = getMultiSearchFilter();
            if ("AND".equals(multipleSearchFilter.getGroupOp()))
                applyJunctionCriterion(Restrictions.conjunction(), criteria, multipleSearchFilter);
            else if ("OR".equals(multipleSearchFilter.getGroupOp()))
                applyJunctionCriterion(Restrictions.disjunction(), criteria, multipleSearchFilter);
        }
    criteria.addOrder(applyOrderBy());
}

From source file:org.egov.infra.persistence.validator.UniqueDateOverlapValidator.java

License:Open Source License

private boolean checkUnique(Object object) throws IllegalAccessException {
    Number id = (Number) FieldUtils.readField(object, uniqueDateOverlap.id(), true);
    Criteria uniqueDateOverlapChecker = entityManager.unwrap(Session.class).createCriteria(object.getClass())
            .setReadOnly(true);/*from  ww  w .  j  a  va  2s. c  o m*/
    Conjunction uniqueCheck = Restrictions.conjunction();
    for (String fieldName : uniqueDateOverlap.uniqueFields()) {
        Object fieldValue = FieldUtils.readField(object, fieldName, true);
        if (fieldValue instanceof String)
            uniqueCheck.add(Restrictions.eq(fieldName, fieldValue).ignoreCase());
        else
            uniqueCheck.add(Restrictions.eq(fieldName, fieldValue));
    }
    Date fromDate = startOfDay((Date) FieldUtils.readField(object, uniqueDateOverlap.fromField(), true));
    Date toDate = endOfDay((Date) FieldUtils.readField(object, uniqueDateOverlap.toField(), true));
    Conjunction checkFromDate = Restrictions.conjunction();
    checkFromDate.add(Restrictions.le(uniqueDateOverlap.fromField(), fromDate));
    checkFromDate.add(Restrictions.ge(uniqueDateOverlap.toField(), fromDate));
    Conjunction checkToDate = Restrictions.conjunction();
    checkToDate.add(Restrictions.le(uniqueDateOverlap.fromField(), toDate));
    checkToDate.add(Restrictions.ge(uniqueDateOverlap.toField(), toDate));
    Conjunction checkFromAndToDate = Restrictions.conjunction();
    checkFromAndToDate.add(Restrictions.ge(uniqueDateOverlap.fromField(), fromDate));
    checkFromAndToDate.add(Restrictions.le(uniqueDateOverlap.toField(), toDate));
    Disjunction dateRangeChecker = Restrictions.disjunction();
    dateRangeChecker.add(checkFromDate).add(checkToDate).add(checkFromAndToDate);
    uniqueCheck.add(dateRangeChecker);
    if (id != null)
        uniqueCheck.add(Restrictions.ne(uniqueDateOverlap.id(), id));
    return uniqueDateOverlapChecker.add(uniqueCheck).setProjection(Projections.id()).setMaxResults(1)
            .uniqueResult() == null;
}

From source file:org.egov.infra.workflow.service.SimpleWorkflowService.java

License:Open Source License

private Criteria createWfMatrixAdditionalCriteria(String type, String department, BigDecimal amountRule,
        String additionalRule, String currentState, String pendingActions, String designation) {
    Criteria wfMatrixCriteria = commonWorkFlowMatrixCriteria(type, additionalRule, currentState,
            pendingActions);/*from   w w  w.  ja  v a  2  s .c o  m*/
    if (isNotBlank(department))
        wfMatrixCriteria.add(Restrictions.eq(DEPARTMENT, department));

    // Added restriction for amount rule
    if (amountRule != null && BigDecimal.ZERO.compareTo(amountRule) != 0) {
        Criterion amount1st = Restrictions.conjunction().add(Restrictions.le(FROM_QTY, amountRule))
                .add(Restrictions.ge(TO_QTY, amountRule));

        Criterion amount2nd = Restrictions.conjunction().add(Restrictions.le(FROM_QTY, amountRule))
                .add(Restrictions.isNull(TO_QTY));
        wfMatrixCriteria.add(Restrictions.disjunction().add(amount1st).add(amount2nd));

    }

    if (isNotBlank(designation))
        wfMatrixCriteria.add(Restrictions.ilike(CURRENT_DESIGNATION, designation));

    return wfMatrixCriteria;
}

From source file:org.egov.infra.workflow.service.SimpleWorkflowService.java

License:Open Source License

public WorkFlowMatrix getPreviousStateFromWfMatrix(String type, String department, BigDecimal amountRule,
        String additionalRule, String currentState, String pendingActions) {

    Criteria wfMatrixCriteria = previousWorkFlowMatrixCriteria(type, additionalRule, currentState,
            pendingActions);/*  w w w  . j  av  a2  s .  com*/
    if (department != null && !"".equals(department))
        wfMatrixCriteria.add(Restrictions.eq(DEPARTMENT, department));
    else
        wfMatrixCriteria.add(Restrictions.eq(DEPARTMENT, ANY));

    // Added restriction for amount rule
    if (amountRule != null && BigDecimal.ZERO.compareTo(amountRule) != 0) {
        Criterion amount1st = Restrictions.conjunction().add(Restrictions.le(FROM_QTY, amountRule))
                .add(Restrictions.ge(TO_QTY, amountRule));
        Criterion amount2nd = Restrictions.conjunction().add(Restrictions.le(FROM_QTY, amountRule))
                .add(Restrictions.isNull(TO_QTY));
        wfMatrixCriteria.add(Restrictions.disjunction().add(amount1st).add(amount2nd));

    }

    List<WorkFlowMatrix> workflowMatrix = wfMatrixCriteria.list();

    return workflowMatrix.isEmpty() ? null : workflowMatrix.get(0);

}

From source file:org.egov.pgr.service.ComplaintEscalationService.java

License:Open Source License

public List<Complaint> getComplaintsEligibleForEscalation() {
    Criteria criteria = entityManager.unwrap(Session.class).createCriteria(Complaint.class, "complaint")
            .createAlias("complaint.status", "complaintStatus");

    criteria.add(Restrictions.disjunction().add(Restrictions.eq(COMPLAINT_STATUS_NAME, REOPENED.name()))
            .add(Restrictions.eq(COMPLAINT_STATUS_NAME, FORWARDED.name()))
            .add(Restrictions.eq(COMPLAINT_STATUS_NAME, PROCESSING.name()))
            .add(Restrictions.eq(COMPLAINT_STATUS_NAME, REGISTERED.name())))
            .add(Restrictions.lt("complaint.escalationDate", new Date()))
            .setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);

    return criteria.list();
}

From source file:org.emonocot.persistence.dao.hibernate.ResourceDaoImpl.java

License:Open Source License

@Override
public List<Resource> listResourcesToHarvest(Integer limit, DateTime now, String fetch) {
    Criteria criteria = getSession().createCriteria(type);
    criteria.add(Restrictions.isNotNull("resourceType"));
    criteria.add(Restrictions.in("status", Arrays.asList(new BatchStatus[] { BatchStatus.COMPLETED,
            BatchStatus.FAILED, BatchStatus.ABANDONED, BatchStatus.STOPPED })));
    criteria.add(Restrictions.eq("scheduled", Boolean.TRUE));
    criteria.add(Restrictions.disjunction().add(Restrictions.lt("nextAvailableDate", now))
            .add(Restrictions.isNull("nextAvailableDate")));

    if (limit != null) {
        criteria.setMaxResults(limit);/*from w w  w.  j  a  va  2s .  c o  m*/
    }
    enableProfilePreQuery(criteria, fetch);
    criteria.addOrder(Property.forName("nextAvailableDate").asc());
    List<Resource> result = (List<Resource>) criteria.list();
    for (Resource t : result) {
        enableProfilePostQuery(t, fetch);
    }
    return result;
}

From source file:org.eurocarbdb.action.hplc.digestAssign.java

License:Open Source License

public String execute() throws Exception {

    refineDigestId = digest_id;/*from  ww w.j  a  va  2 s.  c om*/

    if (classA1 == 0) {
        classA1 = replaceSearch;
    }

    if (classA2 == 0) {
        classA2 = replaceSearch;
    }

    if (classA3 == 0) {
        classA3 = replaceSearch;
    }

    if (classA4 == 0) {
        classA4 = replaceSearch;
    }

    if (refineAssignment != null) {
        SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
        Session session = sessionFactory.openSession();
        logger.info("user whats a refinement displayed");
        logger.info("confirm digest id for criteria" + refineDigestId);

        Criteria criteria = session.createCriteria(HplcPeaksAnnotated.class);
        Disjunction disjunction = Restrictions.disjunction();
        ProjectionList proList = Projections.projectionList();
        criteria.add(Expression.eq("profileId", profile_id));
        criteria.add(Expression.eq("digestId", refineDigestId));
        criteria.createAlias("glycan", "G");
        proList.add(Projections.property("nameAbbreviation"));
        proList.add(Projections.property("gu"));
        proList.add(Projections.property("dbGu"));
        proList.add(Projections.property("peakArea"));
        proList.add(Projections.property("G.ogbitranslation"));
        proList.add(Projections.property("hplcPeaksAnnotatedId"));

        criteria.setProjection(proList);

        if (assignA3S == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a3", classA3), Expression.eq("G.s", assignA3S)));
        }
        if (assignA3F == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a3", classA3), Expression.eq("G.f6", assignA3F)));
            logger.info("assigned a3 f");
        }

        if (assignA3FOUTERARM == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a3", classA3),
                    Expression.eq("G.fouterarm", assignA3FOUTERARM)));
        }

        if (assignA3B == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a3", classA3), Expression.eq("G.b", assignA3B)));
            logger.info("assigned a3 b");
        }

        if (assignA3BGAL == 1) {
            disjunction.add(
                    Restrictions.and(Expression.eq("G.a3", classA3), Expression.eq("G.bgal", assignA3BGAL)));
        }

        if (assignA3AGAL == 1) {
            disjunction.add(
                    Restrictions.and(Expression.eq("G.a3", classA3), Expression.eq("G.agal", assignA3AGAL)));
        }
        if (assignA3GALNAC == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a3", classA3),
                    Expression.eq("G.galnac", assignA3GALNAC)));
        }

        if (assignA3POLYLAC == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a3", classA3),
                    Expression.eq("G.polylac", assignA3POLYLAC)));
        }
        if (assignA3HYBRID == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a3", classA3),
                    Expression.eq("G.hybrid", assignA3HYBRID)));
        }
        if (assignA3MANNOSE == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a3", classA3),
                    Expression.eq("G.mannose", assignA3MANNOSE)));
        }
        if (assignA2S == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a2", classA2), Expression.eq("G.s", assignA2S)));
        }
        if (assignA2F == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a2", classA2), Expression.eq("G.f6", assignA2F)));
        }
        if (assignA2FOUTERARM == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a2", classA2),
                    Expression.eq("G.fouterarm", assignA2FOUTERARM)));
        }
        if (assignA2B == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a2", classA2), Expression.eq("G.b", assignA2B)));
        }
        if (assignA2BGAL == 1) {
            disjunction.add(
                    Restrictions.and(Expression.eq("G.a2", classA2), Expression.eq("G.bgal", assignA2BGAL)));
        }
        if (assignA2AGAL == 1) {
            disjunction.add(
                    Restrictions.and(Expression.eq("G.a2", classA2), Expression.eq("G.agal", assignA2AGAL)));
        }
        if (assignA2GALNAC == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a2", classA2),
                    Expression.eq("G.galnac", assignA2GALNAC)));
        }
        if (assignA2POLYLAC == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a2", classA2),
                    Expression.eq("G.polylac", assignA2POLYLAC)));
        }
        if (assignA2HYBRID == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a2", classA2),
                    Expression.eq("G.hybrid", assignA2HYBRID)));
        }
        if (assignA2MANNOSE == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a2", classA2),
                    Expression.eq("G.mannose", assignA2MANNOSE)));
        }

        if (assignA1S == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a1", classA1), Expression.eq("G.s", assignA1S)));
        }
        if (assignA1F == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a1", classA1), Expression.eq("G.f6", assignA1F)));
        }
        if (assignA1FOUTERARM == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a1", classA1),
                    Expression.eq("G.fouterarm", assignA1FOUTERARM)));
        }
        if (assignA1B == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a1", classA1), Expression.eq("G.b", assignA1B)));
        }
        if (assignA1BGAL == 1) {
            disjunction.add(
                    Restrictions.and(Expression.eq("G.a1", classA1), Expression.eq("G.bgal", assignA1BGAL)));
        }
        if (assignA1AGAL == 1) {
            disjunction.add(
                    Restrictions.and(Expression.eq("G.a1", classA1), Expression.eq("G.agal", assignA1AGAL)));
        }
        if (assignA1GALNAC == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a1", classA1),
                    Expression.eq("G.galnac", assignA1GALNAC)));
        }
        if (assignA1POLYLAC == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a1", classA1),
                    Expression.eq("G.polylac", assignA1POLYLAC)));
        }
        if (assignA1HYBRID == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a1", classA1),
                    Expression.eq("G.hybrid", assignA1HYBRID)));
        }
        if (assignA1MANNOSE == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a1", classA1),
                    Expression.eq("G.mannose", assignA1MANNOSE)));
        }
        if (assignA4S == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a4", classA4), Expression.eq("G.s", assignA4S)));
        }
        if (assignA4F == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a4", classA4), Expression.eq("G.f6", assignA4F)));
        }
        if (assignA4FOUTERARM == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a4", classA4),
                    Expression.eq("G.fouterarm", assignA4FOUTERARM)));
        }
        if (assignA4B == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a4", classA4), Expression.eq("G.b", assignA4B)));
        }
        if (assignA4BGAL == 1) {
            disjunction.add(
                    Restrictions.and(Expression.eq("G.a4", classA4), Expression.eq("G.bgal", assignA4BGAL)));
        }
        if (assignA4AGAL == 1) {
            disjunction.add(
                    Restrictions.and(Expression.eq("G.a4", classA4), Expression.eq("G.agal", assignA4AGAL)));
        }
        if (assignA4GALNAC == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a4", classA4),
                    Expression.eq("G.galnac", assignA4GALNAC)));
        }
        if (assignA4POLYLAC == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a4", classA4),
                    Expression.eq("G.polylac", assignA4POLYLAC)));
        }
        if (assignA4HYBRID == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a4", classA4),
                    Expression.eq("G.hybrid", assignA4HYBRID)));
        }
        if (assignA4MANNOSE == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a4", classA4),
                    Expression.eq("G.mannose", assignA4MANNOSE)));
        }

        criteria.add(disjunction);

        List displayCriteria = criteria.list();

        showCriteria = displayCriteria;

        int criteriaSelection = showCriteria.size();
        logger.info("lets lookup at refinement" + criteriaSelection);

        //What if the refinement lists nothing
        if (criteriaSelection <= 0) {
            logger.info("selection criteria generated no results");
            criteriaResults = 0;
            List display = getEntityManager()
                    .getQuery("org.eurocarbdb.dataaccess.hplc.HplcPeaksAnnotated.DIGEST_DISPLAY")
                    .setParameter("parent", profile_id).setParameter("digest", digest_id).list();

            displayDigest = display;
        }

        Iterator iterCrit = showCriteria.iterator();
        while (iterCrit.hasNext()) {
            Object[] tempcrit = (Object[]) iterCrit.next();
            String namecrit = (String) tempcrit[0];

        }

    }

    if (refineAssignment == null && delete_entry > 0) {
        logger.info("record for deleting" + delete_entry);
        HplcPeaksAnnotated deletedRecord = HplcPeaksAnnotated.deleteById(delete_entry);
        List afterDelete = getEntityManager()
                .getQuery("org.eurocarbdb.dataaccess.hplc.HplcPeaksAnnotated.DIGEST_ASSIGN_DISPLAY")
                .setParameter("parent", profile_id).setParameter("digest", refineDigestId).list();
        displayDigest = afterDelete;
    }

    if (refineAssignment == null && delete_entry == 0) {

        File file = new File("/tmp/digest" + profile_id + digest_id + ".txt");
        //Session s = HibernateUtil.getSession();
        //Transaction tx = s.beginTransaction();

        EntityManager em = getEntityManager();
        ArrayList<Double> arrayGu = new ArrayList<Double>();

        FileReader input = new FileReader(file);

        BufferedReader bufRead = new BufferedReader(input);

        String line; // String that holds current file line
        int count = 0; // Line number of count 

        // Read first line
        line = bufRead.readLine();

        while (line != null) {

            String rec = line;
            String[] gu = rec.split("\t");
            double gu_c = Double.parseDouble(gu[1]);
            arrayGu.add(gu_c);
            double area = Double.parseDouble(gu[0]);
            line = bufRead.readLine();

            // for (Double gu_value : arrayGu) {

            // logger.info("print gu value" + gu_c);
            List list = getEntityManager().getQuery("org.eurocarbdb.dataaccess.hplc.Glycan.PRELIM_ASSIGN")
                    .setParameter("gu_value", gu_c).list();

            preliminary = list;
            logger.info("sizeofprel" + preliminary.size());

            Iterator iter = preliminary.iterator();
            while (iter.hasNext()) {

                Glycan temp = (Glycan) iter.next();
                //logger.info("print contents" + temp);
                peaksannotated = new HplcPeaksAnnotated();
                //peaksannotated.setGlycan(temp);
                peaksannotated.setPeakArea(area);
                peaksannotated.setGu(gu_c);
                peaksannotated.setDbGu(temp.getGu());
                peaksannotated.setProfileId(profile_id);
                peaksannotated.setDigestId(digest_id);
                //peaksannotated.setGlycanId(temp.getGlycanId());
                //modification to support relationship change
                peaksannotated.setGlycan(temp);
                peaksannotated.setNameAbbreviation(temp.getName());
                //getEntityManager().store(peaksannotated);
                //peaksannotated.setContributor(Contributor.getCurrentContributor());
                //peaksannotated.setTechnique(Technique.lookupAbbrev("hplc"));
                getEntityManager().store(peaksannotated);
                logger.info("check storage process");
            } //close the iteration over the query result 

        } // end gu value loop

        bufRead.close(); //close the gu file

        Profile p = Profile.lookupById(profile_id);
        logger.info("themagic is" + p);
        DigestProfile dp = new DigestProfile();
        dp.setDigestId(digest_id);
        dp.setSequentialDigest(enzyme);
        dp.setProfile(p);
        getEntityManager().store(dp);

        int idTest = p.getProfileId();
        logger.info("the value of idTest:" + idTest);
        //note: due to use of evidenceId relationships the profileId in DIgestProfile is the evidenceId
        //to get the corresponfing profileId from  Profile use the getProfileId()

        //get the enzymes used
        logger.info("check profile id" + profile_id);
        logger.info("check digest id" + digest_id);

        List enzymelist = getEntityManager()
                .getQuery("org.eurocarbdb.dataaccess.hplc.DigestProfile.GET_ENZYMES") //.setParameter("parent", parent) .list(); // .setParameter("digest_id", digest_id) .list();
                //recurring problem with the use of evidence id
                //if use evidence id instead of profile id for HplcPeaks... will cause core probs
                .setParameter("parent", p).list();
        logger.info("enzymelist" + enzymelist);

        //loop over the enzymes

        preliminaryenz = enzymelist;
        logger.info("size report" + preliminaryenz.size());

        //delete records which have a digest product for that given enzyme

        for (Object enzymeused : enzymelist) {
            logger.info("loopstufftoheckenz" + enzymeused);
            List annolist = getEntityManager()
                    .getQuery("org.eurocarbdb.dataaccess.hplc.HplcPeaksAnnotated.ATTEMPT")
                    .setParameter("parent", profile_id).setParameter("digest", digest_id)
                    .setParameter("enzymeused", enzymeused).list();

            logger.info("what now");

            Iterator iteraa = annolist.iterator();
            while (iteraa.hasNext()) {
                HplcPeaksAnnotated tempanno = (HplcPeaksAnnotated) iteraa.next();
                logger.info("whatshouldberemoved" + tempanno);
                //tx.begin();
                //s.delete( tempanno );
                Eurocarb.getEntityManager().remove(tempanno);
                //tx.commit();
            }

        }

        //preview the results
        List display = getEntityManager()
                .getQuery("org.eurocarbdb.dataaccess.hplc.HplcPeaksAnnotated.DIGEST_DISPLAY")
                .setParameter("parent", profile_id).setParameter("digest", digest_id).list();

        displayDigest = display;
        logger.info(displayDigest.size());

        digest_id++;

    }
    return SUCCESS;
}

From source file:org.eurocarbdb.action.hplc.preAssign.java

License:Open Source License

public String execute() throws Exception {

    logger.info("before zeros" + classA3);

    if (classA1 == 0) {
        classA1 = replaceSearch;//from  w  w w . ja v  a  2s . com
    }

    if (classA2 == 0) {
        classA2 = replaceSearch;
    }

    if (classA3 == 0) {
        classA3 = replaceSearch;
    }

    if (classA4 == 0) {
        classA4 = replaceSearch;
    }

    logger.info("some zeros" + classA1 + classA2 + classA3 + classA4);

    if (refineAssignment != null) {
        logger.info("user whats a refinement displayed");
        logger.info("was a2f assigned = " + assignA2F + "ws a2 class done" + classA2 + "just to insure"
                + assignA4F);
        String queryRefine = A2S + A2F + A2B + A2BGAL + A2AGAL + A2GALNAC + A2POLYLAC + A2FOUTERARM + A2HYBRID
                + A2MANNOSE + A1B + A1BGAL + A1AGAL + A1GALNAC + A1POLYLAC + A1FOUTERARM + A1HYBRID + A1MANNOSE
                + A1S + A1F + A3S + A3F + A3B + A3BGAL + A3AGAL + A3GALNAC + A3POLYLAC + A3FOUTERARM + A3HYBRID
                + A3MANNOSE + A4S + A4F + A4B + A4BGAL + A4AGAL + A4GALNAC + A4POLYLAC + A4FOUTERARM + A4HYBRID
                + A4MANNOSE;

        String queryReplace = queryRefine.replaceAll("null", "");
        String queryAnd = queryReplace.replaceAll("\\)\\(", ") OR (");
        logger.info("query string again:" + queryAnd);
        int len = queryAnd.length();

        //String queryRefineComplete = "SELECT HP.glycan, HP.peakArea, HP.gu, HP.dbGu, HP.nameAbbreviation, (select g.ogbitranslation from Glycan g where g.glycanId = HP.glycan) as ogbitranslation from HplcPeaksAnnotated HP where HP.profileId = " + profile_id + " and HP.digestId = 0 and HP.glycan IN (SELECT G.glycanId from Glycan G WHERE " + queryAnd + " and G.glycanId = HP.glycan) ORDER BY HP.gu";

        String queryRefineComplete = "from HplcPeaksAnnotated HP join HP.glycan G where HP.profileId = 46 and "
                + queryAnd + " order by HP.gu";

        logger.info("check new query" + queryRefineComplete);

        SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
        Session session = sessionFactory.openSession();

        Query query = session.createQuery(queryRefineComplete);

        List<HplcPeaksAnnotated> display = query.list();
        //display = query.list();
        //prelimarytwo = display;

        int tempint = 1140;
        int tempprofile = 48;
        short tempintr = 1;

        /*Disjunction disc = Expression.disjunction();    */
        /*List displaytest = session.createCriteria(HplcPeaksAnnotated.class)
                
                   .createAlias("glycan", "G")
                   .add( Expression.eq("profileId", tempprofile))
                   .add(Restrictions.and(
        Expression.eq("G.a3", classA3),
         Expression.eq("G.s", assignA3S)
        ))
                .add(Restrictions.and(
         Expression.eq("G.a3", classA3),
         Expression.eq("G.f6", assignA3F)
         ))//.add ( Expression.eq("G.glycanId", tempint))
                           
        .add(Expression.or(
        Expression.eq("G.a1", classA1),
         Expression.eq("G.s", assignA1S)
        ))
        .add(Expression.or(
         Expression.eq("G.a2", classA2),
         Expression.eq("G.s", assignA2S)
         ))
                
        .add(Expression.or(
        Expression.and(
         Expression.eq("G.a3", classA3),
         Expression.eq("G.s", assignA3S)
         )
        .add(Expression.and(
         Expression.eq("G.a3", classA3),
         Expression.eq("G.f6", assignA3F)
         ))
        ))
        .add(Expression.or(
         Expression.eq("G.a4", classA4),
         Expression.eq("G.s", assignA4S)
         ))
        //.AddOrder( Order.Asc("gu") )
            //       .list();
        */

        logger.info("variables check" + classA3 + "core f" + assignA3F + "s" + assignA3S);

        Criteria criteria = session.createCriteria(HplcPeaksAnnotated.class);
        Disjunction disjunction = Restrictions.disjunction();
        ProjectionList proList = Projections.projectionList();
        criteria.add(Expression.eq("profileId", profile_id));
        criteria.createAlias("glycan", "G");
        proList.add(Projections.property("nameAbbreviation"));
        proList.add(Projections.property("gu"));
        proList.add(Projections.property("dbGu"));
        proList.add(Projections.property("peakArea"));
        proList.add(Projections.property("G.ogbitranslation"));
        proList.add(Projections.property("hplcPeaksAnnotatedId"));

        criteria.setProjection(proList);

        if (assignA3S == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a3", classA3), Expression.eq("G.s", assignA3S)));
        }
        if (assignA3F == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a3", classA3), Expression.eq("G.f6", assignA3F)));
            logger.info("assigned a3 f");
        }

        if (assignA3FOUTERARM == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a3", classA3),
                    Expression.eq("G.fouterarm", assignA3FOUTERARM)));
        }

        if (assignA3B == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a3", classA3), Expression.eq("G.b", assignA3B)));
            logger.info("assigned a3 b");
        }

        if (assignA3BGAL == 1) {
            disjunction.add(
                    Restrictions.and(Expression.eq("G.a3", classA3), Expression.eq("G.bgal", assignA3BGAL)));
        }

        if (assignA3AGAL == 1) {
            disjunction.add(
                    Restrictions.and(Expression.eq("G.a3", classA3), Expression.eq("G.agal", assignA3AGAL)));
        }
        if (assignA3GALNAC == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a3", classA3),
                    Expression.eq("G.galnac", assignA3GALNAC)));
        }

        if (assignA3POLYLAC == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a3", classA3),
                    Expression.eq("G.polylac", assignA3POLYLAC)));
        }
        if (assignA3HYBRID == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a3", classA3),
                    Expression.eq("G.hybrid", assignA3HYBRID)));
        }
        if (assignA3MANNOSE == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a3", classA3),
                    Expression.eq("G.mannose", assignA3MANNOSE)));
        }
        if (assignA2S == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a2", classA2), Expression.eq("G.s", assignA2S)));
        }
        if (assignA2F == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a2", classA2), Expression.eq("G.f6", assignA2F)));
        }
        if (assignA2FOUTERARM == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a2", classA2),
                    Expression.eq("G.fouterarm", assignA2FOUTERARM)));
        }
        if (assignA2B == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a2", classA2), Expression.eq("G.b", assignA2B)));
        }
        if (assignA2BGAL == 1) {
            disjunction.add(
                    Restrictions.and(Expression.eq("G.a2", classA2), Expression.eq("G.bgal", assignA2BGAL)));
        }
        if (assignA2AGAL == 1) {
            disjunction.add(
                    Restrictions.and(Expression.eq("G.a2", classA2), Expression.eq("G.agal", assignA2AGAL)));
        }
        if (assignA2GALNAC == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a2", classA2),
                    Expression.eq("G.galnac", assignA2GALNAC)));
        }
        if (assignA2POLYLAC == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a2", classA2),
                    Expression.eq("G.polylac", assignA2POLYLAC)));
        }
        if (assignA2HYBRID == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a2", classA2),
                    Expression.eq("G.hybrid", assignA2HYBRID)));
        }
        if (assignA2MANNOSE == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a2", classA2),
                    Expression.eq("G.mannose", assignA2MANNOSE)));
        }

        if (assignA1S == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a1", classA1), Expression.eq("G.s", assignA1S)));
        }
        if (assignA1F == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a1", classA1), Expression.eq("G.f6", assignA1F)));
        }
        if (assignA1FOUTERARM == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a1", classA1),
                    Expression.eq("G.fouterarm", assignA1FOUTERARM)));
        }
        if (assignA1B == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a1", classA1), Expression.eq("G.b", assignA1B)));
        }
        if (assignA1BGAL == 1) {
            disjunction.add(
                    Restrictions.and(Expression.eq("G.a1", classA1), Expression.eq("G.bgal", assignA1BGAL)));
        }
        if (assignA1AGAL == 1) {
            disjunction.add(
                    Restrictions.and(Expression.eq("G.a1", classA1), Expression.eq("G.agal", assignA1AGAL)));
        }
        if (assignA1GALNAC == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a1", classA1),
                    Expression.eq("G.galnac", assignA1GALNAC)));
        }
        if (assignA1POLYLAC == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a1", classA1),
                    Expression.eq("G.polylac", assignA1POLYLAC)));
        }
        if (assignA1HYBRID == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a1", classA1),
                    Expression.eq("G.hybrid", assignA1HYBRID)));
        }
        if (assignA1MANNOSE == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a1", classA1),
                    Expression.eq("G.mannose", assignA1MANNOSE)));
        }
        if (assignA4S == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a4", classA4), Expression.eq("G.s", assignA4S)));
        }
        if (assignA4F == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a4", classA4), Expression.eq("G.f6", assignA4F)));
        }
        if (assignA4FOUTERARM == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a4", classA4),
                    Expression.eq("G.fouterarm", assignA4FOUTERARM)));
        }
        if (assignA4B == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a4", classA4), Expression.eq("G.b", assignA4B)));
        }
        if (assignA4BGAL == 1) {
            disjunction.add(
                    Restrictions.and(Expression.eq("G.a4", classA4), Expression.eq("G.bgal", assignA4BGAL)));
        }
        if (assignA4AGAL == 1) {
            disjunction.add(
                    Restrictions.and(Expression.eq("G.a4", classA4), Expression.eq("G.agal", assignA4AGAL)));
        }
        if (assignA4GALNAC == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a4", classA4),
                    Expression.eq("G.galnac", assignA4GALNAC)));
        }
        if (assignA4POLYLAC == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a4", classA4),
                    Expression.eq("G.polylac", assignA4POLYLAC)));
        }
        if (assignA4HYBRID == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a4", classA4),
                    Expression.eq("G.hybrid", assignA4HYBRID)));
        }
        if (assignA4MANNOSE == 1) {
            disjunction.add(Restrictions.and(Expression.eq("G.a4", classA4),
                    Expression.eq("G.mannose", assignA4MANNOSE)));
        }
        criteria.add(disjunction);

        List displayCriteria = criteria.list();

        showCriteria = displayCriteria;

        int criteriaSelection = showCriteria.size();
        logger.info("lets lookup at refinement" + criteriaSelection);

        //What if the refinement lists nothing
        if (criteriaSelection <= 0) {
            logger.info("selection criteria generated no results");
            display = getEntityManager()
                    .getQuery("org.eurocarbdb.dataaccess.hplc.HplcPeaksAnnotated.PRE_ASSIGN_DISPLAY")
                    .setParameter("parent", profile_id).list();
            prelimarytwo = display;
        }

        Iterator iterCrit = showCriteria.iterator();
        while (iterCrit.hasNext()) {
            Object[] tempcrit = (Object[]) iterCrit.next();
            String namecrit = (String) tempcrit[0];
            logger.info("here" + namecrit);
        }

    }

    //test deleting records

    if (refineAssignment == null && delete_entry > 0) {
        logger.info("record for deleting" + delete_entry);
        HplcPeaksAnnotated deletedRecord = HplcPeaksAnnotated.deleteById(delete_entry);
        List afterDelete = getEntityManager()
                .getQuery("org.eurocarbdb.dataaccess.hplc.HplcPeaksAnnotated.PRE_ASSIGN_DISPLAY")
                .setParameter("parent", profile_id).list();
        prelimarytwo = afterDelete;
    }

    if (refineAssignment == null && delete_entry == 0) {
        logger.info("i shouldnt be seeing this message");
        File file = new File("/tmp/undigested" + profile_id + ".txt");
        EntityManager em = getEntityManager();
        ArrayList<Double> arrayGu = new ArrayList<Double>();

        FileReader input = new FileReader(file);

        BufferedReader bufRead = new BufferedReader(input);

        String line; // String that holds current file line
        int count = 0; // Line number of count 

        // Read first line
        line = bufRead.readLine();

        while (line != null) {

            String rec = line;
            String[] gu = rec.split("\t");
            double gu_c = Double.parseDouble(gu[1]);
            double area = Double.parseDouble(gu[0]);
            arrayGu.add(gu_c);
            line = bufRead.readLine();
            // }

            // for (Double gu_value : arrayGu) {
            //       logger.info("the value is" + gu_value);
            List list = getEntityManager().getQuery("org.eurocarbdb.dataaccess.hplc.Glycan.PRELIM_ASSIGN")
                    .setParameter("gu_value", gu_c).list();
            preliminary = list;
            //  logger.info("gu value print" + gu_value);
            logger.info(preliminary.size());

            Iterator iter = preliminary.iterator();
            while (iter.hasNext()) {
                Glycan temp = (Glycan) iter.next();
                peaksannotated = new HplcPeaksAnnotated();
                //peaksannotated.setGlycan(temp);
                // peaksannotated.setGu(gu_value);
                peaksannotated.setPeakArea(area);
                peaksannotated.setGu(gu_c);
                peaksannotated.setDbGu(temp.getGu());
                peaksannotated.setProfileId(profile_id);
                peaksannotated.setGlycan(temp);
                peaksannotated.setNameAbbreviation(temp.getName());
                peaksannotated.setDigestId(digest_id);
                //peaksannotated.setContributor(Contributor.getCurrentContributor());
                //peaksannotated.setTechnique(Technique.lookupAbbrev("hplc"));
                getEntityManager().store(peaksannotated);
            }

        }

        bufRead.close();

        /* test
        ArrayList <Double> test = new ArrayList();
        test.addAll(arrayGu);
        for (Double testing : test) {}
        */

        //need to do a query to grap inserted data above for displaying to user
        //logger.info("check the profile id number here:" + profile_id);

        display = getEntityManager()
                .getQuery("org.eurocarbdb.dataaccess.hplc.HplcPeaksAnnotated.PRE_ASSIGN_DISPLAY")
                .setParameter("parent", profile_id).list();

        prelimarytwo = display;
        logger.info(prelimarytwo.size());

    }
    return SUCCESS;

}

From source file:org.eurocarbdb.action.hplc.showGlycobaseRefine.java

License:Open Source License

public String execute() throws Exception {

    if (classA1 == 0) {
        classA1 = replaceSearch;//from w ww  .  j  av  a 2 s  . c o m
    }

    if (classA2 == 0) {
        classA2 = replaceSearch;
    }

    if (classA3 == 0) {
        classA3 = replaceSearch;
    }

    if (classA4 == 0) {
        classA4 = replaceSearch;
    }

    EntityManager em = getEntityManager();
    HibernateEntityManager hem = (HibernateEntityManager) getEntityManager();
    Session session = hem.getHibernateSession();

    Criteria criteria = session.createCriteria(Glycan.class);
    Disjunction disjunction = Restrictions.disjunction();
    ProjectionList proList = Projections.projectionList();
    proList.add(Projections.property("name"));
    proList.add(Projections.property("ogbitranslation"));
    proList.add(Projections.property("gu"));
    proList.add(Projections.property("glycanId"));

    criteria.setProjection(proList);
    criteria.addOrder(Order.asc("gu"));

    if (assignA3S == 1) {
        disjunction.add(Restrictions.and(Expression.eq("a3", classA3), Expression.eq("s", assignA3S)));
    }
    if (assignA3F == 1) {
        disjunction.add(Restrictions.and(Expression.eq("a3", classA3), Expression.eq("f6", assignA3F)));

    }

    if (assignA3FOUTERARM == 1) {
        disjunction.add(
                Restrictions.and(Expression.eq("a3", classA3), Expression.eq("fouterarm", assignA3FOUTERARM)));
    }

    if (assignA3B == 1) {
        disjunction.add(Restrictions.and(Expression.eq("a3", classA3), Expression.eq("b", assignA3B)));

    }

    if (assignA3BGAL == 1) {
        disjunction.add(Restrictions.and(Expression.eq("a3", classA3), Expression.eq("bgal", assignA3BGAL)));
    }

    if (assignA3AGAL == 1) {
        disjunction.add(Restrictions.and(Expression.eq("a3", classA3), Expression.eq("agal", assignA3AGAL)));
    }
    if (assignA3GALNAC == 1) {
        disjunction
                .add(Restrictions.and(Expression.eq("a3", classA3), Expression.eq("galnac", assignA3GALNAC)));
    }

    if (assignA3POLYLAC == 1) {
        disjunction
                .add(Restrictions.and(Expression.eq("a3", classA3), Expression.eq("polylac", assignA3POLYLAC)));
    }
    if (assignA3HYBRID == 1) {
        disjunction
                .add(Restrictions.and(Expression.eq("a3", classA3), Expression.eq("hybrid", assignA3HYBRID)));
    }
    if (assignA3MANNOSE == 1) {
        disjunction
                .add(Restrictions.and(Expression.eq("a3", classA3), Expression.eq("mannose", assignA3MANNOSE)));
    }
    if (assignA2S == 1) {
        disjunction.add(Restrictions.and(Expression.eq("a2", classA2), Expression.eq("s", assignA2S)));
    }
    if (assignA2F == 1) {
        disjunction.add(Restrictions.and(Expression.eq("a2", classA2), Expression.eq("f6", assignA2F)));
    }
    if (assignA2FOUTERARM == 1) {
        disjunction.add(
                Restrictions.and(Expression.eq("a2", classA2), Expression.eq("fouterarm", assignA2FOUTERARM)));
    }
    if (assignA2B == 1) {
        disjunction.add(Restrictions.and(Expression.eq("a2", classA2), Expression.eq("b", assignA2B)));
    }
    if (assignA2BGAL == 1) {
        disjunction.add(Restrictions.and(Expression.eq("a2", classA2), Expression.eq("bgal", assignA2BGAL)));
    }
    if (assignA2AGAL == 1) {
        disjunction.add(Restrictions.and(Expression.eq("a2", classA2), Expression.eq("agal", assignA2AGAL)));
    }
    if (assignA2GALNAC == 1) {
        disjunction
                .add(Restrictions.and(Expression.eq("a2", classA2), Expression.eq("galnac", assignA2GALNAC)));
    }
    if (assignA2POLYLAC == 1) {
        disjunction
                .add(Restrictions.and(Expression.eq("a2", classA2), Expression.eq("polylac", assignA2POLYLAC)));
    }
    if (assignA2HYBRID == 1) {
        disjunction
                .add(Restrictions.and(Expression.eq("a2", classA2), Expression.eq("hybrid", assignA2HYBRID)));
    }
    if (assignA2MANNOSE == 1) {
        disjunction
                .add(Restrictions.and(Expression.eq("a2", classA2), Expression.eq("mannose", assignA2MANNOSE)));
    }

    if (assignA1S == 1) {
        disjunction.add(Restrictions.and(Expression.eq("a1", classA1), Expression.eq("s", assignA1S)));
    }
    if (assignA1F == 1) {
        disjunction.add(Restrictions.and(Expression.eq("a1", classA1), Expression.eq("f6", assignA1F)));
    }
    if (assignA1FOUTERARM == 1) {
        disjunction.add(
                Restrictions.and(Expression.eq("a1", classA1), Expression.eq("fouterarm", assignA1FOUTERARM)));
    }
    if (assignA1B == 1) {
        disjunction.add(Restrictions.and(Expression.eq("a1", classA1), Expression.eq("b", assignA1B)));
    }
    if (assignA1BGAL == 1) {
        disjunction.add(Restrictions.and(Expression.eq("a1", classA1), Expression.eq("bgal", assignA1BGAL)));
    }
    if (assignA1AGAL == 1) {
        disjunction.add(Restrictions.and(Expression.eq("a1", classA1), Expression.eq("agal", assignA1AGAL)));
    }
    if (assignA1GALNAC == 1) {
        disjunction
                .add(Restrictions.and(Expression.eq("a1", classA1), Expression.eq("galnac", assignA1GALNAC)));
    }
    if (assignA1POLYLAC == 1) {
        disjunction
                .add(Restrictions.and(Expression.eq("a1", classA1), Expression.eq("polylac", assignA1POLYLAC)));
    }
    if (assignA1HYBRID == 1) {
        disjunction
                .add(Restrictions.and(Expression.eq("a1", classA1), Expression.eq("hybrid", assignA1HYBRID)));
    }
    if (assignA1MANNOSE == 1) {
        disjunction
                .add(Restrictions.and(Expression.eq("a1", classA1), Expression.eq("mannose", assignA1MANNOSE)));
    }
    if (assignA4S == 1) {
        disjunction.add(Restrictions.and(Expression.eq("a4", classA4), Expression.eq("s", assignA4S)));
    }
    if (assignA4F == 1) {
        disjunction.add(Restrictions.and(Expression.eq("a4", classA4), Expression.eq("f6", assignA4F)));
    }
    if (assignA4FOUTERARM == 1) {
        disjunction.add(
                Restrictions.and(Expression.eq("a4", classA4), Expression.eq("fouterarm", assignA4FOUTERARM)));
    }
    if (assignA4B == 1) {
        disjunction.add(Restrictions.and(Expression.eq("a4", classA4), Expression.eq("b", assignA4B)));
    }
    if (assignA4BGAL == 1) {
        disjunction.add(Restrictions.and(Expression.eq("a4", classA4), Expression.eq("bgal", assignA4BGAL)));
    }
    if (assignA4AGAL == 1) {
        disjunction.add(Restrictions.and(Expression.eq("a4", classA4), Expression.eq("agal", assignA4AGAL)));
    }
    if (assignA4GALNAC == 1) {
        disjunction
                .add(Restrictions.and(Expression.eq("a4", classA4), Expression.eq("galnac", assignA4GALNAC)));
    }
    if (assignA4POLYLAC == 1) {
        disjunction
                .add(Restrictions.and(Expression.eq("a4", classA4), Expression.eq("polylac", assignA4POLYLAC)));
    }
    if (assignA4HYBRID == 1) {
        disjunction
                .add(Restrictions.and(Expression.eq("a4", classA4), Expression.eq("hybrid", assignA4HYBRID)));
    }
    if (assignA4MANNOSE == 1) {
        disjunction
                .add(Restrictions.and(Expression.eq("a4", classA4), Expression.eq("mannose", assignA4MANNOSE)));
    }

    if (serum == 1 && IgG == 1) {
        disjunction.add(Restrictions.and(Expression.eq("serum", serum), Expression.eq("normalIgG", IgG)));
    }

    if (serum == 1 && IgG == 0) {
        criteria.add(Expression.eq("serum", serum));
    }

    if (serum == 0 && IgG == 1) {
        criteria.add(Expression.eq("normalIgg", IgG));
    }

    criteria.add(disjunction);

    List displayCriteria = criteria.list();

    int listSize = displayCriteria.size();

    if (listSize > 0) {
        setAllResults(displayCriteria);

        return SUCCESS;
    } else {
        return ERROR;
    }

}