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