Java tutorial
/* Copyright 2010 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License */ package com.google.ie.business.service.impl; import com.google.ie.business.dao.AdminRequestDao; import com.google.ie.business.dao.IdeaDao; import com.google.ie.business.dao.impl.DaoConstants; import com.google.ie.business.domain.AdminRequest; import com.google.ie.business.domain.EntityIndex; import com.google.ie.business.domain.Idea; import com.google.ie.business.domain.Project; import com.google.ie.business.domain.Tag; import com.google.ie.business.domain.User; import com.google.ie.business.service.EntityIndexService; import com.google.ie.business.service.IdeaService; import com.google.ie.business.service.ProjectService; import com.google.ie.business.service.ServiceConstants; import com.google.ie.business.service.ShardedCounterService; import com.google.ie.business.service.TagService; import com.google.ie.business.service.UserService; import com.google.ie.common.audit.AuditManager; import com.google.ie.common.cache.CacheConstants; import com.google.ie.common.cache.CacheHelper; import com.google.ie.common.constants.IdeaExchangeConstants; import com.google.ie.common.constants.IdeaExchangeErrorCodes; import com.google.ie.common.exception.SystemException; import com.google.ie.common.objectionable.ObjectionableManager; import com.google.ie.common.taskqueue.IndexQueueUpdater; import com.google.ie.common.taskqueue.TagWeightUpdationManager; import com.google.ie.dto.RetrievalInfo; import org.apache.commons.lang.StringUtils; import org.apache.log4j.Logger; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Propagation; import org.springframework.transaction.annotation.Transactional; import java.util.ArrayList; import java.util.Date; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.LinkedList; import java.util.List; import java.util.Map; import java.util.Set; /** * A service implementation of the IdeaService * * @author Charanjeet singh */ @Service public class IdeaServiceImpl implements IdeaService { private static Logger logger = Logger.getLogger(IdeaServiceImpl.class); private static boolean isDebug = logger.isDebugEnabled(); /* Default number of recent ideas to be fetched */ private static final int DEFAULT_NO_OF_RECENT_IDEAS = 3; /* Default number of popular ideas to be fetched */ private static final int DEFAULT_NO_OF_POPULAR_IDEAS = 3; @Autowired private IdeaDao ideaDao; @Autowired private EntityIndexService entityIndexService; @Autowired private AuditManager auditManager; @Autowired private TagService tagService; @Autowired private TagWeightUpdationManager weightUpdationManager; @Autowired private UserService userService; @Autowired private ShardedCounterService shardedCounterService; @Autowired private AdminRequestDao adminRequestDao; @Autowired private ProjectService projectService; @Autowired private IndexQueueUpdater indexQueueUpdater; public IndexQueueUpdater getIndexQueueUpdater() { return indexQueueUpdater; } public void setIndexQueueUpdater(IndexQueueUpdater indexQueueUpdater) { this.indexQueueUpdater = indexQueueUpdater; } public IdeaServiceImpl() { } @Override public Idea saveIdea(Idea idea, User user) { user = userService.getUserById(user.getId()); if (user != null) { if (idea != null && !StringUtils.isBlank(idea.getTitle()) && !StringUtils.isBlank(user.getUserKey())) { if (isDebug) { logger.debug("Idea title=" + idea.getTitle() + " ,user key=" + user.getUserKey()); } Idea savedIdea = saveIdeaLocal(idea, user); return savedIdea; } } return null; } @Override public void deleteIdea(String key, User user) { Idea idea = new Idea(); idea = ideaDao.findEntityByPrimaryKey(idea.getClass(), key); if (idea != null && user != null && !StringUtils.isBlank(user.getUserKey())) { // Soft delete the idea. idea.setStatus(Idea.STATUS_DELETED); ideaDao.saveIdea(idea); } } /** * Saves an idea. * * @param idea Idea to be saved. * @return Returns the saved idea object. */ private Idea saveIdeaLocal(Idea idea, User user) { if (!StringUtils.isBlank(idea.getStatus()) && idea.getStatus().equals(Idea.STATUS_PUBLISHED)) { throw new SystemException(IdeaExchangeErrorCodes.INVALID_PUBLISH, IdeaExchangeConstants.Messages.INVALID_PUBLISH); } /* Handle tags. */ String tagString = idea.getTags(); if (!StringUtils.isBlank(tagString)) { logger.debug("Submitted tags=" + tagString); idea.setTags(formatTagString(tagString)); } /* Update the status and save in data store */ idea.setCreatorKey(user.getUserKey()); idea.setStatus(Idea.STATUS_SAVED); idea.setLastUpdated(new Date(System.currentTimeMillis())); idea = getIdeaDao().saveIdea(idea); if (idea != null && !StringUtils.isBlank(idea.getKey())) { /* Add saved idea key into users ideaKeys set. */ addIdeaKeyToUser(idea, user); logger.info("Idea with title='" + idea.getTitle() + "', saved successfully"); } return idea; } @Override @Transactional(readOnly = false, propagation = Propagation.REQUIRED) public Idea publishIdea(Idea idea, User user) { if (user != null) { /* * boolean specifying whether the idea to be published was earlier * marked as objectionable.If true no points would be added to the * user */ boolean wasObjectionable = false; if (!StringUtils.isBlank(idea.getKey())) { /* If the idea is already published,throw exception */ if (Idea.STATUS_PUBLISHED.equals(idea.getStatus())) { throw new SystemException(IdeaExchangeErrorCodes.INVALID_PUBLISH, IdeaExchangeConstants.Messages.INVALID_PUBLISH); } /* * If the idea was earlier objectionable,set the boolean to * true. */ if (Idea.STATUS_OBJECTIONABLE.equalsIgnoreCase(idea.getStatus())) { wasObjectionable = true; } } if (!StringUtils.isBlank(idea.getTitle()) && !StringUtils.isBlank(user.getUserKey())) { if (isDebug) { logger.debug("User key=" + user.getUserKey() + " ,idea title=" + idea.getTitle()); } String tagString = idea.getTags(); if (!StringUtils.isBlank(tagString)) { if (isDebug) { logger.debug("Submitted tags=" + tagString); } idea.setTags(formatTagString(tagString)); } idea.setCreatorKey(user.getUserKey()); idea.setStatus(Idea.STATUS_PUBLISHED); idea.setLastUpdated(new Date(System.currentTimeMillis())); idea.setPublishDate(new Date(System.currentTimeMillis())); /* Persist idea object. */ idea = publishIdeaLocal(idea); if (idea != null && !StringUtils.isBlank(idea.getKey())) { return performAfterPublish(idea, user, wasObjectionable); } } } return null; } @SuppressWarnings("unchecked") @Override public LinkedList<Idea> getRecentIdeas() { /* Check the cache for the data */ LinkedList<Idea> listOfRecentIdeas = (LinkedList<Idea>) CacheHelper.getObject(CacheConstants.IDEA_NAMESPACE, CacheConstants.RECENT_IDEAS); if (listOfRecentIdeas != null && listOfRecentIdeas.size() > ServiceConstants.ZERO) { logger.info("Recent ideas successfully fetched from cache"); return listOfRecentIdeas; } /* If not found in cache then retrieve from data store. */ RetrievalInfo retrievalInfo = new RetrievalInfo(); retrievalInfo.setNoOfRecords(DEFAULT_NO_OF_RECENT_IDEAS); retrievalInfo.setOrderBy(ServiceConstants.DEFAULT_IDEA_ORDERING_FIELD); retrievalInfo.setOrderType(ServiceConstants.ORDERING_TYPE_FOR_RECENT_IDEAS); /* Fetch the ideas and create a linked list from the fetched data */ listOfRecentIdeas = createLinkedListFromTheFetchedData(getIdeas(retrievalInfo)); /* If the list contains data, add it to the cache */ if (listOfRecentIdeas.size() > ServiceConstants.ZERO) { CacheHelper.putObject(CacheConstants.IDEA_NAMESPACE, CacheConstants.RECENT_IDEAS, listOfRecentIdeas, CacheConstants.RECENT_IDEAS_EXPIRATION_DELAY); logger.info("Recent ideas successfully added to the cache"); } return listOfRecentIdeas; } /** * It performs all other activity, which are needed after publishing the * idea. * * @param idea The published {@link Idea} object. * @param user The {@link User} who has published the idea. * @param wasObjectionale whether the idea was earlier an objectionable one * @return Idea object. */ private Idea performAfterPublish(Idea idea, User user, boolean wasObjectionale) { logger.info("Idea with title=" + idea.getTitle() + ", saved successfully"); /* If the idea is a new one add points to the user */ if (!wasObjectionale) { /* Add saved idea key into users ideaKeys set. */ user = addIdeaKeyToUser(idea, user); addPointsToUserOnIdeaPublish(user.getUserKey(), idea); } /* Place object into cache. */ CacheHelper.putObject(CacheConstants.IDEA_NAMESPACE, idea.getKey(), idea); /* Place object into cache for recent ideas. */ addIdeaToListInCache(idea, CacheConstants.RECENT_IDEAS, DEFAULT_NO_OF_RECENT_IDEAS, CacheConstants.RECENT_IDEAS_EXPIRATION_DELAY); String tagStr = idea.getTags(); /* Increment Tags weights asynchronously. */ if (tagStr != null && !tagStr.equals("")) getWeightUpdationManager().incrementWeight(tagStr); /* Audit the published activity. */ getAuditManager().audit(user.getUserKey(), idea.getKey(), idea.getClass().getName(), ServiceConstants.AUDIT_ACTION_TYPE_PUBLISH_IDEA); /* Check idea for objectionable. */ ObjectionableManager.checkObjectionable(idea.getKey()); return idea; } @SuppressWarnings("unchecked") public void addIdeaToListInCache(Idea originalIdea, String keyOfTheList, int noOfIdeas, int expiryDelay) { LinkedList<Idea> listOfIdeas = (LinkedList<Idea>) CacheHelper.getObject(CacheConstants.IDEA_NAMESPACE, keyOfTheList); if (listOfIdeas != null) { if (listOfIdeas.size() >= noOfIdeas) { /* Remove the last element which is also the oldest */ listOfIdeas.pollLast(); } } else { listOfIdeas = new LinkedList<Idea>(); } /* Create a new idea object to contain the required data only */ Idea ideaWithTheRequiredDataOnly = new Idea(); ideaWithTheRequiredDataOnly .setTitle(StringUtils.abbreviate(originalIdea.getTitle(), ServiceConstants.FIFTY)); /* Limit the description to hundred characters */ ideaWithTheRequiredDataOnly .setDescription(StringUtils.abbreviate(originalIdea.getDescription(), ServiceConstants.HUNDRED)); ideaWithTheRequiredDataOnly.setKey(originalIdea.getKey()); /* Add the idea to the head of the list */ listOfIdeas.addFirst(ideaWithTheRequiredDataOnly); /* Put the updated list back to the cache */ CacheHelper.putObject(CacheConstants.IDEA_NAMESPACE, keyOfTheList, listOfIdeas, expiryDelay); } /** * Update sharded counters for the users reputation point calculation. * * @param user * @param idea * @return */ private void addPointsToUserOnIdeaPublish(String userKey, Idea idea) { int points = 0; if (!StringUtils.isBlank(idea.getTitle())) { points = points + IdeaExchangeConstants.REPUTATION_POINTS_TITLE; } if (!StringUtils.isBlank(idea.getDescription())) { points = points + IdeaExchangeConstants.REPUTATION_POINTS_DESCRIPTION; } if (!StringUtils.isBlank(idea.getMonetization())) { points = points + IdeaExchangeConstants.REPUTATION_POINTS_MONETIZATION; } if (!StringUtils.isBlank(idea.getCompetition())) { points = points + IdeaExchangeConstants.REPUTATION_POINTS_COMPETITION; } if (!StringUtils.isBlank(idea.getTargetAudience())) { points = points + IdeaExchangeConstants.REPUTATION_POINTS_TARGET_AUDIENCE; } updateShardedCounter(userKey, points); } /** * Update counter. * * @param user * @param points */ @Transactional(readOnly = false, propagation = Propagation.REQUIRES_NEW) private void updateShardedCounter(String userKey, int points) { shardedCounterService.updateTotalPoints(userKey, points); } /** * Adds the {@link Idea } key to user's idea key set on save and publish * idea. * * @param idea The saved/published {@link Idea} object. * @param user The {@link User} who has saved/published the idea. * @return User object. */ private User addIdeaKeyToUser(Idea idea, User user) { if (idea.getKey() != null) { user.getIdeaKeys().add(idea.getKey()); userService.saveUser(user); } return user; } @Transactional(readOnly = false, propagation = Propagation.REQUIRED) public Idea publishIdeaLocal(Idea idea) { // Persist idea object. idea = getIdeaDao().saveIdea(idea); if (idea != null) { /* * Index the entity.Create an EntityIndex object for the entity * to be indexed and then queue the job to task queue */ EntityIndex entityIndex = entityIndexService.createEntityIndex(idea.getKey()); getIndexQueueUpdater().indexEntity(entityIndex.getKey()); } return idea; } /** * Formats the tag string submitted by application user for display on view. * * @param tagString String having tags submitted by application user. * @return formated comma separate tags string. */ protected final String formatTagString(String tagString) { String[] tags = tagString.trim().split("[\\s,]"); StringBuilder sb = new StringBuilder(); for (int i = 0; i < tags.length; i++) { String tmpString = tags[i].trim().toLowerCase(); if (!tmpString.equals("")) sb.append(tmpString + ","); if (i == tags.length - 1) sb.deleteCharAt(sb.length() - 1); } return sb.toString(); } @Override public Idea getIdeaDetails(Idea idea) { if (idea != null && !StringUtils.isBlank(idea.getKey())) { if (isDebug) { logger.debug("Retrieving idea details for the idea with key=" + idea.getKey()); } return ideaDao.getIdea(idea); } return null; } @Override public List<Idea> getIdeas(RetrievalInfo retrievalInfo) { /* * Retrieve ideas based on the retrieval information. If retrievalInfo * object is null then use default parameter information. */ retrievalInfo = prepareRetrievalInfoForQuery(retrievalInfo); /* Prepare the Set of status */ Set<String> statusOfIdeas = new HashSet<String>(); statusOfIdeas.add(Idea.STATUS_PUBLISHED); statusOfIdeas.add(Idea.STATUS_DUPLICATE); return ideaDao.getIdeas(retrievalInfo, statusOfIdeas); } @Override public boolean addSummary(String key, String summary, User user) { Idea idea = new Idea(); idea = ideaDao.findEntityByPrimaryKey(idea.getClass(), key); if (idea == null || user == null || StringUtils.isBlank(idea.getKey()) || StringUtils.isBlank(user.getUserKey()) || StringUtils.isBlank(idea.getStatus()) || !(idea.getStatus().equals(Idea.STATUS_PUBLISHED)) || StringUtils.isBlank(idea.getCreatorKey()) || !(idea.getCreatorKey().equals(user.getUserKey()))) { throw new SystemException(IdeaExchangeErrorCodes.INVALID_IDEA_SUMMARY, IdeaExchangeConstants.Messages.INVALID_IDEA_SUMMARY); } // Allow user to add Idea summary only once. if (StringUtils.isBlank(idea.getIdeaSummary())) { idea.setIdeaSummary(summary); getIdeaDao().saveIdea(idea); return true; } return false; } /* Returns the ideas saved or published by user */ @Override public List<Idea> getIdeasForUser(User user, RetrievalInfo retrievalInfo) { if (user == null || StringUtils.isBlank(user.getUserKey())) { return null; } if (isDebug) { logger.debug("Retrieving ideas for the user with key=" + user.getUserKey()); } /* * Retrieve user's ideas based on the retrieval information. In case of * listing user's ideas, ordering will be done on the field * 'lastUpdated'. */ if (retrievalInfo == null) { retrievalInfo = new RetrievalInfo(); } retrievalInfo.setOrderBy(DaoConstants.IDEA_ORDERING_FIELD_LAST_UPDATE_DATE); // Prepare retrieval parameters to fetch users idea. retrievalInfo = prepareRetrievalInfoForQuery(retrievalInfo); /* Prepare the Set of status */ Set<String> statusOfIdeas = new HashSet<String>(); statusOfIdeas.add(Idea.STATUS_SAVED); statusOfIdeas.add(Idea.STATUS_PUBLISHED); statusOfIdeas.add(Idea.STATUS_OBJECTIONABLE); statusOfIdeas.add(Idea.STATUS_DUPLICATE); return ideaDao.getUserIdeas(user, statusOfIdeas, retrievalInfo); } @Override public boolean updateStatus(Idea idea) { if (idea == null || StringUtils.isBlank(idea.getKey())) { return false; } if (isDebug) { logger.debug("updating status of idea for the key=" + idea.getKey()); } return ideaDao.updateStatus(idea); } @Override public boolean updateIdeaVotes(Idea idea) { boolean flag = false; if (idea != null && !StringUtils.isBlank(idea.getKey())) { if (isDebug) { logger.debug("updating status of idea for the key=" + idea.getKey()); } flag = ideaDao.updateIdeaPoints(idea); } return flag; } @Override public List<Idea> getIdeasByTagName(String tagName, RetrievalInfo retrievalInfo) { /* * If the tagname param is not null and is not empty then fetch the Tag * object through tag service */ if (tagName != null && tagName.length() > ServiceConstants.ZERO) { Tag tag = tagService.getTagByName(tagName); /* If tag is not null then get the key of the tag */ if (tag != null) { String tagKey = tag.getKey(); /* * If the tag key contains value then fetch the * list of ideas associated with the tag key */ if (tagKey.length() > ServiceConstants.ZERO) { retrievalInfo = prepareRetrievalInfoForQuery(retrievalInfo); Set<String> statusOfIdeas = new HashSet<String>(); statusOfIdeas.add(Idea.STATUS_PUBLISHED); statusOfIdeas.add(Idea.STATUS_DUPLICATE); List<Idea> ideaList = ideaDao.getIdeasByTagKey(tagKey, statusOfIdeas, retrievalInfo); return ideaList; } } } return null; } @SuppressWarnings("unchecked") @Override public LinkedList<Idea> getPopularIdeas() { /* First check the cache for the data */ LinkedList<Idea> popularIdeas = (LinkedList<Idea>) CacheHelper.getObject(CacheConstants.IDEA_NAMESPACE, CacheConstants.POPULAR_IDEAS); if (popularIdeas != null && popularIdeas.size() > ServiceConstants.ZERO) { logger.info("Popular ideas successfully fetched from cache"); return popularIdeas; } /* If not in cache ,fetch from data store */ RetrievalInfo retrievalInfo = new RetrievalInfo(); /* Set the RetrievalInfo object to contain query parameters */ retrievalInfo.setNoOfRecords(DEFAULT_NO_OF_POPULAR_IDEAS); retrievalInfo.setOrderBy(ServiceConstants.IDEA_ORDERING_FIELD_TOTAL_POSITIVE_VOTES); retrievalInfo.setOrderType(ServiceConstants.ORDERING_DESCENDING); /* Create the set of status conditions to be matched in the query */ Set<String> statusOfIdeas = new HashSet<String>(); statusOfIdeas.add(Idea.STATUS_PUBLISHED); /* * Fetch the ideas from the datastore and create a linked list from the * fetched ideas */ popularIdeas = createLinkedListFromTheFetchedData(ideaDao.getIdeas(retrievalInfo, statusOfIdeas)); if (popularIdeas.size() > ServiceConstants.ZERO) { /* Put popular ideas into cache */ CacheHelper.putObject(CacheConstants.IDEA_NAMESPACE, CacheConstants.POPULAR_IDEAS, popularIdeas, CacheConstants.POPULAR_IDEAS_EXPIRATION_DELAY); logger.info("Popular ideas successfully added to the cache"); } return popularIdeas; } /** * Prepares the {@link RetrievalInfo} object with values to be used as query * parameters. * Checks the received RetrievalInfo object attributes for valid * data.Updates the attributes if they contain garbage values.If the * received {@link RetrievalInfo} object is null,sets it to a new instance * with its attributes set to default values. * * @param retrievalInfo the {@link RetrievalInfo} object containing the * values to be used as query parameters * @return the {@link RetrievalInfo} object containing the query parameters */ private RetrievalInfo prepareRetrievalInfoForQuery(RetrievalInfo retrievalInfo) { if (retrievalInfo == null) { retrievalInfo = new RetrievalInfo(); retrievalInfo.setStartIndex(ServiceConstants.ZERO); retrievalInfo.setNoOfRecords(ServiceConstants.IDEAS_LIST_DEFAULT_SIZE); retrievalInfo.setOrderType(ServiceConstants.DEFAULT_IDEA_ORDERING_TYPE); retrievalInfo.setOrderBy(ServiceConstants.DEFAULT_IDEA_ORDERING_FIELD); } else { // Handle garbage values if any. String orderBY = retrievalInfo.getOrderBy(); String orderType = retrievalInfo.getOrderType(); if (retrievalInfo.getStartIndex() < ServiceConstants.ZERO) retrievalInfo.setStartIndex(ServiceConstants.ZERO); if (retrievalInfo.getNoOfRecords() <= ServiceConstants.ZERO) retrievalInfo.setNoOfRecords(ServiceConstants.IDEAS_LIST_DEFAULT_SIZE); if (orderType == null || !((orderType.equals(DaoConstants.ORDERING_ASCENDING) || orderType.equals(DaoConstants.ORDERING_DESCENDING)))) retrievalInfo.setOrderType(ServiceConstants.DEFAULT_IDEA_ORDERING_TYPE); if (orderBY == null || !((orderBY.equals(DaoConstants.IDEA_ORDERING_FIELD_LAST_UPDATE_DATE) || orderBY.equals(DaoConstants.IDEA_ORDERING_FIELD_PUBLISH_DATE) || orderBY.equals(DaoConstants.IDEA_ORDERING_FIELD_VOTE)))) { retrievalInfo.setOrderBy(ServiceConstants.DEFAULT_IDEA_ORDERING_FIELD); } } return retrievalInfo; } /** * Create a linked list from the list of ideas received.Removes the data not * required on the homepage.This method is intended to create * list for Recent ideas and Popular ideas method * * @param ideas list of ideas * @return a {@link LinkedList} object containing the ideas */ private LinkedList<Idea> createLinkedListFromTheFetchedData(List<Idea> ideas) { LinkedList<Idea> linkedList = new LinkedList<Idea>(); Iterator<Idea> iterator = ideas.iterator(); Idea originalIdea = null; Idea ideaWithTheRequiredDataOnly = null; while (iterator.hasNext()) { originalIdea = iterator.next(); if (originalIdea.getStatus().equals(Idea.STATUS_OBJECTIONABLE)) continue; ideaWithTheRequiredDataOnly = new Idea(); ideaWithTheRequiredDataOnly .setTitle(StringUtils.abbreviate(originalIdea.getTitle(), ServiceConstants.FIFTY)); /* Limit the description to hundred characters */ ideaWithTheRequiredDataOnly.setDescription( StringUtils.abbreviate(originalIdea.getDescription(), ServiceConstants.HUNDRED)); ideaWithTheRequiredDataOnly.setKey(originalIdea.getKey()); /* Add the idea to the linked list */ linkedList.add(ideaWithTheRequiredDataOnly); } return linkedList; } @Override public String flagObjectionableIdea(String ideaKey, User user) { String status = IdeaExchangeConstants.FAIL; /* Get title of the idea */ Idea idea = this.getIdeaByKey(ideaKey); if (idea != null && isFlagTypeAllreadyExist(idea.getFlagType(), Idea.FLAG_TYPE_OBJECTIONABLE)) { status = IdeaExchangeConstants.IDEA_ALLREADY_FLAGED; return status; } /* * Create an admin request to handle the objectionabe flag request for * idea */ AdminRequest adminRequest = new AdminRequest(); adminRequest.setEntityKey(ideaKey); adminRequest.setEntityType(Idea.class.getSimpleName()); adminRequest.setRequesterkey(user.getUserKey()); adminRequest.setRequestType(AdminRequest.REQUEST_OBJECTIONABLE); adminRequest.setCreatedOn(new Date()); adminRequest.setStatus(AdminRequest.STATUS_PENDING); if (!StringUtils.isBlank(user.getEmailId())) { adminRequest.setRequesterEmail(user.getEmailId()); } /* Get Idea to get title and update FlagType of the entity */ if (idea != null && !StringUtils.isBlank(idea.getKey())) { adminRequest.setEntityTitle(idea.getTitle()); idea.getFlagType().add(Idea.FLAG_TYPE_OBJECTIONABLE); ideaDao.saveIdea(idea); } else { throw new SystemException(IdeaExchangeErrorCodes.IDEA_NULL_EXCEPTION, "There is no idea that belongs to the given key in data store"); } if (adminRequestDao.saveRequest(adminRequest)) { status = IdeaExchangeConstants.SUCCESS; } return status; } @Override public String flagDuplicateIdea(String ideaKey, String originalIdeakey, User user) { String status = IdeaExchangeConstants.FAIL; /* Get title of the idea */ Idea idea = this.getIdeaByKey(ideaKey); if (idea != null && isFlagTypeAllreadyExist(idea.getFlagType(), Idea.FLAG_TYPE_DUPLICATE)) { status = IdeaExchangeConstants.IDEA_ALLREADY_MARKED_DUPLICATE; return status; } /* * Create an admin request to handle the duplicate flag request for * idea. */ AdminRequest adminRequest = new AdminRequest(); adminRequest.setEntityKey(ideaKey); adminRequest.setEntityType(Idea.class.getSimpleName()); adminRequest.setRequesterkey(user.getUserKey()); if (!StringUtils.isBlank(user.getEmailId())) { adminRequest.setRequesterEmail(user.getEmailId()); } adminRequest.setRequestType(AdminRequest.REQUEST_DUPLICATE); adminRequest.setCreatedOn(new Date()); /* Creating string for other information set of AdminRequest */ StringBuilder otherInfoString = new StringBuilder(); otherInfoString.append(AdminRequest.INFO_ORIGINAL_IDEA_KEY); otherInfoString.append(AdminRequest.INFO_SEPARATOR); otherInfoString.append(originalIdeakey); Set<String> otherInfo = new HashSet<String>(); otherInfo.add(otherInfoString.toString()); adminRequest.setOtherInfo(otherInfo); adminRequest.setStatus(AdminRequest.STATUS_PENDING); /* Mark Idea as duplicate and save into data store. */ if (idea != null && !StringUtils.isBlank(idea.getKey())) { adminRequest.setEntityTitle(idea.getTitle()); idea.getFlagType().add(Idea.FLAG_TYPE_DUPLICATE); idea.setOriginalIdeaKey(originalIdeakey); ideaDao.saveIdea(idea); } else { throw new SystemException(IdeaExchangeErrorCodes.IDEA_NULL_EXCEPTION, "There is no idea that belongs to the given key in data store"); } /* Save admin request */ if (adminRequestDao.saveRequest(adminRequest)) { status = IdeaExchangeConstants.SUCCESS; } return status; } /** * check for flag type. * * @param flagTypes Type of flags associated with idea for Example * Objectionable,Duplicate. * @param flagTypeToCheck Type of flags associated with the idea. * @return True if flag already exist in set of flagTypes. */ private boolean isFlagTypeAllreadyExist(Set<String> flagTypes, String flagTypeToCheck) { for (String flagType : flagTypes) { if (flagType != null && flagType.equalsIgnoreCase(flagTypeToCheck)) { return true; } } return false; } @Override public Idea updateIdea(Idea idea) { return ideaDao.saveIdea(idea); } @SuppressWarnings("unchecked") @Override public LinkedList<Idea> getRecentlyPickedIdeas() { /* First check the cache for the data */ LinkedList<Idea> recentlyPickedIdeas = (LinkedList<Idea>) CacheHelper .getObject(CacheConstants.IDEA_NAMESPACE, CacheConstants.RECENTLY_PICKED_IDEAS); if (recentlyPickedIdeas != null && recentlyPickedIdeas.size() > ServiceConstants.ZERO) { logger.info("Recently picked ideas successfully fetched from cache"); return recentlyPickedIdeas; } /* * Get the recently created projects.Iterate through the list and fetch * key of idea related to the project */ List<Project> recentProjects = projectService.getRecentProjects(); List<Idea> ideas = new ArrayList<Idea>(); Iterator<Project> iterator = recentProjects.iterator(); Set<String> setOfIdeaKeys = new HashSet<String>(); while (iterator.hasNext()) { String ideaKey = iterator.next().getIdeaKey(); if (!setOfIdeaKeys.contains(ideaKey)) { setOfIdeaKeys.add(ideaKey); ideas.add(getIdeaByKey(ideaKey)); } } recentlyPickedIdeas = createLinkedListFromTheFetchedData(ideas); if (recentlyPickedIdeas.size() > ServiceConstants.ZERO) { /* Put the recently picked ideas into the cache */ CacheHelper.putObject(CacheConstants.IDEA_NAMESPACE, CacheConstants.RECENTLY_PICKED_IDEAS, recentlyPickedIdeas, CacheConstants.RECENTLY_PICKED_IDEAS_EXPIRATION_DELAY); logger.info("Recently picked ideas successfully added to the cache"); } return recentlyPickedIdeas; } @SuppressWarnings("unchecked") @Override public void removeIdeaFromAllListsInCache(String ideaKey) { /* * Create a map containing all list names as keys and the corressponding * expiration delays as values */ Map<String, Integer> map = new HashMap<String, Integer>(); /* Recent ideas list */ map.put(CacheConstants.RECENT_IDEAS, CacheConstants.RECENT_IDEAS_EXPIRATION_DELAY); /* Recently picked ideas list */ map.put(CacheConstants.RECENTLY_PICKED_IDEAS, CacheConstants.RECENTLY_PICKED_IDEAS_EXPIRATION_DELAY); /* Popular ideas list */ map.put(CacheConstants.POPULAR_IDEAS, CacheConstants.POPULAR_IDEAS_EXPIRATION_DELAY); Iterator<String> iterator = map.keySet().iterator(); LinkedList<Idea> listOfIdeas = null; String keyOfTheList = null; while (iterator.hasNext()) { keyOfTheList = iterator.next(); /* Fetch the list */ listOfIdeas = (LinkedList<Idea>) CacheHelper.getObject(CacheConstants.IDEA_NAMESPACE, keyOfTheList); /* If the list is not null check and remove the idea */ if (listOfIdeas != null) { removeIdeaFromList(listOfIdeas, ideaKey, keyOfTheList, map.get(keyOfTheList)); } } /* First check in Recent ideas list and remove if available */ } /** * Remove idea from the list * * @param ideas the list of the ideas * @param ideaKey the key of the idea to be removed * @param keyOfTheList the key of the ideas list as used in the cache * @param expiryDelay the expiry delay for the list in cache */ private void removeIdeaFromList(LinkedList<Idea> ideas, String ideaKey, String keyOfTheList, int expiryDelay) { Iterator<Idea> iterator = ideas.iterator(); Idea idea = null; Idea ideaToBeRemoved = null; while (iterator.hasNext()) { idea = iterator.next(); if (ideaKey.equalsIgnoreCase(idea.getKey())) { ideaToBeRemoved = idea; break; } } if (ideaToBeRemoved != null) { ideas.remove(ideaToBeRemoved); /* Put the updated list back to the cache */ CacheHelper.putObject(CacheConstants.IDEA_NAMESPACE, keyOfTheList, ideas, expiryDelay); } } /** * Returns the IdeaDao type implementation * * @return Returns the TagService */ public IdeaDao getIdeaDao() { return ideaDao; } /** * Sets the IdeaDao type implementation. * * @param val The IdeaDao object */ public void setIdeaDao(IdeaDao val) { this.ideaDao = val; } /** * Sets the AuditManager. * * @param auditManager the auditManager to set */ public void setAuditManager(AuditManager auditManager) { this.auditManager = auditManager; } /** * @return the auditManager */ public AuditManager getAuditManager() { return auditManager; } @Override public Idea getIdeaByKey(String key) { return ideaDao.findEntityByPrimaryKey(Idea.class, key); } public TagService getTagService() { return tagService; } public void setTagService(TagService tagService) { this.tagService = tagService; } /** * @param weightUpdationManager the weightUpdationManager to set */ public void setWeightUpdationManager(TagWeightUpdationManager weightUpdationManager) { this.weightUpdationManager = weightUpdationManager; } /** * @return the weightUpdationManager */ public TagWeightUpdationManager getWeightUpdationManager() { return weightUpdationManager; } /** * @param userService the userService to set */ public void setUserService(UserService userService) { this.userService = userService; } /** * @return the userService */ public UserService getUserService() { return userService; } public EntityIndexService getEntityIndexService() { return entityIndexService; } public void setEntityIndexService(EntityIndexService entityIndexService) { this.entityIndexService = entityIndexService; } /** * @param shardedCounterService the shardedCounterService to set */ public void setShardedCounterService(ShardedCounterService shardedCounterService) { this.shardedCounterService = shardedCounterService; } /** * @return the shardedCounterService */ public ShardedCounterService getShardedCounterService() { return shardedCounterService; } /** * @return the adminRequestDao */ public AdminRequestDao getAdminRequestDao() { return adminRequestDao; } /** * @param adminRequestDao the adminRequestDao to set */ public void setAdminRequestDao(AdminRequestDao adminRequestDao) { this.adminRequestDao = adminRequestDao; } @Override public List<Idea> getIdeasByCategory(String categoryKey, RetrievalInfo retrievalInfo) { if (categoryKey != null && categoryKey.length() > ServiceConstants.ZERO) { retrievalInfo = prepareRetrievalInfoForQuery(retrievalInfo); List<Idea> ideaList = ideaDao.getIdeasByCategoryKey(categoryKey, Idea.STATUS_PUBLISHED, retrievalInfo); return ideaList; } return null; } }