Changeset 3567


Ignore:
Timestamp:
2002-11-26T13:54:23+13:00 (21 years ago)
Author:
kjdon
Message:

tidied up a bit, using new Dictionary stuff

Location:
trunk/gsdl3/src/java/org/greenstone/gsdl3/service
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/gsdl3/src/java/org/greenstone/gsdl3/service/GSDL2ClassifierServices.java

    r3512 r3567  
    4747    }
    4848 
     49    /** creates a display element containing all the text strings needed to display the service page, in the language specified */
     50    protected Element createServiceDisplay(String service, String lang) {
     51    Element display = doc_.createElement(GSXML.DISPLAY_ELEM);
     52    display.appendChild(GSXML.createTextElement(doc_, GSXML.DISPLAY_NAME_ELEM,  getTextString(service+".name", lang)));
     53    display.appendChild(GSXML.createTextElement(doc_,  GSXML.DISPLAY_SUBMIT_ELEM, getTextString(service+".submit", lang)));
     54
     55    Element param;
     56
     57    return display;
     58   
     59    }
     60
    4961    /** processes the request */
    5062    protected Element processService(String name, Element request) {

  • trunk/gsdl3/src/java/org/greenstone/gsdl3/service/MGGDBMServices.java

    r3512 r3567  
    4040    private static final String METADATA_RETRIEVE_SERVICE = "MetadataRetrieve";
    4141   
     42
     43    /** creates a display element containing all the text strings needed to display the service page, in the language specified */
     44    protected Element createServiceDisplay(String service, String lang) {
     45    Element display = doc_.createElement(GSXML.DISPLAY_ELEM);
     46    display.appendChild(GSXML.createTextElement(doc_, GSXML.DISPLAY_NAME_ELEM,  getTextString(service+".name", lang)));
     47    display.appendChild(GSXML.createTextElement(doc_,  GSXML.DISPLAY_SUBMIT_ELEM, getTextString(service+".submit", lang)));
     48
     49    Element param;
     50
     51    return display;
     52   
     53    }
     54
    4255    /** passes the request Element to the appropriate service function*/
    4356    protected Element processService(String name, Element request) {

  • trunk/gsdl3/src/java/org/greenstone/gsdl3/service/MGPPGDBMServices.java

    r3512 r3567  
    3434import java.util.Map;
    3535import java.util.Iterator;
     36import java.util.Locale;
    3637/**
    3738 * A ServicesImpl class for MGPP+GDBM
    … …  
    4647    extends ServicesImpl {
    4748
     49    // these strings must match what is found in the properties file
    4850    // the services on offer
    4951    private static final String TEXT_QUERY_SERVICE = "TextQuery";
    … …  
    5254    private static final String METADATA_RETRIEVE_SERVICE = "MetadataRetrieve";
    5355
     56    // params used
     57    private static final String CASE_PARAM = "case";
     58    private static final String STEM_PARAM = "stem";
     59    private static final String MATCH_PARAM = "matchMode";
     60    private static final String MATCH_PARAM_ALL = "all";
     61    private static final String MATCH_PARAM_SOME = "some";
     62    private static final String INDEX_PARAM = "index";
     63    private static final String LEVEL_PARAM = "level";
     64    private static final String RANK_PARAM = "sortBy";
     65    private static final String RANK_PARAM_RANK = "rank";
     66    private static final String RANK_PARAM_NONE = "natural";
     67    private static final String MAXDOCS_PARAM = "maxDocs";
     68    private static final String BOOLEAN_PARAM_ON = "1";
     69    private static final String BOOLEAN_PARAM_OFF = "0";
     70   
     71    // elements used in the config file that are specific to this class
     72    private static final String DEFAULT_INDEX_ELEM = "defaultIndex";
     73    private static final String DEFAULT_LEVEL_ELEM = "defaultLevel";
     74    private static final String INDEX_ELEM = "index";
     75    private static final String LEVEL_ELEM = "level";
     76   
     77
    5478    private MGPPWrapper mgpp_src_=null;
    5579    private GDBMWrapper gdbm_src_=null;
    … …  
    5882    private String default_level_=null;
    5983
     84    private Element config_info_ = null;
    6085    public MGPPGDBMServices() {
    6186    mgpp_src_ = new MGPPWrapper();
    … …  
    6489    }
    6590   
    66 
    6791    /** configure this service */
    6892    public boolean configure(Element info) {
    6993
    7094    System.out.println("configuring MGPPGDBMServices");
    71 
     95    config_info_ = info;
     96    // get the general info first
    7297    // get the default index from <defaultIndex>
    73     Element def = (Element)GSXML.getChildByTagName(info, "defaultIndex");
     98    Element def = (Element)GSXML.getChildByTagName(info, DEFAULT_INDEX_ELEM );
    7499    if (def !=null) {
    75100        default_index_ = def.getAttribute(GSXML.NAME_ATT);
    … …  
    80105    }
    81106
    82     System.out.println("default index="+default_index_);
    83 
    84107    // get the default level out of <defaultLevel>
    85     def = (Element)GSXML.getChildByTagName(info, "defaultLevel");
     108    def = (Element)GSXML.getChildByTagName(info, DEFAULT_LEVEL_ELEM);
    86109    if (def !=null) {
    87110        default_level_ = def.getAttribute(GSXML.NAME_ATT);
    … …  
    93116    // the default level is also the level which gdbm is expecting
    94117    mgpp_src_.setReturnLevel(default_level_);
    95     System.out.println("default level="+default_level_);
    96118
    97119    // set up which services are available for this collection
    … …  
    126148    e.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_QUERY);
    127149    e.setAttribute(GSXML.NAME_ATT, TEXT_QUERY_SERVICE);
    128     Element paramList = doc_.createElement(GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
     150    Element param_list = doc_.createElement(GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
     151    createTextQueryParamList(param_list, false, null);
     152    e.appendChild(param_list);
     153    service_info_map_.put(TEXT_QUERY_SERVICE, e);
     154   
     155
     156    e = doc_.createElement(GSXML.SERVICE_ELEM);
     157    e.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_QUERY);
     158    e.setAttribute(GSXML.NAME_ATT, FIELD_QUERY_SERVICE);
     159    service_info_map_.put(FIELD_QUERY_SERVICE, e);
     160   
     161    e = doc_.createElement(GSXML.SERVICE_ELEM);
     162    e.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_QUERY);
     163    e.setAttribute(GSXML.NAME_ATT, RESOURCE_RETRIEVE_SERVICE);
     164    service_info_map_.put(RESOURCE_RETRIEVE_SERVICE, e);
     165   
     166    e = doc_.createElement(GSXML.SERVICE_ELEM);
     167    e.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_QUERY);
     168    e.setAttribute(GSXML.NAME_ATT, METADATA_RETRIEVE_SERVICE);
     169    service_info_map_.put(METADATA_RETRIEVE_SERVICE, e);
     170
     171    if (gdbm_src_.openDatabase(GSFile.GDBMDatabaseFile(site_home_, cluster_name_), GDBMWrapper.READER)) {
     172        return true;
     173    }
     174    else {
     175        System.err.println("couldn't open gdbm database!");
     176        return false;
     177    }
     178    }
     179 
     180    /** this creates all teh params and appends them to param_list.
     181     * if display=true it creates the text strings version
     182     * otherwise it creates the description version
     183     */
     184    protected boolean createTextQueryParamList(Element param_list, boolean display, String lang) {
    129185    Element param;
     186
    130187    // first do index and level params
    131188
    132189    // the index info - read from config file
    133     Element index_list = (Element)GSXML.getChildByTagName(info, "indexList");
    134     NodeList indexes = index_list.getElementsByTagName("index");
     190    Element index_list = (Element)GSXML.getChildByTagName(config_info_, INDEX_ELEM+GSXML.LIST_MODIFIER);
     191    NodeList indexes = index_list.getElementsByTagName(INDEX_ELEM);
    135192    int len = indexes.getLength();
    136193    if (len > 1) {
    … …  
    140197        inds[i] = ((Element)indexes.item(i)).getAttribute(GSXML.NAME_ATT);
    141198        }
    142         param = GSXML.createParameter(doc_, "index", GSXML.PARAM_TYPE_ENUM, default_index_, inds);
    143         paramList.appendChild(param);
     199        if (display) {
     200        // use the same index names for now - should get these out of the config info
     201        param = GSXML.createParameterDisplay(doc_, INDEX_PARAM, getTextString("param."+INDEX_PARAM, lang), inds, inds);
     202        } else {
     203        param = GSXML.createParameter(doc_, INDEX_PARAM, GSXML.PARAM_TYPE_ENUM_SINGLE, default_index_, inds);
     204        }
     205        param_list.appendChild(param);
    144206    } // else dont need to add it
    145207
    146208    // the level info - read from config file
    147     Element level_list = (Element)GSXML.getChildByTagName(info, "levelList");
    148     NodeList levels = level_list.getElementsByTagName("level");
     209    Element level_list = (Element)GSXML.getChildByTagName(config_info_, LEVEL_ELEM+GSXML.LIST_MODIFIER);
     210    NodeList levels = level_list.getElementsByTagName(LEVEL_ELEM);
    149211    len = levels.getLength();
    150212    if (len > 1) {
    … …  
    154216        levs[i] = ((Element)levels.item(i)).getAttribute(GSXML.NAME_ATT);
    155217        }
    156         param = GSXML.createParameter(doc_, "queryLevel", GSXML.PARAM_TYPE_ENUM, default_level_, levs);
    157         paramList.appendChild(param);
     218        if (display) {
     219        param =  GSXML.createParameterDisplay(doc_, LEVEL_PARAM, getTextString("param."+LEVEL_PARAM, lang), levs, levs);
     220        } else {
     221        param = GSXML.createParameter(doc_, LEVEL_PARAM, GSXML.PARAM_TYPE_ENUM_SINGLE, default_level_, levs);
     222        }
     223        param_list.appendChild(param);
    158224    } // else dont need to add it
    159 
     225   
    160226    // boolean params
    161     param = GSXML.createParameter(doc_, "case", GSXML.PARAM_TYPE_BOOLEAN, "1", null);
    162     paramList.appendChild(param);
    163     param = GSXML.createParameter(doc_, "stem", GSXML.PARAM_TYPE_BOOLEAN, "1", null);
    164     paramList.appendChild(param);
     227    if (display) {
     228        String[] bool_ops = {"0", "1"};
     229        String[] bool_texts = {getTextString("param.boolean.off", lang),getTextString("param.boolean.on", lang)};
     230        param = GSXML.createParameterDisplay(doc_, CASE_PARAM, getTextString("param."+CASE_PARAM, lang),  bool_ops, bool_texts);
     231        param_list.appendChild(param);
     232        param = GSXML.createParameterDisplay(doc_, STEM_PARAM, getTextString("param."+STEM_PARAM, lang),  bool_ops, bool_texts);
     233        param_list.appendChild(param);
     234
     235    } else {
     236        param = GSXML.createParameter(doc_, CASE_PARAM, GSXML.PARAM_TYPE_BOOLEAN, BOOLEAN_PARAM_ON, null);
     237        param_list.appendChild(param);
     238        param = GSXML.createParameter(doc_, STEM_PARAM, GSXML.PARAM_TYPE_BOOLEAN, BOOLEAN_PARAM_ON, null);
     239        param_list.appendChild(param);
     240    }
     241
    165242    // enum params
    166     String []vals = {"all", "some"};
    167     param = GSXML.createParameter(doc_, "matchMode", GSXML.PARAM_TYPE_ENUM, "all", vals);
    168     paramList.appendChild(param);
    169     String [] vals1 = {"rank", "natural"};
    170     param = GSXML.createParameter(doc_, "sortBy", GSXML.PARAM_TYPE_ENUM, "rank", vals1 );
    171     paramList.appendChild(param);
     243    String []vals = {MATCH_PARAM_ALL, MATCH_PARAM_SOME};
     244    if (display) {
     245        String []val_texts = {getTextString("param."+MATCH_PARAM+"."+MATCH_PARAM_ALL, lang),getTextString("param."+MATCH_PARAM+"."+MATCH_PARAM_SOME, lang)};
     246
     247        param = GSXML.createParameterDisplay(doc_, MATCH_PARAM, getTextString("param."+MATCH_PARAM, lang), vals, val_texts);
     248    } else {
     249        param = GSXML.createParameter(doc_, MATCH_PARAM, GSXML.PARAM_TYPE_ENUM_SINGLE, MATCH_PARAM_ALL, vals);
     250    }   
     251    param_list.appendChild(param);
     252    String [] vals1 = {RANK_PARAM_RANK, RANK_PARAM_NONE };
     253    if (display) {
     254        String [] vals1_texts = { getTextString("param."+RANK_PARAM+"."+RANK_PARAM_RANK, lang),
     255                  getTextString("param."+RANK_PARAM+"."+RANK_PARAM_NONE, lang)};
     256   
     257        param = GSXML.createParameterDisplay(doc_, RANK_PARAM, getTextString("param."+RANK_PARAM, lang), vals1, vals1_texts);
     258    } else {
     259        param = GSXML.createParameter(doc_, RANK_PARAM, GSXML.PARAM_TYPE_ENUM_SINGLE, RANK_PARAM_RANK, vals1 );
     260    }
     261    param_list.appendChild(param);
    172262
    173263    // Integer params
    174     param = GSXML.createParameter(doc_, "maxDocs", GSXML.PARAM_TYPE_INTEGER, "10", null);
    175     paramList.appendChild(param);
    176 
    177 
    178     e.appendChild(paramList);
    179    
    180     service_info_map_.put(TEXT_QUERY_SERVICE, e);
    181    
    182 
    183     e = doc_.createElement(GSXML.SERVICE_ELEM);
    184     e.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_QUERY);
    185     e.setAttribute(GSXML.NAME_ATT, FIELD_QUERY_SERVICE);
    186     service_info_map_.put(FIELD_QUERY_SERVICE, e);
    187    
    188     e = doc_.createElement(GSXML.SERVICE_ELEM);
    189     e.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_QUERY);
    190     e.setAttribute(GSXML.NAME_ATT, RESOURCE_RETRIEVE_SERVICE);
    191     service_info_map_.put(RESOURCE_RETRIEVE_SERVICE, e);
    192    
    193     e = doc_.createElement(GSXML.SERVICE_ELEM);
    194     e.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_QUERY);
    195     e.setAttribute(GSXML.NAME_ATT, METADATA_RETRIEVE_SERVICE);
    196     service_info_map_.put(METADATA_RETRIEVE_SERVICE, e);
    197 
    198     if (gdbm_src_.openDatabase(GSFile.GDBMDatabaseFile(site_home_, cluster_name_), GDBMWrapper.READER)) {
    199         return true;
    200     }
    201     else {
    202         System.err.println("couldn't open gdbm database!");
    203         return false;
    204     }
    205     }
    206        
     264    if (display) {
     265        param = GSXML.createParameterDisplay(doc_, MAXDOCS_PARAM, getTextString("param."+MAXDOCS_PARAM, lang), null, null);
     266    } else {
     267        param = GSXML.createParameter(doc_, MAXDOCS_PARAM, GSXML.PARAM_TYPE_INTEGER, "10", null);
     268    }
     269    param_list.appendChild(param);
     270    return true;
     271    }
     272
     273    /** creates a display element containing all the text strings needed to display the service page, in the language specified */
     274    protected Element createServiceDisplay(String service, String lang) {
     275    Element display = doc_.createElement(GSXML.DISPLAY_ELEM);
     276    display.appendChild(GSXML.createTextElement(doc_, GSXML.DISPLAY_NAME_ELEM,  getTextString(service+".name", lang)));
     277    display.appendChild(GSXML.createTextElement(doc_,  GSXML.DISPLAY_SUBMIT_ELEM, getTextString(service+".submit", lang)));
     278
     279    // now need to add in the params
     280    if (service.equals(TEXT_QUERY_SERVICE)) {
     281       
     282        createTextQueryParamList(display, true, lang);
     283    }
     284    return display;
     285   
     286    }
     287
     288     
    207289
    208290    /** passes the request Element to the appropriate service function*/
    … …  
    261343
    262344    HashMap params = GSXML.extractParams(param_elem);
    263     String index = (String)params.get("index");
     345    String index = (String)params.get(INDEX_PARAM);
    264346    if (index==null) { // if its not present, use the default index
    265347        index=default_index_;
    … …  
    359441    if (resource_type.equals("core")) {
    360442        // get docs from mgpp, and possibly associated files too
    361         String level = (String)params.get("level"); // level at which to
     443        String level = (String)params.get(LEVEL_PARAM); // level at which to
    362444        // retrieve a doc
    363445        if (level==null) {
    … …  
    448530    protected boolean setQueryParams(HashMap params) {
    449531
     532    // set the default ones
     533    mgpp_src_.setReturnTerms(true);
    450534    Set entries = params.entrySet();
    451535    Iterator i = entries.iterator();
    … …  
    455539        String value = (String)m.getValue();
    456540       
    457         if (name.equals("case")) {
    458         boolean val = (value.equals("1")?true:false);
     541        if (name.equals(CASE_PARAM)) {
     542        boolean val = (value.equals(BOOLEAN_PARAM_ON)?true:false);
    459543        mgpp_src_.setCase(val);     
    460         } else if (name.equals("stem")) {
    461         boolean val = (value.equals("1")?true:false);
     544        } else if (name.equals(STEM_PARAM)) {
     545        boolean val = (value.equals(BOOLEAN_PARAM_ON)?true:false);
    462546        mgpp_src_.setStem(val);
    463         } else if (name.equals("maxDocs")) {
     547        } else if (name.equals(MAXDOCS_PARAM)) {
    464548        int docs = Integer.parseInt(value);
    465549        mgpp_src_.setMaxDocs(docs);
    466         } else if (name.equals("queryLevel")) {
     550        } else if (name.equals(LEVEL_PARAM)) {
    467551        mgpp_src_.setQueryLevel(value);
    468         } else if (name.equals("resultLevel")) {
    469         mgpp_src_.setReturnLevel(value);
    470         } else if (name.equals("matchMode")) {
     552        } else if (name.equals(MATCH_PARAM)) {
    471553        int mode;
    472         if (value.equals("all")) mode=1;
     554        if (value.equals(MATCH_PARAM_ALL)) mode=1;
    473555        else mode=0;
    474556        mgpp_src_.setMatchMode(mode);
    475         } else if (name.equals("sortBy")) {
    476         if (value.equals("rank")) {
     557        } else if (name.equals(RANK_PARAM)) {
     558        if (value.equals(RANK_PARAM_RANK)) {
    477559            mgpp_src_.setSortByRank(true);
    478         } else if (value.equals("natural")) {
     560        } else if (value.equals(RANK_PARAM_NONE)) {
    479561            mgpp_src_.setSortByRank(false);
    480562        }
    481         } else if (name.equals("termInfo")) {
    482         boolean val = (value.equals("1")?true:false);
    483         mgpp_src_.setReturnTerms(val);
    484563        } // ignore any others
    485564    }

  • trunk/gsdl3/src/java/org/greenstone/gsdl3/service/PerlBuildServices.java

    r3513 r3567  
    3131import java.util.ArrayList;
    3232import java.io.File;
     33import java.util.Locale;
    3334
    3435/**
    … …  
    5051    private static final String RELOAD_SERVICE = "ReloadCollection";
    5152
    52     /** need to overwrite processDescribe because the params are dynamic */
    53     protected Element processDescribe(Element request) {
    54 
    55     Element response = doc_.createElement(GSXML.RESPONSE_ELEM);
    56     response.setAttribute(GSXML.TYPE_ATT, GSXML.REQUEST_TYPE_DESCRIBE);
    57    
    58     String info = request.getAttribute(GSXML.INFO_ATT);
    59     String to = GSPath.getFirstLink(request.getAttribute(GSXML.TO_ATT));
    60    
    61     if (to.equals("")) { // to="", look at info
    62         if (info.equals(GSXML.SERVICE_ELEM+GSXML.LIST_MODIFIER)) {
    63         response.appendChild(short_service_info_);
    64         return response;
    65         }
    66         // else error in info field
    67         System.err.println("ServicesImpl describe request: error in 'info' field, info='"+info+"'.");
    68         return null;
    69     }
    70 
    71     // describe a particular service
    72    
    73     if (service_info_map_.containsKey(to)) {
    74         Element descript = (Element)service_info_map_.get(to);
    75         // need to add in collection param list
    76         if (!to.equals(NEW_SERVICE)) {
    77         Element param_list = (Element) GSXML.getChildByTagName(descript, GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
    78         Element old_param = GSXML.getNamedElement(param_list, GSXML.PARAM_ELEM, GSXML.NAME_ATT, "collection");
    79         String[] colls = getCollectionList();
    80         Element param = GSXML.createParameter(doc_, "collection", GSXML.PARAM_TYPE_ENUM, null, colls);
     53    // params used
     54    private static final String COL_PARAM = "collection";
     55    private static final String NEW_COL_NAME_PARAM = "collectionName";
     56    private static final String CREATOR_PARAM = "creator";
     57
     58    // the list of the collections - store between some method calls
     59    private String[] collection_list_ = null;
     60
     61    /** returns the service list for the subclass */
     62    protected Element getServiceList(String lang) {
     63    // for now, it is static and there is no lang stuff
     64    return short_service_info_;
     65    }
     66
     67    /** returns a specific service description */
     68    protected Element getServiceDescription(String service, String lang) {
     69    Element descript = (Element)service_info_map_.get(service);
     70    // need to add in collection param list
     71    if (!service.equals(NEW_SERVICE)) {
     72        Element param_list = (Element) GSXML.getChildByTagName(descript, GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
     73        Element old_param = GSXML.getNamedElement(param_list, GSXML.PARAM_ELEM, GSXML.NAME_ATT, COL_PARAM);
     74        collection_list_ = getCollectionList();
     75        Element param = GSXML.createParameter(doc_, COL_PARAM, GSXML.PARAM_TYPE_ENUM_SINGLE, null, collection_list_);
    8176        // put at front of the list
    82         param_list.replaceChild(param, old_param);
    83         }
    84         response.appendChild(descript);
    85         return response;
    86     }
    87     // else error in to field
    88     System.err.println("ServicesImpl describe request: error in 'to' field, to='"+to+"'.");
    89     return null;
    90 
    91     }
     77        param_list.replaceChild(param, old_param);
     78    }
     79    // for now, create it on the fly - look at caching it later
     80    Element display = createServiceDisplay(service, lang);
     81    addServiceDisplay(descript, display);
     82    return descript;
     83   
     84    }
     85
     86    /** creates a display element containing all the text strings needed to display the service page, in the language specified */
     87    protected Element createServiceDisplay(String service, String lang) {
     88    Element display = doc_.createElement(GSXML.DISPLAY_ELEM);
     89    display.appendChild(GSXML.createTextElement(doc_, GSXML.DISPLAY_NAME_ELEM,  getTextString(service+".name", lang)));
     90    display.appendChild(GSXML.createTextElement(doc_,  GSXML.DISPLAY_SUBMIT_ELEM, getTextString(service+".submit", lang)));
     91
     92    Element param;
     93    if (service.equals(NEW_SERVICE)) {
     94        // have the coll name and creator params
     95        param = GSXML.createParameterDisplay(doc_, NEW_COL_NAME_PARAM, getTextString("param."+NEW_COL_NAME_PARAM, lang), null, null);
     96        display.appendChild(param);
     97        param = GSXML.createParameterDisplay(doc_, CREATOR_PARAM, getTextString("param."+CREATOR_PARAM, lang), null, null);
     98        display.appendChild(param);
     99    } else {
     100        // have just the coll param
     101        //use the colleciton list already created - this method is only called directly after getServiceDescription()
     102        param = GSXML.createParameterDisplay(doc_, COL_PARAM, getTextString("param."+COL_PARAM, lang), collection_list_, collection_list_);
     103        display.appendChild(param);
     104    }       
     105
     106    return display;
     107   
     108    }
     109
    92110     /** passes the request Element to the appropriate service function*/
    93111    protected Element processService(String name, Element request) {
    94112
    95     //if (name.equals(NEW_SERVICE)) {
    96     //    return newCollection(request);
    97     //}
    98 
     113    String language = request.getAttribute(GSXML.LANG_ATT);
    99114    // extract the collection out of here
    100115    Element param_list = (Element)GSXML.getChildByTagName(request, GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
    101116    HashMap params = GSXML.extractParams(param_list);
    102     String coll_name = (String)params.get("collection");
     117    String coll_name = (String)params.get(COL_PARAM);
    103118   
    104119    Element response = doc_.createElement(GSXML.RESPONSE_ELEM);
    … …  
    106121    Element status=null;
    107122    if (name.equals(NEW_SERVICE)) {
    108         status = newCollection(coll_name);
     123        status = newCollection(coll_name, language);
    109124    } else if (name.equals(IMPORT_SERVICE)) {
    110         status = importCollection(coll_name);
     125        status = importCollection(coll_name, language);
    111126    } else if (name.equals(BUILD_SERVICE)) {
    112         status = buildCollection(coll_name);
     127        status = buildCollection(coll_name, language);
    113128    } else if (name.equals(ACTIVATE_SERVICE)) {
    114         status = activateCollection(coll_name);
     129        status = activateCollection(coll_name, language);
    115130    } else if (name.equals(DELETE_SERVICE)) {
    116         status = deleteCollection(coll_name);
     131        status = deleteCollection(coll_name, language);
    117132    } else if (name.equals(RELOAD_SERVICE)) {
    118         status = reloadCollection(coll_name);
     133        status = reloadCollection(coll_name, language);
    119134    }
    120135   
    … …  
    179194    Element param_list;
    180195    Element param;
     196
     197    String lang = Locale.US.toString();
     198   
    181199    // should have full details about each service incl params lists etc.
    182 
    183200    e = doc_.createElement(GSXML.SERVICE_ELEM);
    184201    e.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_BUILD);
    185202    e.setAttribute(GSXML.NAME_ATT, NEW_SERVICE);
    186203    param_list = doc_.createElement(GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
    187     param = GSXML.createParameter(doc_, "collectionName", GSXML.PARAM_TYPE_INPUT, "", null);
    188     param_list.appendChild(param);
    189     param = GSXML.createParameter(doc_, "creator", GSXML.PARAM_TYPE_INPUT, "", null);
     204    param = GSXML.createParameter(doc_, NEW_COL_NAME_PARAM, GSXML.PARAM_TYPE_STRING, "", null);
     205    param_list.appendChild(param);
     206    param = GSXML.createParameter(doc_, CREATOR_PARAM, GSXML.PARAM_TYPE_STRING, "", null);
    190207    param_list.appendChild(param);
    191208    e.appendChild(param_list);
    … …  
    196213    e.setAttribute(GSXML.NAME_ATT, IMPORT_SERVICE);
    197214    param_list = doc_.createElement(GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
    198     param = GSXML.createParameter(doc_, "collection", GSXML.PARAM_TYPE_ENUM, "", null);
     215    param = GSXML.createParameter(doc_, COL_PARAM, GSXML.PARAM_TYPE_ENUM_SINGLE, "", null);
    199216    param_list.appendChild(param);
    200217    e.appendChild(param_list);
    … …  
    205222    e.setAttribute(GSXML.NAME_ATT, BUILD_SERVICE);
    206223    param_list = doc_.createElement(GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
    207     param = GSXML.createParameter(doc_, "collection", GSXML.PARAM_TYPE_ENUM, "", null);
     224    param = GSXML.createParameter(doc_, COL_PARAM, GSXML.PARAM_TYPE_ENUM_SINGLE, "", null);
    208225    param_list.appendChild(param);
    209226    e.appendChild(param_list);
    … …  
    214231    e.setAttribute(GSXML.NAME_ATT, ACTIVATE_SERVICE);
    215232    param_list = doc_.createElement(GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
    216     param = GSXML.createParameter(doc_, "collection", GSXML.PARAM_TYPE_ENUM, "", null);
     233    param = GSXML.createParameter(doc_, COL_PARAM, GSXML.PARAM_TYPE_ENUM_SINGLE, "", null);
    217234    param_list.appendChild(param);
    218235    e.appendChild(param_list);
    … …  
    223240    e.setAttribute(GSXML.NAME_ATT, DELETE_SERVICE);
    224241    param_list = doc_.createElement(GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
    225     param = GSXML.createParameter(doc_, "collection", GSXML.PARAM_TYPE_ENUM, "", null);
     242    param = GSXML.createParameter(doc_, COL_PARAM, GSXML.PARAM_TYPE_ENUM_SINGLE, "", null);
    226243    param_list.appendChild(param);
    227244    e.appendChild(param_list);
    … …  
    232249    e.setAttribute(GSXML.NAME_ATT, RELOAD_SERVICE);
    233250    param_list = doc_.createElement(GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
    234     param = GSXML.createParameter(doc_, "collection", GSXML.PARAM_TYPE_ENUM, "", null);
     251    param = GSXML.createParameter(doc_, COL_PARAM, GSXML.PARAM_TYPE_ENUM_SINGLE, "", null);
    235252    param_list.appendChild(param);
    236253    e.appendChild(param_list);
    … …  
    242259
    243260    /** creates a new collection using mkcol.pl */
    244     protected Element newCollection(String coll_name) {
     261    protected Element newCollection(String coll_name, String lang) {
    245262    Element status = doc_.createElement(GSXML.STATUS_ELEM);
    246263    Text t = doc_.createTextNode("trying to create new coll:"+coll_name);
    … …  
    250267   
    251268    /** imports a collection using import.pl */
    252     protected Element importCollection(String coll_name) {
     269    protected Element importCollection(String coll_name, String lang) {
    253270    Element status = doc_.createElement(GSXML.STATUS_ELEM);
    254271    Text t = doc_.createTextNode("trying to import coll:"+coll_name);
    … …  
    257274    }   
    258275    /** builds a collection using buildcol.pl */
    259     protected Element buildCollection(String coll_name) {
     276    protected Element buildCollection(String coll_name, String lang) {
    260277    Element status = doc_.createElement(GSXML.STATUS_ELEM);
    261278    Text t = doc_.createTextNode("trying to build coll:"+coll_name);
    … …  
    263280    return status;
    264281    }   
    265     protected Element reloadCollection(String coll_name) {
     282    protected Element reloadCollection(String coll_name, String lang) {
    266283    Element status = doc_.createElement(GSXML.STATUS_ELEM);
    267284   
    … …  
    277294    request.appendChild(command);
    278295    Element response = router_.process(message); // at the moment, get no info in response so ignore it
     296
     297    String[] args={coll_name};
     298
    279299    if (response == null) {
    280         Text t = doc_.createTextNode("couldn't activate "+coll_name+" in the messagerouter");
     300        Text t = doc_.createTextNode(getTextString("reload.activate_error", args , lang));
    281301        status.appendChild(t);
    282302        return status;
    283303    }
    284304    // if we got here, we have succeeded!
    285     Text t = doc_.createTextNode("collection "+coll_name+ " activated!");
     305    Text t = doc_.createTextNode(getTextString("reload.success", args, lang));
    286306    status.appendChild(t);
    287307    return status; 
    … …  
    291311     * also instructs the MR to activate this new/modified collection
    292312     * fails if no valid building directory */
    293     protected Element activateCollection(String coll_name) {
     313    protected Element activateCollection(String coll_name, String lang) {
    294314    // the return element
    295315    Element status = doc_.createElement(GSXML.STATUS_ELEM);
     316    String[] args={coll_name};
    296317
    297318    // check that we have buildcfg.xml in the building directory
    298319    File coll_build_dir = new File(GSFile.collectionBuildDir(site_home_, coll_name));
    299320    if (!coll_build_dir.exists()) {
    300         Text t = doc_.createTextNode("collection:"+coll_name+" has no building directory");
     321        Text t = doc_.createTextNode(getTextString("activate.build_dir_error", args, lang));
    301322        status.appendChild(t);
    302323        return status;
    … …  
    304325    File coll_build_file = new File(GSFile.collectionBuildConfigFileBuilding(site_home_, coll_name));
    305326    if (!coll_build_file.exists()) {
    306         Text t = doc_.createTextNode("collection:"+coll_name+" has no build config file");
     327        Text t = doc_.createTextNode(getTextString("activate.build_config_error", args, lang));
    307328        status.appendChild(t);
    308329        return status;
    … …  
    314335        // remove it
    315336        if (!GSFile.deleteFile(coll_index_dir)) {
    316         Text t = doc_.createTextNode("couldn't remove old index dir");
     337        Text t = doc_.createTextNode(getTextString("activate.rm_index_error", args, lang));
    317338        status.appendChild(t);
    318339        return status;
    … …  
    322343    // copy building to index
    323344    if (!GSFile.moveDirectory(coll_build_dir, coll_index_dir)) {
    324         Text t = doc_.createTextNode("couldn't copy building to index");
     345        Text t = doc_.createTextNode(getTextString("activate.rename_building_error", args, lang));
    325346        status.appendChild(t);
    326347        return status;
    … …  
    328349   
    329350    // now have to tell the message router
    330     return reloadCollection(coll_name);
     351    return reloadCollection(coll_name, lang);
    331352
    332353    }
    333354    /** deletes a collection - removes the whole directory
    334355     * also instructs the MR to deactivate this  collection*/
    335     protected Element deleteCollection(String coll_name) {
    336     Element status = doc_.createElement(GSXML.STATUS_ELEM);
    337    
     356    protected Element deleteCollection(String coll_name, String lang) {
     357    Element status = doc_.createElement(GSXML.STATUS_ELEM);
     358   
     359    String[] args={coll_name};
    338360    File coll_dir = new File(GSFile.collectionBaseDir(site_home_, coll_name));
    339361    if (coll_dir.exists()) {
    340362        if (!GSFile.deleteFile(coll_dir)) {
    341         Text t = doc_.createTextNode("couldn't delete coll:"+coll_name);
     363        Text t = doc_.createTextNode(getTextString("delete.delete_error", args, lang));
    342364        status.appendChild(t);
    343365        return status;
    … …  
    358380        Element response = router_.process(message); // at the moment, get no info in response so ignore it
    359381        if (response == null) {
    360         Text t = doc_.createTextNode("couldn't deactivate "+coll_name+" in the messagerouter");
     382        Text t = doc_.createTextNode(getTextString("delete.deactivate_error", args, lang));
    361383        status.appendChild(t);
    362384        return status;
    … …  
    365387    // success   
    366388       
    367     Text t = doc_.createTextNode("coll:"+coll_name+" deleted");
     389    Text t = doc_.createTextNode(getTextString("delete.success", args, lang));
    368390    status.appendChild(t);
    369391    return status;
    … …  
    402424   
    403425    }
     426   
     427
    404428}

  • trunk/gsdl3/src/java/org/greenstone/gsdl3/service/PhindServices.java

    r3512 r3567  
    9292    }
    9393
     94    /** creates a display element containing all the text strings needed to display the service page, in the language specified */
     95    protected Element createServiceDisplay(String service, String lang) {
     96    Element display = doc_.createElement(GSXML.DISPLAY_ELEM);
     97    display.appendChild(GSXML.createTextElement(doc_, GSXML.DISPLAY_NAME_ELEM,  getTextString(service+".name", lang)));
     98    display.appendChild(GSXML.createTextElement(doc_,  GSXML.DISPLAY_SUBMIT_ELEM, getTextString(service+".submit", lang)));
     99
     100    Element param;
     101
     102    return display;
     103   
     104    }
     105
    94106    protected Element processService(String name, Element request) {
    95107   

  • trunk/gsdl3/src/java/org/greenstone/gsdl3/service/ServicesImpl.java

    r3512 r3567  
    3838import java.util.HashMap;
    3939
     40import java.util.ResourceBundle;
     41import java.util.Locale;
     42
    4043/**
    4144 * ServicesImpl - abstract base class
    … …  
    159162       
    160163        } else {
    161 
    162         String to = GSPath.getFirstLink(request.getAttribute(GSXML.TO_ATT));
    163        
    164164        // other type of request, must be processed by the subclass -
    165165        // send to the service method
     166
     167        String to = GSPath.getFirstLink(request.getAttribute(GSXML.TO_ATT));       
    166168        if (service_info_map_.containsKey(to)) {
    167169            Element response = processService(to, request);
    … …  
    176178        }
    177179    } // for each request
    178     System.out.println("servicesImpl returning result");
    179     System.out.println(converter_.getString(mainResult));
    180180
    181181    return mainResult;
    182    
    183    
    184     }
    185 
    186     /** process method for describe requests - is implemented here for services
    187      * whose descriptions are static - those services whose params may change dynamically should overwrite this method
     182       
     183    }
     184
     185    /** process method for describe requests
    188186     */
    189187    protected Element processDescribe(Element request) {
    … …  
    192190    response.setAttribute(GSXML.TYPE_ATT, GSXML.REQUEST_TYPE_DESCRIBE);
    193191   
     192    String lang = request.getAttribute(GSXML.LANG_ATT);
    194193    String info = request.getAttribute(GSXML.INFO_ATT);
    195194    String to = GSPath.getFirstLink(request.getAttribute(GSXML.TO_ATT));
    … …  
    197196    if (to.equals("")) { // to="", look at info
    198197        if (info.equals(GSXML.SERVICE_ELEM+GSXML.LIST_MODIFIER)) {
    199         response.appendChild(short_service_info_);
     198        //response.appendChild(short_service_info_);
     199        response.appendChild(getServiceList(lang));
    200200        return response;
    201201        }
    … …  
    208208   
    209209    if (service_info_map_.containsKey(to)) {
    210         response.appendChild((Element)service_info_map_.get(to));
     210        response.appendChild(getServiceDescription(to, lang));//(Element)service_info_map_.get(to));
    211211        return response;
    212212    }
    … …  
    224224    abstract protected Element processService(String service, Element request);
    225225
    226 
     226    // the following two should be overwritten for info with any language stuff in it
     227    /** returns the service list for the subclass */
     228    protected Element getServiceList(String lang) {
     229    // for now, it is static and there is no lang stuff
     230    return short_service_info_;
     231    }
     232
     233    /** returns a specific service description */
     234    protected Element getServiceDescription(String service, String lang) {
     235    Element descript = (Element)((Element)service_info_map_.get(service)).cloneNode(true);
     236    // for now, create it on the fly - look at caching it later
     237    Element display = createServiceDisplay(service, lang);
     238    addServiceDisplay(descript, display);
     239    return descript;
     240    }
     241   
     242    /** adds the display element into the description - appends to the root for now, but may do something fancy later */
     243    protected boolean addServiceDisplay(Element descript, Element display) {
     244    if (descript.getOwnerDocument() != display.getOwnerDocument()) {
     245        display = (Element)descript.getOwnerDocument().importNode(display, true);
     246    }
     247    descript.appendChild(display);
     248    return true;
     249    }
     250    /** creates a display element containing all the text strings needed to display the service page, in the language specified */
     251    abstract protected Element createServiceDisplay(String service, String lang);
     252    /** overloaded version for no args case */
     253    protected String getTextString(String key, String lang) {
     254    return getTextString(key, null, lang);
     255    }
     256    /** getTextString - retrieves a language specific text string for the given
     257key and locale
     258    */
     259    protected String getTextString(String key, String[] args,  String lang) {
     260
     261    String class_name = getClass().getName();
     262    System.out.println("class name found="+class_name);
     263    class_name = class_name.substring(class_name.lastIndexOf('.')+1);
     264    System.out.println("class name altered="+class_name);
     265   
     266    Dictionary dict = new Dictionary(class_name, lang);
     267    String result = dict.get(key, args);
     268    if (result == null) { // not found
     269        return "_"+key+"_";
     270    }
     271    return result;
     272    }
    227273}
Note: See TracChangeset for help on using the changeset viewer.