TypeScript lodash.keys函数代码示例

 function applyPromiseWithCallback(fnName, callback, args_) {
   try {
     let args = args_
     if (!_.isArray(args_)) {
       const fnParameters = jayson.Utils.getParameterNames(rippleAPI[fnName])
       args = fnParameters.map(name => args_[name])
       const defaultArgs = _.omit(args_, fnParameters)
       assert(_.size(defaultArgs) <= 1,
         'Function must have no more than one default argument')
       if (_.size(defaultArgs) > 0) {
         args.push(defaultArgs[_.keys(defaultArgs)[0]])
       }
     }
     Promise.resolve(rippleAPI[fnName](...args))
       .then(res => callback(null, res))
       .catch(err => {
         callback({code: 99, message: err.message, data: {name: err.name}})
       })
   } catch (err) {
     callback({code: 99, message: err.message, data: {name: err.name}})
   }
 }

 p.then(() => {
   assert.lengthOf(fetchMock.calls("/_admin/v1/uidata"), 1);
   assert.lengthOf(_.keys(state), 2);
   assert.equal(state[uiKey1].state, uidata.UIDataState.SAVING);
   assert.equal(state[uiKey2].state, uidata.UIDataState.SAVING);
   assert.isUndefined(state[uiKey1].data);
   assert.isUndefined(state[uiKey2].data);
   assert.notProperty(state[uiKey1], "data");
   assert.notProperty(state[uiKey2], "data");
   assert.isUndefined(state[uiKey1].error);
   assert.isUndefined(state[uiKey2].error);
   setTimeout(
     () => {
       assert.equal(state[uiKey1].state, uidata.UIDataState.SAVE_ERROR);
       assert.equal(state[uiKey2].state, uidata.UIDataState.SAVE_ERROR);
       assert.instanceOf(state[uiKey1].error, Error);
       assert.instanceOf(state[uiKey2].error, Error);
       done();
     },
     1000,
   );
 });

                function(res) {
                    var valittuOppiaine: any = {};
                    valittuOppiaine.oppiaine = res;
                    valittuOppiaine.vuosiluokkakokonaisuudet = _.zipBy(
                        res.vuosiluokkakokonaisuudet,
                        "_vuosiluokkaKokonaisuus"
                    );
                    $scope.valittuOppiaine = valittuOppiaine;

                    var valittavaVuosiluokka = $scope.valittuOppiaine.vuosiluokkakokonaisuudet[
                        $scope.filtterit.valittuKokonaisuus
                    ]
                        ? $scope.filtterit.valittuKokonaisuus
                        : _.first(_.keys($scope.valittuOppiaine.vuosiluokkakokonaisuudet));

                    if ($scope.currentSection === "vlk") {
                        valittavaVuosiluokka = $scope.valittuVuosiluokkakokonaisuus.id;
                    }

                    $scope.valitseOppiaineenVuosiluokka(valittavaVuosiluokka, true);
                    $scope.activeSection = "sisalto";
                },

		fields.forEach(field => {
			let newVal: any;
			let oldVal: any;

			// for dates we want to compare the time stamp
			if (oldObj[field] instanceof Date) {
				newVal = newObj[field] ? new Date(newObj[field]).getTime() : undefined;
				oldVal = oldObj[field] ? new Date(oldObj[field]).getTime() : undefined;

			// for objects, serialize first.
			} else if (isObject(oldObj[field])) {
				newVal = newObj[field] ? JSON.stringify(newObj[field]) : undefined;
				oldVal = oldObj[field] ? JSON.stringify(pick(oldObj[field], keys(newObj[field] || {}))) : undefined;

			// otherwise, take raw values.
			} else {
				newVal = newObj[field];
				oldVal = oldObj[field];
			}
			if (newVal && newVal !== oldVal) {
				modifiedFields.push(field);
			}
		});

function slackFieldify(inputObj: Object, short?: boolean, prefix?: string) {
  var prefix = prefix ? prefix + '_' : ''
  var short = short ? true : false

  if (Array.isArray(inputObj) && inputObj.length === 1) {
    inputObj = inputObj[0]
  }

  var result = _.map(_.keys(inputObj), function(key){
    if (!_.isObject(inputObj[key])) {
      return {
        title: s(prefix + key).humanize().titleize().value(),
        value: inputObj[key],
        short: short
      }
    } else {
      return slackFieldify(inputObj[key], short, prefix + key)
    }
  })

  result = _.flatten(result)
  return result
}

    public selectNewCertificateType(stack: Array<any>) {
        let self = this,
            objectType = Model.CryptoCertificate,
            columnIndex = 2,
            parentContext = stack[columnIndex - 1],
            context: any = {
                columnIndex: columnIndex,
                objectType: objectType,
                parentContext: parentContext,
                isCreatePrevented: true,
                path: parentContext.path + '/create'
            };
        return Promise.all([
            Promise.all(_.map(_.keys(CryptoCertificateType), (type) => this.cryptoCertificateRepository.getNewCryptoCertificate(type))),
            this.modelDescriptorService.getUiDescriptorForType(objectType)
        ]).spread(function(cryptoCertificates: Array<any>, uiDescriptor) {
            (cryptoCertificates as any)._objectType = objectType;
            context.object = _.compact(cryptoCertificates);
            context.userInterfaceDescriptor = uiDescriptor;

            return self.updateStackWithContext(stack, context);
        });
    }

    }).then((backingData: Partial<IEcsServerGroupCommandBackingData>) => {
      let loadBalancerReloader = this.$q.when(null);
      backingData.accounts = keys(backingData.credentialsKeyedByAccount);
      backingData.filtered = {} as IEcsServerGroupCommandBackingDataFiltered;
      command.backingData = backingData as IEcsServerGroupCommandBackingData;
      this.configureVpcId(command);
      this.configureAvailableIamRoles(command);
      this.configureAvailableMetricAlarms(command);
      this.configureAvailableEcsClusters(command);

      if (command.loadBalancers && command.loadBalancers.length) {
        // verify all load balancers are accounted for; otherwise, try refreshing load balancers cache
        const loadBalancerNames = this.getLoadBalancerNames(command);
        if (intersection(loadBalancerNames, command.loadBalancers).length < command.loadBalancers.length) {
          loadBalancerReloader = this.refreshLoadBalancers(command, true);
        }
      }

      return this.$q.all([loadBalancerReloader]).then(() => {
        this.applyOverrides('afterConfiguration', command);
        this.attachEventHandlers(command);
      });
    });

    app.route('/api/threads/:id').post((req, res) => {

        const payload = req.body;



        const threadId = parseInt(req.params.id),
            participantId = parseInt(req.headers['userid']);

        const message: Message = {
            id: messageIdCounter++,
            threadId,
            timestamp: new Date().getTime(),
            text: payload.text,
            participantId
        };

        // save the new message, it's
        // already linked to a thread
        dbMessages[message.id] = message;

        const thread = findThreadById(threadId);
        thread.messageIds.push(message.id);

        const otherParticipantIds = _.keys(thread.participants).filter(id => parseInt(id) !== participantId);

        otherParticipantIds.forEach(participantId => {
            thread.participants[participantId] += 1;
            dbMessagesQueuePerUser[participantId].push(message.id);

        });

        thread.participants[participantId] = 0;

        res.status(200).send();

    });

  changePlugin(newPlugin: PanelPlugin) {
    const pluginId = newPlugin.meta.id;
    const oldOptions: any = this.getOptionsToRemember();
    const oldPluginId = this.type;

    // for angular panels we must remove all events and let angular panels do some cleanup
    if (this.plugin.angularPanelCtrl) {
      this.destroy();
    }

    // remove panel type specific  options
    for (const key of _.keys(this)) {
      if (mustKeepProps[key]) {
        continue;
      }

      delete (this as any)[key];
    }

    this.cachedPluginOptions[oldPluginId] = oldOptions;
    this.restorePanelOptions(pluginId);

    // switch
    this.type = pluginId;
    this.plugin = newPlugin;

    // Let panel plugins inspect options from previous panel and keep any that it can use
    if (newPlugin.onPanelTypeChanged) {
      this.options = this.options || {};
      const old = oldOptions && oldOptions.options ? oldOptions.options : {};
      Object.assign(this.options, newPlugin.onPanelTypeChanged(this.options, oldPluginId, old));
    }

    if (newPlugin.onPanelMigration) {
      this.pluginVersion = getPluginVersion(newPlugin);
    }
  }

      function addAnnotations(options) {
        if (!annotations || annotations.length === 0) {
          return;
        }

        var types = {};
        for (var i = 0; i < annotations.length; i++) {
          var item = annotations[i];

          if (!types[item.source.name]) {
            types[item.source.name] = {
              color: item.source.iconColor,
              position: 'BOTTOM',
              markerSize: 5,
            };
          }
        }

        options.events = {
          levels: _.keys(types).length + 1,
          data: annotations,
          types: types,
        };
      }