M4 开发手册

{ "code": "NoSuchRobot", "message": "找不到机器人 '2032'" }

"yyyy-MM-dd'T'HH:mm:ss.SSSXXX",
"yyyy-MM-dd'T'HH:mm:ss.SSSZ",
"yyyy-MM-dd'T'HH:mm:ssX",
"yyyy-MM-dd HH:mm:ss",
"yyyy-MM-dd HH:mm:ss.SSS",
"yyyy-MM-dd HH:mm",
"yyyy-MM-dd",
"yyyy/MM/dd",
"HH:mm:ss"

GET /api/ping

{
  "id": "__admin__",
  "username": "admin",
  "roAdmin": true,
  "permissions": null
}

POST /api/sign-in

{
  "username": "admin",
  "password": "admin"
}

{
    "userId": "__admin__",
    "userToken": "n6F0HgxprbgTvH1AJ95qmQ5H"
}

{
        "type": "Compound",
        "items": [
            {
                "type": "General",
                "field1": "vendor",
                "operator": "Eq",
                "value": "QA0001"
            },
            {
                "type": "General",
                "field1": "status",
                "operator": "In",
                "value": [
                    "Created",
                    "Pending"
                ]
            }
        ]
    }

{ "type": "All" }

{ "type": "Compound", "or": false, "items": [ ... ] }

{
    "type": "General",
    "field1": "vendor",
    "operator": "Eq",
    "value": "QA0001"
}

{
    "type": "General",
    "field1": "createdBy",
    "operator": "CurrentUser"
}

{
    "type": "General",
    "field1": "createdOn",
    "operator": "ThisWeek"
}

{
    "type": "General",
    "field1": "createdOn",
    "operator": "Between",
    "value": [ "2023-01-01", "2023-01-31" ]
}

POST /api/entity/find/page

{
    "entityName": "HumanUser",
    "query": null,
    "pageNo": 1,
    "pageSize": 50,
    "projection": null,
    "sort": [
        "-id"
    ]
}

"projection": ["username", "age"]

"sort": ["-createdOn", "+id"]

{
    "pageNo": 1,
    "pageSize": 50,
    "total": 200,
    "page": [
        {
            "username": "test1",
            "email": null,
            "createdBy": "__admin__",
            "createdOn": 1699804800000,
            "id": "5DB8C406735B40C4A81CB8FCFF8656E8"
        }
    ]
}

POST /api/entity/find/count

{
    "entityName": "HumanUser",
    "query": null
}

{"count":10}

POST /api/entity/find/many

{
    "entityName": "HumanUser",
    "query": null,
    "limit": 10,
    "projection": null,
    "sort": [
        "-id"
    ]
}

[
    {
        "username": "test1",
        "email": null,
        "createdBy": "__admin__",
        "createdOn": 1699804800000,
        "id": "5DB8C406735B40C4A81CB8FCFF8656E8"
    }
]

POST /api/entity/find/one

{
    "entityName": "HumanUser",
    "id": "OKLD2022-01-02-01221",
    "projection": null,
    "sort": [
        "-id"
    ]
}

{
    "entityValue": {
        "username": "test1",
        "email": null,
        "createdBy": "__admin__",
        "createdOn": 1699804800000,
        "id": "5DB8C406735B40C4A81CB8FCFF8656E8"
    }
}

{
    "entityValue": null
}

POST /api/entity/create/one

{
    "entityName": "HumanUser",
    "entityValue": {
        "username": "test2",
        "password": "12345678"
    }
}

{"id":"3524032D91A04700911F55E00BA03294"}

POST /api/entity/create/many

{
    "entityName": "HumanUser",
    "entityValues": [
        {
            "username": "test2",
            "password": "12345678"
        },
        {
            "username": "test3",
            "password": "12345678"
        }
    ]
}

{
    "ids": [
        "3524032D91A04700911F55E00BA03294",
        "3524032D91A04700911F55E00BA03295"
    ]
}

POST /api/entity/update/one

{
    "entityName": "HumanUser",
    "id": "3524032D91A04700911F55E00BA03294",
    "update": {
        "roAdmin": false,
        "btDisabled": false,
    }
}

{"updatedCount":1}

POST /api/entity/update/many

{
    "entityName": "HumanUser",
    "query": {
        "type": "General",
        "field1": "id",
        "operator": "In",
        "value": [
            "5DB8C406735B40C4A81CB8FCFF8656E8",
            "3524032D91A04700911F55E00BA03294"
        ]
    },
    "update": {
        "disabled": true
    }
}

{"updatedCount":2}

POST /api/entity/remove/one

{
    "entityName": "HumanUser",
    "id": "3524032D91A04700911F55E00BA03294"
}

{"removedCount":1}

POST /api/entity/remove/many

{
    "entityName": "HumanUser",
    "query": {
        "type": "General",
        "field1": "id",
        "operator": "In",
        "value": [
            "5DB8C406735B40C4A81CB8FCFF8656E8",
            "3524032D91A04700911F55E00BA03294"
        ]
    }
}

{"removedCount":2}

POST /api/entity/export

{
    "entityName": "HumanUser",
    "fields": [
        "id",
        "username",
        "email",
        "truename"
    ],
    "query": null
}

{"path":"tmp/export1282539A910D42E88AC19FB3B52B8643.xlsx"}

POST /api/files/upload

{
    "originalName": "test.png",
    "size": 7182,
    "path": "upload/202311318/5DAED8FC3BEC498BA42CA36282E1DC0E.png"
}

GET /api/files/get/<path>

GET /api/wcs/mr/fleet/all-all

{
    "id": "AMB-01", // 机器人 ID

    "systemConfig": {}, // 参见“移动机器人系统配置”业务对象
    "runtimeRecord": {}, // 机器人任务状态
    "selfReport": { // 机器人自身报告，可能为 null，表示没收到任何报文
      "error": false, // true 表示与机器人连接故障
      "errorMsg": "", // 故障详情
      "main": {}, // 主要信息
      "rawReport": {}, // 机器人报告原始报文
      "timestamp": 1699200000000 // 收到报告的时间
    },
}

POST /api/wcs/mr/fleet/add-robots

POST /api/wcs/mr/fleet/remove-robots

POST /api/wcs/mr/fleet/update-robot

{
    "id": "AMB-01", // 机器人 ID
    "systemConfig": { ... }, // 参见“移动机器人系统配置”业务对象
}

{
    "id": "AMB-01",
    "systemConfig": {
        "disabled": true
     },
}

POST /api/wcs/plc/modbus/read

{
    "deviceName": "PLC",
    "maxRetry": 1,
    "retryDelay": 1000,
    "commands": [{
         "code": 3,
         "address": 35,
         "qty": 4,
         "slaveId": 0
        }]
    }
}

[
    [1,11111,0,0]
]

POST /api/wcs/plc/modbus/write

{
    "deviceName": "PLC",
    "maxRetry": 1,
    "retryDelay": 1000,
    "commands": [{
         "code": 6,
         "address": 35,
         "slaveId": 0,
         "values":[1]
      }]
}

base.traceContext()

base.traceContext()

base.logDebug(tc, msg)
base.logInfo(tc, msg)
base.logError(tc, msg, err)

base.logDebug(tc, msg)
base.logInfo(tc, msg)
base.logError(tc, msg, err)

base.logInfo(base.traceContext(), "系统已启动")

let value = "你好"; // 声明一个变量 value，并且设置其初始值为“你好”。

function foo() {
    // do something...
};

function add(a, b) {
    return a + b;
};

const myList = [];

const myList = [1, 2, 4];

const myMap = {};

const myMap = { "key1": "value1" };

const jsonObj = { "key1": "value1", "key2": 3, "key3": false };
const jsonStr = base.jsonToString(jsonObj);

const jsonStr = "{\"key1\":\"value1\",\"key2\":3,\"key3\":false}";
const jsonObj = JSON.parse(jsonStr)

utils.isNullOrBlank(str);

utils.isNullOrBlank(null); // 返回值为 true ;

utils.isNullOrBlank(undefined); // 返回值为 true ;

utils.isNullOrBlank(""); // 返回值为 true ;

utils.isNullOrBlank("  "); // 字符串全是空格，返回值为 true ;

utils.isNullOrBlank("你好"); // 返回值为 false ;

utils.substringAfter(str, sep);

utils.substringAfter(null, *);      // 结果为 null

utils.substringAfter("", *) ;       // 结果为  ""

utils.substringAfter(*, null) ;     // 结果为  ""

utils.substringAfter("abc", "a") ;  // 结果为  "bc"

utils.substringAfter("abcba", "b") ; // 结果为  "cba"

utils.substringAfter("abc", "c") ;   // 结果为  ""

utils.substringAfter("abc", "d") ;   // 结果为  ""

utils.substringAfter("abc", "") ;    // 结果为  "abc"

utils.substringBefore(str, sep);

utils.substringBefore(null, *) ;      // 结果为  null

utils.substringBefore("", *) ;        // 结果为  ""

utils.substringBefore("abc", "a") ;   // 结果为  ""

utils.substringBefore("abcba", "b") ; // 结果为  "a"

utils.substringBefore("abc", "c") ;   // 结果为  "ab"

utils.substringBefore("abc", "d") ;   // 结果为  "abc"

utils.substringBefore("abc", "") ;    // 结果为  ""

utils.substringBefore("abc", null) ;  // 结果为  "abc"

utils.anyToInt(v);

utils.anyToInt(1); // 结果为 1

utils.anyToInt("100"); // 结果为 100

utils.anyToInt("+100"); // 结果为 100

utils.anyToInt("-100"); // 结果为 -100

utils.anyToLong(v);

utils.anyToLong(1); // 结果为 1

utils.anyToLong("100"); // 结果为 100

utils.anyToFloat(v);

utils.anyToFloat(1); // 结果为 1.0

utils.anyToFloat("100"); // 结果为 100.0

utils.anyToDouble(v);

utils.anyToDouble(1); // 结果为 1.0

utils.anyToDouble("100"); // 结果为 100.0

utils.anyToDate(v);

utils.anyToDate("2024-03-20");

utils.formatDate(d, format);

const d = new Date();
utils.formatDate(d, "yyyy-MM-dd_HH_mm_ss"); // 输出：2024-06-19_13_11_28

base.setGlobalValue(key, value)

base.setGlobalValue("a", 1)      // 设置缓存变量 a 值是 1

base.setGlobalValue("a", null)   // 移除缓存变量 a

base.getGlobalValue(key)

base.getGlobalValue("a")    // 获取缓存变量 a 值，如果变量 a 不存在返回 null

// projection 指定查询返回字段, 可不指定; 指定查询按 age 字段降序排列，可不指定
// skip 指定查询跳过前 10 条记录，可不指定; 指定查询只返回 5 条记录，可不指定
entity.buildFindOptions(projection, sort, skip, limit)

let option = entity.buildFindOptions(["httpMethod"], ["id DESC"],  10, 5)

entity.findOne(tc, entityName, conditions, findOptions)

 // 需求：查询库位 id 是 LOC-01 的库位
let traceContext = base.traceContext()                             // 创建上下文对象
let conditons = cq.eq("id", "LOC-01")                               // 查询条件
let result = entity.findOne(traceContext, "FbBin", conditons, null)  // 调用查询单条数据方法，如果不存在返回 null, 存在返回结果

 // 需求：查询库位 LOC-01 有货
let traceContext = base.traceContext()
let conditons = cq.and([cq.eq("id", "LOC-01"), cq.eq("occupied", true)])
let result = entity.findOne(traceContext, "FbBin",conditons, null)

entity.findOneById(tc, entityName, conditions, findOptions)

// 需求：根据库位 id 查询库位
let traceContext = base.traceContext()
let result = entity.findOneById(traceContext, "FbBin", "LOC-01", null) // 如果不存在返回 null, 存在返回结果

entity.findMany(tc, entityName, conditions, findOptions)

// 需求：查询所有未占用的库位，并且只返回库位 id
let traceContext = base.traceContext()
let conditons = cq.eq("occupied", false)                           // 构建查询条件
let findOptions = entity.buildFindOptions(["id"], null,  null, null) // 构建结果集控制条件
let result = entity.findMany(traceContext, "FbBin", conditons, findOptions) // 返回结果类型是数组

entity.exists(tc, entityName, conditons)

// 需求：查询库位 LOC-01 是否存在
let traceContext = base.traceContext()
let conditions = cq.idEq("LOC-01")
let num = entity.exists(traceContext, "FbBin", conditions) // true: 符合查询条件 false：不符合查询条件

entity.count(tc, entityName, conditions)

let traceContext = base.traceContext()
let conditons = cq.all()                       // 构建查询条件
let num = entity.count(traceContext, "FbBin", conditons) // 返回数量

// evjson 指要新增列的数据对象 {}
entity.createOne(tc, entityName, evJson, null) // todo keepId 返回id

// 需求：新增库位 id 为 LOC-02 的库位
let traceContext = base.traceContext()
let evJson = {
  "id":"LOC-02"
}
let id = entity.createOne(traceContext, "FbBin", evJson, null)  // 返回 id

//evJsonList 指要新增多个数据对象 [{}]
entity.createMany(tc, entityName, evJsonList, null)  // todo keepId

// 需求：同时新增库位 LOC-03、LOC-04
let traceContext = base.traceContext()
let evJsonList = [{
  "id": "LOC-03"
},
{
  "id": "LOC-04"
}]
let ids = entity.createMany(traceContext, "FbBin", evJsonList, null) // 返回 id 的数组[]

// updateJson 指要更新列的数据对象 {}
entity.updateOne(tc, entityName, conditons, updateJson, null)

// 需求：更新库位 LOC-01 为占用
let traceContext = base.traceContext()
let conditions = cq.idEq("LOC-01")          // 更新的条件
let updateJson = {                          // 更新的字段
  "loadStatus": "Occupied",
  "occupied": true
}
let num = entity.updateOne(traceContext, "FbBin", conditions, updateJson, null) // 返回更新的条数

// updateJson 指要更新列的数据对象 {}  updateOptions 更新条数数量限制
entity.updateMany(tc, entityName, conditions, updateJson, updateOptions)

// 需求：更新所有库位为非占用
let traceContext = base.traceContext()
let conditions = cq.all()                   // 更新的条件
let updateJson = {                          // 更新的字段
  "loadStatus": "Empty",
  "occupied": false
}
let num = entity.updateMany(traceContext, "FbBin", conditions, updateJson, null) // 返回更新的条数

// 需求：随机更新一个库位为非占用
let traceContext = base.traceContext()
let conditions = cq.all()
let updateJson = {                          // 更新的字段
  "loadStatus": "Empty",
  "occupied": false
}
let updateOptions = {                       // 更新条数限制
  "limit": 1
}
let num = entity.updateMany(traceContext, "FbBin", conditions, updateJson, updateOptions) // 返回更新的条数

// id 业务对象实体的id updateJson 指要更新列的数据对象 {}
entity.updateOneById(tc, entityName, id, updateJson, null)

// 根据库位 id 为 LOC-01 将库位更新为占用
let traceContext = base.traceContext()
let updateJson = {                                                               // 更新的字段
  "loadStatus": "Occupied",
  "occupied": true
}
let num = entity.updateOneById(traceContext, "FbBin", "LOC-01", updateJson, null) // 返回更新的条数

entity.clearCacheAll()          // 清空所有业务对象记录的缓存，并不会删除持久化的数据

entity.clearCacheByEntity(entityName) // 清空指定业务对象记录的缓存，并不会删除持久化的数据

entity.removeOne(tc, entityName, conditions, null)

// 需求：
let traceContext = base.traceContext()
let conditions = cq.idEq("LOC-03")                                  // 删除的条件
let num = entity.removeOne(traceContext, "FbBin", conditions, null) // 返回删除的条数

// removeOptions 删除记录数量限制，可不指定
entity.removeMany(tc, entityName, conditions, removeOptions)

// 需求：随机删除一个库位
let traceContext = base.traceContext()
let conditions = cq.all()
let removeOptions = {                       // 限制删除条数
  "limit": 1
}
let num = entity.removeMany(traceContext, "FbBin", conditions, removeOptions) // 返回删除的条数

// 删除所有未占用的库位
let traceContext = base.traceContext()
let conditions = cq.eq("occupied", false)                            // 删除条件
let num = entity.removeMany(traceContext, "FbBin", conditions, null) // 返回删除的条数

entityExt.extBeforeCreating(entityName, func)

entityExt.extAfterCreating(entityName, func)

entityExt.extBeforeUpdating(entityName, func)

entityExt.extAfterUpdating(entityName, func)

entityExt.extBeforeRemoving(entityName, func)

entityExt.extAfterRemoving(entityName, func)

// 需求：库位实体修改之前之后打印一条日志，修改之后打印日志
function boot() {
  entityExt.extBeforeUpdating("FbBin", "binBeforeUpdating");      // 注册实体修改之前事件
  entityExt.extAfterUpdating("FbBin", "binAfterUpdating");        // 注册实体修改之后事件
}
// tc:TraceContext 上下文对象；em:业务对象 ids 业务对象实体 id 集合
function binAfterUpdating(tc, em, ids) {
  if (em.getName() != "FbBin")            // 判断是库位的业务对象
    return;
  base.logInfo(tc, JSON.stringify(ids));
}
function binBeforeUpdating(tc, em, ids) {
  if (em.getName() != "FbBin")
    return;
  base.logInfo(tc, JSON.stringify(ids));
}

// 参数意思是：用功能码 03 去读取 0 地址位，从站 1，最大重试次数是2，重试间隔是 5s
let resMap = {
  "code": 3,                  // 功能码
  "address": 0,               // 开始读取的地址位
  "qty": 1,                   // 读取地址位个数
  "slaveId": 1,               // 从站 id
  "maxRetry": 2,              // 最大重试次数，可不指定
  "retryDelay": 5000          // 重试间隔，可不指定
}

// 参数意思是：用功能码 03 去写入 0 地址位，从站 1，最大重试次数是2，重试间隔是 5s
let writeMap = {
  "code": 3,          // 功能码
  "address": 0,         // 写入地址位
  "slaveId": 1,         // 从站 id
  "maxRetry": 2,        // 最大重试次数，可不指定
  "retryDelay": 5000   // 重试间隔，可不指定
}

plc.modbusRead(tc, deviceName, reqMap)

// 需求：从 0 地址位连续读 3 个地址位
let traceContext = base.traceContext()
let reqMap = {
  "code": 3,
  "address": 0,
  "qty": 3,
  "slaveId": 1,
  "maxRetry": 2,
  "retryDelay": 5000
}
let resPlc = plc.modbusRead(traceContext, "rollPlc", reqMap) // 返回 number[]