@youzan-cloud/zan-saas-cli 0.0.0-stage → 0.1.0-beta.4

package/src/commands/native/interaction/lottery/get/query.js

@@ -0,0 +1,152 @@
+'use strict';
+
+const { validateCommandValue } = require('../../../../../execution/command-schema');
+const { constraints, modelAt } = require('../../../../../execution/error-details');
+const { formatBeijingMilliseconds } = require('../../../../../execution/beijing-time');
+const { object } = require('../../../../../execution/query-api');
+const { createShopQuery, failure } = require('../../../../../execution/shop-query');
+const schema = require('./schema.json');
+
+const command = 'interaction.lottery.get';
+const bindingBytes = 512 * 1024;
+const responseBytes = 8 * 1024 * 1024;
+const kinds = ['cards', 'wheel', 'zodiac', 'crazyguess', 'shake'];
+const participationFields = {
+  requireFollow: 'is_need_follow', followValidationType: 'follow_validate_type',
+  filterUsers: 'is_filter_user', allowedTagIds: 'white_tags', allowedCardIds: 'white_cards',
+  costPoints: 'cost_points', givePoints: 'give_points', giveOnlyWhenNotWinning: 'is_only_give_no_prize',
+  limitType: 'limit_times_type', limitCount: 'limit_times_value',
+  shareLimit: 'limit_share_times_value', conditionType: 'join_condition_type'
+};
+const awardFields = {
+  awardId: 'id', name: 'award_name', type: 'award_type', imageUrl: 'image_url',
+  originName: 'origin_name', stockQuantity: 'total_amount', sourceRewardId: 'award_fetch',
+  position: 'award_sort', pointsValue: 'points_value', issuedCount: 'total_send_num',
+  probabilityPercent: 'winning_probability'
+};
+const slotFields = {
+  awardId: 'id', type: 'award_type', name: 'award_name', imageUrl: 'image_url',
+  originName: 'origin_name', position: 'position'
+};
+
+function pick(source, fields, path, invalid) {
+  if (!object(source)) throw invalid('protocol', path, source === undefined ? 'required' : 'invalid_type');
+  const result = {};
+  for (const [field, upstream] of Object.entries(fields)) {
+    if (Object.hasOwn(source, upstream)) result[field] = source[upstream];
+  }
+  return result;
+}
+
+function projectArray(source, fields, path, invalid) {
+  if (!Array.isArray(source)) throw invalid('protocol', path, 'invalid_type');
+  return source.map((row, index) => pick(row, fields, `${path}/${index}`, invalid));
+}
+
+function projectLottery(data, input, facts = {}) {
+  const base = '/data/lottery';
+  const invalid = (category, path, reason = 'constraint', expected) => {
+    const error = failure(command, category, 'response', { kdtId: input.kdtId }, 'sent', facts);
+    if (path) error.issues = [{ source: 'output', path, reason,
+      expected: expected || constraints(modelAt(schema, 'output', path)) }];
+    return error;
+  };
+  if (!object(data)) throw invalid('protocol', base, data === undefined ? 'required' : 'invalid_type');
+  for (const [field, target] of [['id', 'activityId'], ['kdt_id', 'ownerKdtId']]) {
+    if (!Number.isSafeInteger(data[field]) || data[field] < 1) {
+      throw invalid('protocol', `${base}/${target}`, Object.hasOwn(data, field) ? 'constraint' : 'required');
+    }
+  }
+  if (typeof data.app_name !== 'string' || !data.app_name.trim()) {
+    throw invalid('protocol', `${base}/kind`, !Object.hasOwn(data, 'app_name') ? 'required' :
+      typeof data.app_name === 'string' ? 'invalid_format' : 'invalid_type');
+  }
+  if (data.id !== input.activityId) throw invalid('scope_unresolved', `${base}/activityId`);
+  if (data.kdt_id !== input.kdtId) throw invalid('scope_unresolved', `${base}/ownerKdtId`);
+  if (!kinds.includes(data.app_name)) throw invalid('scope_unresolved', `${base}/kind`, 'invalid_choice');
+  try {
+    const lottery = pick(data, {
+      activityId: 'id', ownerKdtId: 'kdt_id', title: 'title', kind: 'app_name', alias: 'alias',
+      autoReplyEnabled: 'is_auto_reply'
+    }, base, invalid);
+    for (const [field, upstream] of [['startsAt', 'start_date'], ['endsAt', 'end_date']]) {
+      if (!Object.hasOwn(data, upstream)) continue;
+      try { lottery[field] = formatBeijingMilliseconds(data[upstream]); }
+      catch { throw invalid('protocol', `${base}/${field}`, 'invalid_format'); }
+    }
+    const participation = pick(data, participationFields, `${base}/participation`, invalid);
+    if (Object.keys(participation).length) lottery.participation = participation;
+    if (Object.hasOwn(data, 'winning_setting')) {
+      const source = data.winning_setting;
+      lottery.winning = pick(source, {
+        probabilityBasisPoints: 'winning_probability', noPrizeName: 'un_winning_name',
+        noPrizeText: 'un_winning_words', noPrizeImageUrl: 'un_winning_image_url',
+        jumpWhenNotWinning: 'is_un_winning_jump'
+      }, `${base}/winning`, invalid);
+      if (Object.hasOwn(source, 'un_winning_jump_url')) {
+        lottery.winning.noPrizeLink = pick(source.un_winning_jump_url, {
+          alias: 'alias', id: 'link_id', title: 'link_title', type: 'link_type', url: 'link_url'
+        }, `${base}/winning/noPrizeLink`, invalid);
+      }
+      if (Object.hasOwn(source, 'awards')) {
+        lottery.winning.awards = projectArray(source.awards, awardFields, `${base}/winning/awards`, invalid);
+      }
+    }
+    if (Object.hasOwn(data, 'turntables')) {
+      lottery.wheelSlots = projectArray(data.turntables, slotFields, `${base}/wheelSlots`, invalid);
+    }
+    if (Object.hasOwn(data, 'view')) {
+      lottery.view = pick(data.view, { backgroundImageUrl: 'bg_image_url', description: 'description' }, `${base}/view`, invalid);
+      for (const [field, upstream] of [['showWinnerList', 'is_show_winner_list'], ['showLogo', 'is_show_logo_image']]) {
+        if (!Object.hasOwn(data.view, upstream)) continue;
+        if (![0, 1].includes(data.view[upstream])) throw invalid('protocol', `${base}/view/${field}`, 'invalid_choice',
+          { type: 'integer', enum: [0, 1], format: '接口开关须为0或1，再转换为布尔值' });
+        lottery.view[field] = data.view[upstream] === 1;
+      }
+    }
+    if (Object.hasOwn(data, 'auto_reply')) {
+      lottery.autoReply = pick(data.auto_reply, { content: 'content', ruleId: 'rule_id' }, `${base}/autoReply`, invalid);
+      if (Object.hasOwn(data.auto_reply, 'keywords')) {
+        lottery.autoReply.keywords = projectArray(data.auto_reply.keywords, { name: 'name', fullMatch: 'is_full_match' },
+          `${base}/autoReply/keywords`, invalid);
+      }
+    }
+    const output = { data: { lottery } };
+    validateCommandValue(schema, 'output', output);
+    return output;
+  } catch (cause) {
+    if (cause.cliDetails) throw cause;
+    const error = invalid('protocol');
+    if (cause.issues) error.issues = cause.issues;
+    if (cause.issuesTruncated) error.issuesTruncated = true;
+    throw error;
+  }
+}
+
+async function executeLottery(input) {
+  const scope = { kdtId: input.kdtId };
+  let limit = bindingBytes;
+  let response;
+  try {
+    const read = await createShopQuery(scope, command, {
+      transportOptions: { maxResponseBytes: () => limit }
+    });
+    limit = responseBytes;
+    response = await read(schema.api.path, { activity_id: input.activityId }, 'query');
+  } catch (error) {
+    const details = error.cliDetails;
+    if (details?.category === 'limit' ||
+        (details?.category === 'business_rejected' && details.stage === 'query' &&
+        details.api === schema.api.path && !Object.hasOwn(details, 'gatewayCode') &&
+        [1605406001, '1605406001'].includes(details.businessCode))) {
+      const facts = Object.fromEntries(['api', 'httpStatus', 'businessCode', 'trace_id', 'request_id']
+        .filter(field => Object.hasOwn(details, field)).map(field => [field, details[field]]));
+      throw failure(command, details.category === 'limit' ? 'limit' : 'not_found',
+        details.category === 'limit' ? 'response' : 'query', scope, 'sent', facts);
+    }
+    throw error;
+  }
+  return projectLottery(response.data, input, response.facts);
+}
+
+module.exports = { projectLottery, executeLottery };