Fast-Weigh is a modern cloud-based truck ticketing, ordering, and dispatching platform.

The Fast-Weigh REST & GraphQL APIs allow system integrators to interface with the Fast-Weigh data model to extend functionality and/or extract data for third-party use.

Authentication

The Fast-Weigh REST & GraphQL API services use token-based authentication with a custom x-api-key HTTP header record. The token should be included with every call.

We have transitioned from using Basic Authentication with username/password credentials to token-based authentication. Existing integrations will continue to work, but please note that Basic Auth has been deprecated and will be removed in the future.

Graph QL

Your endpoint:

You can find your endpoint listed on the API Info page under the settings gear of the Fast-Weigh Web Portal.

Don't see API Info on your web portal?

1. You may not be an admin of your Fast-Weigh account. Check with a known admin to see if they can set up this key.

2. Your company's account may not have this enabled. If this is the case you will need to contact your sales or onboarding rep to get it enabled.

The endpoint should look something like this: https://server-name.fast-weigh.dev/v1/graphql

API schema explorer:

Your credentials will allow you to use the Insomnia tool to build queries. There, you can dive into the data model docs as well as test queries with the live editor.

Info for devs

GraphQL queries are handled via standard HTTP.

All GraphQL queries are POST requests

The first thing to understand is the GraphQL query itself is sent along in the body of the request. Since HTTP GET calls cannot include a request body, every call sent to the GraphQL server must be a POST request.

The request body is JSON-encoded

The request body itself should be JSON encoded. So the query you write will be transformed into something like this:

{
    "query": "query get_customers {Customer {CustomerID CustomerName}}"
}

Use libraries

Unless you are programming in a very obscure language, there are probably client libraries that can abstract away a lot of this for you.

These clients typically let you write your query in standard GraphQL syntax, and they handle the rest.

Also, thanks to GraphQL's build-in introspection, many libraries can generate a fully-typed API client for you to use!

Using Parameters

Parameters allow you to pass data into your GraphQL statement.

Common parameter types

• Int

• String

• Boolean

• date (yes, this one is lowercase)

Date formatting

It's important to note that dates must be formatted as YYYY-MM-DD when being passed as parameters.

Parameter arrays

Parameter arrays can be used for filters like the "_in" filter and are defined with []'s.

• [String!]

• [Int!]

GraphQL Crash Course

If you are not familiar with GraphQL, no worries. It's easy to learn. If you have experience working with SQL you'll feel right at home. The syntax also looks similar to a JSON document if you are used to working with responses from REST endpoints. In fact, the structure of the query is simply the format of the JSON response you'd like to receive back.

Another nice feature of GraphQL is schema introspection. That's a fancy way of saying that the fields are self-documenting. This allows us to build things like the Insomnia GraphQL Schema that provides autocompletion and field documentation that is always up to date with the latest API changes. (🍻cheers to no documentation lag!)

GraphQL basics

With GraphQL, you're still issuing a request to an HTTP endpoint just like you would for a REST API. The big difference is there is a single endpoint that services all requests.

For Fast-Weigh, the endpoint looks like this:

https://<your-servername-here>.fast-weigh.dev/v1/graphql

Calling the endpoint directly

If you calling the GraphQL endpoint directly, all requests must be POST requests with a JSON encoded query as the body of the request (Content-Type: application/json)

Writing a simple query

Here's a simple query that requests a few fields from the Customer GraphQL type:

query customers {
  Customer {
    CustomerID
    CustomerName
    ContactName
    ContactPhone
  }
}

Let's break that syntax into its parts:

<ActionType> <QueryName> {
  <Type> {
    <TypeField1>
    <TypeField2>
  }
}

• ActionType: GraphQL endpoints support the following "ActionTypes". Note that Fast-Weigh only supports the "query" type at this time.

  • query: ✅ Similar to a SQL SELECT statement

  • subscription: ❌ A WebSocket based live data stream

  • mutation: ❌ Similar to a SQL UPDATE or INSERT statement

• QueryName: This is the identifier for the query. You can give it any name you'd like. In the GET CUSTOMERS example the QueryName could have been "getAllCustomers", "get-customers-list", or anything else you could dream up. I went with "customers" for brevity.

• Type: If you are familiar with SQL, you can think of this as the corresponding SQL table.

• TypeField: Again, if you are familiar with SQL, you can think of this as the columns within the corresponding SQL table.

The response back from this query will be a JSON response matching the format requested.

If a requested field has no value, it will be omitted from the response. This compresses the payload size and increases performance.

Finding the available fields

GraphQL introspection powers autocomplete within our recommended tooling.

This tool also allows you to browse the schema, as explained here.

Joining via relationships

Relationships in GraphQL can be of 2 types:

• Object: 1 to 1

• Array: 1 to many

Object relationships

Object relationships will embed a single subtype in the response.

For example, the Customer type has an Object Relationship with a TaxCode.

So a query like this:

query customers_with_taxcode {
  Customer {
    CustomerID
    CustomerName
    TaxCode {
      Code
    }
  }
}

Will result in a response that looks like this:

{
  "data": {
    "Customer": [
      {
        "CustomerID": "",
        "CustomerName": "",
        "TaxCode": {
          "Code": ""
        }
      }
    ]
  }
}

Array relationships

Array relationships will nest an list of objects in the response.

As an example, a Customer may have many Orders.

So the Customer type has an array relationship with orders. And querying for the Orders would look some like this:

query customers_and_orders {
  Customer {
    CustomerID
    CustomerName
    Orders {
      OrderNumber
      Description
    }
  }
}

And result in:

{
  "data": {
    "Customer": [
      {
        "CustomerID": "",
        "CustomerName": "",
        "Orders": [
          {
            "OrderNumber": 1,
            "Description": "",
          },
          {
            "OrderNumber": 2,
            "Description": "",
          }
        ]
      }
    ]
  }
}

Filtering data

Until now, the queries we've written would have returned all results from the Customer table.

To filter the results, GraphQL supplies us with a few syntax options.

Limit & offset

This one is pretty easy. Within the Type your are querying, supply the limit argument with an integer specifying the number of results you'd like returned.

query customers_and_orders {
  Customer(limit: 10) {
    CustomerID
    CustomerName
    Orders {
      OrderNumber
      Description
      PONumber
    }
  }
}

Note that this only limits the Customer type to 10 results. So the nested Orders array may contain many more. You can limit on the nested Orders type in the same way.

query customers_and_orders {
  Customer(limit: 10) {
    CustomerID
    CustomerName
    Orders(limit: 10) {
      OrderNumber
      Description
      PONumber
    }
  }
}

If you want to limit each response but still cycle through to retrieve all of the filtered data, you can use an offset loop to go through the next set of 10 records.

In practice, you'd want to increment this number on each call by whatever your limit is. So the first call would be offset of 0, second call an offset of 10, then 20, 30, and so on. Once you get a payload with fewer records than your limit, you'll know there are no more records to retrieve and can stop issuing queries.

query customers_and_orders {
  Customer(limit: 10, offset: 10) {
    CustomerID
    CustomerName
    Orders {
      OrderNumber
      Description
      PONumber
    }
  }
}

Order by

Building on the query above, you can order the results by adding an "order_by" field to your arguments.

query customers_and_orders {
  Customer(
    limit: 10,
    order_by: {CustomerID: asc}
  ) {
    CustomerID
    CustomerName
    Orders {
      OrderNumber
      Description
      PONumber
    }
  }
}

Notice you must pass an object to the "order_by" argument with the field you'd like to order, as well as the sort direction.

The following sort directions are permitted:

• asc

• asc_nulls_first

• asc_nulls_last

• desc

• desc_nulls_first

• desc_nulls_last

Where clauses

Let's modify the query once again and supply a "where" argument.

The "where" argument can apply a number of different filters to a given field.

• _eq: equal to

• _neq: not equal to

• _gt: greater than

• _gte: great than or equal to

• _lt: less than

• _lte: less than or equal to

• _in: exists in an array of values

• _nin: does not exist in an array of values

• _like: matches some part of the given string

• _nlike: does not match some part of the - given string

• _is_null: ...is null 😆

Here's an example of querying for just Customers in the State of Tennessee:

query customers_with_taxcode {
  Customer(
    where: {State: {_eq: "TN"}}
  ) {
    CustomerID
    CustomerName
    Orders {
      OrderNumber
      Description
      PONumber
    }
  }
}

And here's an example of passing an array of States to the filter using the "_in" clause:

query customers_with_taxcode {
  Customer(
    where: {State: {_in: ["TN","KY","GA"]}}
  ) {
    CustomerID
    CustomerName
    Orders {
      OrderNumber
      Description
      PONumber
    }
  }
}

Using multiple filters with _and / _or

You can use the _and / _or operators along with the other "where" filters to create more complex queries.

• _and: Data must satisfy all of the included filters

• _or: Data must satisfy at least one of the included filters

These operators open up an array using "[]" brackets that contain all the filters you wish to apply.

_and:

This query will return a Customer only if it is within the provided States, and also has a Country set to "US".

query customers_with_taxcode {
  Customer(
    where: {_and: [
      {State: {_in: ["TN","KY","GA"]}},
      {Country: {_eq: {_eq: "US"}}}
    ]}
  ) {
    CustomerID
    CustomerName
    TaxCode {
      Code
    }
  }
}

_or:

This query will return a Customer if it's within the given States, OR if its CustomerID field contains "100".

query customers_with_taxcode {
  Customer(
    where: {_or: [
      {State: {_in: ["TN","KY","GA"]}},
      {CustomerID: {_like: "100"}}
    ]}
  ) {
    CustomerID
    CustomerName
    TaxCode {
      Code
    }
  }
}

Filtering on nested Types

Remember that filters can also be used on nested Types as well. But there is a difference for "where" filters in Object vs Array relations.

Object relationship "where" filter

For Object relationships, you'll apply the filter on the parent. For example, a Customer can only have a single TaxCode. So to filter the Customers TaxCode you could write:

query customers_with_taxcode {
  Customer(
    where: {TaxCode: {Code: {_eq: "EXEMPT"}}}
  ) {
    CustomerID
    CustomerName
    TaxCode {
      Code
    }
  }
}

Array relationship "where" filter

For Array relationships, you'll typically apply the filter on the nested array itself. For example, a Customer can have many Orders. So to filter the Orders returned you would write:

query customers_and_orders {
  Customer(
    where: {State: {_in: ["TN","KY","GA"]}}
  ) {
    CustomerID
    CustomerName
    Orders(
      where: {Status: {_eq: "A"}}
    ) {
      OrderNumber
      Description
      PONumber
    }
  }
}

Compound queries

Completely separate requests can also be merged within a single query. This is useful if you need to bring in data from multiple tables and only want to make a single HTTP call to do so.

Typically compound queries would only be used to stitch together the responses of smaller queries. You would not want to combine multiple large payload queries in the same request/response as this can be quite taxing to fetch and parse due to query complexity and payload size.

Here's an example request for some base resources within Fast-Weigh. These lists are generally quite short and are good candidates for compound queries if applicable to your use case.

query sample_compound_query {
  Region {
    RegionName
    RegionDescription
  }
  Salesperson {
    Name
    Email
  }
  TaxCode {
    Code
    MaterialPercent
    FreightPercent
    SurchargePercent
  }
  Product {
    ProductID
    ProductDescription
  }
}

Results in:

{
  "data": {
    "Region": [
      {
        "RegionName": "",
        "RegionDescription": ""
      },
    ],
    "Salesperson": [
      {
        "Name": "",
        "Email": ""
      },
    ],
    "TaxCode": [
      {
        "Code": "",
        "MaterialPercent": 0.0000000,
        "FreightPercent": 0.0000000,
        "SurchargePercent": 0.0000000
      },
    ],
    "Product": [
      {
        "ProductID": "",
        "ProductDescription": ""
      },
    ]
  }
}

Putting queries into practice

Once you've got the query basics down, it's time to start experimenting and using them for your own use case in Insomnia or start quering via HTTP and code in your programming language of choice.

GraphQL and Reporting Quickstart

• Download & install Insomnia Client: https://insomnia.rest/download

• Download & install the Insomnia Fast-Weigh Reporting Plugin: https://insomnia.rest/plugins/insomnia-plugin-fast-weigh

• Download the Telerik Reporting .exe (no install needed) and example reports: Download here

GraphQL Query Examples

query GetTrucks($fromDate: smalldatetime!) {
  Truck(where: { LastLoadDate: { _gte: $fromDate } }) {
    TruckID
    LastLoadDate
    TareWeight
    Hauler {
      HaulerID
      HaulerName
    }
  }
}

Query Variables

{
    "fromDate": "2022-02-01"
}

query GetCustomers($state: String) {
  Customer(where: { State: { _eq: $state } }) {
    CustomerID
    CustomerName
    Address1
    Address2
    City
    State
    Zip
    TaxCode {
      Code
    }
  }
}

Query Variables

{
    "state": "TN"
}

query GetOrders {
  Order(where: {Status: {_eq: "A"}}) {
    OrderNumber
    Description
    PONumber
    DefaultJob
    Customer {
      CustomerID
      CustomerName
    }
    OrderProducts {
      Product {
        ProductID
        ProductDescription
      }
      UnitPrice
      FreightRate
    }
  }
}

query GetTickets($FromDate: date!, $ToDate: date!) {
  LoadTicket(
    where: {
      _and: [
        { TicketDate: { _gte: $FromDate } }
        { TicketDate: { _lte: $ToDate } }
      ]
    }
  ) {
    TicketKey
    TicketNumber
    Void
    NetWeight
    TicketDate
    OrderProduct {
      Product {
        ProductKey
        ProductID
        ProductDescription
        UnitOfMeasure
      }
    }
    Order {
      OrderKey
      OrderNumber
      Description
      Customer {
        CustomerKey
        CustomerID
        CustomerName
      }
    }
    Truck {
      TruckKey
      TruckID
      Hauler {
        HaulerKey
        HaulerID
        HaulerName
      }
    }
    RatesAndAmounts {
      MaterialAmountCalculated
      FreightAmountCalculated
      SurchargeAmountCalculated
    }
  }
}

Query Variables

{
    "FromDate": "2022-02-13",
    "ToDate": "2022-02-23"
}

GraphQL Schema

GraphQL provides a live schema via introspection of the API endpoint. That's a nerdy way of saying the available fields are always up to date and you don't have to worry about the documentation being stale!

How to View the Schema

Head to the Tooling page and follow the instructions listed there to view the schema docs via the Insomnia Client.

Check out the Graph behind the GraphQL here: https://graph.fast-weigh.dev/

Making Sense of the Schema

GraphQL queries are based on "Types". These types are similar to a SQL Table.

A "Customer" database table, for example, becomes a "Customer" type in GraphQL.

Root type:

First, you'll need to drill into a "root" type, two of which are available:

• query_root

• subscription_root

In the vast majority of cases, query_root is what you're after. It's equivalent to a SELECT query in SQL.

The subscription_root is useful for programmers wanting a live websocket connection to the data.

If you're following along, click into the query_root to continue.

Exploring a GraphQL type:

Inside the query_root you'll see a list of available Types to explore.

Let's click into the Customer type.

Here, you'll see a link to view the fields available on the Customer type at the top.

You'll also see a list of arguments that can be passed into the type to filter or order the results returned.

For example, the limit argument tells you that you can pass an integer to limit the number of results.

query GetOneHundredCustomers {
  Customer(limit: 100) {
    CustomerID
  }
}

Arguments/filters are covered further in our GraphQL Crash Course.

Clicking inside the actual Customer type at the top reveals the fields available to you within that type.

Object relationships:

Object relationships on a type are 1:1 relationships with another type.

On the Customer type, if you scroll to the bottom, you'll see the TaxCode field. This is listed as an object type, meaning that if you query for the Customer's TaxCode the result will be a single TaxCode object.

Array relationships:

Array relationships on a type are 1:N relationships with another type.

On the Customer type, you can find the Orders field. This is listed as an array type, meaning that querying for Orders will return a nested array of Orders for the Customer(s) you are filtering for.

Helpful Telerik Links

Telerik Support Page

Telerik Designing Reports Knowledge Base

Telerik Reporting Forum

Getting Started with Telerik Report Designer (Video)

Web Service Data Source Information

Report Parameters Overview

Report Structure Overview

Expressions Overview

Functions Overview

Sorting Data Overview

Filtering Data Overview

Grouping Data Overview

Conditional Formatting

Excel Rendering Design Considerations

Connecting Power BI to GraphQL

GraphQL can be connected into Power BI to visualize your data. In order to connect it up, you will need to be familiar enough with M Query to manipulate the Data Source Advanced Editor to connect in the API

1. Create a new Power BI File and click Get Data.

2. Select a Blank Query as your Data Source for now.

3. Leave this blank.

4. Add in a new parameter called x-api-key , set the Type to Text, and paste your API Key into the Current Value.

5. Add in PBI parameters for any variables in your GraphQL Query.

6. In this example, we have a To and From Date variable that we call RangeStart and RangeEnd in the PBI Parameters.

7. Your Queries should look something like this:
8. Navigate back to your blank Query .

9. Right-click the name in the Queries list and select advanced editor .

10. Copy and paste the pre-written query below into the Advanced Editor (overwriting what was already there).

11. It will automatically use your API key and the date parameters you set with a pre-written Get Ticket query.

12. Copy

          let
          //To and From Date PBI parameters, formatted in yyyy-MM-dd format
          FromDate = Number.ToText(Date.Year(RangeStart)) &"-"& Text.PadStart(Number.ToText(Date.Month(RangeStart)),2,"0") &"-"& Text.PadStart(Number.ToText(Date.Day(RangeStart)),2,"0"),
          ToDate = Number.ToText(Date.Year(RangeEnd))&"-"&Text.PadStart(Number.ToText(Date.Month(RangeEnd)),2,"0")&"-"&Text.PadStart(Number.ToText(Date.Day(RangeEnd)),2,"0"),
          //URL should be your GraphQL Endpoint URL
          url = "https://fwt.fast-weigh.dev/v1/graphql",
          //Header pulls API Key from x-api-key PBI parameter
          header = 
          [#"x-api-key" = #"x-api-key",
          #"Content-Type" = "application/json"],
          //Body is copied from Insomnia "Fast-Weigh: Copy Telerik Body" plugin
          //You will need to surround the body in quotes, and then escape any internal body quotes by using 2 in a row instead of one: ""
          //In the variables, you need to add 3 quotes to end the statement, an ampersand to join the parameters, and the PBI parameter name. 
          //For Example: "" " & FromDate & " ""
          RequestBody=
          "{
          ""query"": ""query GetTickets($FromDate: date!, $ToDate: date!) {\n  LoadTicket(\n    where: {_and: [\n                        {TicketDate: {_gte: $FromDate}}, \n                        {TicketDate: {_lte: $ToDate}}\n                ]}\n        ) \n        {\n    TicketKey # Unique, auto-assigned key\n    TicketNumber\n    Void\n    NetWeight\n    Operator\n    InvoiceNum\n    BatchNum\n    InvoiceHistoryKey\n    InvoiceDate\n    TicketDate # Only the Date\n    TicketDateTime # The Date and the Time in UTC\n    UTCOffset # The UTCoffset that needs to be added to the TicketDateTime to get the correct time\n    OrderProduct { # The specific version of a Product on an Order\n      OrderProductKey # Unique, auto-assigned key\n      Description # The pricing description for the specific version of the product\n      FreightType\n      Product { # The Product used for the OrderProduct\n        ProductKey # Unique, auto-assigned key\n        ProductID\n        ProductDescription\n        UnitOfMeasure\n      }\n      Location {\n        LocationKey # Unique, auto-assigned key\n        LocationName\n        LocationDescription\n      }\n      Yard {\n              YardKey # Unique, auto-assigned key\n        YardName\n        YardDescription\n      }\n    }\n    Order {\n      OrderKey # Unique, auto-assigned key\n      OrderNumber\n      Description\n      DefaultJob\n      PONumber\n      OpenProductOrder\n      Status\n      DeliveryLocation\n      PayType\n      UseHaulZones\n      Customer {\n        CustomerKey # Unique, auto-assigned key\n        CustomerID\n        CustomerName\n        TermsCode\n        Salesperson { # Default Salesperson set on Customer\n          Name\n        }\n      }\n      Salesperson { # Actual Salesperson set on the Order\n        Name\n      }\n    }\n    Region {\n      RegionKey # Unique, auto-assigned key\n      RegionName\n      RegionDescription\n    }\n    TaxCode { # The Tax Code set on the Ticket and what is used for Billing\n      Code\n      Description\n      MaterialPercent\n      MaterialPercent2\n      FreightPercent\n      FreightPercent2\n      SurchargePercent\n      SurchargePercent2\n    }\n    Truck {\n      TruckKey # Unique, auto-assigned key\n      TruckID\n      Hauler {\n        HaulerKey # Unique, auto-assigned key\n        HaulerID\n        HaulerName\n      }\n    }\n    HaulZone{\n      FreightType\n    }\n    RatesAndAmounts { # The dollar amounts on the Tickets\n      MaterialRateOriginal\n      FreightRateOriginal\n      SurchargeRateOriginal\n      MaterialAmountCalculated\n      FreightAmountCalculated\n      SurchargeAmountCalculated\n      MaterialTaxCalculated\n      MaterialTax2Calculated\n      FreightTaxCalculated\n      FreightTax2Calculated\n      SurchargeTaxCalculated\n      SurchargeTax2Calculated\n      HaulerRateOriginal\n      HaulerAmountCalculated\n    }\n  }\n}\n"",
          ""variables"": {
          ""FromDate"": """ & FromDate & """,
          ""ToDate"": """ & ToDate & """
          }
          }",
          //The following 5 steps convert the response to a table that Power BI can expand
          webdata = Web.Contents(url, [Headers=header, Content = Text.ToBinary(RequestBody)]),
          response = Json.Document(webdata),
          data = response[data],
          LoadTicket = data[LoadTicket],
          ConvertToTable = Table.FromList(LoadTicket, Splitter.SplitByNothing(), null, null, ExtraValues.Error),
          //These steps can be done directly in the editor by expanding each column from the header
          #"Expanded Column1" = Table.ExpandRecordColumn(ConvertToTable, "Column1", {"TicketKey", "TicketNumber", "Void", "NetWeight", "Operator", "InvoiceNum", "BatchNum", "InvoiceHistoryKey", "InvoiceDate", "TicketDate", "TicketDateTime", "UTCOffset", "OrderProduct", "Order", "Region", "TaxCode", "Truck", "HaulZone", "RatesAndAmounts"}, {"TicketKey", "TicketNumber", "Void", "NetWeight", "Operator", "InvoiceNum", "BatchNum", "InvoiceHistoryKey", "InvoiceDate", "TicketDate", "TicketDateTime", "UTCOffset", "OrderProduct", "Order", "Region", "TaxCode", "Truck", "HaulZone", "RatesAndAmounts"}),
          #"Expanded OrderProduct" = Table.ExpandRecordColumn(#"Expanded Column1", "OrderProduct", {"OrderProductKey", "Description", "FreightType", "Product", "Location", "Yard"}, {"OrderProductKey", "Description", "FreightType", "Product", "Location", "Yard"}),
          #"Expanded Product" = Table.ExpandRecordColumn(#"Expanded OrderProduct", "Product", {"ProductKey", "ProductID", "ProductDescription", "UnitOfMeasure"}, {"ProductKey", "ProductID", "ProductDescription", "UnitOfMeasure"}),
          #"Expanded Location" = Table.ExpandRecordColumn(#"Expanded Product", "Location", {"LocationKey", "LocationName", "LocationDescription"}, {"LocationKey", "LocationName", "LocationDescription"}),
          #"Expanded Yard" = Table.ExpandRecordColumn(#"Expanded Location", "Yard", {"YardKey", "YardName", "YardDescription"}, {"YardKey", "YardName", "YardDescription"}),
          #"Expanded Order" = Table.ExpandRecordColumn(#"Expanded Yard", "Order", {"OrderKey", "OrderNumber", "Description", "DefaultJob", "PONumber", "OpenProductOrder", "Status", "DeliveryLocation", "PayType", "UseHaulZones", "Customer", "Salesperson"}, {"OrderKey", "OrderNumber", "Description.1", "DefaultJob", "PONumber", "OpenProductOrder", "Status", "DeliveryLocation", "PayType", "UseHaulZones", "Customer", "Salesperson"}),
          #"Expanded Customer" = Table.ExpandRecordColumn(#"Expanded Order", "Customer", {"CustomerKey", "CustomerID", "CustomerName", "TermsCode", "Salesperson"}, {"CustomerKey", "CustomerID", "CustomerName", "TermsCode", "Salesperson.1"}),
          #"Expanded Region" = Table.ExpandRecordColumn(#"Expanded Customer", "Region", {"RegionKey", "RegionName", "RegionDescription"}, {"RegionKey", "RegionName", "RegionDescription"}),
          #"Expanded TaxCode" = Table.ExpandRecordColumn(#"Expanded Region", "TaxCode", {"Code", "Description", "MaterialPercent", "MaterialPercent2", "FreightPercent", "FreightPercent2", "SurchargePercent", "SurchargePercent2"}, {"Code", "Description.2", "MaterialPercent", "MaterialPercent2", "FreightPercent", "FreightPercent2", "SurchargePercent", "SurchargePercent2"}),
          #"Expanded Truck" = Table.ExpandRecordColumn(#"Expanded TaxCode", "Truck", {"TruckKey", "TruckID", "Hauler"}, {"TruckKey", "TruckID", "Hauler"}),
          #"Expanded Hauler" = Table.ExpandRecordColumn(#"Expanded Truck", "Hauler", {"HaulerKey", "HaulerID", "HaulerName"}, {"HaulerKey", "HaulerID", "HaulerName"}),
          #"Expanded RatesAndAmounts" = Table.ExpandRecordColumn(#"Expanded Hauler", "RatesAndAmounts", {"MaterialRateOriginal", "FreightRateOriginal", "SurchargeRateOriginal", "MaterialAmountCalculated", "FreightAmountCalculated", "SurchargeAmountCalculated", "MaterialTaxCalculated", "MaterialTax2Calculated", "FreightTaxCalculated", "FreightTax2Calculated", "SurchargeTaxCalculated", "SurchargeTax2Calculated", "HaulerRateOriginal", "HaulerAmountCalculated"}, {"MaterialRateOriginal", "FreightRateOriginal", "SurchargeRateOriginal", "MaterialAmountCalculated", "FreightAmountCalculated", "SurchargeAmountCalculated", "MaterialTaxCalculated", "MaterialTax2Calculated", "FreightTaxCalculated", "FreightTax2Calculated", "SurchargeTaxCalculated", "SurchargeTax2Calculated", "HaulerRateOriginal", "HaulerAmountCalculated"}),
          //These are nullable fields, and they have to be expanded manually. Make sure to rename column names if any are duplicates like the Name columns
          #"Expanded Salesperson" = Table.ExpandRecordColumn(#"Expanded RatesAndAmounts", "Salesperson", {"Name"}),
          #"Renamed Columns" = Table.RenameColumns(#"Expanded Salesperson",{{"Name", "OrderSalespersonName"}}),
          #"Expanded Salesperson.1" = Table.ExpandRecordColumn(#"Renamed Columns", "Salesperson.1", {"Name"}),
          #"Renamed Columns1" = Table.RenameColumns(#"Expanded Salesperson.1",{{"Name", "CustomerSalespersonName"}}),
          #"Expanded HaulZone" = Table.ExpandRecordColumn(#"Renamed Columns1", "HaulZone", {"HZFreightType"}),
          //After the nullable fields are expanded, make sure to replace the errors with a blank
          #"Replaced Errors" = Table.ReplaceErrorValues(#"Expanded HaulZone", {{"CustomerSalespersonName", ""}, {"OrderSalespersonName", ""}, {"HZFreightType", ""}}),
          //Make sure to rename any other duplicate headers
          #"Renamed Columns2" = Table.RenameColumns(#"Replaced Errors",{{"Description", "PricingDescription"}, {"Description.1", "OrderDescription"}}),
          //Use the Detect Type tool to set the header types automatically, if they are not already set
          #"Changed Type" = Table.TransformColumnTypes(#"Renamed Columns2",{{"TicketKey", Int64.Type}, {"TicketNumber", type number}, {"Void", type logical}, {"NetWeight", type number}, {"Operator", type text}, {"InvoiceNum", Int64.Type}, {"BatchNum", type text}, {"InvoiceHistoryKey", Int64.Type}, {"InvoiceDate", type date}, {"TicketDate", type date}, {"TicketDateTime", type datetime}, {"UTCOffset", Int64.Type}, {"OrderProductKey", Int64.Type}, {"PricingDescription", type text}, {"FreightType", type text}, {"ProductKey", Int64.Type}, {"ProductID", type text}, {"ProductDescription", type text}, {"UnitOfMeasure", type text}, {"LocationKey", Int64.Type}, {"LocationName", type text}, {"LocationDescription", type text}, {"YardKey", Int64.Type}, {"YardName", type text}, {"YardDescription", type text}, {"OrderKey", Int64.Type}, {"OrderNumber", Int64.Type}, {"OrderDescription", type text}, {"DefaultJob", type text}, {"PONumber", type text}, {"OpenProductOrder", type logical}, {"Status", type text}, {"DeliveryLocation", type text}, {"PayType", type text}, {"UseHaulZones", type logical}, {"CustomerKey", Int64.Type}, {"CustomerID", type text}, {"CustomerName", type text}, {"TermsCode", Int64.Type}, {"CustomerSalespersonName", type text}, {"OrderSalespersonName", type text}, {"RegionKey", Int64.Type}, {"RegionName", type text}, {"RegionDescription", type text}, {"Code", type text}, {"Description.2", type text}, {"MaterialPercent", type number}, {"MaterialPercent2", type number}, {"FreightPercent", type number}, {"FreightPercent2", type number}, {"SurchargePercent", type number}, {"SurchargePercent2", type number}, {"TruckKey", Int64.Type}, {"TruckID", type text}, {"HaulerKey", Int64.Type}, {"HaulerID", type text}, {"HaulerName", type text}, {"HZFreightType", type any}, {"MaterialRateOriginal", type number}, {"FreightRateOriginal", Int64.Type}, {"SurchargeRateOriginal", Int64.Type}, {"MaterialAmountCalculated", type number}, {"FreightAmountCalculated", type number}, {"SurchargeAmountCalculated", type number}, {"MaterialTaxCalculated", type number}, {"MaterialTax2Calculated", type number}, {"FreightTaxCalculated", type number}, {"FreightTax2Calculated", type number}, {"SurchargeTaxCalculated", type number}, {"SurchargeTax2Calculated", type number}, {"HaulerRateOriginal", Int64.Type}, {"HaulerAmountCalculated", type number}}),
          #"Replaced Value" = Table.ReplaceValue(#"Changed Type","U","Per Unit",Replacer.ReplaceText,{"FreightType"}),
          #"Replaced Value1" = Table.ReplaceValue(#"Replaced Value","L","Per Load",Replacer.ReplaceText,{"FreightType"}),
          #"Replaced Value2" = Table.ReplaceValue(#"Replaced Value1","A","Active",Replacer.ReplaceText,{"Status"}),
          #"Replaced Value3" = Table.ReplaceValue(#"Replaced Value2","I","Inactive",Replacer.ReplaceText,{"Status"}),
          #"Replaced Value4" = Table.ReplaceValue(#"Replaced Value3","C","Closed",Replacer.ReplaceText,{"Status"}),
          #"Replaced Value5" = Table.ReplaceValue(#"Replaced Value4","C","Charge Hide",Replacer.ReplaceText,{"PayType"}),
          #"Replaced Value6" = Table.ReplaceValue(#"Replaced Value5","D","Credit Card",Replacer.ReplaceText,{"PayType"}),
          #"Replaced Value7" = Table.ReplaceValue(#"Replaced Value6","K","Check",Replacer.ReplaceText,{"PayType"}),
          #"Replaced Value8" = Table.ReplaceValue(#"Replaced Value7","S","Charge Show",Replacer.ReplaceText,{"PayType"}),
          #"Replaced Value9" = Table.ReplaceValue(#"Replaced Value8","X","Cash",Replacer.ReplaceText,{"PayType"})
          in
          #"Replaced Value9"
       

13. When prompted to Specify How To Connect , click "Edit Credentials" and use Anonymous Access to connect.

Using Telerik Report Parameters

Required Parameters

When building your reports within Telerik, you have the ability to link your GraphQL Where Clause directly to dynamic parameters within Telerik to filter your data.

1. Ensure that you have your Where Clause set up within your GraphQL Query.

Tip: For more information about GraphQL Where Clauses, check out our article on Using Parameters in GraphQL.

1. When you copy your query Body over from Insomnia, it should auto-generate Telerik parameter connectors in your variables.

3. 1. Make sure the Type is set to Inline for any Parameters that are passed to your GraphQL Body.

6. Setup the Telerik Parameter in the Report Parameter Editor pop-up

   • For more information about what the settings here are, check out this Telerik Report Parameters Docs

   • Click here for more info on the difference between Blank and Null.

7. Some GraphQL Where clause formats will need to add extra formatting in your Value

8. • Integers: Make sure your body does not have quotes around the @variable in the Body.

   • Dates: Make sure your body does have quotes around the @variable in the Body.

     • You will also need to add the following formatting to the Value expression to ensure that the date is in the correct Year-Month-Day format: = Format("{0:yyyy-MM-dd}", Parameters.NAME.Value )

   • String Arrays: Make sure your body does not have quotes and does have brackets around the @variable in the Body.

     • You will also need to add the following formatting to the Value expression to ensure that each value selected is wrapped in quotes and separated by commas: ='"' + Join('","', Parameters.NAME.Value ) + '"'

   • Integer Arrays: Make sure your body does not have quotes and does have brackets around the @variable in the Body.
9. Click Next to preview your data using the Design-Time Value, then click Finish.

Optional Parameters

In addition to Required Parameters that directly filter what is returned from your Data Source, you can also use Telerik by itself to create optional parameters and filters.

2. Add in a new Parameter in the Report Parameter Editor pop-up

   • For more information about what the settings here are, check out this Telerik Report Parameters Docs.

   • Click here for more info on the difference between Blank and Null.

3. Click OK to close the pop-up.

5. Add a new Filter that you will map to your new Report Parameter

   • Since we want this parameter to pull in everything when blank or filter to one customer when filled out, we will need to add in more to the expression than a simple filter.

6. Under the Expression side of the filter editor, click on the drop-down arrow and select <Expression>

9. Begin the conditional IIf statement with a check to see if the parameter is blank.

   2. In the text box, click between the end of the Value and the parenthesis and add in an equal sign and an empty quote: = ""
10. Click in the text box after the empty quotes and add a comma to begin the truePart of the IIf statement.

    1. Note: Here, we want nothing to happen if the expression is true (the parameter is blank).

    2. Add in another empty quote: ""
11. After the truePart, add another comma to begin the falsePart.

    1. Navigate to Fields and double-click on the field you want to populate if the parameter is not blank (what it will be matching).

Note: Here, we want the Customer ID to populate if the expression is false (the parameter is not blank).

2. Click OK to close the Expression Editor.

3. Under the Value side of the filter editor, click on the drop-down arrow and select the Parameter.

5. Navigate to the Home tab on the top of the Report Designer and click Preview to test out the report.

   • You should be able to leave your new parameter blank (you may have to click inside of the field and then click out in the report designer so it registers and blank) or type in a value to filter the report to that single value

Handling Nullable Tables in Telerik

Sometimes, you may have a table linked in your GraphQL query that can be set or completely blank depending on the parent table it is connected to.

=Fields.Order.Salesperson.Name

"An error has occurred while processing TextBox 'textBox2': The expression contains object 'Name' that is not defined in the current context."

If you do receive this error for the Salesperson Name field (or any other field), there is a workaround you can use to display the name when it is set or hide the object entirely when it is blank.

4. Find the Data section of the Properties.

5. Click on the "..." button to edit the Bindings.

7. Add a new Binding.

   1. Set the Property Path to "DataSource"

   2. The Expression needs to be the parent of the field you are wanting to display. In this case, we want to see = Fields.Order.Salesperson.Name so we will set the Expression to = Fields.Order.Salesperson
9. In the field where you want to show the salesperson name, you only need to add the second half of the expression we referenced for the DataSource = Fields.Order.Salesperson.Name.
11. 1. If you do not want the field to be entirely blank, you can set a "NoDataMessage" and "NoDataStyle" in the Properties Panel

Common Abbreviations

You may encounter some common abbreviations in the fields available to retrieve with GraphQL. Here is a repository of those abbreviations and what they mean so that you can replace them in your reports.

Customer

Tax Status

• T = Taxed

• X = Exempt

Credit Status

• O = Open Account

• C = Cash Only

• N = Do Not Sell

Location

Default Dispatch Type

• PD - FastWeigh POD

• CP - Create at Pickup

• CD - Create at Delivery

• RP - Receive at Pickup

• RD - Receive at Delivery

• LC - Load Count Only

Order

Pay Type

• C = Charge Hide

• D = Credit Card

• K = Check

• S = Charge Show

• X = Cash

Status

• A = Active

• I = Inactive

• C = Closed

Order Product

Freight Type, Surcharge Type, and Order Quantity Type

• U = Per Unit

• L = Per Load

Status

• A = Active

• I = Inactive

• C = Closed

Quote

Pay Type

• C = Charge Hide

• D = Credit Card

• K = Check

• S = Charge Show

• X = Cash

Status

• B = Bidding

• P = Pending

• C = Accepted

• R = Rejected

• E = Expired

• A = Awarded

Quote Product

Status

• A = Active

• I = Inactive

• C = Closed

Request Hauler

Ticket Type

• PD - FastWeigh POD

• CP - Create at Pickup

• CD - Create at Delivery

• RP - Receive at Pickup

• RD - Receive at Delivery

• LC - Load Count Only

Ticket

Manual Weigh

• 0 or False = Weight from a scale

• 1 or True = Manually typed weight

Connecting GraphQL to Telerik Report Designer

Note: Make sure you are running Telerik Report Designer version 14.0.20.219 or later.

2. 1. Enter in your GraphQL Endpoint URL into the Service URL. Example: https://fwt.fast-weigh.dev/v1/graphql

   2. • Your URL can be found at portal.fast-weigh.com/APIInfo

   3. Set the Method to Post

   4. Enter the Body from the Insomnia plugin "Fast-Weigh: Copy Telerik Body"

   5. Set the Data Selector to $.data.*
4. Create a new parameter called x-api-key.

   1. Set the Type to Header
5. If you are using a WHERE clause in your Body, check out this article for information about setting up Inline parameters.

Note: In our example, our Inline Parameters are the @FromDate and @ToDate.