Beispiel #1
0
 @Override
 @HasPermission(action = UGC_UPDATE, type = SocialPermission.class)
 public void setAttributes(
     @SecuredObject final String ugcId, final String contextId, final Map attributes)
     throws SocialException, UGCNotFound {
   log.debug("logging.ugc.addingAttributes", attributes, ugcId, contextId);
   try {
     T toUpdate = (T) ugcRepository.findUGC(contextId, ugcId);
     if (toUpdate == null) {
       throw new UGCNotFound("Unable to found ugc with id " + ugcId);
     }
     final Map attrs = toUpdate.getAttributes();
     attrs.putAll(attrs);
     ugcRepository.setAttributes(ugcId, contextId, attrs);
     final SocialEvent<T> event =
         new SocialEvent<T>(
             ugcId,
             attributes,
             SocialSecurityUtils.getCurrentProfile().getId().toString(),
             UGCEvent.UPDATE_ATTRIBUTES);
     event.setAttribute("baseUrl", calculateBaseUrl());
     reactor.notify(UGCEvent.UPDATE_ATTRIBUTES.getName(), Event.wrap(event));
   } catch (MongoDataException ex) {
     log.debug("logging.ugc.unableToAddAttrs", ex, attributes, ugcId, contextId);
     throw new UGCException("Unable to add Attributes to UGC", ex);
   }
 }
Beispiel #2
0
 public void removeWatcher(final String profileId, final String frequency) {
   if (watchers.remove(new ProfileWatchOptions(profileId, frequency))) {
     log.debug("logging.system.notification.userRemoveWatching", profileId, threadId, frequency);
   } else {
     log.debug("logging.system.notification.userUnableToRemove", profileId, threadId, frequency);
   }
 }
Beispiel #3
0
  @Override
  @HasPermission(action = UGC_UPDATE, type = SocialPermission.class)
  public UGC update(
      @SecuredObject final String ugcId,
      final String body,
      final String subject,
      final String contextId,
      final Map attributes)
      throws SocialException, UGCNotFound {
    log.debug("logging.ugc.updateUgc", ugcId);
    try {
      final Profile currentProfile = SocialSecurityUtils.getCurrentProfile();
      boolean moderateByMail =
          Boolean.parseBoolean(
              tenantConfigurationService.getProperty(contextId, "moderateByMailEnable").toString());

      if (!ObjectId.isValid(ugcId)) {
        throw new IllegalArgumentException("Given UGC Id is not valid");
      }
      T toUpdate = (T) ugcRepository.findUGC(contextId, ugcId);
      if (toUpdate == null) {
        throw new IllegalArgumentException("UGC with Id " + ugcId + " does not exists");
      }
      if (StringUtils.isNotBlank(body)) {
        toUpdate.setBody(body);
      }
      if (StringUtils.isNotBlank(subject)) {
        toUpdate.setBody(subject);
      }
      pipeline.processUgc(toUpdate);
      if (moderateByMail
          && !SocialSecurityUtils.isProfileModeratorOrAdmin(currentProfile, contextId)) {
        if (toUpdate instanceof SocialUgc) {
          ((SocialUgc) toUpdate).setModerationStatus(ModerationStatus.UNMODERATED);
        }
      }
      ugcRepository.update(ugcId, toUpdate, false, false);
      final SocialEvent<T> event =
          new SocialEvent<>(
              toUpdate,
              SocialSecurityUtils.getCurrentProfile().getId().toString(),
              UGCEvent.UPDATE);
      event.setAttribute("baseUrl", calculateBaseUrl());
      reactor.notify(UGCEvent.UPDATE.getName(), Event.wrap(event));
      if (attributes != null && !attributes.isEmpty()) {
        toUpdate.getAttributes().putAll(attributes);
        // ToDo This should be one query, problem is with deep attributes !!
        setAttributes(toUpdate.getId().toString(), contextId, toUpdate.getAttributes());
        reactor.notify(UGCEvent.UPDATE_ATTRIBUTES, Event.wrap(attributes));
      }
      log.info("logging.ugc.updatedUgc", ugcId);
      return toUpdate;
    } catch (MongoDataException ex) {
      log.error("logging.ugc.unableToUpdateUgc", ex);
      throw new UGCException("Unable to removeWatcher UGC", ex);
    }
  }
Beispiel #4
0
 public void addWatcher(final String profileId, final String frequency) {
   final ProfileWatchOptions toAdd = new ProfileWatchOptions(profileId, frequency);
   if (!watchers.contains(toAdd)) {
     watchers.add(toAdd);
     log.debug("logging.system.notification.userAddedWatching", profileId, threadId, frequency);
   } else {
     log.debug("logging.system.notification.userAlreadyWatching", profileId, threadId, frequency);
   }
 }
Beispiel #5
0
 @Override
 @HasPermission(action = UGC_READ, type = SocialPermission.class)
 public Iterable<T> readByTargetId(final String targetId, final String contextId)
     throws UGCException {
   log.debug("logging.ugc.findingByTarget", targetId, contextId);
   try {
     return buildUgcTreeList(
         IterableUtils.toList(ugcRepository.findByTargetId(targetId, contextId)),
         Integer.MAX_VALUE);
   } catch (MongoDataException ex) {
     log.error("logging.ugc.unableRead", ex);
     throw new UGCException("Unable to ", ex);
   }
 }
Beispiel #6
0
 @Override
 @HasPermission(action = UGC_UPDATE, type = SocialPermission.class)
 public FileInfo updateAttachment(
     @SecuredObject final String ugcId,
     final String contextId,
     final String attachmentId,
     final InputStream newAttachment)
     throws UGCException, FileNotFoundException {
   if (!ObjectId.isValid(ugcId)) {
     throw new IllegalArgumentException("Given Ugc Id is not valid");
   }
   if (!ObjectId.isValid(attachmentId)) {
     throw new IllegalArgumentException("Given UGC Id is not valid");
   }
   try {
     T ugc = (T) ugcRepository.findUGC(contextId, ugcId);
     if (ugc == null) {
       throw new IllegalUgcException("Given UGC Id does not exists");
     }
     FileInfo oldInfo = ugcRepository.getFileInfo(attachmentId);
     ugc.getAttachments().remove(oldInfo);
     FileInfo newInfo =
         ugcRepository.updateFile(
             new ObjectId(attachmentId),
             newAttachment,
             oldInfo.getFileName(),
             oldInfo.getContentType(),
             true);
     ugc.getAttachments().add(newInfo);
     ugcRepository.update(ugcId, ugc);
     reactor.notify(
         UGCEvent.DELETE_ATTACHMENT.getName(),
         Event.wrap(new SocialEvent<>(ugcId, attachmentId, UGCEvent.DELETE_ATTACHMENT)));
     reactor.notify(
         UGCEvent.ADD_ATTACHMENT.getName(),
         Event.wrap(
             new SocialEvent<>(
                 ugcId, new InputStream[] {new CloseShieldInputStream(newAttachment)}),
             UGCEvent.ADD_ATTACHMENT));
     return newInfo;
   } catch (MongoDataException e) {
     log.error("logging.ugc.attachmentError");
     throw new UGCException("Unable to removeWatcher Attachment");
   } catch (FileExistsException e) {
     log.error("logging.ugc.attachmentNotFound", attachmentId);
     throw new UGCException("Unable to find attachment with given id", e);
   }
 }
Beispiel #7
0
 @Override
 @HasPermission(action = UGC_UPDATE, type = SocialPermission.class)
 public void removeAttachment(
     @SecuredObject final String ugcId, final String contextId, final String attachmentId)
     throws UGCException, FileNotFoundException {
   try {
     UGC ugc = ugcRepository.findUGC(contextId, ugcId);
     if (ugc == null) {
       throw new IllegalUgcException("UGC with given Id does not exist");
     }
     if (!ObjectId.isValid(attachmentId)) {
       throw new IllegalArgumentException("Given Attachment id is not valid");
     }
     ObjectId attachmentOid = new ObjectId(attachmentId);
     FileInfo info = ugcRepository.getFileInfo(attachmentOid);
     if (!info.getStoreName().startsWith(File.separator + contextId)) {
       throw new IllegalSocialQueryException(
           "Given Attachment does not belong to the given context");
     }
     ugc.getAttachments().remove(info);
     ugcRepository.deleteFile(attachmentOid);
     ugcRepository.update(ugcId, ugc);
     reactor.notify(
         UGCEvent.DELETE_ATTACHMENT.getName(),
         Event.wrap(new SocialEvent<>(ugcId, attachmentId, UGCEvent.DELETE_ATTACHMENT)));
   } catch (MongoDataException e) {
     log.error("logging.ugc.attachmentToRemove", e, attachmentId);
     throw new UGCException("Unable to save File to UGC");
   }
 }
Beispiel #8
0
 @Override
 @HasPermission(action = UGC_READ, type = SocialPermission.class)
 public FileInfo readAttachment(
     final String ugcId, final String contextId, final String attachmentId)
     throws FileNotFoundException, UGCException {
   if (!ObjectId.isValid(ugcId)) {
     throw new IllegalArgumentException("Given Ugc Id is not valid");
   }
   if (!ObjectId.isValid(attachmentId)) {
     throw new IllegalArgumentException("Given attachment Id is not valid");
   }
   try {
     UGC ugc = ugcRepository.findUGC(contextId, ugcId);
     if (ugc == null) {
       throw new IllegalUgcException("UGC with given Id does not exist");
     }
     ObjectId attachmentOid = new ObjectId(attachmentId);
     FileInfo info = ugcRepository.readFile(attachmentOid);
     if (!info.getStoreName().startsWith(File.separator + contextId)) {
       throw new IllegalSocialQueryException(
           "Given Attachment does not belong to the given context");
     }
     return info;
   } catch (MongoDataException ex) {
     log.error("logging.ugc.attachmentNotFound", ex, attachmentId);
     throw new UGCException("Unable to read file", ex);
   }
 }
Beispiel #9
0
  @Override
  @HasPermission(action = UGC_DELETE, type = SocialPermission.class)
  public boolean deleteUgc(final String ugcId, final String contextId) throws SocialException {
    log.debug("logging.ugc.deleteUgc", ugcId);
    try {
      ugcRepository.deleteUgc(ugcId, contextId);
      final SocialEvent<T> event =
          new SocialEvent<T>(
              ugcId, SocialSecurityUtils.getCurrentProfile().getId().toString(), UGCEvent.DELETE);
      event.setAttribute("baseUrl", calculateBaseUrl());

      reactor.notify(UGCEvent.DELETE.getName(), Event.wrap(event));
    } catch (MongoDataException ex) {
      log.error("logging.ugc.deleteUgcError", ex, ugcId, contextId);
      throw new UGCException("Unable to delete UGC", ex);
    }
    return false;
  }
Beispiel #10
0
  @Override
  @HasPermission(action = UGC_CREATE, type = SocialPermission.class)
  public UGC create(
      final String contextId,
      final String ugcParentId,
      final String targetId,
      final String textContent,
      final String subject,
      final Map attrs,
      final boolean isAnonymous)
      throws SocialException {
    log.debug("logging.ugc.creatingUgc", contextId, targetId, ugcParentId, subject, attrs);
    final UGC template = new UGC(subject, textContent, targetId);

    template.setAnonymousFlag(isAnonymous);
    T newUgc = (T) ugcFactory.newInstance(template);
    newUgc.setAttributes(attrs);
    try {
      if (ObjectId.isValid(ugcParentId)) {
        setupAncestors(newUgc, ugcParentId, contextId);

      } else {
        log.debug("logging.ugc.invalidParentId");
      }
      if (StringUtils.isBlank(contextId)) {
        throw new IllegalArgumentException("context cannot be null");
      }
      pipeline.processUgc(newUgc);
      ugcRepository.save(newUgc);

      final SocialEvent<T> event =
          new SocialEvent<>(
              newUgc, SocialSecurityUtils.getCurrentProfile().getId().toString(), UGCEvent.CREATE);
      event.setAttribute("baseUrl", calculateBaseUrl());
      reactor.notify(UGCEvent.CREATE.getName(), Event.wrap(event));
      setupAutoWatch(targetId, SocialSecurityUtils.getCurrentProfile(), contextId);
      log.info("logging.ugc.created", newUgc);
      return newUgc;
    } catch (MongoDataException ex) {
      log.error("logging.ugc.errorSaving", ex);
      throw new UGCException("Unable to Save UGC");
    }
  }
Beispiel #11
0
 @Override
 @HasPermission(action = UGC_READ, type = SocialPermission.class)
 public long countChildren(final String ugcId, final String contextId) throws UGCException {
   try {
     return ugcRepository.countChildrenOf(contextId, ugcId);
   } catch (MongoDataException ex) {
     log.error("logging.ugc.unableToCount", ex);
     throw new UGCException("Unable to count children of Ugc");
   }
 }
Beispiel #12
0
 @Override
 @HasPermission(action = UGC_READ, type = SocialPermission.class)
 public long count(final String threadId, final String contextId) throws UGCException {
   try {
     return ugcRepository.countByTargetId(contextId, threadId, 0);
   } catch (MongoDataException e) {
     log.error("logging.ugc.unableToCount");
     throw new UGCException("Unable to count UGC by target and context", e);
   }
 }
Beispiel #13
0
 @Override
 @HasPermission(action = UGC_READ, type = SocialPermission.class)
 public UGC read(final String ugcId, final String contextId) throws UGCException {
   try {
     return ugcRepository.findUGC(contextId, ugcId);
   } catch (MongoDataException e) {
     log.error("logging.ugc.unableToReadP", e, ugcId, contextId);
     throw new UGCException("Unable to find UGC with given ID and context");
   }
 }
Beispiel #14
0
  @Override
  @HasPermission(action = UGC_UPDATE, type = SocialPermission.class)
  public FileInfo addAttachment(
      @SecuredObject final String ugcId,
      final String contextId,
      final InputStream attachment,
      final String fileName,
      final String contentType)
      throws FileExistsException, UGCException {
    String internalFileName =
        File.separator + contextId + File.separator + ugcId + File.separator + fileName;
    try {
      checkForVirus(attachment);
    } catch (IOException | VirusScannerException ex) {
      log.error("logging.ugc.errorScanVirus", ex);
      return null;
    }

    try {
      UGC ugc = ugcRepository.findUGC(contextId, ugcId);
      if (ugc == null) {
        throw new IllegalUgcException("UGC with given Id does not exist");
      }
      FileInfo info = ugcRepository.saveFile(attachment, internalFileName, contentType);
      try {
        info.setFileName(new URLCodec().decode(fileName));
      } catch (DecoderException e) {
        info.setFileName(fileName);
      }
      info.setAttribute("owner", ugcId);
      ugc.getAttachments().add(info);
      ugcRepository.update(ugcId, ugc);
      reactor.notify(
          UGCEvent.ADD_ATTACHMENT.getName(),
          Event.wrap(
              new SocialEvent<>(
                  ugcId, new InputStream[] {new CloseShieldInputStream(attachment)})));
      return info;
    } catch (MongoDataException e) {
      log.error("logging.ugc.unableToSaveAttachment", e, internalFileName);
      throw new UGCException("Unable to save File to UGC");
    }
  }
Beispiel #15
0
 @Override
 @HasPermission(action = UGC_UPDATE, type = SocialPermission.class)
 public void deleteAttribute(
     @SecuredObject final String ugcId, final String[] attributesName, final String contextId)
     throws SocialException {
   log.debug("logging.ugc.deleteAttributes", attributesName, ugcId);
   try {
     ugcRepository.deleteAttribute(ugcId, contextId, attributesName);
     final SocialEvent<T> event =
         new SocialEvent<T>(
             ugcId,
             SocialSecurityUtils.getCurrentProfile().getId().toString(),
             UGCEvent.DELETE_ATTRIBUTES);
     event.setAttribute("baseUrl", calculateBaseUrl());
     reactor.notify(UGCEvent.DELETE_ATTRIBUTES.getName(), Event.wrap(event));
   } catch (MongoDataException ex) {
     log.debug("logging.ugc.unableToDelAttrs", ex, attributesName, ugcId);
     throw new UGCException("Unable to delete attribute for ugc", ex);
   }
 }
 @Override
 public boolean setContextPreferences(
     final Map<String, Object> preferences, final String contextId) {
   try {
     final String preferencesString = new ObjectMapper().writeValueAsString(preferences);
     final String byId = getQueryFor("social.system.preferences.emailPreferencesByContextId");
     getCollection().update(byId, contextId).with("{$set: " + preferencesString + "}");
     return true;
   } catch (MongoException | JsonProcessingException e) {
     logger.error("Unable to delete context Preferences", e);
     return false;
   }
 }
Beispiel #17
0
 @Override
 @HasPermission(action = UGC_READ, type = SocialPermission.class)
 public List<T> readChildren(
     final String ugcId,
     final String targetId,
     final String contextId,
     final int start,
     final int limit,
     final List sortOrder,
     final int upToLevel,
     final int childrenPerLevel)
     throws UGCException, UGCNotFound {
   log.debug("logging.ugc.readChildren", ugcId, contextId, limit, start);
   try {
     return buildUgcTreeList(
         IterableUtils.toList(
             ugcRepository.findChildren(
                 ugcId, targetId, contextId, start, limit, sortOrder, upToLevel)),
         childrenPerLevel);
   } catch (MongoDataException ex) {
     log.error("logging.ugc.unableToRead", ex);
     throw new UGCException("Unable to ", ex);
   }
 }
Beispiel #18
0
 @Override
 @HasPermission(action = UGC_READ, type = SocialPermission.class)
 public Iterable<T> search(
     final String contextId,
     final String query,
     final String sort,
     final int start,
     final int limit)
     throws UGCException {
   log.debug(
       "Finding all ugc of context {} with user query {} sorted by {} skipping {} and with a limit of {}",
       contextId,
       query,
       sort,
       start,
       limit);
   isQueryValid(query);
   try {
     return ugcRepository.findByUserQuery(contextId, query, sort, start, limit);
   } catch (MongoDataException ex) {
     log.error("Unable to find User with given query" + query + " sorted by " + sort, ex);
     throw new UGCException("Unable to find Ugc with user query ", ex);
   }
 }
Beispiel #19
0
 private void setupAutoWatch(
     final String targetId, final Profile currentProfile, final String context)
     throws NotificationException {
   final Map<String, Object> profileMap = currentProfile.getAttributes();
   if (profileMap.containsKey("defaultFrequency") && profileMap.containsKey("autoWatch")) {
     boolean autoWatch = currentProfile.getAttribute("autoWatch");
     if (autoWatch) {
       notificationService.subscribeUser(
           currentProfile,
           context + "/" + targetId,
           (String) currentProfile.getAttribute("defaultFrequency"));
     }
   } else {
     log.debug("Profile don't have set either defaultFrequency or autoWatch attributes");
   }
 }
Beispiel #20
0
 @Override
 @HasPermission(action = UGC_READ, type = SocialPermission.class)
 public T read(
     final String ugcId,
     final boolean includeChildren,
     final int childCount,
     final String contextId)
     throws UGCException {
   try {
     if (includeChildren) {
       return getUgcTree(ugcId, childCount, contextId);
     } else {
       return (T) ugcRepository.findUGC(contextId, ugcId);
     }
   } catch (MongoDataException e) {
     log.error("logging.ugc.unableToRead");
     throw new UGCException("Unable to find ugc by name");
   }
 }
 @Override
 public boolean deleteContextPreferences(final String context, final List<String> preferences) {
   try {
     final String byId = getQueryFor("social.system.preferences.emailPreferencesByContextId");
     String toUnset = "";
     final Iterator<String> iter = preferences.iterator();
     while (iter.hasNext()) {
       final String key = iter.next();
       toUnset += "preferences." + key + ":1";
       if (iter.hasNext()) {
         toUnset += ",";
       }
     }
     getCollection().update(byId, context).with("{$unset:{" + toUnset + "}}");
     return true;
   } catch (MongoException e) {
     logger.error("Unable to delete context Preferences", e);
     return false;
   }
 }
Beispiel #22
0
 @Override
 @HasPermission(action = UGC_READ, type = SocialPermission.class)
 public List<T> read(
     final String targetId,
     final String contextId,
     final int start,
     final int limit,
     final List sortOrder,
     final int upToLevel,
     final int childrenPerLevel)
     throws UGCException {
   try {
     List<T> list =
         IterableUtils.toList(
             ugcRepository.findByTargetId(
                 targetId, contextId, start, limit, sortOrder, upToLevel));
     list = sortByArrays(list, sortOrder);
     return buildUgcTreeList(list, childrenPerLevel);
   } catch (MongoDataException e) {
     log.error("logging.ugc.unableToRead");
     throw new UGCException("Unable to find ugc by target");
   }
 }
 @Override
 public String findNotificationTemplate(final String contextId, final String notificationType)
     throws SocialException {
   try {
     String query = getQueryFor("social.system.preferences.notificationEmailByType");
     Map qResult =
         getCollection()
             .findOne(query, contextId, notificationType.toUpperCase())
             .projection("{\"templates.$\":1,_id:0}")
             .as(Map.class);
     if (qResult == null) {
       return null;
     }
     final List templates = (List) qResult.get("templates");
     if (templates == null) {
       return null;
     }
     if (templates.isEmpty()) {
       throw new SocialException(
           "No template for type"
               + notificationType
               + " has been define for context "
               + ""
               + contextId);
     } else {
       if (templates.size() > 1) {
         logger.warn(
             "logging.system.notification.multipleTemplatesForType", notificationType, contextId);
       }
       return ((Map) templates.get(0)).get("template").toString();
     }
   } catch (MongoException ex) {
     throw new SocialException(
         "Unable to get Notification Template for " + contextId + " of type" + notificationType);
   }
 }