constructor($scope, $injector, $rootScope) {
    super($scope, $injector);
    this.$rootScope = $rootScope;

    _.defaults(this.panel, panelDefaults);
    _.defaults(this.panel.legend, panelDefaults.legend);

    this.events.on('data-received', this.onDataReceived.bind(this));
    this.events.on('data-error', this.onDataError.bind(this));
    this.events.on('data-snapshot-load', this.onDataReceived.bind(this));
    this.events.on('init-edit-mode', this.onInitEditMode.bind(this));
  }

  function addModels(kiln) {
    extensionA = _.defaults({name: 'A'}, extensionApi)
    const extensionB = _.defaults({name: 'B'}, extensionApi)
    const extensionC = _.defaults({name: 'C'}, extensionApi)
    jest.spyOn(extensionA, 'build').mockReturnValue({resultA: 'foo'})
    jest.spyOn(extensionB, 'build').mockReturnValue({resultB: 'bar'})
    jest.spyOn(extensionC, 'build').mockReturnValue({resultC: 'baz'})

    kiln
      .addModel({name: 'user', model})
      .addExtension({modelName: 'user', extension: extensionA})
      .addExtension({modelName: 'user', extension: extensionB})
      .addModel({name: 'photo', model})
      .addExtension({modelName: 'photo', extension: extensionC})
  }

export const shipOrder = async (transactionId: string, orderLines?: Array<IMollieOrderLine>, tracking?: IMollieTracking): Promise<any> => {
  const [
    { default: store },
  ] = await Promise.all([
    import(/* webpackPrefetch: true, webpackChunkName: "transaction" */ '@transaction/store'),
  ]);
  try {
    const ajaxEndpoint = store.getState().config.ajaxEndpoint;

    const { data } = await axios.post(ajaxEndpoint, {
      resource: 'orders',
      action: 'ship',
      transactionId,
      orderLines,
      tracking,
    });
    if (!data.success && typeof data.message === 'string') {
      throw data.detailed ? data.detailed : data.message;
    }

    return defaults(data, { success: false, order: null });
  } catch (e) {
    if (typeof e === 'string') {
      throw e;
    }
    console.error(e);

    return false;
  }
};

	constructor(config: IConfig) {
		this._config = _.defaults({}, config, {
			request: axiosAdapter({
				forceHttpAdaptor: config.environment === 'node',
			}),
			userAgent: 'anx-api/' + packageJson.version,
			timeout: 60 * 1000,
			headers: {},
			target: null,
			token: null,
			rateLimiting: true,
			chunkSize: DEFAULT_CHUNK_SIZE,
		});

		this.request = __request;

		// Install optional rate limiting adapter
		this.request = this._config.rateLimiting ? rateLimitAdapter(_.assign({}, config, {
			request: __request.bind(this),
		})) : __request.bind(this);

		// Install optional concurrency adapter
		this._config.request = this._config.concurrencyLimit ? concurrencyAdapter({
			limit: this._config.concurrencyLimit,
			request: this._config.request,
		}) : this._config.request;
	}

      .then(() => {
        _.each(datasources, (value, key) => {
          inputs.push(value);
        });

        // templatize constants
        for (let variable of saveModel.templating.list) {
          if (variable.type === 'constant') {
            var refName = 'VAR_' + variable.name.replace(' ', '_').toUpperCase();
            inputs.push({
              name: refName,
              type: 'constant',
              label: variable.label || variable.name,
              value: variable.current.value,
              description: '',
            });
            // update current and option
            variable.query = '${' + refName + '}';
            variable.options[0] = variable.current = {
              value: variable.query,
              text: variable.query,
            };
          }
        }

        // make inputs and requires a top thing
        var newObj = {};
        newObj['__inputs'] = inputs;
        newObj['__requires'] = _.sortBy(requires, ['id']);

        _.defaults(newObj, saveModel);
        return newObj;
      })

    test('TCP/HTTP RPC command', function (done) {
      var server = new stratum.RPCServer(_.defaults({ mode: 'both' }, this.opts)),
        exposed = {
          'func': function (args, opts, callback) {
            callback(null, args)
          }
        },
        spy = sinon.spy(exposed, 'func'),
        client = new rpc.Client(server.opts.port, 'localhost')

      server.expose('func', exposed.func, exposed).listen()

      client.connectSocket(function (err, conn) {
        conn.call('func', ['MTIz', 1, 2], function (err, result) {
          expect(result).to.eql([1, 2])
          expect(spy.calledWith([1, 2])).to.equal(true)

          client.call('func', ['MTIz', 1, 2], function (err, result) {
            expect(result).to.eql([1, 2])
            expect(spy.calledWith([1, 2])).to.equal(true)
            server.close()
            done()
          })
        })
      })
    })

function addParams(request: PathFindRequest, result: RippledPathsResponse
): RippledPathsResponse {
  return _.defaults(_.assign({}, result, {
    source_account: request.source_account,
    source_currencies: request.source_currencies
  }), {destination_amount: request.destination_amount})
}

	private setDefaults(): void {
		this.config = _.defaults<Partial<RouteActiveConfig>, RouteActiveConfig>({
			activeClass: this.activeClass,
			attribute: this.attribute,
			matchExact: this.matchExact
		}, routeActiveConfig);
	}

function buildSassFile (srcFile, dstFile) {
  let sassOptions = _.defaults({ file: srcFile }, sassDefaults)
  return sassRender(sassOptions)
    .then((result) => {
      return writeFile(dstFile, result.css)
    })
}

  public convertServerGroupCommandToDeployConfiguration(base: any): any {
    // use _.defaults to avoid copying the backingData, which is huge and expensive to copy over
    const command = defaults({ backingData: [], viewState: [] }, base);
    command.cloudProvider = 'aws';
    command.availabilityZones = {};
    command.availabilityZones[command.region] = base.availabilityZones;
    command.loadBalancers = (base.loadBalancers || []).concat(base.vpcLoadBalancers || []);
    command.targetGroups = base.targetGroups || [];
    command.account = command.credentials;
    command.subnetType = command.subnetType || '';

    if (base.viewState.mode !== 'clone') {
      delete command.source;
    }
    if (!command.ramdiskId) {
      delete command.ramdiskId; // TODO: clean up in kato? - should ignore if empty string
    }
    delete command.region;
    delete command.viewState;
    delete command.backingData;
    delete command.selectedProvider;
    delete command.instanceProfile;
    delete command.vpcId;

    return command;
  }