| /******************************************************************************* |
| * Copyright (c) 2014, 2016 Orange. |
| * 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/ |
| *******************************************************************************/ |
| package org.eclipse.om2m.sdt.home.utils; |
| |
| import java.math.BigInteger; |
| import java.util.ArrayList; |
| import java.util.Date; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.eclipse.om2m.commons.constants.Constants; |
| import org.eclipse.om2m.commons.constants.FilterUsage; |
| import org.eclipse.om2m.commons.constants.MimeMediaType; |
| import org.eclipse.om2m.commons.constants.Operation; |
| import org.eclipse.om2m.commons.constants.ResourceType; |
| import org.eclipse.om2m.commons.constants.ResponseStatusCode; |
| import org.eclipse.om2m.commons.constants.ResultContent; |
| import org.eclipse.om2m.commons.resource.AbstractFlexContainer; |
| import org.eclipse.om2m.commons.resource.ChildResourceRef; |
| import org.eclipse.om2m.commons.resource.CustomAttribute; |
| import org.eclipse.om2m.commons.resource.FilterCriteria; |
| import org.eclipse.om2m.commons.resource.FlexContainer; |
| import org.eclipse.om2m.commons.resource.AbstractFlexContainerAnnc; |
| import org.eclipse.om2m.commons.resource.RequestPrimitive; |
| import org.eclipse.om2m.commons.resource.ResponsePrimitive; |
| import org.eclipse.om2m.commons.resource.URIList; |
| import org.eclipse.om2m.core.service.CseService; |
| import org.eclipse.om2m.sdt.Action; |
| import org.eclipse.om2m.sdt.Arg; |
| import org.eclipse.om2m.sdt.DataPoint; |
| import org.eclipse.om2m.sdt.Domain; |
| import org.eclipse.om2m.sdt.Identifiers; |
| import org.eclipse.om2m.sdt.Module; |
| import org.eclipse.om2m.sdt.Property; |
| import org.eclipse.om2m.sdt.args.Command; |
| import org.eclipse.om2m.sdt.datapoints.ArrayDataPoint; |
| import org.eclipse.om2m.sdt.datapoints.BooleanDataPoint; |
| import org.eclipse.om2m.sdt.datapoints.ByteDataPoint; |
| import org.eclipse.om2m.sdt.datapoints.DateDataPoint; |
| import org.eclipse.om2m.sdt.datapoints.DateTimeDataPoint; |
| import org.eclipse.om2m.sdt.datapoints.EnumDataPoint; |
| import org.eclipse.om2m.sdt.datapoints.FloatDataPoint; |
| import org.eclipse.om2m.sdt.datapoints.IntegerDataPoint; |
| import org.eclipse.om2m.sdt.datapoints.StringDataPoint; |
| import org.eclipse.om2m.sdt.datapoints.TimeDataPoint; |
| import org.eclipse.om2m.sdt.exceptions.ActionException; |
| import org.eclipse.om2m.sdt.exceptions.DataPointException; |
| import org.eclipse.om2m.sdt.home.devices.GenericDevice; |
| import org.eclipse.om2m.sdt.home.modules.GenericSensor; |
| import org.eclipse.om2m.sdt.home.types.DatapointType; |
| import org.eclipse.om2m.sdt.home.types.PropertyType; |
| import org.eclipse.om2m.sdt.home.utils.api.ISDTDiscovery; |
| |
| public class SDTDiscovery implements ISDTDiscovery { |
| |
| private static class MyFlexContainer { |
| |
| private AbstractFlexContainer flex; |
| private AbstractFlexContainerAnnc flexA; |
| |
| public MyFlexContainer(AbstractFlexContainer flex) { |
| this.flex = flex; |
| } |
| |
| public MyFlexContainer(AbstractFlexContainerAnnc flex) { |
| this.flexA = flex; |
| } |
| |
| public List<String> getLabels() { |
| return (flex == null) ? flexA.getLabels() : flex.getLabels(); |
| } |
| |
| public String getContainerDefinition() { |
| return (flex == null) ? flexA.getContainerDefinition() : flex.getContainerDefinition(); |
| } |
| |
| public CustomAttribute getCustomAttribute(String name) { |
| return (flex == null) ? flexA.getCustomAttribute(name) : flex.getCustomAttribute(name); |
| } |
| |
| public List<CustomAttribute> getCustomAttributes() { |
| return (flex == null) ? flexA.getCustomAttributes() : flex.getCustomAttributes(); |
| } |
| |
| public List<ChildResourceRef> getChildResource() { |
| return (flex == null) ? flexA.getChildResource() : flex.getChildResource(); |
| } |
| |
| public String toString() { |
| return (flex == null) ? flexA.toString() : flex.toString(); |
| } |
| |
| public String getLongName() { |
| return (flex == null) ? flexA.getName() : flex.getLongName(); |
| } |
| |
| public String getShortName() { |
| return (flex == null) ? flexA.getName() : flex.getShortName(); |
| } |
| |
| } |
| |
| static private final String SEP = "/"; |
| static private final String SDT_IPE = "SDT_IPE"; |
| static private final String SDT_IPE_ANNC = "SDT_IPE_Annc"; |
| |
| static private final String SDT_DEVICE_PACKAGE = GenericDevice.class.getPackage().getName(); |
| static private final String SDT_MODULE_PACKAGE = GenericSensor.class.getPackage().getName(); |
| |
| static private final String RESOURCE_ID_SEARCH_STRING = "ResourceID/"; |
| static private final String NAME_SEARCH_STRING = "name/"; |
| static private final String CNT_DEF_SEARCH_STRING = "cntDef/"; |
| static private final String APPLICATION_TYPE_SEARCH_STRING = "ResourceType/Application"; |
| static private final String DEVICE_TYPE_SEARCH_STRING = "object.type/device"; |
| |
| static private CseService cseService; |
| |
| private String mnName; |
| private Domain cloudDomain; |
| private Domain localDomain; |
| |
| static public void initCseService(CseService srv) { |
| cseService = srv; |
| } |
| |
| public SDTDiscovery(final String mnName) throws Exception { |
| this.mnName = mnName; |
| cloudDomain = new Domain("CloudDevices" + mnName); |
| localDomain = new Domain("LocalDevices" + mnName); |
| } |
| |
| @Override |
| public void validateUserCredentials(final String appName, |
| final String userName, final String password) throws Exception { |
| Activator.LOGGER.info("validateUserCredentials " + appName + " " + userName + "/" + password); |
| RequestPrimitive request = new RequestPrimitive(); |
| request.setReturnContentType(MimeMediaType.OBJ); |
| request.setRequestContentType(MimeMediaType.OBJ); |
| request.setOperation(Operation.RETRIEVE); |
| request.setFrom(userName + ":" + password); |
| request.setFilterCriteria(new FilterCriteria()); |
| request.getFilterCriteria().setFilterUsage(FilterUsage.DISCOVERY_CRITERIA); |
| request.getFilterCriteria().getLabels().add(RESOURCE_ID_SEARCH_STRING + appName); |
| request.getFilterCriteria().getLabels().add(APPLICATION_TYPE_SEARCH_STRING); |
| request.setTo(//SEP + Constants.CSE_ID + SEP + Constants.CSE_NAME); |
| SEP + Constants.CSE_ID + SEP + Constants.CSE_NAME + SEP + mnName); |
| Activator.LOGGER.info(request); |
| |
| ResponsePrimitive resp = cseService.doRequest(request); |
| Activator.LOGGER.info(resp); |
| BigInteger result = resp.getResponseStatusCode(); |
| if (! ResponseStatusCode.OK.equals(result)) { |
| Activator.LOGGER.warn("Retrieve error " + result); |
| throw new Exception("Internal error"); |
| } |
| URIList uriList = (URIList) resp.getContent(); |
| Activator.LOGGER.info("Application URIs " + uriList); |
| if (uriList.getListOfUri().isEmpty()) { |
| Activator.LOGGER.warn("Application not found"); |
| throw new Exception("Access denied"); |
| } |
| } |
| |
| @Override |
| public List<GenericDevice> getDevices(final boolean cloud, |
| final String name, final String password) throws Exception { |
| return getDevices(null, cloud, name, password); |
| } |
| |
| @Override |
| public List<GenericDevice> getDevices(final String cntDef, final boolean cloud, |
| final String name, final String password) throws Exception { |
| String cred = name + ":" + password; |
| List<GenericDevice> ret = new ArrayList<GenericDevice>(); |
| List<String> all = retrieveDeviceURIs(cntDef, cred); |
| if ((all != null) && ! all.isEmpty()) { |
| for (String uri : all) { |
| if (cloud) { |
| if (uri.contains(SDT_IPE) && ! uri.contains(SDT_IPE_ANNC)) |
| ret.add(readDevice(uri, true, cred)); |
| } else if (uri.contains(SDT_IPE_ANNC)) |
| ret.add(readDevice(uri, false, cred)); |
| } |
| } |
| return ret; |
| } |
| |
| @Override |
| public GenericDevice getDevice(final String deviceId, final boolean cloud, |
| final String name, final String password) throws Exception { |
| String cred = name + ":" + password; |
| List<String> labels = new ArrayList<String>(); |
| labels.add(DEVICE_TYPE_SEARCH_STRING); |
| labels.add(NAME_SEARCH_STRING + deviceId); |
| List<String> uris = retrieveDeviceURIs(labels, cred); |
| if ((uris == null) || uris.isEmpty()) { |
| throw new Exception("Device not found " + deviceId); |
| } |
| String uri = uris.get(0); |
| return readDevice(uri, cloud, cred); |
| } |
| |
| private List<String> retrieveDeviceURIs(final String cntDef, final String cred) |
| throws Exception { |
| List<String> labels = new ArrayList<String>(); |
| labels.add(DEVICE_TYPE_SEARCH_STRING); |
| if (cntDef != null) |
| labels.add(CNT_DEF_SEARCH_STRING + cntDef); |
| return retrieveDeviceURIs(labels, cred); |
| } |
| |
| private List<String> retrieveDeviceURIs(List<String> labels, final String cred) |
| throws Exception { |
| RequestPrimitive request = new RequestPrimitive(); |
| request.setTo(//Constants.SP_RELATIVE_URI_SEPARATOR + |
| SEP + Constants.CSE_ID + SEP + Constants.CSE_NAME |
| + SEP + mnName); |
| request.setReturnContentType(MimeMediaType.OBJ); |
| request.setRequestContentType(MimeMediaType.OBJ); |
| request.setOperation(Operation.RETRIEVE); |
| request.setFilterCriteria(new FilterCriteria()); |
| request.getFilterCriteria().setFilterUsage(FilterUsage.DISCOVERY_CRITERIA); |
| request.getFilterCriteria().getLabels().addAll(labels); |
| request.setFrom(cred); |
| |
| ResponsePrimitive resp = cseService.doRequest(request); |
| if (! ResponseStatusCode.OK.equals(resp.getResponseStatusCode())) { |
| throw new Exception("Could not read devices list: " + resp); |
| } |
| List<String> ret = ((URIList) resp.getContent()).getListOfUri(); |
| Activator.LOGGER.info("Device URIs found for " + labels + ": " + ret.size() + " " + ret); |
| return ret; |
| } |
| |
| private GenericDevice readDevice(final String uri, final boolean cloud, final String cred) |
| throws Exception { |
| Activator.LOGGER.info("Get device " + uri); |
| MyFlexContainer deviceFlex = retrieveFlexContainer(uri, ResultContent.ORIGINAL_RES, cred); |
| Activator.LOGGER.info("Got device " + deviceFlex); |
| Map<String, String> labels = new HashMap<String, String>(); |
| for (String label : deviceFlex.getLabels()) { |
| int idx = label.indexOf('/'); |
| if (idx > 0) |
| labels.put(label.substring(0, idx), label.substring(idx+1)); |
| } |
| String deviceId = labels.get("id"); |
| CustomAttribute serialAttr = |
| deviceFlex.getCustomAttribute(PropertyType.deviceSerialNum.getShortName()); |
| String serial = null; |
| if (serialAttr == null) { |
| Activator.LOGGER.info("No serial number property. Take id instead."); |
| serial = deviceId; |
| } else { |
| serial = serialAttr.getValue(); |
| } |
| Domain domain = cloud ? cloudDomain : localDomain; |
| GenericDevice device = (GenericDevice) domain.getDevice(deviceId); |
| if (device == null) { |
| String cntDef = deviceFlex.getContainerDefinition(); |
| if (deviceId.startsWith(cntDef + "__")) { |
| deviceId = deviceId.substring(cntDef.length() + 2); |
| } |
| String devName = cntDef.substring(cntDef.lastIndexOf('.') + 1); |
| if (devName.toLowerCase().startsWith("device")) |
| devName = devName.substring(6); // remove "device" prefix |
| devName = Character.toUpperCase(devName.charAt(0)) + devName.substring(1); |
| String className = SDT_DEVICE_PACKAGE + "." + devName; |
| Class<?> clazz = Class.forName(className); |
| device = (GenericDevice) clazz.getConstructor(String.class, String.class, Domain.class) |
| .newInstance(deviceId, serial, domain); |
| Activator.LOGGER.info("Created SDT device " + device); |
| } |
| for (CustomAttribute attr : deviceFlex.getCustomAttributes()) { |
| Activator.LOGGER.info("dev CustomAttribute: " + attr.getShortName() |
| + "/" + attr.getValue()); |
| PropertyType propType = PropertyType.fromShortName(attr.getShortName()); |
| if (propType != null) { |
| // Property prop = new Property(propType, attr.getCustomAttributeValue()); |
| // device.addProperty(prop); |
| device.addProperty(propType, attr.getValue()); |
| } |
| } |
| // Search children resources: modules |
| MyFlexContainer ctr = retrieveFlexContainer(uri, |
| ResultContent.ATTRIBUTES_AND_CHILD_REF, cred); |
| for (ChildResourceRef ref : ctr.getChildResource()) { |
| if (ref.getType().equals(BigInteger.valueOf(ResourceType.FLEXCONTAINER_ANNC)) |
| || ref.getType().equals(BigInteger.valueOf(ResourceType.FLEXCONTAINER))) { |
| Module module = readModule(ref.getValue(), cloud, cred); |
| if (device.getModule(module.getName()) == null) { |
| Activator.LOGGER.info("Add new module " + module); |
| device.addModule(module); // module URI |
| } else { |
| Activator.LOGGER.info("Already present module " + module); |
| } |
| } |
| } |
| Activator.LOGGER.info("Full SDT device " + device);//.prettyPrint()); |
| return device; |
| } |
| |
| private Module readModule(final String uri, final boolean cloud, final String cred) |
| throws Exception { |
| Activator.LOGGER.info("Get module " + uri); |
| MyFlexContainer moduleFlex = retrieveFlexContainer(uri, |
| ResultContent.ORIGINAL_RES, cred); |
| Activator.LOGGER.info("Got module " + moduleFlex); |
| Map<String,String> labels = new HashMap<String,String>(); |
| for (String label : moduleFlex.getLabels()) { |
| int idx = label.indexOf('/'); |
| if (idx > 0) |
| labels.put(label.substring(0, idx), label.substring(idx+1)); |
| } |
| List<Property> props = new ArrayList<Property>(); |
| List<CustomAttribute> dpAttrs = new ArrayList<CustomAttribute>(); |
| for (CustomAttribute attr : moduleFlex.getCustomAttributes()) { |
| Activator.LOGGER.info("CustomAttribute(1): " + attr.getShortName() |
| + "/" + attr.getValue()); |
| PropertyType propType = PropertyType.fromShortName(attr.getShortName()); |
| if (propType != null) { |
| Property prop = new Property(propType, attr.getValue()); |
| props.add(prop); |
| } else { |
| dpAttrs.add(attr); |
| } |
| } |
| String modName = labels.get("name"); |
| Domain domain = cloud ? cloudDomain : localDomain; |
| Module module = (Module) domain.getModule(modName); |
| if (module != null) { |
| for (Property prop : props) { |
| module.addProperty(prop); |
| } |
| Activator.LOGGER.info("Full retrieved SDT module " + module);//.prettyPrint()); |
| return module; |
| } |
| // Case new module |
| String cntDef = moduleFlex.getContainerDefinition(); |
| int idx = cntDef.lastIndexOf('.') + 1; |
| String className = SDT_MODULE_PACKAGE + "." + Character.toUpperCase(cntDef.charAt(idx)) |
| + cntDef.substring(idx + 1); |
| List<DataPoint> dps = new ArrayList<DataPoint>(); |
| for (CustomAttribute attr : dpAttrs) { |
| DatapointType datapointType = DatapointType.fromShortName(attr.getShortName()); |
| if (datapointType == null) { |
| Activator.LOGGER.warn("Unknown custom attribute, neither property nor datapoint: " |
| + attr.getShortName()); |
| continue; |
| } |
| String type = datapointType.getDataType().getTypeChoice().getOneM2MType(); |
| switch (type) { |
| case "xs:integer": dps.add(getIntegerDataPoint(attr, uri, cred)); break; |
| case "xs:boolean": dps.add(getBooleanDataPoint(attr, uri, cred)); break; |
| case "xs:string": dps.add(getStringDataPoint(attr, uri, cred)); break; |
| case "xs:byte": dps.add(getByteDataPoint(attr, uri, cred)); break; |
| case "xs:float": dps.add(getFloatDataPoint(attr, uri, cred)); break; |
| case "xs:datetime": dps.add(getDateTimeDataPoint(attr, uri, cred)); break; |
| case "xs:time": dps.add(getTimeDataPoint(attr, uri, cred)); break; |
| case "xs:date": dps.add(getDateDataPoint(attr, uri, cred)); break; |
| case "xs:enum": dps.add(getArrayDataPoint(attr, uri, cred)); break; |
| default: |
| if (type.startsWith("hd:")) { |
| type = type.substring(3); |
| dps.add(getEnumDataPoint(type, attr, uri, cred)); |
| } |
| break; |
| } |
| } |
| Map<String, DataPoint> dpsMap = new HashMap<String, DataPoint>(); |
| for (DataPoint dp : dps) { |
| dpsMap.put(dp.getShortName(), dp); |
| } |
| Class<?> clazz = Class.forName(className); |
| if (modName.startsWith(cntDef + "__")) { |
| modName = modName.substring(cntDef.length() + 2); |
| } |
| module = (Module) clazz.getConstructor(String.class, Domain.class, Map.class) |
| .newInstance(modName, domain, dpsMap); |
| Activator.LOGGER.info("Created SDT module " + module); |
| for (Property prop : props) { |
| module.addProperty(prop); |
| } |
| Activator.LOGGER.info("Full new SDT module " + module);//.prettyPrint()); |
| // Search children resources: modules |
| MyFlexContainer ctr = retrieveFlexContainer(uri, |
| ResultContent.ATTRIBUTES_AND_CHILD_REF, cred); |
| Activator.LOGGER.info("Children " + ctr.getChildResource()); |
| for (ChildResourceRef ref : ctr.getChildResource()) { |
| if (ref.getType().equals(BigInteger.valueOf(ResourceType.FLEXCONTAINER_ANNC)) |
| || ref.getType().equals(BigInteger.valueOf(ResourceType.FLEXCONTAINER))) { |
| try { |
| Action action = readAction(ref.getValue(), module, cred); |
| if (module.getAction(action.getName()) == null) { |
| Activator.LOGGER.info("Add new action " + action); |
| module.addAction(action); |
| } else { |
| Activator.LOGGER.info("Already present action " + action); |
| } |
| } catch (Exception e) { |
| Activator.LOGGER.error("Error creating action " + ref.getValue()); |
| } |
| } |
| } |
| return module; |
| } |
| |
| private Action readAction(final String uri, final Module module, final String cred) |
| throws Exception { |
| Activator.LOGGER.info("Get action " + uri); |
| final MyFlexContainer actionFlexContainer = retrieveFlexContainer(uri, |
| ResultContent.ORIGINAL_RES, cred); |
| Activator.LOGGER.info("Got action " + actionFlexContainer); |
| Map<String,String> labels = new HashMap<String,String>(); |
| for (String label : actionFlexContainer.getLabels()) { |
| int idx = label.indexOf('/'); |
| if (idx > 0) |
| labels.put(label.substring(0, idx), label.substring(idx+1)); |
| } |
| List<Arg> args = new ArrayList<Arg>(); |
| final List<CustomAttribute> attributes = actionFlexContainer.getCustomAttributes(); |
| // 2017 07 17 - BONNARDEL Gregory |
| // I commented out the next piece of code because there is no way |
| // to retrieve Arg type with current SDT apis. |
| // As we have only no-args action, this is not a problem. |
| // for (final CustomAttribute attr : attributes) { |
| // String type = attr.getCustomAttributeType(); |
| // Arg arg = new ValuedArg<Object>(attr.getCustomAttributeName(), |
| // new DataType(type, SimpleType.getSimpleType(type))) { |
| // public void setValue(Object value) { |
| // try { |
| // TypeConverter.setValue(attr, value); |
| // updateAttribute(uri, attr, cred); |
| // } catch (Exception e) { |
| // Activator.LOGGER.warn("Could not set arg", e); |
| // } |
| // } |
| // }; |
| // args.add(arg); |
| // } |
| final String cntDef = actionFlexContainer.getContainerDefinition(); |
| String actionName = labels.get("name"); |
| if (actionName == null) |
| actionName = cntDef.substring(cntDef.lastIndexOf('.') + 1); |
| Action action = module.getAction(actionName); |
| if (action != null) { |
| Activator.LOGGER.info("Full retrieved SDT action " + action); |
| return action; |
| } |
| action = new Command(actionName, args, |
| new Identifiers() { |
| @Override |
| public String getShortName() { |
| return actionFlexContainer.getShortName(); |
| } |
| @Override |
| public String getLongName() { |
| return actionFlexContainer.getLongName(); |
| } |
| @Override |
| public String getDefinition() { |
| return cntDef; |
| } |
| }) { |
| @Override |
| protected Object doInvoke() throws ActionException { |
| Activator.LOGGER.info("invoke SDT action"); |
| try { |
| return invokeAction(uri, attributes, cred); |
| } catch (Exception e) { |
| throw new ActionException(e); |
| } |
| } |
| }; |
| // |
| Activator.LOGGER.info("Created SDT action " + action); |
| return action; |
| } |
| |
| private IntegerDataPoint getIntegerDataPoint(final CustomAttribute attr, |
| final String uri, final String cred) { |
| return new IntegerDataPoint(DatapointType.fromShortName(attr.getShortName())) { |
| @Override |
| public void doSetValue(Integer val) throws DataPointException { |
| try { |
| SDTUtil.setValue(attr, val, "xs:integer"); |
| updateAttribute(uri, attr, cred); |
| } catch (Exception e) { |
| throw new DataPointException(e); |
| } |
| } |
| @Override |
| public Integer doGetValue() throws DataPointException { |
| try { |
| return (Integer) retrieveAttribute(uri, |
| attr.getShortName(), cred); |
| } catch (Exception e) { |
| throw new DataPointException(e); |
| } |
| } |
| }; |
| } |
| |
| private BooleanDataPoint getBooleanDataPoint(final CustomAttribute attr, |
| final String uri, final String cred) { |
| BooleanDataPoint ret = new BooleanDataPoint(DatapointType.fromShortName(attr.getShortName())) { |
| @Override |
| public void doSetValue(Boolean val) throws DataPointException { |
| try { |
| SDTUtil.setValue(attr, val, "xs:boolean"); |
| updateAttribute(uri, attr, cred); |
| } catch (Exception e) { |
| throw new DataPointException(e); |
| } |
| } |
| @Override |
| public Boolean doGetValue() throws DataPointException { |
| try { |
| return (Boolean) retrieveAttribute(uri, |
| attr.getShortName(), cred); |
| } catch (Exception e) { |
| throw new DataPointException(e); |
| } |
| } |
| }; |
| return ret; |
| } |
| |
| private StringDataPoint getStringDataPoint(final CustomAttribute attr, |
| final String uri, final String cred) { |
| return new StringDataPoint(DatapointType.fromShortName(attr.getShortName())) { |
| @Override |
| public void doSetValue(String val) throws DataPointException { |
| try { |
| SDTUtil.setValue(attr, val, "xs:string"); |
| updateAttribute(uri, attr, cred); |
| } catch (Exception e) { |
| throw new DataPointException(e); |
| } |
| } |
| @Override |
| public String doGetValue() throws DataPointException { |
| try { |
| return (String) retrieveAttribute(uri, |
| attr.getShortName(), cred); |
| } catch (Exception e) { |
| throw new DataPointException(e); |
| } |
| } |
| }; |
| } |
| |
| private ByteDataPoint getByteDataPoint(final CustomAttribute attr, |
| final String uri, final String cred) { |
| return new ByteDataPoint(DatapointType.fromShortName(attr.getShortName())) { |
| @Override |
| public void doSetValue(Byte val) throws DataPointException { |
| try { |
| SDTUtil.setValue(attr, val, "xs:byte"); |
| updateAttribute(uri, attr, cred); |
| } catch (Exception e) { |
| throw new DataPointException(e); |
| } |
| } |
| @Override |
| public Byte doGetValue() throws DataPointException { |
| try { |
| return (Byte) retrieveAttribute(uri, |
| attr.getShortName(), cred); |
| } catch (Exception e) { |
| throw new DataPointException(e); |
| } |
| } |
| }; |
| } |
| |
| private FloatDataPoint getFloatDataPoint(final CustomAttribute attr, |
| final String uri, final String cred) { |
| return new FloatDataPoint(DatapointType.fromShortName(attr.getShortName())) { |
| @Override |
| public void doSetValue(Float val) throws DataPointException { |
| try { |
| SDTUtil.setValue(attr, val, "xs:float"); |
| updateAttribute(uri, attr, cred); |
| } catch (Exception e) { |
| throw new DataPointException(e); |
| } |
| } |
| @Override |
| public Float doGetValue() throws DataPointException { |
| try { |
| return (Float) retrieveAttribute(uri, |
| attr.getShortName(), cred); |
| } catch (Exception e) { |
| throw new DataPointException(e); |
| } |
| } |
| }; |
| } |
| |
| private DateTimeDataPoint getDateTimeDataPoint(final CustomAttribute attr, |
| final String uri, final String cred) { |
| return new DateTimeDataPoint(DatapointType.fromShortName(attr.getShortName())) { |
| @Override |
| public void doSetValue(Date val) throws DataPointException { |
| try { |
| SDTUtil.setValue(attr, val, "xs:datetime"); |
| updateAttribute(uri, attr, cred); |
| } catch (Exception e) { |
| throw new DataPointException(e); |
| } |
| } |
| @Override |
| public Date doGetValue() throws DataPointException { |
| try { |
| return (Date) retrieveAttribute(uri, |
| attr.getShortName(), cred); |
| } catch (Exception e) { |
| throw new DataPointException(e); |
| } |
| } |
| }; |
| } |
| |
| private DateDataPoint getDateDataPoint(final CustomAttribute attr, |
| final String uri, final String cred) { |
| return new DateDataPoint(DatapointType.fromShortName(attr.getShortName())) { |
| @Override |
| public void doSetValue(Date val) throws DataPointException { |
| try { |
| SDTUtil.setValue(attr, val, "xs:date"); |
| updateAttribute(uri, attr, cred); |
| } catch (Exception e) { |
| throw new DataPointException(e); |
| } |
| } |
| @Override |
| public Date doGetValue() throws DataPointException { |
| try { |
| return (Date) retrieveAttribute(uri, |
| attr.getShortName(), cred); |
| } catch (Exception e) { |
| throw new DataPointException(e); |
| } |
| } |
| }; |
| } |
| |
| private TimeDataPoint getTimeDataPoint(final CustomAttribute attr, |
| final String uri, final String cred) { |
| return new TimeDataPoint(DatapointType.fromShortName(attr.getShortName())) { |
| @Override |
| public void doSetValue(Date val) throws DataPointException { |
| try { |
| SDTUtil.setValue(attr, val, "xs:time"); |
| updateAttribute(uri, attr, cred); |
| } catch (Exception e) { |
| throw new DataPointException(e); |
| } |
| } |
| @Override |
| public Date doGetValue() throws DataPointException { |
| try { |
| return (Date) retrieveAttribute(uri, |
| attr.getShortName(), cred); |
| } catch (Exception e) { |
| throw new DataPointException(e); |
| } |
| } |
| }; |
| } |
| |
| private ArrayDataPoint<String> getArrayDataPoint(final CustomAttribute attr, |
| final String uri, final String cred) { |
| return new ArrayDataPoint<String>(DatapointType.fromShortName(attr.getShortName())) { |
| @Override |
| public void doSetValue(List<String> val) throws DataPointException { |
| try { |
| SDTUtil.setValue(attr, val, "xs:enum"); |
| updateAttribute(uri, attr, cred); |
| } catch (Exception e) { |
| throw new DataPointException(e); |
| } |
| } |
| @SuppressWarnings("unchecked") |
| @Override |
| public List<String> doGetValue() throws DataPointException { |
| try { |
| return (List<String>) retrieveAttribute(uri, |
| attr.getShortName(), cred); |
| } catch (Exception e) { |
| throw new DataPointException(e); |
| } |
| } |
| }; |
| } |
| |
| @SuppressWarnings("unchecked") |
| private static EnumDataPoint<Integer> getEnumDataPoint(String type, final CustomAttribute attr, |
| final String uri, final String cred) { |
| try { |
| String className = DatapointType.class.getPackage().getName() + "." |
| + type.substring(0, 1).toUpperCase() + type.substring(1); |
| Class<?> clazz = Class.forName(className); |
| return (EnumDataPoint<Integer>) |
| clazz.getConstructor(Identifiers.class, EnumDataPoint.class) |
| .newInstance(DatapointType.fromShortName(attr.getShortName()), |
| new EnumDataPoint<Integer>(null) { |
| @Override |
| public void doSetValue(Integer val) throws DataPointException { |
| try { |
| SDTUtil.setValue(attr, val, "xs:enum"); |
| updateAttribute(uri, attr, cred); |
| } catch (Exception e) { |
| throw new DataPointException(e); |
| } |
| } |
| @Override |
| public Integer doGetValue() throws DataPointException { |
| try { |
| return (Integer) retrieveAttribute(uri, |
| attr.getShortName(), cred); |
| } catch (Exception e) { |
| throw new DataPointException(e); |
| } |
| } |
| }); |
| } catch (Exception e) { |
| e.printStackTrace(); |
| } |
| return null; |
| } |
| |
| private MyFlexContainer retrieveFlexContainer(final String uri, |
| final BigInteger resultContent, final String cred) throws Exception { |
| RequestPrimitive request = new RequestPrimitive(); |
| request.setOperation(Operation.RETRIEVE); |
| request.setReturnContentType(MimeMediaType.OBJ); |
| request.setRequestContentType(MimeMediaType.OBJ); |
| request.setFilterCriteria(new FilterCriteria()); |
| request.getFilterCriteria().setLevel(BigInteger.ONE); |
| request.setFrom(cred); |
| request.setTo(uri); |
| request.setResultContent(resultContent); |
| |
| ResponsePrimitive resp = cseService.doRequest(request); |
| BigInteger code = resp.getResponseStatusCode(); |
| if (! ResponseStatusCode.OK.equals(code)) |
| throw new Exception("Error searching " + uri + ": " + code); |
| Object ret = resp.getContent(); |
| if (ret instanceof AbstractFlexContainer) |
| return new MyFlexContainer((AbstractFlexContainer)ret); |
| else if (ret instanceof AbstractFlexContainerAnnc) |
| return new MyFlexContainer((AbstractFlexContainerAnnc)ret); |
| else |
| throw new Exception("Error not a FlexContainer " + uri); |
| } |
| |
| static private Object retrieveAttribute(final String uri, final String attr, |
| final String cred) throws Exception { |
| |
| DatapointType datapointType = DatapointType.fromShortName(attr); |
| |
| if (datapointType == null) { |
| return null; |
| } |
| RequestPrimitive request = new RequestPrimitive(); |
| request.setOperation(Operation.RETRIEVE); |
| request.setReturnContentType(MimeMediaType.OBJ); |
| request.setRequestContentType(MimeMediaType.OBJ); |
| request.setFrom(cred); |
| request.setTo(uri); |
| request.setResultContent(ResultContent.ORIGINAL_RES); |
| |
| ResponsePrimitive resp = cseService.doRequest(request); |
| Activator.LOGGER.info("read " + attr + " -> " + resp.getResponseStatusCode()); |
| if (! ResponseStatusCode.OK.equals(resp.getResponseStatusCode())) |
| throw new Exception("Error reading cloud data: " + resp.getResponseStatusCode()); |
| return SDTUtil.getValue(((AbstractFlexContainer) resp.getContent()).getCustomAttribute(attr), datapointType.getDataType().getTypeChoice().getOneM2MType()); |
| } |
| |
| static public void updateAttribute(final String uri, |
| final CustomAttribute customAttribute, final String cred) throws Exception { |
| FlexContainer flexContainer = new FlexContainer(); |
| flexContainer.getCustomAttributes().add(customAttribute); |
| |
| RequestPrimitive request = new RequestPrimitive(); |
| request.setContent(flexContainer); |
| request.setReturnContentType(MimeMediaType.OBJ); |
| request.setRequestContentType(MimeMediaType.OBJ); |
| request.setResultContent(ResultContent.ORIGINAL_RES); |
| request.setOperation(Operation.UPDATE); |
| request.setFrom(cred); |
| request.setTo(uri); |
| |
| ResponsePrimitive resp = cseService.doRequest(request); |
| Activator.LOGGER.info("write " + customAttribute + " -> " + resp.getResponseStatusCode()); |
| if (! ResponseStatusCode.UPDATED.equals(resp.getResponseStatusCode())) |
| throw new Exception("Error writing cloud data: " + resp.getResponseStatusCode()); |
| } |
| |
| public String invokeAction(final String uri, |
| final List<CustomAttribute> customAttributes, final String cred) throws Exception { |
| FlexContainer flexContainer = new FlexContainer(); |
| flexContainer.getCustomAttributes().addAll(customAttributes); |
| |
| RequestPrimitive request = new RequestPrimitive(); |
| request.setContent(flexContainer); |
| request.setReturnContentType(MimeMediaType.OBJ); |
| request.setRequestContentType(MimeMediaType.OBJ); |
| request.setResultContent(ResultContent.ORIGINAL_RES); |
| request.setOperation(Operation.UPDATE); |
| request.setFrom(cred); |
| request.setTo(uri); |
| |
| ResponsePrimitive resp = cseService.doRequest(request); |
| Activator.LOGGER.info("invoke " + customAttributes + " -> " + resp.getResponseStatusCode()); |
| if (! ResponseStatusCode.UPDATED.equals(resp.getResponseStatusCode())) |
| throw new Exception("Error invoking cloud action: " + resp.getResponseStatusCode()); |
| CustomAttribute ret = ((AbstractFlexContainer) resp.getContent()).getCustomAttribute("output"); |
| return (ret == null) ? null : ret.getValue(); |
| } |
| |
| } |
