# Libraries Compatible Libraries to interact with GraphLinq Chain: **For Front-end dApps** Web3:
Overall status
Network Status
](https://docs.graphlinq.io/engine/2-local) # Allocation **Supply**: 650,000,000 **Reserved for migrating from Ethereum Chain:** 500,000,000 **Ecosystem Fund**: 50,000,000 **Rewards for Stakers & Graph Incentivisation**: 50,000,000 **Treasury**: 50,000,000 # Bridge **Steps**: 1. Connect to GraphLinq App on Ethereum Mainnet Or GraphLinq Mainnet depending on you want to bridge in our bridge out. 2. Make sure you are on the [Bridge](https://hub.graphlinq.io/bridge) page 3. Click on "Bridge in my GLQ" or "Bridge out my GLQ"
{% embed url="
# File compression Graphs saved are compressed in a specific format to assure reliability, security and authenticity. The raw json payload is converted using the gzip compression protocol:\ GZip is a form of data compression -- ie it takes a chunk of data and makes it smaller. The original data can be restored by un-zipping the compressed file. It's then converted to base64 bytes code so that it is easily shareable to anyone. You can send your GLQ file to anyone and they will be able to execute it as part of one new Graph, and modify it. A graph has an hash which is from a SHA256 algorithm hashed with the base b64 bytes code + your public wallet identifier which makes it unique for everyone. It means that multiple people can deploy the same graph and manage their own states separately. SHA-256 is used in some of the most popular authentication and encryption protocols, including SSL, TLS, IPsec, SSH, and PGP. In Unix and Linux, SHA-256 is used for secure password hashing. Cryptocurrencies such as Bitcoin use SHA-256 for verifying transactions. # Graph Cycle Costs As you saw in the previous page, a graph has a direct path between its start and the end of the execution, event triggers such as Connector blocks can create new events that trigger a new graph cycle. Easier: Every block that starts a new trigger, from event or time-based, will init a new execution cycle that will occur more blocks of nodes and can create new cycles of nodes depending on your execution path of that cycle. Since every block type has a fixed GAS as GLQ price you can directly now calculate the estimated cost for running a specific task on a Graph. But be careful: since you can have an infinite number of cycles regardings the starting point that you have set (events, triggers, conditions..) the estimated fixed price is not the same as the dynamic that will depend on the number of times you're event get triggered. A more concrete example with a random block price: If you watch every new block coming from the Ethereum Blockchain then add a Twitter message every time it occurs with the base Twitter block costing 1 GLQ at each execution, your graph price will get raised by 1 GLQ every 15 seconds (average graphlinq block time). But now if you decide to do the same but with every new transaction, even if the Twitter block base cost is 1 GLQ, you will have to pay a higher relevant price based on the number of time the Twitter block got executed. Be assured that we will be watching the entire graphs costs and will do the best to keep it as lower as possible, we had to put the system in place into the Protocol to prevent an overload of our network and abuse from malicious attacks. # Node & Fees A node (blocks) is what graphs are made of, it describes the structure of your execution path. We prebuilt a set of nodes in the GraphLinq engine so that you can execute by passing through your needed parameters. This means that you can launch on the Engine a set of blocks that automate a task without coding any of the business logic needed. To avoid having an overwhelm or a congested network we have to apply fees for execution (known as Gas on GraphLinq Chain) each block type has a different cost of execution within its Cycle optimized by the network and CPU consumed by itself. # Engine The engine is the main core of GraphLinq Protocol, it's the software process that execute graphs over the network, We deployed two different protocol layer for testing, and using in production your own graph. On the test-net you can deploy graph and test them for free but they have limited access and cycle length restrictions while it is unlimited on the main-net and only need a balance cover-up in the engine depositor smart-contract. From a coding perspective, the engine is developed and maintained into .net core 3.1 (known as C# language) which allow for a fast execution and a cross-compatibility over any exploitation system. [> Github open source repo of the Engine](https://github.com/GraphLinq/GraphLinq.Engine)[
](https://docs.graphlinq.io/graph/3-cycle) # Setting up the environment **Requirements**: (Windows Only) Visual Studio version >= 2019:\ Microsoft Visual Studio is an integrated development environment (IDE) from Microsoft. It is used to develop computer programs, as well as websites, web apps, web services and mobile apps. MariaDB version > 10.x:\ Maria is one of the most popular open source relational databases. It's made by the original developers of MySQL and guaranteed to stay open source. Redis version > 5.x:\ Redis is an open source (BSD licensed), in-memory data structure store, used as a database, cache, and message broker. .NET Core 3.1 Framework:\ NET Core is used to create server applications that run on Windows, Linux and Mac. General-purpose programming language that can be used to perform a wide range of tasks and objectives that span over a variety of professions. Infura / Ethereum Node:\ Infura provides the tools and infrastructure that allow developers to easily take their blockchain application from testing to scaled deployment - with simple, reliable access to Ethereum and IPFS. MariaDB is used as database storage to authentify and save datas about deployed graphs and costs. Redis is the storage engine which is used when a graph ask to save a key/value store. [
](https://docs.graphlinq.io/engine) # Running an Engine locally Once you have prepared your own environment, you need to download and setup the Engine. Download the Engine from the official GraphLinq repository: ``` git clone https://github.com/GraphLinq/GraphLinq.Engine ``` Install the required [Nuget](https://www.nuget.org/) packages to load the Engine through the interface or on CLI: ``` dotnet restore ``` Then you need to setup the init variables: ``` redis_master_addr=REDIS_SERVER_HOST {ex: "localhost"}redis_master_port=REDIS_SERVER_PORT {ex: 6379}redis_master_passw=REDIS_SERVER_PASSWORD {ex: 12345}eth_api_http_url=ETH_HTTP_NODE {ex: "https://mainnet.infura.io/v3/xxx"}eth_api_ws_url=ETH_WS_NODE {ex: "wss://mainnet.infura.io/ws/v3/xxx"}mariadb_uri=MARIA_URI {ex: "Server=localhost;Database=graphlinq;User=root;Password=superp@ssw0rd;Port=3306;Max Pool Size=50;Connection Timeout=60;"}factor_decimal=DECIMAL_USED_FOR_GAS {ex: "1000000000000000000"} ``` Next step is to load the Engine by running it through CLI or Visual Studio Interface If you have something look alike as an output, you're engine is up and ready to handle new graphs, congratulations!\ The next step is to use the embedded internal API within the Engine code to deploy and start your local graphs directly. Doing this will also make you eligible to earn GLQ as rewards since nodes will be notified that you're contributing to the network by running on-chain processor and executing graphs on-chain. [
](https://docs.graphlinq.io/engine/1-index) # Dashboard Interface The dashboard is the inferface connected to your wallet and the engine mainnet network, on there you can deploy, manage states and check all logs of your own graphs, the only official url is [app.graphlinq.io](https://app.graphlinq.io/) You can also buy GLQ token automatically through the interface and manage your balance for the costs of your running graphs, make deposit and withdrawal request from the ethereum smart-contract. [> Github open source repo of the Interface](https://github.com/GraphLinq/GraphLinq.IDE) # Importing Graph/Template With the IDE, you can first create your graph and export it as .GLQ file, then, you can either select a template from the lists and deploy in on the dashboard interface or the .GLQ file that you generated with the graph IDE over `Save graph` in the `File` Menu.  Once you are on the dashboard interface you just need to import your file and execute it over `Deploy a New Graph`: One unique hash and an alias name will be set to recognize your graph. You will then be in control of the graph state / cycle costs and be able to view logs of executions, also later on we will add stats with specific information of the execution.  # Deploying a Graph Once you're logged on the dashboard interface, you can select the "New Graph" Button over the Graph page that you can select on the Menu.  You then have to choose between modifying a template pre-made or directly importing a .GLQ file that you created on the IDE.  Next step is to select the 'Create' button and deploy the graph over the network, you will then see the hash and this message:
# Blocks In the GraphLinq Integrated Development Environment (IDE), a "Block" or "Node" refers to a fundamental building block used for creating automated workflows, smart contracts, and decentralized applications (dApps) on the GraphLinq platform. Nodes represent individual elements of a graphical programming language that users can visually connect together to create complex and functional systems. Each node in the GraphLinq IDE serves a specific purpose and can perform various tasks or operations. Nodes are connected together in a flowchart-like manner to define the logical flow of a program. The connections between nodes, often represented as colored lines, determine the sequence in which the operations are executed. These lines indicate the flow of data or control between the nodes, allowing them to interact and exchange information. In the GraphLinq IDE, blocks or nodes can be of different types, including but not limited to: 1. Function Nodes: These nodes execute specific functions or operations, such as retrieving data, performing calculations, calling APIs, or interacting with the blockchain. 2. Variable Nodes: Variable nodes store and handle data within the graph. They can be used to store values like strings, numbers, or other data types. 3. Event Nodes: These nodes can be triggered by external events or conditions, such as receiving input or detecting changes in data. 4. Control Flow Nodes: Control flow nodes define the logic and structure of the graph, allowing for conditional branching and loop iterations. 5. Connector Nodes: Connector nodes allow users to connect to external data sources, such as blockchains, messaging platforms like Telegram or Discord, block explorers, and more. These nodes facilitate data retrieval and communication with external services. 6. Condition Nodes: Condition nodes offer a way to implement different paths of execution based on the value of node results or specified pre-set variables. They allow users to create IF statements, Boolean branches, and other conditional logic. Each node typically has input (IN) and output (OUT) parameters that define the data flow. IN parameters are the inputs required for the node to execute, while OUT parameters are the results or data produced by the node's operation. Nodes can be customized and extended through user-defined code, allowing developers to create custom nodes tailored to their specific use cases and requirements. This flexibility and extensibility empower developers to create sophisticated workflows and applications without the need for extensive coding knowledge. Overall, in the GraphLinq IDE, blocks or nodes are the essential building blocks that enable developers and users to create powerful, automated systems by visually designing the logic and flow of their applications in a user-friendly, graphical manner. # Base Variable The Base Variable subsection within the Blocks category consists of a diverse set of block types, each corresponding to fundamental data types in computer science. These blocks are essential for handling and manipulating data within GraphLinq graphs, enabling users to work with various data representations and perform operations involving literals and variables. One of the block types found in this subsection is the [Boolean](/dev-tooling/blocks/base-variable/boolean) block, which represents the Boolean data type capable of holding either true or false values. Users can utilize this block to make logical decisions and control the flow of their graphs based on conditions. For numeric data with decimal precision, the [Decimal](/dev-tooling/blocks/base-variable/decimal) block comes into play. It allows users to work with numerical values that include decimal points, facilitating precise calculations and data manipulation. When dealing with whole number values, the [Integer](/dev-tooling/blocks/base-variable/integer) block is the ideal choice. This block handles integers without decimal points and enables mathematical operations involving whole numbers. The [KeyValue](/dev-tooling/blocks/base-variable/keyvalue) block is used to define key-value pairs, providing a structured way to organize and work with data. Users can use this block to store related information in their graphs efficiently. For handling large integer values, the [Long](/dev-tooling/blocks/base-variable/long) block comes into play. It allows users to store and manipulate large whole number values within their graphs. Textual data is handled by the [String](/dev-tooling/blocks/base-variable/string) block, which can contain characters, spaces, and numbers. This block is essential for working with text-based information and performing string operations. To retrieve the value of a previously declared variable within the graph's data context, the [Get Variable](/dev-tooling/blocks/base-variable/set-variable) block is employed. This block enables users to access stored data and use it in subsequent parts of their graphs. Determining whether a variable with a given name has been declared within the graph is made possible with the [Is Variable Exist](/dev-tooling/blocks/base-variable/is-variable-exist) block. This block allows users to control the flow of their graphs based on the existence of specific variables. For declaring and assigning values to variables within the graph, the [Set Variable](/dev-tooling/blocks/base-variable/set-variable) block is utilized. It provides a means to store data dynamically and enables users to use variables for more flexible graph design. The [Variable Portal](/dev-tooling/blocks/base-variable/variable-portal) block plays a role in transferring data from one area of the graph to another while maintaining visual organization. This block ensures that data flows smoothly between different parts of the graph. Finally, the [Secret String](/dev-tooling/blocks/base-variable/secret-string) block handles sensitive text data but hides its contents from view within the graph file. This block is ideal for managing confidential information securely within the graph. Together, these blocks offer a versatile set of tools for managing and manipulating data in GraphLinq graphs. By leveraging the capabilities of these block types, users can build powerful automated workflows and decentralized applications with ease, efficiently handling a wide range of data types and operations. # Boolean The Boolean block in the GraphLinq IDE is a fundamental building block that represents the Boolean data type, which can have two possible values: "true" or "false". Booleans are commonly used in programming as a means of making decisions and controlling the flow of a program based on certain conditions. ### Input Parameters The Boolean block does not have any inputs. Instead, it serves as a static value block that can be connected to other blocks in a graph. ### Output The Boolean block has one output parameter that represents the Boolean value. This output can be connected to other blocks that accept Boolean values as input. ### Usage The Boolean block is primarily used for making logical decisions within a graph. By connecting the Boolean block's output to a branch or conditional block, developers can control the flow of execution based on whether the value is "true" or "false". ### Examples #### Using a Boolean for Conditional Branching Suppose a graph is designed to check whether a user is logged in. The graph might have a login check block that returns a Boolean value indicating whether the user is logged in or not. **Input (Boolean):** ``` true ``` Based on the output of the login check block (which is "true" in this case), the graph can follow different paths. For example, if the user is logged in (Boolean value is "true"), the graph may proceed to display personalized content. If the user is not logged in (Boolean value is "false"), the graph may redirect the user to the login page. #### Using a Boolean for Loop Control In another scenario, a graph might use a Boolean block to control a loop. For instance, a graph could have a loop that continues to execute as long as a certain condition is true. **Input (Boolean):** ``` false ``` When the Boolean value is "false," the loop will terminate, and the graph will proceed to the next set of instructions. *Note:* The Boolean block plays a crucial role in decision-making and flow control within graphs. By providing a simple "true" or "false" value, developers can create logic that responds to specific conditions, making their graphs dynamic and responsive to different scenarios. Whether used for conditional branching or loop control, the Boolean block is an essential tool for building versatile and interactive graphs. *** ### More Information The Boolean block in the GraphLinq IDE allows users to enter boolean values ("true" or "false"), which serve as conditions to determine the execution flow of the graph. These boolean values act as control signals, guiding the graph to follow specific yellow lines based on their true or false status. A common way to use boolean values to control flow is by employing the [Boolean Branch](/dev-tooling/blocks/base-condition/boolean-branch) block, which takes a boolean input and executes one of two output connections depending on the value of the boolean. Here's an example of how the [Boolean Branch](/dev-tooling/blocks/base-condition/boolean-branch) block works:
# Decimal The Decimal block in the GraphLinq IDE allows manipulation of fractional values, also known as decimal numbers. Decimal numbers are used to represent values with a higher precision than whole numbers (integers). They are essential for performing calculations that involve fractional parts. ### Input Parameters The Decimal block does not have any inputs. Instead, it serves as a static value block that can be connected to other blocks in a graph. ### Output The Decimal block has one output parameter that represents the decimal value. This output can be connected to other blocks that accept decimal values as input. ### Usage The Decimal block is used in various mathematical operations within a graph. It can represent quantities like currency, measurements, and percentages accurately. Additionally, the Decimal block is often used in conjunction with other math blocks to perform complex arithmetic calculations. ### Examples #### Performing Arithmetic Operations Suppose a graph needs to calculate the total cost of items in a shopping cart, including tax. The graph may use Decimal blocks to represent the item prices, tax rate, and the total cost. **Input (Decimal):** ``` Item Price: $10.99 Tax Rate: 0.08 (8%) ``` By connecting the Decimal blocks to an Add A + B block, the graph can calculate the total cost, including tax. **Output (Decimal):** ``` Total Cost: $11.87 ``` #### Handeling Financial Transactions In a financial application, the Decimal block can be used to represent currency values accurately. For example, a graph could calculate the interest accrued on a loan using decimal values for principal amount, interest rate, and time. **Input (Decimal):** ``` Principal Amount: $1000.00 Interest Rate: 0.05 (5%) Time: 2 years ``` By connecting the Decimal blocks to a Multiply A \* B block and a Multiply A \* B block, the graph can calculate the total interest and the final amount. **Output (Decimal):** ``` Total Interest: $100.00 Final Amount: $1100.00 ``` *Note:* The Decimal block is a versatile tool for working with fractional values and performing precise calculations. By using Decimal blocks in combination with other math blocks, developers can build graphs that handle various financial, scientific, and engineering calculations with accuracy and efficiency. *** ### More Information The Decimal block in the GraphLinq IDE allows users to enter fractional values or non-integers into their graphs. These values are represented as 64-bit floating-point numbers. The Decimal block's output can be linked to the decimal type input of other blocks, enabling the use of decimal values in various calculations and operations.
# Integer The `Integer` block allows us to enter whole number values into our graphs by linking an `Integer` block's output to an integer type input of another block. In the following graph snippet, we use an `Integer` block to enter the integer 10 as an input into the `Get Uniswap Token Price` block:
# Get variable The Get Variable block allows us to retrieve the value of a previously stored variable within the graph's data context. The Get Variable block allows us to retrieve the value of a previously stored variable within the graph's data context that had previously been declared and assigned to by [`Set variable`](/dev-tooling/blocks/base-variable/set-variable) block. In the example below, we use the Get Variable block to retrieve the previously stored value of "priceThreshold" and use it as an input for the Check Price block:
# Set variable The [Set Variable](/dev-tooling/blocks/base-variable/set-variable) block is used to store or update a variable with a specified name and value within the graph's data context. It allows us to save data for later use and update variable values as the graph executes. `Set variable` blocks have two inputs: a string for the variable's name, and the data that we want to assign to the variable. The purpose of `Set variable` blocks is to store data in variables to be used later in our graph's execution with the help of [`Get variable`](https://docs.graphlinq.io/blockTypes/1-baseVariable/7-getVariable) blocks. If the variable name that we pass to a `Set variable` block is the name of a variable that already exists, then it will simply overwrite the value of that existing variable with whatever value we passed into the `Set variable` block. If, on the other hand, no variable yet exists with the name that we pass to our `Set variable` block, then it will both declare a new variable by that name, and also initialize its value with whatever value we give to the `Set variable` block. In the following example, we are retrieving the price of Bitcoin with a [`Get CoinGecko Coin`](https://docs.graphlinq.io/blockTypes/29-coinGecko/1-getCoinGeckoCoin) block, and then storing that value in a variable named "currentBitcoinPrice" using a `Set variable` block:
# Variable Portal The [Variable Portal](/dev-tooling/blocks/base-variable/variable-portal) block enhances the flexibility and organization of our graphs, allowing for more efficient data transfer and management. `Variable Portal` blocks are not essential, and are never actually necessary, since it would always be possible to link your data directly from a block's output to another block's input, without first passing the data through a `Variable Portal` block. The point of `Variable Portal` blocks, then, is simply to keep your graph visually organized, and to prevent your dotted-line connections from crossing through areas of your graph that are already complicated, making things more confusing to look at. The following graph uses a Telegram bot to listen for the command "/maticprice", and to respond with a message containing Matic's price in whatever channel it heard the command:
# Common Documentation about `Entry Point` - `On Graph Start` - `Stop Graph` # Entry Point The Entry Point block is the starting point of every graph in the GraphLinq IDE. When a graph is executed, the flow of execution begins at the Entry Point block. This block serves as the entryway into the graph's logic and acts as the initial trigger for the entire workflow. In the example below, the Entry Point block is connected to other blocks, creating a sequence of operations that will be executed when the graph starts:
# Format Date The Format Date block is a versatile tool in the GraphLinq IDE that enables developers to convert Unix timestamps into human-readable date formats. This block grants users the flexibility to customize the output format according to their preferences and specific requirements. By transforming Unix timestamps into readable date strings, developers can present time-related data in a user-friendly manner, making it easier for end-users to understand and interpret. Additionally, the Format Date block is invaluable in generating informative logs, displaying relevant dates and times in reports, and formatting timestamps for use in various external systems or APIs. # Millisecond Timestamp to Date The Millisecond Timestamp to Date block is an extended version of the Timestamp to Date block, allowing developers to convert Unix timestamps that include milliseconds into human-readable date formats. With this block, developers can work with timestamp data that offers sub-second precision. Applications that require highly accurate time representation, such as real-time data visualization, time-sensitive analytics, or transactional systems, can benefit significantly from the Millisecond Timestamp to Date block. By leveraging this block's capabilities, developers can ensure that timestamp data is presented with the level of precision required by their specific use case. # Timestamp to Date The Timestamp to Date block serves a similar purpose to the Format Date block but focuses on converting Unix timestamps to human-readable date formats. By simply inputting a Unix timestamp into this block, developers can obtain a formatted date string that represents the corresponding date and time. This block is particularly useful in scenarios where developers need to work with time data in human-readable form for display purposes or further processing. Whether it's displaying timestamps in user interfaces, generating time-based reports, or organizing time-related data in a readable format, the Timestamp to Date block simplifies the conversion process. # Execution Time Interval The Execution Time Interval block serves as a valuable time-tracking tool within the GraphLinq IDE, enabling developers to measure the time interval between the start and end of executing a particular part of the graph. By incorporating this block into their graphs, developers can monitor the execution time of specific code segments, operations, or functions. The Execution Time Interval block proves instrumental in performance analysis, allowing developers to identify potential bottlenecks or optimize critical sections of the graph. It provides insights into the time efficiency of different parts of the workflow and aids in debugging and optimizing graph execution. # JSON JSON (JavaScript Object Notation) is a fundamental category of blocks in the GraphLinq IDE, designed to work with JSON data. JSON is a lightweight data interchange format widely used to transmit and store structured data between servers and web applications. Its simplicity, human-readability, and compatibility with various programming languages make it a popular choice for data representation. JSON blocks facilitate the manipulation and transformation of JSON data, allowing developers to create dynamic and interactive graphs that can handle complex data structures effectively. The JSON category encompasses a variety of blocks, each serving a specific purpose in working with JSON data. Let's explore the subcategories and their respective blocks: The [Last Node To JSON](/dev-tooling/blocks/json/last-node-to-json) block is used to convert the output of the previous block in the graph to JSON format. This allows developers to take the data produced by earlier blocks and represent it in the JSON structure. The [Convert To JSON](/dev-tooling/blocks/json/convert-to-json) block is a versatile component that takes input values and converts them into JSON format. It enables developers to create custom JSON objects and arrays from various data types, including strings, integers, decimals, and more. The [Add JSON Property](/dev-tooling/blocks/json/add-json-property) block is used to add a new property to an existing JSON object. Developers can specify the property name and its corresponding value, dynamically expanding the JSON object as needed. The [Create JSON Object](/dev-tooling/blocks/json/create-json-object) block allows developers to build a JSON object from scratch. By adding multiple properties and their corresponding values, developers can construct complex JSON structures tailored to their application's requirements. The [JSON Deserialize To Array](/dev-tooling/blocks/json/json-deserialize-to-array) block is essential for transforming a JSON array (represented as a string) back into a structured array within the graph. This allows developers to extract and work with specific elements of the JSON array as needed. The [JSON To JSON Object](/dev-tooling/blocks/json/json-to-json-object) block converts a JSON string into a JSON object representation. This is useful for parsing and manipulating JSON data obtained from external sources or APIs. The [Merge JSON](/dev-tooling/blocks/json/merge-json) block allows developers to merge two or more JSON objects into a single JSON object. This facilitates data aggregation and combination, enabling developers to consolidate multiple sets of data. The [Serialize JSON Object](/dev-tooling/blocks/json/serialize-json-object) block performs the opposite operation of JSON To JSON Object. It converts a JSON object into a JSON string, making it suitable for external data exchange and storage. The [Serialize To JSON](/dev-tooling/blocks/json/serialize-to-json) block converts various data types (such as strings, numbers, arrays) into a JSON string. This is particularly useful when preparing data to be sent to APIs or stored in JSON-based databases. The JSON category offers a comprehensive suite of blocks to work with JSON data effectively. Whether it's converting data to or from JSON format, merging JSON objects, or creating custom JSON structures, these blocks provide the necessary tools to handle JSON data with precision and flexibility. JSON manipulation is essential in modern web applications, and these blocks enable developers to create sophisticated and interactive graphs that interact seamlessly with JSON-based APIs and services. *** ### More Information JSON data is organized as a collection of key/value pairs, where keys are always represented as strings, and values can be strings, numbers, arrays, or other JSON objects. JSON Blocks enable developers to work with this data format seamlessly, allowing them to extract, modify, and generate JSON data as part of their graph's logic. The available JSON Blocks cover a wide range of functionalities, from converting data to and from JSON format to merging, deserializing, and serializing JSON objects. With these blocks, developers can perform complex JSON-related operations, such as adding properties, creating JSON objects, and transforming JSON data to meet the requirements of their applications. By harnessing the power of JSON Blocks, developers can efficiently work with JSON data, enabling the integration of external APIs, data serialization, and data interchange in their GraphLinq graphs. These blocks play a crucial role in ensuring seamless communication and data manipulation within the graph, contributing to the development of robust and versatile applications. {% code title="JSON Example" lineNumbers="true" %} ```json { "name": "GraphLinq Protocol", "allTimeHighUSD": 0.10966683966210045, "rate": 0.01375348745855626, "volume": 913981, "cap": 4676184, "liquidity": 36833, "delta": { "hour": 1.0242, "day": 0.9969, "week": 1.1052, } } ``` {% endcode %} # Last Node to JSON The Last Node To JSON block is a powerful tool in the GraphLinq IDE that allows developers to convert the output of the previous node in the graph into JSON format. This block is particularly useful when developers want to represent the data generated by earlier blocks as a structured JSON object. The Last Node To JSON block does not require any specific input. Instead, it automatically takes the output of the previous node in the graph as its input. This feature makes it incredibly convenient as developers don't need to manually provide input; the block implicitly receives the data from the previous node. The block's output is a JSON representation of the data received from the previous node. The output is a JSON object that can include nested properties and values, making it versatile for handling complex data structures. ### Use Case Consider a scenario where a graph fetches real-time cryptocurrency data from an API using the HTTP blocks. The data obtained might include details like the current price, volume, and market cap of a particular cryptocurrency. The Last Node To JSON block can then be used to convert this data into a JSON object, making it easier to process and display on a user interface or send to other external services. ### Example Let's take a simplified example where a graph calculates the sum of two numbers, A and B, using the Add A + B block. The result of this addition is then passed to the Last Node To JSON block. The JSON output will be a representation of the sum in the following format: ```json { "result": 10 } ``` In this example, the "result" property is automatically generated by the Last Node To JSON block, and its value is the sum of numbers A and B. *Note:* It's important to ensure that the data provided to the Last Node To JSON block is in a suitable format for JSON representation. For example, non-JSON-compatible data, such as circular structures, might cause errors in the process. Developers should ensure that the output of the previous node is compatible with JSON formatting to achieve accurate results. The Last Node To JSON block simplifies the process of converting graph data into JSON format, making it easier to work with and transmit structured data between different parts of the graph or to external systems. Its implicit input mechanism ensures seamless integration with other blocks, enhancing the overall efficiency and flexibility of the graph. # Convert To JSON The Convert To JSON block in the GraphLinq IDE is a versatile tool that enables developers to convert various data types into JSON format. JSON (JavaScript Object Notation) is a widely used data interchange format that is human-readable and easy for machines to parse. This block is valuable when developers need to prepare data for external APIs, databases, or other systems that require JSON-formatted data. The Convert To JSON block accepts different types of data as input, such as strings, numbers, arrays, or objects. This means developers can pass various data structures to the block for conversion to JSON format. The block's output is a JSON representation of the input data. The output is a JSON object that can include nested properties and values, depending on the structure of the input data. ### Use Case Imagine a scenario where a graph receives data from multiple sources, such as a user inputting values, data fetched from an API, and calculations performed by the graph. Before sending this data to an external service or saving it in a database, the Convert To JSON block can be used to format the data into a unified JSON structure, ensuring consistent data representation across different sources. ### Example Let's consider a simple example where a graph receives two numeric inputs, "temperature" and "humidity," from different blocks. These inputs might represent real-time weather data. The Convert To JSON block can then take these inputs and convert them into a JSON object in the following format: ```json { "temperature": 25, "humidity": 60 } ``` In this example, the Convert To JSON block converts the individual temperature and humidity values into a single JSON object. *Note:* It is essential to ensure that the input data provided to the Convert To JSON block is compatible with JSON formatting. Data types that are not natively supported by JSON, such as circular structures or functions, may cause errors during the conversion process. The Convert To JSON block significantly simplifies the process of converting diverse data types into a standardized JSON format. It empowers developers to seamlessly prepare data for consumption by external systems and services, enabling efficient data exchange and interoperability within the graph and beyond. # Add JSON Property The Add JSON Property block in the GraphLinq IDE serves as a valuable tool for dynamically adding properties to JSON objects. JSON (JavaScript Object Notation) is a widely used data interchange format that represents data as a collection of key-value pairs. With the Add JSON Property block, developers can enhance the flexibility and dynamic nature of their JSON objects by inserting new properties with corresponding values. The Add JSON Property block takes two inputs: 1. JSON Object: This input represents the original JSON object to which a new property will be added. 2. Property Name: This input specifies the name of the property to be added to the JSON object. The block's output is a new JSON object that includes the additional property specified by the input. ### Use Case The Add JSON Property block is particularly useful when developers need to adapt their JSON objects based on dynamic or changing conditions. For instance, in an e-commerce application, the JSON object representing a shopping cart may need to be updated with a new product and its corresponding quantity. The Add JSON Property block can be employed to insert the product name as a property and its quantity as the associated value. ### Example Let's consider an example where a graph receives a JSON object representing a user profile with existing properties such as "name," "age," and "email." At a later stage, the graph needs to add a new property, "location," to the user profile based on user input. The Add JSON Property block can be utilized to achieve this dynamically. Suppose the initial JSON object is as follows: ```json { "name": "John Doe", "age": 30, "email": "john@example.com" } ``` With the Add JSON Property block, the graph can take the input JSON object and the new property name "location," along with its value, and create an updated JSON object: ```json { "name": "John Doe", "age": 30, "email": "john@example.com", "location": "New York" } ``` In this example, the Add JSON Property block dynamically added the "location" property with the value "New York" to the original JSON object. *Note:* When using the Add JSON Property block, it is crucial to ensure that the JSON object provided as input is valid. Any discrepancies in the input format may result in errors during the process of adding properties. The Add JSON Property block empowers developers to build dynamic and adaptable JSON objects by allowing them to incorporate new properties on the fly. By doing so, developers can create more responsive and customizable graphs that cater to various scenarios and evolving data requirements. # Create JSON Object The Create JSON Object block in the GraphLinq IDE is a fundamental component for generating JSON data structures. JSON (JavaScript Object Notation) is a lightweight and widely used data interchange format that represents data in a human-readable and easily interpretable form. The Create JSON Object block enables developers to construct JSON objects with multiple key-value pairs, providing a structured and organized approach to data representation. The Create JSON Object block has one output, which is a JSON object constructed based on the key-value pairs specified in the block. The Create JSON Object block is particularly useful when developers need to generate JSON data structures that consist of multiple properties and corresponding values. These JSON objects can serve as data payloads to be sent over networks, stored in databases, or used for various data processing tasks within a graph. Suppose a graph needs to create a JSON object representing a user profile. The profile should contain properties such as "name," "age," "email," and "address." The Create JSON Object block can be used to generate the desired JSON structure: ```json { "name": "John Doe", "age": 30, "email": "john@example.com", "address": "123 Main Street" } ``` In this example, the Create JSON Object block takes four key-value pairs as inputs to construct the JSON object representing the user profile. *Note:* When using the Create JSON Object block, it is essential to ensure that the keys (property names) are unique within the JSON object. Duplicating keys will lead to unexpected behavior and errors when processing the JSON data. The Create JSON Object block provides a straightforward and efficient way to create JSON data structures within a graph. By using this block, developers can easily organize and represent data in a format that is widely supported and easily understood by various systems and applications. The ability to generate JSON objects programmatically enhances the flexibility and versatility of graphs in handling and manipulating data effectively. # JSON Deserialize To Array The JSON Deserialize To Array block in the GraphLinq IDE is a powerful tool for extracting data from JSON representations and converting it into an array format. JSON (JavaScript Object Notation) is a widely used data interchange format that represents data in a human-readable and lightweight manner. The JSON Deserialize To Array block allows developers to parse JSON strings or objects and transform them into structured arrays for further processing and analysis within the graph. ### Input Parameters The JSON Deserialize To Array block has one input, which is the JSON data that needs to be converted into an array format. This input can be a JSON string or a JSON object. ### Output The JSON Deserialize To Array block outputs the data in an array format that can be utilized by other blocks in the graph for various data manipulation tasks. ### Usage The JSON Deserialize To Array block is essential when developers need to extract structured data from JSON representations and work with it in an array format. This is especially useful when dealing with APIs that return data in JSON format, as the block allows for easy transformation of the received JSON data into arrays that can be processed, filtered, and combined with other data within the graph. ### Example Suppose a graph needs to fetch data from an external API that returns data in JSON format and then extract specific information from the JSON response. The JSON Deserialize To Array block can be used to convert the JSON data into an array, enabling further analysis and processing: ```json [ { "name": "John", "age": 30, "email": "john@example.com" }, { "name": "Jane", "age": 28, "email": "jane@example.com" } ] ``` In this example, the JSON data represents an array of user objects, where each object contains properties such as "name," "age," and "email." The JSON Deserialize To Array block can convert this JSON array into an array format that can be accessed and manipulated within the graph. *Note:* It is essential to ensure that the JSON data provided as input to the JSON Deserialize To Array block is well-formed and valid. Invalid JSON data may result in errors during parsing and conversion. The JSON Deserialize To Array block empowers developers to work with JSON data in a structured and organized manner by converting it into arrays. This enables seamless integration of JSON data into graphs and facilitates data processing, analysis, and transformation tasks with ease. # JSON to JSON Object The JSON To JSON Object block in the GraphLinq IDE is a versatile tool designed to convert JSON strings or objects into structured JSON objects. JSON (JavaScript Object Notation) is a widely used data interchange format that represents data in a human-readable and lightweight manner. The JSON To JSON Object block enables developers to parse JSON data and extract specific elements or properties, allowing for further manipulation and analysis within the graph. ### Input Parameters The JSON To JSON Object block has one input, which is the JSON data that needs to be converted into a JSON object format. This input can be a JSON string or a JSON object. ### Output The JSON To JSON Object block outputs the data in a structured JSON object format, making it easy to access and work with specific elements and properties. ### Usage The JSON To JSON Object block is particularly useful when developers need to extract specific information from JSON data and use it within the graph for various data processing tasks. It enables the isolation of individual elements from complex JSON data structures, allowing for more focused analysis and manipulation. ### Example Suppose a graph receives data from an external API in JSON format, and the task is to extract certain properties from the JSON response and utilize them for specific operations. The JSON To JSON Object block can be employed to convert the JSON data into a structured JSON object and access the required elements: ```json { "name": "John", "age": 30, "email": "john@example.com" } ``` In this example, the JSON data represents a JSON object that contains properties such as "name," "age," and "email." The JSON To JSON Object block can convert this JSON object into a structured format, allowing for easy access and manipulation of its elements. *Note:* It is essential to ensure that the JSON data provided as input to the JSON To JSON Object block is well-formed and valid. Invalid JSON data may result in errors during parsing and conversion. The JSON To JSON Object block empowers developers to extract specific elements from JSON data and represent them in a structured JSON object format within the graph. This facilitates more targeted data analysis, manipulation, and integration with other blocks for building sophisticated applications and automations. # Merge JSON The Merge JSON block in the GraphLinq IDE serves as a powerful tool to combine multiple JSON objects into a single JSON object. JSON (JavaScript Object Notation) is a lightweight data interchange format used to represent data as key-value pairs, making it easy to read and process. The Merge JSON block enables developers to merge JSON data from different sources or manipulate and aggregate JSON objects within the graph. *Block Inputs:* The Merge JSON block has multiple inputs, each representing a JSON object. You can connect different blocks or APIs that produce JSON objects to these inputs. The block will combine the JSON objects from all the inputs into one cohesive JSON object. *Block Output:* The Merge JSON block outputs a single JSON object, which is the result of merging the JSON objects from all the connected inputs. *Usage:* The Merge JSON block is especially useful when developers need to combine JSON data from multiple sources or when they want to aggregate data into a single JSON object for further processing. It enables the seamless integration of JSON objects produced by various parts of the graph, facilitating unified data management and manipulation. *Example:* Suppose a graph fetches data from two different APIs, and each API returns data in JSON format. The task is to merge the data from both APIs into a single JSON object for further analysis. The Merge JSON block can be utilized to combine the JSON objects obtained from the two APIs: **API 1 Output (JSON):** ```json { "name": "John Doe", "age": 35, "email": "john.doe@example.com" } ``` **API 2 Output (JSON):** ```json { "address": "123 Main Street", "city": "New York", "country": "USA" } ``` The Merge JSON block will merge the data from API 1 and API 2 into one JSON object: **Merged JSON Output:** ```json { "name": "John Doe", "age": 35, "email": "john.doe@example.com", "address": "123 Main Street", "city": "New York", "country": "USA" } ``` *Note:* When merging JSON objects, it is essential to ensure that the keys in the JSON objects do not conflict. If there are duplicate keys in the input JSON objects, the values from the last input will overwrite the values from the previous inputs. The Merge JSON block empowers developers to efficiently combine JSON data from various sources or merge JSON objects produced within the graph. This consolidation of JSON objects enables streamlined data management and facilitates further data processing and analysis in complex applications and workflows. # Serialize JSON Object The Serialize JSON Object block in the GraphLinq IDE is a fundamental component used to convert a JSON object into a serialized string. JSON (JavaScript Object Notation) is a popular data interchange format used to represent structured data in a human-readable and machine-readable format. Serialization refers to the process of converting a data structure, such as a JSON object, into a sequence of bytes or characters so that it can be easily transmitted or stored. ### Input Parameters The Serialize JSON Object block takes a JSON object as input. This JSON object can be the result of API calls, data processing, or any other operations that produce JSON data within the graph. ### Output The Serialize JSON Object block outputs a serialized string representation of the input JSON object. This string can be easily stored in databases, transmitted over networks, or used in various data interchange scenarios. ### Usage The Serialize JSON Object block is a crucial tool in data processing and communication workflows. It enables developers to convert complex JSON data structures into strings that can be shared across different systems, applications, or services. This serialized format allows for seamless data transmission and integration between various components of a system. *Example:* Suppose a graph processes data and generates the following JSON object: **Input JSON Object:** ```json { "name": "John Doe", "age": 30, "email": "john.doe@example.com", "address": { "street": "123 Main Street", "city": "New York", "country": "USA" } } ``` The Serialize JSON Object block will convert this JSON object into a serialized string: **Serialized Output:** ``` {"name":"John Doe","age":30,"email":"john.doe@example.com","address":{"street":"123 Main Street","city":"New York","country":"USA"}} ``` *Note:* Serialized JSON strings are usually compact and do not include any extra whitespace or indentation to reduce the size of the data. This format ensures efficient data transmission and storage. The Serialize JSON Object block plays a pivotal role in data serialization within the graph. It enables developers to convert JSON objects into serialized strings, facilitating seamless data interchange and integration in various application scenarios. This serialization process is crucial for efficiently transmitting and storing JSON data and is widely used in web applications, APIs, and data communication protocols. # Serialize to JSON The Serialize To JSON block in the GraphLinq IDE is a powerful tool that enables developers to convert various data types into their corresponding JSON representations. JSON (JavaScript Object Notation) is a widely used data interchange format that provides a human-readable and easy-to-parse structure for representing data. This block allows users to transform different data types into JSON, making it convenient for data serialization and communication. *Block Input:* The Serialize To JSON block accepts various data types as input. It can handle data types such as strings, numbers (integers and decimals), booleans, arrays, and dictionaries. *Block Output:* The Serialize To JSON block produces a JSON-formatted string as its output. This string represents the serialized version of the input data. *Usage:* The Serialize To JSON block is essential for data transformation and communication tasks within graphs. It allows users to convert data into a standardized JSON format, making it easier to exchange and integrate information between different systems and services. ### Example 1. Serializing a Dictionary: Suppose a graph contains a dictionary with key-value pairs representing user information: **Input Dictionary:** ``` { "name": "Alice", "age": 28, "email": "alice@example.com" } ``` Using the Serialize To JSON block, the dictionary is converted into a JSON string: **Serialized Output:** ``` {"name":"Alice","age":28,"email":"alice@example.com"} ``` 2. Serializing an Array: Consider a graph that processes an array of temperature values recorded over time: **Input Array:** ``` [25.5, 27.8, 29.1, 26.7, 24.9] ``` With the Serialize To JSON block, the array is transformed into a JSON string: **Serialized Output:** ``` [25.5,27.8,29.1,26.7,24.9] ``` 3. Serializing a Number: In another scenario, the graph receives a single numeric value that needs to be serialized: **Input Number:** ``` 42 ``` Using the Serialize To JSON block, the number is converted into a JSON string: **Serialized Output:** ``` 42 ``` *Note:* The Serialize To JSON block is a versatile component that allows developers to easily convert different data types into their JSON representations. This simplifies data serialization tasks and facilitates seamless data exchange and integration across various systems. JSON serialization is widely used in web development, APIs, and data communication, making the Serialize To JSON block an essential tool for data-driven applications. # Log **Log:** The "Log" block category in the GraphLinq IDE is dedicated to one essential block type: the "Log" block. The primary purpose of this block is to facilitate message recording in a graph's logs during its runtime. Logging is a critical aspect of graph development as it enables developers to monitor and track the execution flow and output of their graphs. **Log Block:** The "Log" block serves as a valuable tool for developers to log information, errors, or any relevant data generated during the execution of a graph. When the "Log" block is executed, it appends the specified message to the graph's log, providing insights into the graph's behavior and state at different stages of its execution. Developers can use the "Log" block to record various types of information, such as: 1. Debugging Information: Logging allows developers to display variable values, execution status, and intermediate results to aid in debugging and troubleshooting potential issues within the graph's logic. 2. Execution Flow: The "Log" block can be utilized to track the flow of execution through the graph, helping developers understand the sequence of operations and decision-making processes. 3. Event Recording: Important events or milestones during the graph's execution can be logged, providing a comprehensive overview of the graph's behavior. 4. Error Handling: When errors or exceptions occur during graph execution, the "Log" block can be used to record error messages, stack traces, and other relevant details, enabling effective error handling and diagnosis. By incorporating the "Log" block strategically within a graph, developers gain valuable insights into the graph's behavior, enabling them to monitor and optimize its performance. The log messages can be viewed in real-time during graph execution, providing a dynamic view of the graph's operation. Overall, the "Log" block category plays a crucial role in facilitating transparency and visibility into a graph's runtime behavior. It empowers developers to capture and analyze essential information, making the graph development process more efficient and facilitating effective debugging and maintenance. # Print **Print Blocks:** The "Print" blocks in the GraphLinq IDE serve the purpose of recording messages into the logs of a graph while it is running. These blocks play a crucial role in aiding experimentation, debugging, and event recording within the graph development process. **Main Use Cases:** 1. **Experimentation and Debugging:** Using "Print" blocks to output values calculated by the graph is a valuable approach for experimenting with different blocks and testing the graph's functionality. During development, developers can quickly assess the behavior of the graph by logging intermediate results, variable values, and execution status. The real-time feedback provided by the "Print" blocks helps in identifying potential issues and streamlining the debugging process. As a local context is provided, it becomes easier to verify the correctness of the graph's logic. 2. **Recording Graph Events:** "Print" blocks also serve as a means to record significant events and activities within the graph. These messages are stored persistently in the logs associated with the specific graph. For instance, "Print" blocks can be utilized to record error messages when certain conditions go wrong, providing insights for error handling and troubleshooting. Moreover, they can be effectively used to monitor the frequency of user commands submitted to GraphLinq-based applications like Discord bots. **Examples:** 1. **Simple "Hello World" Message:** The simplest use of a "Print" block involves recording a message, such as "Hello World," into the logs at the beginning of the graph's execution. This helps in verifying that the graph has started successfully. The output message appears in the terminal at the bottom right of the IDE and is time-stamped for reference. 2. **Recording Telegram Channel Commands:** In a more complex scenario, "Print" blocks can be employed to record events when specific commands are detected in a Telegram channel. Using cascading "String Branch" blocks, messages submitted in the Telegram channel are checked to see if they match specific commands, such as "/menu", "/price", or "/links". Whenever these commands are detected, corresponding "Print" blocks are used to log messages in the graph's logs, indicating the commands' occurrences. Note that the "Print" messages are not visible to the users in the Telegram channel; instead, they are stored in the graph's logs. This enables the graph owner to access and analyze the data later, determining the frequency and usage of different commands by members of the Telegram channel. In conclusion, "Print" blocks are a powerful tool for developers to gain insights into their graph's behavior and operation. By providing real-time feedback and recording important events, these blocks contribute significantly to the efficient development, testing, and monitoring of graphs. The logs containing the "Print" messages offer valuable information for assessing the graph's performance and user interactions. Here is the simplest possible use of a `Print` block, in which we are recording the string "Hello World" into the logs one time, upon the beginning of the graph's execution:
# String Contains Perform conditional checks and make decisions based on the presence or absence of certain patterns in a string The String Contains block in the GraphLinq IDE is a powerful tool designed to determine whether a specific substring exists within a given string. It enables developers to perform conditional checks and make decisions based on the presence or absence of certain patterns in the input strings. This block provides essential functionality for handling and processing text-based data within graphs. Block Description The String Contains block belongs to the String category of blocks in the GraphLinq IDE. Its primary purpose is to check if a specified substring is present within a given input string. Input Parameters The String Contains block requires two input parameters: 1. InputString (String Type): This parameter represents the input string within which the presence of the substring will be evaluated. 2. Substring (String Type): The Substring input is the specific sequence of characters that the block will search for in the InputString. Output: The output of the String Contains block is a boolean value ("true" or "false") that indicates whether the Substring is found within the InputString. If the Substring is present, the output will be "true"; otherwise, it will be "false." Example Use Case Let's explore a practical example to illustrate how the String Contains block can be utilized in a graph: 1. The graph receives user input through a String block, storing it in the variable "userMessage." 2. The String Contains block is then used to check if the user's message contains a specific keyword, such as "help" or "support." 3. Based on the output of the String Contains block, the graph can determine whether the user's message requires additional assistance or action. 4. If the output is "true," indicating that the keyword is present in the user's message, the graph can execute specific blocks to provide the required support or information. In this example, the String Contains block enables the graph to perform conditional checks on the user's input, allowing developers to create interactive and responsive applications that respond to specific keywords or patterns in user messages. The String Contains block is an essential component in the GraphLinq IDE for handling and processing text data within graphs. Its capability to check for the existence of substrings provides valuable functionalities for conditional branching and decision-making. By leveraging the String Contains block, developers can create dynamic and intelligent graphs that respond appropriately to different patterns in input strings, enhancing the overall functionality and interactivity of their applications. *** ### More Information The [String Contains](/dev-tooling/blocks/string/string-contains) block is a versatile component in the GraphLinq IDE used to check if a specific substring exists within a given string. It is invaluable for performing conditional checks and making decisions based on the presence or absence of certain patterns in the input strings. **Usage:** The [String Contains](/dev-tooling/blocks/string/string-contains) block takes two string inputs: the main string and the substring. It then evaluates whether the substring is a part of the main string. If the substring is found within the main string, the block outputs a boolean value "true"; otherwise, it outputs "false." **Example:** Suppose we have a string "GraphLinq is awesome," and we want to check if it contains the substring "awesome." We can use the "String Contains" block with the main string as "GraphLinq is awesome" and the substring as "awesome." The block will return "true" because the substring "awesome" is present in the main string. **Advantages:** The "String Contains" block empowers developers to create conditional logic within their graphs. By checking for specific substrings, graphs can dynamically adapt their behavior based on user input or real-time data, making applications more interactive and responsive. **Summary:** The "String Contains" block in the GraphLinq IDE provides a straightforward way to determine if a particular substring exists within a given string. It enables the implementation of conditional checks and dynamic decision-making in graphs, enhancing the graph's ability to respond intelligently to different scenarios. *** ### Full Example `String Contains` blocks make it possible to search through a string to see if it contains some other string. This allows us to sift through text from whatever sources and check for certain words or phrases. In the following example, we check every message that a Telegram bot hears to see if it contains the string "forbidden phrase". If it hears "forbidden phrase", it sends a warning message in the same Telegram channel that it heard the message in.
# Concat String Concatenation is the operation of joining character strings end-to-end The [Concat String](/dev-tooling/blocks/string/concat-string) block in the GraphLinq IDE is a versatile tool that allows developers to merge two strings into a single string. This block is invaluable for building dynamic and informative messages by combining multiple text elements within graphs. It provides essential functionalities for string manipulation and data presentation. ### Block Description The Concatenate String block is part of the String category in the GraphLinq IDE. Its primary function is to merge two input strings into a single output string. #### Input Parameters The Concatenate String block requires two input parameters: 1. String A (String Type): This parameter represents the first string that will be included in the output. It could be a fixed string or a string variable obtained from other blocks. 2. String B (String Type): The String B input is the second string that will be concatenated with String A to form the final output string. #### Output The output of the Concatenate String block is a single string that results from merging String A and String B together. The output string is a combination of the text from both input strings. #### Example Use Case Let's explore a practical example to illustrate how the Concatenate String block can be used in a graph: 1. The graph contains a variable "userName" that stores a user's name obtained from external sources. 2. The String block is used to create a fixed text, such as "Welcome, ". 3. The Concatenate String block is then employed to combine the fixed text with the value of the "userName" variable. 4. The final output from the Concatenate String block will be a personalized greeting message, such as "Welcome, John!" or "Welcome, Jane!" depending on the value stored in the "userName" variable. In this example, the Concatenate String block allows the graph to create dynamic and personalized messages by merging fixed text with variable data. This enables developers to build more engaging and interactive applications that can provide personalized feedback and responses. The Concatenate String block is a crucial element in the GraphLinq IDE for working with textual data within graphs. Its ability to combine two strings into a single output string provides valuable functionalities for generating personalized messages and dynamic content. By utilizing the Concatenate String block, developers can enhance the user experience by delivering customized responses and informative messages, making their applications more user-friendly and interactive. *** ### More Information The [Concatenate String](/dev-tooling/blocks/string/concat-string) block, often referred to as "[Concat String](/dev-tooling/blocks/string/concat-string)," is a fundamental component in the GraphLinq IDE for working with strings. As the name suggests, this block is used to concatenate or combine multiple strings into a single string. #### Usage The [Concatenate String](/dev-tooling/blocks/string/concat-string) block takes two strings as inputs and merges them together to form a new string. The output of this block is the result of combining the input strings. It provides a simple yet powerful way to create dynamic messages, generate meaningful information, or construct complex text outputs in graphs. #### Example Let's consider a practical example where we have two strings, "Hello" and "World." By using the "Concatenate String" block, we can merge these two strings into a single greeting message, such as "Hello World." The block takes "Hello" as one input and "World" as another, and the output will be the concatenated string "Hello World." #### Advantages The [Concatenate String](/dev-tooling/blocks/string/concat-string) block allows developers to dynamically build strings based on various inputs, making it ideal for generating customized messages and responses within graphs. It enhances the flexibility and versatility of graph designs by enabling the creation of dynamic content based on real-time data or user interactions. #### Summary The [Concatenate String](/dev-tooling/blocks/string/concat-string) block in the GraphLinq IDE is a powerful tool for merging multiple strings into a single coherent string. It is widely used for creating dynamic messages, generating informative outputs, and building flexible applications that respond to different scenarios with customized text. With the ability to combine strings easily, developers can craft engaging and interactive experiences within their graphs. *** ### Full Example `Concat String` blocks are used to combine two strings into one string. They take three strings as input: the two strings you want to merge together, and a delimiter string. When a `Concat String` block executes, it will stick the second string onto the end of the first string, with the delimiter string inserted between them. If you don't provide a delimiter, then it will default to a space character.
# Math The Math blocks in the GraphLinq IDE enable users to perform a wide range of mathematical operations and calculations within their graphs. These blocks empower developers to manipulate numeric data, perform complex calculations, and make data-driven decisions, making them essential tools for creating dynamic and efficient graph designs. The [Subtract A - B](/dev-tooling/blocks/math/subtract-a-b) block allows users to perform subtraction operations between two numeric values, A and B, resulting in the output of A minus B. This block serves as a fundamental component for conducting basic subtraction calculations within graphs and acts as a building block for various mathematical scenarios. The [Add A + B](/dev-tooling/blocks/math/add-a-+-b) block enables users to perform addition operations between two numeric values, A and B, yielding the result of A plus B. This block is crucial for conducting basic addition calculations and serves as a foundation for various aggregations and dynamic data processing in graphs. The [Ceiling](/dev-tooling/blocks/math/ceiling) block is used to round a numeric value to the smallest integer greater than or equal to the input value. This block is particularly useful for scenarios where data needs to be rounded up to the nearest whole number. The [Divide A / B](/dev-tooling/blocks/math/divide-a-b) block allows users to perform division operations between two numeric values, A and B, resulting in the output of A divided by B. This block is essential for conducting basic division calculations within graphs and handling scenarios involving ratios and proportions. The [Floor](/dev-tooling/blocks/math/floor) block is used to round a numeric value to the largest integer less than or equal to the input value. This block is valuable for scenarios where data needs to be rounded down to the nearest whole number. The [Modulo A % B](/dev-tooling/blocks/math/modulo-a-b) block calculates the remainder when numeric value A is divided by B. This block is particularly useful for determining cyclic patterns and managing periodic calculations in graphs. The [Multiply A \* B](/dev-tooling/blocks/math/multiply-a-b) block allows users to perform multiplication operations between two numeric values, A and B, resulting in the output of A multiplied by B. This block is essential for conducting basic multiplication calculations and is often used in data scaling and transformations. The [Percentage Difference](/dev-tooling/blocks/math/percentage-difference) block computes the percentage difference between two numeric values, A and B. This block is valuable for analyzing data changes over time and comparing variations between data sets. The [Round](/dev-tooling/blocks/math/round) block is used to round a numeric value to the nearest whole number or to a specific number of decimal places. This block is versatile and can be employed for various rounding operations based on the requirements of the graph. The Math section in the GraphLinq IDE equips users with powerful tools for handling numerical data and conducting mathematical operations within their graphs. From simple arithmetic to more advanced calculations, the Math blocks open up a world of possibilities for building data-driven and precise graph designs. Each subsection provides unique functionalities that cater to different mathematical scenarios, enabling developers to create dynamic and efficient graph designs for a wide range of applications. This block category comprises blocks used to perform basic arithmetic. Included are block types for all the basic arithmetic operators: [`Add A + B`](/dev-tooling/blocks/math/add-a-+-b) blocks, [`Subtract A - B`](/dev-tooling/blocks/math/subtract-a-b) blocks, [`Multiply A * B`](/dev-tooling/blocks/math/multiply-a-b) blocks, [`Divide A / B`](/dev-tooling/blocks/math/divide-a-b) blocks, and [`Modulo A % B`](/dev-tooling/blocks/math/modulo-a-b) blocks. This category also includes several block types related to rounding. [`Ceiling`](/dev-tooling/blocks/math/ceiling) blocks round up to the nearest integer, [`Floor`](/dev-tooling/blocks/math/floor) blocks round down to the nearest integer, and [`Round`](/dev-tooling/blocks/math/round) blocks round to some given precision (significant digits after the decimal). Finally, this category includes [`Percentage Difference`](/dev-tooling/blocks/math/percentage-difference) blocks, which offer a quick way to calculate the percentage gain one number would need to undergo to become equal to another number. # Subtract A - B Subtraction is an operation that represents removal of objects from a collection The Subtract A - B block in the GraphLinq IDE is an essential mathematical component that calculates the difference between two numeric values. This block allows developers to perform subtraction operations on various numeric data types, enabling them to handle scenarios where finding the difference between two values is necessary. ### Block Description The Subtract A - B block belongs to the Math blocks category in the GraphLinq IDE. Like other blocks in this category, it is a non-executive block, meaning it does not have yellow connectors and is implicitly called when other blocks require its output during graph execution. ### Input Parameters The Subtract A - B block requires two input parameters: 1. A (Numeric Type): The A input represents the first numeric value for the subtraction operation. 2. B (Numeric Type): The B input denotes the second numeric value to be subtracted from the first value. Both A and B can be any type of numeric data, such as decimal, integer, or long. The two data types do not need to match; for instance, you can subtract a decimal value from an integer value. ### Output The Subtract A - B block outputs the result of the subtraction operation between A and B. The output will be of the same numeric type as the input values. ### Example Use Case Let's explore a practical example demonstrating the usage of the Subtract A - B block in a graph: 1. The graph retrieves two numerical values, "TotalRevenue" and "OperatingCost," which represent a company's financial data. 2. The Subtract A - B block is invoked, with TotalRevenue as input A and OperatingCost as input B. 3. The block calculates the difference between TotalRevenue and OperatingCost, yielding the net income or profit generated by the company. 4. The output of the Subtract A - B block represents the net income, which can be further utilized for analysis, display, or other financial computations. In this example, the Subtract A - B block enables the graph to perform a fundamental subtraction operation, allowing developers to compute key financial metrics, such as profit or loss, and make informed decisions based on the calculated results. The Subtract A - B block is a critical mathematical tool in the GraphLinq IDE, providing the ability to calculate the difference between two numeric values. Its versatility allows for various applications, such as financial modeling, data analysis, and performance evaluations. By leveraging the Subtract A - B block, developers can handle subtraction operations efficiently within their graphs, ensuring accuracy and precision in the final output. *** ### More Information The [Subtract A - B](/dev-tooling/blocks/math/subtract-a-b) block in the GraphLinq IDE is a powerful tool for performing subtraction operations between two numeric values, A and B. This block takes two inputs, A and B, and calculates the result of subtracting B from A. The output of this operation is the difference between the two input values. #### Use Case The "Subtract A - B" block is incredibly useful in scenarios where you need to calculate the difference or change between two numerical values. It is commonly employed in financial applications for calculating profits or losses, in data analysis for finding variations between data points, and in various other mathematical computations that involve subtraction. #### Example Let's consider an example where we have two variables, A = 10 and B = 5. By connecting these variables to the "Subtract A - B" block, the result will be 5. This represents the difference between A and B. In this example, the [Subtract A - B](/dev-tooling/blocks/math/subtract-a-b) block efficiently calculates the subtraction operation and produces the desired output of 5. *** ### Full Example `Subtract A - B` blocks subtract one given number from another, and then output the result. `Subtract A - B` blocks have two input parameters called "A" and "B". These are, of course, the two numbers we want to calculate the difference of. Note that these input parameters can be supplied with any type of numeric data (decimal, integer, long), and the two data types do not need to match (ie: you can subtract a decimal value from an integer value). As with all block types in the [`Math`](/dev-tooling/blocks/math) category, `Subtract A - B` blocks are non-executive blocks, which means that they have no yellow connectors, and thus they are never called explicitly by other blocks, and they themselves cannot call other blocks. Instead, they are called implicitly whenever their output is required as input by some other block that is executing. We can observe this happening in the example below.
# Add A + B Addition operations on numeric values The Add A + B block in the GraphLinq IDE is a fundamental mathematical component that allows developers to perform addition operations on numeric values. This block is a fundamental arithmetic operation that enables the combination of two numeric inputs to produce a single output representing their sum. ### Block Description The Add A + B block is categorized under the Math blocks in the GraphLinq IDE. Like other blocks in this category, it is a non-executive block, which means it does not have any yellow connectors and is implicitly called whenever its output is needed as input by other blocks during graph execution. ### Input Parameters The Add A + B block requires two input parameters: 1. A (Numeric Type): The A input represents the first numeric value to be added. 2. B (Numeric Type): The B input represents the second numeric value to be added. Both A and B can accept various numeric data types, such as integers, decimals, and longs. ### Output The Add A + B block outputs the result of the addition operation performed on the input values A and B. The output is of the same data type as the input values and represents the sum of A and B. ### Example Use Case Let's explore a practical example of how the Add A + B block can be used within a graph to calculate the total price of items in a shopping cart. 1. The graph receives real-time price data for each item in the shopping cart, expressed as decimal values (e.g., 10.50, 25.75, etc.). 2. The Add A + B block is called, taking the individual item prices as inputs A and B. 3. The block performs the addition operation, combining the prices of two items to calculate the total price. 4. The resulting sum (e.g., 36.25) is further processed or used in subsequent calculations within the graph. In this example, the Add A + B block plays a crucial role in calculating the total price of the items in the shopping cart by summing the individual item prices. The simplicity and efficiency of the Add A + B block make it an essential tool for performing basic arithmetic operations on numeric data in various graph scenarios. ### Conclusion The Add A + B block provides a straightforward and efficient solution for performing addition operations on numeric values in the GraphLinq IDE. By using this block, developers can easily combine two numeric inputs to produce a single output representing their sum. Whether it's for financial calculations, data aggregation, or any other scenario involving numeric data, the Add A + B block proves to be a valuable asset in achieving accurate and reliable results. *** ### More Information The Add A + B block is a fundamental component in the GraphLinq IDE, designed to calculate the sum of two numeric values, A and B. This block takes two inputs, "A" and "B," and efficiently computes their sum. The output of this operation is the numerical result of adding A and B together. Block Details: Add A + B blocks have two input parameters: "A" and "B." These input parameters can accept various types of numeric data, such as decimal, integer, or long. Additionally, "A" and "B" can have different data types, enabling users to add a decimal value to an integer value or vice versa. Execution: Similar to other block types in the Math category, Add A + B blocks are non-executive blocks. They do not have yellow connectors, which means they are not explicitly called by other blocks and cannot call other blocks themselves. Instead, they are implicitly called whenever their output is required as input by some other executing block. Use Case: The Add A + B block finds extensive applications in various domains where numerical addition is necessary. It is commonly used in financial calculations, data analysis, and general arithmetic operations. For instance, in financial applications, this block can be used to calculate total investment amounts, revenue projections, or asset valuations. Example: Let's consider an example to demonstrate the functionality of the Add A + B block. Suppose we have a graph that calculates the total sales revenue for a business. The graph takes inputs "A" and "B," representing the revenue from two different product lines. The Add A + B block then computes the total revenue by adding the revenue from both product lines together. The output of the Add A + B block represents the overall sales revenue, which can be further processed or displayed using other blocks in the graph. The graph can be configured to update in real-time, allowing business owners to monitor their total revenue dynamically as it changes. This example illustrates the implicit calling of the Add A + B block, as it is executed only when its output is required by another block's input. By utilizing the Add A + B block, developers can perform efficient addition operations within their graphs, making it easier to perform complex calculations and data processing tasks. The versatility of the Add A + B block makes it an indispensable tool for developers seeking to perform mathematical computations within their graphs. Whether it's summing financial data, calculating statistical measures, or performing general arithmetic operations, the Add A + B block offers a straightforward and effective solution for adding numerical values together. *** ### Full Example `Add A + B` blocks, as the name suggests, simply add two given numbers together and then output the result. `Add A + B` blocks have two input parameters called "A" and "B". These are, of course, the two numbers we want to add together. Note that these input parameters can be supplied with any type of numeric data (decimal, integer, long), and the two data types do not need to match (ie: you can add a decimal value to an integer value). As with all block types in the [`Math`](/dev-tooling/blocks/math) category, `Add A + B` blocks are non-executive blocks, which means that they have no yellow connectors, and thus they are never called explicitly by other blocks, and they themselves cannot call other blocks. Instead, they are called implicitly whenever their output is required as input by some other block that is executing. We can observe this happening in the example below.
# Ceiling Round a numeric value up to the nearest integer greater than or equal to the original value The Ceiling block in the GraphLinq IDE is a powerful mathematical tool used to round a numeric value up to the nearest integer greater than or equal to the original value. This block is particularly useful when precision is not required, and developers need to ensure that a value is always rounded up to the nearest whole number or integer. ### Block Description The Ceiling block is categorized under the Math blocks in the GraphLinq IDE. Like other blocks in this category, it is a non-executive block, meaning it does not have yellow connectors and is implicitly called whenever its output is needed as input by other blocks during graph execution. ### Input Parameter The Ceiling block requires one input parameter: 1. A (Numeric Type): The A input represents the numeric value that needs to be rounded up to the nearest integer. The A input can accept various numeric data types, such as decimals, integers, and longs. ### Output The Ceiling block outputs the result of rounding up the input value A to the nearest integer greater than or equal to A. The output is of the same data type as the input value. ### Example Use Case Let's explore a practical example of how the Ceiling block can be used within a graph to ensure that a calculated value is always rounded up to the nearest whole number. 1. The graph performs various complex calculations, resulting in a numeric value (e.g., 34.75, 11.35, etc.). 2. The Ceiling block is called, taking the calculated numeric value as input A. 3. The block rounds up the value to the nearest integer greater than or equal to the original value. 4. The resulting rounded-up value (e.g., 35, 12) is further used in subsequent calculations or to display data in the graph's output. In this example, the Ceiling block ensures that the calculated numeric value is always rounded up to the nearest whole number, even if the original value contains decimal places. This rounding behavior can be beneficial in various scenarios, such as calculating quantities for inventory management, displaying rounded data in user interfaces, or ensuring proper billing amounts in financial applications. ### Conclusion The Ceiling block provides a straightforward and effective solution for rounding numeric values up to the nearest integer in the GraphLinq IDE. By using this block, developers can ensure that a value is always rounded up, regardless of its decimal precision. Whether it's for simplifying complex calculations or ensuring data consistency, the Ceiling block proves to be a valuable tool in achieving precise and predictable rounding outcomes. *** ### More Information The Ceiling block in the GraphLinq IDE is a powerful mathematical tool used to round up a numeric value to the nearest integer greater than or equal to that value. This block is particularly useful when precision is required in numeric calculations, ensuring that values are rounded up to the desired level of accuracy. #### Block Details The Ceiling block takes a single input parameter, "A," which represents the numeric value that needs to be rounded up. This input can accept various types of numeric data, such as decimal, integer, or long. The Ceiling block's output is the rounded-up integer result of the input value. #### Execution Like other block types in the Math category, the Ceiling block is a non-executive block. It does not have yellow connectors and is not directly called by other blocks. Instead, it is implicitly called whenever its output is required as input by other executing blocks. #### Use Case The Ceiling block is essential in situations where precise rounding of numeric values is required. It is commonly used in financial applications, pricing calculations, and scenarios where data needs to be presented in a clear and consistent format. For example, in e-commerce applications, the Ceiling block can be used to round up product prices to the nearest whole number or a specific decimal place, ensuring consistent and accurate pricing. #### Example Let's consider an example to demonstrate the functionality of the Ceiling block. Suppose we have a graph that calculates the total cost of purchasing a specific quantity of items. The graph takes inputs "Unit Price" and "Quantity," representing the price of each item and the desired quantity to purchase, respectively. To determine the total cost, we need to multiply the unit price by the quantity. However, in certain scenarios, the unit price may have decimal places, and we want to ensure that the total cost is rounded up to the nearest whole number. Here, we can use the Ceiling block to round up the calculated total cost. The Ceiling block takes the product of the unit price and quantity as input and rounds it up to the nearest integer, representing the total cost of the purchase. This ensures that the total cost is always rounded up to the desired level of accuracy, even if the unit price has fractional values. By utilizing the Ceiling block, developers can perform precise rounding of numeric values within their graphs, ensuring that calculations and data processing tasks are accurate and reliable. The Ceiling block is an essential tool for maintaining consistency and precision in numerical operations, making it a valuable asset in various applications across industries. *** ### Full Example `Ceiling` blocks are used to round numbers up to the nearest integer. They are very similar to [`Floor`](/dev-tooling/blocks/math/floor) blocks; the only difference between the two is that `Ceiling` blocks round up (so 5.01 -> 6), whereas `Floor` blocks round down (so 5.99 -> 5). `Ceiling` blocks only have one input parameter called "Number", which is the number that we would like to round up. The logical data type for this parameter is decimal. As with all block types in the [`Math`](/dev-tooling/blocks/math) category, `Ceiling` blocks are non-executive blocks, which means that they have no yellow connectors, and thus they are never called explicitly by other blocks, and they themselves cannot call other blocks. Instead, they are called implicitly whenever their output is required as input by some other block that is executing. We can observe this happening in the example below.
# Divide A / B Perform division operations The Divide A / B block in the GraphLinq IDE is a fundamental mathematical block used to calculate the result of dividing one numeric value (A) by another (B). This block enables developers to perform division operations within their graphs and handle scenarios where sharing or splitting quantities is required. ### Block Description The Divide A / B block belongs to the Math blocks category in the GraphLinq IDE. As with other blocks in this category, it is a non-executive block, meaning it lacks yellow connectors and is implicitly called when its output is needed as input by other blocks during graph execution. ### Input Parameters The Divide A / B block requires two input parameters: 1. A (Numeric Type): The A input represents the numerator or dividend in the division operation. 2. B (Numeric Type): The B input represents the denominator or divisor in the division operation. Both A and B inputs accept various numeric data types, such as decimals, integers, and longs. It is essential to ensure that the B input is not set to zero, as division by zero is undefined and may lead to errors in the graph's execution. ### Output The Divide A / B block outputs the result of dividing the value of input A by the value of input B. The output is of the same data type as the inputs and represents the quotient or result of the division operation. ### Example Use Case Let's explore a practical example of how the Divide A / B block can be utilized within a graph to calculate the division of two quantities: 1. The graph retrieves data, such as the total quantity of items in stock (A) and the number of items sold (B). 2. The Divide A / B block is called, taking the values of A (total quantity) and B (number of items sold) as inputs. 3. The block calculates the division of A by B, resulting in the ratio of items sold to the total quantity. 4. The resulting quotient is then used for further analysis or to generate reports on sales performance. In this example, the Divide A / B block facilitates the computation of a vital business metric—the percentage of items sold out of the total quantity available. This information can be crucial for inventory management, sales forecasting, and decision-making processes.: ### Conclusion The Divide A / B block is an indispensable tool for performing division operations within graphs in the GraphLinq IDE. By using this block, developers can effortlessly calculate ratios, proportions, or percentages based on numeric values. Whether it's for business analytics, financial calculations, or any scenario that requires division, the Divide A / B block proves to be a valuable asset in ensuring accurate and efficient mathematical computations. *** ### More Information The Divide A / B block in the GraphLinq IDE is a fundamental mathematical block used to perform division operations between two numeric values. This block enables developers to divide one number (A) by another number (B) and obtain the result as the output. #### Block Details The Divide A / B block has two input parameters: "A" and "B." These parameters represent the dividend and divisor, respectively. The block takes the value of "A" and divides it by the value of "B" to compute the division result. Both "A" and "B" can be of various numeric data types, such as decimal, integer, or long. #### Execution As with other block types in the Math category, the Divide A / B block is non-executive. It does not have yellow connectors and is not explicitly called by other blocks. Instead, it is implicitly called whenever its output is needed as input by other executing blocks. #### Use Case The Divide A / B block is essential for performing division operations within graphs. It finds applications in various scenarios, such as calculating ratios, proportions, percentages, and scaling values. In financial applications, it can be used to determine unit prices, interest rates, or profit margins. Additionally, the block is valuable in data analysis and manipulation tasks where numeric values need to be divided to obtain meaningful insights. #### Example Let's consider an example to illustrate the functionality of the Divide A / B block. Suppose we have a graph that calculates the average rating of a product based on the total sum of ratings and the number of ratings received. The graph takes inputs "Total Ratings" (A) and "Number of Ratings" (B). To calculate the average rating, we need to divide the total sum of ratings by the number of ratings received. Here, we can use the Divide A / B block to perform the division operation. The block takes "Total Ratings" as A and "Number of Ratings" as B, and it computes the division result, which represents the average rating of the product. This enables us to obtain the average rating as output, which can then be used for further analysis or display. By using the Divide A / B block, developers can perform precise division operations within their graphs, allowing them to handle various numerical calculations and data processing tasks efficiently. The block plays a crucial role in ensuring accuracy and reliability in division-based computations, making it an indispensable component in numerous applications. *** ### Full Example `Divide A / B` blocks divide one given number by another and then output the result. `Divide A / B` blocks have two input parameters called "A" and "B". These are the two numbers that we want to get the quotient of. Note that these input parameters can be supplied with any type of numeric data (decimal, integer, long), and the two data types do not need to match (ie: you can divide a decimal value by an integer value). As with all block types in the [`Math`](/dev-tooling/blocks/math) category, `Divide A / B` blocks are non-executive blocks, which means that they have no yellow connectors, and thus they are never called explicitly by other blocks, and they themselves cannot call other blocks. Instead, they are called implicitly whenever their output is required as input by some other block that is executing. We can observe this happening in the example below.
# Floor Round down a numeric value to the nearest integer less than or equal to the original value The Floor block in the GraphLinq IDE is a fundamental component that allows developers to round down a numeric value to the nearest integer less than or equal to the original value. This mathematical operation is particularly useful for scenarios where precision is not required, and the goal is to obtain a whole number representation of the data. Block Description: The Floor block is categorized under the Math blocks in the GraphLinq IDE. Like other blocks in this category, it is a non-executive block, meaning it has no yellow connectors and is implicitly called whenever its output is needed as input by other blocks during graph execution. ### Input Parameters The Floor block requires a single input parameter: 1. Value (Numeric Type): The Value input represents the numeric value that needs to be rounded down to the nearest integer. This input can accept various numeric data types, such as integers, decimals, and longs. ### Output The Floor block outputs the result of rounding down the input value to the nearest integer. The output is always of integer data type, representing the whole number obtained after applying the floor function. ### Example Use Case Let's explore a practical example of how the Floor block can be used within a graph that processes financial data. 1. The graph receives real-time price data for a cryptocurrency, expressed as a decimal value (e.g., 45.75). 2. The Floor block is then called, taking the price data as input. 3. The block applies the floor function to the input value, rounding it down to the nearest whole number (e.g., 45). 4. The resulting integer value (e.g., 45) is further processed or used in subsequent calculations within the graph. In this example, the Floor block is employed to obtain a whole number representation of the cryptocurrency price, which is often used for display purposes or to make decisions based on discrete price levels. The simplicity and efficiency of the Floor block make it an essential tool for handling numeric data in scenarios where fractional values need to be converted into integers. ### Conclusion The Floor block offers a straightforward and effective solution for rounding down numeric values to the nearest integer. By using this block, developers can easily handle numeric data within their graphs, ensuring that the data aligns with specific requirements or calculations. Whether it's for financial applications, data processing, or any other scenario where precision is not a primary concern, the Floor block proves to be a valuable asset in achieving accurate and reliable results. *** ### More Information The Floor block in the GraphLinq IDE is a key mathematical block used to round down a numeric value to the nearest integer that is less than or equal to the original value. This block allows developers to truncate decimal or floating-point numbers and obtain whole numbers as output. #### Block Details The Floor block takes a single input parameter called "A," which represents the numeric value that needs to be rounded down. The block performs the floor operation on the input value "A" and outputs the resulting integer. "A" can be of various numeric data types, such as decimal, integer, or long. #### Execution Like other block types in the Math category, the Floor block is non-executive. It does not have yellow connectors and is implicitly called when its output is required by other executing blocks. Whenever the Floor block's output is needed in a graph, it automatically performs the floor operation on the input value "A" and provides the rounded-down integer as output. #### Use Case The Floor block is particularly useful when dealing with financial or quantitative data that involves rounding down decimal numbers to obtain whole numbers. It is commonly employed in areas such as accounting, finance, statistics, and data analysis. #### Example Let's consider an example to demonstrate the functionality of the Floor block. Suppose we have a graph that calculates the number of days required to complete a project based on the estimated total hours and the daily work capacity. The graph takes inputs "Total Hours" (A) and "Daily Work Capacity" (B). To calculate the number of days required, we need to divide the total hours by the daily work capacity. However, we also need to consider that partial days cannot be allocated, and we want to round down to the nearest whole number of days. Here, we can use the Floor block to perform the floor operation on the division result. The block takes the output of the division operation (A / B) and rounds it down to the nearest integer representing the number of whole days required to complete the project. By using the Floor block in this example, we ensure that we obtain accurate and realistic estimates of the project's duration, accounting for the restriction on partial days and aligning with practical project planning. The Floor block's ability to truncate decimal values is valuable in scenarios where precise whole numbers are necessary for further calculations, analysis, or decision-making. It provides developers with a simple yet powerful tool for handling rounding down operations and enhances the accuracy of their graphs and applications. *** ### Full Example `Floor` blocks are used to round numbers down to the nearest integer. They are very similar to [`Ceiling`](/dev-tooling/blocks/math/ceiling) blocks; the only difference between the two is that `Ceiling` blocks round up (so 5.01 -> 6), whereas `Floor` blocks round down (so 5.99 -> 5). `Floor` blocks only have one input parameter called "Number", which is the number that we would like to round down. The logical data type for this parameter is decimal. As with all block types in the [`Math`](/dev-tooling/blocks/math) category, `Floor` blocks are non-executive blocks, which means that they have no yellow connectors, and thus they are never called explicitly by other blocks, and they themselves cannot call other blocks. Instead, they are called implicitly whenever their output is required as input by some other block that is executing. We can observe this happening in the example below.
# Multiply A \* B Calculate the product of two numeric values The Multiply A \* B block in the GraphLinq IDE is a fundamental mathematical block used to calculate the product of two numeric values, A and B. This block is essential for performing various arithmetic operations and is widely used in mathematical computations and data processing tasks. ### Block Description The Multiply A \* B block is categorized under the Math blocks in the GraphLinq IDE. It is a non-executive block, which means it does not have yellow connectors and is implicitly called when its output is required by other blocks during graph execution. ### Input Parameters The Multiply A \* B block requires two input parameters: 1. A (Numeric Type): The A input represents the first numeric value to be multiplied. 2. B (Numeric Type): The B input is the second numeric value used for multiplication. Both A and B inputs can accept various numeric data types, including decimals, integers, and longs. The block automatically performs type conversion if the two inputs have different numeric data types. ### Output The Multiply A \* B block outputs the result of multiplying the values of input A and input B. The output is of the same data type as the inputs and represents the product of the multiplication. ### Example Use Case Let's explore a practical example of how the Multiply A \* B block can be used within a graph: 1. The graph receives sensor data containing the temperature readings (A) and the number of units (B) produced in a factory. 2. The Multiply A \* B block is called, taking the temperature readings (A) as the first numeric value and the number of units produced (B) as the second numeric value. 3. The block calculates the total energy consumption by multiplying the temperature readings with the number of units produced. 4. The output represents the total energy consumed during the production process. In this example, the Multiply A \* B block helps calculate the total energy consumption based on temperature and production quantity, providing valuable insights into the energy efficiency of the factory's production process. ### Conclusion The Multiply A \* B block is a fundamental arithmetic block in the GraphLinq IDE, enabling developers to perform multiplication operations between numeric values. Its versatility makes it suitable for various mathematical computations, data processing tasks, and real-world applications. By utilizing the Multiply A \* B block, developers can efficiently calculate products and derive valuable information from numeric data within their graphs. *** ### More Information The Multiply A \* B block in the GraphLinq IDE is designed to perform multiplication on two given numeric values "A" and "B." This block takes two input parameters representing the operands and outputs their product as the result. The Multiply A \* B block plays a crucial role in arithmetic operations within graphs and enables developers to compute the product of two numeric values efficiently. #### Block Details The Multiply A \* B block has two input parameters, "A" and "B," which represent the numeric values to be multiplied. Both "A" and "B" can be of various numeric data types, such as decimal, integer, or long. The block performs the multiplication operation on these input values and provides the product as its output. #### Execution As with other block types in the Math category, the Multiply A \* B block is non-executive. It does not have yellow connectors and is implicitly called whenever its output is needed as input by other executing blocks. Whenever the Multiply A \* B block's output is required in a graph, it performs the multiplication operation on the input values "A" and "B" and delivers the product as its output. #### Use Case The Multiply A \* B block finds widespread applications in various fields, including finance, engineering, and data analytics. In financial applications, it is used for calculating interest rates, profits, and asset valuations. In engineering, it is utilized in designing components with scalable dimensions or conducting simulations involving growth or decay. In data analytics, the block aids in scaling values and performing mathematical transformations on datasets. #### Example Let's consider an example to illustrate the usage of the Multiply A \* B block. Suppose we have a graph that simulates a sales calculator for an online store. The graph takes the unit price of a product (A) and the quantity of the product ordered (B) as inputs and needs to calculate the total cost of the order. To achieve this, we can use the Multiply A \* B block. By providing the unit price (A) and the quantity (B) to the Multiply A \* B block, it performs the multiplication operation and outputs the total cost of the order as the result. This enables us to quickly determine the financial impact of the purchase for both the customers and the store. The Multiply A \* B block's capability to perform multiplication efficiently is essential in a wide range of scenarios where the product of two numeric values needs to be computed. It empowers developers to perform arithmetic calculations within their graphs seamlessly and enhances the functionality and versatility of their applications. *** ### Full Example `Multiply A * B` blocks simply multiply two given numbers together and then output the result. `Multiply A * B` blocks have two input parameters called "A" and "B". These are, of course, the two numbers we want to multiply together. Note that these input parameters can be supplied with any type of numeric data (decimal, integer, long), and the two data types do not need to match (ie: you can multiply a decimal value by an integer value). As with all block types in the [`Math`](/dev-tooling/blocks/math) category, `Multiply A * B` blocks are non-executive blocks, which means that they have no yellow connectors, and thus they are never called explicitly by other blocks, and they themselves cannot call other blocks. Instead, they are called implicitly whenever their output is required as input by some other block that is executing. We can observe this happening in the example below.
# Percentage Difference Calculate the percentage difference between two numeric values The Percentage Difference block in the GraphLinq IDE is a powerful mathematical tool used to calculate the percentage difference between two numeric values. This block is particularly useful for analyzing data changes, comparing variations between values, and assessing relative differences in quantities. ### Block Description The Percentage Difference block belongs to the Math blocks category in the GraphLinq IDE. Like other blocks in this category, it is a non-executive block, meaning it does not have yellow connectors and is implicitly called when its output is needed by other blocks during graph execution. ### Input Parameters The Percentage Difference block requires two input parameters: 1. A (Numeric Type): The A input represents the initial numeric value that serves as the baseline for comparison. 2. B (Numeric Type): The B input is the second numeric value, which will be compared to the baseline value to calculate the percentage difference. Both A and B inputs can accept various numeric data types, including decimals, integers, and longs. The block automatically handles type conversion if the two inputs have different numeric data types. ### Output The Percentage Difference block outputs the percentage difference between values A and B. The output is a decimal value representing the percentage change. The output can be positive or negative, indicating whether the value B is an increase or decrease relative to the baseline value A. ### Example Use Case Let's explore a practical example of how the Percentage Difference block can be utilized in a graph: 1. The graph retrieves historical stock prices for a particular company and stores them in variables A and B. 2. The Percentage Difference block is invoked, taking the historical stock price (A) as the baseline and the current stock price (B) as the second value. 3. The block calculates the percentage difference between the historical price and the current price, indicating the price variation. 4. The output represents the percentage change in the stock price over the selected period. In this example, the Percentage Difference block enables the graph to analyze and visualize the percentage change in the stock price, aiding investors and analysts in making informed decisions based on historical data. The Percentage Difference block is a valuable mathematical tool within the GraphLinq IDE, facilitating the calculation of percentage changes between two numeric values. Its versatility makes it ideal for a wide range of applications, including data analysis, financial modeling, and trend assessment. By employing the Percentage Difference block, developers can easily assess and understand the relative differences between quantities, providing valuable insights in their graphs. *** ### More Information The Percentage Difference block in the GraphLinq IDE is a valuable tool for calculating the percentage difference between two given numeric values "A" and "B." It enables developers to determine the percentage change or variance between two quantities, expressing the result as a percentage. The Percentage Difference block plays a crucial role in various scenarios where comparing relative changes in values is essential. #### Block Details The Percentage Difference block takes two input parameters, "A" and "B," which represent the numeric values for comparison. Both "A" and "B" can be of various numeric data types, such as decimal, integer, or long. The block calculates the percentage difference between "A" and "B" and provides the result as its output. #### Execution As with other block types in the Math category, the Percentage Difference block is non-executive. It does not have yellow connectors and is implicitly called whenever its output is needed as input by other executing blocks. When the Percentage Difference block's output is required in a graph, it performs the calculation to find the percentage difference between the input values "A" and "B" and delivers the result as its output. #### Use Case The Percentage Difference block finds broad applications in various fields, including finance, economics, statistics, and data analysis. In finance, it is used to analyze the performance of investments and financial instruments by comparing their values over time. In economics, it aids in evaluating changes in economic indicators and trends. In statistics, it is utilized to assess changes in data distributions and relationships between variables. In data analysis, the block helps in quantifying variations in datasets and identifying outliers. #### Example Let's consider an example to illustrate the usage of the Percentage Difference block. Suppose we have a graph that tracks the monthly revenue of an e-commerce website. The graph takes the revenue for the current month (A) and the revenue for the previous month (B) as inputs and needs to calculate the percentage change in revenue. To achieve this, we can use the Percentage Difference block. By providing the revenue for the current month (A) and the revenue for the previous month (B) to the Percentage Difference block, it calculates the percentage difference and outputs the result. This enables us to quickly determine the percentage increase or decrease in revenue from one month to the next, providing valuable insights into the business's performance. The Percentage Difference block's ability to calculate percentage variations is crucial in various real-world scenarios where understanding relative changes in values is essential. It empowers developers to perform percentage-based analyses within their graphs and facilitates data-driven decision-making in diverse domains. *** ### Full Example `Percentage Difference` blocks calculate the percentage difference between two given numbers, with respect to the first of the two numbers. `Percentage Difference` blocks have two input parameters called "A" and "B". Their output expresses what percent "A" would need to change for it to be equal to "B". This is equivalent to *100(B - A) / A*. As with all block types in the [`Math`](/dev-tooling/blocks/math) category, `Percentage Difference` blocks are non-executive blocks, which means that they have no yellow connectors, and thus they are never called explicitly by other blocks, and they themselves cannot call other blocks. Instead, they are called implicitly whenever their output is required as input by some other block that is executing. We can observe this happening in the example below.
# Round Round numeric values to the nearest integer or to a specific number of decimal places The Round block in the GraphLinq IDE is a fundamental mathematical tool used to round numeric values to the nearest integer or to a specific number of decimal places. This block is invaluable for formatting numerical data and ensuring it aligns with desired precision levels. ### Block Description The Round block is part of the Math blocks category in the GraphLinq IDE. As with other blocks in this category, it is a non-executive block, which means it lacks yellow connectors and is implicitly called when other blocks require its output during graph execution. ### Input Parameters The Round block requires two input parameters: 1. Number (Numeric Type): The Number input represents the numeric value that needs to be rounded. 2. Decimal Places (Integer Type): The Decimal Places input specifies the number of decimal places to which the value should be rounded. If this parameter is omitted, the block will round the number to the nearest integer. ### Output The Round block outputs the rounded numeric value based on the provided input. The output will be an integer when the Decimal Places parameter is not provided, and a decimal number when the Decimal Places parameter is used to specify the precision level. Example Use Case: Let's examine a practical example of how the Round block can be utilized in a graph: 1. The graph calculates the average temperature of a location and stores the result in a variable called AverageTemperature. 2. The Round block is invoked, taking AverageTemperature as the input number and specifying the desired precision level using the Decimal Places parameter. 3. The block rounds the average temperature to the specified number of decimal places, ensuring that the temperature value is presented with the appropriate level of precision. 4. The output represents the rounded temperature value, which can be used for display or further computations. In this example, the Round block allows the graph to format the average temperature data, ensuring it is presented in a visually pleasing and meaningful way to users or other downstream processes. The Round block is a versatile mathematical tool within the GraphLinq IDE, providing the capability to round numeric values to the nearest integer or to a specific number of decimal places. Its usefulness extends across various domains, including financial applications, data analysis, and user interface development. By utilizing the Round block, developers can ensure that numeric data aligns with desired precision levels, enhancing the overall quality and readability of the graph's output. *** ### More Information The Round block in the GraphLinq IDE is a fundamental mathematical component used to round a given numeric value "A" to the nearest whole number or a specified number of decimal places. It provides a convenient method to adjust the precision of numeric data, ensuring that the output conforms to the desired level of accuracy. #### Block Details The Round block takes two input parameters: "A" and "Decimal Places." "A" represents the numeric value that needs to be rounded, and "Decimal Places" is an optional parameter that allows developers to specify the number of decimal places to which the value should be rounded. If "Decimal Places" is not provided, the block rounds "A" to the nearest whole number. #### Execution Like other blocks in the Math category, the Round block is non-executive, meaning it does not have yellow connectors. Instead, it is implicitly called whenever its output is needed as input by other executing blocks. When the Round block's output is required in a graph, it performs the rounding operation on the input value "A" and delivers the rounded result as its output. #### Use Case The Round block finds extensive applications in various scenarios where precision in numeric data is critical. It is commonly used in financial calculations, statistical analyses, and data visualizations. For instance, in financial applications, rounding is essential for representing monetary values in a standardized format. In statistics, rounding data helps maintain a consistent level of significance across datasets. In data visualizations, rounded values improve readability and eliminate unnecessary detail. #### Example Let's consider an example to illustrate the usage of the Round block. Suppose we have a graph that calculates the average temperature for a given day, based on hourly temperature measurements. The graph takes the sum of hourly temperatures (A) and the number of measurements (B) as inputs and needs to compute the average temperature. To achieve this, we first use the Divide A / B block to calculate the average temperature, which might result in a decimal value with multiple decimal places. However, for display purposes, we want to round the average temperature to two decimal places. To achieve the desired rounding, we can use the Round block with "Decimal Places" set to 2. By providing the calculated average temperature to the Round block and specifying "2" for the "Decimal Places" parameter, the block rounds the value to two decimal places and outputs the rounded average temperature. The Round block's ability to round numeric values to a specified precision enables developers to control the level of detail in their graphs' outputs. It enhances the presentation of numeric data and ensures that calculations conform to the desired level of accuracy. *** ### Full Example `Round` blocks are used to round a given decimal number to a given degree of precision. `Round` blocks have two input parameters: "Number", which is the number we would like to have rounded, and which should be a decimal type value, and "Decimal", which (somewhat confusingly) is an integer that represents how many digits of precision we would like to the right of the decimal point. As with all block types in the [`Math`](/dev-tooling/blocks/math) category, `Round` blocks are non-executive blocks, which means that they have no yellow connectors, and thus they are never called explicitly by other blocks, and they themselves cannot call other blocks. Instead, they are called implicitly whenever their output is required as input by some other block that is executing. We can observe this happening in the example below. In this example, we are using a Discord bot that we control in conjunction with a [`String Branch`](/dev-tooling/blocks/base-condition/string-branch) block to listen to our Discord channel for the message "/matic\_price". When we detect that someone has sent that message, we use a [`Get CoinGecko Coin`](/dev-tooling/blocks-exchange/coingecko/get-coingecko-coin) block to retrieve the current price of the Matic token. We then use our `Round` block to round the price to 3 digits of precision (for example, $1.124) before adding it into a short message using a [`Replace String In String`](/dev-tooling/blocks/string/replace-string-in-string) block and then submitting that message to our Discord channel with our bot using a [`Send Discord Channel Message`](/dev-tooling/blocks-messaging/discord/send-discord-channel-message) block.
# HTTP Hypertext Transfer Protocol: the set of rules that control the way data is sent and received over the Internet HTTP (Hypertext Transfer Protocol) blocks in the GraphLinq IDE provide essential functionalities for making HTTP requests to interact with external web services and APIs. These blocks enable developers to retrieve data from external sources, send data to remote servers, and perform various operations that involve web-based communication. The HTTP blocks facilitate seamless integration of graphs with web-based services, making them powerful tools for building applications that rely on external data sources or APIs. The [Delete HTTP Request](/dev-tooling/blocks/http/delete-http-request) block is used to send HTTP DELETE requests to a specified URL. DELETE requests are commonly used to delete resources or data on a server. The block allows developers to configure headers, query parameters, and other options required for the DELETE request. The [Get HTTP Request](/dev-tooling/blocks/http/get-http-request) block enables the execution of HTTP GET requests to retrieve data from a specified URL. GET requests are used to fetch data from servers without altering the server's state. The block allows developers to include headers, query parameters, and other options in the GET request. The [Post HTTP Request](/dev-tooling/blocks/http/post-http-request) block facilitates the sending of HTTP POST requests to a designated URL. POST requests are typically used to submit data to the server to create new resources or perform other actions that change the server's state. The block supports customization of headers, query parameters, and the body of the POST request. The [Put HTTP Request](/dev-tooling/blocks/http/put-http-request) block enables the execution of HTTP PUT requests to update resources on a server. PUT requests are commonly used to update existing data or resources. The block allows developers to specify headers, query parameters, and the body of the PUT request. The [Array to JSON Body](/dev-tooling/blocks/http/array-to-json-body) block is a utility block that converts an array of data into a JSON format. JSON (JavaScript Object Notation) is a widely used data interchange format, and this block is handy when preparing data to be sent as the body of an HTTP request. The [Array To Body Values](/dev-tooling/blocks/http/array-to-body-values) block is another utility block used to convert an array of data into a format suitable for use in the body of an HTTP request. It allows developers to transform array data into a format that can be included as part of the request's body. HTTP blocks play a crucial role in enabling graphs to interact with external web services, APIs, and data sources. These blocks empower developers to create dynamic and data-rich applications that leverage data from the web to enhance functionality and user experience. By utilizing HTTP blocks, developers can seamlessly integrate their graphs with web-based services, making them more versatile and capable of handling a wide range of tasks that involve web communication and data exchange. # Array To Body Values Transform arrays into key-value pairs The Array To Body Values block is a powerful component within the GraphLinq IDE that facilitates the transformation of arrays into key-value pairs suitable for use as the body of an HTTP request. When interacting with APIs or web services, it is common to send data in the form of key-value pairs within the request body. The Array To Body Values block simplifies this process by converting arrays into a format that can be readily utilized as an HTTP request body. ### Block Description The Array To Body Values block is categorized under the HTTP blocks in the GraphLinq IDE. As a non-executive block, it does not have any yellow connectors and is implicitly called whenever its output is required by another block during graph execution. ### Input Parameters The Array To Body Values block requires one primary input parameter: 1. Array: The array input contains the data elements that need to be transformed into key-value pairs. This array can include various data types, such as strings, numbers, and booleans. ### Output The Array To Body Values block outputs the data from the input array in the form of key-value pairs suitable for use as the body of an HTTP request. The keys represent the indices of the array elements, and the values represent the corresponding data elements. ### Example Use Case Let's explore a practical example of how the Array To Body Values block can be utilized in a graph that interacts with an API to update user information. 1. The graph receives inputs from a user interface or data source containing the updated information for a user. This information is stored in an array within the graph. 2. The Array To Body Values block is then called, taking the array of user data as input. 3. The block automatically transforms the array data into key-value pairs, with each index of the array serving as the key and the corresponding data element as the value. 4. The resulting key-value pairs are used as the body of an HTTP PUT request to the API's endpoint for updating user information. 5. The API processes the request and updates the user's information based on the provided key-value pairs. 6. The API responds with a success message or status, which can be further processed by other blocks in the graph. By leveraging the Array To Body Values block, developers can easily convert arrays into key-value pairs suitable for use in HTTP requests, simplifying the data transmission process when interacting with various APIs and web services. This capability enables developers to create robust applications that seamlessly exchange data with external services, enhancing the overall functionality and versatility of their applications. # Array To JSON Body Convert arrays into JSON format The Array To JSON Body block is a valuable component in the GraphLinq IDE that facilitates the conversion of arrays into JSON format. JSON (JavaScript Object Notation) is a widely used data interchange format, and it is particularly useful for representing complex data structures, such as arrays and objects, in a human-readable and easy-to-parse format. ### Block Description The Array To JSON Body block is categorized under the HTTP blocks in the GraphLinq IDE. It serves as a non-executive block, meaning it does not have any yellow connectors and is implicitly called whenever its output is required by another block during graph execution. ### Input Parameters The Array To JSON Body block requires one primary input parameter: 1. Array: The array input contains the data elements that need to be converted into JSON format. This array can consist of various data types, including strings, numbers, booleans, and even other arrays or objects. ### Output The Array To JSON Body block outputs the JSON representation of the input array. This JSON output can be used as the body of an HTTP request when interacting with APIs that expect data in JSON format. ### Example Use Case Let's explore a practical example where the Array To JSON Body block is utilized in a graph that interacts with an online store's API to place an order for multiple items. 1. The graph receives inputs from a user interface or data source containing the details of the items the user wants to purchase. These item details are stored in an array within the graph. 2. The Array To JSON Body block is then called, taking the array of item details as input. 3. The block automatically converts the array into JSON format, maintaining the data's structure and type information. 4. The JSON output is used as the body of an HTTP POST request to the online store's API. 5. The API processes the request and places the order for the items specified in the JSON body. 6. The API responds with a confirmation or order status, which can be further processed by other blocks in the graph. By leveraging the Array To JSON Body block, developers can effortlessly convert arrays containing structured data into JSON format, enabling seamless interactions with APIs that require JSON-formatted data. This capability allows developers to build applications that efficiently communicate with various web services and APIs, streamlining data exchange processes and enhancing the overall functionality of their applications. # Put HTTP Request Send HTTP PUT requests ### **Overview** Within the GraphLinq Integrated Development Environment (IDE), the `Put HTTP Request` block is essential for initiating HTTP PUT requests to external web servers or APIs. This method is crucial for updating or replacing resources on a server, allowing developers to effectively modify existing records or refresh data on remote servers using RESTful APIs. ### **Block Characteristics** * **Type**: Non-executive, operating without yellow connectors and is triggered indirectly as other blocks in the graph require its output. * **Functionality**: Specially designed for data updates or replacements, making it an invaluable asset for interfacing with external APIs. ### **Inputs** To execute a PUT request, the block necessitates the following inputs: * **URL**: Points to the specific server or API endpoint where the data update or replacement will occur. * **Headers**: An [Array](/dev-tooling/blocks/array) of [Key-Value](/dev-tooling/blocks/base-variable/keyvalue) pairs, allowing for the transmission of additional request information or authentication details to the server. These headers are optional but can be pivotal for specific server communications. * **Body**: Contains the payload with the data meant to be updated or replaced, often formatted as a JSON object or according to the API's prescribed data formats. ### **Output** The block yields the server's response following the PUT request, encompassing the status code, any returned data, and potentially other relevant feedback. ### **Practical Application** Imagine a scenario where the `Put HTTP Request` block updates user profile data through a fictional API: 1. The process begins with an interface (e.g., a web form or chatbot) that collects the user's new profile information. 2. This updated data is then stored within a designated variable or data store in the graph. 3. Subsequently, the block is configured with the API's URL, incorporating the updated profile data into the request body. 4. Headers are crucial at this stage; developers can append custom key-value pairs to convey specific instructions or authentication details to the server. 5. The block is indirectly activated by the graph's logic whenever its output becomes necessary. 6. The PUT request is dispatched to the API, aiming to update the user's profile on the server. 7. Following the request processing, the server returns a response, which might confirm the update or provide additional information. This use case illustrates how the `Put HTTP Request` block seamlessly integrates data update capabilities into graphs, enabling interactions with a variety of web services and APIs that accept the HTTP PUT method. This enriches applications by allowing secure and efficient data modification or replacement on remote servers, thus offering users enhanced control over their data within the application ecosystem. # Post HTTP Request Send HTTP POST requests ### **Overview** The `Post HTTP Request` block in the GraphLinq Integrated Development Environment (IDE) is a fundamental tool for executing HTTP POST requests to external web servers or APIs. Utilizing the POST method, this block is designed to submit data for processing to a targeted resource on a server. It is an essential block for developers looking to create, update records, or send user inputs to remote endpoints via RESTful APIs. ### **Block Characteristics** * **Type**: Non-executive * **Connectivity**: Lacks yellow connectors; activated indirectly by the demand for its output in graph flows * **Functionality**: Facilitates the submission of data to external servers or APIs, supporting a wide range of interactions. ### **Inputs** To execute an HTTP POST request, the `Post HTTP Request` block requires: * **URL**: Identifies the API endpoint or server resource where the data will be processed. * **Headers**: An [Array](/dev-tooling/blocks/array) of [Key-Value](/dev-tooling/blocks/base-variable/keyvalue) pairs, allowing for the transmission of additional request information or authentication details to the server. These headers are optional but can be pivotal for specific server communications. * **Body**: The main content of the POST request, containing the data intended for submission. This is often structured as a JSON object or in another format suitable for the target API. ### **Output** The output from the block includes the server's response to the POST request, which might comprise the status code, returned data, or other pertinent feedback from the server. ### **Practical Application** Imagine a scenario where the `Post HTTP Request` block is used to send user feedback to a hypothetical API. The process involves: 1. Gathering feedback through a user interface, such as a web form or chat interface. 2. Storing the collected feedback in a graph variable or data source. 3. Configuring the block with the API's URL and incorporating the feedback within the request body. 4. Optionally adding custom headers for additional request specifications or authentication. 5. The block is invoked indirectly as needed by the graph's flow for its output. 6. Upon execution, it sends the POST request to the API, delivering the user feedback for storage. 7. The API processes the submission and responds, potentially with confirmation of receipt or additional information. This example highlights the `Post HTTP Request` block's role in enabling graphs to incorporate data submission functionalities seamlessly. With this block, developers can extend their applications to interact dynamically with web services and APIs supporting the HTTP POST method, thereby enriching the applications' interactivity and capabilities in handling user inputs or other data transactions remotely. --- [Next Page](/llms-full.txt/1)