Exemple #1
0
  /*
   * Insert the relation between two metadata records.
   * If it already exist, bypass insert statement and an alreadyExist flag.
   *
   * @see jeeves.interfaces.Service#exec(org.jdom.Element,
   * jeeves.server.context.ServiceContext) Parameter name: parentId - Parent
   * metadata identifier Parameter name: childId - Child metadata identifier
   */
  public Element serviceSpecificExec(Element params, ServiceContext context) throws Exception {
    int parentId =
        Integer.parseInt(
            Utils.getIdentifierFromParameters(
                params, context, Params.PARENT_UUID, Params.PARENT_ID));
    int childId =
        Integer.parseInt(
            Utils.getIdentifierFromParameters(params, context, Params.CHILD_UUID, Params.CHILD_ID));

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

    String query = "Select count(*) as exist from Relations where id=? and relatedId=?";
    Element record = dbms.select(query, parentId, childId).getChild("record");
    boolean exist = false;
    if (record.getChild("exist").getText().equals("1")) {
      exist = true;
    } else {
      // Add new relation
      query = "INSERT INTO Relations (id, relatedId) " + "VALUES (?, ?)";

      dbms.execute(query, parentId, childId);
    }

    Element response =
        new Element(Jeeves.Elem.RESPONSE)
            .setAttribute("alreadyExist", String.valueOf(exist))
            .addContent(new Element("parentId").setText(String.valueOf(parentId)))
            .addContent(new Element("childId").setText(String.valueOf(childId)));

    return response;
  }
  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 #3
0
  public Element serviceSpecificExec(Element params, ServiceContext context) throws Exception {
    String id = Utils.getIdentifierFromParameters(params, context);
    String filename = Util.getParam(params, Params.FILENAME);
    String access = Util.getParam(params, Params.ACCESS);

    Lib.resource.checkEditPrivilege(context, id);

    // delete the file
    File dir = new File(Lib.resource.getDir(context, access, id));
    File file = new File(dir, filename);

    if (file.exists() && !file.delete()) throw new OperationAbortedEx("unable to delete resource");

    Element response =
        new Element(Jeeves.Elem.RESPONSE).addContent(new Element(Geonet.Elem.ID).setText(id));
    return response;
  }
  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 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;
  }
  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;
  }
Exemple #7
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;
  }
  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;
  }