export function toResponseErrorJson(request: JsonRpcRequest, error: any) {
    return toJson({
        ...pick(request, ['jsonrpc', 'id']),
        error
    });
}

export function getEvents(req: EventsRequestMessage, timeout?: moment.Duration): Promise<EventsResponseMessage> {
  const queryString = propsToQueryString(_.pick(req, ["type", "target_id"]));
  return timeoutFetch(serverpb.EventsResponse, `${API_PREFIX}/events?${queryString}`, null, timeout);
}

 resourcePrivileges: transform(applicationPrivilegesResponse, (result, value, key) => {
   result[key!] = pick(value, privileges);
 }),

  _influxRequest(method: string, url: string, data: any, options?: any) {
    const currentUrl = this.urls.shift();
    this.urls.push(currentUrl);

    const params: any = {};

    if (this.username) {
      params.u = this.username;
      params.p = this.password;
    }

    if (options && options.database) {
      params.db = options.database;
    } else if (this.database) {
      params.db = this.database;
    }

    if (method === 'POST' && _.has(data, 'q')) {
      // verb is POST and 'q' param is defined
      _.extend(params, _.omit(data, ['q']));
      data = this.serializeParams(_.pick(data, ['q']));
    } else if (method === 'GET' || method === 'POST') {
      // verb is GET, or POST without 'q' param
      _.extend(params, data);
      data = null;
    }

    const req: any = {
      method: method,
      url: currentUrl + url,
      params: params,
      data: data,
      precision: 'ms',
      inspect: { type: 'influxdb' },
      paramSerializer: this.serializeParams,
    };

    req.headers = req.headers || {};
    if (this.basicAuth || this.withCredentials) {
      req.withCredentials = true;
    }
    if (this.basicAuth) {
      req.headers.Authorization = this.basicAuth;
    }

    if (method === 'POST') {
      req.headers['Content-type'] = 'application/x-www-form-urlencoded';
    }

    return this.backendSrv.datasourceRequest(req).then(
      result => {
        return result.data;
      },
      err => {
        if (err.status !== 0 || err.status >= 300) {
          if (err.data && err.data.error) {
            throw {
              message: 'InfluxDB Error: ' + err.data.error,
              data: err.data,
              config: err.config,
            };
          } else {
            throw {
              message: 'Network Error: ' + err.statusText + '(' + err.status + ')',
              data: err.data,
              config: err.config,
            };
          }
        }
      }
    );
  }

					base.file.compatibility = f._compatibility.map((c: BuildDocument) => pick(c, ['id', 'label']));

//.........这里部分代码省略.........
          vm.lockedchanged = true;
        }
      },
      excludeItem(item: D1Item) {
        vm.onExcludedDrop(item.index, item.type);
      },
      onExcludedDrop(droppedId, type) {
        droppedId = getId(droppedId);
        if (
          alreadyExists(vm.excludeditems, droppedId) ||
          (vm.lockeditems[type] && alreadyExists([vm.lockeditems[type]], droppedId))
        ) {
          return;
        }
        const item = getItemById(droppedId, type)!;
        vm.excludeditems.push(item);
        vm.highestsets = vm.getSetBucketsStep(vm.active);
        if (vm.progress < 1) {
          vm.excludedchanged = true;
        }
      },
      onExcludedRemove(removedIndex) {
        vm.excludeditems = vm.excludeditems.filter(
          (excludeditem) => excludeditem.index !== removedIndex
        );
        vm.highestsets = vm.getSetBucketsStep(vm.active);
        if (vm.progress < 1) {
          vm.excludedchanged = true;
        }
      },
      lockEquipped() {
        const store = vm.activeCharacters[vm.selectedCharacter];
        const loadout = filterLoadoutToEquipped(store.loadoutFromCurrentlyEquipped(''));
        const items = _.pick(
          loadout.items,
          'helmet',
          'gauntlets',
          'chest',
          'leg',
          'classitem',
          'artifact',
          'ghost'
        );
        // Do not lock items with no stats
        vm.lockeditems.Helmet = items.helmet[0].stats ? (items.helmet[0] as D1Item) : null;
        vm.lockeditems.Gauntlets = items.gauntlets[0].stats ? (items.gauntlets[0] as D1Item) : null;
        vm.lockeditems.Chest = items.chest[0].stats ? (items.chest[0] as D1Item) : null;
        vm.lockeditems.Leg = items.leg[0].stats ? (items.leg[0] as D1Item) : null;
        vm.lockeditems.ClassItem = items.classitem[0].stats ? (items.classitem[0] as D1Item) : null;
        vm.lockeditems.Artifact = items.artifact[0].stats ? (items.artifact[0] as D1Item) : null;
        vm.lockeditems.Ghost = items.ghost[0].stats ? (items.ghost[0] as D1Item) : null;
        vm.highestsets = vm.getSetBucketsStep(vm.active);
        if (vm.progress < 1) {
          vm.lockedchanged = true;
        }
      },
      clearLocked() {
        vm.lockeditems = {
          Helmet: null,
          Gauntlets: null,
          Chest: null,
          Leg: null,
          ClassItem: null,
          Artifact: null,
          Ghost: null
        };

function createStatementForIndex(tableName: string, index: ISequelizeIndex): string {
  const subset = pick(index, ['name', 'unique', 'fields'])
  return `queryInterface.addIndex('${tableName}', ${JSON.stringify(subset).replace(/"/g, `'`)})`
}

	public serializeDetailed(metadata: { [p: string]: any }): { [p: string]: any } {
		return pick(metadata, 'format', 'size', 'depth', 'JPEG-Quality');
	}

Wallets.prototype.add = function(params, callback) {
  params = params || {};
  common.validateParams(params, [], ['label', 'enterprise', 'type'], callback);

  // no need to pass keys for (single) custodial wallets
  if (params.type !== 'custodial') {
    if (Array.isArray(params.keys) === false || !_.isNumber(params.m) || !_.isNumber(params.n)) {
      throw new Error('invalid argument');
    }

    // TODO: support more types of multisig
    if (!this.baseCoin.isValidMofNSetup(params)) {
      throw new Error('unsupported multi-sig type');
    }
  }

  if (params.tags && Array.isArray(params.tags) === false) {
    throw new Error('invalid argument for tags - array expected');
  }

  if (params.clientFlags && Array.isArray(params.clientFlags) === false) {
    throw new Error('invalid argument for clientFlags - array expected');
  }

  if (params.isCold && !_.isBoolean(params.isCold)) {
    throw new Error('invalid argument for isCold - boolean expected');
  }

  if (params.isCustodial && !_.isBoolean(params.isCustodial)) {
    throw new Error('invalid argument for isCustodial - boolean expected');
  }

  const self = this;
  const walletParams: any = _.pick(params, ['label', 'm', 'n', 'keys', 'enterprise', 'isCold', 'isCustodial', 'tags', 'clientFlags', 'type']);

  // Additional params needed for xrp
  if (params.rootPub) {
    walletParams.rootPub = params.rootPub;
  }

  // In XLM this private key is used only for wallet creation purposes, once the wallet is initialized then we
  // update its weight to 0 making it an invalid key.
  // https://www.stellar.org/developers/guides/concepts/multi-sig.html#additional-signing-keys
  if (params.rootPrivateKey) {
    walletParams.rootPrivateKey = params.rootPrivateKey;
  }

  if (params.initializationTxs) {
    walletParams.initializationTxs = params.initializationTxs;
  }

  if (params.disableTransactionNotifications) {
    walletParams.disableTransactionNotifications = params.disableTransactionNotifications;
  }

  return self.bitgo.post(self.baseCoin.url('/wallet')).send(walletParams).result()
  .then(function(newWallet) {
    return {
      wallet: new self.coinWallet(self.bitgo, self.baseCoin, newWallet)
    };
  })
  .nodeify(callback);
};

	/**
	 * Creates a new release.
	 *
	 * @see POST /v1/releases
	 * @param {Context} ctx Koa context
	 */
	public async create(ctx: Context) {

		const span = this.apmStartSpan('ReleaseApi.create');
		let release: ReleaseDocument;
		const now = new Date();

		try {
			// defaults
			if (ctx.request.body.versions) {
				ctx.request.body.versions.forEach((version: ReleaseVersionDocument) => {
					version.released_at = version.released_at || now.toISOString();
					if (version.files) {
						const releasedAt = version.released_at || now.toISOString();
						version.files.forEach((file: ReleaseVersionFileDocument) => {
							file.released_at = file.released_at || releasedAt;
						});
					}
				});
			}

			logger.info(ctx.state, '[ReleaseApi.create] Body: %s', JSON.stringify(ctx.request.body));
			const newRelease = await state.models.Release.getInstance(ctx.state, extend(ctx.request.body, {
				_created_by: ctx.state.user._id,
				modified_at: now,
				created_at: now,
			}));

			release = newRelease;
			await this.preProcess(ctx, newRelease.getFileIds());
			await release.validate();

			logger.info(ctx.state, '[ReleaseApi.create] Validations passed.');
			release.versions = orderBy(release.versions, ['released_at'], ['desc']);
			release.released_at = release.versions[0].released_at as Date;
			await release.save();

			await this.postProcess(ctx.state, release.getPlayfieldImageIds());

			logger.info(ctx.state, '[ReleaseApi.create] Release "%s" created.', release.name);
			await release.activateFiles();

			logger.info(ctx.state, '[ReleaseApi.create] All referenced files activated, returning object to client.');

			release = await this.getDetails(release._id);
			const game = release._game as GameDocument;

			// log event
			await LogEventUtil.log(ctx, 'create_release', true, {
				release: state.serializers.Release.detailed(ctx, release, { thumbFormat: 'medium', includedFields: ['moderation'] }),
				game: pick(state.serializers.Game.simple(ctx, game), ['id', 'title', 'manufacturer', 'year', 'ipdb', 'game_type']),
			}, {
				release: release._id,
				game: release._game._id,
			});

			// invalidate cache
			await apiCache.invalidateCreatedRelease(ctx.state, release);
			if (game.game_type === 'og' && release.moderation.is_approved && game.counter.releases === 0) {
				// empty original games aren't shown in lists, so we need to invalidate when that changes.
				await apiCache.invalidateCreatedGame(ctx.state);
			}

			this.success(ctx, state.serializers.Release.detailed(ctx, release, { includedFields: ['is_active'] }), 201);

		} catch (err) {
			throw err;

		} finally {
			this.apmEndSpan(span);
		}

		this.noAwait(async () => {

			// notify (co-)author(s)
			for (const author of release.authors) {
				if ((author._user as UserDocument).id !== ctx.state.user.id) {
					await mailer.releaseAdded(ctx.state, ctx.state.user, author._user as UserDocument, release);
				}
			}

			// handle moderation mails
			if (release.moderation.is_approved) {
				await (release._game as GameDocument).incrementCounter('releases');
				await mailer.releaseAutoApproved(ctx.state, ctx.state.user, release);
			} else {
				await mailer.releaseSubmitted(ctx.state, ctx.state.user, release);
			}

			// update game modification date
			await (release._game as GameDocument).update({ modified_at: new Date() });
		});
	}