> ## Documentation Index
> Fetch the complete documentation index at: https://docs.alvys.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Cree consultas Power BI contra la API Alvys
> Cree Power BI consultas M que llamen a Alvys puntos finales de búsqueda como cargas, conductores y aprovechen para extraer registros filtrados con su token de acceso para generar informes.
Una vez que tenga AccessToken, puede usarlo para consultar varios puntos finales de API.
### **API de búsqueda de cargas:`/api/p/v{version}/loads/search`**
1. **Cree una nueva consulta** para el punto final `Loads Search`:
* Agregue una nueva consulta y asígnele un nombre descriptivo, como `Loads Search`, para identificar fácilmente su propósito.
* Abra la consulta en **Editor avanzado** y pegue el siguiente código:
```
let
// Define the API endpoint URL
url = "https://integrations.alvys.com/api/p/v1/loads/search",
// Define the body of the POST request
requestBody = Text.ToBinary("{
""page"": 0,
""pageSize"": 200,
""dateRange"": {
""startDate"": ""2023-09-09T13:09:30.788Z"",
""endDate"": ""2024-09-09T13:09:30.788Z""
},
""status"": [""Open""]
}"),
// Retrieve the access token from AccessToken query
accessToken = AccessToken,
// Define headers with authorization token
headers = [
#"Authorization" = "Bearer " & accessToken,
#"Content-Type" = "application/json"
],
// Make the POST request
response = Web.Contents(url, [
Headers = headers,
Content = requestBody
]),
// Parse the JSON response
jsonResponse = Json.Document(response)
in
jsonResponse
```
**Guardar y cerrar la consulta.**
**Resultado esperado**:
* La consulta `Loads Search` recuperará datos de la API Alvys y mostrará la tabla **Cargas** en Power BI.
* Puede explorar detalles adicionales en los resultados de la consulta:
* En el **panel derecho**, haga clic para expandir la respuesta JSON y ver los resultados totales, los objetos anidados u otros detalles relevantes de la API.
> Esta consulta le permite recuperar dinámicamente datos de clientes filtrados por sus estados o rango de fechas creado. Modifique el cuerpo de la solicitud según sea necesario para incluir filtros adicionales o ajuste los criterios de búsqueda para obtener resultados más específicos.
### **API de búsqueda de conductores:`/api/p/v{version}/drivers/search`**
1. **Cree una nueva consulta** para el punto final `Drivers Search`:
* Agregue una nueva consulta en Power BI y asígnele un nombre descriptivo, como `Drivers Search`, para identificar claramente su propósito.
* Abra la consulta en el **Editor avanzado** y pegue el siguiente código:
```
let
// Define the API endpoint URL
url = "https://integrations.alvys.com/api/p/v1/drivers/search",
// Define the body of the POST request
body = Text.ToBinary("{
""page"": 0,
""pageSize"": 50,
""status"": [
""OFF DUTY""
],
""name"": """",
""employeeId"": """",
""fleetName"": """",
""isActive"": true
}"),
// Retrieve the access token from AccessToken query
accessToken = AccessToken,
// Construct the Authorization header
authorizationHeader = "Bearer " & accessToken,
// Define the headers
headers = [
#"Authorization" = authorizationHeader,
#"Content-Type" = "application/json"
],
// Make the POST request
response = Web.Contents(url, [
Headers = headers,
Content = body
]),
// Parse the JSON response
jsonResponse = Json.Document(response),
// Extract the items from the response
drivers = jsonResponse[Items],
// Convert the list to a table
driversTable = Table.FromList(drivers, Splitter.SplitByNothing(), null, null, ExtraValues.Error),
#"Expanded Column1" = Table.ExpandRecordColumn(driversTable, "Column1", {"Id", "PhoneNumber", "Name", "Type", "Status", "Notes", "CreatedAt"}, {"Driver.Id", "Driver.PhoneNumber", "Driver.Name", "Driver.Type", "Driver.Status", "Driver.Notes", "Driver.CreatedAt"})
in
#"Expanded Column1"
```
Guarde la consulta y cierre el Editor avanzado.
**Resultado esperado**
* La consulta `Drivers Search` recuperará correctamente los datos de la API Alvys y mostrará la tabla **Conductores** en Power BI.
> Esta consulta le permite filtrar conductores dinámicamente según su estado u otros parámetros en el cuerpo de la solicitud. Modifique la consulta según sea necesario para ajustar los criterios de filtrado, como el nombre de la flota o el estado activo.
### **API de búsqueda de combustible:`/api/p/v{version}/fuel/search`**
**Cree una nueva consulta** para el punto final `Fuel Search`:
* Agregue una nueva consulta en Power BI y asígnele un nombre descriptivo, como `Fuel Search`, para identificar fácilmente su propósito.
* Abra la consulta en el **Editor avanzado** y pegue el siguiente código:
```
let
// Define the API endpoint URL
url = "https://integrations.alvys.com/api/p/v1/fuel/search",
// Define the body of the POST request
body = Text.ToBinary("{
""page"": 0,
""pageSize"": 100,
""fuelCardNumber"": """",
""truckNumber"": """",
""transactionRange"": {
""start"": ""2022-07-29T15:33:17.224Z"",
""end"": ""2025-07-29T15:33:17.224Z""
}
}"),
// Retrieve the access token from AccessToken query
accessToken = AccessToken,
// Construct the Authorization header
authorizationHeader = "Bearer " & accessToken,
// Define the headers
headers = [
#"Authorization" = authorizationHeader,
#"Content-Type" = "application/json"
],
// Make the POST request
response = Web.Contents(url, [
Headers = headers,
Content = body
]),
// Parse the JSON response
jsonResponse = Json.Document(response),
// Extract the items from the response
fuelTransactions = jsonResponse[Items],
// Convert the list to a table
fuelTransactionsTable = Table.FromList(fuelTransactions, Splitter.SplitByNothing(), null, null, ExtraValues.Error),
// Expand the table to show all relevant fields
expandedFuelTransactions = Table.ExpandRecordColumn(fuelTransactionsTable, "Column1", {"Id", "FuelCardNumber", "TruckNumber", "TransactionDate", "Amount", "Location", "CreatedAt"}, {"Id", "FuelCardNumber", "TruckNumber", "TransactionDate", "Amount", "Location", "CreatedAt"})
in
expandedFuelTransactions
```
Guarde la consulta y cierre el Editor avanzado.
**Resultado esperado**
* La consulta `Fuel Search` recuperará correctamente los datos de la API Alvys y mostrará la **tabla de transacciones de combustible** en Power BI.
> Esta consulta le permite filtrar y recuperar datos de transacciones de combustible de forma dinámica, utilizando parámetros como el número de tarjeta de combustible, el número de camión y el rango de fechas de la transacción. Ajuste el cuerpo de la consulta para refinar sus criterios de búsqueda según sea necesario.
### **API de búsqueda de facturas:`/api/p/v{version}/invoices/search`**
**Cree una nueva consulta** para el punto final `Invoice Search`:
* Agregue una nueva consulta en Power BI y asígnele un nombre descriptivo, como `Invoice Search`, para identificar claramente su propósito.
* Abra la consulta en el **Editor avanzado** y pegue el siguiente código:
```
let
// Define the API endpoint URL
url = "https://integrations.alvys.com/api/p/v1/invoices/search",
// Define the body of the POST request
body = Text.ToBinary("{
""page"": 0,
""pageSize"": 100,
""invoicedDateRange"": {
""start"": ""2023-08-02T09:53:34.251Z"",
""end"": ""2024-08-02T09:53:34.251Z""
},
""paidDateRange"": {
""start"": ""2023-08-02T09:53:34.251Z"",
""end"": ""2024-08-02T09:53:34.251Z""
},
""status"": [""Paid""],
""customerId"": """"
}"),
// Retrieve the access token from AccessToken query
accessToken = AccessToken,
// Construct the Authorization header
authorizationHeader = "Bearer " & accessToken,
// Define the headers
headers = [
#"Authorization" = authorizationHeader,
#"Content-Type" = "application/json"
],
// Make the POST request
response = Web.Contents(url, [
Headers = headers,
Content = body
]),
// Parse the JSON response
jsonResponse = Json.Document(response),
// Extract the items from the response
invoices = jsonResponse[Items],
// Convert the list to a table
invoicesTable = Table.FromList(invoices, Splitter.SplitByNothing(), null, null, ExtraValues.Error),
// Expand the table to show all relevant fields
#"Expanded Column1" = Table.ExpandRecordColumn(invoicesTable, "Column1", {"Id", "Number", "Type", "Status", "CreatedDate", "InvoicedDate", "DueDate", "PaidDate", "Total", "AmountPaid", "RemainingBalance", "OverPaymentAmount", "IsSubmitted", "LastSendDate", "Vendor", "Customer", "LineItems", "Loads", "Payments"}, {"Id", "Number", "Type", "Status", "CreatedDate", "InvoicedDate", "DueDate", "PaidDate", "Total", "AmountPaid", "RemainingBalance", "OverPaymentAmount", "IsSubmitted", "LastSendDate", "Vendor", "Customer", "LineItems", "Loads", "Payments"})
in
#"Expanded Column1"
```
Guarde la consulta y cierre el Editor avanzado.
**Resultado esperado**
* La consulta `Invoice Search` recuperará datos de la API Alvys y mostrará la **tabla Facturas** en Power BI.
> Esta consulta proporciona opciones de filtrado dinámico, como rangos de fechas, estado e ID de cliente, para obtener datos de facturas específicos. Puede ajustar el cuerpo de la solicitud para incluir filtros o parámetros adicionales según sea necesario.
### **API de búsqueda de mantenimiento:`/api/p/v{version}/maintenance/search`**
**Cree una nueva consulta** para el punto final `Maintenance Search`:
* Agregue una nueva consulta en Power BI y asígnele un nombre descriptivo, como `Maintenance Search`, para identificar claramente su propósito.
* Abra la consulta en el **Editor avanzado** y pegue el siguiente código:
```
let
// Define the API endpoint URL
url = "https://integrations.alvys.com/api/p/v1/maintenance/search",
// Define the body of the POST request
body = Text.ToBinary("{
""page"": 0,
""pageSize"": 100,
""dateRange"": {
""start"": ""2021-01-23T13:36:42.021Z"",
""end"": ""2024-08-23T13:36:42.021Z""
}
}"),
// Retrieve the access token from AccessToken query
accessToken = AccessToken,
// Construct the Authorization header
authorizationHeader = "Bearer " & accessToken,
// Define the headers
headers = [
#"Authorization" = authorizationHeader,
#"Content-Type" = "application/json"
],
// Make the POST request
response = Web.Contents(url, [
Headers = headers,
Content = body
]),
// Parse the JSON response
jsonResponse = Json.Document(response),
// Extract the items from the response
maintenanceItems = jsonResponse[Items],
// Convert the list to a table
maintenanceTable = Table.FromList(maintenanceItems, Splitter.SplitByNothing(), null, null, ExtraValues.Error),
// Expand the table to show all relevant fields
expandedMaintenance = Table.ExpandRecordColumn(maintenanceTable, "Column1", {"Id", "Date", "Description", "TruckNumber", "Status", "Cost", "CreatedAt"}, {"Id", "Date", "Description", "TruckNumber", "Status", "Cost", "CreatedAt"})
in
expandedMaintenance
```
Guarde la consulta y cierre el Editor avanzado.
**Resultado esperado**
* La consulta `Maintenance Search` recuperará datos de la API Alvys y mostrará la **tabla Registros de mantenimiento** en Power BI.
> Esta consulta le permite filtrar y recuperar registros de mantenimiento dinámicamente según rangos de fechas u otros parámetros. Puede modificar el cuerpo de la solicitud para ajustar los criterios de búsqueda o incluir filtros adicionales según sea necesario.
### **API de búsqueda de peaje:`/api/p/v{version}/tolls/search`**
**Cree una nueva consulta** para el extremo `Toll Search`:
* Agregue una nueva consulta en Power BI y asígnele un nombre descriptivo, como `Toll Search`, para identificar claramente su propósito.
* Abra la consulta en el **Editor avanzado** y pegue el siguiente código:
```
let
// Define the API endpoint URL
url = "https://integrations.alvys.com/api/p/v1/tolls/search",
// Define the body of the POST request
body = Text.ToBinary("{
""page"": 0,
""pageSize"": 100,
""dateRange"": {
""start"": ""2021-07-23T14:48:05.234Z"",
""end"": ""2024-07-23T14:48:05.234Z""
}
}"),
// Retrieve the access token from AccessToken query
accessToken = AccessToken,
// Construct the Authorization header
authorizationHeader = "Bearer " & accessToken,
// Define the headers
headers = [
#"Authorization" = authorizationHeader,
#"Content-Type" = "application/json"
],
// Make the POST request
response = Web.Contents(url, [
Headers = headers,
Content = body
]),
// Parse the JSON response
jsonResponse = Json.Document(response),
// Extract the items from the response
tollsItems = jsonResponse[Items],
// Convert the list to a table
tollsTable = Table.FromList(tollsItems, Splitter.SplitByNothing(), null, null, ExtraValues.Error),
// Expand the table to show all relevant fields
expandedTolls = Table.ExpandRecordColumn(tollsTable, "Column1", {"Id", "Date", "Amount", "Location", "TruckNumber", "CreatedAt"}, {"Id", "Date", "Amount", "Location", "TruckNumber", "CreatedAt"})
in
expandedTolls
```
Guarde la consulta y cierre el Editor avanzado.
**Resultado esperado**
* La consulta `Toll Search` recuperará datos de la API Alvys y mostrará la **tabla de transacciones de peaje** en Power BI.
> Esta consulta le permite recuperar dinámicamente datos de transacciones de peaje según rangos de fechas u otros parámetros. Puede ajustar el cuerpo de la solicitud para refinar sus criterios de búsqueda según sea necesario.
***
### **API de búsqueda de remolques:`/api/p/v{version}/trailers/search`**
**Cree una nueva consulta** para el punto final `Trailer Search`:
* Agregue una nueva consulta en Power BI y asígnele un nombre descriptivo, como `Trailer Search`, para identificar claramente su propósito.
* Abra la consulta en el **Editor avanzado** y pegue el siguiente código:
```
let
// Define the API endpoint URL
url = "https://integrations.alvys.com/api/p/v1/trailers/search",
// Define the body of the POST request
body = Text.ToBinary("{
""page"": 0,
""pageSize"": 50,
""status"": [""Active""],
""trailerNumber"": """",
""fleetName"": """",
""vinNumber"": """"
}"),
// Retrieve the access token from AccessToken query
accessToken = AccessToken,
// Construct the Authorization header
authorizationHeader = "Bearer " & accessToken,
// Define the headers
headers = [
#"Authorization" = authorizationHeader,
#"Content-Type" = "application/json"
],
// Make the POST request
response = Web.Contents(url, [
Headers = headers,
Content = body
]),
// Parse the JSON response
jsonResponse = Json.Document(response),
// Extract the items from the response
trailersItems = jsonResponse[Items],
// Convert the list to a table
trailersTable = Table.FromList(trailersItems, Splitter.SplitByNothing(), null, null, ExtraValues.Error),
// Expand the table to show all relevant fields
expandedTrailers = Table.ExpandRecordColumn(trailersTable, "Column1", {"Id", "TrailerNumber", "Status", "FleetName", "VinNumber", "CreatedAt"}, {"Id", "TrailerNumber", "Status", "FleetName", "VinNumber", "CreatedAt"})
in
expandedTrailers
```
Guarde la consulta y cierre el Editor avanzado.
**Resultado esperado**
* La consulta `Trailer Search` recuperará datos de la API Alvys y mostrará la **tabla de remolques** en Power BI.
> Esta consulta le permite recuperar dinámicamente datos del remolque según el estado, el nombre de la flota o el número del remolque. Ajuste el cuerpo de la solicitud para incluir filtros adicionales o refine sus criterios de búsqueda según sea necesario.
***
### **API de búsqueda de viajes:`/api/p/v{version}/trips/search`**
**Cree una nueva consulta** para el extremo `Trips Search`:
* Agregue una nueva consulta en Power BI y asígnele un nombre descriptivo, como `Trips Search`, para identificar claramente su propósito.
* Abra la consulta en el **Editor avanzado** y pegue el siguiente código:
```
let
// Define the API endpoint URL
url = "https://integrations.alvys.com/api/p/v1/trips/search",
// Define the body of the POST request
body = Text.ToBinary("{
""page"": 0,
""pageSize"": 100,
""status"": [""Covered""]
}"),
// Retrieve the access token from AccessToken query
accessToken = AccessToken,
// Construct the Authorization header
authorizationHeader = "Bearer " & accessToken,
// Define the headers
headers = [
#"Authorization" = authorizationHeader,
#"Content-Type" = "application/json"
],
// Make the POST request
response = Web.Contents(url, [
Headers = headers,
Content = body
]),
// Parse the JSON response
jsonResponse = Json.Document(response),
// Extract the items from the response
tripsItems = jsonResponse[Items],
// Convert the list to a table
tripsTable = Table.FromList(tripsItems, Splitter.SplitByNothing(), null, null, ExtraValues.Error),
// Expand the table to show all relevant fields
expandedTrips = Table.ExpandRecordColumn(tripsTable, "Column1", {"Id", "Status", "DriverName", "TruckNumber", "LoadNumber", "StartDate", "EndDate", "CreatedAt"}, {"Id", "Status", "DriverName", "TruckNumber", "LoadNumber", "StartDate", "EndDate", "CreatedAt"})
in
expandedTrips
```
Guarde la consulta y cierre el Editor avanzado.
**Resultado esperado**
* La consulta `Trips Search` recuperará datos de la API Alvys y mostrará la tabla **Viajes** en Power BI.
> Esta consulta le permite recuperar dinámicamente datos viaje en función de parámetros como el estado o la paginación. Ajuste el cuerpo de la solicitud para incluir filtros adicionales o refine sus criterios de búsqueda según sea necesario.
***
### **API de búsqueda de camiones:`/api/p/v{version}/trucks/search`**
**Cree una nueva consulta** para el extremo `Trucks Search`:
* Agregue una nueva consulta en Power BI y asígnele un nombre descriptivo, como `Trucks Search`, para identificar claramente su propósito.
* Abra la consulta en el **Editor avanzado** y pegue el siguiente código:
```
let
// Define the API endpoint URL
url = "https://integrations.alvys.com/api/p/v1/trucks/search",
// Define the body of the POST request
body = Text.ToBinary("{
""page"": 0,
""pageSize"": 100,
""status"": [""Active""],
""truckNumber"": """",
""fleetName"": """",
""vinNumber"": """",
""isActive"": true,
""registeredName"": """"
}"),
// Retrieve the access token from AccessToken query
accessToken = AccessToken,
// Construct the Authorization header
authorizationHeader = "Bearer " & accessToken,
// Define the headers
headers = [
#"Authorization" = authorizationHeader,
#"Content-Type" = "application/json"
],
// Make the POST request
response = Web.Contents(url, [
Headers = headers,
Content = body
]),
// Parse the JSON response
jsonResponse = Json.Document(response),
// Extract the items from the response
trucksItems = jsonResponse[Items],
// Convert the list to a table
trucksTable = Table.FromList(trucksItems, Splitter.SplitByNothing(), null, null, ExtraValues.Error),
// Expand the table to show all relevant fields
expandedTrucks = Table.ExpandRecordColumn(trucksTable, "Column1", {"Id", "TruckNumber", "Status", "FleetName", "VinNumber", "IsActive", "RegisteredName", "CreatedAt"}, {"Id", "TruckNumber", "Status", "FleetName", "VinNumber", "IsActive", "RegisteredName", "CreatedAt"})
in
expandedTrucks
```
Guarde la consulta y cierre el Editor avanzado.
**Resultado esperado**
* La consulta `Trucks Search` recuperará datos de la API Alvys y mostrará la **tabla Camiones** en Power BI.
> Esta consulta le permite recuperar dinámicamente datos del camión en función de parámetros como el estado, el nombre de la flota o el VIN. Ajuste el cuerpo de la solicitud para incluir filtros adicionales o refine sus criterios de búsqueda según sea necesario.
***
### **API de búsqueda de usuarios:`/api/p/v{version}/users/search`**
**Cree una nueva consulta** para el punto final `User Search`:
* Agregue una nueva consulta en Power BI y asígnele un nombre descriptivo, como `User Search`, para identificar claramente su propósito.
* Abra la consulta en el **Editor avanzado** y pegue el siguiente código:
```
let
// Define the API endpoint URL
url = "https://integrations.alvys.com/api/p/v1/users/search",
// Define the body of the POST request
body = Text.ToBinary("{
""page"": 0,
""pageSize"": 100,
""keyword"": """"
}"),
// Retrieve the access token from AccessToken query
accessToken = AccessToken,
// Construct the Authorization header
authorizationHeader = "Bearer " & accessToken,
// Define the headers
headers = [
#"Authorization" = authorizationHeader,
#"Content-Type" = "application/json"
],
// Make the POST request
response = Web.Contents(url, [
Headers = headers,
Content = body
]),
// Parse the JSON response
jsonResponse = Json.Document(response),
// Extract the items from the response
usersItems = jsonResponse[Items],
// Convert the list to a table
usersTable = Table.FromList(usersItems, Splitter.SplitByNothing(), null, null, ExtraValues.Error),
// Expand the table to show all relevant fields
expandedUsers = Table.ExpandRecordColumn(usersTable, "Column1", {"Id", "Name", "Email", "Role", "Status", "CreatedAt"}, {"Id", "Name", "Email", "Role", "Status", "CreatedAt"})
in
expandedUsers
```
Guarde la consulta y cierre el Editor avanzado.
**Resultado esperado**
* La consulta `User Search` recuperará datos de la API Alvys y mostrará la **tabla Usuarios** en Power BI.
> Esta consulta le permite recuperar dinámicamente datos del usuario en función de filtros como palabras clave o paginación. Puede ajustar el cuerpo de la solicitud para incluir criterios de búsqueda específicos para refinar aún más los resultados.
***
### **API de búsqueda de clientes:`/api/p/v{version}/customers/search`**
**Cree una nueva consulta** para el punto final `Customer Search`:
* Agregue una nueva consulta en Power BI y asígnele un nombre descriptivo, como `Customer Search`, para identificar claramente su propósito.
* Abra la consulta en el **Editor avanzado** y pegue el siguiente código:
```
let
// Define the API endpoint URL
url = "https://integrations.alvys.com/api/p/v1/customers/search",
// Define the body of the POST request
body = Text.ToBinary("{
""page"": 0,
""pageSize"": 100,
""statuses"": [""Active""],
""createdDateRange"": {}
}"),
// Retrieve the access token from AccessToken query
accessToken = AccessToken,
// Construct the Authorization header
authorizationHeader = "Bearer " & accessToken,
// Define the headers
headers = [
#"Authorization" = authorizationHeader,
#"Content-Type" = "application/json"
],
// Make the POST request
response = Web.Contents(url, [
Headers = headers,
Content = body
]),
// Parse the JSON response
jsonResponse = Json.Document(response),
// Extract the items from the response
customersItems = jsonResponse[Items],
// Convert the list to a table
customersTable = Table.FromList(customersItems, Splitter.SplitByNothing(), null, null, ExtraValues.Error),
// Expand the table to show all relevant fields
expandedCustomers = Table.ExpandRecordColumn(customersTable, "Column1", {"Id", "Name", "Status", "CreatedAt"}, {"Id", "Name", "Status", "CreatedAt"})
in
expandedCustomers
```
Guarde la consulta y cierre el Editor avanzado.
**Resultado esperado**
* La consulta `Customer Search` recuperará datos de la API Alvys y mostrará la **tabla Clientes** en Power BI.
> Esta consulta le permite recuperar dinámicamente datos de clientes filtrados por sus estados o rango de fechas creado. Modifique el cuerpo de la solicitud según sea necesario para incluir filtros adicionales o ajuste los criterios de búsqueda para obtener resultados más específicos.
***
### **API de errores salientes de visibilidad:`/api/p/v{version}/visibility/outbound/errors`**
**Cree una nueva consulta** para el punto final `Visibility Outbound Errors`:
* Agregue una nueva consulta en Power BI y asígnele un nombre descriptivo, como `Visibility Errors`, para identificar claramente su propósito.
* Abra la consulta en el **Editor avanzado** y pegue el siguiente código:
```
let
// Define the API endpoint URL
url = "https://integrations.alvys.com/api/p/v1/visibility/outbound/errors",
// Define the body of the POST request
body = Text.ToBinary("{
""page"": 0,
""pageSize"": 10,
""timeRange"": {
""start"": ""2024-11-05T16:58:54.450Z"",
""end"": ""2024-11-11T16:58:54.450Z""
}
}"),
// Retrieve the access token from AccessToken query
accessToken = AccessToken,
// Construct the Authorization header
authorizationHeader = "Bearer " & accessToken,
// Define the headers
headers = [
#"Authorization" = authorizationHeader,
#"Content-Type" = "application/json"
],
// Make the POST request
response = Web.Contents(url, [
Headers = headers,
Content = body
]),
// Parse the JSON response
jsonResponse = Json.Document(response),
// Extract the items from the response
errorsItems = jsonResponse[Items],
// Convert the list to a table
errorsTable = Table.FromList(errorsItems, Splitter.SplitByNothing(), null, null, ExtraValues.Error),
// Expand the table to show all relevant fields
expandedErrors = Table.ExpandRecordColumn(errorsTable, "Column1", {"Id", "ErrorMessage", "Timestamp", "ErrorDetails"}, {"Id", "ErrorMessage", "Timestamp", "ErrorDetails"})
in
expandedErrors
```
Guarde la consulta y cierre el Editor avanzado.
**Resultado esperado**
* La consulta `Visibility Outbound Errors` recuperará datos de la API Alvys y mostrará la **tabla de errores** en Power BI.
* Puede explorar las siguientes columnas en el resultado:
* **Id**: Identificador único para cada registro de error.
* **Mensaje de error**: Descripción del error.
* **Marca de tiempo**: la hora a la que ocurrió el error.
* **ErrorDetails**: detalles adicionales sobre el error, si están disponibles.
> Esta consulta le permite recuperar dinámicamente datos de errores salientes para operaciones de visibilidad en función de un rango de tiempo específico. Modifique el cuerpo de la solicitud para ajustar el rango de fechas, el tamaño de la página u otros parámetros para obtener resultados personalizados.