Extractor/Extractor.groovy

   1 ////////////////////////////////////////
   2 //import libraries
   3 import groovy.transform.Field
   4
   5
   6 //import classes
   7 //Importing Classes
   8 import ContactSensor.ContactSensor
   9 import ContactSensor.ContactSensors
  10 import DoorControl.DoorControl
  11 import DoorControl.DoorControls
  12 import Lock.Lock
  13 import Lock.Locks
  14 import Thermostat.Thermostat
  15 import Thermostat.Thermostats
  16 import Switch.Switch
  17 import Switch.Switches
  18 import PresenceSensor.PresenceSensor
  19 import PresenceSensor.PresenceSensors
  20 import Logger.Logger
  21 import Location.LocationVar
  22 import Location.Phrase
  23 import appTouch.Touched
  24 import NfcTouch.NfcTouch
  25 import AeonKeyFob.AeonKeyFob
  26 import AeonKeyFob.AeonKeyFobs
  27 import MusicPlayer.MusicPlayer
  28 import MusicPlayer.MusicPlayers
  29 import MotionSensor.MotionSensor
  30 import MotionSensor.MotionSensors
  31 import ImageCapture.ImageCapture
  32 import ImageCapture.ImageCaptures
  33 import SmokeDetector.SmokeDetector
  34 import SmokeDetector.SmokeDetectors
  35 import Alarm.Alarm
  36 import Alarm.Alarms
  37 import SpeechSynthesis.SpeechSynthesis
  38 import SpeechSynthesis.SpeechSynthesises
  39 import AccelerationSensor.AccelerationSensor
  40 import AccelerationSensor.AccelerationSensors
  41 import Battery.Battery
  42 import Battery.Batteries
  43 import BeaconSensor.BeaconSensor
  44 import BeaconSensor.BeaconSensors
  45 import CarbonMonoxideDetector.CarbonMonoxideDetector
  46 import CarbonMonoxideDetector.CarbonMonoxideDetectors
  47 import ColorControl.ColorControl
  48 import ColorControl.ColorControls
  49 import EnergyMeter.EnergyMeter
  50 import EnergyMeter.EnergyMeters
  51 import IlluminanceMeasurement.IlluminanceMeasurement
  52 import IlluminanceMeasurement.IlluminanceMeasurements
  53 import PowerMeter.PowerMeter
  54 import PowerMeter.PowerMeters
  55 import RelativeHumidityMeasurement.RelativeHumidityMeasurement
  56 import RelativeHumidityMeasurement.RelativeHumidityMeasurements
  57 import RelaySwitch.RelaySwitch
  58 import RelaySwitch.RelaySwitches
  59 import SleepSensor.SleepSensor
  60 import SleepSensor.SleepSensors
  61 import StepSensor.StepSensor
  62 import StepSensor.StepSensors
  63 import SwitchLevel.SwitchLevel
  64 import SwitchLevel.SwitchLevels
  65 import TemperatureMeasurement.TemperatureMeasurement
  66 import TemperatureMeasurement.TemperatureMeasurements
  67 import WaterSensor.WaterSensor
  68 import WaterSensor.WaterSensors
  69 import Valve.Valve
  70 import Valve.Valves
  71 import MobilePresence.MobilePresence
  72 import MobilePresence.MobilePresences
  73 import ColorTemperature.ColorTemperature
  74 import ColorTemperature.ColorTemperatures
  75 import Button.Button
  76 import Button.Buttons
  77 import ThreeAxis.ThreeAxis
  78 import ThreeAxis.ThreeAxises
  79 import Momentary.Momentary
  80 import Momentary.Momentaries
  81 import Timer.SimulatedTimer
  82
  83 //GlobalVariables
  84 @Field def location = new LocationVar()
  85 //Settings variable defined to settings on purpose
  86 @Field def settings = [app: "app"]
  87 //Global variable for state[mode]
  88 @Field def state = [home:[],away:[],night:[]]
  89 //Create a global logger object for methods
  90 @Field def log = new Logger()
  91 //Create a global variable for optional property
  92 @Field def optional = false //by default for now
  93 //Global Object for class AtomicState!
  94 @Field def atomicState = [history: "15:00"]
  95
  96
  97 //Global variables for files
  98 @Field File globalObjects = new File("Extractor/globalObjects.groovy")
  99 @Field File extractedObjectsApp1 = new File("Extractor/App1/extractedObjectsApp1.groovy")
 100 @Field File extractedObjectsApp2 = new File("Extractor/App2/extractedObjectsApp2.groovy")
 101 @Field File extractedObjectsConstructorApp1 = new File("Extractor/App1/extractedObjectsConstructorApp1.groovy")
 102 @Field File extractedObjectsConstructorApp2 = new File("Extractor/App2/extractedObjectsConstructorApp2.groovy")
 103
 104
 105 //Empty the files
 106 if (App == "App1") {
 107         globalObjects.write("")
 108         extractedObjectsApp1.write("")
 109         extractedObjectsConstructorApp1.write("")
 110 } else if (App == "App2") {
 111         extractedObjectsApp2.write("")
 112         extractedObjectsConstructorApp2.write("")
 113 }
 114
 115
 116
 117 //Some of methods-May be needed even in install
 118 /////////////////////////////////////////////////////////////////////
 119 def timeToday(String time, Object timeZone) {
 120         def timeOfDay = new Date()
 121         def _inputTime = time.split(':')
 122         def inputTime = Integer.parseInt(_inputTime[0])*3600+Integer.parseInt(_inputTime[1])*60+1564191100415
 123         timeOfDay.time = inputTime
 124         return timeOfDay
 125 }
 126
 127
 128
 129 //Global objects
 130 //Global Object for class Touch Sensor!
 131 @Field touchSensorObjects = 0
 132 @Field def touchSensorObject0
 133 @Field def touchSensorObject1
 134 @Field def touchSensorObject2
 135 //Global Object for class switch!
 136 @Field switchObjects = 0
 137 @Field def switchObject0
 138 @Field def switchObject1
 139 @Field def switchObject2
 140 //Global Object for class lock!
 141 @Field lockObjects = 0
 142 @Field def lockObject0
 143 @Field def lockObject1
 144 @Field def lockObject2
 145 //Global Object for class door control!
 146 @Field doorControlObjects = 0
 147 @Field def doorControlObject0
 148 @Field def doorControlObject1
 149 @Field def doorControlObject2
 150 //Global Object for class contact sensor!
 151 @Field contactObjects = 0
 152 @Field def contactObject0
 153 @Field def contactObject1
 154 @Field def contactObject2
 155 //Global Object for class presence sensor!
 156 @Field presenceSensorObjects = 0
 157 @Field def presenceSensorObject0
 158 @Field def presenceSensorObject1
 159 @Field def presenceSensorObject2
 160 //Global Object for class thermostat!
 161 @Field thermostatObjects = 0
 162 @Field def thermostatObject0
 163 @Field def thermostatObject1
 164 @Field def thermostatObject2
 165 //Global Object for class music player!
 166 @Field musicPlayerObjects = 0
 167 @Field def musicPlayerObject0
 168 @Field def musicPlayerObject1
 169 @Field def musicPlayerObject2
 170 //Global Object for class aeon key fob!
 171 @Field aeonKeyFobObjects = 0
 172 @Field def aeonKeyFobObject0
 173 @Field def aeonKeyFobObject1
 174 @Field def aeonKeyFobObject2
 175 //Global Object for class motion sensor!
 176 @Field motionSensorObjects = 0
 177 @Field def motionSensorObject0
 178 @Field def motionSensorObject1
 179 @Field def motionSensorObject2
 180 //Global Object for class image capture!
 181 @Field imageCaptureObjects = 0
 182 @Field def imageCaptureObject0
 183 @Field def imageCaptureObject1
 184 @Field def imageCaptureObject2
 185 //Global Object for class smoke detector!
 186 @Field smokeDetectorObjects = 0
 187 @Field def smokeDetectorObject0
 188 @Field def smokeDetectorObject1
 189 @Field def smokeDetectorObject2
 190 //Global Object for class alarm!
 191 @Field alarmObjects = 0
 192 @Field def alarmObject0
 193 @Field def alarmObject1
 194 @Field def alarmObject2
 195 //Global Object for class speech synthesis!
 196 @Field speechSynthesisObjects = 0
 197 @Field def speechSynthesisObject0
 198 @Field def speechSynthesisObject1
 199 @Field def speechSynthesisObject2
 200 //Global Object for class acceleration sensor!
 201 @Field accelerationSensorObjects = 0
 202 @Field def accelerationSensorObject0
 203 @Field def accelerationSensorObject1
 204 @Field def accelerationSensorObject2
 205 //Global Object for class battery!
 206 @Field batteryObjects = 0
 207 @Field def batteryObject0
 208 @Field def batteryObject1
 209 @Field def batteryObject2
 210 //Global Object for class beacon sensor!
 211 @Field beaconSensorObjects = 0
 212 @Field def beaconSensorObject0
 213 @Field def beaconSensorObject1
 214 @Field def beaconSensorObject2
 215 //Global Object for class carbon monoxide detector!
 216 @Field carbonMonoxideDetectorObjects = 0
 217 @Field def carbonMonoxideDetectorObject0
 218 @Field def carbonMonoxideDetectorObject1
 219 @Field def carbonMonoxideDetectorObject2
 220 //Global Object for class color control!
 221 @Field colorControlObjects = 0
 222 @Field def colorControlObject0
 223 @Field def colorControlObject1
 224 @Field def colorControlObject2
 225 //Global Object for class energy meter!
 226 @Field energyMeterObjects = 0
 227 @Field def energyMeterObject0
 228 @Field def energyMeterObject1
 229 @Field def energyMeterObject2
 230 //Global Object for class energy meter!
 231 @Field illuminanceMeasurementObjects = 0
 232 @Field def illuminanceMeasurementObject0
 233 @Field def illuminanceMeasurementObject1
 234 @Field def illuminanceMeasurementObject2
 235 //Global Object for class power meter!
 236 @Field powerMeterObjects = 0
 237 @Field def powerMeterObject0
 238 @Field def powerMeterObject1
 239 @Field def powerMeterObject2
 240 //Global Object for class power meter!
 241 @Field humidityMeasurementObjects = 0
 242 @Field def humidityMeasurementObject0
 243 @Field def humidityMeasurementObject1
 244 @Field def humidityMeasurementObject2
 245 //Global Object for class relay switch!
 246 @Field relaySwitchObjects = 0
 247 @Field def relaySwitchObject0
 248 @Field def relaySwitchObject1
 249 @Field def relaySwitchObject2
 250 //Global Object for class sleep sensor!
 251 @Field sleepSensorObjects = 0
 252 @Field def sleepSensorObject0
 253 @Field def sleepSensorObject1
 254 @Field def sleepSensorObject2
 255 //Global Object for class step sensor!
 256 @Field stepSensorObjects = 0
 257 @Field def stepSensorObject0
 258 @Field def stepSensorObject1
 259 @Field def stepSensorObject2
 260 //Global Object for class switch level!
 261 @Field switchLevelObjects = 0
 262 @Field def switchLevelObject0
 263 @Field def switchLevelObject1
 264 @Field def switchLevelObject2
 265 //Global Object for class temperature measurement!
 266 @Field temperatureMeasurementObjects = 0
 267 @Field def temperatureMeasurementObject0
 268 @Field def temperatureMeasurementObject1
 269 @Field def temperatureMeasurementObject2
 270 //Global Object for class water sensor!
 271 @Field waterSensorObjects = 0
 272 @Field def waterSensorObject0
 273 @Field def waterSensorObject1
 274 @Field def waterSensorObject2
 275 //Global Object for class valve!
 276 @Field valveObjects = 0
 277 @Field def valveObject0
 278 @Field def valveObject1
 279 @Field def valveObject2
 280 //Global Object for class mobile presence!
 281 @Field mobilePresenceObjects = 0
 282 @Field def mobilePresenceObject0
 283 @Field def mobilePresenceObject1
 284 @Field def mobilePresenceObject2
 285 //Global Object for class color temperature!
 286 @Field colorTemperatureObjects = 0
 287 @Field def colorTemperatureObject0
 288 @Field def colorTemperatureObject1
 289 @Field def colorTemperatureObject2
 290 //Global Object for class button!
 291 @Field buttonObjects = 0
 292 @Field def buttonObject0
 293 @Field def buttonObject1
 294 @Field def buttonObject2
 295 //Global Object for class three axis!
 296 @Field threeAxisObjects = 0
 297 @Field def threeAxisObject0
 298 @Field def threeAxisObject1
 299 @Field def threeAxisObject2
 300 //Global Object for class momentary switch device!
 301 @Field momentaryObjects = 0
 302 @Field def momentaryObject0
 303 @Field def momentaryObject1
 304 @Field def momentaryObject2
 305
 306
 307 //Global variables
 308 //For mode
 309 @Field modeVariables = 0
 310 @Field mode0
 311 @Field mode1
 312 @Field mode2
 313 @Field mode3
 314 @Field mode4
 315 @Field mode5
 316 //For number
 317 @Field numberVariables = 0
 318 @Field number0
 319 @Field number1
 320 @Field number2
 321 @Field number3
 322 @Field number4
 323 @Field number5
 324 //For decimal
 325 @Field decimalVariables = 0
 326 @Field decimal0
 327 @Field decimal1
 328 @Field decimal2
 329 @Field decimal3
 330 @Field decimal4
 331 @Field decimal5
 332 //For time
 333 @Field timeVariables = 0
 334 @Field time0
 335 @Field time1
 336 @Field time2
 337 @Field time3
 338 @Field time4
 339 @Field time5
 340 //For enum
 341 @Field enumVariables = 0
 342 @Field enum0
 343 @Field enum1
 344 @Field enum2
 345 @Field enum3
 346 @Field enum4
 347 @Field enum5
 348 //For phone
 349 @Field phoneVariables = 0
 350 @Field phone0
 351 @Field phone1
 352 @Field phone2
 353 @Field phone3
 354 @Field phone4
 355 @Field phone5
 356 //For contact
 357 @Field contactVariables = 0
 358 @Field contact0
 359 @Field contact1
 360 @Field contact2
 361 @Field contact3
 362 @Field contact4
 363 @Field contact5
 364 //For text
 365 @Field textVariables = 0
 366 @Field textVariable0
 367 @Field textVariable1
 368 @Field textVariable2
 369 @Field textVariable3
 370 @Field textVariable4
 371 @Field textVariable5
 372 //For boolean
 373 @Field boolVariables = 0
 374 @Field boolVariable0
 375 @Field boolVariable1
 376 @Field boolVariable2
 377 @Field boolVariable3
 378 @Field boolVariable4
 379 @Field boolVariable5
 380
 381 /////Input Methods/////
 382 //input "",""
 383 def input(String name, String type) {
 384         LinkedHashMap metaData = []
 385         metaData.put('name',name)
 386         metaData.put('type',type)
 387         input(metaData)
 388 }
 389
 390 //input "","",linkedHashMap
 391 def input(LinkedHashMap metaData, String name, String type) {
 392         metaData.put('name',name)
 393         metaData.put('type',type)
 394         input(metaData)
 395 }
 396
 397 //input "", "", linkedHashMap, Closure
 398 def input(LinkedHashMap metaData, String name, String type, Closure Input) {
 399         metaData.put('name',name)
 400         metaData.put('type',type)
 401         input(metaData)
 402         find(Input)
 403 }
 404
 405 //input linkedHashMap
 406 def input(LinkedHashMap metaData) {
 407         if (metaData.containsKey('title')) {
 408                 println metaData['title']
 409         }
 410         if (metaData.containsKey('options')) {
 411                 println "Options: "+metaData['options']
 412         }
 413         def contains = 0
 414         switch(metaData['type']) {
 415                 case "capability.lock":
 416                         globalObjects.eachLine { line ->
 417                                 if(line.contains("lockObject")){
 418                                         contains = 1
 419                             }
 420                         }
 421
 422                         if (contains == 0)
 423                                 globalObjects.append("@Field def lockObject = new Locks(sendEvent, 1, init)\n")
 424
 425                         if (lockObjects == 0) {
 426                                 lockObject0 = metaData['name']
 427                                 this[lockObject0] = new Locks({}, 1, true)
 428                         } else if (lockObjects == 1) {
 429                                 lockObject1 = metaData['name']
 430                                 this[lockObject1] = new Locks({}, 1, true)
 431                         } else if (lockObjects == 2) {
 432                                 lockObject2 = metaData['name']
 433                                 this[lockObject2] = new Locks({}, 1, true)
 434                         }
 435
 436                         lockObjects=lockObjects+1
 437
 438                         settings.put(metaData['name'], new Locks({}, 1, true))
 439
 440                         if (App == "App1") {
 441                                 extractedObjectsApp1.append("//Object for class lock!\n")
 442                                 extractedObjectsApp1.append("def "+metaData['name']+"\n")
 443                                 extractedObjectsConstructorApp1.append(metaData['name']+" = obj.lockObject\n")
 444                         } else {
 445                                 extractedObjectsApp2.append("//Object for class lock!\n")
 446                                 extractedObjectsApp2.append("def "+metaData['name']+"\n")
 447                                 extractedObjectsConstructorApp2.append(metaData['name']+" = obj.lockObject\n")
 448                         }
 449                         break
 450                 case "capability.alarm":
 451                         globalObjects.eachLine { line ->
 452                                 if(line.contains("alarmObject")){
 453                                         contains = 1
 454                                 }
 455                         }
 456
 457                         if (contains == 0)
 458                                 globalObjects.append("@Field def alarmObject = new Alarms(sendEvent, 1, init)\n")
 459
 460                         if (alarmObjects == 0) {
 461                                 alarmObject0 = metaData['name']
 462                                 this[alarmObject0] = new Alarms({}, 1, true)
 463                         } else if (alarmObjects == 1) {
 464                                 alarmObject1 = metaData['name']
 465                                 this[alarmObject1] = new Alarms({}, 1, true)
 466                         } else if (alarmObjects == 2) {
 467                                 alarmObject2 = metaData['name']
 468                                 this[alarmObject2] = new Alarms({}, 1, true)
 469                         }
 470
 471                         alarmObjects=alarmObjects+1
 472
 473                         settings.put(metaData['name'], new Alarms({}, 1, true))
 474
 475                         if (App == "App1") {
 476                                 extractedObjectsApp1.append("//Object for class alarm!\n")
 477                                 extractedObjectsApp1.append("def "+metaData['name']+"\n")
 478                                 extractedObjectsConstructorApp1.append(metaData['name']+" = obj.alarmObject\n")
 479                         } else {
 480                                 extractedObjectsApp2.append("//Object for class alarm!\n")
 481                                 extractedObjectsApp2.append("def "+metaData['name']+"\n")
 482                                 extractedObjectsConstructorApp2.append(metaData['name']+" = obj.alarmObject\n")
 483                         }
 484                         break
 485                 case "capability.button":
 486                         globalObjects.eachLine { line ->
 487                                 if(line.contains("buttonObject")){
 488                                         contains = 1
 489                                 }
 490                         }
 491
 492                         if (contains == 0)
 493                                 globalObjects.append("@Field def buttonObject = new Buttons(sendEvent, 1, init)\n")
 494
 495                         if (buttonObjects == 0) {
 496                                 buttonObject0 = metaData['name']
 497                                 this[buttonObject0] = new Buttons({}, 1, true)
 498                         } else if (buttonObjects == 1) {
 499                                 buttonObject1 = metaData['name']
 500                                 this[buttonObject1] = new Buttons({}, 1, true)
 501                         } else if (buttonObjects == 2) {
 502                                 buttonObject2 = metaData['name']
 503                                 this[buttonObject2] = new Buttons({}, 1, true)
 504                         }
 505
 506                         buttonObjects=buttonObjects+1
 507
 508                         settings.put(metaData['name'], new Buttons({}, 1, true))
 509
 510                         if (App == "App1") {
 511                                 extractedObjectsApp1.append("//Object for class Button!\n")
 512                                 extractedObjectsApp1.append("def "+metaData['name']+"\n")
 513                                 extractedObjectsConstructorApp1.append(metaData['name']+" = obj.buttonObject\n")
 514                         } else {
 515                                 extractedObjectsApp2.append("//Object for class Button!\n")
 516                                 extractedObjectsApp2.append("def "+metaData['name']+"\n")
 517                                 extractedObjectsConstructorApp2.append(metaData['name']+" = obj.buttonObject\n")
 518                         }
 519                         break
 520                 case "capability.battery":
 521                         globalObjects.eachLine { line ->
 522                                 if(line.contains("batteryObject")){
 523                                         contains = 1
 524                                 }
 525                         }
 526
 527                         if (contains == 0)
 528                                 globalObjects.append("@Field def batteryObject = new Batteries(sendEvent, 1, init)\n")
 529
 530                         if (batteryObjects == 0) {
 531                                 batteryObject0 = metaData['name']
 532                                 this[batteryObject0] = new Batteries({}, 1, true)
 533                         } else if (batteryObjects == 1) {
 534                                 batteryObject1 = metaData['name']
 535                                 this[batteryObject1] = new Batteries({}, 1, true)
 536                         } else if (batteryObjects == 2) {
 537                                 batteryObject2 = metaData['name']
 538                                 this[batteryObject2] = new Batteries({}, 1, true)
 539                         }
 540
 541                         batteryObjects=batteryObjects+1
 542
 543                         settings.put(metaData['name'], new Batteries({}, 1, true))
 544
 545                         if (App == "App1") {
 546                                 extractedObjectsApp1.append("//Object for class Battery!\n")
 547                                 extractedObjectsApp1.append("def "+metaData['name']+"\n")
 548                                 extractedObjectsConstructorApp1.append(metaData['name']+" = obj.batteryObject\n")
 549                         } else {
 550                                 extractedObjectsApp2.append("//Object for class Battery!\n")
 551                                 extractedObjectsApp2.append("def "+metaData['name']+"\n")
 552                                 extractedObjectsConstructorApp2.append(metaData['name']+" = obj.batteryObject\n")
 553                         }
 554                         break
 555                 case "capability.beacon":
 556                         globalObjects.eachLine { line ->
 557                                 if(line.contains("beaconSensorObject")){
 558                                         contains = 1
 559                                 }
 560                         }
 561
 562                         if (contains == 0)
 563                                 globalObjects.append("@Field def beaconSensorObject = new BeaconSensors(sendEvent, 1, init)\n")
 564
 565                         if (beaconSensorObjects == 0) {
 566                                 beaconSensorObject0 = metaData['name']
 567                                 this[beaconSensorObject0] = new BeaconSensors({}, 1, true)
 568                         } else if (beaconSensorObjects == 1) {
 569                                 beaconSensorObject1 = metaData['name']
 570                                 this[beaconSensorObject1] = new BeaconSensors({}, 1, true)
 571                         } else if (beaconSensorObjects == 2) {
 572                                 beaconSensorObject2 = metaData['name']
 573                                 this[beaconSensorObject2] = new BeaconSensors({}, 1, true)
 574                         }
 575
 576                         beaconSensorObjects=beaconSensorObjects+1
 577
 578                         settings.put(metaData['name'], new BeaconSensors({}, 1, true))
 579
 580                         if (App == "App1") {
 581                                 extractedObjectsApp1.append("//Object for class beacon sensor!\n")
 582                                 extractedObjectsApp1.append("def "+metaData['name']+"\n")
 583                                 extractedObjectsConstructorApp1.append(metaData['name']+" = obj.beaconSensorObject\n")
 584                         } else {
 585                                 extractedObjectsApp2.append("//Object for class beacon sensor!\n")
 586                                 extractedObjectsApp2.append("def "+metaData['name']+"\n")
 587                                 extractedObjectsConstructorApp2.append(metaData['name']+" = obj.beaconSensorObject\n")
 588                         }
 589                         break
 590                 case "capability.carbonMonoxideDetector":
 591                         globalObjects.eachLine { line ->
 592                                 if(line.contains("carbonMonoxideDetectorObject")){
 593                                         contains = 1
 594                                 }
 595                         }
 596
 597                         if (contains == 0)
 598                                 globalObjects.append("@Field def carbonMonoxideDetectorObject = new CarbonMonoxideDetectors(sendEvent, 1, init)\n")
 599
 600                         if (carbonMonoxideDetectorObjects == 0) {
 601                                 carbonMonoxideDetectorObject0 = metaData['name']
 602                                 this[carbonMonoxideDetectorObject0] = new CarbonMonoxideDetectors({}, 1, true)
 603                         } else if (carbonMonoxideDetectorObjects == 1) {
 604                                 carbonMonoxideDetectorObject1 = metaData['name']
 605                                 this[carbonMonoxideDetectorObject1] = new CarbonMonoxideDetectors({}, 1, true)
 606                         } else if (carbonMonoxideDetectorObjects == 2) {
 607                                 carbonMonoxideDetectorObject2 = metaData['name']
 608                                 this[carbonMonoxideDetectorObject2] = new CarbonMonoxideDetectors({}, 1, true)
 609                         }
 610
 611                         carbonMonoxideDetectorObjects=carbonMonoxideDetectorObjects+1
 612
 613                         settings.put(metaData['name'], new CarbonMonoxideDetectors({}, 1, true))
 614
 615                         if (App == "App1") {
 616                                 extractedObjectsApp1.append("//Object for class carbon monoxide detector!\n")
 617                                 extractedObjectsApp1.append("def "+metaData['name']+"\n")
 618                                 extractedObjectsConstructorApp1.append(metaData['name']+" = obj.carbonMonoxideDetectorObject\n")
 619                         } else {
 620                                 extractedObjectsApp2.append("//Object for class carbon monoxide detector!\n")
 621                                 extractedObjectsApp2.append("def "+metaData['name']+"\n")
 622                                 extractedObjectsConstructorApp2.append(metaData['name']+" = obj.carbonMonoxideDetectorObject\n")
 623                         }
 624                         break
 625                 case "capability.colorTemperature":
 626                         globalObjects.eachLine { line ->
 627                                 if(line.contains("colorTemperatureObject")){
 628                                         contains = 1
 629                                 }
 630                         }
 631
 632                         if (contains == 0)
 633                                 globalObjects.append("@Field def colorTemperatureObject = new ColorTemperatures(sendEvent, 1, init)\n")
 634
 635                         if (colorTemperatureObjects == 0) {
 636                                 colorTemperatureObject0 = metaData['name']
 637                                 this[colorTemperatureObject0] = new ColorTemperatures({}, 1, true)
 638                         } else if (colorTemperatureObjects == 1) {
 639                                 colorTemperatureObject1 = metaData['name']
 640                                 this[colorTemperatureObject1] = new ColorTemperatures({}, 1, true)
 641                         } else if (colorTemperatureObjects == 2) {
 642                                 colorTemperatureObject2 = metaData['name']
 643                                 this[colorTemperatureObject2] = new ColorTemperatures({}, 1, true)
 644                         }
 645
 646                         colorTemperatureObjects=colorTemperatureObjects+1
 647
 648                         settings.put(metaData['name'], new ColorTemperatures({}, 1, true))
 649
 650                         if (App == "App1") {
 651                                 extractedObjectsApp1.append("//Object for class color temperature!\n")
 652                                 extractedObjectsApp1.append("def "+metaData['name']+"\n")
 653                                 extractedObjectsConstructorApp1.append(metaData['name']+" = obj.colorTemperatureObject\n")
 654                         } else {
 655                                 extractedObjectsApp2.append("//Object for class color control!\n")
 656                                 extractedObjectsApp2.append("def "+metaData['name']+"\n")
 657                                 extractedObjectsConstructorApp2.append(metaData['name']+" = obj.colorTemperatureObject\n")
 658                         }
 659                         break
 660                 case "capability.colorControl":
 661                         globalObjects.eachLine { line ->
 662                                 if(line.contains("colorControlObject")){
 663                                         contains = 1
 664                                 }
 665                         }
 666
 667                         if (contains == 0)
 668                                 globalObjects.append("@Field def colorControlObject = new ColorControls(sendEvent, 1, init)\n")
 669
 670                         if (colorControlObjects == 0) {
 671                                 colorControlObject0 = metaData['name']
 672                                 this[colorControlObject0] = new ColorControls({}, 1, true)
 673                         } else if (colorControlObjects == 1) {
 674                                 colorControlObject1 = metaData['name']
 675                                 this[colorControlObject1] = new ColorControls({}, 1, true)
 676                         } else if (colorControlObjects == 2) {
 677                                 colorControlObject2 = metaData['name']
 678                                 this[colorControlObject2] = new ColorControls({}, 1, true)
 679                         }
 680
 681                         colorControlObjects=colorControlObjects+1
 682
 683                         settings.put(metaData['name'], new ColorControls({}, 1, true))
 684
 685                         if (App == "App1") {
 686                                 extractedObjectsApp1.append("//Object for class color control!\n")
 687                                 extractedObjectsApp1.append("def "+metaData['name']+"\n")
 688                                 extractedObjectsConstructorApp1.append(metaData['name']+" = obj.colorControlObject\n")
 689                         } else {
 690                                 extractedObjectsApp2.append("//Object for class color control!\n")
 691                                 extractedObjectsApp2.append("def "+metaData['name']+"\n")
 692                                 extractedObjectsConstructorApp2.append(metaData['name']+" = obj.colorControlObject\n")
 693                         }
 694                         break
 695                 case "capability.contactSensor":
 696                         globalObjects.eachLine { line ->
 697                                 if(line.contains("contactObject")){
 698                                         contains = 1
 699                                 }
 700                         }
 701
 702                         if (contains == 0)
 703                                 globalObjects.append("@Field def contactObject = new ContactSensors(sendEvent, 1, init)\n")
 704
 705                         if (contactObjects == 0) {
 706                                 contactObject0 = metaData['name']
 707                                 this[contactObject0] = new ContactSensors({}, 1, true)
 708                         } else if (contactObjects == 1) {
 709                                 contactObject1 = metaData['name']
 710                                 this[contactObject1] = new ContactSensors({}, 1, true)
 711                         } else if (contactObjects == 2) {
 712                                 contactObject2 = metaData['name']
 713                                 this[contactObject2] = new ContactSensors({}, 1, true)
 714                         }
 715
 716                         contactObjects=contactObjects+1
 717
 718                         settings.put(metaData['name'], new ContactSensors({}, 1, true))
 719
 720                         if (App == "App1") {
 721                                 extractedObjectsApp1.append("//Object for class contactSensor!\n")
 722                                 extractedObjectsApp1.append("def "+metaData['name']+"\n")
 723                                 extractedObjectsConstructorApp1.append(metaData['name']+" = obj.contactObject\n")
 724                         } else {
 725                                 extractedObjectsApp2.append("//Object for class contactSensor!\n")
 726                                 extractedObjectsApp2.append("def "+metaData['name']+"\n")
 727                                 extractedObjectsConstructorApp2.append(metaData['name']+" = obj.contactObject\n")
 728                         }
 729                         break
 730                 case "capability.threeAxis":
 731                         globalObjects.eachLine { line ->
 732                                 if(line.contains("threeAxisObject")){
 733                                         contains = 1
 734                                 }
 735                         }
 736
 737                         if (contains == 0)
 738                                 globalObjects.append("@Field def threeAxisObject = new ThreeAxises(sendEvent, 1, init)\n")
 739
 740                         if (threeAxisObjects == 0) {
 741                                 threeAxisObject0 = metaData['name']
 742                                 this[threeAxisObject0] = new ThreeAxises({}, 1, true)
 743                         } else if (threeAxisObjects == 1) {
 744                                 threeAxisObject1 = metaData['name']
 745                                 this[threeAxisObject1] = new ThreeAxises({}, 1, true)
 746                         } else if (threeAxisObjects == 2) {
 747                                 threeAxisObject2 = metaData['name']
 748                                 this[threeAxisObject2] = new ThreeAxises({}, 1, true)
 749                         }
 750
 751                         threeAxisObjects=threeAxisObjects+1
 752
 753                         settings.put(metaData['name'], new ThreeAxises({}, 1, true))
 754
 755                         if (App == "App1") {
 756                                 extractedObjectsApp1.append("//Object for class three axis!\n")
 757                                 extractedObjectsApp1.append("def "+metaData['name']+"\n")
 758                                 extractedObjectsConstructorApp1.append(metaData['name']+" = obj.threeAxisObject\n")
 759                         } else {
 760                                 extractedObjectsApp2.append("//Object for class three axis!\n")
 761                                 extractedObjectsApp2.append("def "+metaData['name']+"\n")
 762                                 extractedObjectsConstructorApp2.append(metaData['name']+" = obj.threeAxisObject\n")
 763                         }
 764                         break
 765                 case "capability.doorControl":
 766                         globalObjects.eachLine { line ->
 767                                 if(line.contains("doorControlObject")){
 768                                         contains = 1
 769                                 }
 770                         }
 771
 772                         if (contains == 0)
 773                                 globalObjects.append("@Field def doorControlObject = new DoorControls(sendEvent, 1, init)\n")
 774
 775                         if (doorControlObjects == 0) {
 776                                 doorControlObject0 = metaData['name']
 777                                 this[doorControlObject0] = new DoorControls({}, 1, true)
 778                         } else if (doorControlObjects == 1) {
 779                                 doorControlObject1 = metaData['name']
 780                                 this[doorControlObject1] = new DoorControls({}, 1, true)
 781                         } else if (doorControlObjects == 2) {
 782                                 doorControlObject2 = metaData['name']
 783                                 this[doorControlObject2] = new DoorControls({}, 1, true)
 784                         }
 785
 786                         doorControlObjects=doorControlObjects+1
 787
 788                         settings.put(metaData['name'], new DoorControls({}, 1, true))
 789
 790                         if (App == "App1") {
 791                                 extractedObjectsApp1.append("//Object for class door control!\n")
 792                                 extractedObjectsApp1.append("def "+metaData['name']+"\n")
 793                                 extractedObjectsConstructorApp1.append(metaData['name']+" = obj.doorControlObject\n")
 794                         } else {
 795                                 extractedObjectsApp2.append("//Object for class door control!\n")
 796                                 extractedObjectsApp2.append("def "+metaData['name']+"\n")
 797                                 extractedObjectsConstructorApp2.append(metaData['name']+" = obj.doorControlObject\n")
 798                         }
 799                         break
 800                 case "capability.energyMeter":
 801                         globalObjects.eachLine { line ->
 802                                 if(line.contains("energyMeterObject")){
 803                                         contains = 1
 804                                 }
 805                         }
 806
 807                         if (contains == 0)
 808                                 globalObjects.append("@Field def energyMeterObject = new EnergyMeters(sendEvent, 1, init)\n")
 809
 810                         if (energyMeterObjects == 0) {
 811                                 energyMeterObject0 = metaData['name']
 812                                 this[energyMeterObject0] = new EnergyMeters({}, 1, true)
 813                         } else if (energyMeterObjects == 1) {
 814                                 energyMeterObject1 = metaData['name']
 815                                 this[energyMeterObject1] = new EnergyMeters({}, 1, true)
 816                         } else if (energyMeterObjects == 2) {
 817                                 energyMeterObject2 = metaData['name']
 818                                 this[energyMeterObject2] = new EnergyMeters({}, 1, true)
 819                         }
 820
 821                         energyMeterObjects=energyMeterObjects+1
 822
 823                         settings.put(metaData['name'], new EnergyMeters({}, 1, true))
 824
 825                         if (App == "App1") {
 826                                 extractedObjectsApp1.append("//Object for class energy meter!\n")
 827                                 extractedObjectsApp1.append("def "+metaData['name']+"\n")
 828                                 extractedObjectsConstructorApp1.append(metaData['name']+" = obj.energyMeterObject\n")
 829                         } else {
 830                                 extractedObjectsApp2.append("//Object for class energy meter!\n")
 831                                 extractedObjectsApp2.append("def "+metaData['name']+"\n")
 832                                 extractedObjectsConstructorApp2.append(metaData['name']+" = obj.energyMeterObject\n")
 833                         }
 834                         break
 835                 case "capability.illuminanceMeasurement":
 836                         globalObjects.eachLine { line ->
 837                                 if(line.contains("illuminanceMeasurementObject")){
 838                                         contains = 1
 839                                 }
 840                         }
 841
 842                         if (contains == 0)
 843                                 globalObjects.append("@Field def illuminanceMeasurementObject = new IlluminanceMeasurements(sendEvent, 1, init)\n")
 844
 845                         if (illuminanceMeasurementObjects == 0) {
 846                                 illuminanceMeasurementObject0 = metaData['name']
 847                                 this[illuminanceMeasurementObject0] = new IlluminanceMeasurements({}, 1, true)
 848                         } else if (illuminanceMeasurementObjects == 1) {
 849                                 illuminanceMeasurementObject1 = metaData['name']
 850                                 this[illuminanceMeasurementObject1] = new IlluminanceMeasurements({}, 1, true)
 851                         } else if (illuminanceMeasurementObjects == 2) {
 852                                 illuminanceMeasurementObject2 = metaData['name']
 853                                 this[illuminanceMeasurementObject2] = new IlluminanceMeasurements({}, 1, true)
 854                         }
 855
 856                         illuminanceMeasurementObjects=illuminanceMeasurementObjects+1
 857
 858                         settings.put(metaData['name'], new IlluminanceMeasurements({}, 1, true))
 859
 860                         if (App == "App1") {
 861                                 extractedObjectsApp1.append("//Object for class illuminance measurement!\n")
 862                                 extractedObjectsApp1.append("def "+metaData['name']+"\n")
 863                                 extractedObjectsConstructorApp1.append(metaData['name']+" = obj.illuminanceMeasurementObject\n")
 864                         } else {
 865                                 extractedObjectsApp2.append("//Object for class illuminance measurement!\n")
 866                                 extractedObjectsApp2.append("def "+metaData['name']+"\n")
 867                                 extractedObjectsConstructorApp2.append(metaData['name']+" = obj.illuminanceMeasurementObject\n")
 868                         }
 869                         break
 870                 case "capability.accelerationSensor":
 871                         globalObjects.eachLine { line ->
 872                                 if(line.contains("accelerationSensorObject")){
 873                                         contains = 1
 874                                 }
 875                         }
 876
 877                         if (contains == 0)
 878                                 globalObjects.append("@Field def accelerationSensorObject = new AccelerationSensors(sendEvent, 1, init)\n")
 879
 880                         if (accelerationSensorObjects == 0) {
 881                                 accelerationSensorObject0 = metaData['name']
 882                                 this[accelerationSensorObject0] = new AccelerationSensors({}, 1, true)
 883                         } else if (accelerationSensorObjects == 1) {
 884                                 accelerationSensorObject1 = metaData['name']
 885                                 this[accelerationSensorObject1] = new AccelerationSensors({}, 1, true)
 886                         } else if (accelerationSensorObjects == 2) {
 887                                 accelerationSensorObject2 = metaData['name']
 888                                 this[accelerationSensorObject2] = new AccelerationSensors({}, 1, true)
 889                         }
 890
 891                         accelerationSensorObjects=accelerationSensorObjects+1
 892
 893                         settings.put(metaData['name'], new AccelerationSensors({}, 1, true))
 894
 895                         if (App == "App1") {
 896                                 extractedObjectsApp1.append("//Object for class Acceleration Sensor!\n")
 897                                 extractedObjectsApp1.append("def "+metaData['name']+"\n")
 898                                 extractedObjectsConstructorApp1.append(metaData['name']+" = obj.accelerationSensorObject\n")
 899                         } else {
 900                                 extractedObjectsApp2.append("//Object for class Acceleration Sensor!\n")
 901                                 extractedObjectsApp2.append("def "+metaData['name']+"\n")
 902                                 extractedObjectsConstructorApp2.append(metaData['name']+" = obj.accelerationSensorObject\n")
 903                         }
 904                         break
 905                 case "capability.momentary":
 906                         globalObjects.eachLine { line ->
 907                                 if(line.contains("momentoryObject")){
 908                                         contains = 1
 909                                 }
 910                         }
 911
 912                         if (contains == 0)
 913                                 globalObjects.append("@Field def momentaryObject = new Momentaries(sendEvent, 1)\n")
 914
 915                         if (momentaryObjects == 0) {
 916                                 momentaryObject0 = metaData['name']
 917                                 this[momentaryObject0] = new Momentaries({}, 1)
 918                         } else if (momentaryObjects == 1) {
 919                                 momentaryObject1 = metaData['name']
 920                                 this[momentaryObject1] = new Momentaries({}, 1)
 921                         } else if (momentaryObjects == 2) {
 922                                 momentaryObject2 = metaData['name']
 923                                 this[momentaryObject2] = new Momentaries({}, 1)
 924                         }
 925
 926                         momentaryObjects=momentaryObjects+1
 927
 928                         settings.put(metaData['name'], new Momentaries({}, 1))
 929
 930                         if (App == "App1") {
 931                                 extractedObjectsApp1.append("//Object for class momentory switch class!\n")
 932                                 extractedObjectsApp1.append("def "+metaData['name']+"\n")
 933                                 extractedObjectsConstructorApp1.append(metaData['name']+" = obj.momentaryObject\n")
 934                         } else {
 935                                 extractedObjectsApp2.append("//Object for class momentory Sensor!\n")
 936                                 extractedObjectsApp2.append("def "+metaData['name']+"\n")
 937                                 extractedObjectsConstructorApp2.append(metaData['name']+" = obj.momentaryObject\n")
 938                         }
 939                         break
 940                 case "capability.motionSensor":
 941                         globalObjects.eachLine { line ->
 942                                 if(line.contains("motionSensorObject")){
 943                                         contains = 1
 944                                 }
 945                         }
 946
 947                         if (contains == 0)
 948                                 globalObjects.append("@Field def motionSensorObject = new MotionSensors(sendEvent, 1, init)\n")
 949
 950                         if (motionSensorObjects == 0) {
 951                                 motionSensorObject0 = metaData['name']
 952                                 this[motionSensorObject0] = new MotionSensors({}, 1, true)
 953                         } else if (motionSensorObjects == 1) {
 954                                 motionSensorObject1 = metaData['name']
 955                                 this[motionSensorObject1] = new MotionSensors({}, 1, true)
 956                         } else if (motionSensorObjects == 2) {
 957                                 motionSensorObject2 = metaData['name']
 958                                 this[motionSensorObject2] = new MotionSensors({}, 1, true)
 959                         }
 960
 961                         motionSensorObjects=motionSensorObjects+1
 962
 963                         settings.put(metaData['name'], new MotionSensors({}, 1, true))
 964
 965                         if (App == "App1") {
 966                                 extractedObjectsApp1.append("//Object for class Motion Sensor!\n")
 967                                 extractedObjectsApp1.append("def "+metaData['name']+"\n")
 968                                 extractedObjectsConstructorApp1.append(metaData['name']+" = obj.motionSensorObject\n")
 969                         } else {
 970                                 extractedObjectsApp2.append("//Object for class Motion Sensor!\n")
 971                                 extractedObjectsApp2.append("def "+metaData['name']+"\n")
 972                                 extractedObjectsConstructorApp2.append(metaData['name']+" = obj.motionSensorObject\n")
 973                         }
 974                         break
 975                 case "capability.musicPlayer":
 976                         globalObjects.eachLine { line ->
 977                                 if(line.contains("musicPlayerObject")){
 978                                         contains = 1
 979                                 }
 980                         }
 981
 982                         if (contains == 0)
 983                                 globalObjects.append("@Field def musicPlayerObject = new MusicPlayers(sendEvent, 1, init)\n")
 984
 985                         if (musicPlayerObjects == 0) {
 986                                 musicPlayerObject0 = metaData['name']
 987                                 this[musicPlayerObject0] = new MusicPlayers({}, 1, true)
 988                         } else if (musicPlayerObjects == 1) {
 989                                 musicPlayerObject1 = metaData['name']
 990                                 this[musicPlayerObject1] = new MusicPlayers({}, 1, true)
 991                         } else if (musicPlayerObjects == 2) {
 992                                 musicPlayerObject2 = metaData['name']
 993                                 this[musicPlayerObject2] = new MusicPlayers({}, 1, true)
 994                         }
 995
 996                         musicPlayerObjects=musicPlayerObjects+1
 997
 998                         settings.put(metaData['name'], new MusicPlayers({}, 1, true))
 999
1000                         if (App == "App1") {
1001                                 extractedObjectsApp1.append("//Object for class music player!\n")
1002                                 extractedObjectsApp1.append("def "+metaData['name']+"\n")
1003                                 extractedObjectsConstructorApp1.append(metaData['name']+" = obj.musicPlayerObject\n")
1004                         } else {
1005                                 extractedObjectsApp2.append("//Object for class music player!\n")
1006                                 extractedObjectsApp2.append("def "+metaData['name']+"\n")
1007                                 extractedObjectsConstructorApp2.append(metaData['name']+" = obj.musicPlayerObject\n")
1008                         }
1009                         break
1010                 case "capability.powerMeter":
1011                         globalObjects.eachLine { line ->
1012                                 if(line.contains("powerMeterObject")){
1013                                         contains = 1
1014                                 }
1015                         }
1016
1017                         if (contains == 0)
1018                                 globalObjects.append("@Field def powerMeterObject = new PowerMeters(sendEvent, 1, init)\n")
1019
1020                         if (powerMeterObjects == 0) {
1021                                 powerMeterObject0 = metaData['name']
1022                                 this[powerMeterObject0] = new PowerMeters({}, 1, true)
1023                         } else if (powerMeterObjects == 1) {
1024                                 powerMeterObject1 = metaData['name']
1025                                 this[powerMeterObject1] = new PowerMeters({}, 1, true)
1026                         } else if (powerMeterObjects == 2) {
1027                                 powerMeterObject2 = metaData['name']
1028                                 this[powerMeterObject2] = new PowerMeters({}, 1, true)
1029                         }
1030
1031                         powerMeterObjects=powerMeterObjects+1
1032
1033                         settings.put(metaData['name'], new PowerMeters({}, 1, true))
1034
1035                         if (App == "App1") {
1036                                 extractedObjectsApp1.append("//Object for class power meter!\n")
1037                                 extractedObjectsApp1.append("def "+metaData['name']+"\n")
1038                                 extractedObjectsConstructorApp1.append(metaData['name']+" = obj.powerMeterObject\n")
1039                         } else {
1040                                 extractedObjectsApp2.append("//Object for class power meter!\n")
1041                                 extractedObjectsApp2.append("def "+metaData['name']+"\n")
1042                                 extractedObjectsConstructorApp2.append(metaData['name']+" = obj.powerMeterObject\n")
1043                         }
1044                         break
1045                 case "capability.presenceSensor":
1046                         globalObjects.eachLine { line ->
1047                                 if(line.contains("presenceSensorObject")){
1048                                         contains = 1
1049                                 }
1050                         }
1051
1052                         if (contains == 0)
1053                                 globalObjects.append("@Field def presenceSensorObject = new PresenceSensors(sendEvent, 1, init)\n")
1054
1055                         if (presenceSensorObjects == 0) {
1056                                 presenceSensorObject0 = metaData['name']
1057                                 this[presenceSensorObject0] = new PresenceSensors({}, 1, true)
1058                         } else if (presenceSensorObjects == 1) {
1059                                 presenceSensorObject1 = metaData['name']
1060                                 this[presenceSensorObject1] = new PresenceSensors({}, 1, true)
1061                         } else if (presenceSensorObjects == 2) {
1062                                 presenceSensorObject2 = metaData['name']
1063                                 this[presenceSensorObject2] = new PresenceSensors({}, 1, true)
1064                         }
1065
1066                         presenceSensorObjects=presenceSensorObjects+1
1067
1068                         settings.put(metaData['name'], new PresenceSensors({}, 1, true))
1069
1070                         if (App == "App1") {
1071                                 extractedObjectsApp1.append("//Object for class presence sensor!\n")
1072                                 extractedObjectsApp1.append("def "+metaData['name']+"\n")
1073                                 extractedObjectsConstructorApp1.append(metaData['name']+" = obj.presenceSensorObject\n")
1074                         } else {
1075                                 extractedObjectsApp2.append("//Object for class presence sensor!\n")
1076                                 extractedObjectsApp2.append("def "+metaData['name']+"\n")
1077                                 extractedObjectsConstructorApp2.append(metaData['name']+" = obj.presenceSensorObject\n")
1078                         }
1079                         break
1080                 case "capability.relativeHumidityMeasurement":
1081                         globalObjects.eachLine { line ->
1082                                 if(line.contains("humidityMeasurementObject")){
1083                                         contains = 1
1084                                 }
1085                         }
1086
1087                         if (contains == 0)
1088                                 globalObjects.append("@Field def humidityMeasurementObject = new RelativeHumidityMeasurements(sendEvent, 1, init)\n")
1089
1090                         if (humidityMeasurementObjects == 0) {
1091                                 humidityMeasurementObject0 = metaData['name']
1092                                 this[humidityMeasurementObject0] = new RelativeHumidityMeasurements({}, 1, true)
1093                         } else if (humidityMeasurementObjects == 1) {
1094                                 humidityMeasurementObject1 = metaData['name']
1095                                 this[humidityMeasurementObject1] = new RelativeHumidityMeasurements({}, 1, true)
1096                         } else if (humidityMeasurementObjects == 2) {
1097                                 humidityMeasurementObject2 = metaData['name']
1098                                 this[humidityMeasurementObject2] = new RelativeHumidityMeasurements({}, 1, true)
1099                         }
1100
1101                         humidityMeasurementObjects=humidityMeasurementObjects+1
1102
1103                         settings.put(metaData['name'], new RelativeHumidityMeasurements({}, 1, true))
1104
1105                         if (App == "App1") {
1106                                 extractedObjectsApp1.append("//Object for class humidity measurement!\n")
1107                                 extractedObjectsApp1.append("def "+metaData['name']+"\n")
1108                                 extractedObjectsConstructorApp1.append(metaData['name']+" = obj.humidityMeasurementObject\n")
1109                         } else {
1110                                 extractedObjectsApp2.append("//Object for class humidity measurement!\n")
1111                                 extractedObjectsApp2.append("def "+metaData['name']+"\n")
1112                                 extractedObjectsConstructorApp2.append(metaData['name']+" = obj.humidityMeasurementObject\n")
1113                         }
1114                         break
1115                 case "capability.relaySwitch":
1116                         globalObjects.eachLine { line ->
1117                                 if(line.contains("relaySwitchObject")){
1118                                         contains = 1
1119                                 }
1120                         }
1121
1122                         if (contains == 0)
1123                                 globalObjects.append("@Field def relaySwitchObject = new RelaySwitches(sendEvent, 1, init)\n")
1124
1125                         if (relaySwitchObjects == 0) {
1126                                 relaySwitchObject0 = metaData['name']
1127                                 this[relaySwitchObject0] = new RelaySwitches({}, 1, true)
1128                         } else if (relaySwitchObjects == 1) {
1129                                 relaySwitchObject1 = metaData['name']
1130                                 this[relaySwitchObject1] = new RelaySwitches({}, 1, true)
1131                         } else if (relaySwitchObjects == 2) {
1132                                 relaySwitchObject2 = metaData['name']
1133                                 this[relaySwitchObject2] = new RelaySwitches({}, 1, true)
1134                         }
1135
1136                         relaySwitchObjects=relaySwitchObjects+1
1137
1138                         settings.put(metaData['name'], new RelaySwitches({}, 1, true))
1139
1140                         if (App == "App1") {
1141                                 extractedObjectsApp1.append("//Object for class relay switch!\n")
1142                                 extractedObjectsApp1.append("def "+metaData['name']+"\n")
1143                                 extractedObjectsConstructorApp1.append(metaData['name']+" = obj.relaySwitchObject\n")
1144                         } else {
1145                                 extractedObjectsApp2.append("//Object for class relay switch!\n")
1146                                 extractedObjectsApp2.append("def "+metaData['name']+"\n")
1147                                 extractedObjectsConstructorApp2.append(metaData['name']+" = obj.relaySwitchObject\n")
1148                         }
1149                         break
1150                 case "capability.sleepSensor":
1151                         globalObjects.eachLine { line ->
1152                                 if(line.contains("sleepSensorObject")){
1153                                         contains = 1
1154                                 }
1155                         }
1156
1157                         if (contains == 0)
1158                                 globalObjects.append("@Field def sleepSensorObject = new SleepSensors(sendEvent, 1, init)\n")
1159
1160                         if (sleepSensorObjects == 0) {
1161                                 sleepSensorObject0 = metaData['name']
1162                                 this[sleepSensorObject0] = new SleepSensors({}, 1, true)
1163                         } else if (sleepSensorObjects == 1) {
1164                                 sleepSensorObject1 = metaData['name']
1165                                 this[sleepSensorObject1] = new SleepSensors({}, 1, true)
1166                         } else if (sleepSensorObjects == 2) {
1167                                 sleepSensorObject2 = metaData['name']
1168                                 this[sleepSensorObject2] = new SleepSensors({}, 1, true)
1169                         }
1170
1171                         sleepSensorObjects=sleepSensorObjects+1
1172
1173                         settings.put(metaData['name'], new SleepSensors({}, 1, true))
1174
1175                         if (App == "App1") {
1176                                 extractedObjectsApp1.append("//Object for class sleep sensor!\n")
1177                                 extractedObjectsApp1.append("def "+metaData['name']+"\n")
1178                                 extractedObjectsConstructorApp1.append(metaData['name']+" = obj.sleepSensorObject\n")
1179                         } else {
1180                                 extractedObjectsApp2.append("//Object for class sleep sensor!\n")
1181                                 extractedObjectsApp2.append("def "+metaData['name']+"\n")
1182                                 extractedObjectsConstructorApp2.append(metaData['name']+" = obj.sleepSensorObject\n")
1183                         }
1184                         break
1185                 case "capability.smokeDetector":
1186                         globalObjects.eachLine { line ->
1187                                 if(line.contains("smokeDetectorObject")){
1188                                         contains = 1
1189                                 }
1190                         }
1191
1192                         if (contains == 0)
1193                                 globalObjects.append("@Field def smokeDetectorObject = new SmokeDetectors(sendEvent, 1, init)\n")
1194
1195                         if (smokeDetectorObjects == 0) {
1196                                 smokeDetectorObject0 = metaData['name']
1197                                 this[smokeDetectorObject0] = new SmokeDetectors({}, 1, true)
1198                         } else if (smokeDetectorObjects == 1) {
1199                                 smokeDetectorObject1 = metaData['name']
1200                                 this[smokeDetectorObject1] = new SmokeDetectors({}, 1, true)
1201                         } else if (smokeDetectorObjects == 2) {
1202                                 smokeDetectorObject2 = metaData['name']
1203                                 this[smokeDetectorObject2] = new SmokeDetectors({}, 1, true)
1204                         }
1205
1206                         smokeDetectorObjects=smokeDetectorObjects+1
1207
1208                         settings.put(metaData['name'], new SmokeDetectors({}, 1, true))
1209
1210                         if (App == "App1") {
1211                                 extractedObjectsApp1.append("//Object for class smoke detector!\n")
1212                                 extractedObjectsApp1.append("def "+metaData['name']+"\n")
1213                                 extractedObjectsConstructorApp1.append(metaData['name']+" = obj.smokeDetectorObject\n")
1214                         } else {
1215                                 extractedObjectsApp2.append("//Object for class smoke detector!\n")
1216                                 extractedObjectsApp2.append("def "+metaData['name']+"\n")
1217                                 extractedObjectsConstructorApp2.append(metaData['name']+" = obj.smokeDetectorObject\n")
1218                         }
1219                         break
1220                 case "capability.stepSensor":
1221                         globalObjects.eachLine { line ->
1222                                 if(line.contains("stepSensorObject")){
1223                                         contains = 1
1224                                 }
1225                         }
1226
1227                         if (contains == 0)
1228                                 globalObjects.append("@Field def stepSensorObject = new StepSensors(sendEvent, 1, init)\n")
1229
1230                         if (stepSensorObjects == 0) {
1231                                 stepSensorObject0 = metaData['name']
1232                                 this[stepSensorObject0] = new StepSensors({}, 1, true)
1233                         } else if (stepSensorObjects == 1) {
1234                                 stepSensorObject1 = metaData['name']
1235                                 this[stepSensorObject1] = new StepSensors({}, 1, true)
1236                         } else if (stepSensorObjects == 2) {
1237                                 stepSensorObject2 = metaData['name']
1238                                 this[stepSensorObject2] = new StepSensors({}, 1, true)
1239                         }
1240
1241                         stepSensorObjects=stepSensorObjects+1
1242
1243                         settings.put(metaData['name'], new StepSensors({}, 1, true))
1244
1245                         if (App == "App1") {
1246                                 extractedObjectsApp1.append("//Object for class step sensor!\n")
1247                                 extractedObjectsApp1.append("def "+metaData['name']+"\n")
1248                                 extractedObjectsConstructorApp1.append(metaData['name']+" = obj.stepSensorObject\n")
1249                         } else {
1250                                 extractedObjectsApp2.append("//Object for class step sensor!\n")
1251                                 extractedObjectsApp2.append("def "+metaData['name']+"\n")
1252                                 extractedObjectsConstructorApp2.append(metaData['name']+" = obj.stepSensorObject\n")
1253                         }
1254                         break
1255                 case "capability.switch":
1256                         globalObjects.eachLine { line ->
1257                                 if(line.contains("switchObject")){
1258                                         contains = 1
1259                                 }
1260                         }
1261
1262                         if (contains == 0)
1263                                 globalObjects.append("@Field def switchObject = new Switches(sendEvent, 1, init)\n")
1264
1265                         if (switchObjects == 0) {
1266                                 switchObject0 = metaData['name']
1267                                 this[switchObject0] = new Switches({}, 1, true)
1268                         } else if (switchObjects == 1) {
1269                                 switchObject1 = metaData['name']
1270                                 this[switchObject1] = new Switches({}, 1, true)
1271                         } else if (switchObjects == 2) {
1272                                 switchObject2 = metaData['name']
1273                                 this[switchObject2] = new Switches({}, 1, true)
1274                         }
1275
1276                         switchObjects=switchObjects+1
1277
1278                         settings.put(metaData['name'], new Switches({}, 1, true))
1279
1280                         if (App == "App1") {
1281                                 extractedObjectsApp1.append("//Object for class switch!\n")
1282                                 extractedObjectsApp1.append("def "+metaData['name']+"\n")
1283                                 extractedObjectsConstructorApp1.append(metaData['name']+" = obj.switchObject\n")
1284                         } else {
1285                                 extractedObjectsApp2.append("//Object for class switch!\n")
1286                                 extractedObjectsApp2.append("def "+metaData['name']+"\n")
1287                                 extractedObjectsConstructorApp2.append(metaData['name']+" = obj.switchObject\n")
1288                         }
1289                         break
1290                 case "capability.switchLevel":
1291                         globalObjects.eachLine { line ->
1292                                 if(line.contains("switchLevelObject")){
1293                                         contains = 1
1294                                 }
1295                         }
1296
1297                         if (contains == 0)
1298                                 globalObjects.append("@Field def switchLevelObject = new SwitchLevels(sendEvent, 1, init)\n")
1299
1300                         if (switchLevelObjects == 0) {
1301                                 switchLevelObject0 = metaData['name']
1302                                 this[switchLevelObject0] = new SwitchLevels({}, 1, true)
1303                         } else if (switchLevelObjects == 1) {
1304                                 switchLevelObject1 = metaData['name']
1305                                 this[switchLevelObject1] = new SwitchLevels({}, 1, true)
1306                         } else if (switchLevelObjects == 2) {
1307                                 switchLevelObject2 = metaData['name']
1308                                 this[switchLevelObject2] = new SwitchLevels({}, 1, true)
1309                         }
1310
1311                         switchLevelObjects=switchLevelObjects+1
1312
1313                         settings.put(metaData['name'], new SwitchLevels({}, 1, true))
1314
1315                         if (App == "App1") {
1316                                 extractedObjectsApp1.append("//Object for class switch level!\n")
1317                                 extractedObjectsApp1.append("def "+metaData['name']+"\n")
1318                                 extractedObjectsConstructorApp1.append(metaData['name']+" = obj.switchLevelObject\n")
1319                         } else {
1320                                 extractedObjectsApp2.append("//Object for class switch level!\n")
1321                                 extractedObjectsApp2.append("def "+metaData['name']+"\n")
1322                                 extractedObjectsConstructorApp2.append(metaData['name']+" = obj.switchLevelObject\n")
1323                         }
1324                         break
1325                 case "capability.temperatureMeasurement":
1326                         globalObjects.eachLine { line ->
1327                                 if(line.contains("temperatureMeasurementObject")){
1328                                         contains = 1
1329                                 }
1330                         }
1331
1332                         if (contains == 0)
1333                                 globalObjects.append("@Field def temperatureMeasurementObject = new TemperatureMeasurements(sendEvent, 1, init)\n")
1334
1335                         if (temperatureMeasurementObjects == 0) {
1336                                 temperatureMeasurementObject0 = metaData['name']
1337                                 this[temperatureMeasurementObject0] = new TemperatureMeasurements({}, 1, true)
1338                         } else if (temperatureMeasurementObjects == 1) {
1339                                 temperatureMeasurementObject1 = metaData['name']
1340                                 this[temperatureMeasurementObject1] = new TemperatureMeasurements({}, 1, true)
1341                         } else if (temperatureMeasurementObjects == 2) {
1342                                 temperatureMeasurementObject2 = metaData['name']
1343                                 this[temperatureMeasurementObject2] = new TemperatureMeasurements({}, 1, true)
1344                         }
1345
1346                         temperatureMeasurementObjects=temperatureMeasurementObjects+1
1347
1348                         settings.put(metaData['name'], new TemperatureMeasurements({}, 1, true))
1349
1350                         if (App == "App1") {
1351                                 extractedObjectsApp1.append("//Object for class temperature measurement!\n")
1352                                 extractedObjectsApp1.append("def "+metaData['name']+"\n")
1353                                 extractedObjectsConstructorApp1.append(metaData['name']+" = obj.temperatureMeasurementObject\n")
1354                         } else {
1355                                 extractedObjectsApp2.append("//Object for class temperature measurement!\n")
1356                                 extractedObjectsApp2.append("def "+metaData['name']+"\n")
1357                                 extractedObjectsConstructorApp2.append(metaData['name']+" = obj.temperatureMeasurementObject\n")
1358                         }
1359                         break
1360                 case "capability.thermostat":
1361                         globalObjects.eachLine { line ->
1362                                 if(line.contains("thermostatObject")){
1363                                         contains = 1
1364                                 }
1365                         }
1366
1367                         if (contains == 0)
1368                                 globalObjects.append("@Field def thermostatObject = new Thermostats(sendEvent, 1, init)\n")
1369
1370                         if (thermostatObjects == 0) {
1371                                 thermostatObject0 = metaData['name']
1372                                 this[thermostatObject0] = new Thermostats({}, 1, true)
1373                         } else if (thermostatObjects == 1) {
1374                                 thermostatObject1 = metaData['name']
1375                                 this[thermostatObject1] = new Thermostats({}, 1, true)
1376                         } else if (thermostatObjects == 2) {
1377                                 thermostatObject2 = metaData['name']
1378                                 this[thermostatObject2] = new Thermostats({}, 1, true)
1379                         }
1380
1381                         thermostatObjects=thermostatObjects+1
1382
1383                         settings.put(metaData['name'], new Thermostats({}, 1, true))
1384
1385                         if (App == "App1") {
1386                                 extractedObjectsApp1.append("//Object for class thermostat!\n")
1387                                 extractedObjectsApp1.append("def "+metaData['name']+"\n")
1388                                 extractedObjectsConstructorApp1.append(metaData['name']+" = obj.thermostatObject\n")
1389                         } else {
1390                                 extractedObjectsApp2.append("//Object for class thermostat!\n")
1391                                 extractedObjectsApp2.append("def "+metaData['name']+"\n")
1392                                 extractedObjectsConstructorApp2.append(metaData['name']+" = obj.thermostatObject\n")
1393                         }
1394                         break
1395                 case "capability.valve":
1396                         globalObjects.eachLine { line ->
1397                                 if(line.contains("valveObject")){
1398                                         contains = 1
1399                                 }
1400                         }
1401
1402                         if (contains == 0)
1403                                 globalObjects.append("@Field def valveObject = new Valves(sendEvent, 1, init)\n")
1404
1405                         if (valveObjects == 0) {
1406                                 valveObject0 = metaData['name']
1407                                 this[valveObject0] = new Valves({}, 1, true)
1408                         } else if (valveObjects == 1) {
1409                                 valveObject1 = metaData['name']
1410                                 this[valveObject1] = new Valves({}, 1, true)
1411                         } else if (valveObjects == 2) {
1412                                 valveObject2 = metaData['name']
1413                                 this[valveObject2] = new Valves({}, 1, true)
1414                         }
1415
1416                         valveObjects=valveObjects+1
1417
1418                         settings.put(metaData['name'], new Valves({}, 1, true))
1419
1420                         if (App == "App1") {
1421                                 extractedObjectsApp1.append("//Object for class valve!\n")
1422                                 extractedObjectsApp1.append("def "+metaData['name']+"\n")
1423                                 extractedObjectsConstructorApp1.append(metaData['name']+" = obj.valveObject\n")
1424                         } else {
1425                                 extractedObjectsApp2.append("//Object for class valve!\n")
1426                                 extractedObjectsApp2.append("def "+metaData['name']+"\n")
1427                                 extractedObjectsConstructorApp2.append(metaData['name']+" = obj.valveObject\n")
1428                         }
1429                         break
1430                 case "capability.speechSynthesis":
1431                         globalObjects.eachLine { line ->
1432                                 if(line.contains("speechSynthesisObject")){
1433                                         contains = 1
1434                                 }
1435                         }
1436
1437                         if (contains == 0)
1438                                 globalObjects.append("@Field def speechSynthesisObject = new SpeechSynthesises(sendEvent, 1, init)\n")
1439
1440                         if (speechSynthesisObjects == 0) {
1441                                 speechSynthesisObject0 = metaData['name']
1442                                 this[speechSynthesisObject0] = new SpeechSynthesises({}, 1, true)
1443                         } else if (speechSynthesisObjects == 1) {
1444                                 speechSynthesisObject1 = metaData['name']
1445                                 this[speechSynthesisObject1] = new SpeechSynthesises({}, 1, true)
1446                         } else if (speechSynthesisObjects == 2) {
1447                                 speechSynthesisObject2 = metaData['name']
1448                                 this[speechSynthesisObject2] = new SpeechSynthesises({}, 1, true)
1449                         }
1450
1451                         speechSynthesisObjects=speechSynthesisObjects+1
1452
1453                         settings.put(metaData['name'], new SpeechSynthesises({}, 1, true))
1454
1455                         if (App == "App1") {
1456                                 extractedObjectsApp1.append("//Object for class speech synthesis!\n")
1457                                 extractedObjectsApp1.append("def "+metaData['name']+"\n")
1458                                 extractedObjectsConstructorApp1.append(metaData['name']+" = obj.speechSynthesisObject\n")
1459                         } else {
1460                                 extractedObjectsApp2.append("//Object for class speech synthesis!\n")
1461                                 extractedObjectsApp2.append("def "+metaData['name']+"\n")
1462                                 extractedObjectsConstructorApp2.append(metaData['name']+" = obj.speechSynthesisObject\n")
1463                         }
1464                         break
1465                 case "capability.waterSensor":
1466                         globalObjects.eachLine { line ->
1467                                 if(line.contains("waterSensorObject")){
1468                                         contains = 1
1469                                 }
1470                         }
1471
1472                         if (contains == 0)
1473                                 globalObjects.append("@Field def waterSensorObject = new WaterSensors(sendEvent, 1, init)\n")
1474
1475                         if (waterSensorObjects == 0) {
1476                                 waterSensorObject0 = metaData['name']
1477                                 this[waterSensorObject0] = new WaterSensors({}, 1, true)
1478                         } else if (waterSensorObjects == 1) {
1479                                 waterSensorObject1 = metaData['name']
1480                                 this[waterSensorObject1] = new WaterSensors({}, 1, true)
1481                         } else if (waterSensorObjects == 2) {
1482                                 waterSensorObject2 = metaData['name']
1483                                 this[waterSensorObject2] = new WaterSensors({}, 1, true)
1484                         }
1485
1486                         waterSensorObjects=waterSensorObjects+1
1487
1488                         settings.put(metaData['name'], new WaterSensors({}, 1, true))
1489
1490                         if (App == "App1") {
1491                                 extractedObjectsApp1.append("//Object for class water sensor!\n")
1492                                 extractedObjectsApp1.append("def "+metaData['name']+"\n")
1493                                 extractedObjectsConstructorApp1.append(metaData['name']+" = obj.waterSensorObject\n")
1494                         } else {
1495                                 extractedObjectsApp2.append("//Object for class water sensor!\n")
1496                                 extractedObjectsApp2.append("def "+metaData['name']+"\n")
1497                                 extractedObjectsConstructorApp2.append(metaData['name']+" = obj.waterSensorObject\n")
1498                         }
1499                         break
1500                 case "capability.touchSensor":
1501                         globalObjects.eachLine { line ->
1502                                 if(line.contains("touchSensorObject")){
1503                                         contains = 1
1504                                 }
1505                         }
1506
1507                         if (contains == 0)
1508                                 globalObjects.append("@Field def touchSensorObject = new NfcTouch(sendEvent, 1)\n")
1509
1510                         if (touchSensorObjects == 0) {
1511                                 touchSensorObject0 = metaData['name']
1512                                 this[touchSensorObject0] = new NfcTouch({}, 1)
1513                         } else if (touchSensorObjects == 1) {
1514                                 touchSensorObject1 = metaData['name']
1515                                 this[touchSensorObject1] = new NfcTouch({}, 1)
1516                         } else if (touchSensorObjects == 2) {
1517                                 touchSensorObject2 = metaData['name']
1518                                 this[touchSensorObject2] = new NfcTouch({}, 1)
1519                         }
1520
1521                         touchSensorObjects=touchSensorObjects+1
1522
1523                         settings.put(metaData['name'], new NfcTouch({}, 1))
1524
1525                         if (App == "App1") {
1526                                 extractedObjectsApp1.append("//Object for class Touch Sensor!\n")
1527                                 extractedObjectsApp1.append("def "+metaData['name']+"\n")
1528                                 extractedObjectsConstructorApp1.append(metaData['name']+" = obj.touchSensorObject\n")
1529                         } else {
1530                                 extractedObjectsApp2.append("//Object for class Touch Sensor!\n")
1531                                 extractedObjectsApp2.append("def "+metaData['name']+"\n")
1532                                 extractedObjectsConstructorApp2.append(metaData['name']+" = obj.touchSensorObject\n")
1533                         }
1534                         break
1535                 case "capability.imageCapture":
1536                         globalObjects.eachLine { line ->
1537                                 if(line.contains("imageCaptureObject")){
1538                                         contains = 1
1539                                 }
1540                         }
1541
1542                         if (contains == 0)
1543                                 globalObjects.append("@Field def imageCaptureObject = new ImageCaptures(sendEvent, 1, init)\n")
1544
1545                         if (imageCaptureObjects == 0) {
1546                                 imageCaptureObject0 = metaData['name']
1547                                 this[imageCaptureObject0] = new ImageCaptures({}, 1, true)
1548                         } else if (imageCaptureObjects == 1) {
1549                                 imageCaptureObject1 = metaData['name']
1550                                 this[imageCaptureObject1] = new ImageCaptures({}, 1, true)
1551                         } else if (imageCaptureObjects == 2) {
1552                                 imageCaptureObject2 = metaData['name']
1553                                 this[imageCaptureObject2] = new ImageCaptures({}, 1, true)
1554                         }
1555
1556                         imageCaptureObjects=imageCaptureObjects+1
1557
1558                         settings.put(metaData['name'], new ImageCaptures({}, 1, true))
1559
1560                         if (App == "App1") {
1561                                 extractedObjectsApp1.append("//Object for class Image Capture!\n")
1562                                 extractedObjectsApp1.append("def "+metaData['name']+"\n")
1563                                 extractedObjectsConstructorApp1.append(metaData['name']+" = obj.imageCaptureObject\n")
1564                         } else {
1565                                 extractedObjectsApp2.append("//Object for class Image Capture!\n")
1566                                 extractedObjectsApp2.append("def "+metaData['name']+"\n")
1567                                 extractedObjectsConstructorApp2.append(metaData['name']+" = obj.imageCaptureObject\n")
1568                         }
1569                         break
1570                 case "device.mobilePresence":
1571                         globalObjects.eachLine { line ->
1572                                 if(line.contains("mobilePresenceObject")){
1573                                         contains = 1
1574                                 }
1575                         }
1576
1577                         if (contains == 0)
1578                                 globalObjects.append("@Field def mobilePresenceObject = new MobilePresences(sendEvent, 1)\n")
1579
1580                         if (mobilePresenceObjects == 0) {
1581                                 mobilePresenceObject0 = metaData['name']
1582                                 this[mobilePresenceObject0] = new MobilePresences({}, 1)
1583                         } else if (mobilePresenceObjects == 1) {
1584                                 mobilePresenceObject1 = metaData['name']
1585                                 this[mobilePresenceObject1] = new MobilePresences({}, 1)
1586                         } else if (mobilePresenceObjects == 2) {
1587                                 mobilePresenceObject2 = metaData['name']
1588                                 this[mobilePresenceObject2] = new MobilePresences({}, 1)
1589                         }
1590
1591                         mobilePresenceObjects=mobilePresenceObjects+1
1592
1593                         settings.put(metaData['name'], new MobilePresences({}, 1))
1594
1595                         if (App == "App1") {
1596                                 extractedObjectsApp1.append("//Object for class mobile presence!\n")
1597                                 extractedObjectsApp1.append("def "+metaData['name']+"\n")
1598                                 extractedObjectsConstructorApp1.append(metaData['name']+" = obj.mobilePresenceObject\n")
1599                         } else {
1600                                 extractedObjectsApp2.append("//Object for class mobile presence!\n")
1601                                 extractedObjectsApp2.append("def "+metaData['name']+"\n")
1602                                 extractedObjectsConstructorApp2.append(metaData['name']+" = obj.mobilePresenceObject\n")
1603                         }
1604                         break
1605                 case "device.aeonKeyFob":
1606                         globalObjects.eachLine { line ->
1607                                 if(line.contains("aeonKeyFobObject")){
1608                                         contains = 1
1609                                 }
1610                         }
1611                         if (contains == 0)
1612                                 globalObjects.append("@Field def aeonKeyFobObject = new AeonKeyFobs(sendEvent, 1)\n")
1613
1614                         if (aeonKeyFobObjects == 0) {
1615                                 aeonKeyFobObject0 = metaData['name']
1616                                 this[aeonKeyFobObject0] = new AeonKeyFobs({}, 1)
1617                         } else if (aeonKeyFobObjects == 1) {
1618                                 aeonKeyFobObject1 = metaData['name']
1619                                 this[aeonKeyFobObject1] = new AeonKeyFobs({}, 1)
1620                         } else if (aeonKeyFobObjects == 2) {
1621                                 aeonKeyFobObject2 = metaData['name']
1622                                 this[aeonKeyFobObject2] = new AeonKeyFobs({}, 1)
1623                         }
1624
1625                         aeonKeyFobObjects=aeonKeyFobObjects+1
1626
1627                         settings.put(metaData['name'], new AeonKeyFobs({}, 1))
1628
1629                         if (App == "App1") {
1630                                 extractedObjectsApp1.append("//Object for class aeon key fob!\n")
1631                                 extractedObjectsApp1.append("def "+metaData['name']+"\n")
1632                                 extractedObjectsConstructorApp1.append(metaData['name']+" = obj.aeonKeyFobObject\n")
1633                         } else {
1634                                 extractedObjectsApp2.append("//Object for class aeon key fob!\n")
1635                                 extractedObjectsApp2.append("def "+metaData['name']+"\n")
1636                                 extractedObjectsConstructorApp2.append(metaData['name']+" = obj.aeonKeyFobObject\n")
1637                         }
1638                         break
1639                 case "mode":
1640                         //def randomVariable = Math.abs(new Random().nextInt() % 3)
1641                         def modes = ["away", "home", "night"]
1642                         def userInput = modes[1]
1643
1644                         if (modeVariables == 0) {
1645                                 mode0 = metaData['name']
1646                                 this[mode0] = userInput
1647                         } else if (modeVariables == 1) {
1648                                 mode1 = metaData['name']
1649                                 this[mode1] = userInput
1650                         } else if (modeVariables == 2) {
1651                                 mode2 = metaData['name']
1652                                 this[mode2] = userInput
1653                         } else if (modeVariables == 3) {
1654                                 mode3 = metaData['name']
1655                                 this[mode3] = userInput
1656                         } else if (modeVariables == 4) {
1657                                 mode4 = metaData['name']
1658                                 this[mode4] = userInput
1659                         } else if (modeVariables == 5) {
1660                                 mode5 = metaData['name']
1661                                 this[mode5] = userInput
1662                         }
1663
1664                         if (modeVariables != 5)
1665                                 modeVariables=modeVariables+1
1666                         else
1667                                 modeVariables=0
1668
1669
1670                         settings.put(metaData['name'], metaData['name'])
1671
1672                         if (App == "App1") {
1673                                 extractedObjectsApp1.append("//Global variable for mode!\n")
1674                                 extractedObjectsApp1.append("def "+metaData['name']+" = \""+userInput+"\"\n")
1675                         } else {
1676                                 extractedObjectsApp2.append("//Global variable for mode!\n")
1677                                 extractedObjectsApp2.append("def "+metaData['name']+" = \""+userInput+"\"\n")
1678                         }
1679                         break
1680                 case "decimal":
1681                         //def userInput = Math.abs(new Random().nextInt() % 60) + 40
1682                         def userInput = 50
1683
1684                         if (decimalVariables == 0) {
1685                                 decimal0 = metaData['name']
1686                                 this[decimal0] = userInput
1687                         } else if (decimalVariables == 1) {
1688                                 decimal1 = metaData['name']
1689                                 this[decimal1] = userInput
1690                         } else if (decimalVariables == 2) {
1691                                 decimal2 = metaData['name']
1692                                 this[decimal2] = userInput
1693                         } else if (decimalVariables == 3) {
1694                                 decimal3 = metaData['name']
1695                                 this[decimal3] = userInput
1696                         } else if (decimalVariables == 4) {
1697                                 decimal4 = metaData['name']
1698                                 this[decimal4] = userInput
1699                         } else if (decimalVariables == 5) {
1700                                 decimal5 = metaData['name']
1701                                 this[decimal5] = userInput
1702                         }
1703
1704                         if (decimalVariables != 5)
1705                                 decimalVariables=decimalVariables+1
1706                         else
1707                                 decimalVariables=0
1708
1709                         settings.put(metaData['name'], metaData['name'])
1710
1711                         if (App == "App1") {
1712                                 extractedObjectsApp1.append("//Global variable for decimal number!\n")
1713                                 extractedObjectsApp1.append("def "+metaData['name']+" = "+userInput+"\n")
1714                         } else {
1715                                 extractedObjectsApp2.append("//Global variable for decimal number!\n")
1716                                 extractedObjectsApp2.append("def "+metaData['name']+" = "+userInput+"\n")
1717                         }
1718                         break
1719                 case "text":
1720                         def userInput = "This is just a text!"
1721
1722                         if (textVariables == 0) {
1723                                 text0 = metaData['name']
1724                                 this[text0] = userInput
1725                         } else if (textVariables == 1) {
1726                                 text1 = metaData['name']
1727                                 this[text1] = userInput
1728                         } else if (textVariables == 2) {
1729                                 text2 = metaData['name']
1730                                 this[text2] = userInput
1731                         } else if (textVariables == 3) {
1732                                 text3 = metaData['name']
1733                                 this[text3] = userInput
1734                         } else if (textVariables == 4) {
1735                                 text4 = metaData['name']
1736                                 this[text4] = userInput
1737                         } else if (textVariables == 5) {
1738                                 text5 = metaData['name']
1739                                 this[text5] = userInput
1740                         }
1741
1742                         if (textVariables != 5)
1743                                 textVariables=textVariables+1
1744                         else
1745                                 textVariables=0
1746
1747
1748                         settings.put(metaData['name'], metaData['name'])
1749
1750                         if (App == "App1") {
1751                                 extractedObjectsApp1.append("//Global variable for text!\n")
1752                                 extractedObjectsApp1.append("def "+metaData['name']+" = \""+userInput+"\"\n")
1753                         } else {
1754                                 extractedObjectsApp2.append("//Global variable for text!\n")
1755                                 extractedObjectsApp2.append("def "+metaData['name']+" = \""+userInput+"\"\n")
1756                         }
1757                         break
1758                 case "number":
1759                         //def userInput = Math.abs(new Random().nextInt() % 60) + 40
1760                         def userInput = 50
1761
1762                         if (numberVariables == 0) {
1763                                 number0 = metaData['name']
1764                                 this[number0] = userInput
1765                         } else if (numberVariables == 1) {
1766                                 number1 = metaData['name']
1767                                 this[number1] = userInput
1768                         } else if (numberVariables == 2) {
1769                                 number2 = metaData['name']
1770                                 this[number2] = userInput
1771                         } else if (numberVariables == 3) {
1772                                 number3 = metaData['name']
1773                                 this[number3] = userInput
1774                         } else if (numberVariables == 4) {
1775                                 number4 = metaData['name']
1776                                 this[number4] = userInput
1777                         } else if (numberVariables == 5) {
1778                                 number5 = metaData['name']
1779                                 this[number5] = userInput
1780                         }
1781
1782
1783                         if (numberVariables != 5)
1784                                 numberVariables=numberVariables+1
1785                         else
1786                                 numberVariables=0
1787
1788
1789                         settings.put(metaData['name'], metaData['name'])
1790
1791                         if (App == "App1") {
1792                                 extractedObjectsApp1.append("//Global variable for number!\n")
1793                                 extractedObjectsApp1.append("def "+metaData['name']+" = "+userInput+"\n")
1794                         } else {
1795                                 extractedObjectsApp2.append("//Global variable for number!\n")
1796                                 extractedObjectsApp2.append("def "+metaData['name']+" = "+userInput+"\n")
1797                         }
1798                         break
1799                 case "time":
1800                         def userInput = "15:00"
1801
1802                         if (timeVariables == 0) {
1803                                 time0 = metaData['name']
1804                                 this[time0] = userInput
1805                         } else if (timeVariables == 1) {
1806                                 time1 = metaData['name']
1807                                 this[time1] = userInput
1808                         } else if (timeVariables == 2) {
1809                                 time2 = metaData['name']
1810                                 this[time2] = userInput
1811                         } else if (timeVariables == 3) {
1812                                 time3 = metaData['name']
1813                                 this[time3] = userInput
1814                         } else if (timeVariables == 4) {
1815                                 time4 = metaData['name']
1816                                 this[time4] = userInput
1817                         } else if (timeVariables == 5) {
1818                                 time5 = metaData['name']
1819                                 this[time5] = userInput
1820                         }
1821
1822                         if (timeVariables != 5)
1823                                 timeVariables=timeVariables+1
1824                         else
1825                                 timeVariables=0
1826
1827                         settings.put(metaData['name'], metaData['name'])
1828
1829                         if (App == "App1") {
1830                                 extractedObjectsApp1.append("//Global variable for time!\n")
1831                                 extractedObjectsApp1.append("def "+metaData['name']+" = \""+userInput+"\"\n")
1832                         } else {
1833                                 extractedObjectsApp2.append("//Global variable for time!\n")
1834                                 extractedObjectsApp2.append("def "+metaData['name']+" = \""+userInput+"\"\n")
1835                         }
1836                         break
1837                 case "enum":
1838                         if (metaData['options'] != null)
1839                                 modes = metaData['options']
1840                         else if (metaData['metadata'] != null) { // If it is not named 'options' then it is captured as 'metadata'
1841                                 modes = metaData['metadata']
1842                                 modes = modes['values']
1843                         }
1844                         def userInput = modes[0]
1845
1846                         if (enumVariables == 0) {
1847                                 enum0 = metaData['name']
1848                                 this[enum0] = userInput
1849                         } else if (enumVariables == 1) {
1850                                 enum1 = metaData['name']
1851                                 this[enum1] = userInput
1852                         } else if (enumVariables == 2) {
1853                                 enum2 = metaData['name']
1854                                 this[enum2] = userInput
1855                         } else if (enumVariables == 3) {
1856                                 enum3 = metaData['name']
1857                                 this[enum3] = userInput
1858                         } else if (enumVariables == 4) {
1859                                 enum4 = metaData['name']
1860                                 this[enum4] = userInput
1861                         } else if (enumVariables == 5) {
1862                                 enum5 = metaData['name']
1863                                 this[enum5] = userInput
1864                         }
1865
1866                         if (enumVariables != 5)
1867                                 enumVariables=enumVariables+1
1868                         else
1869                                 enumVariables=0
1870
1871
1872                         settings.put(metaData['name'], metaData['name'])
1873
1874                         if (App == "App1") {
1875                                 extractedObjectsApp1.append("//Global variable for enum!\n")
1876                                 extractedObjectsApp1.append("def "+metaData['name']+" = \""+userInput+"\"\n")
1877                         } else {
1878                                 extractedObjectsApp2.append("//Global variable for enum!\n")
1879                                 extractedObjectsApp2.append("def "+metaData['name']+" = \""+userInput+"\"\n")
1880                         }
1881                         break
1882                 case "boolean":
1883                         //def userInput = Math.abs(new Random().nextInt() % 2)
1884                         def userInput = true
1885
1886                         if (boolVariables == 0) {
1887                                 bool0 = metaData['name']
1888                                 this[bool0] = userInput
1889                         } else if (boolVariables == 1) {
1890                                 bool1 = metaData['name']
1891                                 this[bool1] = userInput
1892                         } else if (boolVariables == 2) {
1893                                 bool2 = metaData['name']
1894                                 this[bool2] = userInput
1895                         } else if (boolVariables == 3) {
1896                                 bool3 = metaData['name']
1897                                 this[bool3] = userInput
1898                         } else if (boolVariables == 4) {
1899                                 bool4 = metaData['name']
1900                                 this[bool4] = userInput
1901                         } else if (boolVariables == 5) {
1902                                 bool5 = metaData['name']
1903                                 this[bool5] = userInput
1904                         }
1905
1906                         if (boolVariables != 5)
1907                                 boolVariables=boolVariables+1
1908                         else
1909                                 boolVariables=0
1910
1911
1912                         settings.put(metaData['name'], metaData['name'])
1913
1914                         if (App == "App1") {
1915                                 extractedObjectsApp1.append("//Global variable for boolean!\n")
1916                                 extractedObjectsApp1.append("def "+metaData['name']+" = \""+userInput+"\"\n")
1917                         } else {
1918                                 extractedObjectsApp2.append("//Global variable for boolean!\n")
1919                                 extractedObjectsApp2.append("def "+metaData['name']+" = \""+userInput+"\"\n")
1920                         }
1921                         break
1922                 case "bool":
1923                         //def userInput = Math.abs(new Random().nextInt() % 2)
1924                         def userInput = true
1925
1926                         if (boolVariables == 0) {
1927                                 bool0 = metaData['name']
1928                                 this[bool0] = userInput
1929                         } else if (boolVariables == 1) {
1930                                 bool1 = metaData['name']
1931                                 this[bool1] = userInput
1932                         } else if (boolVariables == 2) {
1933                                 bool2 = metaData['name']
1934                                 this[bool2] = userInput
1935                         } else if (boolVariables == 3) {
1936                                 bool3 = metaData['name']
1937                                 this[bool3] = userInput
1938                         } else if (boolVariables == 4) {
1939                                 bool4 = metaData['name']
1940                                 this[bool4] = userInput
1941                         } else if (boolVariables == 5) {
1942                                 bool5 = metaData['name']
1943                                 this[bool5] = userInput
1944                         }
1945
1946                         if (boolVariables != 5)
1947                                 boolVariables=boolVariables+1
1948                         else
1949                                 boolVariables=0
1950
1951
1952                         settings.put(metaData['name'], metaData['name'])
1953
1954                         if (App == "App1") {
1955                                 extractedObjectsApp1.append("//Global variable for boolean!\n")
1956                                 extractedObjectsApp1.append("def "+metaData['name']+" = \""+userInput+"\"\n")
1957                         } else {
1958                                 extractedObjectsApp2.append("//Global variable for boolean!\n")
1959                                 extractedObjectsApp2.append("def "+metaData['name']+" = \""+userInput+"\"\n")
1960                         }
1961                         break
1962                 case "phone":
1963                         def userInput = 9495379373
1964
1965                         if (phoneVariables == 0) {
1966                                 phone0 = metaData['name']
1967                                 this[phone0] = userInput
1968                         } else if (phoneVariables == 1) {
1969                                 phone1 = metaData['name']
1970                                 this[phone1] = userInput
1971                         } else if (phoneVariables == 2) {
1972                                 phone2 = metaData['name']
1973                                 this[phone2] = userInput
1974                         } else if (phoneVariables == 3) {
1975                                 phone3 = metaData['name']
1976                                 this[phone3] = userInput
1977                         } else if (phoneVariables == 4) {
1978                                 phone4 = metaData['name']
1979                                 this[phone4] = userInput
1980                         } else if (phoneVariables == 5) {
1981                                 phone5 = metaData['name']
1982                                 this[phone5] = userInput
1983                         }
1984
1985                         if (phoneVariables != 5)
1986                                 phoneVariables=phoneVariables+1
1987                         else
1988                                 phoneVariables=0
1989
1990                         settings.put(metaData['name'], metaData['name'])
1991
1992                         if (App == "App1") {
1993                                 extractedObjectsApp1.append("//Global variable for phone!\n")
1994                                 extractedObjectsApp1.append("def "+metaData['name']+" = "+userInput+"\n")
1995                         } else {
1996                                 extractedObjectsApp2.append("//Global variable for phone!\n")
1997                                 extractedObjectsApp2.append("def "+metaData['name']+" = "+userInput+"\n")
1998                         }
1999                         break
2000                 case "contact":
2001                         def userInput = "AJ"
2002
2003                         if (contactVariables == 0) {
2004                                 contact0 = metaData['name']
2005                                 this[contact0] = userInput
2006                         } else if (contactVariables == 1) {
2007                                 contact1 = metaData['name']
2008                                 this[contact1] = userInput
2009                         } else if (contactVariables == 2) {
2010                                 contact2 = metaData['name']
2011                                 this[contact2] = userInput
2012                         } else if (contactVariables == 3) {
2013                                 contact3 = metaData['name']
2014                                 this[contact3] = userInput
2015                         } else if (contactVariables == 4) {
2016                                 contact4 = metaData['name']
2017                                 this[contact4] = userInput
2018                         } else if (contactVariables == 5) {
2019                                 contact5 = metaData['name']
2020                                 this[contact5] = userInput
2021                         }
2022
2023                         if (contactVariables != 5)
2024                                 contactVariables=contactVariables+1
2025                         else
2026                                 contactVariables=0
2027
2028                         settings.put(metaData['name'], metaData['name'])
2029
2030                         if (App == "App1") {
2031                                 extractedObjectsApp1.append("//Global variable for contact!\n")
2032                                 extractedObjectsApp1.append("def "+metaData['name']+" = \""+userInput+"\"\n")
2033                         } else {
2034                                 extractedObjectsApp2.append("//Global variable for contact!\n")
2035                                 extractedObjectsApp2.append("def "+metaData['name']+" = \""+userInput+"\"\n")
2036                         }
2037                         break
2038                 default:
2039                         break
2040         }
2041 }
2042
2043 def label(LinkedHashMap metaData) {
2044         if (metaData.containsKey('title')) {
2045                 println metaData['title']
2046         }
2047         if (metaData.containsKey('options')) {
2048                 println "Options: "+metaData['options']
2049         }
2050
2051         println("//IGNORE--ForMobileUse//")
2052 }
2053
2054 def mode(LinkedHashMap metaData) {
2055         if (metaData.containsKey('title')) {
2056                 println metaData['title']
2057         }
2058         if (metaData.containsKey('options')) {
2059                 println "Options: "+metaData['options']
2060         }
2061
2062         println("//IGNORE--ForMobileUse//")
2063 }
2064
2065 def href(LinkedHashMap metaData) {
2066         println("//IGNORE--some data//")
2067 }
2068
2069 def href(LinkedHashMap metaData, String name) {
2070         println("//IGNORE--some data//")
2071 }
2072 /////Input Methods/////
2073
2074
2075 /////MethodsForExtraction/////
2076 def definition(LinkedHashMap metaData) {
2077         println("///Just some information///")
2078 }
2079
2080 def preferences(Closure inputData) {
2081         find(inputData) //Run the closure to extract pages/sections/inputMethods
2082         settings.put("END", "END")
2083         if (App == "App1") {
2084                 extractedObjectsConstructorApp1.append("//Global variable for settings!\n")
2085                 extractedObjectsConstructorApp1.append("settings = [")
2086                 settings.each{
2087                         key, value ->
2088                         if (value != "END")
2089                                 extractedObjectsConstructorApp1.append("$key: $key, ")
2090                         else
2091                                 extractedObjectsConstructorApp1.append("END: \"END\"]\n")
2092                 }
2093         } else {
2094                 extractedObjectsConstructorApp2.append("//Global variable for settings!\n")
2095                 extractedObjectsConstructorApp2.append("settings = [")
2096                 settings.each{
2097                         key, value ->
2098                         if (value != "END")
2099                                 extractedObjectsConstructorApp2.append("$key: $key, ")
2100                         else
2101                                 extractedObjectsConstructorApp2.append("END: \"END\"]\n")
2102                 }
2103                 def line
2104                 File GlobalVariablesBothApps = new File("GlobalVariables/GlobalVariablesBothApps.groovy")
2105                 GlobalVariablesBothApps.write("")
2106                 GlobalVariablesBothApps.append("//Creating Global variables for both apps\n")
2107                 GlobalVariablesBothApps.append("@Field def sendEvent = {eventDataMap -> eventHandler(eventDataMap)}\n")
2108                 GlobalVariablesBothApps.append("@Field def locationObject = new LocationVar(sendEvent)\n")
2109                 GlobalVariablesBothApps.append("@Field def appObject = new Touched(sendEvent, 0)\n")
2110
2111                 globalObjects.withReader { reader ->
2112                         while ((line = reader.readLine()) != null) {
2113                                 GlobalVariablesBothApps.append(line)
2114                                 GlobalVariablesBothApps.append("\n")
2115                         }
2116                  }
2117         }
2118 }
2119
2120 def image(String data) {
2121         println("//IGNORE--some image//")
2122 }
2123
2124 def page(LinkedHashMap metaData, Closure inputData) {
2125         if (metaData.containsKey('name'))
2126                 println(metaData['name'])
2127         if (metaData.containsKey('title'))
2128                 println(metaData['title'])
2129
2130         find(inputData) //Run the closure to extract sections/inputMethods
2131 }
2132
2133 def page(LinkedHashMap metaData) {
2134         def nameOfFunction = metaData['name']
2135         "$nameOfFunction"() //Call the page
2136 }
2137
2138 def dynamicPage(LinkedHashMap metaData, Closure inputData) {
2139         if (metaData.containsKey('name'))
2140                 println(metaData['name'])
2141         if (metaData.containsKey('title'))
2142                 println(metaData['title'])
2143
2144         find(inputData) //Run the closure to extract sections/inputMethods
2145 }
2146
2147 def paragraph(String paragraphText) {
2148         println(paragraphText)
2149 }
2150
2151 def paragraph(LinkedHashMap metaData, String paragraphText) {
2152         println(paragraphText)
2153 }
2154
2155 def section(String title, Closure inputData) {
2156         println(title)
2157         find(inputData) //Run the closure to extract inputMethods
2158 }
2159
2160 def section(Closure inputData) {
2161         find(inputData) //Run the closure to extract inputMethods
2162 }
2163
2164 def section(LinkedHashMap metaData, Closure inputData) {
2165         find(inputData) //Run the closure to extract inputMethods
2166 }
2167
2168 def section(LinkedHashMap metaData, String data, Closure inputData) {
2169         find(inputData)
2170 }
2171
2172 def mappings(Closure inputData) {
2173         println("//IGNORE--some data//")
2174 }
2175 /////MethodsForExtraction/////
2176