feat: 新增规则链中英文配置

+/**
+ *规则链 动作 英文配置文件
+  目前共有22个，分类按名称进行配置
+ */
+export default {
+  assignToCustomer: {
+    name: 'assign to customer',
+    details: `Finds target Customer by customer name pattern and then assign Originator Entity to this customer. Will create new Customer if it doesn't exists and 'Create new Customer if not exists' is set to true.`,
+    description: 'Assign Message Originator Entity to Customer',
+  },
+  clearAlarm: {
+    name: 'clear alarm',
+    details: `Details - JS function that creates JSON object based on incoming message. This object will be added into Alarm.details field.\nNode output:\nIf alarm was not cleared, original message is returned. Otherwise new Message returned with type 'ALARM', Alarm object in 'msg' property and 'metadata' will contains 'isClearedAlarm' property. Message payload can be accessed via <code>msg</code> property. For example <code>'temperature = ' + msg.temperature ;</code>. Message metadata can be accessed via <code>metadata</code> property. For example <code>'name = ' + metadata.customerName;</code>.`,
+    description: 'Clear Alarm',
+  },
+  copyToView: {
+    name: 'copy to view',
+    details: `Copy attributes from asset/device to related entity view according to entity view configuration. \n Copy will be done only for attributes that are between start and end dates and according to attribute keys configuration. \nChanges message originator to related entity view and produces new messages according to count of updated entity views`,
+    description:
+      'Copy attributes from asset/device to entity view and changes message originator to related entity view',
+  },
+  createAlarm: {
+    name: 'create alarm',
+    details: `Details - JS function that creates JSON object based on incoming message. This object will be added into Alarm.details field.\nNode output:\nIf alarm was not created, original message is returned. Otherwise new Message returned with type 'ALARM', Alarm object in 'msg' property and 'metadata' will contains one of those properties 'isNewAlarm/isExistingAlarm'. Message payload can be accessed via <code>msg</code> property. For example <code>'temperature = ' + msg.temperature ;</code>. Message metadata can be accessed via <code>metadata</code> property. For example <code>'name = ' + metadata.customerName;</code>.`,
+    description: 'Create or Update Alarm',
+  },
+  createRelation: {
+    name: 'create relation',
+    details: `If the relation already exists or successfully created -  Message send via <b>Success</b> chain, otherwise <b>Failure</b> chain will be used.`,
+    description: `Finds target Entity by entity name pattern and (entity type pattern for Asset, Device) and then create a relation to Originator Entity by type and direction. If Selected entity type: Asset, Device or Customer will create new Entity if it doesn't exist and selected checkbox 'Create new entity if not exists'.<br> In case that relation from the message originator to the selected entity not exist and  If selected checkbox 'Remove current relations', before creating the new relation all existed relations to message originator by type and direction will be removed.<br> If relation from the message originator to the selected entity created and If selected checkbox 'Change originator to related entity', outbound message will be processed as a message from this entity.`,
+  },
+  deleteRelation: {
+    name: 'delete relation',
+    details: `If the relation(s) successfully deleted -  Message send via <b>Success</b> chain, otherwise <b>Failure</b> chain will be used.`,
+    description: `Finds target Entity by entity name pattern and then delete a relation to Originator Entity by type and direction if 'Delete single entity' is set to true, otherwise rule node will delete all relations to the originator of the message by type and direction.`,
+  },
+  delay: {
+    name: 'delay (deprecated)',
+    details: `Delays messages for a configurable period. Please note, this node acknowledges the message from the current queue (message will be removed from queue). Deprecated because the acknowledged message still stays in memory (to be delayed) and this does not guarantee that message will be processed even if the "retry failures and timeouts" processing strategy will be chosen.`,
+    description: `Delays incoming message (deprecated)`,
+  },
+  deviceProfile: {
+    name: 'device profile',
+    details: `Create and clear alarms based on alarm rules defined in device profile. The output relation type is either 'Alarm Created', 'Alarm Updated', 'Alarm Severity Updated' and 'Alarm Cleared' or simply 'Success' if no alarms were affected.`,
+    description: `Process device messages based on device profile settings`,
+  },
+  generator: {
+    name: 'generator',
+    details: `Generates messages with configurable period. Javascript function used for message generation.`,
+    description: `Periodically generates messages`,
+  },
+  gpsGeofencingEvents: {
+    name: 'gps geofencing events',
+    details: `Extracts latitude and longitude parameters from incoming message and returns different events based on configuration parameters`,
+    description: `Produces incoming messages using GPS based geofencing`,
+  },
+  log: {
+    name: 'log',
+    details: `Transform incoming Message with configured JS function to String and log final value into Thingsboard log file. Message payload can be accessed via <code>msg</code> property. For example <code>'temperature = ' + msg.temperature ;</code>. Message metadata can be accessed via <code>metadata</code> property. For example <code>'name = ' + metadata.customerName;</code>.`,
+    description: `Log incoming messages using JS script for transformation Message into String`,
+  },
+  messageCount: {
+    name: 'message count',
+    details: `Count incoming messages for specified interval and produces POST_TELEMETRY_REQUEST msg with messages count`,
+    description: `Count incoming messages`,
+  },
+  pushToEdge: {
+    name: 'push to edge',
+    details: `Push messages from cloud to edge. Message originator must be assigned to particular edge or message originator is <b>EDGE</b> entity itself. This node used only on cloud instances to push messages from cloud to edge. Once message arrived into this node it’s going to be converted into edge event and saved to the database. Node doesn't push messages directly to edge, but stores event(s) in the edge queue. <br>Supports next originator types:<br><code>DEVICE</code><br><code>ASSET</code><br><code>ENTITY_VIEW</code><br><code>DASHBOARD</code><br><code>TENANT</code><br><code>CUSTOMER</code><br><code>EDGE</code><br><br>As well node supports next message types:<br><code>POST_TELEMETRY_REQUEST</code><br><code>POST_ATTRIBUTES_REQUEST</code><br><code>ATTRIBUTES_UPDATED</code><br><code>ATTRIBUTES_DELETED</code><br><code>ALARM</code><br><br>Message will be routed via <b>Failure</b> route if node was not able to save edge event to database or unsupported originator type/message type arrived. In case successful storage edge event to database message will be routed via <b>Success</b> route.`,
+    description: `Push messages from cloud to edge`,
+  },
+  rpcCallReply: {
+    name: 'rpc call reply',
+    details: `Expects messages with any message type. Will forward message body to the device.`,
+    description: `Sends reply to RPC call from device`,
+  },
+  rpcCallRequest: {
+    name: 'rpc call request',
+    details: `Expects messages with "method" and "params". Will forward response from device to next nodes.If the RPC call request is originated by REST API call from user, will forward the response to user immediately.`,
+    description: `Sends RPC call to device`,
+  },
+  saveAttributes: {
+    name: 'save attributes',
+    details: `Saves entity attributes based on configurable scope parameter. Expects messages with 'POST_ATTRIBUTES_REQUEST' message type`,
+    description: `Saves attributes data`,
+  },
+  saveEvent: {
+    name: 'save event',
+    details: `Saves entity event . Expects messages with 'POST_EVENT_REQUEST' message type`,
+    description: `Saves device event data`,
+  },
+  saveTimeseries: {
+    name: 'save timeseries',
+    details: `Saves timeseries telemetry data based on configurable TTL parameter. Expects messages with 'POST_TELEMETRY_REQUEST' message type. Timestamp in milliseconds will be taken from metadata.ts, otherwise 'now' message timestamp will be applied. Allows stopping updating values for incoming keys in the latest ts_kv table if 'skipLatestPersistence' is set to true.\n <br/>Enable 'useServerTs' param to use the timestamp of the message processing instead of the timestamp from the message. Useful for all sorts of sequential processing if you merge messages from multiple sources (devices, assets, etc).\n<br/>In the case of sequential processing, the platform guarantees that the messages are processed in the order of their submission to the queue. However, the timestamp of the messages originated by multiple devices/servers may be unsynchronized long before they are pushed to the queue. The DB layer has certain optimizations to ignore the updates of the \"attributes\" and \"latest values\" tables if the new record has a timestamp that is older than the previous record. So, to make sure that all the messages will be processed correctly, one should enable this parameter for sequential message processing scenarios.`,
+    description: `Saves timeseries data`,
+  },
+  saveToCustomTable: {
+    name: 'save to custom table',
+    details: `Administrator should set the custom table name without prefix: <b>cs_tb_</b>. <br>Administrator can configure the mapping between the Message field names and Table columns name.<br><b>Note:</b>If the mapping key is <b>$entity_id</b>, that is identified by the Message Originator, then to the appropriate column name(mapping value) will be write the message originator id.<br><br>If specified message field does not exist or is not a JSON Primitive, the outbound message will be routed via <b>failure</b> chain, otherwise, the message will be routed via <b>success</b> chain.`,
+    description: `Node stores data from incoming Message payload to the Cassandra database into the predefined custom table that should have <b>cs_tb_</b> prefix, to avoid the data insertion to the common TB tables.<br><b>Note:</b> rule node can be used only for Cassandra DB.`,
+  },
+  synchronizationEnd: {
+    name: 'synchronization end',
+    details: ``,
+    description: `This Node is now deprecated. Use "Checkpoint" instead.`,
+  },
+  synchronizationStart: {
+    name: 'synchronization start',
+    details: `This node should be used together with "synchronization end" node. \n This node will put messages into queue based on message originator id. \nSubsequent messages will not be processed until the previous message processing is completed or timeout event occurs.\nSize of the queue per originator and timeout values are configurable on a system level`,
+    description: `This Node is now deprecated. Use "Checkpoint" instead.`,
+  },
+  unassigFromCustomer: {
+    name: 'unassign from customer',
+    details: `Finds target Entity Customer by Customer name pattern and then unassign Originator Entity from this customer.`,
+    description: `Unassign Message Originator Entity from Customer`,
+  },
+};

+/**
+ *规则链 外部的 英文配置文件
+  目前共有11个，分类按名称进行配置
+ */
+export default {
+  alarmNotice: {
+    name: 'alarm notice',
+    details: `notice method include sms,email and so on.`,
+    description: 'while device alarm, notice some people.',
+  },
+  awsSns: {
+    name: 'aws sns',
+    details: `Will publish message payload to the AWS SNS topic. Outbound message will contain response fields (<code>messageId</code>, <code>requestId</code>) in the Message Metadata from the AWS SNS. For example <b>requestId</b> field can be accessed with <code>metadata.requestId</code>.`,
+    description: 'Publish message to the AWS SNS',
+  },
+  awsSqs: {
+    name: 'aws sqs',
+    details: `Will publish message payload and metadata attributes to the AWS SQS queue. Outbound message will contain response fields (<code>messageId</code>, <code>requestId</code>, <code>messageBodyMd5</code>, <code>messageAttributesMd5</code>, <code>sequenceNumber</code>) in the Message Metadata from the AWS SQS. For example <b>requestId</b> field can be accessed with <code>metadata.requestId</code>.`,
+    description: 'Publish messages to the AWS SQS',
+  },
+  azureIotHub: {
+    name: 'azure iot hub',
+    details: `Will publish message payload to the Azure IoT Hub with QoS <b>AT_LEAST_ONCE</b>.`,
+    description: 'Publish messages to the Azure IoT Hub',
+  },
+  gcpPubsub: {
+    name: 'gcp pubsub',
+    details: `Will publish message payload to the Google Cloud Platform PubSub topic. Outbound message will contain response fields (<code>messageId</code> in the Message Metadata from the GCP PubSub. <b>messageId</b> field can be accessed with <code>metadata.messageId</code>.`,
+    description: 'Publish message to the Google Cloud PubSub',
+  },
+  kafka: {
+    name: 'kafka',
+    details: `Will send record via Kafka producer to Kafka server. Outbound message will contain response fields (<code>offset</code>, <code>partition</code>, <code>topic</code>) from the Kafka in the Message Metadata. For example <b>partition</b> field can be accessed with <code>metadata.partition</code>.`,
+    description: 'Publish messages to Kafka server',
+  },
+  mqtt: {
+    name: 'mqtt',
+    details: `Will publish message payload to the MQTT broker with QoS <b>AT_LEAST_ONCE</b>.`,
+    description: 'Publish messages to the MQTT broker',
+  },
+  rabbitmq: {
+    name: 'rabbitmq',
+    details: `Will publish message payload to RabbitMQ queue.`,
+    description: 'Publish messages to the RabbitMQ',
+  },
+  restApiCall: {
+    name: 'rest api call',
+    details: `Will invoke REST API call <code>GET | POST | PUT | DELETE</code> to external REST server. Message payload added into Request body. Configured attributes can be added into Headers from Message Metadata. Outbound message will contain response fields (<code>status</code>, <code>statusCode</code>, <code>statusReason</code> and response <code>headers</code>) in the Message Metadata. Response body saved in outbound Message payload. For example <b>statusCode</b> field can be accessed with <code>metadata.statusCode</code>.<br/><b>Note-</b> if you use system proxy properties, the next system proxy properties should be added: "http.proxyHost" and "http.proxyPort" or  "https.proxyHost" and "https.proxyPort" or "socksProxyHost" and "socksProxyPort",and if your proxy with auth, the next ones  should be added: "tb.proxy.user" and "tb.proxy.password" to the thingsboard.conf file.`,
+    description: 'Invoke REST API calls to external REST server',
+  },
+  sendEmail: {
+    name: 'send email',
+    details: `Expects messages with <b>SEND_EMAIL</b> type. Node works only with messages that  where created using <code>to Email</code> transformation Node, please connect this Node with <code>to Email</code> Node using <code>Successful</code> chain.`,
+    description: 'Sends email message via SMTP server.',
+  },
+  sendSms: {
+    name: 'send sms',
+    details: `Will send SMS message by populating target phone numbers and sms message fields using values derived from message metadata.`,
+    description: 'Sends SMS message via SMS provider.',
+  },
+};

+/**
+ *规则链 Flow 英文配置文件
+  目前共有4个，分类按名称进行配置
+ */
+export default {
+  acknowledge: {
+    name: 'acknowledge',
+    details: `After acknowledgement, the message is pushed to related rule nodes. Useful if you don't care what happens to this message next.`,
+    description: 'Acknowledges the incoming message',
+  },
+  checkpoint: {
+    name: 'checkpoint',
+    details: `After successful transfer incoming message is automatically acknowledged. Queue name is configurable.`,
+    description: 'transfers the message to another queue',
+  },
+  output: {
+    name: 'output',
+    details: `Produces output of the rule chain processing. The output is forwarded to the caller rule chain, as an output of the corresponding "input" rule node. The output rule node name corresponds to the relation type of the output message, and it is used to forward messages to other rule nodes in the caller rule chain. `,
+    description: 'transfers the message to the caller rule chain',
+  },
+  ruleChain: {
+    name: 'rule chain',
+    details: `Allows to nest the rule chain similar to single rule node. The incoming message is forwarded to the input node of the specified target rule chain. The target rule chain may produce multiple labeled outputs. You may use the outputs to forward the results of processing to other rule nodes.`,
+    description: 'transfers the message to another rule chain',
+  },
+};

+/**
+ *规则链 变换 英文配置文件
+  目前共有3个，分类按名称进行配置
+ */
+export default {
+  changeOriginator: {
+    name: 'change originator',
+    details: `Related Entity found using configured relation direction and Relation Type. If multiple Related Entities are found, only first Entity is used as new Originator, other entities are discarded.<br/>Alarm Originator found only in case original Originator is <code>Alarm</code> entity.`,
+    description: 'Change Message Originator To Tenant/Customer/Related Entity/Alarm Originator',
+  },
+  script: {
+    name: 'script',
+    details: `JavaScript function receive 3 input parameters <br/> <code>metadata</code> - is a Message metadata.<br/><code>msg</code> - is a Message payload.<br/><code>msgType</code> - is a Message type.<br/>Should return the following structure:<br/><code>{ msg: <i style="color: #666;">new payload</i>,<br/>&nbsp&nbsp&nbspmetadata: <i style="color: #666;">new metadata</i>,<br/>&nbsp&nbsp&nbspmsgType: <i style="color: #666;">new msgType</i> }</code><br/>All fields in resulting object are optional and will be taken from original message if not specified.`,
+    description: 'Change Message payload, Metadata or Message type using JavaScript',
+  },
+  toEmail: {
+    name: 'to email',
+    details: `Transforms message to email message by populating email fields using values derived from message metadata. Set 'SEND_EMAIL' output message type.`,
+    description: 'Transforms message to email message',
+  },
+};

+/**
+ *规则链 动作 中文配置文件
+  目前共有22个，分类按名称进行配置
+ */
+export default {
+  assignToCustomer: {
+    name: '分配给客户',
+    details: `按客户名称模式查找目标客户，然后将发起者实体分配给该客户。如果不存在将创建新客户，并且【如果不存在则创建新客户]设置为true。`,
+    description: '将消息发起人实体分配给客户',
+  },
+  clearAlarm: {
+    name: '清除告警',
+    details: `详情-基于传入消息创建JSON对象的JS函数。该对象将被添加到Alarm.details字段中。节点输出：如果告警未被清除，则返回原始消息。否则，返回类型为【告警】新消息【msg】属性和【metadata】中的告警对象将包含【isClearedAlarm】属性。可以通过【msg】属性访问消息负载。例如'temperature='+msg.temperature。也可以通过【metadata】属性访问消息元数据。例如'name='+metadata.customerName。`,
+    description: '清除告警',
+  },
+  copyToView: {
+    name: '复制到视图',
+    details: `根据实体视图配置，将属性从资产/设备复制到相关的实体视图。复制将仅针对开始日期和结束日期之间的属性，并根据属性键进行配置。将消息发起者更改为相关的实体视图，并根据更新的实体视图的计数生成新消息。`,
+    description: '将属性从资产/设备复制到实体视图，并将消息发起者更改为相关实体视图。',
+  },
+  createAlarm: {
+    name: '创建告警',
+    details: `详情-基于传入消息创建JSON对象的JS函数。该对象将被添加到Alarm.details字段中。节点输出：如果告警未被创建，则返回原始消息。否则，返回类型为【告警】的新消息，【msg】属性和【metadata】中的告警对象将包含其中一个属性【isNewAlarm/isExistingAlarm】。可以通过【msg】属性访问消息负载。例如'temperature='+msg.temperature。可以通过【metadata】属性访问消息元数据。例如'name='+metadata.customerName。`,
+    description: '创建或更新告警。',
+  },
+  createRelation: {
+    name: '创建关联关系',
+    details: `如果关系已存在或已成功创建；通过Success链发送消息，否则将使用Failure链路。`,
+    description: `按实体名称模式和（资产、设备的实体类型模式）查找目标实体，然后按类型和方向创建与发起人实体的关系。如果所选实体类型：资产、设备或客户将创建新实体（如果不存在），并选中【创建新实体】；如果从邮件发起人到所选实体的关系不存在，并且选中【删除当前关系】，则在创建新关系之前，将删除按类型和方向与邮件发起人的所有现有关系；如果创建了从邮件发件人到所选实体的关系，并且选中了【将发件人更改为相关实体】，则出站邮件将作为来自该实体的邮件进行处理。`,
+  },
+  deleteRelation: {
+    name: '删除关联关系',
+    details: `如果成功删除关系；通过则走Success链发送消息，否则将使用Failure链。`,
+    description: `如果“删除单个实体”设置为true，则按实体名称模式查找目标实体，然后按类型和方向删除与发起者实体的关系，否则规则节点将按类型和顺序，删除与消息发起人的所有关系。`,
+  },
+  delay: {
+    name: '延迟（已弃用）',
+    details: `为消息传输配置一段时间的延迟。请注意，此节点确认当前队列中的消息（消息将从队列中删除）。不推荐，因为已确认的消息仍保留在内存中（待延迟），并且即使选择了【重试失败和超时】处理策略，也不能保证消息得到处理。`,
+    description: `延迟传入消息（已弃用）`,
+  },
+  deviceProfile: {
+    name: '设备配置',
+    details: `根据设备配置文件中定义的告警规则，创建和清除报警。输出关联类型为【告警创建】、【告警更新】、【告警严重性更新】和【告警已清除】，如果没有告警受到影响，则仅为【成功】。`,
+    description: `根据设备配置文件处理设备消息。`,
+  },
+  generator: {
+    name: '生成器',
+    details: `生成具有可配置周期的消息。用于生成消息的Javascript函数。`,
+    description: `定期生成消息。`,
+  },
+  gpsGeofencingEvents: {
+    name: 'GPS地理围栏事件',
+    details: `从传入消息中提取纬度和经度参数，并根据配置参数返回不同的事件。`,
+    description: `使用基于GPS的地理围栏生成传入消息。`,
+  },
+  log: {
+    name: '日志',
+    details: `将配置JS函数的传入Message转换为String，并将最终值记录到平台日志文件中。可以通过msg属性访问消息负载。例如temperature= +msg.temperature。可以通过metadata属性访问消息元数据。例如name= +metadata.customerName。`,
+    description: `使用JS脚本记录传入消息，将Message转换为String。`,
+  },
+  messageCount: {
+    name: '消息计数',
+    details: `对指定间隔内的传入消息进行计数，并生成具有消息计数的POST_ELEMETRY_REQUEST消息。`,
+    description: `统计传入消息。`,
+  },
+  pushToEdge: {
+    name: '推送消息到边缘端',
+    details: `将消息从云端推送到边缘。消息发起者必须分配给指定边缘，或者消息发起方是边缘实体本身。此节点仅在云实例上用于将消息从云推送到边缘。一旦消息到达该节点，它将被转换为边缘事件并保存到数据库中。节点不直接将消息推送到边缘，而是将事件存储在边缘队列中；支持下一个发起方类型：DEVICE/ASSET/ENTITY_VIEW/DASHBOARD/TENANT/CUSTOMER/EDGE；节点也支持下一条消息类型：POST_ELEMETRY_REQUEST/POST_ATTRIBUTES_REQUEST/ATTRIBUTES_UPDATED/ATTRIBUTES_DELETED/ALARM；如果节点无法将边缘事件保存到数据库或到达了不受支持的发起者类型/消息类型，则消息将通过Failure进行路由。在成功存储边缘事件到数据库的情况下，消息将通过Success进行路由。`,
+    description: `将消息从云端推送到边缘端。`,
+  },
+  rpcCallReply: {
+    name: 'rpc请求回复',
+    details: `应为任何消息类型的消息。将消息正文转发到设备。`,
+    description: `从设备发送对RPC调用的答复。`,
+  },
+  rpcCallRequest: {
+    name: 'RPC调用请求',
+    details: `带有method和params的消息，将响应从设备转发到下一个节点。如果RPC调用请求是由用户的REST API调用发起的，则会立即将响应转发给用户。`,
+    description: `将RPC调用发送到设备。`,
+  },
+  saveAttributes: {
+    name: '保存属性',
+    details: `根据可配置的作用域参数保存实体属性。消息类型为POST_ATTRIBUTES_REQUEST的消息`,
+    description: `保存属性数据。`,
+  },
+  saveEvent: {
+    name: '保存事件',
+    details: `保存实体事件，消息类型为POST_EVENT_REQUEST的消息。`,
+    description: `保存设备事件数据。`,
+  },
+  saveTimeseries: {
+    name: '保存时序数据',
+    details: `根据可配置的TTL参数保存时序遥测数据，消息类型为POST_TELEMETRY_REQUEST的消息。时间戳（以毫秒为单位）将取自元数据时间戳，否则将应用现在消息时间戳，如果skipLatestPersistence设置为true，则允许停止更新最新ts_kv表中传入键的值。启用【useServerTs】参数以使用消息处理的时间戳，而不是消息中的时间戳。如果合并的消息来自多种类型（设备、资产等）的消息，则对各种顺序处理都很有用。在顺序处理的情况下，平台保证消息按照提交到队列的顺序进行处理。然而，由多个设备/服务器发起的消息的时间戳可能早在它们被推送到队列之前就不同步了。如果新记录的时间戳比以前的记录旧，则DB层具有某些优化，可以忽略“属性”和“最新值”表的更新。因此，为了确保所有消息都得到正确处理，应该为顺序消息处理场景启用此参数。`,
+    description: `保存时序数据。`,
+  },
+  saveToCustomTable: {
+    name: '保存到自定义表',
+    details: `管理员应设置不带前缀的自定义表名：【cs_tb_】，管理员可以配置消息字段名称和Table列名称之间的映射；注意：如果映射键为【$entity_id】；由消息发起人标识，然后到适当的列名（映射值）将写入消息发起人id。如果指定的消息字段不存在或不是标准JSON，出站消息将通过failure链路；否则，消息将通过success链进行。`,
+    description: `节点将来自Cassandra数据库的传入Message有效负载的数据，存储到预定义的自定义表中，该表应以cs_tb_为前缀，以避免数据插入到公共tb表中。注意：规则节点只能用于Cassandra DB。`,
+  },
+  synchronizationEnd: {
+    name: '同步结束',
+    details: ``,
+    description: `此节点现在已弃用。请改用“检查数据点”。`,
+  },
+  synchronizationStart: {
+    name: '同步启动',
+    details: `此节点应与“同步结束”节点一起使用。此节点将根据消息发起方id将消息放入队列。在上一条消息处理完成或发生超时事件之前，不会处理后续消息。每个发起方的队列大小和超时值可在系统级别进行配置。`,
+    description: `此节点现在已弃用。请改用【检查数据点】。`,
+  },
+  unassigFromCustomer: {
+    name: '从客户取消分配',
+    details: `按客户端名称模式查找目标实体客户，然后取消分配该客户的发起者实体。.`,
+    description: `从客户取消分配消息发起者实体。`,
+  },
+};

@@ -49,8 +49,8 @@ export default {
     description: '将发起者租户属性或最新遥测添加到消息元数据中。',
   },
   tenantDetails: {
-    name: '租户属性',
-    details: `如果配置了单个/多个属性，则会将服务器范围属性添加到消息元数据中。如果配置了单个/多个“最新遥测”，则将最新遥测添加到元数据中。要访问其他节点中的这些属性，可以使用metadata.temperature。`,
-    description: '将发起者租户属性或最新遥测添加到消息元数据中。',
+    name: '租户详细信息',
+    details: `如果选中：【将选定的详细信息添加到消息元数据】，则现有字段将添加到消息元数据而不是消息数据；注意：只允许设备、资产和实体视图类型；如果原始的消息发件人未分配给Tenant或者不支持原始发件人类型，消息将转发到失败链，否则将使用成功链路。`,
+    description: '将租户详细信息中的字段添加到消息正文或元数据中。',
   },
 };

+/**
+ *规则链 外部的 中文配置文件
+  目前共有11个，分类按名称进行配置
+ */
+export default {
+  alarmNotice: {
+    name: '告警通知',
+    details: `通知方式包括短信、电子邮件等。`,
+    description: '当设备产生告警时，通知联系人。',
+  },
+  awsSns: {
+    name: 'AWS SNS',
+    details: `将向AWS SNS主题发布消息有效载荷；出站消息将在AWS SNS的消息元数据中包含响应字段（messageId、requestId），例如requestId字段可以使用Metadata.requestId访问。`,
+    description: '将消息发布到AWS SNS。',
+  },
+  awsSqs: {
+    name: 'AWS SQS',
+    details: `将向AWS SQS队列发布消息有效负载和元数据属性。出站消息将在AWS SQS的消息元数据中包含响应字段（messageId、requestId、messageBodyMd5、messageAttributesMd5、sequenceNumber）。例如requestId字段可以使用Metadata.requestId访问。`,
+    description: '向AWS SQS发布消息。',
+  },
+  azureIotHub: {
+    name: 'Azure物联网中心',
+    details: `将消息有效负载发布到Azure物联网中心，使用QoS的条件至少一次。`,
+    description: '将消息发布到Azure物联网中心。',
+  },
+  gcpPubsub: {
+    name: 'GCP pubsub',
+    details: `将向Google Cloud Platform PubSub主题发布消息负载。出站消息将包含响应字段（GCP PubSub的消息元数据中的messageId字段可以通过Metadata.messageId访问）。`,
+    description: '将消息发布到Google Cloud PubSub。',
+  },
+  kafka: {
+    name: 'Kafka',
+    details: `将通过Kafka生产记录发送到Kafka服务器。出站消息将包含来自消息元数据中Kafka的响应字段(offset、partition和topic)。例如，partition字段可以通过metadata.partition访问。`,
+    description: '将消息发布到Kafka服务器。',
+  },
+  mqtt: {
+    name: 'MQTT',
+    details: `将消息有效负载发布到MQTT代理，使用QoS的条件至少一次。`,
+    description: '将消息发布到MQTT代理。',
+  },
+  rabbitmq: {
+    name: 'RabbitMQ',
+    details: `将向RabbitMQ队列发布消息负载。`,
+    description: '将消息发布到RabbitMQ。',
+  },
+  restApiCall: {
+    name: 'rest_api调用',
+    details: `将调用REST-API调用GET|POST|PUT|DELETE到外部REST服务器。已将消息有效负载添加到请求正文中。配置的属性可以从消息元数据添加到标头中。出站消息将在消息元数据中包含响应字段（status、statusCode和响应headers）。响应正文保存在出站消息负载中。例如，可以使用metadata.statusCode访问statusCode字段。注意：如果使用系统代理属性，则应添加下一个系统代理属性：“http.proxyHost”和“http.prroxyPort”或“https.proxyHost”和“https.prroxyPort”，接下来的两个应该添加到thingsbard.conf文件中：“tb.proxy.user”和“tb.prroxy.password”。`,
+    description: '调用对外部REST服务器的REST_API',
+  },
+  sendEmail: {
+    name: '发送邮件',
+    details: `应为SEND_EMAIL类型的邮件。节点仅适用于使用to Email转换节点创建的消息，请使用Successful链将与to Email节点一起使用。`,
+    description: '通过SMTP服务器发送电子邮件。',
+  },
+  sendSms: {
+    name: '发送短信',
+    details: `将通过使用从消息元数据派生的值填充目标电话号码和短信字段来发送短信。`,
+    description: '通过短信提供商发送短信。',
+  },
+};

+/**
+ *规则链 Flow 中文配置文件
+  目前共有4个，分类按名称进行配置
+ */
+export default {
+  acknowledge: {
+    name: '确认消息',
+    details: `在确认之后，消息被推送到相关的规则节点。如果你不需要这条消息，接下来会发生什么，这很有用。`,
+    description: '确认传入消息。',
+  },
+  checkpoint: {
+    name: '检查数据点',
+    details: `成功传输后，自动确认收到消息。队列名称是可配置的。`,
+    description: '将消息转移到另一个队列。',
+  },
+  output: {
+    name: '输出',
+    details: `产生规则链处理的输出。输出作为相应的“输入”规则节点的输出转发给调用者规则链。输出规则节点名称对应于输出消息的关系类型，用于将消息转发给调用者规则链中的其他规则节点。`,
+    description: '将消息传递给呼叫者规则链。',
+  },
+  ruleChain: {
+    name: '规则链',
+    details: `允许嵌套规则链，类似于单个规则节点。传入消息被转发到指定目标规则链的输入节点。目标规则链可能会产生多个标记的输出。您可以使用输出将处理结果转发给其他规则节点。`,
+    description: '将消息传递到另一个规则链。',
+  },
+};

+/**
+ *规则链 变换 中文配置文件
+  目前共有3个，分类按名称进行配置
+ */
+export default {
+  changeOriginator: {
+    name: '变更发起者',
+    details: `使用配置的关联方向和关联类型找到相关实体；若发现多个关联实体，则只有第一个实体被用作新的发起者，其他实体被丢弃；只有在原始发起者是Alarm实体的情况下才能找到告警联系人。`,
+    description: '将消息发起者更改为租户/客户/相关实体/警报发起者。',
+  },
+  script: {
+    name: 'JS脚本',
+    details: `JavaScript函数接收3个输入参数：- metadata：一条消息的元数据；- msg：一条消息的有效负载；- msgType：一条消息的类型。应返回以下结构：{ msg: new payload,<br/> metadata: new metadata,<br/>msgType: new msgType }；结果对象中的所有字段都是可选的，如果没有指定，将使用原始消息中的字段。`,
+    description: '使用JavaScript更改消息有效负载、元数据或消息类型。',
+  },
+  toEmail: {
+    name: '发送到电子邮件',
+    details: `通过使用从元数据派生的值填充电子邮件字段，将消息转换为电子邮件内容并发送。设置SEND_EMAIL输出消息类型。`,
+    description: '将消息转换为电子邮件内容并发送。',
+  },
+};

@@ -2,9 +2,11 @@ import { ActionCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(ActionCategoryComponentEnum.ASSIGN_TO_CUSTOMER);
 
+const { t } = useI18n(); //加载国际化
 export interface AssignToCustomerDataType {
   someConfiguration?: Recordable;
 }
@@ -13,12 +15,11 @@ export const AssignToCustomerConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.action.TbAssignToCustomerNode',
   categoryType: RuleNodeTypeEnum.ACTION,
-  name: 'assign to customer',
+  name: t('actions.index.assignToCustomer.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details:
-        "Finds target Customer by customer name pattern and then assign Originator Entity to this customer. Will create new Customer if it doesn't exists and 'Create new Customer if not exists' is set to true.",
-      description: 'Assign Message Originator Entity to Customer',
+      details: t('actions.index.assignToCustomer.details'),
+      description: t('actions.index.assignToCustomer.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: ['Success', 'Failure'],

@@ -2,9 +2,11 @@ import { ActionCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(ActionCategoryComponentEnum.CLEAR_ALARM);
 
+const { t } = useI18n(); //加载国际化
 export interface ClearAlarmDataType {
   someConfiguration?: Recordable;
 }
@@ -13,12 +15,11 @@ export const ClearAlarmConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.action.TbClearAlarmNode',
   categoryType: RuleNodeTypeEnum.ACTION,
-  name: 'clear alarm',
+  name: t('actions.index.clearAlarm.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details:
-        "Details - JS function that creates JSON object based on incoming message. This object will be added into Alarm.details field.\nNode output:\nIf alarm was not cleared, original message is returned. Otherwise new Message returned with type 'ALARM', Alarm object in 'msg' property and 'metadata' will contains 'isClearedAlarm' property. Message payload can be accessed via <code>msg</code> property. For example <code>'temperature = ' + msg.temperature ;</code>. Message metadata can be accessed via <code>metadata</code> property. For example <code>'name = ' + metadata.customerName;</code>.",
-      description: 'Clear Alarm',
+      details: t('actions.index.clearAlarm.details'),
+      description: t('actions.index.clearAlarm.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: ['Cleared', 'False', 'Failure'],

@@ -2,9 +2,11 @@ import { ActionCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(ActionCategoryComponentEnum.COPY_TO_VIEW);
 
+const { t } = useI18n(); //加载国际化
 export interface CopyToViewDataType {
   someConfiguration?: Recordable;
 }
@@ -13,13 +15,11 @@ export const CopyToViewConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.action.TbCopyAttributesToEntityViewNode',
   categoryType: RuleNodeTypeEnum.ACTION,
-  name: 'copy to view',
+  name: t('actions.index.copyToView.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details:
-        'Copy attributes from asset/device to related entity view according to entity view configuration. \n Copy will be done only for attributes that are between start and end dates and according to attribute keys configuration. \nChanges message originator to related entity view and produces new messages according to count of updated entity views',
-      description:
-        'Copy attributes from asset/device to entity view and changes message originator to related entity view',
+      details: t('actions.index.copyToView.details'),
+      description: t('actions.index.copyToView.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: ['Success', 'Failure'],

@@ -2,9 +2,11 @@ import { ActionCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(ActionCategoryComponentEnum.CREATE_ALARM);
 
+const { t } = useI18n(); //加载国际化
 export interface CreateAlarmDataType {
   someConfiguration?: Recordable;
 }
@@ -13,12 +15,11 @@ export const CreateAlarmConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.action.TbCreateAlarmNode',
   categoryType: RuleNodeTypeEnum.ACTION,
-  name: 'create alarm',
+  name: t('actions.index.createAlarm.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details:
-        "Details - JS function that creates JSON object based on incoming message. This object will be added into Alarm.details field.\nNode output:\nIf alarm was not created, original message is returned. Otherwise new Message returned with type 'ALARM', Alarm object in 'msg' property and 'metadata' will contains one of those properties 'isNewAlarm/isExistingAlarm'. Message payload can be accessed via <code>msg</code> property. For example <code>'temperature = ' + msg.temperature ;</code>. Message metadata can be accessed via <code>metadata</code> property. For example <code>'name = ' + metadata.customerName;</code>.",
-      description: 'Create or Update Alarm',
+      details: t('actions.index.createAlarm.details'),
+      description: t('actions.index.createAlarm.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: ['Created', 'Updated', 'False', 'Failure'],

@@ -2,9 +2,11 @@ import { ActionCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(ActionCategoryComponentEnum.CREATE_RELATION);
 
+const { t } = useI18n(); //加载国际化
 export interface CreateRelationDataType {
   someConfiguration?: Recordable;
 }
@@ -13,13 +15,11 @@ export const CreateRelationConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.action.TbCreateRelationNode',
   categoryType: RuleNodeTypeEnum.ACTION,
-  name: 'create relation',
+  name: t('actions.index.createRelation.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details:
-        'If the relation already exists or successfully created -  Message send via <b>Success</b> chain, otherwise <b>Failure</b> chain will be used.',
-      description:
-        "Finds target Entity by entity name pattern and (entity type pattern for Asset, Device) and then create a relation to Originator Entity by type and direction. If Selected entity type: Asset, Device or Customer will create new Entity if it doesn't exist and selected checkbox 'Create new entity if not exists'.<br> In case that relation from the message originator to the selected entity not exist and  If selected checkbox 'Remove current relations', before creating the new relation all existed relations to message originator by type and direction will be removed.<br> If relation from the message originator to the selected entity created and If selected checkbox 'Change originator to related entity', outbound message will be processed as a message from this entity.",
+      details: t('actions.index.createRelation.details'),
+      description: t('actions.index.createRelation.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: ['Success', 'Failure'],

@@ -2,9 +2,11 @@ import { ActionCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(ActionCategoryComponentEnum.DELAY_DEPRECATED);
 
+const { t } = useI18n(); //加载国际化
 export interface DelayDeprecatedDataType {
   someConfiguration?: Recordable;
 }
@@ -13,12 +15,11 @@ export const DelayDeprecatedConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.delay.TbMsgDelayNode',
   categoryType: RuleNodeTypeEnum.ACTION,
-  name: 'delay (deprecated)',
+  name: t('actions.index.delay.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details:
-        'Delays messages for a configurable period. Please note, this node acknowledges the message from the current queue (message will be removed from queue). Deprecated because the acknowledged message still stays in memory (to be delayed) and this does not guarantee that message will be processed even if the "retry failures and timeouts" processing strategy will be chosen.',
-      description: 'Delays incoming message (deprecated)',
+      details: t('actions.index.delay.details'),
+      description: t('actions.index.delay.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: ['Success', 'Failure'],

@@ -2,9 +2,12 @@ import { ActionCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(ActionCategoryComponentEnum.DELETE_RELATION);
 
+const { t } = useI18n(); //加载国际化
+
 export interface DeleteRelationDataType {
   someConfiguration?: Recordable;
 }
@@ -13,13 +16,11 @@ export const DeleteRelationConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.action.TbDeleteRelationNode',
   categoryType: RuleNodeTypeEnum.ACTION,
-  name: 'delete relation',
+  name: t('actions.index.deleteRelation.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details:
-        'If the relation(s) successfully deleted -  Message send via <b>Success</b> chain, otherwise <b>Failure</b> chain will be used.',
-      description:
-        "Finds target Entity by entity name pattern and then delete a relation to Originator Entity by type and direction if 'Delete single entity' is set to true, otherwise rule node will delete all relations to the originator of the message by type and direction.",
+      details: t('actions.index.deleteRelation.details'),
+      description: t('actions.index.deleteRelation.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: ['Success', 'Failure'],

@@ -2,9 +2,12 @@ import { ActionCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(ActionCategoryComponentEnum.DEVICE_PROFILE);
 
+const { t } = useI18n(); //加载国际化
+
 export interface DeviceProfileDataType {
   someConfiguration?: Recordable;
 }
@@ -13,12 +16,11 @@ export const DeviceProfileConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.profile.TbDeviceProfileNode',
   categoryType: RuleNodeTypeEnum.ACTION,
-  name: 'device profile',
+  name: t('actions.index.deviceProfile.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details:
-        "Create and clear alarms based on alarm rules defined in device profile. The output relation type is either 'Alarm Created', 'Alarm Updated', 'Alarm Severity Updated' and 'Alarm Cleared' or simply 'Success' if no alarms were affected.",
-      description: 'Process device messages based on device profile settings',
+      details: t('actions.index.deviceProfile.details'),
+      description: t('actions.index.deviceProfile.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: [

@@ -2,9 +2,12 @@ import { ActionCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(ActionCategoryComponentEnum.GENERATOR);
 
+const { t } = useI18n(); //加载国际化
+
 export interface GeneratorDataType {
   someConfiguration?: Recordable;
 }
@@ -13,12 +16,11 @@ export const GeneratorConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.debug.TbMsgGeneratorNode',
   categoryType: RuleNodeTypeEnum.ACTION,
-  name: 'generator',
+  name: t('actions.index.generator.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details:
-        'Generates messages with configurable period. Javascript function used for message generation.',
-      description: 'Periodically generates messages',
+      details: t('actions.index.generator.details'),
+      description: t('actions.index.generator.description'),
       inEnabled: false,
       outEnabled: true,
       relationTypes: ['Success', 'Failure'],

@@ -2,9 +2,11 @@ import { ActionCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(ActionCategoryComponentEnum.GPS_GEOFENCING_EVENTS);
 
+const { t } = useI18n(); //加载国际化
 export interface GpsGeofencingEventsDataType {
   someConfiguration?: Recordable;
 }
@@ -13,12 +15,11 @@ export const GpsGeofencingEventsConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.geo.TbGpsGeofencingActionNode',
   categoryType: RuleNodeTypeEnum.ACTION,
-  name: 'gps geofencing events',
+  name: t('actions.index.gpsGeofencingEvents.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details:
-        'Extracts latitude and longitude parameters from incoming message and returns different events based on configuration parameters',
-      description: 'Produces incoming messages using GPS based geofencing',
+      details: t('actions.index.gpsGeofencingEvents.details'),
+      description: t('actions.index.gpsGeofencingEvents.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: ['Success', 'Entered', 'Left', 'Inside', 'Outside', 'Failure'],

@@ -2,9 +2,11 @@ import { ActionCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(ActionCategoryComponentEnum.LOG);
 
+const { t } = useI18n(); //加载国际化
 export interface LogDataType {
   someConfiguration?: Recordable;
 }
@@ -13,12 +15,11 @@ export const LogConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.action.TbLogNode',
   categoryType: RuleNodeTypeEnum.ACTION,
-  name: 'log',
+  name: t('actions.index.log.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details:
-        "Transform incoming Message with configured JS function to String and log final value into Thingsboard log file. Message payload can be accessed via <code>msg</code> property. For example <code>'temperature = ' + msg.temperature ;</code>. Message metadata can be accessed via <code>metadata</code> property. For example <code>'name = ' + metadata.customerName;</code>.",
-      description: 'Log incoming messages using JS script for transformation Message into String',
+      details: t('actions.index.log.details'),
+      description: t('actions.index.log.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: ['Success', 'Failure'],

@@ -2,9 +2,12 @@ import { ActionCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(ActionCategoryComponentEnum.MESSAGE_COUNT);
 
+const { t } = useI18n(); //加载国际化
+
 export interface MessageCountDataType {
   someConfiguration?: Recordable;
 }
@@ -13,12 +16,11 @@ export const MessageCountConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.action.TbMsgCountNode',
   categoryType: RuleNodeTypeEnum.ACTION,
-  name: 'message count',
+  name: t('actions.index.messageCount.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details:
-        'Count incoming messages for specified interval and produces POST_TELEMETRY_REQUEST msg with messages count',
-      description: 'Count incoming messages',
+      details: t('actions.index.messageCount.details'),
+      description: t('actions.index.messageCount.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: ['Success', 'Failure'],

@@ -2,9 +2,11 @@ import { ActionCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(ActionCategoryComponentEnum.PUSH_TO_EDGE);
 
+const { t } = useI18n(); //加载国际化
 export interface PushToEdgeDataType {
   someConfiguration?: Recordable;
 }
@@ -13,12 +15,11 @@ export const PushToEdgeConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.edge.TbMsgPushToEdgeNode',
   categoryType: RuleNodeTypeEnum.ACTION,
-  name: 'push to edge',
+  name: t('actions.index.pushToEdge.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details:
-        "Push messages from cloud to edge. Message originator must be assigned to particular edge or message originator is <b>EDGE</b> entity itself. This node used only on cloud instances to push messages from cloud to edge. Once message arrived into this node it’s going to be converted into edge event and saved to the database. Node doesn't push messages directly to edge, but stores event(s) in the edge queue. <br>Supports next originator types:<br><code>DEVICE</code><br><code>ASSET</code><br><code>ENTITY_VIEW</code><br><code>DASHBOARD</code><br><code>TENANT</code><br><code>CUSTOMER</code><br><code>EDGE</code><br><br>As well node supports next message types:<br><code>POST_TELEMETRY_REQUEST</code><br><code>POST_ATTRIBUTES_REQUEST</code><br><code>ATTRIBUTES_UPDATED</code><br><code>ATTRIBUTES_DELETED</code><br><code>ALARM</code><br><br>Message will be routed via <b>Failure</b> route if node was not able to save edge event to database or unsupported originator type/message type arrived. In case successful storage edge event to database message will be routed via <b>Success</b> route.",
-      description: 'Push messages from cloud to edge',
+      details: t('actions.index.pushToEdge.details'),
+      description: t('actions.index.pushToEdge.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: ['Success', 'Failure'],

@@ -2,9 +2,11 @@ import { ActionCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(ActionCategoryComponentEnum.RPC_CALL_REPLY);
 
+const { t } = useI18n(); //加载国际化
 export interface RpcCallReplyDataType {
   someConfiguration?: Recordable;
 }
@@ -13,11 +15,11 @@ export const RpcCallReplyConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.rpc.TbSendRPCReplyNode',
   categoryType: RuleNodeTypeEnum.ACTION,
-  name: 'rpc call reply',
+  name: t('actions.index.rpcCallReply.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details: 'Expects messages with any message type. Will forward message body to the device.',
-      description: 'Sends reply to RPC call from device',
+      details: t('actions.index.rpcCallReply.details'),
+      description: t('actions.index.rpcCallReply.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: ['Success', 'Failure'],

@@ -2,9 +2,11 @@ import { ActionCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(ActionCategoryComponentEnum.RPC_CALL_REQUEST);
 
+const { t } = useI18n(); //加载国际化
 export interface RpcCallRequestDataType {
   someConfiguration?: Recordable;
 }
@@ -13,12 +15,11 @@ export const RpcCallRequestConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.rpc.TbSendRPCRequestNode',
   categoryType: RuleNodeTypeEnum.ACTION,
-  name: 'rpc call request',
+  name: t('actions.index.rpcCallRequest.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details:
-        'Expects messages with "method" and "params". Will forward response from device to next nodes.If the RPC call request is originated by REST API call from user, will forward the response to user immediately.',
-      description: 'Sends RPC call to device',
+      details: t('actions.index.rpcCallRequest.details'),
+      description: t('actions.index.rpcCallRequest.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: ['Success', 'Failure'],

@@ -2,9 +2,11 @@ import { ActionCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(ActionCategoryComponentEnum.SAVE_ATTRIBUTES);
 
+const { t } = useI18n(); //加载国际化
 export interface SaveAttributesDataType {
   someConfiguration?: Recordable;
 }
@@ -13,12 +15,11 @@ export const SaveAttributesConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.telemetry.TbMsgAttributesNode',
   categoryType: RuleNodeTypeEnum.ACTION,
-  name: 'save attributes',
+  name: t('actions.index.saveAttributes.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details:
-        "Saves entity attributes based on configurable scope parameter. Expects messages with 'POST_ATTRIBUTES_REQUEST' message type",
-      description: 'Saves attributes data',
+      details: t('actions.index.saveAttributes.details'),
+      description: t('actions.index.saveAttributes.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: ['Success', 'Failure'],

@@ -2,9 +2,11 @@ import { ActionCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(ActionCategoryComponentEnum.SAVE_EVENT);
 
+const { t } = useI18n(); //加载国际化
 export interface SaveEventDataType {
   someConfiguration?: Recordable;
 }
@@ -13,11 +15,11 @@ export const SaveEventConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.yunteng.event.TkMsgEventNode',
   categoryType: RuleNodeTypeEnum.ACTION,
-  name: 'save event',
+  name: t('actions.index.saveEvent.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details: "Saves entity event . Expects messages with 'POST_EVENT_REQUEST' message type",
-      description: 'Saves device event data',
+      details: t('actions.index.saveEvent.details'),
+      description: t('actions.index.saveEvent.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: ['Success', 'Failure'],

@@ -2,9 +2,11 @@ import { ActionCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(ActionCategoryComponentEnum.SAVE_TIMESERIES);
 
+const { t } = useI18n(); //加载国际化
 export interface SaveTimeseriesDataType {
   someConfiguration?: Recordable;
 }
@@ -13,12 +15,11 @@ export const SaveTimeseriesConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.telemetry.TbMsgTimeseriesNode',
   categoryType: RuleNodeTypeEnum.ACTION,
-  name: 'save timeseries',
+  name: t('actions.index.saveTimeseries.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details:
-        "Saves timeseries telemetry data based on configurable TTL parameter. Expects messages with 'POST_TELEMETRY_REQUEST' message type. Timestamp in milliseconds will be taken from metadata.ts, otherwise 'now' message timestamp will be applied. Allows stopping updating values for incoming keys in the latest ts_kv table if 'skipLatestPersistence' is set to true.\n <br/>Enable 'useServerTs' param to use the timestamp of the message processing instead of the timestamp from the message. Useful for all sorts of sequential processing if you merge messages from multiple sources (devices, assets, etc).\n<br/>In the case of sequential processing, the platform guarantees that the messages are processed in the order of their submission to the queue. However, the timestamp of the messages originated by multiple devices/servers may be unsynchronized long before they are pushed to the queue. The DB layer has certain optimizations to ignore the updates of the \"attributes\" and \"latest values\" tables if the new record has a timestamp that is older than the previous record. So, to make sure that all the messages will be processed correctly, one should enable this parameter for sequential message processing scenarios.",
-      description: 'Saves timeseries data',
+      details: t('actions.index.saveTimeseries.details'),
+      description: t('actions.index.saveTimeseries.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: ['Success', 'Failure'],

@@ -2,9 +2,11 @@ import { ActionCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(ActionCategoryComponentEnum.SAVE_TO_CUSTOM_TABLE);
 
+const { t } = useI18n(); //加载国际化
 export interface SaveToCustomTableDataType {
   someConfiguration?: Recordable;
 }
@@ -13,13 +15,11 @@ export const SaveToCustomTableConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.action.TbSaveToCustomCassandraTableNode',
   categoryType: RuleNodeTypeEnum.ACTION,
-  name: 'save to custom table',
+  name: t('actions.index.saveToCustomTable.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details:
-        'Administrator should set the custom table name without prefix: <b>cs_tb_</b>. <br>Administrator can configure the mapping between the Message field names and Table columns name.<br><b>Note:</b>If the mapping key is <b>$entity_id</b>, that is identified by the Message Originator, then to the appropriate column name(mapping value) will be write the message originator id.<br><br>If specified message field does not exist or is not a JSON Primitive, the outbound message will be routed via <b>failure</b> chain, otherwise, the message will be routed via <b>success</b> chain.',
-      description:
-        'Node stores data from incoming Message payload to the Cassandra database into the predefined custom table that should have <b>cs_tb_</b> prefix, to avoid the data insertion to the common TB tables.<br><b>Note:</b> rule node can be used only for Cassandra DB.',
+      details: t('actions.index.saveToCustomTable.details'),
+      description: t('actions.index.saveToCustomTable.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: ['Success', 'Failure'],

@@ -2,9 +2,11 @@ import { ActionCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(ActionCategoryComponentEnum.SYNCHRONIZATION_END);
 
+const { t } = useI18n(); //加载国际化
 export interface SynchronizationEndDataType {
   someConfiguration?: Recordable;
 }
@@ -13,11 +15,11 @@ export const SynchronizationEndConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.transaction.TbSynchronizationEndNode',
   categoryType: RuleNodeTypeEnum.ACTION,
-  name: 'synchronization end',
+  name: t('actions.index.synchronizationEnd.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details: '',
-      description: 'This Node is now deprecated. Use "Checkpoint" instead.',
+      details: t('actions.index.synchronizationEnd.details'),
+      description: t('actions.index.synchronizationEnd.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: ['Success', 'Failure'],

@@ -2,9 +2,11 @@ import { ActionCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(ActionCategoryComponentEnum.SYNCHRONIZATION_START);
 
+const { t } = useI18n(); //加载国际化
 export interface SynchronizationStartDataType {
   someConfiguration?: Recordable;
 }
@@ -13,12 +15,11 @@ export const SynchronizationStartConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.transaction.TbSynchronizationBeginNode',
   categoryType: RuleNodeTypeEnum.ACTION,
-  name: 'synchronization start',
+  name: t('actions.index.synchronizationStart.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details:
-        'This node should be used together with "synchronization end" node. \n This node will put messages into queue based on message originator id. \nSubsequent messages will not be processed until the previous message processing is completed or timeout event occurs.\nSize of the queue per originator and timeout values are configurable on a system level',
-      description: 'This Node is now deprecated. Use "Checkpoint" instead.',
+      details: t('actions.index.synchronizationStart.details'),
+      description: t('actions.index.synchronizationStart.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: ['Success', 'Failure'],

@@ -2,9 +2,11 @@ import { ActionCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(ActionCategoryComponentEnum.UNASSIGN_FROM_CUSTOMER);
 
+const { t } = useI18n(); //加载国际化
 export interface UnassignFromCustomerDataType {
   someConfiguration?: Recordable;
 }
@@ -13,12 +15,11 @@ export const UnassignFromCustomerConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.action.TbUnassignFromCustomerNode',
   categoryType: RuleNodeTypeEnum.ACTION,
-  name: 'unassign from customer',
+  name: t('actions.index.unassigFromCustomer.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details:
-        'Finds target Entity Customer by Customer name pattern and then unassign Originator Entity from this customer.',
-      description: 'Unassign Message Originator Entity from Customer',
+      details: t('actions.index.unassigFromCustomer.details'),
+      description: t('actions.index.unassigFromCustomer.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: ['Success', 'Failure'],

@@ -2,9 +2,12 @@ import { EnrichmentCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(EnrichmentCategoryComponentEnum.TENANT_DETAILS);
 
+const { t } = useI18n(); //加载国际化
+
 export interface TenantDetailsDataType {
   someConfiguration?: Recordable;
 }
@@ -13,12 +16,11 @@ export const TenantDetailsConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.metadata.TbGetTenantDetailsNode',
   categoryType: RuleNodeTypeEnum.ENRICHMENT,
-  name: 'tenant details',
+  name: t('enrichments.index.tenantDetails.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details:
-        'If checkbox: <b>Add selected details to the message metadata</b> is selected, existing fields will be added to the message metadata instead of message data.<br><br><b>Note:</b> only Device, Asset, and Entity View type are allowed.<br><br>If the originator of the message is not assigned to Tenant, or originator type is not supported - Message will be forwarded to <b>Failure</b> chain, otherwise, <b>Success</b> chain will be used.',
-      description: 'Adds fields from Tenant details to the message body or metadata',
+      details: t('enrichments.index.tenantDetails.details'),
+      description: t('enrichments.index.tenantDetails.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: ['Success', 'Failure'],

@@ -2,9 +2,11 @@ import { ExternalCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(ExternalCategoryComponentEnum.ALARM_NOTICE);
 
+const { t } = useI18n(); //加载国际化
 export interface AlarmNoticeDataType {
   someConfiguration?: Recordable;
 }
@@ -13,11 +15,11 @@ export const AlarmNoticeConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.notice.AlarmNoticeNode',
   categoryType: RuleNodeTypeEnum.EXTERNAL,
-  name: 'alarm notice',
+  name: t('externals.index.alarmNotice.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details: 'notice method include sms,email and so on.',
-      description: 'while device alarm, notice some people.',
+      details: t('externals.index.alarmNotice.details'),
+      description: t('externals.index.alarmNotice.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: ['Success', 'Failure'],

@@ -2,9 +2,11 @@ import { ExternalCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(ExternalCategoryComponentEnum.AWS_SNS);
 
+const { t } = useI18n(); //加载国际化
 export interface AwsSnsDataType {
   someConfiguration?: Recordable;
 }
@@ -13,12 +15,11 @@ export const AwsSnsConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.aws.sns.TbSnsNode',
   categoryType: RuleNodeTypeEnum.EXTERNAL,
-  name: 'aws sns',
+  name: t('externals.index.awsSns.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details:
-        'Will publish message payload to the AWS SNS topic. Outbound message will contain response fields (<code>messageId</code>, <code>requestId</code>) in the Message Metadata from the AWS SNS. For example <b>requestId</b> field can be accessed with <code>metadata.requestId</code>.',
-      description: 'Publish message to the AWS SNS',
+      details: t('externals.index.awsSns.details'),
+      description: t('externals.index.awsSns.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: ['Success', 'Failure'],

@@ -2,9 +2,11 @@ import { ExternalCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(ExternalCategoryComponentEnum.AWS_SQS);
 
+const { t } = useI18n(); //加载国际化
 export interface AwsSqsDataType {
   someConfiguration?: Recordable;
 }
@@ -13,12 +15,11 @@ export const AwsSqsConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.aws.sqs.TbSqsNode',
   categoryType: RuleNodeTypeEnum.EXTERNAL,
-  name: 'aws sqs',
+  name: t('externals.index.awsSqs.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details:
-        'Will publish message payload and metadata attributes to the AWS SQS queue. Outbound message will contain response fields (<code>messageId</code>, <code>requestId</code>, <code>messageBodyMd5</code>, <code>messageAttributesMd5</code>, <code>sequenceNumber</code>) in the Message Metadata from the AWS SQS. For example <b>requestId</b> field can be accessed with <code>metadata.requestId</code>.',
-      description: 'Publish messages to the AWS SQS',
+      details: t('externals.index.awsSqs.details'),
+      description: t('externals.index.awsSqs.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: ['Success', 'Failure'],

@@ -2,9 +2,11 @@ import { ExternalCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(ExternalCategoryComponentEnum.AZURE_IOT_HUB);
 
+const { t } = useI18n(); //加载国际化
 export interface AzureIotHubDataType {
   someConfiguration?: Recordable;
 }
@@ -13,11 +15,11 @@ export const AzureIotHubConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.mqtt.azure.TbAzureIotHubNode',
   categoryType: RuleNodeTypeEnum.EXTERNAL,
-  name: 'azure iot hub',
+  name: t('externals.index.azureIotHub.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details: 'Will publish message payload to the Azure IoT Hub with QoS <b>AT_LEAST_ONCE</b>.',
-      description: 'Publish messages to the Azure IoT Hub',
+      details: t('externals.index.azureIotHub.details'),
+      description: t('externals.index.azureIotHub.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: ['Success', 'Failure'],

@@ -2,9 +2,11 @@ import { ExternalCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(ExternalCategoryComponentEnum.GCP_PUBSUB);
 
+const { t } = useI18n(); //加载国际化
 export interface GcpPubsubDataType {
   someConfiguration?: Recordable;
 }
@@ -13,12 +15,11 @@ export const GcpPubsubConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.gcp.pubsub.TbPubSubNode',
   categoryType: RuleNodeTypeEnum.EXTERNAL,
-  name: 'gcp pubsub',
+  name: t('externals.index.gcpPubsub.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details:
-        'Will publish message payload to the Google Cloud Platform PubSub topic. Outbound message will contain response fields (<code>messageId</code> in the Message Metadata from the GCP PubSub. <b>messageId</b> field can be accessed with <code>metadata.messageId</code>.',
-      description: 'Publish message to the Google Cloud PubSub',
+      details: t('externals.index.gcpPubsub.details'),
+      description: t('externals.index.gcpPubsub.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: ['Success', 'Failure'],

@@ -2,9 +2,11 @@ import { ExternalCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(ExternalCategoryComponentEnum.KAFKA);
 
+const { t } = useI18n(); //加载国际化
 export interface KafkaDataType {
   someConfiguration?: Recordable;
 }
@@ -13,12 +15,11 @@ export const KafkaConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.kafka.TbKafkaNode',
   categoryType: RuleNodeTypeEnum.EXTERNAL,
-  name: 'kafka',
+  name: t('externals.index.kafka.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details:
-        'Will send record via Kafka producer to Kafka server. Outbound message will contain response fields (<code>offset</code>, <code>partition</code>, <code>topic</code>) from the Kafka in the Message Metadata. For example <b>partition</b> field can be accessed with <code>metadata.partition</code>.',
-      description: 'Publish messages to Kafka server',
+      details: t('externals.index.kafka.details'),
+      description: t('externals.index.kafka.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: ['Success', 'Failure'],

@@ -2,9 +2,11 @@ import { ExternalCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(ExternalCategoryComponentEnum.MQTT);
 
+const { t } = useI18n(); //加载国际化
 export interface MqttDataType {
   someConfiguration?: Recordable;
 }
@@ -13,11 +15,11 @@ export const MqttConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.mqtt.TbMqttNode',
   categoryType: RuleNodeTypeEnum.EXTERNAL,
-  name: 'mqtt',
+  name: t('externals.index.mqtt.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details: 'Will publish message payload to the MQTT broker with QoS <b>AT_LEAST_ONCE</b>.',
-      description: 'Publish messages to the MQTT broker',
+      details: t('externals.index.mqtt.details'),
+      description: t('externals.index.mqtt.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: ['Success', 'Failure'],

@@ -2,9 +2,12 @@ import { ExternalCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(ExternalCategoryComponentEnum.RABBITMQ);
 
+const { t } = useI18n(); //加载国际化
+
 export interface RabbitmqDataType {
   someConfiguration?: Recordable;
 }
@@ -13,11 +16,11 @@ export const RabbitmqConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.rabbitmq.TbRabbitMqNode',
   categoryType: RuleNodeTypeEnum.EXTERNAL,
-  name: 'rabbitmq',
+  name: t('externals.index.rabbitmq.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details: 'Will publish message payload to RabbitMQ queue.',
-      description: 'Publish messages to the RabbitMQ',
+      details: t('externals.index.rabbitmq.details'),
+      description: t('externals.index.rabbitmq.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: ['Success', 'Failure'],

@@ -2,9 +2,11 @@ import { ExternalCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(ExternalCategoryComponentEnum.REST_API_CALL);
 
+const { t } = useI18n(); //加载国际化
 export interface RestApiCallDataType {
   someConfiguration?: Recordable;
 }
@@ -13,12 +15,11 @@ export const RestApiCallConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.rest.TbRestApiCallNode',
   categoryType: RuleNodeTypeEnum.EXTERNAL,
-  name: 'rest api call',
+  name: t('externals.index.restApiCall.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details:
-        'Will invoke REST API call <code>GET | POST | PUT | DELETE</code> to external REST server. Message payload added into Request body. Configured attributes can be added into Headers from Message Metadata. Outbound message will contain response fields (<code>status</code>, <code>statusCode</code>, <code>statusReason</code> and response <code>headers</code>) in the Message Metadata. Response body saved in outbound Message payload. For example <b>statusCode</b> field can be accessed with <code>metadata.statusCode</code>.<br/><b>Note-</b> if you use system proxy properties, the next system proxy properties should be added: "http.proxyHost" and "http.proxyPort" or  "https.proxyHost" and "https.proxyPort" or "socksProxyHost" and "socksProxyPort",and if your proxy with auth, the next ones  should be added: "tb.proxy.user" and "tb.proxy.password" to the thingsboard.conf file.',
-      description: 'Invoke REST API calls to external REST server',
+      details: t('externals.index.restApiCall.details'),
+      description: t('externals.index.restApiCall.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: ['Success', 'Failure'],

@@ -2,9 +2,11 @@ import { ExternalCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(ExternalCategoryComponentEnum.SEND_EMAIL);
 
+const { t } = useI18n(); //加载国际化
 export interface SendEmailDataType {
   someConfiguration?: Recordable;
 }
@@ -13,12 +15,11 @@ export const SendEmailConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.mail.TbSendEmailNode',
   categoryType: RuleNodeTypeEnum.EXTERNAL,
-  name: 'send email',
+  name: t('externals.index.sendEmail.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details:
-        'Expects messages with <b>SEND_EMAIL</b> type. Node works only with messages that  where created using <code>to Email</code> transformation Node, please connect this Node with <code>to Email</code> Node using <code>Successful</code> chain.',
-      description: 'Sends email message via SMTP server.',
+      details: t('externals.index.sendEmail.details'),
+      description: t('externals.index.sendEmail.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: ['Success', 'Failure'],

@@ -2,9 +2,11 @@ import { ExternalCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(ExternalCategoryComponentEnum.SEND_SMS);
 
+const { t } = useI18n(); //加载国际化
 export interface SendSmsDataType {
   someConfiguration?: Recordable;
 }
@@ -13,12 +15,11 @@ export const SendSmsConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.sms.TbSendSmsNode',
   categoryType: RuleNodeTypeEnum.EXTERNAL,
-  name: 'send sms',
+  name: t('externals.index.sendSms.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details:
-        'Will send SMS message by populating target phone numbers and sms message fields using values derived from message metadata.',
-      description: 'Sends SMS message via SMS provider.',
+      details: t('externals.index.sendSms.details'),
+      description: t('externals.index.sendSms.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: ['Success', 'Failure'],

@@ -2,9 +2,11 @@ import { FlowCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(FlowCategoryComponentEnum.ACKNOWLEDGE);
 
+const { t } = useI18n(); //加载国际化
 export interface AcknowledgeDataType {
   someConfiguration?: Recordable;
 }
@@ -13,12 +15,11 @@ export const AcknowledgeConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.flow.TbAckNode',
   categoryType: RuleNodeTypeEnum.FLOW,
-  name: 'acknowledge',
+  name: t('flows.index.acknowledge.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details:
-        "After acknowledgement, the message is pushed to related rule nodes. Useful if you don't care what happens to this message next.",
-      description: 'Acknowledges the incoming message',
+      details: t('flows.index.acknowledge.details'),
+      description: t('flows.index.acknowledge.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: ['Success', 'Failure'],

@@ -2,9 +2,11 @@ import { FlowCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(FlowCategoryComponentEnum.CHECKPOINT);
 
+const { t } = useI18n(); //加载国际化
 export interface CheckpointDataType {
   someConfiguration?: Recordable;
 }
@@ -13,12 +15,11 @@ export const CheckpointConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.flow.TbCheckpointNode',
   categoryType: RuleNodeTypeEnum.FLOW,
-  name: 'checkpoint',
+  name: t('flows.index.checkpoint.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details:
-        'After successful transfer incoming message is automatically acknowledged. Queue name is configurable.',
-      description: 'transfers the message to another queue',
+      details: t('flows.index.checkpoint.details'),
+      description: t('flows.index.checkpoint.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: ['Success', 'Failure'],

@@ -2,9 +2,11 @@ import { FlowCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(FlowCategoryComponentEnum.OUTPUT);
 
+const { t } = useI18n(); //加载国际化
 export interface OutputDataType {
   someConfiguration?: Recordable;
 }
@@ -13,12 +15,11 @@ export const OutputConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.flow.TbRuleChainOutputNode',
   categoryType: RuleNodeTypeEnum.FLOW,
-  name: 'output',
+  name: t('flows.index.output.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details:
-        'Produces output of the rule chain processing. The output is forwarded to the caller rule chain, as an output of the corresponding "input" rule node. The output rule node name corresponds to the relation type of the output message, and it is used to forward messages to other rule nodes in the caller rule chain. ',
-      description: 'transfers the message to the caller rule chain',
+      details: t('flows.index.output.details'),
+      description: t('flows.index.output.description'),
       inEnabled: true,
       outEnabled: false,
       relationTypes: ['Success', 'Failure'],

@@ -2,9 +2,11 @@ import { FlowCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(FlowCategoryComponentEnum.RULE_CHAIN);
 
+const { t } = useI18n(); //加载国际化
 export interface RuleChainDataType {
   someConfiguration?: Recordable;
 }
@@ -13,13 +15,12 @@ export const RuleChainConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.flow.TbRuleChainInputNode',
   categoryType: RuleNodeTypeEnum.FLOW,
-  name: 'rule chain',
+  name: t('flows.index.ruleChain.name'),
   // backgroundColor: '#d6c4f1',
   configurationDescriptor: {
     nodeDefinition: {
-      details:
-        'Allows to nest the rule chain similar to single rule node. The incoming message is forwarded to the input node of the specified target rule chain. The target rule chain may produce multiple labeled outputs. You may use the outputs to forward the results of processing to other rule nodes.',
-      description: 'transfers the message to another rule chain',
+      details: t('flows.index.ruleChain.details'),
+      description: t('flows.index.ruleChain.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: ['Failure'],

@@ -2,9 +2,11 @@ import { TransformationCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(TransformationCategoryComponentEnum.CHANGE_ORIGINATOR);
 
+const { t } = useI18n(); //加载国际化
 export interface ChangeOriginatorDataType {
   someConfiguration?: Recordable;
 }
@@ -13,12 +15,11 @@ export const ChangeOriginatorConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.transform.TbChangeOriginatorNode',
   categoryType: RuleNodeTypeEnum.TRANSFORMATION,
-  name: 'change originator',
+  name: t('transformations.index.changeOriginator.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details:
-        'Related Entity found using configured relation direction and Relation Type. If multiple Related Entities are found, only first Entity is used as new Originator, other entities are discarded.<br/>Alarm Originator found only in case original Originator is <code>Alarm</code> entity.',
-      description: 'Change Message Originator To Tenant/Customer/Related Entity/Alarm Originator',
+      details: t('transformations.index.changeOriginator.details'),
+      description: t('transformations.index.changeOriginator.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: ['Success', 'Failure'],

@@ -2,9 +2,12 @@ import { TransformationCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(TransformationCategoryComponentEnum.SCRIPT);
 
+const { t } = useI18n(); //加载国际化
+
 export interface ScriptDataType {
   someConfiguration?: Recordable;
 }
@@ -13,12 +16,11 @@ export const ScriptConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.transform.TbTransformMsgNode',
   categoryType: RuleNodeTypeEnum.TRANSFORMATION,
-  name: 'script',
+  name: t('transformations.index.script.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details:
-        'JavaScript function receive 3 input parameters <br/> <code>metadata</code> - is a Message metadata.<br/><code>msg</code> - is a Message payload.<br/><code>msgType</code> - is a Message type.<br/>Should return the following structure:<br/><code>{ msg: <i style="color: #666;">new payload</i>,<br/>&nbsp&nbsp&nbspmetadata: <i style="color: #666;">new metadata</i>,<br/>&nbsp&nbsp&nbspmsgType: <i style="color: #666;">new msgType</i> }</code><br/>All fields in resulting object are optional and will be taken from original message if not specified.',
-      description: 'Change Message payload, Metadata or Message type using JavaScript',
+      details: t('transformations.index.script.details'),
+      description: t('transformations.index.script.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: ['Success', 'Failure'],

@@ -2,9 +2,11 @@ import { TransformationCategoryComponentEnum } from '../../../enum/category';
 import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
 import type { NodeItemConfigType } from '../../../types/node';
 import { RuleNodeTypeEnum } from '../../index.type';
+import { useI18n } from '/@/hooks/web/useI18n';
 
 const keys = useCreateNodeKey(TransformationCategoryComponentEnum.TO_EMAIL);
 
+const { t } = useI18n(); //加载国际化
 export interface ToEmailDataType {
   someConfiguration?: Recordable;
 }
@@ -13,12 +15,11 @@ export const ToEmailConfig: NodeItemConfigType = {
   ...keys,
   clazz: 'org.thingsboard.rule.engine.mail.TbMsgToEmailNode',
   categoryType: RuleNodeTypeEnum.TRANSFORMATION,
-  name: 'to email',
+  name: t('transformations.index.toEmail.name'),
   configurationDescriptor: {
     nodeDefinition: {
-      details:
-        "Transforms message to email message by populating email fields using values derived from message metadata. Set 'SEND_EMAIL' output message type.",
-      description: 'Transforms message to email message',
+      details: t('transformations.index.toEmail.details'),
+      description: t('transformations.index.toEmail.description'),
       inEnabled: true,
       outEnabled: true,
       relationTypes: ['Success', 'Failure'],