public Harvester(Logger log, ServiceContext context, Dbms dbms, Z3950Params params) {
   GeonetContext gc = (GeonetContext) context.getHandlerContext(Geonet.CONTEXT_NAME);
   this.context = context;
   this.log = log;
   this.searchMan = gc.getSearchmanager();
   this.dataMan = gc.getDataManager();
   this.settingMan = gc.getSettingManager();
   this.context = context;
   this.dbms = dbms;
   this.params = params;
 }
  public Element exec(Element params, ServiceContext context) throws Exception {
    GeonetContext gc = (GeonetContext) context.getHandlerContext(Geonet.CONTEXT_NAME);
    ThesaurusManager thesaurusMan = gc.getThesaurusManager();
    String THESAURUS_DIR = thesaurusMan.getThesauriDirectory();

    Element thesauriList = new Element("thesaurusList");

    String type = Util.getParam(params, Params.TYPE, init_type);

    if (type.equals("all-directories")) {
      listThesauri(
          thesauriList, THESAURUS_DIR + EXTERNAL_DIR, 1, directoryFilter, Geonet.CodeList.EXTERNAL);
      listThesauri(
          thesauriList, THESAURUS_DIR + LOCAL_DIR, 1, directoryFilter, Geonet.CodeList.LOCAL);
    } else if (type.equals("upload-directories")) {
      listThesauri(
          thesauriList, THESAURUS_DIR + EXTERNAL_DIR, 1, directoryFilter, Geonet.CodeList.EXTERNAL);
    } else if (type.equals("all-thesauri")) {
      listThesauri(
          thesauriList, THESAURUS_DIR + EXTERNAL_DIR, 2, thesauriFilter, Geonet.CodeList.EXTERNAL);
      listThesauri(
          thesauriList, THESAURUS_DIR + LOCAL_DIR, 2, thesauriFilter, Geonet.CodeList.LOCAL);
    } else if (type.equals("update-thesauri")) {
      listThesauri(
          thesauriList, THESAURUS_DIR + LOCAL_DIR, 3, thesauriFilter, Geonet.CodeList.LOCAL);
    } else {
      listThesauri(
          thesauriList, THESAURUS_DIR + EXTERNAL_DIR, 3, thesauriFilter, Geonet.CodeList.EXTERNAL);
      listThesauri(
          thesauriList, THESAURUS_DIR + LOCAL_DIR, 3, thesauriFilter, Geonet.CodeList.LOCAL);
    }

    // -----------------------------------------------------------------------

    Element elRes = new Element(Jeeves.Elem.RESPONSE).addContent(thesauriList);

    // -----------------------------------------------------------------------

    String selected = Util.getParam(params, Params.SELECTED, "none");
    if (!selected.equals("none")) {
      Element elSelected = new Element("selectedThesaurus");
      elSelected.addContent(selected);
      elRes.addContent(elSelected);
    }
    String mode = Util.getParam(params, "mode", "none");
    if (!mode.equals("none")) {
      Element elMode = new Element("mode");
      elMode.addContent(mode);
      elRes.addContent(elMode);
    }
    // -----------------------------------------------------------------------

    return elRes;
  }
  public Element exec(Element params, ServiceContext context) throws Exception {
    Element response = new Element("response");

    Dbms dbms = (Dbms) context.getResourceManager().open(Geonet.Res.MAIN_DB);

    // --- check access
    GeonetContext gc = (GeonetContext) context.getHandlerContext(Geonet.CONTEXT_NAME);
    DataManager dm = gc.getDataManager();

    boolean addEdit = false;

    // --- the request should contain an ID or UUID
    String id = Utils.getIdentifierFromParameters(params, context);

    if (id == null) {
      throw new MetadataNotFoundEx("No record has this UUID");
    }

    // --- check download access
    Lib.resource.checkPrivilege(context, id, AccessManager.OPER_DOWNLOAD);

    // --- get metadata
    boolean withValidationErrors = false, keepXlinkAttributes = false;
    Element elMd =
        gc.getDataManager()
            .getMetadata(context, id, addEdit, withValidationErrors, keepXlinkAttributes);

    if (elMd == null) throw new MetadataNotFoundEx("Metadata not found - deleted?");

    response.addContent(new Element("id").setText(id));

    // --- transform record into brief version
    String briefXslt = appPath + "xsl/metadata-brief.xsl";
    Element elBrief = Xml.transform(elMd, briefXslt);

    XPath xp;
    List elems;

    // --- process links to a file (have name field not blank)
    // --- if they are a reference to a downloadable local file then get size
    // --- and date modified, if not then set local to false
    xp = XPath.newInstance("link[starts-with(@protocol,'WWW:DOWNLOAD') and @name!='']");
    elems = xp.selectNodes(elBrief);
    response = processDownloadLinks(context, id, dm.getSiteURL(), elems, response);

    // --- now process web links so that they can be displayed as well
    xp = XPath.newInstance("link[starts-with(@protocol,'WWW:LINK')]");
    elems = xp.selectNodes(elBrief);
    response = processWebLinks(elems, response);

    return response;
  }
Exemple #4
0
  public Aligner(Logger log, ServiceContext sc, Dbms dbms, CswServer server, CswParams params)
      throws OperationAbortedEx {
    this.log = log;
    this.context = sc;
    this.dbms = dbms;
    this.params = params;

    GeonetContext gc = (GeonetContext) context.getHandlerContext(Geonet.CONTEXT_NAME);
    dataMan = gc.getDataManager();
    result = new HarvestResult();

    // --- setup get-record-by-id request

    request = new GetRecordByIdRequest(sc);
    request.setElementSetName(ElementSetName.FULL);

    CswOperation oper = server.getOperation(CswServer.GET_RECORD_BY_ID);

    // Use the preferred HTTP method and check one exist.
    if (oper.getUrl != null && Harvester.PREFERRED_HTTP_METHOD.equals("GET")) {
      request.setUrl(oper.getUrl);
      request.setMethod(CatalogRequest.Method.GET);
    } else if (oper.postUrl != null && Harvester.PREFERRED_HTTP_METHOD.equals("POST")) {
      request.setUrl(oper.postUrl);
      request.setMethod(CatalogRequest.Method.POST);
    } else {
      if (oper.getUrl != null) {
        request.setUrl(oper.getUrl);
        request.setMethod(CatalogRequest.Method.GET);
      } else if (oper.postUrl != null) {
        request.setUrl(oper.postUrl);
        request.setMethod(CatalogRequest.Method.POST);
      } else {
        throw new OperationAbortedEx("No GET or POST DCP available in this service.");
      }
    }

    if (oper.preferredOutputSchema != null) {
      request.setOutputSchema(oper.preferredOutputSchema);
    }

    if (oper.preferredServerVersion != null) {
      request.setServerVersion(oper.preferredServerVersion);
    }

    if (params.useAccount) {
      request.setCredentials(params.username, params.password);
    }
  }
  /**
   * Get Feature Catalog ID if exists using relation table.
   *
   * @param context
   * @param metadataId Metadata record id to search for feature catalogue for.
   * @return String Feature catalogue uuid.
   * @throws Exception
   */
  private static String getFeatureCatalogID(ServiceContext context, int metadataId)
      throws Exception {
    GeonetContext gc = (GeonetContext) context.getHandlerContext(Geonet.CONTEXT_NAME);
    DataManager dm = gc.getBean(DataManager.class);

    List<MetadataRelation> relations =
        context.getBean(MetadataRelationRepository.class).findAllById_MetadataId(metadataId);

    if (relations.isEmpty()) {
      return "";
    }

    // Assume only one feature catalogue is available for a metadata record.
    int ftId = relations.get(0).getId().getRelatedId();

    String ftUuid = dm.getMetadataUuid("" + ftId);

    return ftUuid != null ? ftUuid : "";
  }
  public GNResultSet(GNXMLQuery query, Object userInfo, Observer[] observers, ServiceContext srvctx)
      throws Exception {
    super(observers);
    this.query = query;
    this.srvxtx = srvctx;

    try {

      GeonetContext gc = (GeonetContext) this.srvxtx.getHandlerContext(Geonet.CONTEXT_NAME);
      SearchManager searchMan = gc.getBean(SearchManager.class);

      metasearcher = searchMan.newSearcher(SearchManager.LUCENE, Geonet.File.SEARCH_Z3950_SERVER);

    } catch (Exception e) {
      if (Log.isDebugEnabled(Geonet.Z3950_SERVER))
        Log.debug(Geonet.Z3950_SERVER, "error constructing GNresult set: " + e);
      e.printStackTrace();
    }
  }
  public Element serviceSpecificExec(Element params, ServiceContext context) throws Exception {
    String parentUuid = Util.getParam(params, "parentUuid");
    String childrenIds = Util.getParam(params, "childrenIds");

    // Transform params element into Map<String, String> for xsl transformation
    @SuppressWarnings("unchecked")
    List<Element> lstParams = params.getChildren();
    Map<String, String> parameters = new HashMap<String, String>();
    for (Element param : lstParams) {
      parameters.put(param.getName(), param.getTextTrim());
    }

    // Handle children IDs.
    String[] children = childrenIds.split(",");

    // Update children
    GeonetContext gc = (GeonetContext) context.getHandlerContext(Geonet.CONTEXT_NAME);
    DataManager dm = gc.getDataManager();

    Set<String> untreatedChildren = dm.updateChildren(context, parentUuid, children, parameters);

    Element response = new Element(Jeeves.Elem.RESPONSE);
    int treatedChildren = children.length;
    StringBuilder untreatedReport = new StringBuilder();
    if (untreatedChildren.size() != 0) {
      treatedChildren = children.length - untreatedChildren.size();
      untreatedReport.setLength(0);
      untreatedReport.append(untreatedChildren.size()).append(" child/children not updated");
      for (String id : untreatedChildren) untreatedReport.append(", ").append(id);
    }

    String report =
        treatedChildren
            + " child/children updated for metadata "
            + parentUuid
            + ". "
            + untreatedReport;

    return response.setText(report);
  }
  public Element serviceSpecificExec(Element params, ServiceContext context) throws Exception {
    GeonetContext gc = (GeonetContext) context.getHandlerContext(Geonet.CONTEXT_NAME);
    DataManager dataMan = gc.getBean(DataManager.class);
    AccessManager accessMan = gc.getBean(AccessManager.class);

    Dbms dbms = (Dbms) context.getResourceManager().open(Geonet.Res.MAIN_DB);

    String id = Utils.getIdentifierFromParameters(params, context);

    // -----------------------------------------------------------------------
    // --- check access

    MdInfo info = dataMan.getMetadataInfo(dbms, id);

    if (info == null) throw new IllegalArgumentException("Metadata not found --> " + id);

    if (!accessMan.canEdit(context, id)) throw new OperationNotAllowedEx();

    // -----------------------------------------------------------------------
    // --- backup metadata in 'removed' folder

    if (info.template != MdInfo.Template.SUBTEMPLATE)
      backupFile(
          context, id, info.uuid, MEFLib.doExport(context, info.uuid, "full", false, true, false));

    // -----------------------------------------------------------------------
    // --- remove the metadata directory including the public and private directories.
    File pb = new File(Lib.resource.getMetadataDir(context, id));
    FileCopyMgr.removeDirectoryOrFile(pb);

    // -----------------------------------------------------------------------
    // --- delete metadata and return status

    dataMan.deleteMetadata(context, dbms, id);

    Element elResp = new Element(Jeeves.Elem.RESPONSE);
    elResp.addContent(new Element(Geonet.Elem.ID).setText(id));

    return elResp;
  }
  public Aligner(
      Logger log,
      ServiceContext context,
      Dbms dbms,
      XmlRequest req,
      GeonetParams params,
      Element remoteInfo) {
    this.log = log;
    this.context = context;
    this.dbms = dbms;
    this.request = req;
    this.params = params;

    GeonetContext gc = (GeonetContext) context.getHandlerContext(Geonet.CONTEXT_NAME);
    dataMan = gc.getDataManager();
    result = new GeonetResult();

    // --- save remote categories and groups into hashmaps for a fast access

    List list = remoteInfo.getChild("groups").getChildren("group");
    setupLocEntity(list, hmRemoteGroups);
  }
  public Element exec(Element params, ServiceContext context) throws Exception {

    GeonetContext gc = (GeonetContext) context.getHandlerContext(Geonet.CONTEXT_NAME);
    SchemaManager scm = gc.getBean(SchemaManager.class);

    String schema = Util.getParam(params, Params.SCHEMA);
    String urlStr, uuid, fname;
    uuid = "";
    URL url = null;

    // -- try the file name argument then the url then the uuid of a metadata
    // -- record to which a schema is attached
    fname = Util.getParam(params, Params.FNAME, "");
    if ("".equals(fname)) {
      urlStr = Util.getParam(params, Params.URL, "");
      if ("".equals(urlStr)) {
        uuid = Util.getParam(params, Params.UUID, "");
        if ("".equals(uuid)) {
          throw new IllegalArgumentException("One of fname, url or uuid must be supplied");
        }
      } else {
        try {
          url = new URL(urlStr);
        } catch (MalformedURLException mu) {
          throw new OperationAbortedEx("URL " + urlStr + " is malformed: " + mu.getMessage());
        }
      }
    }

    // -- test if schema to be updated exists, if not then chuck a fit and exit
    if (!scm.existsSchema(schema)) {
      throw new OperationAbortedEx("Schema doesn't exist");
    }

    SchemaUtils su = new SchemaUtils();
    return su.updateSchema(context, schema, fname, url, uuid, scm);
  }
  /**
   * @param request
   * @param context
   * @return
   * @throws Exception
   */
  private int deleteTransaction(Element request, ServiceContext context) throws Exception {
    int deleted = 0;

    GeonetContext gc = (GeonetContext) context.getHandlerContext(Geonet.CONTEXT_NAME);
    DataManager dataMan = gc.getDataManager();

    if (context.getUserSession().getUserId() == null)
      throw new NoApplicableCodeEx("User not authenticated.");

    // first, search the record in the database to get the record id
    Element constr = request.getChild("Constraint", Csw.NAMESPACE_CSW);
    List<Element> results = getResultsFromConstraints(context, constr);

    // second, delete the metadata in the dbms using the id
    Iterator<Element> i = results.iterator();
    if (!i.hasNext()) return deleted;

    Dbms dbms = (Dbms) context.getResourceManager().open(Geonet.Res.MAIN_DB);

    // delete all matching records
    while (i.hasNext()) {
      Element result = i.next();
      String uuid = result.getChildText("identifier", Csw.NAMESPACE_DC);
      String id = dataMan.getMetadataId(dbms, uuid);

      if (id == null) return deleted;

      if (!dataMan.getAccessManager().canEdit(context, id))
        throw new NoApplicableCodeEx("User not allowed to delete metadata : " + id);

      dataMan.deleteMetadata(context, dbms, id);
      deleted++;
    }

    return deleted;
  }
Exemple #12
0
  public Element serviceSpecificExec(Element params, ServiceContext context) throws Exception {

    GeonetContext gc = (GeonetContext) context.getHandlerContext(Geonet.CONTEXT_NAME);
    DataManager dataMan = gc.getDataManager();

    Dbms dbms = (Dbms) context.getResourceManager().open(Geonet.Res.MAIN_DB);

    UserSession session = context.getUserSession();

    String id = Utils.getIdentifierFromParameters(params, context);

    // --- validate metadata from session
    Element errorReport =
        new AjaxEditUtils(context)
            .validateMetadataEmbedded(session, dbms, id, context.getLanguage());

    // --- update element and return status
    Element elResp = new Element(Jeeves.Elem.RESPONSE);
    elResp.addContent(new Element(Geonet.Elem.ID).setText(id));
    elResp.addContent(new Element("schema").setText(dataMan.getMetadataSchema(dbms, id)));
    elResp.addContent(errorReport);

    return elResp;
  }
  private String getSiteId() {
    GeonetContext gc = (GeonetContext) context.getHandlerContext(Geonet.CONTEXT_NAME);
    SettingManager sm = gc.getBean(SettingManager.class);

    return sm.getValue("system/site/siteId");
  }
  public Element exec(Element params, ServiceContext context) throws Exception {
    GeonetContext gc = (GeonetContext) context.getHandlerContext(Geonet.CONTEXT_NAME);
    DataManager dm = gc.getDataManager();
    AccessManager am = gc.getAccessManager();

    Dbms dbms = (Dbms) context.getResourceManager().open(Geonet.Res.MAIN_DB);

    String id = Utils.getIdentifierFromParameters(params, context);

    // -----------------------------------------------------------------------
    // --- check access

    MdInfo info = dm.getMetadataInfo(dbms, id);

    if (info == null) throw new MetadataNotFoundEx(id);

    Element ownerId = new Element("ownerid").setText(info.owner);
    Element hasOwner = new Element("owner");
    if (am.isOwner(context, id)) hasOwner.setText("true");
    else hasOwner.setText("false");

    // --- get all operations

    Element elOper = Lib.local.retrieve(dbms, "Operations").setName(Geonet.Elem.OPERATIONS);

    // -----------------------------------------------------------------------
    // --- retrieve groups operations

    Set<String> userGroups =
        am.getUserGroups(dbms, context.getUserSession(), context.getIpAddress());

    Element elGroup = Lib.local.retrieve(dbms, "Groups");

    List list = elGroup.getChildren();

    for (int i = 0; i < list.size(); i++) {
      Element el = (Element) list.get(i);

      el.setName(Geonet.Elem.GROUP);

      // --- get all operations that this group can do on given metadata

      String sGrpId = el.getChildText("id");

      el.setAttribute("userGroup", userGroups.contains(sGrpId) ? "true" : "false");

      String query = "SELECT operationId FROM OperationAllowed WHERE metadataId=? AND groupId=?";

      List listAllow = dbms.select(query, id, sGrpId).getChildren();

      // --- now extend the group list adding proper operations

      List listOper = elOper.getChildren();

      for (int j = 0; j < listOper.size(); j++) {
        String operId = ((Element) listOper.get(j)).getChildText("id");
        Element elGrpOper =
            new Element(Geonet.Elem.OPER).addContent(new Element(Geonet.Elem.ID).setText(operId));
        boolean bFound = false;

        for (int k = 0; k < listAllow.size(); k++) {
          Element elAllow = (Element) listAllow.get(k);

          if (operId.equals(elAllow.getChildText("operationid"))) {
            bFound = true;
            break;
          }
        }
        if (bFound) elGrpOper.addContent(new Element(Geonet.Elem.ON));

        el.addContent(elGrpOper);
      }
    }

    // -----------------------------------------------------------------------
    // --- put all together

    Element elRes =
        new Element(Jeeves.Elem.RESPONSE)
            .addContent(new Element(Geonet.Elem.ID).setText(id))
            .addContent(elOper)
            .addContent(elGroup)
            .addContent(ownerId)
            .addContent(hasOwner);

    return elRes;
  }
  public Element exec(Element params, ServiceContext context) throws Exception {
    GeonetContext gc = (GeonetContext) context.getHandlerContext(Geonet.CONTEXT_NAME);

    return gc.getBean(DataManager.class).getKeywords();
  }
  public Element serviceSpecificExec(Element params, ServiceContext context) throws Exception {
    AjaxEditUtils ajaxEditUtils = new AjaxEditUtils(context);
    ajaxEditUtils.preprocessUpdate(params, context);

    GeonetContext gc = (GeonetContext) context.getHandlerContext(Geonet.CONTEXT_NAME);
    DataManager dataMan = gc.getBean(DataManager.class);
    UserSession session = context.getUserSession();

    Dbms dbms = (Dbms) context.getResourceManager().open(Geonet.Res.MAIN_DB);

    String id = Utils.getIdentifierFromParameters(params, context);
    String isTemplate = Util.getParam(params, Params.TEMPLATE, "n");
    String showValidationErrors = Util.getParam(params, Params.SHOWVALIDATIONERRORS, "false");
    String title = params.getChildText(Params.TITLE);
    String data = params.getChildText(Params.DATA);
    String minor = Util.getParam(params, Params.MINOREDIT, "false");

    boolean finished = config.getValue(Params.FINISHED, "no").equals("yes");
    boolean forget = config.getValue(Params.FORGET, "no").equals("yes");

    if (!forget) {
      int iLocalId = Integer.parseInt(id);
      dataMan.setTemplateExt(dbms, iLocalId, isTemplate, title);

      // --- use StatusActionsFactory and StatusActions class to possibly
      // --- change status as a result of this edit (use onEdit method)
      StatusActionsFactory saf = new StatusActionsFactory(gc.getStatusActionsClass());
      StatusActions sa = saf.createStatusActions(context, dbms);
      saf.onEdit(sa, iLocalId, minor.equals("true"));

      if (data != null) {
        Element md = Xml.loadString(data, false);

        String changeDate = null;
        boolean validate = showValidationErrors.equals("true");
        boolean updateDateStamp = !minor.equals("true");
        boolean ufo = true;
        boolean index = true;
        if (!dataMan.updateMetadata(
            context,
            dbms,
            id,
            md,
            validate,
            ufo,
            index,
            context.getLanguage(),
            changeDate,
            updateDateStamp)) {
          throw new ConcurrentUpdateEx(id);
        }
      } else {
        ajaxEditUtils.updateContent(params, false, true);
      }
    }

    // -----------------------------------------------------------------------
    // --- update element and return status

    Element elResp = new Element(Jeeves.Elem.RESPONSE);
    elResp.addContent(new Element(Geonet.Elem.ID).setText(id));
    elResp.addContent(new Element(Geonet.Elem.SHOWVALIDATIONERRORS).setText(showValidationErrors));
    boolean justCreated = Util.getParam(params, Params.JUST_CREATED, null) != null;
    if (justCreated) {
      elResp.addContent(new Element(Geonet.Elem.JUSTCREATED).setText("true"));
    }
    elResp.addContent(new Element(Params.MINOREDIT).setText(minor));

    // --- if finished then remove the XML from the session
    if (finished) {
      ajaxEditUtils.removeMetadataEmbedded(session, id);
    }

    return elResp;
  }
  /**
   * @param request
   * @param xml
   * @param context
   * @param toIndex
   * @return
   * @throws Exception
   */
  private int updateTransaction(
      Element request, Element xml, ServiceContext context, Set<String> toIndex) throws Exception {
    GeonetContext gc = (GeonetContext) context.getHandlerContext(Geonet.CONTEXT_NAME);
    DataManager dataMan = gc.getDataManager();

    if (context.getUserSession().getUserId() == null)
      throw new NoApplicableCodeEx("User not authenticated.");

    int totalUpdated = 0;

    // Update full metadata
    if (xml != null) {

      // Retrieve schema and the related Namespaces
      String schemaId = gc.getSchemamanager().autodetectSchema(xml);

      if (schemaId == null) {
        throw new NoApplicableCodeEx("Can't identify metadata schema");
      }

      // Retrieve the metadata identifier
      Dbms dbms = (Dbms) context.getResourceManager().open(Geonet.Res.MAIN_DB);

      String uuid = gc.getDataManager().extractUUID(schemaId, xml);

      if (uuid.length() == 0) {
        throw new NoApplicableCodeEx("Metadata identifier not provided");
      }

      // Update metadata record
      String id = dataMan.getMetadataId(dbms, uuid);

      if (id == null) return totalUpdated;

      if (!gc.getAccessManager().canEdit(context, id))
        throw new NoApplicableCodeEx("User not allowed to update this metadata(" + id + ").");

      String changeDate = null;

      boolean validate = false;
      boolean ufo = false;
      boolean index = false;
      String language = context.getLanguage();
      dataMan.updateMetadata(
          context, dbms, id, xml, validate, ufo, index, language, changeDate, false);

      dbms.commit();
      toIndex.add(id);

      totalUpdated++;

      return totalUpdated;

      // Update properties
    } else {
      // first, search the record in the database to get the record id
      Element constr = (Element) request.getChild("Constraint", Csw.NAMESPACE_CSW).clone();
      List<Element> results = getResultsFromConstraints(context, constr);

      List<Element> recordProperties =
          (List<Element>) request.getChildren("RecordProperty", Csw.NAMESPACE_CSW);

      Iterator<Element> it = results.iterator();
      if (!it.hasNext()) return totalUpdated;

      Dbms dbms = (Dbms) context.getResourceManager().open(Geonet.Res.MAIN_DB);

      Set updatedMd = new HashSet<String>();
      // Process all records selected
      while (it.hasNext()) {
        Element result = it.next();
        String uuid = result.getChildText("identifier", Csw.NAMESPACE_DC);
        String id = dataMan.getMetadataId(dbms, uuid);
        String changeDate = null;

        if (id == null) continue;

        if (!dataMan.getAccessManager().canEdit(context, id))
          throw new NoApplicableCodeEx("User not allowed to update this metadata(" + id + ").");

        Element metadata = dataMan.getMetadata(context, id, false, false, true);
        metadata.removeChild("info", Edit.NAMESPACE);

        // Retrieve the schema and Namespaces of metadata to update
        String schemaId = gc.getDataManager().autodetectSchema(metadata);

        if (schemaId == null) {
          throw new NoApplicableCodeEx("Can't identify metadata schema");
        }

        Map mapNs = retrieveNamepacesForSchema(gc.getDataManager().getSchema(schemaId));

        boolean metadataChanged = false;

        // Process properties to update
        for (Element recordProperty : recordProperties) {
          Element propertyNameEl = recordProperty.getChild("Name", Csw.NAMESPACE_CSW);
          Element propertyValueEl = recordProperty.getChild("Value", Csw.NAMESPACE_CSW);

          String propertyName = propertyNameEl.getText();

          String propertyValue = propertyValueEl.getText();

          // Get XPath for queriable name, i provided in propertyName.
          // Otherwise assume propertyName contains full XPath to property to update
          String xpathProperty = FieldMapper.mapXPath(propertyName, schemaId);
          if (xpathProperty == null) {
            xpathProperty = propertyName;
          }

          Log.info(Geonet.CSW, "Xpath of property: " + xpathProperty);
          XPath xpath = new JDOMXPath(xpathProperty);
          xpath.setNamespaceContext(new SimpleNamespaceContext(mapNs));

          Object propEl = xpath.selectSingleNode(metadata);
          Log.info(Geonet.CSW, "XPath found in metadata: " + (propEl != null));

          // If a property is not found in metadata, just ignore it.
          if (propEl != null) {
            if (propEl instanceof Element) {
              ((Element) propEl).setText(propertyValue);
              metadataChanged = true;

            } else if (propEl instanceof Attribute) {
              ((Attribute) propEl).setValue(propertyValue);
              metadataChanged = true;
            }
          }
        } // for(Element recordProperty : recordProperties)

        // Update the metadata with changes
        if (metadataChanged) {
          boolean validate = false;
          boolean ufo = false;
          boolean index = false;
          String language = context.getLanguage();
          dataMan.updateMetadata(
              context, dbms, id, metadata, validate, ufo, index, language, changeDate, false);

          updatedMd.add(id);

          totalUpdated++;
        }
      }
      dbms.commit();
      toIndex.addAll(updatedMd);

      return totalUpdated;
    }
  }
  /**
   * @param xml
   * @param fileIds
   * @param context
   * @param toIndex
   * @return
   * @throws Exception
   */
  private boolean insertTransaction(
      Element xml, List<String> fileIds, ServiceContext context, Set<String> toIndex)
      throws Exception {
    GeonetContext gc = (GeonetContext) context.getHandlerContext(Geonet.CONTEXT_NAME);
    DataManager dataMan = gc.getDataManager();

    String schema = dataMan.autodetectSchema(xml);

    //		String category   = Util.getParam(request, Params.CATEGORY);
    String category = null, source = null, createDate = null, changeDate = null;

    String uuid;
    uuid = dataMan.extractUUID(schema, xml);
    if (uuid.length() == 0) uuid = UUID.randomUUID().toString();

    // -----------------------------------------------------------------------
    // --- insert metadata into the system

    UserSession us = context.getUserSession();

    if (us.getUserId() == null) throw new NoApplicableCodeEx("User not authenticated.");

    String profile = us.getProfile();

    // Only editors and above are allowed to insert metadata
    if (!profile.equals(Geonet.Profile.EDITOR)
        && !profile.equals(Geonet.Profile.REVIEWER)
        && !profile.equals(Geonet.Profile.USER_ADMIN)
        && !profile.equals(Geonet.Profile.ADMINISTRATOR))
      throw new NoApplicableCodeEx("User not allowed to insert metadata.");

    int userId = us.getUserIdAsInt();

    AccessManager am = gc.getAccessManager();
    Dbms dbms = (Dbms) context.getResourceManager().open(Geonet.Res.MAIN_DB);

    // Set default group: user first group
    Set<String> userGroups = am.getVisibleGroups(dbms, userId);
    String group;
    if (userGroups.isEmpty()) {
      group = null;
    } else {
      group = (String) userGroups.iterator().next();
    }
    //
    // insert metadata
    //
    String docType = null, title = null, isTemplate = null;
    boolean ufo = true, indexImmediate = false;
    String id =
        dataMan.insertMetadata(
            context,
            dbms,
            schema,
            xml,
            context.getSerialFactory().getSerial(dbms, "Metadata"),
            uuid,
            userId,
            group,
            source,
            isTemplate,
            docType,
            title,
            category,
            createDate,
            changeDate,
            ufo,
            indexImmediate);

    if (id == null) return false;

    // Set metadata as public if setting enabled
    SettingManager sm = gc.getSettingManager();
    boolean metadataPublic = sm.getValueAsBool("system/csw/metadataPublic", false);

    if (metadataPublic) {
      dataMan.setOperation(context, dbms, id, "1", AccessManager.OPER_VIEW);
    }

    dataMan.indexMetadata(dbms, id);

    fileIds.add(uuid);

    dbms.commit();
    toIndex.add(id);
    return true;
  }
  public GeonetResult align(Set<RecordInfo> records) throws Exception {
    log.info("Start of alignment for : " + params.name);

    // -----------------------------------------------------------------------
    // --- retrieve all local categories and groups
    // --- retrieve harvested uuids for given harvesting node

    localCateg = new CategoryMapper(dbms);
    localGroups = new GroupMapper(dbms);
    localUuids = new UUIDMapper(dbms, params.uuid);
    dbms.commit();

    parseXSLFilter();

    // -----------------------------------------------------------------------
    // --- remove old metadata

    for (String uuid : localUuids.getUUIDs())
      if (!exists(records, uuid)) {
        String id = localUuids.getID(uuid);

        if (log.isDebugEnabled()) log.debug("  - Removing old metadata with id:" + id);
        dataMan.deleteMetadata(context, dbms, id);
        dbms.commit();
        result.locallyRemoved++;
      }

    // -----------------------------------------------------------------------
    // --- insert/update new metadata

    for (RecordInfo ri : records) {
      result.totalMetadata++;

      if (!dataMan.existsSchema(ri.schema)) {
        if (log.isDebugEnabled())
          log.debug(
              "  - Metadata skipped due to unknown schema. uuid:"
                  + ri.uuid
                  + ", schema:"
                  + ri.schema);
        result.unknownSchema++;
      } else {
        String id = dataMan.getMetadataId(dbms, ri.uuid);

        // look up value of localrating/enabled
        GeonetContext gc = (GeonetContext) context.getHandlerContext(Geonet.CONTEXT_NAME);
        SettingManager settingManager = gc.getSettingManager();
        boolean localRating = settingManager.getValueAsBool("system/localrating/enabled", false);

        if (id == null) {
          addMetadata(ri, localRating);
        } else {
          updateMetadata(ri, id, localRating);
        }
      }
    }

    log.info("End of alignment for : " + params.name);

    return result;
  }
  public Element execute(Element request, ServiceContext context) throws CatalogException {
    checkService(request);
    checkVersion(request);

    // num counter
    int totalInserted = 0;
    int totalUpdated = 0;
    int totalDeleted = 0;

    // Response element
    Element response = new Element(getName() + "Response", Csw.NAMESPACE_CSW);

    List<String> strFileIds = new ArrayList<String>();

    // process the transaction from the first to the last
    List<Element> childList = request.getChildren();

    GeonetContext gc = (GeonetContext) context.getHandlerContext(Geonet.CONTEXT_NAME);
    DataManager dataMan = gc.getDataManager();

    Set<String> toIndex = new HashSet<String>();

    try {
      // process the childlist
      for (Element transRequest : childList) {
        String transactionType = transRequest.getName().toLowerCase();
        if (transactionType.equals("insert")
            || transactionType.equals("update")
            || transactionType.equals("delete")) {
          List<Element> mdList = transRequest.getChildren();

          // insert to database, and get the number of inserted successful
          if (transactionType.equals("insert")) {
            Iterator<Element> inIt = mdList.iterator();
            while (inIt.hasNext()) {
              Element metadata = (Element) inIt.next().clone();
              boolean insertSuccess = insertTransaction(metadata, strFileIds, context, toIndex);
              if (insertSuccess) {
                totalInserted++;
              }
            }
          }
          // Update
          else if (transactionType.equals("update")) {
            Iterator<Element> inIt = mdList.iterator();
            Element metadata = null;

            while (inIt.hasNext()) {
              Element reqElem = (Element) inIt.next();
              if (reqElem.getNamespace() != Csw.NAMESPACE_CSW) {
                metadata = (Element) reqElem.clone();
              }
            }

            totalUpdated = updateTransaction(transRequest, metadata, context, toIndex);
          }
          // Delete
          else {
            totalDeleted = deleteTransaction(transRequest, context);
          }
        }
      }
    } catch (Exception e) {
      Log.error(Geonet.CSW, "Cannot process transaction");
      Log.error(Geonet.CSW, " (C) StackTrace\n" + Util.getStackTrace(e));

      throw new NoApplicableCodeEx("Cannot process transaction: " + e.getMessage());
    } finally {
      try {
        dataMan.indexInThreadPool(context, new ArrayList<String>(toIndex), null);
      } catch (SQLException e) {
        Log.error(Geonet.CSW, "cannot index");
        Log.error(Geonet.CSW, " (C) StackTrace\n" + Util.getStackTrace(e));
      }
      getResponseResult(request, response, strFileIds, totalInserted, totalUpdated, totalDeleted);
    }

    return response;
  }
  /**
   * Uses the notifier update service to handle insertion and updates of metadata
   *
   * @param metadata
   * @param metadataUuid
   * @throws MetadataNotifierClientException
   */
  public void webUpdate(
      String serviceUrl,
      String username,
      String password,
      String metadata,
      String metadataUuid,
      GeonetContext gc)
      throws MetadataNotifierClientException {
    HttpClient client;

    Protocol.registerProtocol(
        "https", new Protocol("https", new EasySSLProtocolSocketFactory(), 443));

    // Create a method instance.
    PostMethod method = new PostMethod(serviceUrl);

    // Provide custom retry handler is necessary
    method
        .getParams()
        .setParameter(HttpMethodParams.RETRY_HANDLER, new DefaultHttpMethodRetryHandler(3, false));

    NameValuePair[] data = {
      new NameValuePair("action", "update"),
      new NameValuePair("uuid", metadataUuid),
      new NameValuePair("XMLFile", metadata)
    };

    method.setRequestBody(data);

    // RequestEntity requestEntity = new InputStreamRequestEntity(isoDocumentInputStream);

    // method.setRequestEntity(requestEntity);
    try {
      // Create an instance of HttpClient.
      client = new HttpClient();

      if (StringUtils.isNotBlank(username) && StringUtils.isNotBlank(password)) {
        System.out.println("webUpdate: SET USER");
        client
            .getState()
            .setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(username, password));

        method.setDoAuthentication(true);
      }

      System.out.println("settingMan: " + (gc.getSettingManager() != null));
      if (gc.getSettingManager() != null) Lib.net.setupProxy(gc.getSettingManager(), client);

      // Execute the method.
      int statusCode = client.executeMethod(method);

      if (statusCode != HttpStatus.SC_OK) {
        throw new MetadataNotifierClientException("Method failed: " + method.getStatusLine());
      }

      // Read the response body.
      // byte[] responseBody = method.getResponseBody();

      // Deal with the response.
      // Use caution: ensure correct character encoding and is not binary data
      // System.out.println(new String(responseBody));

    } catch (HttpException e) {
      throw new MetadataNotifierClientException(e);
    } catch (IOException e) {
      throw new MetadataNotifierClientException(e);
    } finally {
      // Release the connection.
      method.releaseConnection();
      client = null;
    }
  }
Exemple #22
0
  public Element exec(Element params, ServiceContext context) throws Exception {
    UserSession session = context.getUserSession();

    boolean witholdWithheldElements = Util.getParam(params, "hide_withheld", false);
    if (witholdWithheldElements) {
      XmlSerializer.getThreadLocal(true).setForceHideWithheld(witholdWithheldElements);
    }

    // -----------------------------------------------------------------------
    // --- handle current tab

    Element elCurrTab = params.getChild(Params.CURRTAB);

    if (elCurrTab != null) session.setProperty(Geonet.Session.METADATA_SHOW, elCurrTab.getText());

    // -----------------------------------------------------------------------
    // --- check access

    GeonetContext gc = (GeonetContext) context.getHandlerContext(Geonet.CONTEXT_NAME);
    DataManager dm = gc.getDataManager();

    String id = Utils.getIdentifierFromParameters(params, context);

    if (!skipPopularity) { // skipPopularity could be a URL param as well
      String skip = Util.getParam(params, "skipPopularity", "n");
      skipPopularity = skip.equals("y");
    }

    if (id == null) throw new MetadataNotFoundEx("Metadata not found.");

    Lib.resource.checkPrivilege(context, id, AccessManager.OPER_VIEW);

    // -----------------------------------------------------------------------
    // --- get metadata

    Element elMd;
    boolean addEditing = false;
    if (!skipInfo) {
      boolean withValidationErrors = false, keepXlinkAttributes = false;
      elMd = dm.getMetadata(context, id, addEditing, withValidationErrors, keepXlinkAttributes);
    } else {
      elMd = dm.getMetadataNoInfo(context, id);
    }

    if (elMd == null) throw new MetadataNotFoundEx(id);

    if (addRefs) { // metadata.show for GeoNetwork needs geonet:element
      elMd = dm.enumerateTree(elMd);
    }

    //
    // setting schemaLocation
    // TODO currently it's only set for ISO metadata - this should all move
    // to
    // the updatefixedinfo.xsl for each schema

    // do not set schemaLocation if it is already there
    if (elMd.getAttribute("schemaLocation", Csw.NAMESPACE_XSI) == null) {
      Namespace gmdNs = elMd.getNamespace("gmd");
      // document has ISO root element and ISO namespace
      if (gmdNs != null && gmdNs.getURI().equals("http://www.isotc211.org/2005/gmd")) {
        String schemaLocation;
        // if document has srv namespace then add srv schemaLocation
        if (elMd.getNamespace("srv") != null) {
          schemaLocation =
              " http://www.isotc211.org/2005/srv http://schemas.opengis.net/iso/19139/20060504/srv/srv.xsd";
        }
        // otherwise add gmd schemaLocation
        // (but not both! as that is invalid, the schemas describe
        // partially the same schema types)
        else {
          schemaLocation =
              "http://www.isotc211.org/2005/gmd http://www.isotc211.org/2005/gmd/gmd.xsd";
        }
        Attribute schemaLocationA =
            new Attribute("schemaLocation", schemaLocation, Csw.NAMESPACE_XSI);
        elMd.setAttribute(schemaLocationA);
      }
    }

    // --- increase metadata popularity
    if (!skipPopularity) dm.increasePopularity(context, id);

    return elMd;
  }
Exemple #23
0
  public Element serviceSpecificExec(Element params, ServiceContext context) throws Exception {
    GeonetContext gc = (GeonetContext) context.getHandlerContext(Geonet.CONTEXT_NAME);
    DataManager dm = gc.getBean(DataManager.class);
    Dbms dbms = (Dbms) context.getResourceManager().open(Geonet.Res.MAIN_DB);

    String child = Util.getParam(params, Params.CHILD, "n");
    String isTemplate = Util.getParam(params, Params.TEMPLATE, "n");
    String id = "";
    String uuid = "";
    boolean haveAllRights = Boolean.valueOf(Util.getParam(params, Params.FULL_PRIVILEGES, "false"));

    // does the request contain a UUID ?
    try {
      uuid = Util.getParam(params, Params.UUID);
      // lookup ID by UUID
      id = dm.getMetadataId(dbms, uuid);
    } catch (BadInputEx x) {
      try {
        id = Util.getParam(params, Params.ID);
        uuid = dm.getMetadataUuid(dbms, id);
      }
      // request does not contain ID
      catch (BadInputEx xx) {
        // give up
        throw new Exception("Request must contain a UUID or an ID");
      }
    }

    String groupOwner = Util.getParam(params, Params.GROUP);

    // TODO : Check user can create a metadata in that group
    UserSession user = context.getUserSession();
    if (!user.getProfile().equals(Geonet.Profile.ADMINISTRATOR)) {
      String selectGroupIdQuery =
          "SELECT groupId FROM UserGroups WHERE profile='Editor' AND userId=? AND groupId=?";
      @SuppressWarnings("unchecked")
      java.util.List<Element> list =
          dbms.select(
                  selectGroupIdQuery,
                  Integer.valueOf(user.getUserId()),
                  Integer.valueOf(groupOwner))
              .getChildren();
      if (list.size() == 0) {
        throw new ServiceNotAllowedEx(
            "Service not allowed. User needs to be Editor in group with id " + groupOwner);
      }
    }

    // --- query the data manager

    String newId =
        dm.createMetadata(
            context,
            dbms,
            id,
            groupOwner,
            context.getSerialFactory(),
            gc.getSiteId(),
            context.getUserSession().getUserIdAsInt(),
            (child.equals("n") ? null : uuid),
            isTemplate,
            haveAllRights);

    Element response = new Element(Jeeves.Elem.RESPONSE);
    response.addContent(new Element(Geonet.Elem.JUSTCREATED).setText("true"));

    String sessionTabProperty =
        useEditTab ? Geonet.Session.METADATA_EDITING_TAB : Geonet.Session.METADATA_SHOW;

    // Set current tab for new editing session if defined.
    Element elCurrTab = params.getChild(Params.CURRTAB);
    if (elCurrTab != null) {
      context.getUserSession().setProperty(sessionTabProperty, elCurrTab.getText());
    }
    response.addContent(new Element(Geonet.Elem.ID).setText(newId));
    return response;
  }
  // --------------------------------------------------------------------------
  // ---
  // --- Service
  // ---
  // --------------------------------------------------------------------------
  @Override
  public Element serviceSpecificExec(Element params, ServiceContext context) throws Exception {
    boolean readOnlyMode = super.exec(params, context) == null;
    if (readOnlyMode) {
      return null;
    }
    String message = "";
    GeonetContext gc = (GeonetContext) context.getHandlerContext(Geonet.CONTEXT_NAME);

    // gets the total popularity count (=100)
    Dbms dbms = (Dbms) context.getResourceManager().open(Geonet.Res.MAIN_DB);

    // wont work if there is no metadata
    List l = dbms.select("select sum(popularity) as sumpop from metadata").getChildren();
    if (l.size() != 1) {
      message = "cannot get popularity count";
      return null;
    }

    int cnt = Integer.parseInt(((Element) l.get(0)).getChildText("sumpop"));

    if (Log.isDebugEnabled(Geonet.SEARCH_LOGGER))
      Log.debug(Geonet.SEARCH_LOGGER, "query to get popularity by group:\n" + query);
    dbms = (Dbms) context.getResourceManager().open(Geonet.Res.MAIN_DB);

    DefaultPieDataset dataset = new DefaultPieDataset();
    List resultSet = dbms.select(query).getChildren();

    for (int i = 0; i < resultSet.size(); i++) {
      Element record = (Element) resultSet.get(i);
      String popularity = (record).getChildText("popu");
      Double d = 0.0;
      if (popularity.length() > 0) {
        d = (Double.parseDouble(popularity) / cnt) * 100;
      }
      dataset.setValue(record.getChildText("source"), d);
      // System.out.println(record.getChildText("groupname") + ", " + d);
    }

    // create a chart...
    JFreeChart chart =
        ChartFactory.createPieChart(
            null,
            dataset,
            true, // legend?
            true, // tooltips?
            false // URLs?
            );

    // hard coded values for the moment. should come from a configuration file.
    chart.setBackgroundPaint(Color.decode("#E7EDF5"));
    String chartFilename = "popubycatalog_" + System.currentTimeMillis() + ".png";

    File statFolder =
        new File(
            gc.getHandlerConfig().getMandatoryValue(Geonet.Config.RESOURCES_DIR)
                + File.separator
                + "images"
                + File.separator
                + "statTmp");
    if (!statFolder.exists()) {
      statFolder.mkdirs();
    }
    File f = new File(statFolder, chartFilename);
    this.imageMap =
        org.fao.geonet.services.statistics.ChartFactory.writeChartImage(
            chart,
            f,
            this.chartWidth,
            this.chartHeight,
            this.createTooltips,
            "graphPopuByCatalogImageMap");
    // will return some info to the XSLT:
    // dateFrom, dateTo, graphicType, chartUrl, tooltipImageMap,
    // message, chartWidth, chartHeight

    Element elResp = new Element(Jeeves.Elem.RESPONSE);
    Element elchartUrl =
        new Element("popuByCatalogUrl")
            .setText(context.getBaseUrl() + "/images/statTmp/" + chartFilename);
    Element elTooltipImageMap =
        new Element("tooltipImageMap").addContent(this.createTooltips ? this.imageMap : "");

    Element elMessage = new Element("message").setText(message);
    Element elChartWidth = new Element("chartWidth").setText("" + this.chartWidth);
    Element elChartHeight = new Element("chartHeight").setText("" + this.chartHeight);

    elResp.addContent(elchartUrl);
    elResp.addContent(elTooltipImageMap);
    elResp.addContent(elMessage);
    elResp.addContent(elChartWidth);
    elResp.addContent(elChartHeight);

    return elResp;
  }
  public static List<Element> handlePropertyName(
      String[] propertyNames,
      ServiceContext context,
      boolean freq,
      int maxRecords,
      String cswServiceSpecificConstraint,
      LuceneConfig luceneConfig)
      throws Exception {

    List<Element> domainValuesList = null;

    if (Log.isDebugEnabled(Geonet.CSW))
      Log.debug(
          Geonet.CSW,
          "Handling property names '"
              + Arrays.toString(propertyNames)
              + "' with max records of "
              + maxRecords);

    for (int i = 0; i < propertyNames.length; i++) {

      if (i == 0) domainValuesList = new ArrayList<Element>();

      // Initialize list of values element.
      Element listOfValues = null;

      // Generate DomainValues element
      Element domainValues = new Element("DomainValues", Csw.NAMESPACE_CSW);

      // FIXME what should be the type ???
      domainValues.setAttribute("type", "csw:Record");

      String property = propertyNames[i].trim();

      // Set propertyName in any case.
      Element pn = new Element("PropertyName", Csw.NAMESPACE_CSW);
      domainValues.addContent(pn.setText(property));

      GeonetContext gc = (GeonetContext) context.getHandlerContext(Geonet.CONTEXT_NAME);
      SearchManager sm = gc.getSearchmanager();

      IndexAndTaxonomy indexAndTaxonomy = sm.getNewIndexReader(null);
      try {
        GeonetworkMultiReader reader = indexAndTaxonomy.indexReader;
        BooleanQuery groupsQuery = (BooleanQuery) CatalogSearcher.getGroupsQuery(context);
        BooleanQuery query = null;

        // Apply CSW service specific constraint
        if (StringUtils.isNotEmpty(cswServiceSpecificConstraint)) {
          Query constraintQuery =
              CatalogSearcher.getCswServiceSpecificConstraintQuery(
                  cswServiceSpecificConstraint, luceneConfig);

          query = new BooleanQuery();

          BooleanClause.Occur occur = LuceneUtils.convertRequiredAndProhibitedToOccur(true, false);

          query.add(groupsQuery, occur);
          query.add(constraintQuery, occur);

        } else {
          query = groupsQuery;
        }

        List<Pair<String, Boolean>> sortFields =
            Collections.singletonList(Pair.read(Geonet.SearchResult.SortBy.RELEVANCE, true));
        Sort sort = LuceneSearcher.makeSort(sortFields, context.getLanguage(), false);
        CachingWrapperFilter filter = null;

        Pair<TopDocs, Element> searchResults =
            LuceneSearcher.doSearchAndMakeSummary(
                maxRecords,
                0,
                maxRecords,
                context.getLanguage(),
                null,
                reader,
                query,
                filter,
                sort,
                null,
                false,
                false,
                false,
                false // Scoring is useless for GetDomain operation
                );
        TopDocs hits = searchResults.one();

        try {
          // Get mapped lucene field in CSW configuration
          String indexField = CatalogConfiguration.getFieldMapping().get(property.toLowerCase());
          if (indexField != null) property = indexField;

          // check if params asked is in the index using getFieldNames ?
          FieldInfos fi = new SlowCompositeReaderWrapper(reader).getFieldInfos();
          if (fi.fieldInfo(property) == null) continue;

          boolean isRange = false;
          if (CatalogConfiguration.getGetRecordsRangeFields().contains(property)) isRange = true;

          if (isRange) listOfValues = new Element("RangeOfValues", Csw.NAMESPACE_CSW);
          else listOfValues = new Element("ListOfValues", Csw.NAMESPACE_CSW);

          Set<String> fields = new HashSet<String>();
          fields.add(property);
          fields.add("_isTemplate");

          // parse each document in the index
          String[] fieldValues;
          SortedSet<String> sortedValues = new TreeSet<String>();
          HashMap<String, Integer> duplicateValues = new HashMap<String, Integer>();
          for (int j = 0; j < hits.scoreDocs.length; j++) {
            DocumentStoredFieldVisitor selector = new DocumentStoredFieldVisitor(fields);
            reader.document(hits.scoreDocs[j].doc, selector);
            Document doc = selector.getDocument();

            // Skip templates and subTemplates
            String[] isTemplate = doc.getValues("_isTemplate");
            if (isTemplate[0] != null && !isTemplate[0].equals("n")) continue;

            // Get doc values for specified property
            fieldValues = doc.getValues(property);
            if (fieldValues == null) continue;

            addtoSortedSet(sortedValues, fieldValues, duplicateValues);
          }

          SummaryComparator valuesComparator =
              new SummaryComparator(SortOption.FREQUENCY, Type.STRING, context.getLanguage(), null);
          TreeSet<Map.Entry<String, Integer>> sortedValuesFrequency =
              new TreeSet<Map.Entry<String, Integer>>(valuesComparator);
          sortedValuesFrequency.addAll(duplicateValues.entrySet());

          if (freq) return createValuesByFrequency(sortedValuesFrequency);
          else listOfValues.addContent(createValuesElement(sortedValues, isRange));

        } finally {
          // any children means that the catalog was unable to determine
          // anything about the specified parameter
          if (listOfValues != null && listOfValues.getChildren().size() != 0)
            domainValues.addContent(listOfValues);

          // Add current DomainValues to the list
          domainValuesList.add(domainValues);
        }
      } finally {
        sm.releaseIndexReader(indexAndTaxonomy);
      }
    }
    return domainValuesList;
  }