@gadmin2n/schematics 0.0.144 → 0.0.145

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/workflow/node-instances/widgets/CronTriggerConfigEditor.tsx

@@ -0,0 +1,569 @@
+import { DeleteOutlined, PlusOutlined } from '@ant-design/icons';
+import { Button, Select, TimePicker, Typography } from 'antd';
+import dayjs from 'dayjs';
+import { useTranslation } from 'react-i18next';
+import type { WidgetProps } from '../schema-form/widget-registry';
+
+type CronTriggerConfig = {
+  cronExpressions?: string[];
+  timezone?: string;
+};
+
+type Frequency =
+  | 'HOURLY'
+  | 'DAILY'
+  | 'WEEKDAYS'
+  | 'WEEKLY'
+  | 'MONTHLY'
+  | 'YEARLY';
+
+type ScheduleSelection = {
+  frequency: Frequency;
+  hour: number;
+  minute: number;
+  weekdays: number[];
+  monthDays: number[];
+  months: number[];
+  hourlyMinutes: number[];
+  executionTimes: Array<{ hour: number; minute: number }>;
+};
+
+const DEFAULT_SCHEDULE: ScheduleSelection = {
+  frequency: 'DAILY',
+  hour: 9,
+  minute: 0,
+  weekdays: [1],
+  monthDays: [1],
+  months: [1],
+  hourlyMinutes: [0],
+  executionTimes: [{ hour: 9, minute: 0 }],
+};
+
+const TIMEZONE_VALUES = [
+  'Asia/Shanghai',
+  'Asia/Singapore',
+  'Asia/Tokyo',
+  'Europe/London',
+  'America/New_York',
+  'UTC',
+] as const;
+
+function parseCronExpression(value: string): ScheduleSelection | null {
+  const parts = value?.trim().split(/\s+/);
+  if (!parts || parts.length !== 5) return null;
+
+  const [minuteText, hourText, monthDayText, monthText, weekdayText] = parts;
+
+  if (
+    hourText === '*' &&
+    monthDayText === '*' &&
+    monthText === '*' &&
+    weekdayText === '*'
+  ) {
+    const hourlyMinutes = minuteText.split(',').map(Number);
+    if (
+      hourlyMinutes.length === 0 ||
+      !hourlyMinutes.every(
+        (minute, index) =>
+          Number.isInteger(minute) &&
+          minute >= 0 &&
+          minute <= 59 &&
+          hourlyMinutes.indexOf(minute) === index,
+      )
+    ) {
+      return null;
+    }
+    return {
+      ...DEFAULT_SCHEDULE,
+      frequency: 'HOURLY',
+      minute: hourlyMinutes[0],
+      hourlyMinutes,
+    };
+  }
+
+  const minute = Number(minuteText);
+  if (!Number.isInteger(minute) || minute < 0 || minute > 59) return null;
+
+  const hour = Number(hourText);
+  if (!Number.isInteger(hour) || hour < 0 || hour > 23) {
+    return null;
+  }
+
+  if (monthText === '*' && monthDayText === '*' && weekdayText === '*') {
+    return { ...DEFAULT_SCHEDULE, frequency: 'DAILY', hour, minute };
+  }
+  if (monthText === '*' && monthDayText === '*' && weekdayText === '1-5') {
+    return { ...DEFAULT_SCHEDULE, frequency: 'WEEKDAYS', hour, minute };
+  }
+
+  const weekdays = weekdayText.split(',').map(Number);
+  if (
+    monthText === '*' &&
+    monthDayText === '*' &&
+    weekdays.length > 0 &&
+    weekdays.every(
+      (weekday, index) =>
+        Number.isInteger(weekday) &&
+        weekday >= 0 &&
+        weekday <= 6 &&
+        weekdays.indexOf(weekday) === index,
+    )
+  ) {
+    return {
+      ...DEFAULT_SCHEDULE,
+      frequency: 'WEEKLY',
+      hour,
+      minute,
+      weekdays,
+    };
+  }
+
+  const monthDay = Number(monthDayText);
+  if (
+    monthText === '*' &&
+    weekdayText === '*' &&
+    Number.isInteger(monthDay) &&
+    monthDay >= 1 &&
+    monthDay <= 31
+  ) {
+    return {
+      ...DEFAULT_SCHEDULE,
+      frequency: 'MONTHLY',
+      hour,
+      minute,
+      monthDays: [monthDay],
+    };
+  }
+
+  const monthDays = monthDayText.split(',').map(Number);
+  if (
+    monthText === '*' &&
+    weekdayText === '*' &&
+    monthDays.length > 0 &&
+    monthDays.every(
+      (day, index) =>
+        Number.isInteger(day) &&
+        day >= 1 &&
+        day <= 31 &&
+        monthDays.indexOf(day) === index,
+    )
+  ) {
+    return {
+      ...DEFAULT_SCHEDULE,
+      frequency: 'MONTHLY',
+      hour,
+      minute,
+      monthDays,
+    };
+  }
+
+  const months = monthText.split(',').map(Number);
+  if (
+    weekdayText === '*' &&
+    Number.isInteger(monthDay) &&
+    monthDay >= 1 &&
+    monthDay <= 31 &&
+    months.length > 0 &&
+    months.every(
+      (month, index) =>
+        Number.isInteger(month) &&
+        month >= 1 &&
+        month <= 12 &&
+        months.indexOf(month) === index,
+    )
+  ) {
+    return {
+      ...DEFAULT_SCHEDULE,
+      frequency: 'YEARLY',
+      hour,
+      minute,
+      monthDays: [monthDay],
+      months,
+    };
+  }
+
+  return null;
+}
+
+function parseSchedule(values?: string[]): ScheduleSelection | null {
+  if (!values?.length) return null;
+  const parsed = values.map(parseCronExpression);
+  if (parsed.some((item) => !item)) return null;
+  const schedules = parsed as ScheduleSelection[];
+  const first = schedules[0];
+  if (!schedules.every((item) => item.frequency === first.frequency)) {
+    return null;
+  }
+  if (first.frequency === 'HOURLY') {
+    return schedules.length === 1 ? first : null;
+  }
+
+  const scopeKey = (item: ScheduleSelection) => {
+    if (item.frequency === 'WEEKLY') {
+      return [...item.weekdays].sort((a, b) => a - b).join(',');
+    }
+    if (item.frequency === 'MONTHLY') {
+      return [...item.monthDays].sort((a, b) => a - b).join(',');
+    }
+    if (item.frequency === 'YEARLY') {
+      return `${[...item.months].sort((a, b) => a - b).join(',')}:${item.monthDays[0]}`;
+    }
+    return '';
+  };
+  if (!schedules.every((item) => scopeKey(item) === scopeKey(first))) {
+    return null;
+  }
+
+  const executionTimes = schedules.map(({ hour, minute }) => ({
+    hour,
+    minute,
+  }));
+  if (
+    new Set(executionTimes.map(({ hour, minute }) => `${hour}:${minute}`))
+      .size !== executionTimes.length
+  ) {
+    return null;
+  }
+  return { ...first, executionTimes };
+}
+
+function buildCronExpressions(selection: ScheduleSelection): string[] {
+  const { frequency, weekdays, monthDays, months } = selection;
+  if (frequency === 'HOURLY') {
+    return [
+      `${[...selection.hourlyMinutes].sort((a, b) => a - b).join(',')} * * * *`,
+    ];
+  }
+  if (frequency === 'DAILY') {
+    return selection.executionTimes.map(
+      (time) => `${time.minute} ${time.hour} * * *`,
+    );
+  }
+  if (frequency === 'WEEKDAYS') {
+    return selection.executionTimes.map(
+      (time) => `${time.minute} ${time.hour} * * 1-5`,
+    );
+  }
+  if (frequency === 'WEEKLY') {
+    const weekdayText = [...weekdays]
+      .sort((a, b) => (a === 0 ? 7 : a) - (b === 0 ? 7 : b))
+      .join(',');
+    return selection.executionTimes.map(
+      (time) => `${time.minute} ${time.hour} * * ${weekdayText}`,
+    );
+  }
+  if (frequency === 'MONTHLY') {
+    const monthDayText = [...monthDays].sort((a, b) => a - b).join(',');
+    return selection.executionTimes.map(
+      (time) => `${time.minute} ${time.hour} ${monthDayText} * *`,
+    );
+  }
+  if (frequency === 'YEARLY') {
+    const monthText = [...months].sort((a, b) => a - b).join(',');
+    return selection.executionTimes.map(
+      (time) => `${time.minute} ${time.hour} ${monthDays[0]} ${monthText} *`,
+    );
+  }
+  return [];
+}
+
+function nextExecutionTime(times: ScheduleSelection['executionTimes']) {
+  const occupied = new Set(times.map(({ hour, minute }) => hour * 60 + minute));
+  const last = times[times.length - 1] ?? { hour: 8, minute: 0 };
+  const start = last.hour * 60 + last.minute;
+  for (let offset = 60; offset <= 24 * 60; offset += 5) {
+    const candidate = (start + offset) % (24 * 60);
+    if (!occupied.has(candidate)) {
+      return { hour: Math.floor(candidate / 60), minute: candidate % 60 };
+    }
+  }
+  return null;
+}
+
+export function CronTriggerConfigEditor({
+  value,
+  onChange,
+  disabled,
+}: WidgetProps<CronTriggerConfig | undefined>) {
+  const { t } = useTranslation('workflow');
+  const config = value ?? {};
+  const parsedSchedule = parseSchedule(config.cronExpressions);
+  const selection =
+    parsedSchedule ??
+    (config.cronExpressions?.length === 0
+      ? { ...DEFAULT_SCHEDULE, executionTimes: [], hourlyMinutes: [] }
+      : DEFAULT_SCHEDULE);
+
+  const updateSchedule = (next: ScheduleSelection) =>
+    onChange({
+      cronExpressions: buildCronExpressions(next),
+      ...(config.timezone ? { timezone: config.timezone } : {}),
+    });
+
+  const changeFrequency = (frequency: Frequency) =>
+    updateSchedule({
+      ...selection,
+      frequency,
+      ...(frequency === 'HOURLY'
+        ? { hourlyMinutes: [selection.minute] }
+        : {
+            executionTimes: [
+              { hour: selection.hour, minute: selection.minute },
+            ],
+          }),
+    });
+
+  return (
+    <div className="cron-trigger-config">
+      <div className="cron-trigger-config__field">
+        <Typography.Text className="workflow-node-config__field-label">
+          {t('nodeEditors.cron.frequency')}
+        </Typography.Text>
+        <Select
+          aria-label={t('nodeEditors.cron.frequency')}
+          value={parsedSchedule?.frequency}
+          disabled={disabled}
+          placeholder={t('nodeEditors.cron.frequencyPlaceholder')}
+          options={(
+            [
+              'HOURLY',
+              'DAILY',
+              'WEEKDAYS',
+              'WEEKLY',
+              'MONTHLY',
+              'YEARLY',
+            ] as const
+          ).map((frequency) => ({
+            value: frequency,
+            label: t(`nodeEditors.cron.frequencies.${frequency}`),
+          }))}
+          onChange={changeFrequency}
+        />
+        {!parsedSchedule && config.cronExpressions?.length && (
+          <Typography.Text
+            type="secondary"
+            className="cron-trigger-config__hint"
+          >
+            {t('nodeEditors.cron.chooseNewSchedule')}
+          </Typography.Text>
+        )}
+      </div>
+
+      {selection.frequency === 'HOURLY' ? (
+        <div className="cron-trigger-config__field">
+          <Typography.Text className="workflow-node-config__field-label">
+            {t('nodeEditors.cron.minute')}
+          </Typography.Text>
+          <Select
+            mode="multiple"
+            aria-label={t('nodeEditors.cron.minute')}
+            value={selection.hourlyMinutes}
+            disabled={disabled || !parsedSchedule}
+            options={Array.from({ length: 60 }, (_, minute) => ({
+              value: minute,
+              label: t('nodeEditors.cron.minuteOption', { minute }),
+            }))}
+            onChange={(hourlyMinutes) =>
+              updateSchedule({ ...selection, hourlyMinutes })
+            }
+          />
+        </div>
+      ) : (
+        <div className="cron-trigger-config__field">
+          <Typography.Text className="workflow-node-config__field-label">
+            {t('nodeEditors.cron.times')}
+          </Typography.Text>
+          <div className="cron-trigger-config__time-list">
+            {selection.executionTimes.map((time, index) => (
+              <div
+                key={`${time.hour}:${time.minute}`}
+                className="cron-trigger-config__time-row"
+              >
+                <TimePicker
+                  aria-label={t('nodeEditors.cron.timeNumber', {
+                    number: index + 1,
+                  })}
+                  format="HH:mm"
+                  minuteStep={5}
+                  value={dayjs().hour(time.hour).minute(time.minute).second(0)}
+                  disabled={disabled || !parsedSchedule}
+                  onChange={(nextTime) => {
+                    if (!nextTime) {
+                      updateSchedule({
+                        ...selection,
+                        executionTimes: selection.executionTimes.filter(
+                          (_, itemIndex) => itemIndex !== index,
+                        ),
+                      });
+                      return;
+                    }
+                    const next = {
+                      hour: nextTime.hour(),
+                      minute: nextTime.minute(),
+                    };
+                    updateSchedule({
+                      ...selection,
+                      executionTimes: selection.executionTimes.map(
+                        (item, itemIndex) =>
+                          itemIndex === index ? next : item,
+                      ),
+                    });
+                  }}
+                />
+                <Button
+                  type="text"
+                  danger
+                  icon={<DeleteOutlined />}
+                  aria-label={t('nodeEditors.cron.removeTime', {
+                    number: index + 1,
+                  })}
+                  disabled={disabled}
+                  onClick={() =>
+                    updateSchedule({
+                      ...selection,
+                      executionTimes: selection.executionTimes.filter(
+                        (_, itemIndex) => itemIndex !== index,
+                      ),
+                    })
+                  }
+                />
+              </div>
+            ))}
+          </div>
+          <Button
+            className="workflow-panel-action"
+            icon={<PlusOutlined />}
+            aria-label={t('nodeEditors.cron.addTime')}
+            disabled={disabled || !parsedSchedule}
+            onClick={() => {
+              const next = nextExecutionTime(selection.executionTimes);
+              if (next) {
+                updateSchedule({
+                  ...selection,
+                  executionTimes: [...selection.executionTimes, next],
+                });
+              }
+            }}
+          >
+            {t('nodeEditors.cron.addTime')}
+          </Button>
+        </div>
+      )}
+
+      {selection.frequency === 'WEEKLY' && (
+        <div className="cron-trigger-config__field">
+          <Typography.Text className="workflow-node-config__field-label">
+            {t('nodeEditors.cron.weekday')}
+          </Typography.Text>
+          <Select
+            mode="multiple"
+            aria-label={t('nodeEditors.cron.weekday')}
+            value={selection.weekdays}
+            disabled={disabled || !parsedSchedule}
+            options={[1, 2, 3, 4, 5, 6, 0].map((weekday) => ({
+              value: weekday,
+              label: t(`nodeEditors.cron.weekdays.${weekday}`),
+            }))}
+            onChange={(weekdays) => updateSchedule({ ...selection, weekdays })}
+          />
+        </div>
+      )}
+
+      {selection.frequency === 'MONTHLY' && (
+        <div className="cron-trigger-config__field">
+          <Typography.Text className="workflow-node-config__field-label">
+            {t('nodeEditors.cron.monthDay')}
+          </Typography.Text>
+          <Select
+            mode="multiple"
+            aria-label={t('nodeEditors.cron.monthDay')}
+            value={selection.monthDays}
+            disabled={disabled || !parsedSchedule}
+            options={Array.from({ length: 31 }, (_, index) => ({
+              value: index + 1,
+              label: t('nodeEditors.cron.monthDayOption', { day: index + 1 }),
+            }))}
+            onChange={(monthDays) =>
+              updateSchedule({ ...selection, monthDays })
+            }
+          />
+        </div>
+      )}
+
+      {selection.frequency === 'YEARLY' && (
+        <>
+          <div className="cron-trigger-config__field">
+            <Typography.Text className="workflow-node-config__field-label">
+              {t('nodeEditors.cron.months')}
+            </Typography.Text>
+            <Select
+              mode="multiple"
+              aria-label={t('nodeEditors.cron.months')}
+              value={selection.months}
+              disabled={disabled || !parsedSchedule}
+              options={Array.from({ length: 12 }, (_, index) => ({
+                value: index + 1,
+                label: t('nodeEditors.cron.monthOption', {
+                  month: index + 1,
+                }),
+              }))}
+              onChange={(months) => updateSchedule({ ...selection, months })}
+            />
+          </div>
+          <div className="cron-trigger-config__field">
+            <Typography.Text className="workflow-node-config__field-label">
+              {t('nodeEditors.cron.monthDay')}
+            </Typography.Text>
+            <Select
+              aria-label={t('nodeEditors.cron.monthDay')}
+              value={selection.monthDays[0]}
+              disabled={disabled || !parsedSchedule}
+              options={Array.from({ length: 31 }, (_, index) => ({
+                value: index + 1,
+                label: t('nodeEditors.cron.yearMonthDayOption', {
+                  day: index + 1,
+                }),
+              }))}
+              onChange={(monthDay) =>
+                updateSchedule({ ...selection, monthDays: [monthDay] })
+              }
+            />
+          </div>
+        </>
+      )}
+
+      <div className="cron-trigger-config__field">
+        <Typography.Text className="workflow-node-config__field-label">
+          {t('nodeEditors.cron.timezone')}
+        </Typography.Text>
+        <Select
+          aria-label={t('nodeEditors.cron.timezone')}
+          value={
+            TIMEZONE_VALUES.includes(
+              config.timezone as (typeof TIMEZONE_VALUES)[number],
+            )
+              ? config.timezone
+              : undefined
+          }
+          disabled={disabled}
+          allowClear
+          placeholder={t('nodeEditors.cron.timezonePlaceholder')}
+          options={TIMEZONE_VALUES.map((timezone) => ({
+            value: timezone,
+            label: t(`nodeEditors.cron.timezones.${timezone}`),
+          }))}
+          onChange={(timezone) =>
+            onChange({
+              cronExpressions:
+                config.cronExpressions ?? buildCronExpressions(selection),
+              ...(timezone ? { timezone } : {}),
+            })
+          }
+        />
+        <Typography.Text type="secondary" className="cron-trigger-config__hint">
+          {t('nodeEditors.cron.timezoneHint')}
+        </Typography.Text>
+      </div>
+    </div>
+  );
+}

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/workflow/node-instances/widgets/DbExecuteConfigEditor.tsx

@@ -0,0 +1,130 @@
+import { Input, InputNumber, Space, Switch, Typography } from 'antd';
+import { useTranslation } from 'react-i18next';
+import type { ParameterBinding } from '../../types/parameter-binding';
+import type { WidgetProps } from '../schema-form/widget-registry';
+import { ParameterBindingListEditor } from './ParameterBindingListEditor';
+
+type DbExecuteConfig = {
+  allowWrite?: boolean;
+  sql?: string;
+  parameters?: ParameterBinding[];
+  timeoutSeconds?: number | null;
+};
+
+function normalizeSql(sql: string): string {
+  const withoutContent = sql
+    .replace(/\$(\w*)\$[\s\S]*?\$\1\$/g, ' ')
+    .replace(/'(?:''|[^'])*'/g, ' ')
+    .replace(/"(?:""|[^"])*"/g, ' ')
+    .replace(/\/\*[\s\S]*?\*\//g, ' ')
+    .replace(/--[^\r\n]*/g, ' ')
+    .trim();
+  const withoutTrailingSemicolon = withoutContent.replace(/;\s*$/, '').trim();
+  return withoutTrailingSemicolon.includes(';') ? '' : withoutTrailingSemicolon;
+}
+
+export function isDatabaseSqlAllowed(
+  sql: string,
+  allowWrite: boolean,
+): boolean {
+  const normalized = normalizeSql(sql);
+  if (!normalized) return false;
+  const readOnly =
+    /^(select|with)\b/i.test(normalized) &&
+    !/\b(insert|update|delete|merge|call|copy|create|alter|drop|truncate|grant|revoke|vacuum|refresh)\b/i.test(
+      normalized,
+    );
+  const writableCte =
+    /^with\b/i.test(normalized) &&
+    /\b(insert|update|delete)\b/i.test(normalized) &&
+    !/\b(merge|call|copy|create|alter|drop|truncate|grant|revoke|vacuum|refresh)\b/i.test(
+      normalized,
+    );
+  return (
+    readOnly ||
+    (allowWrite &&
+      (/^(insert|update|delete)\b/i.test(normalized) || writableCte))
+  );
+}
+
+export function DbExecuteConfigEditor({
+  value,
+  onChange,
+  disabled,
+}: WidgetProps<DbExecuteConfig | undefined>) {
+  const { t } = useTranslation('workflow');
+  const config = value ?? {};
+  const allowWrite = config.allowWrite === true;
+
+  return (
+    <Space direction="vertical" size={14} style={{ width: '100%' }}>
+      <div className="db-execute-config__permission">
+        <div>
+          <Typography.Text strong>
+            {t('nodeEditors.database.allowWrite')}
+          </Typography.Text>
+          <Typography.Text type="secondary" className="db-execute-config__hint">
+            {t(
+              allowWrite
+                ? 'nodeEditors.database.readWriteDescription'
+                : 'nodeEditors.database.readOnlyDescription',
+            )}
+          </Typography.Text>
+        </div>
+        <Switch
+          aria-label={t('nodeEditors.database.allowWrite')}
+          checked={allowWrite}
+          disabled={disabled}
+          onChange={(nextAllowWrite) =>
+            onChange({ ...config, allowWrite: nextAllowWrite })
+          }
+        />
+      </div>
+
+      <Space direction="vertical" size={6} style={{ width: '100%' }}>
+        <Typography.Text>{t('nodeEditors.database.sql')}</Typography.Text>
+        <Input.TextArea
+          aria-label={t('nodeEditors.database.sql')}
+          value={config.sql ?? ''}
+          disabled={disabled}
+          rows={7}
+          placeholder={
+            allowWrite
+              ? 'UPDATE users SET active = $1 WHERE id = $2'
+              : 'SELECT id, name FROM users WHERE id = $1'
+          }
+          onChange={(event) => onChange({ ...config, sql: event.target.value })}
+        />
+      </Space>
+
+      <Space direction="vertical" size={6} style={{ width: '100%' }}>
+        <Typography.Text>
+          {t('nodeEditors.database.parameters')}
+        </Typography.Text>
+        <Typography.Text type="secondary" className="db-execute-config__hint">
+          {t('nodeEditors.database.parametersHint')}
+        </Typography.Text>
+        <ParameterBindingListEditor
+          value={config.parameters}
+          disabled={disabled}
+          addLabel={t('nodeEditors.database.addParameter')}
+          onChange={(parameters) => onChange({ ...config, parameters })}
+        />
+      </Space>
+
+      <Space direction="vertical" size={6} style={{ width: '100%' }}>
+        <Typography.Text>{t('nodeEditors.database.timeout')}</Typography.Text>
+        <InputNumber
+          precision={0}
+          value={
+            config.timeoutSeconds === undefined ? 30 : config.timeoutSeconds
+          }
+          disabled={disabled}
+          addonAfter={t('nodeEditors.database.seconds')}
+          onChange={(timeoutSeconds) => onChange({ ...config, timeoutSeconds })}
+          style={{ width: '100%' }}
+        />
+      </Space>
+    </Space>
+  );
+}