Bloques lógicos

Por qué los bloques lógicos están sujetos a restricciones

Los bloques lógicos se ejecutan en línea como parte de un flujo de trabajo. El uso sin restricciones de Python conlleva los siguientes riesgos:

• Ralentiza el flujo de trabajo

• Introduce riesgos de seguridad

• Los flujos de trabajo son más difíciles de depurar y escalar

Para evitar estos problemas, los bloques lógicos admiten una lógica rápida y predecible, mientras que las herramientas pueden manejar procesamientos más pesados u operaciones externas.

Formato del mensaje

Puede dar formato o reestructurar los mensajes según sea necesario, al tiempo que traslada la información al siguiente nodo. El siguiente ejemplo de bloque lógico muestra una aplicación práctica del formato de mensajes.

Ejemplos

# Format address
addr = flow["input"]["address"]
formatted_address = f"{addr['street']}, {addr['city']}, {addr['state']}, {addr['country']}"
self["output"]["address"] = formatted_address
 

Integración flexible

Puede colocar el nodo del bloque lógico en cualquier lugar del flujo de trabajo del agente para integrarlo con otros nodos y herramientas. El siguiente ejemplo de bloque lógico muestra una aplicación práctica de la integración flexible.

Ejemplos

today = datetime.date.today()
self.output.todays_date = today.isoformat()

Bloque lógico que inicializa un conjunto de variables de salida utilizando tipos de datos primitivos: cadena, entero, número y booleano.

Las variables de salida son:

• name : Cadena
• age : Entero
• salary : Número
• isActive : Booleano

En el bloque lógico, cada variable se inicializa con un valor de muestra.

self.output.name = "John Doe"
self.output.age = 37
self.output.salary = 12345.67
self.output.isActive = True
 

Transformación de datos personalizada

Puede escribir una lógicas Python para transformar, filtrar, inicializar variables o mejorar los datos existentes a medida que pasan por el flujo de trabajo del agente. Los siguientes ejemplos de bloques lógicos muestran una aplicación práctica de la transformación de datos personalizada.

Ejemplos

address_json = '''

{
  "street": "123 ABC Street",
  "city": "NY",
  "state": "NY",
  "country": "USA"
}

'''

address = json.loads(address_json)

flow["input"]["address"]["state"] = address["state"]

{
    "employee": {
    "type": "object",
    "description": "",
    "properties": {
      "id": {
        "type": "integer",
        "description": "Unique identifier for the employee"
      },
      "firstName": {
        "type": "string",
        "description": "Employee's first name"
      },
      "lastName": {
        "type": "string",
        "description": "Employee's last name"
      },
      "email": {
        "type": "string",
        "description": "Employee's email address"
      },
      "department": {
        "type": "string",
        "description": "Employee's department"
      },
      "salary": {
        "type": "number",
        "description": "Employee's salary"
      },
      "isActive": {
        "type": "boolean",
        "description": "Whether the employee is currently active"
      },
      "startDate": {
        "type": "string",
        "format": "date",
        "description": "Employee's start date"
      },
      "badges": {
        "type": "array",
        "items": {
          "type": "string"
        },
        "description": "Employee's badges"
      },
      "address": {
        "type": "object",
        "description": "",
        "properties": {
          "street": {
            "type": "string"
          },
          "city": {
            "type": "string"
          },
          "zipCode": {
            "type": "string"
          }
        },
        "default": ""
      }
    }
    }
}

 

Implementación de la lógica de negocio

Puede aplicar lógica condicional, realizar cálculos y tomar decisiones, o ejecutar operaciones personalizadas según sea necesario en el flujo de trabajo del agente. Los siguientes ejemplos de bloques lógicos muestran una aplicación práctica de la implementación de la lógica empresarial.

Ejemplos

# Get today's date
today = datetime.date.today()
# Get the user's birthday from the output of the previous user activity
birthday_str = flow["User activity 1"]["Ask for date of birth"].output.value
# Convert the user's birthday into a date object
birthday = datetime.datetime.strptime(birthday_str, "%Y-%m-%d").date()
# Calculate the user's age
age = today.year - birthday.year - ((today.month, today.day) < (birthday.month, birthday.day))
# Return the user's age
self.output.age = age
 

product = flow.input.product

age = flow.input.age

if product == "Alcohol" and age < 18:
    self.output.accept_payment = False
elif product == "Fireworks" and age < 18:
    self.output.accept_payment = False
else:
    self.output.accept_payment = True

# Ensure customer_status and price are available

status = flow["input"].get("customer_status")
price = flow["input"].get("price", 0)

discount_rate = 0

if status == "Bronze":
    if price < 100:
        discount_rate = 0
    elif price < 500:
        discount_rate = 0.01

    elif price < 900:
        discount_rate = 0.02
    else:
        discount_rate = 0.03
elif status == "Silver":
    if price < 100:
        discount_rate = 0.02
    elif price < 500:
        discount_rate = 0.04
    elif price < 900:
        discount_rate = 0.05
    else:
        discount_rate = 0.07
elif status == "Gold":
    if price < 100:
        discount_rate = 0
    elif price < 500:
        discount_rate = 0.05
    elif price < 900:
        discount_rate = 0.07
    else:
        discount_rate = 0.10

self["output"]["discount_rate"] = discount_rate
 

# Format address using if-then logic

addr = flow["input"]["address"]
formatted_address = addr["street"]

if addr.get("city"):
    formatted_address += f", {addr['city']}"
if addr.get("state"):
    formatted_address += f", {addr['state']}"
if addr.get("country"):
    formatted_address += f", {addr['country']}"

self["output"]["address"] = formatted_address

today = datetime.date.today()

three_days_ago = today - datetime.timedelta(days=3)

self.output.three_days_ago = three_days_ago.isoformat()

Procesamiento de archivos

Puede utilizar el nodo de bloque lógico para gestionar operaciones con archivos, como gestionar cargas de uno o varios archivos, extraer o transformar el contenido de archivos y generar archivos para su descarga. El siguiente ejemplo muestra un caso práctico de procesamiento de archivos.

Funciones disponibles para el procesamiento de archivos

Puede utilizar funciones de archivos del sistema o métodos WxoFile de instancia para ejecutar operaciones con archivos.

Funciones de los archivos del sistema

A continuación se describen los system.file métodos para trabajar con archivos:

• system.file.get_name(file) – Devuelve el nombre del archivo
• system.file.get_type(file) – Devuelve el tipo de archivo
• system.file.get_size(file) – Devuelve el tamaño del archivo
• system.file.get_content(file) – Devuelve el contenido del archivo en bytes

WxoFile Métodos de instancia

A continuación se muestran los métodos de instancia disponibles en un WxoFile objeto :

• file.get_name() – Devuelve el nombre del archivo
• file.get_type() – Devuelve el tipo de archivo
• file.get_size() – Devuelve el tamaño del archivo
• file.get_content() – Devuelve el contenido del archivo en bytes

A continuación se muestran ejemplos prácticos que muestran cómo acceder a archivos desde entradas de flujo, formularios de actividad de usuario y carga de archivos de actividad de usuario, y recuperar su URL, nombre, tipo y tamaño utilizando tanto system.file funciones como métodos WxoFile de instancia.

input_file = flow.input.externalFile
self.output.file_name = system.file.get_name(input_file)
self.output.file_type = system.file.get_type(input_file)
self.output.file_size = system.file.get_size(input_file)
self.output.file_content = system.file.get_content(input_file)
 

input_file = flow.input.externalFile
self.output.file_name = input_file.get_name()
self.output.file_type = input_file.get_type()
self.output.file_size = input_file.get_size()
self.output.file_content = input_file.get_content()
 

form_single_file = flow["User activity 1"]["Form 1"].output["single file upload"]
self.output.file_name = system.file.get_name(form_single_file)
self.output.file_type = system.file.get_type(form_single_file)
self.output.file_size = system.file.get_size(form_single_file)
self.output.file_content = system.file.get_content(form_single_file)
 

form_single_file = flow["User activity 1"]["Form 1"].output["single file upload"]
self.output.file_name = form_single_file.get_name()
self.output.file_type = form_single_file.get_type()
self.output.file_size = form_single_file.get_size()
self.output.file_content = form_single_file.get_content()
 

form_multi_file = flow["User activity 1"]["Form 1"].output["Multi file upload"]
self.output.file_count = len(form_multi_file)
self.output.first_file_name = system.file.get_name(form_multi_file[0])
self.output.first_file_type = system.file.get_type(form_multi_file[0])
self.output.first_file_size = system.file.get_size(form_multi_file[0])
self.output.first_file_content = system.file.get_content(form_multi_file[0])
 

form_multi_file = flow["User activity 1"]["Form 1"].output["Multi file upload"]
self.output.file_count = len(form_multi_file)
self.output.first_file_name = form_multi_file[0].get_name()
self.output.first_file_type = form_multi_file[0].get_type()
self.output.first_file_size = form_multi_file[0].get_size()
self.output.first_file_content = form_multi_file[0].get_content()
 

normal_single_file = flow["User activity 1"]["File upload 1"].output.value
self.output.file_name = system.file.get_name(normal_single_file)
self.output.file_type = system.file.get_type(normal_single_file)
self.output.file_size = system.file.get_size(normal_single_file)
self.output.file_content = system.file.get_content(normal_single_file)
 

normal_single_file = flow["User activity 1"]["File upload 1"].output.value
self.output.file_name = normal_single_file.get_name()
self.output.file_type = normal_single_file.get_type()
self.output.file_size = normal_single_file.get_size()
self.output.file_content = normal_single_file.get_content()
 

Métodos de búsqueda de usuarios

Puedes utilizar el nodo de bloque lógico para recuperar información del usuario, como el nombre, la dirección de correo electrónico y el ID.

Utiliza los siguientes métodos para buscar usuarios y recuperar un objeto de usuario:

• system.user.search_by_name(name)

• system.user.search_by_email(email)

• system.user.search_by_id(id)

Estos métodos devuelven una lista de usuarios que coinciden. A continuación, puedes utilizar el objeto de usuario devuelto para acceder a los atributos del usuario.

Una vez recuperado un objeto User, puedes utilizar los siguientes métodos de atributos de usuario para acceder a los datos del usuario:

• user.get_name() o system.user.get_name(user) – Devuelve el nombre del usuario especificado.

• user.get_email() o system.user.get_email(user) – Devuelve la dirección de correo electrónico del usuario especificado

• user.get_id() o system.user.get_id(user) – Devuelve el ID del usuario especificado

Los siguientes ejemplos muestran cómo recuperar información del usuario utilizando tanto los métodos del tipo de datos «User» como las funciones de « system.user ».

• Un bloque lógico que recupera los datos del usuario mediante los métodos del tipo de datos del usuario.

  
  user_variable = system.user.search_by_email("user1@ibm.com")[0]
  
  self.output.user_name = user_variable.get_name()
  self.output.user_email = user_variable.get_email()
  self.output.user_id = user_variable.get_id()

• Un bloque lógico que recupera los datos del usuario mediante funciones de « system.user ».

  
  user_variable = system.user.search_by_email("user1@ibm.com")[0]
  
  self.output.user_name = system.user.get_name(user_variable)
  self.output.user_email = system.user.get_email(user_variable)
  self.output.user_id = system.user.get_id(user_variable

Variables de contexto del sistema

Las variables de contexto del sistema le permiten almacenar y reutilizar valores en todo un flujo de trabajo. Actúan como puntos de datos compartidos, y las variables de contexto del sistema persisten durante toda la duración del flujo de trabajo. Si una variable de contexto se actualiza al inicio del flujo de trabajo, como en un bloque lógico, el valor permanece disponible durante toda la ejecución del flujo de trabajo.

Están disponibles los métodos siguientes:

get_variable método

El get_variable método recupera una variable de contexto del sistema por su nombre.

• nombre_variable : Especifica la clave de la variable.

system.context.get_variable("variable_name")
 

set_variable método

El set_variable método almacena un valor en el sistema utilizando la clave variable.

• nombre_variable : Especifica la clave de la variable.

• valor_variable : Especifica el valor que se va a almacenar.

system.context.set_variable('variable_name', "variable_value")
 

Variables de contexto del sistema predefinidas

Las variables predefinidas siempre están disponibles en el flujo de trabajo. No es necesario configurarlos manualmente utilizando el set_variable método. Utilice el get_variable método para acceder a ellos en cualquier momento del flujo de trabajo.

Las variables predefinidas son:

• wxo_email_id

• wxo_tenant_id

• wxo_user_name