Implement the types options in gen-template.json.

docs/sdk-integration.md

@@ -71,9 +71,10 @@ The following sections describe the details specific for use in certain more com
 Options are loaded into the database, keyed to the given generation package. While you can always use them in templates via the `template_options` key, certain keys have special meanings.
 The following is the list of special meanings:
 
-| Category          | Meaning                                                                                                                |
-| ----------------- | ---------------------------------------------------------------------------------------------------------------------- |
-| manufacturerCodes | This category backs a code/label map of valid manufacturer codes. They can be used in UI when selecting manufacturers. |
+| Category          | Meaning                                                                                                                                                                                                     |
+| ----------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| manufacturerCodes | This category backs a code/label map of valid manufacturer codes. They can be used in UI when selecting manufacturers.                                                                                      |
+| types             | This category backs a code/label map of type mappings. For a code, you can use any of the atomic or other ZCL types, and label is an override for a generator, detemining what type it shuld translate into |
 
 ## Template key: zcl
 

docs/template-tutorial.md

@@ -85,6 +85,17 @@ This content is output ONLY if there are no clusters at all.
 
 ```
 
+## Global context
+
+Whichever helpers get executed they all contain `global` inside their context that will always contain:
+
+- `db`: connection to the database being used
+- `sessionId`: session id for the user data being used
+- `genTemplatePackageId`: toplevel package id for gen-template.json file, used for querying options and other
+- `zclPackageId`: populated after you call `templateUtil.ensureZclPackageId()` the first time, used for querying the ZCL static data.
+
+Whenever a context switches, the switch will preserve this `global` object inside the context for helpers to access.
+
 ## Helper API
 
 Helper API is listed in the generated JSDoc documentation under "Template API modules". There are many helpers that can be used for all kind of different cases of ZCL generation.

src-electron/db/db-mapping.js

@@ -30,6 +30,7 @@ exports.map = {
       crc: x.CRC,
       type: x.TYPE,
       version: x.VERSION,
+      parentId: x.PARENT_PACKAGE_REF,
     }
   },
   options: (x) => {

src-electron/db/query-package.js

@@ -145,7 +145,7 @@ function getPackageByPackageId(db, packageId) {
   return dbApi
     .dbGet(
       db,
-      'SELECT PACKAGE_ID, PATH, TYPE, CRC, VERSION FROM PACKAGE WHERE PACKAGE_ID = ?',
+      'SELECT PACKAGE_ID, PARENT_PACKAGE_REF, PATH, TYPE, CRC, VERSION FROM PACKAGE WHERE PACKAGE_ID = ?',
       [packageId]
     )
     .then(dbMapping.map.package)

src-electron/db/query-zcl.js

@@ -1473,7 +1473,7 @@ function selectAtomicType(db, packageId, typeName) {
     .dbGet(
       db,
       'SELECT ATOMIC_IDENTIFIER, NAME, DESCRIPTION, ATOMIC_SIZE FROM ATOMIC WHERE PACKAGE_REF = ? AND NAME = ?',
-      [packageId, typeName.toLowerCase()]
+      [packageId, typeName == null ? typeName : typeName.toLowerCase()]
     )
     .then(dbMapping.map.atomic)
 }

src-electron/generator/generation-engine.js

@@ -205,13 +205,17 @@ function loadTemplates(db, genTemplatesJson) {
  * Generates all the templates inside a toplevel package.
  *
  * @param {*} genResult
- * @param {*} pkg
+ * @param {*} genTemplateJsonPkg Package that points to genTemplate.json file
  * @param {*} generateOnly if NULL then generate all templates, else only generate template whose out file name matches this.
  * @returns Promise that resolves with genResult, that contains all the generated templates, keyed by their 'output'
  */
-function generateAllTemplates(genResult, pkg, generateOnly = null) {
+function generateAllTemplates(
+  genResult,
+  genTemplateJsonPkg,
+  generateOnly = null
+) {
   return queryPackage
-    .getPackageByParent(genResult.db, pkg.id)
+    .getPackageByParent(genResult.db, genTemplateJsonPkg.id)
     .then((packages) => {
       var generationPromises = []
       var helperPromises = []
@@ -219,7 +223,11 @@ function generateAllTemplates(genResult, pkg, generateOnly = null) {
         if (singlePkg.type == dbEnum.packageType.genSingleTemplate) {
           if (generateOnly == null || generateOnly == singlePkg.version) {
             generationPromises.push(
-              generateSingleTemplate(genResult, singlePkg)
+              generateSingleTemplate(
+                genResult,
+                singlePkg,
+                genTemplateJsonPkg.id
+              )
             )
           }
         } else if (singlePkg.type == dbEnum.packageType.genHelper) {
@@ -240,14 +248,23 @@ function generateAllTemplates(genResult, pkg, generateOnly = null) {
  * Function that generates a single package and adds it to the generation result.
  *
  * @param {*} genResult
- * @param {*} pkg
+ * @param {*} singleTemplatePkg Single template package.
  * @returns promise that resolves with the genResult, with newly generated content added.
  */
-function generateSingleTemplate(genResult, pkg) {
+function generateSingleTemplate(
+  genResult,
+  singleTemplatePkg,
+  genTemplateJsonPackageId
+) {
   return templateEngine
-    .produceContent(genResult.db, genResult.sessionId, pkg)
+    .produceContent(
+      genResult.db,
+      genResult.sessionId,
+      singleTemplatePkg,
+      genTemplateJsonPackageId
+    )
     .then((data) => {
-      genResult.content[pkg.version] = data
+      genResult.content[singleTemplatePkg.version] = data
       genResult.partial = true
       return genResult
     })
@@ -257,7 +274,7 @@ function generateSingleTemplate(genResult, pkg) {
  * Main API function to generate stuff.
  *
  * @param {*} db Database
- * @param {*} packageId packageId Template package id
+ * @param {*} packageId packageId Template package id. It can be either single template or gen template json.
  * @returns Promise that resolves into a generation result.
  */
 function generate(db, sessionId, packageId, generateOnly = null) {
@@ -271,7 +288,7 @@ function generate(db, sessionId, packageId, generateOnly = null) {
     if (pkg.type === dbEnum.packageType.genTemplatesJson) {
       return generateAllTemplates(genResult, pkg, generateOnly)
     } else if (pkg.type === dbEnum.packageType.genSingleTemplate) {
-      return generateSingleTemplate(genResult, pkg)
+      return generateSingleTemplate(genResult, pkg, pkg.parentId)
     } else {
       throw `Invalid package type: ${pkg.type}`
     }
@@ -422,7 +439,7 @@ function generateSingleFileForPreview(db, sessionId, outFileName) {
 }
 
 exports.loadTemplates = loadTemplates
-exports.generate = generate
 exports.generateAndWriteFiles = generateAndWriteFiles
 exports.generateSingleFileForPreview = generateSingleFileForPreview
 exports.contentIndexer = contentIndexer
+exports.generate = generate

src-electron/generator/helper-c.js

@@ -16,6 +16,7 @@
  */
 
 const queryZcl = require('../db/query-zcl.js')
+const queryPackage = require('../db/query-package.js')
 const templateUtil = require('./template-util.js')
 const bin = require('../util/bin.js')
 const { logInfo } = require('../util/env.js')
@@ -196,9 +197,19 @@ function asUnderlyingType(value) {
     })
     .then((atomic) => {
       if (atomic == null) {
-        return `EmberAf${value}`
+        return `/* TYPE WARNING: not a valid atomic type: ${value} */ ${value}`
       } else {
-        return defaultAtomicType(atomic)
+        return queryPackage
+          .selectSpecificOptionValue(
+            this.global.db,
+            this.global.genTemplatePackageId,
+            'types',
+            atomic.name
+          )
+          .then((opt) => {
+            if (opt == null) return defaultAtomicType(atomic)
+            else return opt.optionLabel
+          })
       }
     })
 }

src-electron/generator/template-engine.js

@@ -31,14 +31,14 @@ const templateCompileOptions = {
 
 const precompiledTemplates = {}
 
-function produceCompiledTemplate(singlePkg) {
+function produceCompiledTemplate(singleTemplatePkg) {
   initializeGlobalHelpers()
-  if (singlePkg.id in precompiledTemplates)
-    return Promise.resolve(precompiledTemplates[singlePkg.id])
+  if (singleTemplatePkg.id in precompiledTemplates)
+    return Promise.resolve(precompiledTemplates[singleTemplatePkg.id])
   else
-    return fsPromise.readFile(singlePkg.path, 'utf8').then((data) => {
+    return fsPromise.readFile(singleTemplatePkg.path, 'utf8').then((data) => {
       var template = handlebars.compile(data, templateCompileOptions)
-      precompiledTemplates[singlePkg.id] = template
+      precompiledTemplates[singleTemplatePkg.id] = template
       return template
     })
 }
@@ -51,13 +51,19 @@ function produceCompiledTemplate(singlePkg) {
  * @param {*} singlePkg
  * @returns Promise that resolves with the 'utf8' string that contains the generated content.
  */
-function produceContent(db, sessionId, singlePkg) {
-  return produceCompiledTemplate(singlePkg).then((template) =>
+function produceContent(
+  db,
+  sessionId,
+  singleTemplatePkg,
+  genTemplateJsonPackageId
+) {
+  return produceCompiledTemplate(singleTemplatePkg).then((template) =>
     template({
       global: {
         db: db,
         sessionId: sessionId,
         promises: [],
+        genTemplatePackageId: genTemplateJsonPackageId,
       },
     })
   )

test/gen-template/zigbee/gen-templates.json

@@ -10,7 +10,10 @@
       "code5": "label5"
     },
     "externalOption": "externalOptions.json",
-    "cli": "cli.json"
+    "cli": "cli.json",
+    "types": {
+      "bacnet_oid": "bacnet_type_t"
+    }
   },
   "helpers": ["addon-helper.js"],
   "templates": [

test/gen-template/zigbee/simple-test.zapt

@@ -4,4 +4,6 @@ Header:{{zap_header}}
 
 SessionId: {{global.sessionId}}
 
-Addon: {{test_addon_helper}}
+Addon: {{test_addon_helper}}
\ No newline at end of file
+
+Strange type: {{asUnderlyingType "bacnet_oid"}}
\ No newline at end of file

test/genengine.test.js

@@ -115,6 +115,7 @@ test(
         expect(genResult.content).not.toBeNull()
         var simpleTest = genResult.content['simple-test.out']
         expect(simpleTest.startsWith('Test template file.')).toBeTruthy()
+        expect(simpleTest.includes('Strange type: bacnet_type_t')).toBeTruthy()
       }),
   genTimeout
 )