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.appengine.api.datastore.Blob; import com.google.ie.business.dao.ProjectDao; 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.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.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.taskqueue.IndexQueueUpdater; import com.google.ie.dto.RetrievalInfo; import com.google.ie.web.controller.WebConstants; import org.apache.commons.lang.StringUtils; import org.apache.log4j.Logger; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import java.util.Date; import java.util.HashSet; import java.util.Iterator; import java.util.LinkedList; import java.util.List; import java.util.Set; /** * A service implementation of the ProjectService * * @author Charanjeet singh * */ @Service public class ProjectServiceImpl implements ProjectService { private static final Logger LOGGER = Logger.getLogger(ProjectServiceImpl.class); private static final int DEFAULT_NO_OF_RECENT_PROJECTS = 3; @Autowired private IdeaService ideaService; @Autowired private ProjectDao projectDao; @Autowired private AuditManager auditManager; @Autowired private EntityIndexService entityIndexService; @Autowired private IndexQueueUpdater indexQueueUpdater; public IndexQueueUpdater getIndexQueueUpdater() { return indexQueueUpdater; } public void setIndexQueueUpdater(IndexQueueUpdater indexQueueUpdater) { this.indexQueueUpdater = indexQueueUpdater; } @Override public Project createOrUpdateProject(Project project, User user) { /* check for user and idea key. */ if (StringUtils.isBlank(user.getUserKey()) || StringUtils.isBlank(project.getIdeaKey())) { throw new SystemException(IdeaExchangeErrorCodes.PROJECT_CREATION_FAILURE_EXCEPTION, IdeaExchangeConstants.Messages.PROJECT_CREATION_FAILURE_MESSAGE); } Idea idea = ideaService.getIdeaByKey(project.getIdeaKey()); /* * We need to check only for saved idea as edit project is possible on * deleted idea as well */ if (!idea.getStatus().equals(Idea.STATUS_SAVED)) { /* Save project details */ long date = System.currentTimeMillis(); /* If project already exists then update it */ if (project.getKey() != null) { Project projectFromDataStore = getProjectDao().getProject(project.getKey()); projectFromDataStore.setUpdatedOn(new Date(date)); projectFromDataStore.setName(project.getName()); projectFromDataStore.setDescription(project.getDescription()); projectFromDataStore.setLogo(project.getLogo()); project = saveProjectLocal(projectFromDataStore); } else { /* If project is newly created */ project.setStatus(Project.STATUS_CREATED); project.setCreatedOn(new Date(date)); project.setUpdatedOn(new Date(date)); project.setCreatorKey(user.getUserKey()); project = saveProjectLocal(project); afterProjectCreation(project, user, idea); } return project; } return null; } /** * Check validity arguments for project creation . * * @throws SystemException */ private boolean checkIfValid(Idea idea) throws SystemException { /* Check if idea is published. */ if (!idea.getStatus().equals(Idea.STATUS_PUBLISHED)) { throw new SystemException(IdeaExchangeErrorCodes.PROJECT_CREATION_FAILURE_UNPUBLISHED_IDEA_EXCEPTION, IdeaExchangeConstants.Messages.PROJECT_CREATION_FAILURE_UNPUBLISHED_IDEA_MESSAGE); } return true; } /** * Save project and index it. * * @param project Project to be saved * @return Saved project */ private Project saveProjectLocal(Project project) { project = projectDao.saveProject(project); if (project != 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(project.getKey()); getIndexQueueUpdater().indexEntity(entityIndex.getKey()); } return project; } /** * Performs the post project creation activity. * * @param project Project entity. * @param user The User who has created the project. * @param idea Idea entity on which a project is being created. * */ private void afterProjectCreation(Project project, User user, Idea idea) { LOGGER.info("Project is successfully saved"); /* log the activity into Audit log. */ getAuditManager().audit(user.getUserKey(), project.getKey(), project.getClass().getName(), ServiceConstants.AUDIT_ACTION_TYPE_CREATE_PROJECT); /* Place the idea into recently picked ideas. */ CacheHelper.putObject(CacheConstants.PROJECT_NAMESPACE, CacheConstants.RECENTLY_PICKED, idea); addIdeaToRecentlyPickedIdeaListInCache(idea); } @SuppressWarnings("unchecked") private void addIdeaToRecentlyPickedIdeaListInCache(Idea ideaToBeAdded) { /* Get the list of recently picked ideas from cache */ LinkedList<Idea> ideas = (LinkedList<Idea>) CacheHelper.getObject(CacheConstants.IDEA_NAMESPACE, CacheConstants.RECENTLY_PICKED_IDEAS); if (ideas != null) { Iterator<Idea> iterator = ideas.iterator(); Idea ideaFromCache = null; /* Iterate to check whether the list already contains the idea */ while (iterator.hasNext()) { ideaFromCache = iterator.next(); String ideaKey = ideaFromCache.getKey(); if (ideaKey.equalsIgnoreCase(ideaToBeAdded.getKey())) { /* * If idea already exists in the list , move it to the head */ ideas.remove(ideaFromCache); ideas.addFirst(ideaFromCache); CacheHelper.putObject(CacheConstants.IDEA_NAMESPACE, CacheConstants.RECENTLY_PICKED_IDEAS, ideas, CacheConstants.RECENTLY_PICKED_IDEAS_EXPIRATION_DELAY); return; } } } /* This is executed if the idea does not already exist in cache */ ideaService.addIdeaToListInCache(ideaToBeAdded, CacheConstants.RECENTLY_PICKED_IDEAS, DEFAULT_NO_OF_RECENT_PROJECTS, CacheConstants.RECENTLY_PICKED_IDEAS_EXPIRATION_DELAY); } @Override public Blob getImageById(String key) { Project project = projectDao.getProject(key); Blob image = project.getLogo(); if (image == null) return null; return image; } @Override public Project getDetails(Project project) { if (project != null && !StringUtils.isBlank(project.getKey())) { LOGGER.debug("Retrieving details for the project with key=" + project.getKey()); project = projectDao.getProject(project.getKey()); return project; } throw new SystemException(IdeaExchangeErrorCodes.PROJECT_DETAILS_EXCEPTION, IdeaExchangeConstants.Messages.PROJECT_DETAILS_EXCEPTION_MESSAGE); } @Override public List<Project> listProjects(RetrievalInfo retrievalInfo) { /* Fetch one more record than what is required */ retrievalInfo.setNoOfRecords(retrievalInfo.getNoOfRecords() + WebConstants.ONE); /* * Retrieve Project 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> statusOfProject = new HashSet<String>(); statusOfProject.add(Project.STATUS_CREATED); return getProjectDao().getProjects(retrievalInfo, statusOfProject); } @Override public List<Project> listProjects(User user, RetrievalInfo retrievalInfo) { /* * Retrieve Project 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> statusOfProject = new HashSet<String>(); statusOfProject.add(Project.STATUS_CREATED); return getProjectDao().getProjects(user, retrievalInfo, statusOfProject); } @Override public List<Project> getProjects(Set<String> projectKeys, RetrievalInfo retrievalInfo) { return getProjectDao().getProjectsByKeys(projectKeys, retrievalInfo); } /** * 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.PROJECT_LIST_DEFAULT_SIZE); retrievalInfo.setOrderType(ServiceConstants.PROJECT_DEFAULT_ORDERING_TYPE); retrievalInfo.setOrderBy(ServiceConstants.DEFAULT_PROJECT_ORDERING_FIELD); } else { // Handle garbage values if any. String orderOn = retrievalInfo.getOrderBy(); String orderByParam = retrievalInfo.getOrderType(); if (retrievalInfo.getStartIndex() < ServiceConstants.ZERO) retrievalInfo.setStartIndex(ServiceConstants.ZERO); if (retrievalInfo.getNoOfRecords() <= ServiceConstants.ZERO) retrievalInfo.setNoOfRecords(ServiceConstants.PROJECT_LIST_DEFAULT_SIZE); if (orderByParam == null || !((orderByParam.equals(ServiceConstants.ORDERING_ASCENDING) || orderByParam.equals(ServiceConstants.ORDERING_DESCENDING)))) retrievalInfo.setOrderType(ServiceConstants.PROJECT_DEFAULT_ORDERING_TYPE); if (orderOn == null || !orderOn.equals(ServiceConstants.PROJECT_ORDERING_FIELD_UPDATED_ON)) { retrievalInfo.setOrderBy(ServiceConstants.DEFAULT_PROJECT_ORDERING_FIELD); } } return retrievalInfo; } @Override public List<Project> getProjectsByIdeaKey(String key) { return getProjectDao().getProjectsByIdeaKey(key); } /** * @param ideaService the ideaService to set */ public void setIdeaService(IdeaService ideaService) { this.ideaService = ideaService; } /** * @return the ideaService */ public IdeaService getIdeaService() { return ideaService; } /** * @param projectDao the projectDao to set */ public void setProjectDao(ProjectDao projectDao) { this.projectDao = projectDao; } /** * @return the projectDao */ public ProjectDao getProjectDao() { return projectDao; } /** * @param auditManager the auditManager to set */ public void setAuditManager(AuditManager auditManager) { this.auditManager = auditManager; } /** * @return the auditManager */ public AuditManager getAuditManager() { return auditManager; } /** * @return the entityIndexService */ public EntityIndexService getEntityIndexService() { return entityIndexService; } /** * @param entityIndexService the entityIndexService to set */ public void setEntityIndexService(EntityIndexService entityIndexService) { this.entityIndexService = entityIndexService; } @Override public Project getProjectById(String key) { return projectDao.findEntityByPrimaryKey(Project.class, key); } @Override public List<Project> getRecentProjects() { RetrievalInfo retrievalInfo = new RetrievalInfo(); retrievalInfo.setNoOfRecords(DEFAULT_NO_OF_RECENT_PROJECTS); retrievalInfo.setOrderBy(Project.PROJECT_FIELD_CREATED_ON); retrievalInfo.setOrderType(ServiceConstants.ORDERING_DESCENDING); /* The set of status to match for */ Set<String> statusOfProject = new HashSet<String>(); statusOfProject.add(Project.STATUS_CREATED); return projectDao.getProjects(retrievalInfo, statusOfProject); } @Override public Project updateProject(Project project) { return projectDao.saveProject(project); } }