Java tutorial
/* ==================================================================== * * Copyright (C) 2007 - 2016 GeoSolutions S.A.S. * http://www.geo-solutions.it * * GPLv3 + Classpath exception * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. * * ==================================================================== * * This software consists of voluntary contributions made by developers * of GeoSolutions. For more information on GeoSolutions, please see * <http://www.geo-solutions.it/>. * */ package it.geosolutions.geostore.services; import it.geosolutions.geostore.core.dao.AttributeDAO; import it.geosolutions.geostore.core.dao.CategoryDAO; import it.geosolutions.geostore.core.dao.ResourceDAO; import it.geosolutions.geostore.core.dao.SecurityDAO; import it.geosolutions.geostore.core.dao.StoredDataDAO; import it.geosolutions.geostore.core.dao.UserGroupDAO; import it.geosolutions.geostore.core.model.Attribute; import it.geosolutions.geostore.core.model.Category; import it.geosolutions.geostore.core.model.Resource; import it.geosolutions.geostore.core.model.SecurityRule; import it.geosolutions.geostore.core.model.StoredData; import it.geosolutions.geostore.core.model.User; import it.geosolutions.geostore.core.model.UserGroup; import it.geosolutions.geostore.core.model.enums.DataType; import it.geosolutions.geostore.core.model.enums.Role; import it.geosolutions.geostore.services.dto.ShortAttribute; import it.geosolutions.geostore.services.dto.ShortResource; import it.geosolutions.geostore.services.dto.search.SearchFilter; import it.geosolutions.geostore.services.exception.BadRequestServiceEx; import it.geosolutions.geostore.services.exception.DuplicatedResourceNameServiceEx; import it.geosolutions.geostore.services.exception.InternalErrorServiceEx; import it.geosolutions.geostore.services.exception.NotFoundServiceEx; import it.geosolutions.geostore.util.SearchConverter; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Date; import java.util.List; import java.util.Set; import java.util.regex.Matcher; import java.util.regex.Pattern; import org.apache.log4j.Logger; import org.springframework.dao.DataIntegrityViolationException; import com.googlecode.genericdao.search.Search; import java.util.LinkedList; /** * Class ResourceServiceImpl. * * @author Tobia di Pisa (tobia.dipisa at geo-solutions.it) * @author ETj (etj at geo-solutions.it) */ public class ResourceServiceImpl implements ResourceService { private static final Logger LOGGER = Logger.getLogger(ResourceServiceImpl.class); private UserGroupDAO userGroupDAO; private ResourceDAO resourceDAO; private AttributeDAO attributeDAO; private StoredDataDAO storedDataDAO; private CategoryDAO categoryDAO; private SecurityDAO securityDAO; /** * @param securityDAO the securityDAO to set */ public void setSecurityDAO(SecurityDAO securityDAO) { this.securityDAO = securityDAO; } /** * @param storedDataDAO the storedDataDAO to set */ public void setStoredDataDAO(StoredDataDAO storedDataDAO) { this.storedDataDAO = storedDataDAO; } /** * @param resourceDAO */ public void setResourceDAO(ResourceDAO resourceDAO) { this.resourceDAO = resourceDAO; } /** * @param attributeDAO */ public void setAttributeDAO(AttributeDAO attributeDAO) { this.attributeDAO = attributeDAO; } /** * @param categoryDAO the categoryDAO to set */ public void setCategoryDAO(CategoryDAO categoryDAO) { this.categoryDAO = categoryDAO; } /** * @param userGroupDAO the userGroupDAO to set */ public void setUserGroupDAO(UserGroupDAO userGroupDAO) { this.userGroupDAO = userGroupDAO; } /* * (non-Javadoc) * * @see it.geosolutions.geostore.services.ResourceService#insert(it.geosolutions.geostore.core.model.Resource) */ @Override public long insert(Resource resource) throws BadRequestServiceEx, NotFoundServiceEx, DuplicatedResourceNameServiceEx { if (LOGGER.isDebugEnabled()) { LOGGER.debug("Persisting Resource ... "); } validateResourceName(resource, false); Category category = resource.getCategory(); if (category == null) { throw new BadRequestServiceEx("Category type must be specified"); } // // Searching the corresponding Category // Category loadedCategory = null; if (category.getId() != null) { loadedCategory = categoryDAO.find(category.getId()); if (loadedCategory == null) { throw new NotFoundServiceEx("Resource Category not found [id:" + category.getId() + "]"); } } else if (category.getName() != null) { Search searchCriteria = new Search(Category.class); searchCriteria.addFilterEqual("name", category.getName()); List<Category> categories = categoryDAO.search(searchCriteria); if (categories.isEmpty()) { throw new NotFoundServiceEx("Resource Category not found [name:" + category.getName() + "]"); } loadedCategory = categories.get(0); } Resource r = new Resource(); r.setCreation(new Date()); r.setDescription(resource.getDescription()); r.setMetadata(resource.getMetadata()); r.setName(resource.getName()); r.setCategory(loadedCategory); try { resourceDAO.persist(r); } catch (DataIntegrityViolationException exc) { throw new BadRequestServiceEx(exc.getLocalizedMessage()); } // // Persisting Attributes // List<Attribute> attributes = resource.getAttribute(); if (attributes != null) { for (Attribute a : attributes) { a.setResource(r); attributeDAO.persist(a); } } // // Persisting StoredData // StoredData data = resource.getData(); if (data != null) { data.setId(r.getId()); data.setResource(r); storedDataDAO.persist(data); } // // Persisting SecurityRule // List<SecurityRule> rules = resource.getSecurity(); if (rules != null) { for (SecurityRule rule : rules) { rule.setResource(r); securityDAO.persist(rule); } } return r.getId(); } /* * (non-Javadoc) * * @see it.geosolutions.geostore.services.ResourceService#update(it.geosolutions.geostore.core.model.Resource) */ @Override public long update(Resource resource) throws NotFoundServiceEx, DuplicatedResourceNameServiceEx { Resource orig = resourceDAO.find(resource.getId()); if (orig == null) { throw new NotFoundServiceEx("Resource not found " + resource.getId()); } validateResourceName(resource, true); // reset some server-handled data. resource.setCreation(orig.getCreation()); resource.setLastUpdate(new Date()); resourceDAO.merge(resource); return orig.getId(); } /* * (non-Javadoc) * * @see it.geosolutions.geostore.services.ResourceService#updateAttributes(long, java.util.List) */ @Override public void updateAttributes(long id, List<Attribute> attributes) throws NotFoundServiceEx { Resource resource = resourceDAO.find(id); if (resource == null) { throw new NotFoundServiceEx("Resource not found " + id); } // // Removing old attributes // List<Attribute> oldList = resource.getAttribute(); if (oldList != null) { for (Attribute a : oldList) { attributeDAO.removeById(a.getId()); } } // // Saving old attributes // for (Attribute a : attributes) { a.setResource(resource); attributeDAO.persist(a); } } /* * Makes sure that no resource with the same name exists in the database; * if a conflict is found, the method throws a DuplicatedResourceNameServiceEx * exception, putting an alternative, non-conflicting resource name in the exception's message */ private void validateResourceName(Resource resource, boolean isUpdate) throws DuplicatedResourceNameServiceEx { Resource existentResource = resourceDAO.findByName(resource.getName()); if (existentResource != null && !(isUpdate && existentResource.getId().equals(resource.getId()))) { String validResourceName = suggestValidResourceName(resource.getName()); throw new DuplicatedResourceNameServiceEx(validResourceName); } } /* * Utility method containing the logic to determine a valid (i.e. not duplicated) resource name. * To do so, the method queries the database in search of resouce names matching the pattern: * [baseResourceName] - [counter] * The maximum employed counter is then established and a unique resource name following the * aforementioned pattern is constructed. */ private String suggestValidResourceName(String baseResourceName) { final String COUNTER_SEPARATOR = " - "; final String BASE_PATTERN = baseResourceName + COUNTER_SEPARATOR; final String RESOURCE_NAME_LIKE_PATTERN = BASE_PATTERN + "%"; final Pattern RESOURCE_NAME_REGEX_PATTERN = Pattern.compile(BASE_PATTERN + "(\\d+)"); int maxCounter = 0, initialCounter = 2; List<String> resourceNames = resourceDAO.findResourceNamesMatchingPattern(RESOURCE_NAME_LIKE_PATTERN); for (String resourceName : resourceNames) { Matcher matcher = RESOURCE_NAME_REGEX_PATTERN.matcher(resourceName); if (matcher.matches()) { String suffix = matcher.group(1); int suffixAsInteger = 0; try { suffixAsInteger = Integer.valueOf(suffix); if (suffixAsInteger > maxCounter) { maxCounter = suffixAsInteger; } } catch (NumberFormatException ex) { // ignore: suffix is NOT an integer } } } Integer validCounter = Math.max(maxCounter + 1, initialCounter); String validName = BASE_PATTERN + validCounter; return validName; } /* * @param id * * @return the Resource or null if none was found with given id * * @see it.geosolutions.geostore.services.ResourceService#get(long) */ @Override public Resource get(long id) { Resource resource = resourceDAO.find(id); return resource; } /* * (non-Javadoc) * * @see it.geosolutions.geostore.services.ResourceService#delete(long) */ @Override public boolean delete(long id) { // // data on ancillary tables should be deleted by cascading // return resourceDAO.removeById(id); } /* * (non-Javadoc) * * @see it.geosolutions.geostore.services.ResourceService#delete(long) */ @Override public void deleteResources(SearchFilter filter) throws BadRequestServiceEx, InternalErrorServiceEx { Search searchCriteria = SearchConverter.convert(filter); this.resourceDAO.removeResources(searchCriteria); } /* * (non-Javadoc) * * @see it.geosolutions.geostore.services.ResourceService#getList(java.lang.String, java.lang.Integer, java.lang.Integer) */ @Override public List<ShortResource> getList(String nameLike, Integer page, Integer entries, User authUser) throws BadRequestServiceEx { if (((page != null) && (entries == null)) || ((page == null) && (entries != null))) { throw new BadRequestServiceEx("Page and entries params should be declared together"); } Search searchCriteria = new Search(Resource.class); if (page != null) { searchCriteria.setMaxResults(entries); searchCriteria.setPage(page); } searchCriteria.addSortAsc("name"); if (nameLike != null) { searchCriteria.addFilterILike("name", nameLike); } // load security rules for each resource in the list searchCriteria.addFetch("security"); searchCriteria.setDistinct(true); resourceDAO.addReadSecurityConstraints(searchCriteria, authUser); if (LOGGER.isTraceEnabled()) { LOGGER.trace("Get Resource List: " + searchCriteria); } List<Resource> found = resourceDAO.search(searchCriteria); return convertToShortList(found, authUser); } /* * (non-Javadoc) * * @see it.geosolutions.geostore.services.ResourceService#getList(java.lang.Integer, java.lang.Integer) */ @Override public List<ShortResource> getAll(Integer page, Integer entries, User authUser) throws BadRequestServiceEx { if (((page != null) && (entries == null)) || ((page == null) && (entries != null))) { throw new BadRequestServiceEx("Page and entries params should be declared together"); } Search searchCriteria = new Search(Resource.class); if (page != null) { searchCriteria.setMaxResults(entries); searchCriteria.setPage(page); } searchCriteria.addSortAsc("name"); // load security rules for each resource in the list searchCriteria.addFetch("security"); searchCriteria.setDistinct(true); resourceDAO.addReadSecurityConstraints(searchCriteria, authUser); List<Resource> found = resourceDAO.search(searchCriteria); return convertToShortList(found, authUser); } /* * (non-Javadoc) * * @see it.geosolutions.geostore.services.ResourceService#getCount(java.lang.String) */ @Override public long getCount(String nameLike) { Search searchCriteria = new Search(Resource.class); if (nameLike != null) { searchCriteria.addFilterILike("name", nameLike); } return resourceDAO.count(searchCriteria); } /* * (non-Javadoc) * * @see it.geosolutions.geostore.services.ResourceService#getCount(java.lang.String) */ @Override public long getCountByFilter(SearchFilter filter) throws InternalErrorServiceEx, BadRequestServiceEx { Search searchCriteria = SearchConverter.convert(filter); return resourceDAO.count(searchCriteria); } /** * @param list * @return List<ShortResource> */ private List<ShortResource> convertToShortList(List<Resource> list, User authUser) { List<ShortResource> swList = new LinkedList<>(); for (Resource resource : list) { ShortResource shortResource = new ShortResource(resource); // /////////////////////////////////////////////////////////////////////// // This fragment checks if the authenticated user can modify and delete // the loaded resource (and associated attributes and stored data). // This to inform the client in HTTP response result. // /////////////////////////////////////////////////////////////////////// if (authUser != null) { if (authUser.getRole().equals(Role.ADMIN)) { shortResource.setCanEdit(true); shortResource.setCanDelete(true); } else { for (SecurityRule rule : resource.getSecurity()) { User owner = rule.getUser(); UserGroup userGroup = rule.getGroup(); if (owner != null) { if (owner.getId().equals(authUser.getId())) { if (rule.isCanWrite()) { shortResource.setCanEdit(true); shortResource.setCanDelete(true); break; } } } else if (userGroup != null) { List<String> groups = extratcGroupNames(authUser.getGroups()); if (groups.contains(userGroup.getGroupName())) { if (rule.isCanWrite()) { shortResource.setCanEdit(true); shortResource.setCanDelete(true); break; } } } } } } swList.add(shortResource); } return swList; } public static List<String> extratcGroupNames(Set<UserGroup> groups) { List<String> groupNames = new ArrayList<String>(); if (groups == null) { return groupNames; } for (UserGroup ug : groups) { groupNames.add(ug.getGroupName()); } return groupNames; } /* * (non-Javadoc) * * @see it.geosolutions.geostore.services.ResourceService#getListAttributes(long) */ @Override public List<ShortAttribute> getAttributes(long id) { Search searchCriteria = new Search(Attribute.class); searchCriteria.addFilterEqual("resource.id", id); List<Attribute> attributes = this.attributeDAO.search(searchCriteria); List<ShortAttribute> dtoList = convertToShortAttributeList(attributes); return dtoList; } /** * @param list * @return List<ShortAttribute> */ private List<ShortAttribute> convertToShortAttributeList(List<Attribute> list) { List<ShortAttribute> swList = new ArrayList<ShortAttribute>(list.size()); for (Attribute attribute : list) { swList.add(new ShortAttribute(attribute)); } return swList; } /* * (non-Javadoc) * * @see it.geosolutions.geostore.services.ResourceService#getAttribute(long, java.lang.String) */ @Override public ShortAttribute getAttribute(long id, String name) { Search searchCriteria = new Search(Attribute.class); searchCriteria.addFilterEqual("resource.id", id); searchCriteria.addFilterEqual("name", name); List<Attribute> attributes = this.attributeDAO.search(searchCriteria); List<ShortAttribute> dtoList = convertToShortAttributeList(attributes); if (dtoList.size() > 0) { return dtoList.get(0); } else { return null; } } /* * (non-Javadoc) * * @see it.geosolutions.geostore.services.ResourceService#updateAttribute(long, java.lang.String, java.lang.String) */ @Override public long updateAttribute(long id, String name, String value) throws InternalErrorServiceEx { Search searchCriteria = new Search(Attribute.class); searchCriteria.addFilterEqual("resource.id", id); searchCriteria.addFilterEqual("name", name); List<Attribute> attributes = this.attributeDAO.search(searchCriteria); Attribute attribute = attributes.get(0); switch (attribute.getType()) { case DATE: SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS"); try { attribute.setDateValue(sdf.parse(value)); } catch (ParseException e) { throw new InternalErrorServiceEx("Error parsing attribute date value"); } break; case NUMBER: attribute.setNumberValue(Double.valueOf(value)); break; case STRING: attribute.setTextValue(value); break; default: throw new IllegalStateException("Unknown type " + attribute.getType()); } attribute = this.attributeDAO.merge(attribute); return attribute.getId(); } @Override public long insertAttribute(long id, String name, String value, DataType type) throws InternalErrorServiceEx { Search searchCriteria = new Search(Attribute.class); searchCriteria.addFilterEqual("resource.id", id); searchCriteria.addFilterEqual("name", name); List<Attribute> attributes = this.attributeDAO.search(searchCriteria); //if the attribute exist, update id (note: it must have the same type) if (attributes.size() > 0) { Attribute attribute = attributes.get(0); switch (attribute.getType()) { case DATE: SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS"); try { attribute.setDateValue(sdf.parse(value)); } catch (ParseException e) { throw new InternalErrorServiceEx("Error parsing attribute date value"); } break; case NUMBER: attribute.setNumberValue(Double.valueOf(value)); break; case STRING: attribute.setTextValue(value); break; default: throw new IllegalStateException("Unknown type " + attribute.getType()); } attribute = this.attributeDAO.merge(attribute); return attribute.getId(); } else { //create the new attribute Attribute attribute = new Attribute(); attribute.setType(type); attribute.setName(name); attribute.setResource(resourceDAO.find(id)); switch (type) { case DATE: SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS"); try { attribute.setDateValue(sdf.parse(value)); } catch (ParseException e) { throw new InternalErrorServiceEx("Error parsing attribute date value"); } break; case NUMBER: attribute.setNumberValue(Double.valueOf(value)); break; case STRING: attribute.setTextValue(value); break; default: throw new IllegalStateException("Unknown type " + attribute.getType()); } return this.attributeDAO.merge(attribute).getId(); } } /* * (non-Javadoc) * * @see it.geosolutions.geostore.services.ResourceService#getResourcesByFilter(it.geosolutions.geostore.services.dto.SearchFilter) */ @Override public List<ShortResource> getResources(SearchFilter filter, User authUser) throws BadRequestServiceEx, InternalErrorServiceEx { return getResources(filter, null, null, authUser); } /* * (non-Javadoc) * * @see it.geosolutions.geostore.services.ResourceService#getResources(it.geosolutions.geostore.services.dto.search.SearchFilter, * java.lang.Integer, java.lang.Integer, boolean, boolean, it.geosolutions.geostore.core.model.User) */ public List<Resource> getResources(SearchFilter filter, Integer page, Integer entries, boolean includeAttributes, boolean includeData, User authUser) throws BadRequestServiceEx, InternalErrorServiceEx { if (((page != null) && (entries == null)) || ((page == null) && (entries != null))) { throw new BadRequestServiceEx("Page and entries params should be declared together"); } Search searchCriteria = SearchConverter.convert(filter); if (page != null) { searchCriteria.setMaxResults(entries); searchCriteria.setPage(page); } searchCriteria.addFetch("security"); searchCriteria.setDistinct(true); resourceDAO.addReadSecurityConstraints(searchCriteria, authUser); List<Resource> resources = this.resourceDAO.search(searchCriteria); resources = this.configResourceList(resources, includeAttributes, includeData, authUser); return resources; } /** * @param list * @param includeAttributes * @param includeData * @param authUser * @return List<Resource> */ private List<Resource> configResourceList(List<Resource> list, boolean includeAttributes, boolean includeData, User authUser) { List<Resource> rList = new LinkedList<>(); for (Resource resource : list) { Resource res = new Resource(); res.setCategory(resource.getCategory()); res.setCreation(resource.getCreation()); res.setDescription(resource.getDescription()); res.setId(resource.getId()); res.setLastUpdate(resource.getLastUpdate()); res.setName(resource.getName()); if (includeData) { res.setData(resource.getData()); } if (includeAttributes) { res.setAttribute(resource.getAttribute()); } rList.add(res); } return rList; } @Override public List<ShortResource> getResources(SearchFilter filter, Integer page, Integer entries, User authUser) throws BadRequestServiceEx, InternalErrorServiceEx { if (((page != null) && (entries == null)) || ((page == null) && (entries != null))) { throw new BadRequestServiceEx("Page and entries params should be declared together"); } Search searchCriteria = SearchConverter.convert(filter); if (page != null) { searchCriteria.setMaxResults(entries); searchCriteria.setPage(page); } // ////////////////////////////////////////////////////////// // addFetch to charge the corresponding security rules // for each resource in the list // ////////////////////////////////////////////////////////// searchCriteria.addFetch("security"); searchCriteria.setDistinct(true); resourceDAO.addReadSecurityConstraints(searchCriteria, authUser); List<Resource> resources = this.resourceDAO.search(searchCriteria); return convertToShortList(resources, authUser); } /** * Return a list of resources joined with their data. This call can be very heavy for the system. Please use this * method only when you are sure a few data will be returned, otherwise consider using * {@link #getResources(it.geosolutions.geostore.services.dto.search.SearchFilter, it.geosolutions.geostore.core.model.User) getResources) * if you need less data. * * @param filter * @param authUser * @return * @throws BadRequestServiceEx * @throws InternalErrorServiceEx */ @Override public List<Resource> getResourcesFull(SearchFilter filter, User authUser) throws BadRequestServiceEx, InternalErrorServiceEx { Search searchCriteria = SearchConverter.convert(filter); searchCriteria.addFetch("security"); searchCriteria.setDistinct(true); searchCriteria.addFetch("data"); resourceDAO.addReadSecurityConstraints(searchCriteria, authUser); List<Resource> resources = this.resourceDAO.search(searchCriteria); return resources; } /* * (non-Javadoc) * @see it.geosolutions.geostore.services.SecurityService#getUserSecurityRule(java.lang.String, long) */ @Override public List<SecurityRule> getUserSecurityRule(String userName, long resourceId) { return resourceDAO.findUserSecurityRule(userName, resourceId); } /* (non-Javadoc) * @see it.geosolutions.geostore.services.SecurityService#getGroupSecurityRule(java.lang.String, long) */ @Override public List<SecurityRule> getGroupSecurityRule(List<String> groupNames, long resourceId) { return resourceDAO.findGroupSecurityRule(groupNames, resourceId); } @Override public List<SecurityRule> getSecurityRules(long id) throws BadRequestServiceEx, InternalErrorServiceEx { return resourceDAO.findSecurityRules(id); } @Override public void updateSecurityRules(long id, List<SecurityRule> rules) throws BadRequestServiceEx, InternalErrorServiceEx, NotFoundServiceEx { Resource resource = resourceDAO.find(id); if (resource != null) { Search searchCriteria = new Search(); searchCriteria.addFilterEqual("resource.id", id); List<SecurityRule> resourceRules = this.securityDAO.search(searchCriteria); // remove previous rules for (SecurityRule rule : resourceRules) { securityDAO.remove(rule); } // insert new rules for (SecurityRule rule : rules) { rule.setResource(resource); //Retrieve from db the entity usergroup, if the securityrule is related to a group if (rule.getGroup() != null) { UserGroup ug = userGroupDAO.find(rule.getGroup().getId()); if (ug == null) { throw new InternalErrorServiceEx("The usergroup having the provided Id doesn't exist"); } rule.setGroup(ug); } securityDAO.persist(rule); } } else { throw new NotFoundServiceEx("Resource not found " + id); } } /** * Get filter count by filter and user * * @param filter * @param user * @return resources' count that the user has access * @throws InternalErrorServiceEx * @throws BadRequestServiceEx */ public long getCountByFilterAndUser(SearchFilter filter, User user) throws BadRequestServiceEx, InternalErrorServiceEx { Search searchCriteria = SearchConverter.convert(filter); resourceDAO.addReadSecurityConstraints(searchCriteria, user); return resourceDAO.count(searchCriteria); } /** * Get filter count by namerLike and user * * @param nameLike * @param user * @return resources' count that the user has access * @throws InternalErrorServiceEx * @throws BadRequestServiceEx */ public long getCountByFilterAndUser(String nameLike, User user) throws BadRequestServiceEx { Search searchCriteria = new Search(Resource.class); if (nameLike != null) { searchCriteria.addFilterILike("name", nameLike); } resourceDAO.addReadSecurityConstraints(searchCriteria, user); return resourceDAO.count(searchCriteria); } }