| /******************************************************************************* |
| * Copyright (c) 2013-2020 LAAS-CNRS (www.laas.fr) |
| * 7 Colonel Roche 31077 Toulouse - France |
| * |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License 2.0 |
| * which accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * Initial Contributors: |
| * Thierry Monteil : Project manager, technical co-manager |
| * Mahdi Ben Alaya : Technical co-manager |
| * Samir Medjiah : Technical co-manager |
| * Khalil Drira : Strategy expert |
| * Guillaume Garzone : Developer |
| * François Aïssaoui : Developer |
| * |
| * New contributors : |
| *******************************************************************************/ |
| package org.eclipse.om2m.core.controller; |
| |
| import java.math.BigInteger; |
| import java.util.List; |
| |
| import org.eclipse.om2m.commons.constants.Constants; |
| import org.eclipse.om2m.commons.constants.MimeMediaType; |
| import org.eclipse.om2m.commons.constants.ResourceStatus; |
| import org.eclipse.om2m.commons.constants.ResourceType; |
| import org.eclipse.om2m.commons.constants.ResponseStatusCode; |
| import org.eclipse.om2m.commons.constants.ShortName; |
| import org.eclipse.om2m.commons.entities.AccessControlPolicyEntity; |
| import org.eclipse.om2m.commons.entities.ContainerEntity; |
| import org.eclipse.om2m.commons.entities.ContentInstanceEntity; |
| import org.eclipse.om2m.commons.entities.ResourceEntity; |
| import org.eclipse.om2m.commons.entities.SubscriptionEntity; |
| import org.eclipse.om2m.commons.exceptions.BadRequestException; |
| import org.eclipse.om2m.commons.exceptions.ConflictException; |
| import org.eclipse.om2m.commons.exceptions.NotImplementedException; |
| import org.eclipse.om2m.commons.exceptions.OperationNotAllowed; |
| import org.eclipse.om2m.commons.exceptions.ResourceNotFoundException; |
| import org.eclipse.om2m.commons.resource.ContentInstance; |
| import org.eclipse.om2m.commons.resource.RequestPrimitive; |
| import org.eclipse.om2m.commons.resource.ResponsePrimitive; |
| import org.eclipse.om2m.core.datamapper.DataMapperSelector; |
| import org.eclipse.om2m.core.entitymapper.EntityMapperFactory; |
| import org.eclipse.om2m.core.notifier.Notifier; |
| import org.eclipse.om2m.core.persistence.PersistenceService; |
| import org.eclipse.om2m.core.router.Patterns; |
| import org.eclipse.om2m.core.urimapper.UriMapper; |
| import org.eclipse.om2m.core.util.ControllerUtil; |
| import org.eclipse.om2m.persistence.service.DAO; |
| import org.eclipse.om2m.persistence.service.DBService; |
| import org.eclipse.om2m.persistence.service.DBTransaction; |
| |
| /** |
| * Controller for the content instance resource |
| * |
| */ |
| public class ContentInstanceController extends Controller { |
| |
| /** |
| * do create operation for contentInstance |
| * @param request |
| * @return response |
| */ |
| @Override |
| public ResponsePrimitive doCreate(RequestPrimitive request) { |
| /* |
| * ContentInstance creation procedure |
| * |
| * @resourceName NP |
| * resourceType NP |
| * resourceID NP |
| * parentID NP |
| * creationTime NP |
| * expirationTime O? |
| * lastModifiedTime NP |
| * labels O |
| * announceTo O |
| * announcedAttribute NP |
| * |
| * creator O |
| * contentInfo M |
| * contentSize O |
| * ontologyRef O |
| * content M |
| * |
| */ |
| // create the response |
| ResponsePrimitive response = new ResponsePrimitive(request); |
| Patterns patterns = new Patterns(); |
| |
| // get the dao of the parent |
| @SuppressWarnings("unchecked") |
| DAO<ResourceEntity> parentDAO = (DAO<ResourceEntity>) patterns.getDAO(request.getTo(), dbs); |
| if (parentDAO == null) { |
| throw new ResourceNotFoundException("Cannot find parent resource"); |
| } |
| // get the parent entity |
| ResourceEntity parentEntity = parentDAO.find(transaction, request.getTo()); |
| // check the parent existence |
| if (parentEntity == null) { |
| throw new ResourceNotFoundException("Cannot find parent resource"); |
| } |
| |
| // get lists to change in the method corresponding to specific object |
| List<AccessControlPolicyEntity> acpsToCheck = null; |
| List<SubscriptionEntity> subscriptions = null; |
| |
| // different cases |
| // case parent is Container |
| if (parentEntity.getResourceType().intValue() == (ResourceType.CONTAINER)) { |
| ContainerEntity container = (ContainerEntity) parentEntity; |
| acpsToCheck = container.getAccessControlPolicies(); |
| subscriptions = container.getSubscriptions(); |
| } else if (parentEntity.getResourceType().intValue() == (ResourceType.CONTAINER_ANNC)) { |
| // case parent is ContainerAnnc |
| throw new NotImplementedException("Parent is Container Annc, not implemented yet."); |
| } |
| |
| // Check acp |
| checkACP(acpsToCheck, request.getFrom(), request.getOperation()); |
| |
| // check if content is present |
| if (request.getContent() == null){ |
| throw new BadRequestException("A content is requiered for ContentInstance creation"); |
| } |
| // get the object from the representation |
| ContentInstance cin = null; |
| try{ |
| if (request.getRequestContentType().equals(MimeMediaType.OBJ)){ |
| cin = (ContentInstance) request.getContent(); |
| } else { |
| cin = (ContentInstance)DataMapperSelector.getDataMapperList() |
| .get(request.getRequestContentType()).stringToObj((String)request.getContent()); |
| } |
| |
| } catch (ClassCastException e){ |
| throw new BadRequestException("Incorrect resource representation in content", e); |
| } |
| if (cin == null){ |
| throw new BadRequestException("Error in provided content"); |
| } |
| |
| |
| ContentInstanceEntity cinEntity = new ContentInstanceEntity(); |
| // check attributes |
| // @resourceName NP |
| // Resource Type NP |
| // resourceID NP |
| // parentID NP |
| // lastModifiedTime NP |
| // creationTime NP |
| // labels O |
| ControllerUtil.CreateUtil.fillEntityFromGenericResource(cin, cinEntity); |
| |
| // announcedAttribute O |
| if (!cin.getAnnouncedAttribute().isEmpty()) { |
| cinEntity.getAnnouncedAttribute().addAll(cin.getAnnouncedAttribute()); |
| } |
| |
| // contentInfo M |
| if (cin.getContentInfo() == null) { |
| cinEntity.setContentInfo("text/plain:0"); |
| } else { |
| cinEntity.setContentInfo(cin.getContentInfo()); |
| } |
| // content M |
| if (cin.getContent() == null) { |
| throw new BadRequestException("Content is Mandatory"); |
| } |
| |
| String generatedId = generateId("", ""); |
| cinEntity.setResourceID("/" + Constants.CSE_ID + "/" + ShortName.CIN |
| + Constants.PREFIX_SEPERATOR + generatedId); |
| // check & set resource name if present |
| if (cin.getName() != null){ |
| if (!patterns.checkResourceName(cin.getName())){ |
| throw new BadRequestException("Name provided is incorrect. Must be:" + patterns.ID_STRING); |
| } |
| cinEntity.setName(cin.getName()); |
| } else { |
| cinEntity.setName(ShortName.CIN + "_" + generatedId); |
| } |
| cinEntity.setHierarchicalURI(parentEntity.getHierarchicalURI() + "/" + cinEntity.getName()); |
| if (! UriMapper.addNewUri(cinEntity.getHierarchicalURI(), cinEntity.getResourceID(), |
| ResourceType.CONTENT_INSTANCE)) { |
| throw new ConflictException("Name already present in the parent collection."); |
| } |
| |
| cinEntity.setParentID(parentEntity.getResourceID()); |
| cinEntity.setResourceType(ResourceType.CONTENT_INSTANCE); |
| cinEntity.setContent(cin.getContent()); |
| cinEntity.setStateTag(BigInteger.valueOf(0)); |
| |
| // creator O |
| if (cin.getCreator() != null) { |
| cinEntity.setCreator(cin.getCreator()); |
| } |
| |
| // expiration time O? |
| if (cin.getExpirationTime() != null){ |
| cinEntity.setExpirationTime(cin.getExpirationTime()); |
| } |
| |
| // announceTo O |
| if (!cin.getAnnounceTo().isEmpty()){ |
| cinEntity.getAnnounceTo().addAll(cin.getAnnounceTo()); |
| } |
| // ontologyRef O |
| if (cin.getOntologyRef() != null){ |
| cinEntity.setOntologyRef(cin.getOntologyRef()); |
| } |
| |
| DAO<ContentInstanceEntity> ciDAO = dbs.getDAOFactory().getContentInstanceDAO(); |
| |
| // case parent is Container |
| if (parentEntity.getResourceType().intValue() == (ResourceType.CONTAINER)) { |
| ContainerEntity container = (ContainerEntity) parentEntity; |
| if (container.getMaxNrOfInstances() != null) { |
| if (container.getCurrentNrOfInstances().intValue() >= container.getMaxNrOfInstances().intValue()) { |
| LOGGER.info("Deleting oldest content instance due to container size limit"); |
| ContentInstanceEntity oldCI = dbs.getDAOFactory().getOldestDAO().find(transaction, request.getTo()); |
| ciDAO.delete(transaction, oldCI); |
| UriMapper.deleteUri(oldCI.getHierarchicalURI()); |
| } else { |
| container.setCurrentNrOfInstances(BigInteger.valueOf(container.getCurrentNrOfInstances().intValue()+1)); |
| } |
| } |
| cinEntity.setParentContainer(container); |
| if(container.getStateTag() != null){ |
| container.setStateTag(BigInteger.valueOf(container.getStateTag().intValue() + 1)); |
| } |
| } |
| |
| // case parent is ContainerAnnc |
| if (parentEntity.getResourceType().intValue() == (ResourceType.CONTAINER_ANNC)) { |
| //TODO set parent containerAnnc when implemented |
| } |
| |
| // create the contentInstance in the DB |
| ciDAO.create(transaction, cinEntity); |
| |
| // commit the transaction |
| transaction.commit(); |
| |
| Notifier.notify(subscriptions, cinEntity, ResourceStatus.CHILD_CREATED); |
| |
| // create the response |
| response.setResponseStatusCode(ResponseStatusCode.CREATED); |
| // set the location of the resource |
| setLocationAndCreationContent(request, response, cinEntity); |
| return response; |
| } |
| |
| /** |
| * Generic do retrieve operation |
| * @param request |
| * @return response |
| */ |
| @Override |
| public ResponsePrimitive doRetrieve(RequestPrimitive request) { |
| // create the response primitive |
| ResponsePrimitive response = new ResponsePrimitive(request); |
| |
| // check existence of the resource |
| ContentInstanceEntity cinEntity = dbs.getDAOFactory().getContentInstanceDAO().find(transaction, request.getTo()); |
| if (cinEntity == null) { |
| throw new ResourceNotFoundException("Resource not found"); |
| } |
| |
| // check authorization |
| List<AccessControlPolicyEntity> acpList = cinEntity.getAcpListFromParent(); |
| checkACP(acpList, request.getFrom(), request.getOperation()); |
| |
| |
| // mapping the entity with the exchange resource |
| ContentInstance cin = EntityMapperFactory.getContentInstanceMapper(). |
| mapEntityToResource(cinEntity, request); |
| response.setContent(cin); |
| |
| response.setResponseStatusCode(ResponseStatusCode.OK); |
| // return the completed response |
| return response; |
| } |
| |
| |
| /** |
| * Full update for Content Instance |
| */ |
| @Override |
| public ResponsePrimitive doUpdate(RequestPrimitive request) { |
| // this operation is not allowed for content instance resource |
| throw new OperationNotAllowed("Update on ContentInstance is not Allowed"); |
| } |
| |
| /** |
| * Generic delete procedure |
| */ |
| @Override |
| public ResponsePrimitive doDelete(RequestPrimitive request) { |
| // create the response primitive |
| ResponsePrimitive response = new ResponsePrimitive(request); |
| Patterns patterns = new Patterns(); |
| |
| |
| // get the database service |
| DBService dbs = PersistenceService.getInstance().getDbService(); |
| DBTransaction transaction = dbs.getDbTransaction(); |
| // open the transaction |
| transaction.open(); |
| |
| // retrieve the target resource from database |
| ContentInstanceEntity cin = dbs.getDAOFactory() |
| .getContentInstanceDAO().find(transaction, request.getTo()); |
| if (cin == null) { |
| throw new ResourceNotFoundException("Resource not found"); |
| } |
| |
| // check the access control policies |
| checkACP(cin.getAcpListFromParent(), |
| request.getFrom(), request.getOperation()); |
| |
| UriMapper.deleteUri(cin.getHierarchicalURI()); |
| |
| @SuppressWarnings("unchecked") |
| DAO<ResourceEntity> parentDAO = (DAO<ResourceEntity>) patterns.getDAO(cin.getParentID(), dbs); |
| ResourceEntity parentEntity = parentDAO.find(transaction, cin.getParentID()); |
| if (parentEntity.getResourceType().intValue() == (ResourceType.CONTAINER)) { |
| ContainerEntity container = (ContainerEntity) parentEntity; |
| int nbI = container.getCurrentNrOfInstances().intValue(); |
| container.setCurrentNrOfInstances(BigInteger.valueOf(nbI-1)); |
| dbs.getDAOFactory().getContainerDAO().update(transaction, container); |
| } else { |
| throw new NotImplementedException("Parent is Container Annc, not implemented yet."); |
| } |
| Notifier.notifyDeletion(null, cin); |
| |
| // delete the resource |
| dbs.getDAOFactory().getContentInstanceDAO().delete(transaction, cin); |
| // commit the transaction |
| transaction.commit(); |
| // return the correct response |
| response.setResponseStatusCode(ResponseStatusCode.DELETED); |
| return response; |
| } |
| |
| } |
