public attempt(context: ReplyContext) {
    const normalizedText = context.sourceMessage.text.toLowerCase()
    const shortCommands = _.sortBy(_.values(Looker.customCommands), (c) => -c.name.length)
    const matchedCommand = shortCommands.filter((c) => normalizedText.indexOf(c.name) === 0)[0]
    if (matchedCommand) {

      const { dashboard } = matchedCommand
      const query = context.sourceMessage.text.slice(matchedCommand.name.length).trim()
      normalizedText.indexOf(matchedCommand.name)

      context.looker = matchedCommand.looker

      const filters: {[key: string]: string} = {}
      const dashboardFilters = dashboard.dashboard_filters || dashboard.filters
      for (const filter of dashboardFilters) {
        filters[filter.name] = query
      }
      const runner = new DashboardQueryRunner(context, matchedCommand.dashboard, filters)
      runner.start()

      return true
    } else {
      return false
    }
  }

    constructor(opts: DaoOptions<T>) {
        this.tablename = opts.tablename;
        this.columnsMapping = opts.columnsMapping;
        this.objectconstructor = opts.objectconstructor;
        this.columnsMappingLength = _.keys(this.columnsMapping).length;
        this.columnsMappingKeys = _.keys(this.columnsMapping);
        this.columnsMappingValues = _.values(this.columnsMapping);
        this.primarykey = opts.primarykey;

        // Generate insert query string
        this.insertQuery = "INSERT INTO " + this.tablename + " (";
        let includeLength = 0;
        let args: any[] = [];
        let i = 0;
        while (i < this.columnsMappingLength - 1) {
            this.insertQuery += this.columnsMappingValues[i] + ", ";
            i++;
        }

        this.insertQuery += this.columnsMappingValues[i];
        this.insertQuery += ") values(";
        i = 0;
        while (i < this.columnsMappingLength - 1) {
            this.insertQuery += "?, ";
            i++;
        }
        this.insertQuery += "?);";
    }

function reduceBy(reducables: any[], properties: string[]) {
  const reduced = reducables.reduce((map, entry) => {
    const id = properties.map((prop) => entry[prop]).join('-');
    map[id] = map[id] || [];
    map[id].push(entry);
    return map;
  }, {});
  return _.values(reduced).map((rows: any[]) => reduce(rows))
}

 constructor(opts: DaoOptions<T>) {
     this.tablename = opts.tablename;
     this.columnsMapping = opts.columnsMapping;
     this.objectconstructor = opts.objectconstructor;
     this.columnsMappingLength = _.keys(this.columnsMapping).length;
     this.columnsMappingKeys = _.keys(this.columnsMapping);
     this.columnsMappingValues = _.values(this.columnsMapping);
     this.primarykey = opts.primarykey;
 }

 onConfiguredExecute: async (server:any, conf:ConfDTO, program:any, params:any, wizardTasks:any) => {
   const step = params[0];
   const tasks = step ? [wizardTasks[step]] : _.values(wizardTasks);
   for (const task of tasks) {
     if (!task) {
       throw 'Unknown task';
     }
     await task(conf, program)
   }
   // Check config
   await server.checkConfig();
   await server.dal.saveConf(conf);
   logger.debug("Configuration saved.");
 }

    constructor(options:ParseTemplate) {
		this._keys = _.keys(options.template.props);
		this._mappings = _.values(options.template.props);
		this._name = options.name;
		this._props = options.template.props;

		// set document context
		if (options.template.context) {

			if (_.isString(options.template.context)) {
				this._documentSelector = options.template.context;
			} else {
				this._documentSelector = options.template.context.selector;
				this._documentSelectorIndex = options.template.context.index;
			}
		} else {
			throw new Error('Missing template context');
		}
	}

function dump(mode: "E" | "D", args1: [any?, ...any[]]) {

    const a2 = _.values(args1) as [string, ...string[]];
    const output = format.apply(null, a2);
    let a1 = [buildPrefix(mode)];

    let i = 0;
    for (const line of output.split("\n")) {
        const lineArguments = ([] as string[]).concat(a1, [line]) as [string, ...string[]];
        console.log.apply(console, lineArguments);
        a1 = [continuation];
        i = i + 1;
        if (i > maxLines) {
            const a3 = a1.concat([" .... TRUNCATED ....."]);
            console.log.apply(console, a3 as [string, ...string[]]);
            break;
        }
    }

}

function constructNamespaceDependency(
  namespace: NamespacePrivate
) {

    const addressSpace = namespace.addressSpace;

    // navigate all namespace recursively to
    // find dependency
    const dependency = [];
    const depMap = new Set();

    // default namespace is always first
    dependency.push(addressSpace.getDefaultNamespace());
    depMap.add(dependency[0].index);

    if (namespace !== addressSpace.getDefaultNamespace()) {
        dependency.push(namespace);
        depMap.add(namespace.index);
    }

    for (const node of _.values(namespace._nodeid_index)) {
        // visit all reference
        const references = node.ownReferences();
        for (const reference of references) {
            // check referenceId
            const namespaceIndex = reference._referenceType!.nodeId.namespace;
            if (!depMap.has(namespaceIndex)) {
                depMap.add(namespaceIndex);
                dependency.push(addressSpace.getNamespace(namespaceIndex));
            }
            const namespaceIndex2 = reference.nodeId.namespace;
            if (!depMap.has(namespaceIndex2)) {
                depMap.add(namespaceIndex2);
                dependency.push(addressSpace.getNamespace(namespaceIndex2));
            }
        }
    }
    return dependency;
}

 async lookup(req:any): Promise<HttpLookup> {
   // Get the search parameter from HTTP query
   const search = await ParametersService.getSearchP(req);
   // Make the research
   const identities:any[] = await this.IdentityService.searchIdentities(search);
   // Entitify each result
   identities.forEach((idty, index) => identities[index] = DBIdentity.copyFromExisting(idty));
   // Prepare some data to avoid displaying expired certifications
   for (const idty of identities) {
     const certs = await this.server.dal.certsToTarget(idty.pubkey, idty.getTargetHash());
     const validCerts = [];
     for (const cert of certs) {
       const member = await this.IdentityService.getWrittenByPubkey(cert.from);
       if (member) {
         cert.uids = [member.uid];
         cert.isMember = member.member;
         cert.wasMember = member.wasMember;
       } else {
         const potentials = await this.IdentityService.getPendingFromPubkey(cert.from);
         cert.uids = _(potentials).pluck('uid');
         cert.isMember = false;
         cert.wasMember = false;
       }
       validCerts.push(cert);
     }
     idty.certs = validCerts;
     const signed = await this.server.dal.certsFrom(idty.pubkey);
     const validSigned = [];
     for (let j = 0; j < signed.length; j++) {
       const cert = _.clone(signed[j]);
       cert.idty = await this.server.dal.getIdentityByHashOrNull(cert.target);
       if (cert.idty) {
         validSigned.push(cert);
       } else {
         this.logger.debug('A certification to an unknown identity was found (%s => %s)', cert.from, cert.to);
       }
     }
     idty.signed = validSigned;
   }
   if (identities.length == 0) {
     throw BMAConstants.ERRORS.NO_MATCHING_IDENTITY;
   }
   const resultsByPubkey:any = {};
   identities.forEach((identity) => {
     const copy = DBIdentity.copyFromExisting(identity)
     const jsoned = copy.json();
     if (!resultsByPubkey[jsoned.pubkey]) {
       // Create the first matching identity with this pubkey in the map
       resultsByPubkey[jsoned.pubkey] = jsoned;
     } else {
       // Merge the identity with the existing(s)
       const existing = resultsByPubkey[jsoned.pubkey];
       // We add the UID of the identity to the list of already added UIDs
       existing.uids = existing.uids.concat(jsoned.uids);
       // We do not merge the `signed`: every identity with the same pubkey has the same `signed` because it the *pubkey* which signs, not the identity
     }
   });
   return {
     partial: false,
     results: _.values(resultsByPubkey)
   };
 }

 .subscribe((threadIdx: { [key: string]: Thread }) => {
     const threads = _.values(threadIdx);
     const threadNames = _.map(threads, (t: Thread) => t.name);
     console.log(` => threads (${threads.length}: ${threadNames}`);
 });