Examples with AnnotationCategory org.nextprot.api.commons.constants.AnnotationCategory used on opensource projects

Example 1 with AnnotationCategory

use of org.nextprot.api.commons.constants.AnnotationCategory in project nextprot-api by calipho-sib.

the class RawStatementDaoTest method findModificationEffectCategory.

@Test
public void findModificationEffectCategory() {
    AnnotationCategory category = AnnotationCategory.PHENOTYPIC_VARIATION;
    Annotation isoAnnotation = new Annotation();
    isoAnnotation.setAnnotationCategory(category);
    assertEquals(isoAnnotation.getCategory(), "phenotypic-variation");
}

Example 2 with AnnotationCategory

use of org.nextprot.api.commons.constants.AnnotationCategory in project nextprot-api by calipho-sib.

the class AnnotationServiceImpl method bioPhyChemPropsToAnnotationList.

private List<Annotation> bioPhyChemPropsToAnnotationList(String entryName, List<AnnotationProperty> props) {
    List<Annotation> annotations = new ArrayList<>(props.size());
    List<Isoform> isoforms = isoformService.findIsoformsByEntryName(entryName);
    for (AnnotationProperty property : props) {
        Annotation annotation = new Annotation();
        AnnotationCategory model = AnnotationCategory.getByDbAnnotationTypeName(property.getName());
        String description = property.getValue();
        annotation.setAnnotationId(property.getAnnotationId() + IdentifierOffset.BIOPHYSICOCHEMICAL_ANNOTATION_OFFSET);
        annotation.setCategory(model.getDbAnnotationTypeName());
        annotation.setDescription(description);
        annotation.setEvidences(new ArrayList<>());
        annotation.setQualityQualifier("GOLD");
        annotation.setUniqueName(entryName + "_" + model.getApiTypeName());
        annotation.addTargetingIsoforms(newAnnotationIsoformSpecificityList(annotation.getAnnotationId(), isoforms));
        annotations.add(annotation);
    }
    return annotations;
}

Example 3 with AnnotationCategory

use of org.nextprot.api.commons.constants.AnnotationCategory in project nextprot-api by calipho-sib.

the class AnnotationFieldBuilder method init.

@Override
protected void init(Entry entry) {
    // Function with canonical first
    List<String> function_canonical = EntryUtils.getFunctionInfoWithCanonicalFirst(entry);
    for (String finfo : function_canonical) {
        addField(Fields.FUNCTION_DESC, finfo);
        addField(Fields.ANNOTATIONS, finfo);
    }
    List<Annotation> annots = entry.getAnnotations();
    for (Annotation currannot : annots) {
        String category = currannot.getCategory();
        AnnotationCategory apiCategory = currannot.getAPICategory();
        String quality = currannot.getQualityQualifier();
        if (apiCategory.equals(AnnotationCategory.FUNCTION_INFO) || apiCategory.equals(AnnotationCategory.EXPRESSION_PROFILE))
            // and tissue specificity values are indexed under other fields
            continue;
        // We also should exclude uninformative category 'sequence conflict'
        // if(!category.equals("tissue specificity")) {//These values are
        // indexed under other fields
        // if(!apiCategory.equals(AnnotationCategory.) {//These values are
        // indexed under other fields
        String desc = currannot.getDescription();
        if (apiCategory.equals(AnnotationCategory.GLYCOSYLATION_SITE)) {
            String xref = currannot.getSynonym();
            if (xref != null)
                // It is actually not a synonym but the carbohydrate id from
                // glycosuitedb !
                addField(Fields.ANNOTATIONS, xref);
        } else if (apiCategory.equals(AnnotationCategory.DNA_BINDING_REGION))
            addField(Fields.ANNOTATIONS, category);
        else if (apiCategory.equals(AnnotationCategory.VARIANT))
            // We need to index them somehow for the GOLD/SILVER tests, or
            // do we ? in creates a lot of useless 'variant null' tokens
            desc = "Variant " + desc;
        if (desc != null) {
            // System.err.println(category + ": " + desc);
            if (apiCategory.equals(AnnotationCategory.SEQUENCE_CAUTION)) {
                int stringpos = 0;
                // The sequence
                desc = desc.split(":")[1].substring(1);
                // AAH70170 differs
                // from that shown.
                // Reason:
                // miscellaneous
                // discrepancy
                String[] desclevels = desc.split("\\.");
                String mainreason = desclevels[0];
                if ((stringpos = mainreason.indexOf(" at position")) != -1) {
                    // truncate the position
                    mainreason = mainreason.substring(0, stringpos);
                }
                addField(Fields.ANNOTATIONS, mainreason);
                if (desclevels.length > 1) {
                    if (// mainreason truncated
                    stringpos > 0)
                        desc = desc.substring(desc.indexOf(".") + 2);
                    else {
                        stringpos = desc.indexOf(mainreason) + mainreason.length();
                        desc = desc.substring(stringpos + 2);
                    }
                    addField(Fields.ANNOTATIONS, desc);
                }
            }
            if (!category.startsWith("go") && desc.length() > 1) {
                // description
                if (!this.isGold() || quality.equals("GOLD")) {
                    if (apiCategory.equals(AnnotationCategory.PHENOTYPIC_VARIATION)) {
                        // Get BED data (also get the notes ? )
                        Map<String, AnnotationIsoformSpecificity> annotSpecs = currannot.getTargetingIsoformsMap();
                        for (Map.Entry<String, AnnotationIsoformSpecificity> mapentry : annotSpecs.entrySet()) {
                            String subjectName = mapentry.getValue().getName();
                            // update description with the subject for each
                            // target isofotm
                            addField(Fields.ANNOTATIONS, subjectName + " " + desc);
                        // System.err.println("adding: " + subjectName +
                        // " " + desc);
                        }
                    } else
                        addField(Fields.ANNOTATIONS, desc);
                }
            }
        // in pathway and disease new annotations may appear due to
        // transformation of specific xrefs (orphanet...) into
        // annotations in the api
        }
        handleAnnotationTerm(currannot, entry);
        if (apiCategory.equals(AnnotationCategory.MATURE_PROTEIN) || apiCategory.equals(AnnotationCategory.MATURATION_PEPTIDE)) {
            String chainid = currannot.getSynonym();
            if (chainid != null) {
                // " synonyms: " + currannot.getAllSynonyms());
                if (chainid.contains("-"))
                    // Uniprot FT id,
                    addField(Fields.ANNOTATIONS, chainid);
                else // like
                // PRO_0000019235,
                // shouldn't be
                // called a
                // synonym
                {
                    List<String> chainsynonyms = currannot.getSynonyms();
                    if (chainsynonyms.size() == 1)
                        addField(Fields.ANNOTATIONS, StringUtils.getSortedValueFromPipeSeparatedField(desc + " | " + chainid));
                    else {
                        chainid = "";
                        for (String syno : chainsynonyms) {
                            chainid += syno + " | ";
                        }
                        addField(Fields.ANNOTATIONS, StringUtils.getSortedValueFromPipeSeparatedField(chainid));
                    }
                }
            }
        // else System.err.println("chainid null for: " + desc);
        // chainid 's null for the main chain, this is wrong
        }
        // variant xrefs and identifiers
        if (apiCategory.equals(AnnotationCategory.VARIANT)) {
            String evidxrefaccs = "";
            List<AnnotationEvidence> evidences = currannot.getEvidences();
            if (evidences != null)
                for (AnnotationEvidence ev : evidences) {
                    if (ev.isResourceAXref()) {
                        String db = ev.getResourceDb();
                        if (db == null)
                            System.err.println("db is null for evidence in variant annot: " + desc);
                        else {
                            if (!evidxrefaccs.isEmpty())
                                evidxrefaccs += " | ";
                            if (db.equals("Cosmic"))
                                evidxrefaccs += db.toLowerCase() + ":" + ev.getResourceAccession();
                            else if (// Just to allow
                            db.equals("dbSNP"))
                                // comparison with
                                // incoherent
                                // current solr
                                // implementation
                                evidxrefaccs += ev.getResourceAccession();
                            else
                                // Uniprot
                                evidxrefaccs += currannot.getSynonym();
                        // FT
                        // id,
                        // like
                        // VAR_056577
                        }
                    }
                }
            if (!this.isGold() || quality.equals("GOLD")) {
                if (!evidxrefaccs.isEmpty())
                    addField(Fields.ANNOTATIONS, StringUtils.getSortedValueFromPipeSeparatedField(evidxrefaccs));
                Collection<AnnotationProperty> props = currannot.getProperties();
                for (AnnotationProperty prop : props) if (prop.getName().equals("mutation AA"))
                    // eg: p.D1685E, it is unclear why this property
                    // exists only in cosmic variants
                    addField(Fields.ANNOTATIONS, prop.getValue());
            }
        }
    }
    // Families (why not part of Annotations ?), always GOLD
    for (Family family : entry.getOverview().getFamilies()) {
        String ac = family.getAccession();
        int stringpos = 0;
        addField(Fields.ANNOTATIONS, ac);
        String famdesc = family.getDescription();
        // There is no get_synonyms() method for families -> can't access
        // PERVR for FA-04785
        addField(Fields.ANNOTATIONS, famdesc);
        stringpos = famdesc.indexOf("elongs to ") + 14;
        // Skip the 'Belongs to' and
        famdesc = famdesc.substring(stringpos);
        // what may come before (eg:
        // NX_P19021)
        // remove
        famdesc = famdesc.substring(0, famdesc.length() - 1);
        // final dot
        addField(Fields.ANNOTATIONS, famdesc);
        // are there subfamilies
        String[] families = famdesc.split("\\. ");
        // ?
        if (families.length > 1) {
            // Always GOLD
            for (int i = 0; i < families.length; i++) {
                addField(Fields.ANNOTATIONS, families[i]);
                if (families[i].contains(") superfamily")) {
                    // index one
                    // more time
                    // without
                    // parenthesis
                    famdesc = families[i].substring(0, families[i].indexOf("(")) + "superfamily";
                    addField(Fields.ANNOTATIONS, famdesc);
                }
            }
        }
        // Sonetimes these synonymes are wrong eg: NX_Q6NUT3 -> Major
        // facilitator (TC 2.A.1) superfamily
        List<String> famsynonyms = this.terminologyservice.findCvTermByAccession(ac).getSynonyms();
        if (famsynonyms != null)
            for (String famsynonym : famsynonyms) addField(Fields.ANNOTATIONS, famsynonym.trim());
    }
}

Example 4 with AnnotationCategory

use of org.nextprot.api.commons.constants.AnnotationCategory in project nextprot-api by calipho-sib.

the class SchemaDaoImpl method findAllAnnotation.

@Override
public List<OWLAnnotation> findAllAnnotation() {
    // get description for annotations that exist in db
    AnnotationCategory[] cats = AnnotationCategory.values();
    List<Long> typeIds = new ArrayList<Long>();
    for (AnnotationCategory cat : cats) typeIds.add(new Long(cat.getDbId()));
    SqlParameterSource params = new MapSqlParameterSource("typeIds", typeIds);
    List<NameDescr> nds = new NamedParameterJdbcTemplate(dsLocator.getDataSource()).query(sqlDictionary.getSQLQuery("schema-instantiated-annotation-list"), params, new ParameterizedRowMapper<NameDescr>() {

        @Override
        public NameDescr mapRow(ResultSet rs, int row) throws SQLException {
            NameDescr nd = new NameDescr(rs.getString("cv_name"), rs.getString("description"));
            // System.out.println("rs.cv_name=" + nd.name + " description="+ nd.descr);
            return nd;
        }
    });
    // inject descriptions found in db into the OWLAnnotationCategory enum values
    for (NameDescr nd : nds) {
        AnnotationCategory m = AnnotationCategory.getByDbAnnotationTypeName(nd.name);
        // System.out.println("before descr: " + m.toString());
        m.setDescription(nd.descr);
    // System.out.println("after descr: " + m.toString());
    // AnnotationCategory.getByDbAnnotationTypeName(nd.name).setDescription(nd.descr);
    }
    // encapsulate OWLAnnotationCategory into OWLAnnotation to be compatible with the rest
    List<OWLAnnotation> annotations = new ArrayList<OWLAnnotation>();
    for (AnnotationCategory cat : AnnotationCategory.values()) {
        annotations.add(new OWLAnnotation(cat));
    }
    return annotations;
}

Example 5 with AnnotationCategory

use of org.nextprot.api.commons.constants.AnnotationCategory in project nextprot-api by calipho-sib.

the class SequenceFeatureBase method newFeature.

public static SequenceFeature newFeature(SingleFeatureQuery query) throws FeatureQueryException {
    // throw exception if invalid query
    query.checkFeatureQuery();
    AnnotationCategory annotationCategory = AnnotationCategory.getDecamelizedAnnotationTypeName(query.getFeatureType());
    try {
        switch(annotationCategory) {
            case MUTAGENESIS:
            case VARIANT:
                return new SequenceVariant(query.getFeature());
            case GENERIC_PTM:
                return new SequenceModification(query.getFeature());
            default:
                throw new InvalidFeatureQueryTypeException(query);
        }
    } catch (ParseException e) {
        throw new InvalidFeatureQueryFormatException(query, e);
    }
}