예제 #1
0
 /**
  * Convert a Tag to XML and write XML to given writer.
  *
  * @param tag the Tag
  * @param writer the XMLStreamWriter to write to
  */
 public static void marshal(Tag tag, XMLStreamWriter writer) {
   try {
     writer.writeCharacters("\n");
     writer.writeStartElement("tag");
     writer.writeAttribute("name", tag.getTagName());
     writer.writeAttribute("objectIdentifier", tag.getObjectIdentifier());
     writer.writeAttribute("type", "" + tag.getType());
     writer.writeEndElement();
   } catch (XMLStreamException e) {
     throw new RuntimeException(e);
   }
 }
예제 #2
0
 /**
  * For a given FieldDescriptor, look up its 'aspect:' tags and place it in the correct map within
  * placementRefsAndCollections. If categorised, remove it from the supplied miscRefs map.
  *
  * @param fd the FieldDecriptor (a references or collection)
  * @param taggedType 'reference' or 'collection'
  * @param dispRef the corresponding DisplayReference or DisplayCollection
  * @param miscRefs map that contains dispRef (may be removed by this method)
  * @param tagManager the tag manager
  * @param sup the superuser account name
  * @param placementRefsAndCollections take from the ReportObject
  * @param isSuperUser if current user is superuser
  */
 public static void categoriseBasedOnTags(
     FieldDescriptor fd,
     String taggedType,
     DisplayField dispRef,
     Map<String, DisplayField> miscRefs,
     TagManager tagManager,
     String sup,
     Map<String, Map<String, DisplayField>> placementRefsAndCollections,
     boolean isSuperUser) {
   List<Tag> tags =
       tagManager.getTags(
           null,
           fd.getClassDescriptor().getUnqualifiedName() + "." + fd.getName(),
           taggedType,
           sup);
   for (Tag tag : tags) {
     String tagName = tag.getTagName();
     if (!isSuperUser && tagName.equals(TagNames.IM_HIDDEN)) {
       // miscRefs.remove(fd.getName());
       // Maybe it was added already to some placement and
       // that's why it must be removed
       removeField(fd.getName(), placementRefsAndCollections);
       return;
     }
     if (AspectTagUtil.isAspectTag(tagName)) {
       Map<String, DisplayField> refs = placementRefsAndCollections.get(tagName);
       if (refs != null) {
         refs.put(fd.getName(), dispRef);
         miscRefs.remove(fd.getName());
       }
     } else if (tagName.equals(TagNames.IM_SUMMARY)) {
       Map<String, DisplayField> summary = placementRefsAndCollections.get(TagNames.IM_SUMMARY);
       if (summary != null) {
         summary.put(fd.getName(), dispRef);
         miscRefs.remove(fd.getName());
       }
       miscRefs.remove(fd.getName());
     }
   }
 }
예제 #3
0
  /** {@inheritDoc} */
  @SuppressWarnings("unused")
  @Override
  public ActionForward execute(
      @SuppressWarnings("unused") ActionMapping mapping,
      @SuppressWarnings("unused") ActionForm form,
      HttpServletRequest request,
      @SuppressWarnings("unused") HttpServletResponse response)
      throws Exception {

    long startTime = System.currentTimeMillis();

    HttpSession session = request.getSession();
    InterMineAPI im = SessionMethods.getInterMineAPI(session);

    if (im.getBagManager().isAnyBagToUpgrade(SessionMethods.getProfile(session))) {
      recordError(new ActionMessage("login.upgradeListManually"), request);
    }
    // fetch & set requested object
    InterMineObject requestedObject = getRequestedObject(im, request);

    if (requestedObject != null) {
      ReportObjectFactory reportObjectFactory = SessionMethods.getReportObjects(session);
      ReportObject reportObject = reportObjectFactory.get(requestedObject);

      request.setAttribute("object", reportObject);
      request.setAttribute("reportObject", reportObject);

      request.setAttribute("requestedObject", requestedObject);

      // hell starts here
      TagManager tagManager = im.getTagManager();
      ServletContext servletContext = session.getServletContext();
      ObjectStore os = im.getObjectStore();
      String superuser = im.getProfileManager().getSuperuser();
      if (superuser.equals(SessionMethods.getProfile(session).getUsername())) {
        request.setAttribute("SHOW_TAGS", true);
      }
      // place InlineLists based on TagManager, reportObject is cached while Controller is not
      Map<String, List<InlineList>> placedInlineLists = new TreeMap<String, List<InlineList>>();
      // traverse all unplaced (non-header) InlineLists
      for (InlineList list : reportObject.getNormalInlineLists()) {
        FieldDescriptor fd = list.getDescriptor();
        String taggedType = getTaggedType(fd);

        // assign lists to any aspects they are tagged to or put in unplaced lists
        String fieldPath = fd.getClassDescriptor().getUnqualifiedName() + "." + fd.getName();
        List<Tag> tags = tagManager.getTags(null, fieldPath, taggedType, superuser);
        for (Tag tag : tags) {
          String tagName = tag.getTagName();
          if (AspectTagUtil.isAspectTag(tagName)) {
            List<InlineList> listsForAspect = placedInlineLists.get(tagName);
            if (listsForAspect == null) {
              listsForAspect = new ArrayList<InlineList>();
              placedInlineLists.put(tagName, listsForAspect);
            }
            listsForAspect.add(list);
          } else if (tagName.equals(TagNames.IM_SUMMARY)) {
            List<InlineList> summaryLists = placedInlineLists.get(tagName);
            if (summaryLists == null) {
              summaryLists = new ArrayList<InlineList>();
              placedInlineLists.put(tagName, summaryLists);
            }
            summaryLists.add(list);
          }
        }
      }

      // any lists that aren't tagged will be 'unplaced'
      List<InlineList> unplacedInlineLists =
          new ArrayList<InlineList>(reportObject.getNormalInlineLists());
      unplacedInlineLists.removeAll(placedInlineLists.values());

      long now = System.currentTimeMillis();
      LOG.info("TIME placed inline lists: " + (now - startTime) + "ms");
      long stepTime = now;

      request.setAttribute("mapOfInlineLists", placedInlineLists);
      request.setAttribute("listOfUnplacedInlineLists", unplacedInlineLists);

      Map<String, Map<String, DisplayField>> placementRefsAndCollections =
          new TreeMap<String, Map<String, DisplayField>>();
      Set<String> aspects = new LinkedHashSet<String>(SessionMethods.getCategories(servletContext));

      Set<ClassDescriptor> cds =
          os.getModel().getClassDescriptorsForClass(requestedObject.getClass());

      for (String aspect : aspects) {
        placementRefsAndCollections.put(
            TagNames.IM_ASPECT_PREFIX + aspect,
            new TreeMap<String, DisplayField>(String.CASE_INSENSITIVE_ORDER));
      }

      Map<String, DisplayField> miscRefs =
          new TreeMap<String, DisplayField>(reportObject.getRefsAndCollections());
      placementRefsAndCollections.put(TagNames.IM_ASPECT_MISC, miscRefs);

      // summary refs and colls
      Map<String, DisplayField> summaryRefsCols = new TreeMap<String, DisplayField>();
      placementRefsAndCollections.put(TagNames.IM_SUMMARY, summaryRefsCols);

      for (Iterator<Entry<String, DisplayField>> iter =
              reportObject.getRefsAndCollections().entrySet().iterator();
          iter.hasNext(); ) {
        Map.Entry<String, DisplayField> entry = iter.next();
        DisplayField df = entry.getValue();
        if (df instanceof DisplayReference) {
          categoriseBasedOnTags(
              ((DisplayReference) df).getDescriptor(),
              "reference",
              df,
              miscRefs,
              tagManager,
              superuser,
              placementRefsAndCollections,
              SessionMethods.isSuperUser(session));
        } else if (df instanceof DisplayCollection) {
          categoriseBasedOnTags(
              ((DisplayCollection) df).getDescriptor(),
              "collection",
              df,
              miscRefs,
              tagManager,
              superuser,
              placementRefsAndCollections,
              SessionMethods.isSuperUser(session));
        }
      }

      // remove any fields overridden by displayers
      removeFieldsReplacedByReportDisplayers(reportObject, placementRefsAndCollections);
      request.setAttribute("placementRefsAndCollections", placementRefsAndCollections);

      String type = reportObject.getType();
      request.setAttribute("objectType", type);

      String stableLink = PortalHelper.generatePortalLink(reportObject.getObject(), im, request);
      if (stableLink != null) {
        request.setAttribute("stableLink", stableLink);
      }

      stepTime = System.currentTimeMillis();
      startTime = stepTime;

      // attach only non empty categories
      Set<String> allClasses = new HashSet<String>();
      for (ClassDescriptor cld : cds) {
        allClasses.add(cld.getUnqualifiedName());
      }
      TemplateManager templateManager = im.getTemplateManager();
      Map<String, List<ReportDisplayer>> displayerMap = reportObject.getReportDisplayers();

      stepTime = System.currentTimeMillis();
      startTime = stepTime;

      List<String> categories = new LinkedList<String>();
      for (String aspect : aspects) {
        // 1) Displayers
        // 2) Inline Lists
        if ((displayerMap != null && displayerMap.containsKey(aspect))
            || placedInlineLists.containsKey(aspect)) {
          categories.add(aspect);
        } else {
          // 3) Templates
          if (!templateManager.getReportPageTemplatesForAspect(aspect, allClasses).isEmpty()) {
            categories.add(aspect);
          } else {
            // 4) References & Collections
            if (placementRefsAndCollections.containsKey("im:aspect:" + aspect)
                && placementRefsAndCollections.get("im:aspect:" + aspect) != null) {
              for (DisplayField df :
                  placementRefsAndCollections.get("im:aspect:" + aspect).values()) {
                categories.add(aspect);
                break;
              }
            }
          }
        }
      }
      if (!categories.isEmpty()) {
        request.setAttribute("categories", categories);
      }
      now = System.currentTimeMillis();
      LOG.info("TIME made list of categories: " + (now - stepTime) + "ms");
    }

    return null;
  }
예제 #4
0
  /** {@inheritDoc} */
  @Override
  public void endElement(String uri, String localName, String qName) throws SAXException {
    super.endElement(uri, localName, qName);
    if ("userprofile".equals(qName)) {
      Profile profile;
      profile = profileHandler.getProfile();
      profileManager.createProfileWithoutBags(profile);
      try {
        Map<String, Set<BagValue>> bagValues = profileHandler.getBagsValues();
        for (StorableBag bag : profile.getAllBags().values()) {
          bag.saveWithBagValues(profile.getUserId(), bagValues.get(bag.getName()));
        }
      } catch (ObjectStoreException ose) {
        throw new SAXException(ose);
      }
      // Must come after the bags themselves have been stored.
      try {
        SharedBagManager.getInstance(profileManager);
        profileHandler.getInvitationHandler().storeInvites(profile);
      } catch (SQLException e) {
        LOG.error("Cannot store invitations", e);
        if (abortOnError) {
          throw new SAXException(e);
        }
      }
      Set<Tag> tags = profileHandler.getTags();
      TagManager tagManager = new TagManagerFactory(profile.getProfileManager()).getTagManager();
      for (Tag tag : tags) {
        try {
          tagManager.addTag(tag.getTagName(), tag.getObjectIdentifier(), tag.getType(), profile);
        } catch (TagManager.TagException e) {
          LOG.error("Cannot add tag: " + tag.toString(), e);
          if (abortOnError) {
            throw new SAXException(e);
          }
        } catch (RuntimeException e) {
          LOG.error("Error adding tag: " + tag.toString(), e);
          if (abortOnError) {
            throw new SAXException(e);
          }
        }
      }
      profile.getSearchRepository().receiveEvent(new MassTaggingEvent());
      profileHandler = null;
      long totalTime = System.currentTimeMillis() - startTime;
      LOG.info("Finished profile: " + profile.getUsername() + " took " + totalTime + "ms.");
    }
    if ("userprofiles".equals(qName)) {
      if (!sharedBagsByUsers.isEmpty()) {
        SharedBagManager sharedBagManager = SharedBagManager.getInstance(profileManager);
        String bagName, dateCreated;
        for (String user : sharedBagsByUsers.keySet()) {
          List<Map<String, String>> sharedBags = sharedBagsByUsers.get(user);
          if (!sharedBags.isEmpty()) {
            for (Map<String, String> sharedBag : sharedBags) {
              bagName = sharedBag.get("name");
              dateCreated = sharedBag.get("dateCreated");
              sharedBagManager.shareBagWithUser(bagName, dateCreated, user);
            }
          }
        }
      }
    }
    if (profileHandler != null) {
      profileHandler.endElement(uri, localName, qName);
    }

    if (trackHandler != null) {
      trackHandler.endElement(uri, localName, qName);
    }
  }