Turn on suggestions
Auto-suggest helps you quickly narrow down your search results by suggesting possible matches as you type.
Showing results for
Turn on suggestions
Auto-suggest helps you quickly narrow down your search results by suggesting possible matches as you type.
Showing results for
Community Tip - You can subscribe to a forum, label or individual post and receive email notifications when someone posts a new topic or reply. Learn more! X
Options
- Subscribe to RSS Feed
- Mark as New
- Mark as Read
- Bookmark
- Subscribe
- Printer Friendly Page
- Notify Moderator
Axeda: Helper Functions for Extended Objects
No ratings
This is a collection of methods for working with ExtendedObjects based on the functions used in Fleetster.
import com.axeda.drm.sdk.device.Device
import com.axeda.platform.sdk.v1.services.ServiceFactory
import com.axeda.platform.sdk.v1.services.extobject.ExtendedObjectSearchCriteria
import com.axeda.platform.sdk.v1.services.extobject.PropertySearchCriteria
import com.axeda.platform.sdk.v1.services.extobject.expression.PropertyExpressionFactory
import com.axeda.drm.sdk.data.CurrentDataFinder
import com.axeda.platform.sdk.v1.services.extobject.ExtendedObject
import com.axeda.platform.sdk.v1.services.extobject.Property
import java.text.DecimalFormat
import com.axeda.drm.sdk.Context
import com.axeda.drm.sdk.device.DeviceDataFinder
import com.axeda.drm.sdk.user.User
import com.axeda.platform.sdk.v1.services.extobject.ExtendedObjectService
import com.axeda.platform.sdk.v1.services.extobject.PropertyType
import com.axeda.platform.sdk.v1.services.extobject.PropertyDataType
import com.axeda.platform.sdk.v1.services.extobject.ExtendedObjectType
import com.axeda.common.sdk.id.Identifier
import groovy.time.*
/* ************************************* */
/* HelperFunctionsExtendedObjects.groovy
* Extended Object retrieval/manipulation functions.
*
* A collection of methods for working with ExtendedObjects.
*
* author: sara streeter <sstreeter@axeda.com>
************************************* */
def eoSvc = new ServiceFactory().getExtendedObjectService()
def fetchFirstExtendedObject(DataItem dataItem, Map searchcriteria) {
def criteria = new ExtendedObjectSearchCriteria()
criteria.extendedObjectClassName = 'com.axeda.drm.sdk.device.DataItem'
criteria.internalObjectId = dataItem.id.value
criteria.extendedClientKey = "ExtendedDataItem!${dataItem.name}"
def eo
if (searchcriteria != null){
criteria.propertySearchCriteria = advancedPropertySearch(searchcriteria)
}
def queryResult = eoSvc.findExtendedObjects(criteria, -1, -1, null)
if (queryResult.size() > 0 ){
eo = queryResult.first()
}
return eo
}
def addOrFetchExtendedDataItem(DataItem dataItem, Map searchcriteria) {
def criteria = new ExtendedObjectSearchCriteria()
criteria.extendedObjectClassName = 'com.axeda.drm.sdk.device.DataItem'
criteria.internalObjectId = dataItem.id.value
criteria.extendedClientKey = "ExtendedDataItem!${dataItem.name}"
def eo
if (searchcriteria != null){
criteria.propertySearchCriteria = advancedPropertySearch(searchcriteria)
}
def queryResult = eoSvc.findExtendedObjects(criteria, -1, -1, null)
if (queryResult.size() == 0 || queryResult == null){
eo = new ExtendedObject()
eo.internalObjectId = dataItem.id.value
eo.extendedObjectType = eoSvc.findExtendedObjectTypeByClassname('com.axeda.drm.sdk.device.DataItem')
eo.externalClientKey = "ExtendedDataItem!${dataItem.name}"
eo = eoSvc.createExtendedObject(eo)
searchcriteria += [eotype: "ExtendedObject"]
createProperties(eoSvc, eo, searchcriteria)
}
else eo = queryResult.first()
return eo
}
def fetchExtendedDataItem(DataItem dataItem) {
def criteria = new ExtendedObjectSearchCriteria()
criteria.extendedObjectClassName = "com.axeda.drm.sdk.device.DataItem"
criteria.extendedClientKey = "ExtendedDataItem!${dataItem.name}"
criteria.internalObjectId = dataItem.id.value
def queryResult = eoSvc.findExtendedObjects(criteria, -1, -1, null)
return queryResult
}
def fetchExtendedObjectsAdvancedCriteria(DataItem dataItem, Map searchcriteria, String classname, String uniqueKey) {
def criteria = new ExtendedObjectSearchCriteria()
criteria.extendedObjectClassName = "com.axeda.drm.sdk.device.DataItem"
criteria.extendedClientKey = "ExtendedDataItem!${dataItem.name}"
criteria.internalObjectId = dataItem.id.value
if (searchcriteria != null){
criteria.propertySearchCriteria = advancedPropertySearch(searchcriteria)
}
def queryResult = eoSvc.findExtendedObjects(criteria, -1, -1, null)
return queryResult
}
def fetchExtendedObject(User user, Map searchcriteria) {
def criteria = new ExtendedObjectSearchCriteria()
criteria.extendedObjectClassName = "com.axeda.drm.sdk.user.User"
criteria.extendedClientKey = "ExtendedObject!${user.username}"
criteria.internalObjectId = user.id.value
criteria.propertySearchCriteria = exactdatePropertySearch(searchcriteria)
def queryResult = eoSvc.findExtendedObjects(criteria, -1, -1, null)
return queryResult
}
def addExtendedObject(String eoTypeName, Long referenceId, String referenceName, Map objectProperties) {
def eo = new ExtendedObject()
eo.internalObjectId = referenceId
eo.extendedObjectType = eoSvc.findExtendedObjectTypeByClassname(eoTypeName)
eo.externalClientKey = referenceName
eo = eoSvc.createExtendedObject(eo)
eo = createProperties(eoSvc, eo, objectProperties)
return eo
}
def updateExtendedObject(ExtendedObject ExtendedObject, ExtendedObject ExtendedObject) {
def ExtendedObjectprop = getProperties(ExtendedObject)
def ExtendedObjectprop = getProperties(ExtendedObject)
def newproperties = [:]
if (ExtendedObjectprop.timestamp != null){
def ExtendedObjecttype = ExtendedObjectprop.lasttype
def ExtendedObjecttime = ExtendedObjectprop.lasttime
if (ExtendedObjecttype == null){
newproperties["lasttype"] = ExtendedObjectprop.type
newproperties["lasttime"] = ExtendedObjectprop.timestamp
}
else {
def oldtime = Long.valueOf(ExtendedObjecttime)
def total = (Long.valueOf(ExtendedObjectprop.timestamp) - oldtime)/1000
// illustrating getPropertyByName /
def lasttype = ExtendedObject.getPropertyByName("lasttype")
lasttype.setValue(ExtendedObjectprop.type)
def lasttime = ExtendedObject.getPropertyByName("lasttime")
lasttime.setValue(ExtendedObjectprop.timestamp)
updateProperty(lasttype)
updateProperty(lasttime)
if (ExtendedObjectprop.containsKey(ExtendedObjecttype + "_total")==false)
{
newproperties[ExtendedObjecttype + "_total"] = total
}
else {
def totalprop = ExtendedObject.getPropertyByName(ExtendedObjecttype + "_total")
def lasttotal = Double.valueOf(totalprop.value)
totalprop.setValue(String.valueOf(Double.valueOf(total) + lasttotal))
updateProperty(totalprop)
}
}
if (newproperties.size() > 0){
ExtendedObject = createProperties(eoSvc, ExtendedObject, newproperties)
}
}
return ExtendedObject
}
def getProperties(ExtendedObject object){
def result = object.properties.inject([:]) { target, property ->
target += [(property.propertyType.name): castPropertyValueToDefinedType(property)]
}
return result
}
def formatProperties(Map properties){
def result = properties.collect { property, value ->
[type: property, time: value]
}
return result
}
def updateProperty(Property property){
eoSvc.updateProperty(property)
return property
}
//default string version
def createProperties (ExtendedObjectService eoSvc, ExtendedObject object, Map properties) {
return createProperties(eoSvc, object, properties, PropertyDataType.String)
}
//WARNING: PDT may not work if it's a Date; it hasn't been tested.
def createProperties (ExtendedObjectService eoSvc, ExtendedObject object, Map properties, PropertyDataType PDT) {
// http://groovy.codehaus.org/Operators#Operators-ElvisOperator
PDT = PDT?:PropertyDataType.String
properties.each { k , v ->
def property = new com.axeda.platform.sdk.v1.services.extobject.Property()
def propertytype = object.extendedObjectType.getPropertyTypeByName(k.toString())
if (propertytype == null){
def newPropertyType = new PropertyType()
newPropertyType.name = k
newPropertyType.dataType = PDT
newPropertyType.extendedObjectType = object.extendedObjectType
eoSvc.createPropertyType(newPropertyType)
property.propertyType = newPropertyType
} else { property.propertyType = propertytype }
property.value = (PDT == PropertyDataType.Date && v instanceof Date?v.format("yyyy-MM-ddTHH:mm:ssZ"):v.toString())
eoSvc.createPropertyOnExtendedObject(object, property)
}
object = findExtendedObjectById(object.id)
return object
}
def findExtendedObjectById(Long id){
def criteria = new ExtendedObjectSearchCriteria()
criteria.id = id
def queryResult = eoSvc.findExtendedObjects(criteria, -1, -1, null)
return queryResult.first()
}
def findObjectByNextPropertyValue (ExtendedObject object, Map criteria, PropertySearchCriteria psCriteria){
Property prop = object.getPropertyByName(criteria.incrementName)
def incrementedProp = prop.value.toInteger() + criteria.incrementValue.toInteger()
psCriteria.setPropertyExpression(
PropertyExpressionFactory.and(
psCriteria.propertyExpression,
PropertyExpressionFactory.eq(criteria.incrementName, incrementedProp.toString())
)
)
def eoCriteria = new ExtendedObjectSearchCriteria()
eoCriteria.extendedObjectClassName = "com.axeda.drm.sdk.user.User"
eoCriteria.internalObjectId = object.internalObjectId
eoCriteria.propertySearchCriteria = psCriteria
def queryResult = eoSvc.findExtendedObjects(eoCriteria, -1, -1, null)
return queryResult.first()
}
def advancedPropertySearch (Map searchcriteria){
def propCriteria = new PropertySearchCriteria()
propCriteria.setPropertyExpression(
PropertyExpressionFactory.and(
PropertyExpressionFactory.eq("year", searchcriteria.year),
PropertyExpressionFactory.and(
PropertyExpressionFactory.eq("month", searchcriteria.month),
PropertyExpressionFactory.eq("date", searchcriteria.date)
)
)
)
return propCriteria
}
static def extendedObjectToMap(ExtendedObject object) {
Map result = [:]
result.extendedObjectType = object?.extendedObjectType?.className
result.extendedObjectTypeId = object?.extendedObjectTypeId
result.id = object?.id
result.externalClientKey = object?.externalClientKey
result.internalObjectId = object?.internalObjectId
// build up the properties of the ExtendedObject.
result.properties = object?.properties.inject([:]) { target, property ->
target += [(property?.propertyType?.name): castPropertyValueToDefinedType(property)]
}
return result
}
static def extendedObjectTypeToMap(ExtendedObjectType objectType) {
Map result = [:]
result.className = objectType.className
result.id = objectType.id
result.displayName = objectType.displayName
result.userDefined = objectType.userDefined
result.description = objectType.description
result.properties = objectType.propertyTypes.inject([]) { List list, PropertyType propertyType ->
list << [
name: propertyType.name,
id: propertyType.id,
description: propertyType.description,
dataType: propertyType.dataType.toString(),
extendedObjectType: propertyType.extendedObjectType.className
]
}
return result
}
private static def castPropertyValueToDefinedType(Property property) {
switch(property.propertyType.dataType) {
case PropertyDataType.Boolean:
return property.value as Boolean
case PropertyDataType.Date:
Calendar calendar = javax.xml.bind.DatatypeConverter.parseDateTime(property.value)
return calendar.getTime()
case PropertyDataType.Double:
return property.value as Double
case PropertyDataType.Integer:
return property.value as Long
case PropertyDataType.String:
default:
return property.value
}
}
static def removeExtendedObject(Long itemId) {
def eoSvc = new ServiceFactory().getExtendedObjectService()
eoSvc.deleteExtendedObject(itemId)
}
def removeUserExtendedObjects(User user) {
def queryresult = fetchUserExtendedObjects(user)
queryresult.each{
eoSvc.deleteExtendedObject(it.id)
}
}
ExtendedObjectType findExtendedObjectType(String typeName) {
ExtendedObjectType userObjType = eoSvc.findExtendedObjectTypeByClassname(typeName)
return userObjType
}
ExtendedObjectType findOrCreateExtendedObjectType(String typeName) {
ExtendedObjectType type = findExtendedObjectType(typeName)
if (type == null) {
type = new ExtendedObjectType()
type.className = typeName
type.displayName = typeName
type.description = "Autocreated type for $typeName"
type = eoSvc.createExtendedObjectType(type)
}
return type
}
