wowok 1.8.2 → 2.1.9

package/dist/esm/w/call/progress.js

@@ -0,0 +1,827 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import {
+  toTxObject,
+  toTxString,
+  isValidName,
+  isValidLongName,
+  PackageAddress,
+  MAX_LONG_NAME_LENGTH,
+  MAX_NAME_LENGTH,
+  GetObjectExisted
+} from "../common.js";
+import { W_ERROR, WErrors } from "../exception.js";
+import { GetManyAccountOrMark_Address } from "../local/index.js";
+import { LocalMark } from "../local/local.js";
+import {
+  ObjectType,
+  query_objects,
+  queryTableItem_MachineNode
+} from "../query/object.js";
+import { validObjects } from "../util.js";
+import { CallBase } from "./base.js";
+class CallProgress extends CallBase {
+  constructor(data) {
+    super();
+    __publicField(this, "data");
+    __publicField(this, "object_address");
+    __publicField(this, "machine");
+    this.data = data;
+  }
+  async prepare(env) {
+    await super.prepare(env);
+    if (!this.object_address) {
+      this.object_address = await GetObjectExisted(this.data?.object);
+    }
+    if (this.object_address) {
+      await this.update_content(
+        env,
+        ObjectType.Progress,
+        this.object_address
+      );
+      if (!this.content) {
+        W_ERROR(
+          WErrors.InvalidParam,
+          "CallProgress_Data.data.object:" + this.object_address
+        );
+      }
+      const r = await query_objects({
+        objects: [this.content.machine],
+        no_cache: false,
+        network: env.network
+      });
+      if (!r.objects || r.objects.length !== 1 || r.objects[0].type !== ObjectType.Machine) {
+        W_ERROR(
+          WErrors.InvalidParam,
+          `fetch machine ${this.content.machine} failed`
+        );
+      }
+      this.machine = r.objects[0];
+    } else {
+      W_ERROR(
+        WErrors.InvalidParam,
+        "CallProgress_Data.data.object:" + this.data?.object
+      );
+    }
+  }
+  async call(env) {
+    await this.prepare(env);
+    const guards = [];
+    const progressObj = this.content;
+    const add_guard = (guard) => {
+      if (!guards.includes(guard)) {
+        guards.push(guard);
+      }
+    };
+    if (this.data?.operate != null) {
+      const f = await getMachineNodeForward(
+        env,
+        this.machine?.object,
+        progressObj.current,
+        this.data.operate.operation.next_node_name,
+        this.data.operate.operation.forward
+      );
+      if (f) {
+        if (f?.guard?.guard) {
+          add_guard(f.guard.guard);
+        }
+      } else {
+        W_ERROR(
+          WErrors.InvalidParam,
+          `CallProgress_Data.data.operate.operation.forward:${this.data?.operate.operation.forward} not found`
+        );
+      }
+    }
+    if (guards.length > 0) {
+      return await this.check_guard_and_call(env, guards);
+    }
+    return await this.exec(env);
+  }
+  async operate(env, tx, passport, submission) {
+    const content = this.content;
+    if (this.data?.task) {
+      if (content.task) {
+        W_ERROR(
+          WErrors.InvalidParam,
+          `CallProgress_Data.data.task:${this.data?.task} is set; and once set, it can not be changed`
+        );
+      }
+      const t = await LocalMark.Instance().get_address(this.data?.task);
+      if (t) {
+        task_set(
+          tx,
+          this.object_address,
+          this.machine?.object,
+          this.machine?.permission,
+          t,
+          passport
+        );
+      } else {
+        W_ERROR(
+          WErrors.InvalidParam,
+          `CallProgress_Data.data.task:${this.data?.task} invalid`
+        );
+      }
+    }
+    if (this.data?.repository) {
+      switch (this.data.repository.op) {
+        case "add":
+        case "set": {
+          if (this.data.repository.objects.length > MAX_CONTEXT_REPOSITORY_COUNT - (content?.context_repositories?.length ?? 0)) {
+            W_ERROR(
+              WErrors.InvalidParam,
+              `CallProgress_Data.data.repository.objects exceeds max count:${this.data.repository.objects}`
+            );
+          }
+          if (this.data.repository.op === "set") {
+            context_repository_clear(
+              tx,
+              this.object_address,
+              this.machine?.object,
+              this.machine?.permission
+            );
+          }
+          const r = await LocalMark.Instance().get_many_address_availables(
+            this.data.repository.objects
+          );
+          r.forEach((repo) => {
+            context_repository_add(
+              tx,
+              this.object_address,
+              this.machine?.object,
+              this.machine?.permission,
+              repo,
+              passport
+            );
+          });
+          break;
+        }
+        case "remove": {
+          if (this.data.repository.objects.length > (content?.context_repositories?.length ?? 0)) {
+            W_ERROR(
+              WErrors.InvalidParam,
+              `CallProgress_Data.data.repository.objects exceeds max count:${this.data.repository.objects}`
+            );
+          }
+          const addrs = await LocalMark.Instance().get_many_address_availables(
+            this.data.repository.objects
+          );
+          context_repository_remove(
+            tx,
+            this.object_address,
+            this.machine?.object,
+            this.machine?.permission,
+            addrs,
+            passport
+          );
+          break;
+        }
+        case "clear":
+          context_repository_clear(
+            tx,
+            this.object_address,
+            this.machine?.object,
+            this.machine?.permission,
+            passport
+          );
+          break;
+      }
+    }
+    if (this.data?.progress_namedOperator) {
+      switch (this.data.progress_namedOperator.op) {
+        case "add": {
+          const r = await GetManyAccountOrMark_Address(
+            this.data.progress_namedOperator.operators
+          );
+          namedOperator_add(
+            tx,
+            this.object_address,
+            this.machine?.object,
+            this.machine?.permission,
+            this.data.progress_namedOperator.name,
+            r,
+            passport
+          );
+          break;
+        }
+        case "set": {
+          const r = await GetManyAccountOrMark_Address(
+            this.data.progress_namedOperator.operators
+          );
+          namedOperator_set(
+            tx,
+            this.object_address,
+            this.machine?.object,
+            this.machine?.permission,
+            this.data.progress_namedOperator.name,
+            r,
+            passport
+          );
+          break;
+        }
+        case "remove": {
+          const r = await GetManyAccountOrMark_Address(
+            this.data.progress_namedOperator.operators
+          );
+          namedOperator_remove(
+            tx,
+            this.object_address,
+            this.machine?.object,
+            this.machine?.permission,
+            this.data.progress_namedOperator.name,
+            r,
+            passport
+          );
+          break;
+        }
+      }
+    }
+    if (this.data.operate != null) {
+      if ("hold" in this.data.operate) {
+        if (this.data.operate.adminUnhold) {
+          adminUnhold(
+            tx,
+            this.object_address,
+            this.machine?.object,
+            this.machine?.permission,
+            this.data.operate.operation.next_node_name,
+            this.data.operate.operation.forward,
+            this.data.operate.message ?? "",
+            passport
+          );
+        } else {
+          let order = void 0;
+          if (content.task) {
+            const r = await query_objects({
+              objects: [content.task],
+              no_cache: false,
+              network: env.network
+            });
+            if (r.objects && r.objects.length === 1 && r.objects[0].type === ObjectType.Order) {
+              order = r.objects[0].object;
+            }
+          }
+          hold(
+            tx,
+            this.object_address,
+            this.machine?.object,
+            this.machine?.permission,
+            this.data.operate.operation.next_node_name,
+            this.data.operate.operation.forward,
+            this.data.operate.message ?? "",
+            this.data.operate.hold,
+            order,
+            passport
+          );
+        }
+      } else {
+        let order = void 0;
+        if (content.task) {
+          const r = await query_objects({
+            objects: [content.task],
+            no_cache: false,
+            network: env.network
+          });
+          if (r.objects && r.objects.length === 1 && r.objects[0].type === ObjectType.Order) {
+            order = r.objects[0].object;
+          }
+        }
+        accomplish(
+          tx,
+          this.object_address,
+          this.machine?.object,
+          this.machine?.permission,
+          this.data.operate.operation.next_node_name,
+          this.data.operate.operation.forward,
+          this.data.operate.message ?? "",
+          order,
+          passport
+        );
+      }
+    }
+  }
+}
+function progressFn(name) {
+  return `${PackageAddress}::progress::${name}`;
+}
+const MAX_CONTEXT_REPOSITORY_COUNT = 30;
+const MAX_NAMED_OPERATOR_COUNT = 60;
+const MAX_NAMED_OPERATOR_ADDRESS_COUNT = 80;
+function newProgress(tx, machine, permission, task, passport) {
+  validObjects([machine, permission, task, passport]);
+  if (passport) {
+    return tx.moveCall({
+      target: progressFn("new_with_passport"),
+      arguments: [
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        passport,
+        tx.pure.option("address", task),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ]
+    });
+  } else {
+    return tx.moveCall({
+      target: progressFn("new"),
+      arguments: [
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        tx.pure.option("address", task),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ]
+    });
+  }
+}
+function create(tx, progress) {
+  validObjects([progress]);
+  return tx.moveCall({
+    target: progressFn("create"),
+    arguments: [toTxObject(tx, progress)]
+  });
+}
+function namedOperator_add(tx, progress, machine, permission, name, operators, passport) {
+  if (operators.length === 0) {
+    return;
+  }
+  if (operators.length > MAX_NAMED_OPERATOR_ADDRESS_COUNT) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Named operator address count ${operators.length} is not valid`
+    );
+  }
+  validObjects([progress, machine, permission, passport, ...operators]);
+  if (!isValidName(name)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Named operator name ${name} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: progressFn("namedOperator_add_with_passport"),
+      arguments: [
+        toTxObject(tx, progress),
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        toTxString(tx, name),
+        tx.pure.vector("address", operators)
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: progressFn("namedOperator_add"),
+      arguments: [
+        toTxObject(tx, progress),
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        toTxString(tx, name),
+        tx.pure.vector("address", operators)
+      ]
+    });
+  }
+}
+function namedOperator_remove(tx, progress, machine, permission, name, operators, passport) {
+  if (operators.length === 0) {
+    return;
+  }
+  if (operators.length > MAX_NAMED_OPERATOR_ADDRESS_COUNT) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Named operator address count ${operators.length} is not valid`
+    );
+  }
+  validObjects([progress, machine, permission, passport, ...operators]);
+  if (!isValidName(name)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Named operator name ${name} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: progressFn("namedOperator_remove_with_passport"),
+      arguments: [
+        toTxObject(tx, progress),
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        toTxString(tx, name),
+        tx.pure.vector("address", operators)
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: progressFn("namedOperator_remove"),
+      arguments: [
+        toTxObject(tx, progress),
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        toTxString(tx, name),
+        tx.pure.vector("address", operators)
+      ]
+    });
+  }
+}
+function namedOperator_set(tx, progress, machine, permission, name, operators, passport) {
+  validObjects([progress, machine, permission, passport, ...operators]);
+  if (operators.length > MAX_NAMED_OPERATOR_ADDRESS_COUNT) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Named operator address count ${operators.length} is not valid`
+    );
+  }
+  if (!isValidName(name)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Named operator name ${name} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: progressFn("namedOperator_set_with_passport"),
+      arguments: [
+        toTxObject(tx, progress),
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        toTxString(tx, name),
+        tx.pure.vector("address", operators)
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: progressFn("namedOperator_set"),
+      arguments: [
+        toTxObject(tx, progress),
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        toTxString(tx, name),
+        tx.pure.vector("address", operators)
+      ]
+    });
+  }
+}
+function task_set(tx, progress, machine, permission, task, passport) {
+  validObjects([progress, machine, permission, passport, task]);
+  if (passport) {
+    tx.moveCall({
+      target: progressFn("task_set_with_passport"),
+      arguments: [
+        toTxObject(tx, progress),
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        tx.pure.address(task)
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: progressFn("task_set"),
+      arguments: [
+        toTxObject(tx, progress),
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        tx.pure.address(task)
+      ]
+    });
+  }
+}
+function context_repository_add(tx, progress, machine, permission, repository, passport) {
+  validObjects([progress, machine, permission, passport, repository]);
+  if (passport) {
+    tx.moveCall({
+      target: progressFn("context_repository_add_with_passport"),
+      arguments: [
+        toTxObject(tx, progress),
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        toTxObject(tx, repository),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: progressFn("context_repository_add"),
+      arguments: [
+        toTxObject(tx, progress),
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        toTxObject(tx, repository),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ]
+    });
+  }
+}
+function context_repository_remove(tx, progress, machine, permission, repositories, passport) {
+  validObjects([progress, machine, permission, passport, ...repositories]);
+  if (passport) {
+    tx.moveCall({
+      target: progressFn("context_repository_remove_with_passport"),
+      arguments: [
+        toTxObject(tx, progress),
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        tx.pure.vector("address", repositories),
+        tx.object.mutRegistrar()
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: progressFn("context_repository_remove"),
+      arguments: [
+        toTxObject(tx, progress),
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        tx.pure.vector("address", repositories),
+        tx.object.mutRegistrar()
+      ]
+    });
+  }
+}
+function context_repository_clear(tx, progress, machine, permission, passport) {
+  validObjects([progress, machine, permission, passport]);
+  if (passport) {
+    tx.moveCall({
+      target: progressFn("context_repository_clear_with_passport"),
+      arguments: [
+        toTxObject(tx, progress),
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        tx.object.mutRegistrar()
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: progressFn("context_repository_clear"),
+      arguments: [
+        toTxObject(tx, progress),
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        tx.object.mutRegistrar()
+      ]
+    });
+  }
+}
+function hold(tx, progress, machine, permission, next_node, forward, message, bHold, order, passport) {
+  validObjects([progress, machine, permission, passport, order]);
+  if (!next_node || !isValidName(next_node)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Next node ${next_node} is exceeds maximum length ${MAX_NAME_LENGTH}`
+    );
+  }
+  if (forward && !isValidName(forward)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Forward ${forward} is exceeds maximum length ${MAX_NAME_LENGTH}`
+    );
+  }
+  if (!isValidLongName(message)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Message ${message} is exceeds maximum length ${MAX_LONG_NAME_LENGTH}`
+    );
+  }
+  if (passport) {
+    if (order) {
+      tx.moveCall({
+        target: progressFn("order_hold_with_passport"),
+        arguments: [
+          toTxObject(tx, progress),
+          toTxObject(tx, machine),
+          toTxObject(tx, permission),
+          passport,
+          toTxObject(tx, order),
+          toTxString(tx, next_node),
+          toTxString(tx, forward),
+          tx.pure.bool(bHold),
+          toTxString(tx, message),
+          tx.object.clock()
+        ]
+      });
+    } else {
+      tx.moveCall({
+        target: progressFn("hold_with_passport"),
+        arguments: [
+          toTxObject(tx, progress),
+          toTxObject(tx, machine),
+          toTxObject(tx, permission),
+          passport,
+          toTxString(tx, next_node),
+          toTxString(tx, forward),
+          tx.pure.bool(bHold),
+          toTxString(tx, message),
+          tx.object.clock()
+        ]
+      });
+    }
+  } else {
+    if (order) {
+      tx.moveCall({
+        target: progressFn("order_hold"),
+        arguments: [
+          toTxObject(tx, progress),
+          toTxObject(tx, machine),
+          toTxObject(tx, permission),
+          toTxObject(tx, order),
+          toTxString(tx, next_node),
+          toTxString(tx, forward),
+          tx.pure.bool(bHold),
+          toTxString(tx, message),
+          tx.object.clock()
+        ]
+      });
+    } else {
+      tx.moveCall({
+        target: progressFn("hold"),
+        arguments: [
+          toTxObject(tx, progress),
+          toTxObject(tx, machine),
+          toTxObject(tx, permission),
+          toTxString(tx, next_node),
+          toTxString(tx, forward),
+          tx.pure.bool(bHold),
+          toTxString(tx, message),
+          tx.object.clock()
+        ]
+      });
+    }
+  }
+}
+function adminUnhold(tx, progress, machine, permission, next_node, forward, message, passport) {
+  validObjects([progress, machine, permission, passport]);
+  if (!next_node || !isValidName(next_node)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Next node ${next_node} is exceeds maximum length ${MAX_NAME_LENGTH}`
+    );
+  }
+  if (forward && !isValidName(forward)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Forward ${forward} is exceeds maximum length ${MAX_NAME_LENGTH}`
+    );
+  }
+  if (!isValidLongName(message)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Message ${message} is exceeds maximum length ${MAX_LONG_NAME_LENGTH}`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: progressFn("unhold_with_passport"),
+      arguments: [
+        toTxObject(tx, progress),
+        toTxObject(tx, passport),
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        passport,
+        toTxString(tx, next_node),
+        toTxString(tx, forward),
+        toTxString(tx, message),
+        tx.object.clock()
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: progressFn("unhold"),
+      arguments: [
+        toTxObject(tx, progress),
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        toTxString(tx, next_node),
+        toTxString(tx, forward),
+        toTxString(tx, message),
+        tx.object.clock()
+      ]
+    });
+  }
+}
+function accomplish(tx, progress, machine, permission, next_node, forward, message, order, passport) {
+  validObjects([progress, machine, permission, passport, order]);
+  if (!isValidName(next_node)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Next node ${next_node} is exceeds maximum length ${MAX_NAME_LENGTH}`
+    );
+  }
+  if (forward && !isValidName(forward)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Forward ${forward} is exceeds maximum length ${MAX_NAME_LENGTH}`
+    );
+  }
+  if (!isValidLongName(message)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Message ${message} is exceeds maximum length ${MAX_LONG_NAME_LENGTH}`
+    );
+  }
+  if (passport) {
+    if (order) {
+      tx.moveCall({
+        target: progressFn("order_next_with_passport"),
+        arguments: [
+          toTxObject(tx, progress),
+          toTxObject(tx, machine),
+          toTxObject(tx, permission),
+          toTxObject(tx, passport),
+          toTxObject(tx, order),
+          toTxString(tx, next_node),
+          toTxString(tx, forward),
+          toTxString(tx, message),
+          tx.object.clock()
+        ]
+      });
+    } else {
+      tx.moveCall({
+        target: progressFn("next_with_passport"),
+        arguments: [
+          toTxObject(tx, progress),
+          toTxObject(tx, machine),
+          toTxObject(tx, permission),
+          toTxObject(tx, passport),
+          toTxString(tx, next_node),
+          toTxString(tx, forward),
+          toTxString(tx, message),
+          tx.object.clock()
+        ]
+      });
+    }
+  } else {
+    if (order) {
+      tx.moveCall({
+        target: progressFn("order_next"),
+        arguments: [
+          toTxObject(tx, progress),
+          toTxObject(tx, machine),
+          toTxObject(tx, permission),
+          toTxObject(tx, order),
+          toTxString(tx, next_node),
+          toTxString(tx, forward),
+          toTxString(tx, message),
+          tx.object.clock()
+        ]
+      });
+    } else {
+      tx.moveCall({
+        target: progressFn("next"),
+        arguments: [
+          toTxObject(tx, progress),
+          toTxObject(tx, machine),
+          toTxObject(tx, permission),
+          toTxString(tx, next_node),
+          toTxString(tx, forward),
+          toTxString(tx, message),
+          tx.object.clock()
+        ]
+      });
+    }
+  }
+}
+async function getMachineNodeForward(env, machine, node, next_node, forward) {
+  const r = await queryTableItem_MachineNode({
+    parent: machine,
+    key: next_node,
+    no_cache: env.no_cache,
+    network: env.network
+  });
+  if (r && r.type === ObjectType.TableItem_MachineNode) {
+    const n = r;
+    const pair = n.value.find((item) => item.prev_node === node);
+    if (pair) {
+      return pair.forwards.find((item) => item.name === forward);
+    }
+  }
+  return void 0;
+}
+export {
+  CallProgress,
+  MAX_CONTEXT_REPOSITORY_COUNT,
+  MAX_NAMED_OPERATOR_ADDRESS_COUNT,
+  MAX_NAMED_OPERATOR_COUNT,
+  accomplish,
+  adminUnhold,
+  context_repository_add,
+  context_repository_clear,
+  context_repository_remove,
+  create,
+  getMachineNodeForward,
+  hold,
+  namedOperator_add,
+  namedOperator_remove,
+  namedOperator_set,
+  newProgress,
+  progressFn,
+  task_set
+};