Downloads Documentation Community Contribute Demo






Show Sidebar
Login | Register
Show
Ignore:
Timestamp:
05/16/08 13:28:28 (4 months ago)
Author:
bwolfe
Message:

api-refactoring: Re-refactoring some of the api services

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • openmrs/branches/api_refactoring/src/api/org/openmrs/api/db/hibernate/HibernateConceptDAO.java

    r4231 r4240  
    1616import java.sql.SQLException; 
    1717import java.util.Collection; 
    18 import java.util.Date; 
    1918import java.util.HashSet; 
    2019import java.util.Iterator; 
     
    5655 
    5756/** 
    58  * the Hibernate class for Concepts, Drugs, and related classes 
     57 * The Hibernate class for Concepts, Drugs, and related classes 
     58 *  
    5959 * @see org.openmrs.ConceptService to access these methods 
    6060 */ 
    61 public class HibernateConceptDAO implements 
    62                 ConceptDAO { 
     61public class HibernateConceptDAO implements ConceptDAO { 
    6362 
    6463        protected final Log log = LogFactory.getLog(getClass()); 
    6564        private SessionFactory sessionFactory; 
    66          
    67         /** 
    68          * constructor 
    69          */ 
    70         public HibernateConceptDAO() { } 
    7165         
    7266        /** 
     
    8074         
    8175        /** 
    82          *  
    83          * Updates or creates a concept 
    84          * @see ConceptService.saveConcept()  
    85          * @param concept 
    86          * @throws DAOException 
    87          * @returns Concept 
     76         * @see org.openmrs.api.db.ConceptDAO#saveConcept(org.openmrs.Concept) 
    8877         */ 
    8978        public Concept saveConcept(Concept concept) throws DAOException { 
     
    9584 
    9685        /** 
    97          * @see org.openmrs.api.db.ConceptService#deleteConcept(org.openmrs.Concept) 
    98          * @param Concept concept  
    99          * @throws DAOException 
     86         * @see org.openmrs.api.db.ConceptDAO#purgeConcept(org.openmrs.Concept) 
    10087         */ 
    10188        public void purgeConcept(Concept concept) throws DAOException  { 
     89                // must delete all the stored concept words first 
    10290                sessionFactory.getCurrentSession().createQuery("delete from ConceptWord where concept_id = :c") 
    10391                                        .setInteger("c", concept.getConceptId()) 
    104                                         .executeUpdate();                        
     92                                        .executeUpdate(); 
     93                 
     94                // now we can safely delete the concept 
    10595                sessionFactory.getCurrentSession().delete(concept); 
    10696        } 
    107          
    108  
    109         /** 
    110          * @see org.openmrs.api.db.ConceptService#getConcept(java.lang.Integer) 
     97 
     98        /** 
     99         * @see org.openmrs.api.db.ConceptDAO#getConcept(java.lang.Integer) 
    111100         */ 
    112101        public Concept getConcept(Integer conceptId) throws DAOException  { 
     
    115104 
    116105        /** 
    117          * @see org.openmrs.api.db.ConceptService#getConcept(java.lang.Integer) 
     106         * @see org.openmrs.api.db.ConceptDAO#getConceptAnswer(java.lang.Integer) 
    118107         */ 
    119108        public ConceptAnswer getConceptAnswer(Integer conceptAnswerId) throws DAOException  { 
     
    122111 
    123112        /** 
    124          * @see org.openmrs.api.db.ConceptDAO#getConcepts(java.lang.String, boolean, boolean) 
    125          */ 
    126         @SuppressWarnings("unchecked") 
    127         public List<Concept> getConcepts(String sortBy, boolean asc, boolean includeRetired) throws DAOException  { 
     113         * @see org.openmrs.api.db.ConceptDAO#getAllConcepts(java.lang.String, boolean, boolean) 
     114         */ 
     115        @SuppressWarnings("unchecked") 
     116        public List<Concept> getAllConcepts(String sortBy, boolean asc, boolean includeRetired) throws DAOException  { 
    128117                String sql = "from Concept concept";     
    129118                 
     
    152141 
    153142        /** 
    154          * @see org.openmrs.api.db.DrugService#saveDrug(org.openmrs.Drug) 
     143         * @see org.openmrs.api.db.ConceptDAO#saveDrug(org.openmrs.Drug) 
    155144         */ 
    156145        public Drug saveDrug(Drug drug) throws DAOException { 
    157                         if (drug.getDateCreated() == null) 
    158                                 drug.setDateCreated(new Date());                 
    159146                        sessionFactory.getCurrentSession().saveOrUpdate(drug); 
    160147                        return drug; 
    161148        } 
    162149 
    163  
    164         /** 
    165          * @see org.openmrs.api.db.ConceptService#getDrug(java.lang.Integer) 
     150        /** 
     151         * @see org.openmrs.api.db.ConceptDAO#getDrug(java.lang.Integer) 
    166152         */ 
    167153        public Drug getDrug(Integer drugId) throws DAOException { 
     
    169155        } 
    170156         
    171          
    172         /** 
    173          * @see org.openmrs.api.db.ConceptService#getDrugs(org.openmrs.Concept) 
    174          */ 
    175         @SuppressWarnings("unchecked") 
    176         public List<Drug> getDrugs(String drugName, Concept concept, boolean includeVoided) throws DAOException { 
     157        /** 
     158         * @see org.openmrs.api.db.ConceptDAO#getDrugs(java.lang.String, org.openmrs.Concept, boolean) 
     159         */ 
     160        @SuppressWarnings("unchecked") 
     161        public List<Drug> getDrugs(String drugName, Concept concept, boolean includeRetired) throws DAOException { 
    177162                Criteria searchCriteria = sessionFactory.getCurrentSession().createCriteria(Drug.class, "drug"); 
    178                 if (includeVoided == false)  
    179                         searchCriteria.add(Expression.eq("drug.voided", false)); 
     163                if (includeRetired == false)  
     164                        searchCriteria.add(Expression.eq("drug.retired", false)); 
    180165                if (concept != null) 
    181166                        searchCriteria.add(Expression.eq("drug.concept", concept)); 
     
    185170        } 
    186171         
    187          
    188         /** 
    189          * @see org.openmrs.api.db.ConceptService#findDrugs(java.lang.String,boolean) 
    190          */ 
    191         @SuppressWarnings("unchecked") 
    192         public List<Drug> getDrugs(String phrase, boolean includeRetired) throws DAOException { 
     172        /** 
     173         * @see org.openmrs.api.db.ConceptDAO#getDrugs(java.lang.String) 
     174         */ 
     175        @SuppressWarnings("unchecked") 
     176        public List<Drug> getDrugs(String phrase) throws DAOException { 
    193177                List<String> words = ConceptWord.getUniqueWords(phrase);  
    194178                List<Drug> conceptDrugs = new Vector<Drug>(); 
     
    197181                 
    198182                        Criteria searchCriteria = sessionFactory.getCurrentSession().createCriteria(Drug.class, "drug"); 
    199                         if (includeRetired == false) { 
    200                                searchCriteria.add(Expression.eq("drug.voided", false)); 
    201                         } 
     183                         
     184                        searchCriteria.add(Expression.eq("drug.voided", false)); 
     185                         
    202186                        Iterator<String> word = words.iterator(); 
    203187                        searchCriteria.add(Expression.like("name", word.next(), MatchMode.ANYWHERE)); 
     
    214198        } 
    215199         
    216  
    217         /** 
    218          * @see org.openmrs.api.db.ConceptService#getConceptClass(java.lang.Integer) 
     200        /** 
     201         * @see org.openmrs.api.db.ConceptDAO#getConceptClass(java.lang.Integer) 
    219202         */ 
    220203        public ConceptClass getConceptClass(Integer i) throws DAOException { 
    221204                return (ConceptClass)sessionFactory.getCurrentSession().get(ConceptClass.class, i); 
    222205        } 
    223  
    224          
    225         /** 
    226          * @see org.openmrs.api.db.ConceptService#getConceptClassByName(java.lang.String) 
     206         
     207        /** 
     208         * @see org.openmrs.api.db.ConceptDAO#getConceptClasses(java.lang.String) 
    227209         */ 
    228210        @SuppressWarnings("unchecked") 
     
    230212                Criteria crit = sessionFactory.getCurrentSession().createCriteria(ConceptClass.class); 
    231213                if (name != null)        
    232                 crit.add(Expression.eq("name", name));                         
     214                       crit.add(Expression.eq("name", name));                  
    233215                return crit.list(); 
    234216        } 
    235  
    236         /** 
    237          *  
    238          * Updates or creates a ConceptClass 
    239          * @see ConceptService.saveConceptClass()  
    240          * @param ConceptClass cc 
    241          * @throws DAOException 
    242          * @returns ConceptClass 
     217         
     218        /** 
     219         * @see org.openmrs.api.db.ConceptDAO#getAllConceptClasses(boolean) 
     220         */ 
     221        @SuppressWarnings("unchecked") 
     222        public List<ConceptClass> getAllConceptClasses(boolean includeRetired) throws DAOException { 
     223                Criteria crit = sessionFactory.getCurrentSession().createCriteria(ConceptClass.class); 
     224                 
     225                if (includeRetired = false)      
     226                        crit.add(Expression.eq("retired", false)); 
     227                 
     228                return crit.list(); 
     229        } 
     230 
     231        /** 
     232         * @see org.openmrs.api.db.ConceptDAO#saveConceptClass(org.openmrs.ConceptClass) 
    243233         */ 
    244234        public ConceptClass saveConceptClass(ConceptClass cc) throws DAOException { 
     
    248238 
    249239        /** 
    250          *  
    251          * Purges a ConceptClass object from the database 
    252          *  
    253          * @return voied 
    254          * @param cc 
    255          * @throws DAOException 
     240         * @see org.openmrs.api.db.ConceptDAO#purgeConceptClass(org.openmrs.ConceptClass) 
    256241         */ 
    257242        public void purgeConceptClass(ConceptClass cc) throws DAOException  { 
     
    261246                sessionFactory.getCurrentSession().delete(cc); 
    262247        } 
    263          
    264  
    265         /** 
    266          * @see org.openmrs.api.db.ConceptService#getConceptDatatype(java.lang.Integer) 
     248 
     249        /** 
     250         * @see org.openmrs.api.db.ConceptDAO#getConceptDatatype(java.lang.Integer) 
    267251         */ 
    268252        public ConceptDatatype getConceptDatatype(Integer i) { 
     
    270254        } 
    271255         
    272  
    273         /** 
    274          * @see org.openmrs.api.db.ConceptService#getConceptDatatypes() 
    275          */ 
    276         @SuppressWarnings("unchecked") 
    277         public List<ConceptDatatype> getConceptDatatypes() { 
    278                 return sessionFactory.getCurrentSession().createQuery("from ConceptDatatype cd order by cd.name").list(); 
    279         } 
    280          
    281         /** 
    282          *  
     256    /** 
     257     * @see org.openmrs.api.db.ConceptDAO#getAllConceptDatatypes(boolean) 
     258     */ 
     259    public List<ConceptDatatype> getAllConceptDatatypes(boolean includeRetired) 
     260            throws DAOException { 
     261        Criteria crit = sessionFactory.getCurrentSession().createCriteria(ConceptDatatype.class); 
     262         
     263                if (includeRetired == false)     
     264                        crit.add(Expression.eq("retired", false)); 
     265                 
     266                return crit.list(); 
     267    } 
     268 
     269    /** 
     270     * @see org.openmrs.api.db.ConceptDAO#getConceptDatatypes(java.lang.String) 
     271     */ 
     272    public List<ConceptDatatype> getConceptDatatypes(String name) 
     273            throws DAOException { 
     274        Criteria crit = sessionFactory.getCurrentSession().createCriteria(ConceptDatatype.class); 
     275         
     276                if (name != null)        
     277                        crit.add(Expression.like("name", name, MatchMode.START)); 
     278                 
     279                return crit.list(); 
     280    } 
     281         
     282        /** 
    283283         * @see org.openmrs.api.db.ConceptDAO#saveConceptDatatype(org.openmrs.ConceptDatatype) 
    284284         */ 
     
    289289         
    290290        /** 
    291          *  
    292291         * @see org.openmrs.api.db.ConceptDAO#purgeConceptDatatype(org.openmrs.ConceptDatatype) 
    293292         */ 
     
    297296 
    298297        /** 
    299          * @see org.openmrs.api.db.ConceptService#getConceptNumeric(java.lang.Integer) 
     298         * @see org.openmrs.api.db.ConceptDAO#getConceptNumeric(java.lang.Integer) 
    300299         */ 
    301300        public ConceptNumeric getConceptNumeric(Integer i) { 
     
    318317 
    319318        /** 
    320          *  
    321          * @see org.openmrs.api.db.ConceptDAO#getConcepts(java.lang.String, java.util.Locale, boolean, boolean) 
    322          */ 
    323         @SuppressWarnings("unchecked") 
    324         public List<Concept> getConcepts(String name, Locale loc, boolean includeRetired, boolean searchOnPhrase) throws DAOException { 
    325                 if (searchOnPhrase) 
    326                         name = "%" + name + "%"; 
    327                 String sql = " from Concept c join c.names names where names.name like ? "; 
    328                 if (!includeRetired){ 
    329                           sql += " and c.retired = false "; 
    330                 } 
    331                 if (loc != null){ 
    332                         String locale = loc.getLanguage().substring(0, 2); 
    333                         sql += " and names.locale = '" + locale + "'"; 
    334                 } else { 
    335                         throw new DAOException("Locale must be not null for HibernateConceptDAO.getConcepts(name, loc, includeRetired)"); 
    336                 } 
    337                 Query query = sessionFactory.getCurrentSession().createQuery(sql); 
    338                 if (name == null) 
    339                         name = ""; 
    340                 query.setString(0, name); 
    341                 return query.list(); 
    342         } 
    343          
    344         /** 
    345          *  
    346          * @see org.openmrs.api.db.ConceptDAO#getConcepts(java.lang.String, java.util.Locale, boolean, java.util.List, java.util.List, java.util.List, java.util.List, java.lang.Integer, java.lang.Integer) 
    347          */ 
    348         @SuppressWarnings("unchecked") 
    349         public List<ConceptWord> getConcepts(String phrase, List<Locale> locales, boolean includeRetired,  
     319         * @see org.openmrs.api.db.ConceptDAO#getConcepts(java.lang.String, java.util.Locale, boolean, java.util.List, java.util.List) 
     320         */ 
     321        @SuppressWarnings("unchecked") 
     322        public List<Concept> getConcepts(String name, Locale loc, boolean searchOnPhrase, List<ConceptClass> classes, List<ConceptDatatype> datatypes) throws DAOException { 
     323                 
     324                Criteria criteria = sessionFactory.getCurrentSession().createCriteria(Concept.class); 
     325                 
     326                criteria.add(Expression.eq("retired", false)); 
     327                 
     328                if (name != null) { 
     329                        if (loc == null) 
     330                                throw new DAOException("Locale must be not null"); 
     331                         
     332                        criteria.createAlias("names", "names"); 
     333                        MatchMode matchmode = MatchMode.EXACT; 
     334                        if (searchOnPhrase) 
     335                                matchmode = MatchMode.ANYWHERE; 
     336                         
     337                        criteria.add(Expression.like("names.name", name, matchmode)); 
     338                        criteria.add(Expression.eq("names.locale", loc.getLanguage().substring(0, 2))); 
     339                } 
     340                 
     341                if (classes.size() > 0) 
     342                        criteria.add(Expression.in("conceptClasses", classes)); 
     343                 
     344                if (datatypes.size() > 0) 
     345                        criteria.add(Expression.in("conceptDatatypes", datatypes)); 
     346                 
     347                return criteria.list(); 
     348        } 
     349         
     350        /** 
     351         * @see org.openmrs.api.db.ConceptDAO#getConceptWords(java.lang.String, java.util.List, boolean, java.util.List, java.util.List, java.util.List, java.util.List, org.openmrs.Concept, java.lang.Integer, java.lang.Integer) 
     352         */ 
     353        @SuppressWarnings("unchecked") 
     354        public List<ConceptWord> getConceptWords(String phrase, List<Locale> locales, boolean includeRetired,  
    350355                        List<ConceptClass> requireClasses, List<ConceptClass> excludeClasses, 
    351                         List<ConceptDatatype> requireDatatypes, List<ConceptDatatype> excludeDatatypes, 
    352                         Integer start, Integer size)  
     356                        List<ConceptDatatype> requireDatatypes, List<ConceptDatatype> excludeDatatypes, Concept answersToConcept, 
     357                        Integer start, Integer size) throws DAOException 
    353358                        { 
    354359                 
     
    356361                List<String> words = ConceptWord.getUniqueWords(phrase); //assumes getUniqueWords() removes quote(') characters.  (otherwise we would have a security leak) 
    357362                 
     363                // these are the answers to restrict on 
     364                List<Concept> answers = new Vector<Concept>(); 
     365                 
     366                if (answersToConcept.getAnswers() != null) { 
     367                        for (ConceptAnswer conceptAnswer : answersToConcept.getAnswers()) { 
     368                                answers.add(conceptAnswer.getAnswerConcept()); 
     369                        } 
     370                } 
     371                 
    358372                List<ConceptWord> conceptWords = new Vector<ConceptWord>(); 
    359373                 
     
    362376                        Criteria searchCriteria = sessionFactory.getCurrentSession().createCriteria(ConceptWord.class, "cw1"); 
    363377                        searchCriteria.add(Expression.in("locale", locales)); 
     378                         
    364379                        if (includeRetired == false) { 
    365380                                searchCriteria.createAlias("concept", "concept"); 
    366381                                searchCriteria.add(Expression.eq("concept.retired", false)); 
    367382                        } 
     383                         
     384                        // Only restrict on answers if there are any 
     385                        if (!answers.isEmpty()) 
     386                                searchCriteria.add(Expression.in("cw1.concept", answers)); 
     387                         
    368388                        Iterator<String> word = words.iterator(); 
    369389                        searchCriteria.add(Expression.like("word", word.next(), MatchMode.START)); 
     
    371391                        while (word.hasNext()) { 
    372392                                String w = word.next(); 
    373                                 log.debug(w); 
     393                                 
     394                                if (log.isDebugEnabled()) 
     395                                        log.debug("Current word: " + w); 
     396                                 
    374397                                DetachedCriteria crit = DetachedCriteria.forClass(ConceptWord.class) 
    375398                                                        .setProjection(Property.forName("concept")) 
     
    393416                                searchCriteria.add(Expression.not(Expression.in("concept.datatype", excludeDatatypes))); 
    394417                         
    395                          
    396418                        searchCriteria.addOrder(Order.asc("synonym")); 
    397419                        conceptWords = searchCriteria.list(); 
     420                         
     421                        // trim down the list  
     422                        // TODO: put this in the criteria object? 
    398423                        if (start != null && size != null){ 
    399                         List<ConceptWord> subList = conceptWords.subList(start, start + size); 
    400                         return subList; 
    401                         } 
    402                 } 
    403                  
    404                 log.debug("ConceptWords found: " + conceptWords.size()); 
    405                  
     424                               List<ConceptWord> subList = conceptWords.subList(start, start + size); 
     425                               return subList; 
     426                        } 
     427                } 
     428                 
     429                if (log.isDebugEnabled()) 
     430                       log.debug("ConceptWords found: " + conceptWords.size()); 
    406431                 
    407432                return conceptWords; 
     
    409434         
    410435        /** 
    411          *  
    412          * @see org.openmrs.api.db.ConceptDAO#findConceptAnswers(java.lang.String, java.util.Locale, org.openmrs.Concept, boolean) 
    413          */ 
    414         @SuppressWarnings("unchecked") 
    415         public List<ConceptWord> findConceptAnswers(String phrase, Locale loc, Concept concept, boolean includeRetired) { 
    416                 String locale = loc.getLanguage().substring(0, 2);              //only get language portion of locale 
    417                 List<String> words = ConceptWord.getUniqueWords(phrase); //assumes getUniqueWords() removes quote(') characters.  (otherwise we would have a security leak) 
    418                  
    419                 // default return list 
    420                 List<ConceptWord> conceptWords = new Vector<ConceptWord>(); 
    421                  
    422                 // these are the answers to restrict on 
    423                 List<Concept> answers = new Vector<Concept>(); 
    424                  
    425                 if (concept.getAnswers() != null) 
    426                         for (ConceptAnswer conceptAnswer : concept.getAnswers()) { 
    427                                 answers.add(conceptAnswer.getAnswerConcept()); 
    428                         } 
    429                  
    430                 // by default, we will return all of the concept's answers 
    431                 // however, if there are no answers, return nothing by default 
    432                 if (words.size() > 0 || !answers.isEmpty()) { 
    433                         Criteria searchCriteria = sessionFactory.getCurrentSession().createCriteria(ConceptWord.class, "cw1"); 
    434                         searchCriteria.add(Restrictions.eq("locale", locale)); 
    435                         if (includeRetired == false) { 
    436                                 searchCriteria.createAlias("concept", "concept"); 
    437                                 searchCriteria.add(Expression.eq("concept.retired", false)); 
    438                         } 
    439                          
    440                         // Only modification from standard word search 
    441                         // Only restrict on answers if there are any 
    442                         if (!answers.isEmpty()) 
    443                                 searchCriteria.add(Expression.in("cw1.concept", answers)); 
    444                  
    445                         // if the user typed in a phrase, restrict further 
    446                         if (words.size() > 0) { 
    447                                 Iterator<String> word = words.iterator(); 
    448                                 searchCriteria.add(Expression.like("word", word.next(), MatchMode.START)); 
    449                                 Conjunction junction = Expression.conjunction(); 
    450                                 while (word.hasNext()) {        // add 'and' expression for _each word_ in search phrase 
    451                                         String w = word.next(); 
    452                                         log.debug(w); 
    453                                         DetachedCriteria crit = DetachedCriteria.forClass(ConceptWord.class) 
    454                                                                 .setProjection(Property.forName("concept")) 
    455                                                                 .add(Expression.eqProperty("concept", "cw1.concept")) 
    456                                                                 .add(Restrictions.like("word", w, MatchMode.START)) 
    457                                                                 .add(Restrictions.eq("locale", locale)); 
    458                                         junction.add(Subqueries.exists(crit)); 
    459                                 } 
    460                                 searchCriteria.add(junction); 
    461                         } 
    462                  
    463                         searchCriteria.addOrder(Order.asc("synonym")); 
    464                         conceptWords = searchCriteria.list(); 
    465                 } 
    466                  
    467                 return conceptWords; 
    468         } 
    469          
    470         /** 
    471          * @see org.openmrs.api.db.ConceptService#getQuestionsForAnswer(org.openmrs.Concept) 
     436         * gets questions for the given answer concept 
     437         * @see org.openmrs.api.db.ConceptDAO#getConceptsByAnswer(org.openmrs.Concept) 
    472438         */ 
    473439        @SuppressWarnings("unchecked") 
     
    482448         
    483449        /** 
    484          * @see org.openmrs.api.db.ConceptService#getNextConcept(org.openmrs.Concept, java.lang.Integer
     450         * @see org.openmrs.api.db.ConceptDAO#getPrevConcept(org.openmrs.Concept
    485451         */ 
    486452        @SuppressWarnings("unchecked") 
     
    500466 
    501467        /** 
    502          * @see org.openmrs.api.db.ConceptService#getNextConcept(org.openmrs.Concept, java.lang.Integer
     468         * @see org.openmrs.api.db.ConceptDAO#getNextConcept(org.openmrs.Concept
    503469         */ 
    504470        @SuppressWarnings("unchecked") 
     
    518484 
    519485        /** 
    520          *  
    521486         * @see org.openmrs.api.db.ConceptDAO#getNextAvailableId() 
    522487         */ 
     
    551516         
    552517        /** 
    553          * @see org.openmrs.api.db.ConceptDAO#getConcepts(org.openmrs.ConceptClass, boolean) 
    554          */ 
    555         @SuppressWarnings("unchecked") 
    556         public List<Concept> getConcepts(ConceptClass cc, boolean includeRetired) { 
    557                 Criteria crit = sessionFactory.getCurrentSession().createCriteria(Concept.class); 
    558                 crit.add(Expression.eq("conceptClass", cc)); 
    559                 crit.add(Expression.eq("retired", includeRetired)); 
    560                 return crit.list(); 
    561         } 
    562          
    563         /** 
    564          * @see org.openmrs.api.db.ConceptDAO#getConceptsWithDrugsInFormulary(boolean) 
    565          */ 
    566         @SuppressWarnings("unchecked") 
    567         public List<Concept> getConceptsWithDrugsInFormulary(boolean includeVoided) { 
    568                 Query query = sessionFactory.getCurrentSession().createQuery("select distinct concept from Drug where voided = false").setEntity(0, includeVoided); 
     518         * @see org.openmrs.api.db.ConceptDAO#getConceptsWithDrugsInFormulary() 
     519         */ 
     520        @SuppressWarnings("unchecked") 
     521        public List<Concept> getConceptsWithDrugsInFormulary() { 
     522                Query query = sessionFactory.getCurrentSession().createQuery("select distinct concept from Drug where retired = false"); 
    569523                return query.list(); 
    570524        } 
    571525         
    572          
    573         /** 
    574          *  
    575          * Deletes a drug from the drug table permanently 
    576          * @use ConceptService.purgeDrug(Drug)  
    577          * @param drug 
    578          * @throws DAOException 
     526        /** 
     527         * @see org.openmrs.api.db.ConceptDAO#purgeDrug(org.openmrs.Drug) 
    579528         */ 
    580529        public void purgeDrug(Drug drug) throws DAOException { 
    581530                sessionFactory.getCurrentSession().delete(drug); 
    582531        } 
    583  
    584          
    585         /** 
    586          *  
     532         
     533        /** 
    587534         * @see org.openmrs.api.db.ConceptDAO#updateConceptWord(org.openmrs.Concept) 
    588535         */ 
     
    618565         */ 
    619566        @SuppressWarnings("unchecked") 
    620     public void deleteConceptWord(Concept concept) throws DAOException { 
     567    private void deleteConceptWord(Concept concept) throws DAOException { 
    621568                if (concept != null) { 
    622569                        Criteria crit = sessionFactory.getCurrentSession().createCriteria(ConceptWord.class); 
     
    638585         
    639586        /** 
    640          * @see org.openmrs.api.db.ConceptDAO#updateConceptProposal(org.openmrs.ConceptProposal) 
     587         * @see org.openmrs.api.db.ConceptDAO#saveConceptProposal(org.openmrs.ConceptProposal) 
    641588         */ 
    642589        public ConceptProposal saveConceptProposal(ConceptProposal cp) throws DAOException { 
     
    646593         
    647594        /** 
    648          * @see org.openmrs.api.db.ConceptDAO#updateConceptProposal(org.openmrs.ConceptProposal) 
     595         * @see org.openmrs.api.db.ConceptDAO#purgeConceptProposal(org.openmrs.ConceptProposal) 
    649596         */ 
    650597        public void purgeConceptProposal(ConceptProposal cp) throws DAOException { 
     
    654601         
    655602        /** 
    656          * @see org.openmrs.api.db.ConceptService#getConceptProposals(boolean) 
    657          */ 
    658         @SuppressWarnings("unchecked") 
    659         public List<ConceptProposal> getConceptProposals(boolean includeCompleted) throws DAOException { 
     603         * @see org.openmrs.api.db.ConceptDAO#getAllConceptProposals(boolean) 
     604         */ 
     605        @SuppressWarnings("unchecked") 
     606        public List<ConceptProposal> getAllConceptProposals(boolean includeCompleted) throws DAOException { 
    660607                Criteria crit = sessionFactory.getCurrentSession().createCriteria(ConceptProposal.class); 
    661608                 
     
    668615         
    669616        /** 
    670          * @see org.openmrs.api.db.ConceptService#getConceptProposal(java.lang.Integer) 
     617         * @see org.openmrs.api.db.ConceptDAO#getConceptProposal(java.lang.Integer) 
    671618         */ 
    672619        public ConceptProposal getConceptProposal(Integer conceptProposalId) throws DAOException { 
     
    675622         
    676623        /** 
    677          * @see org.openmrs.api.db.ConceptService#findMatchingConceptProposals(java.lang.String) 
     624         * @see org.openmrs.api.db.ConceptDAO#getConceptProposals(java.lang.String) 
    678625         */ 
    679626        @SuppressWarnings("unchecked") 
     
    686633         
    687634        /** 
    688          * @see org.openmrs.api.db.ConceptService#findProposedConcepts(java.lang.String) 
     635         * @see org.openmrs.api.db.ConceptDAO#getProposedConcepts(java.lang.String) 
    689636         */ 
    690637        @SuppressWarnings("unchecked") 
     
    700647         
    701648        /** 
    702          * @see org.openmrs.api.db.ConceptService#getConceptSets(java.lang.Integer
    703          */ 
    704         @SuppressWarnings("unchecked") 
    705         public List<ConceptSet> getConceptSets(Concept concept) { 
     649         * @see org.openmrs.api.db.ConceptDAO#getConceptSetsByConcept(org.openmrs.Concept
     650         */ 
     651        @SuppressWarnings("unchecked") 
     652        public List<ConceptSet> getConceptSetsByConcept(Concept concept) { 
    706653                return sessionFactory.getCurrentSession().createCriteria(ConceptSet.class) 
    707654                                        .add(Restrictions.eq("conceptSet", concept)) 
     
    711658         
    712659        /** 
    713          * @see org.openmrs.api.ConceptService#getSetsContainingConcept(org.openmrs.Concept) 
     660         * @see org.openmrs.api.db.ConceptDAO#getSetsContainingConcept(org.openmrs.Concept) 
    714661         */ 
    715662        @SuppressWarnings("unchecked") 
     
    722669        //TODO:  eventually, this method should probably just run updateConceptSetDerived(Concept) inside an iteration of all concepts... (or something else less transactionally-intense) 
    723670        /** 
    724          *  
    725671         * @see org.openmrs.api.db.ConceptDAO#updateConceptSetDerived() 
    726672         */ 
     
    784730         
    785731        /** 
    786          *  
    787732         * @see org.openmrs.api.db.ConceptDAO#updateConceptSetDerived(org.openmrs.Concept) 
    788733         */ 
     
    827772         
    828773        /** 
    829          *  
    830          * returns a list of n-generations of parents of a concept in a concept set 
     774y        * returns a list of n-generations of parents of a concept in a concept set 
    831775         *  
    832776         * @param Concept current