Forem: Bensigo Egwey

Creating A Simple Blog Engine With Solidity

Bensigo Egwey — Sun, 09 Oct 2022 05:49:56 +0000

Blockchain has been one of the top buzzwords in the world lately, and Ethereum is one of the top Blockchains, which uses Solidity for building DAPPS (decentralized apps) or smart contracts. Today I will be showing you how easy it is to develop a DAPPS. So excited about this.

A quick overview of what we will be doing.

Create Post
Publish Post
List Post
Get Post.

Remix is an online solidity editor which you can use in writing and deploying your smart contract. we are going to be using it today.
Go to remix and you should have something like this below.

Click the contract directory and create a file Blog.sol
Add this snippet to your file.

// SPDX-License-Identifier: unlicensed
pragma solidity ^0.8.0;

contract Blog {}

what is going on up there, what is SPDX License Identifier?
SPDX License Identifiers can be used to indicate relevant license information at any level, from package to the source code file level
pragma solidity ^0.8.0 tells the EVM (Ethereum Virtual Machine) what version of solidity we are using. To check everything is working as expected, go to solidity compiler and click the blue button compile Blog.sol it should work fine.
Next, let's define the structure of what a Post should look like.

     uint256 _id = 1;

    struct Post{
       uint256 id;
       string  title;
       address owner;
       string body;
       bool isPublished;
       uint256 createdAt;
       uint256 publishedAt;
    }

    mapping(uint256 => Post) posts;

Here we have a variable _id which serves as a counter, and a struct which is used to define a new data type. Mapping is very similar to objects in Javascript, which is just a key-value pair.

Creating A Post

To create a post, add this snippet below

    function createPost(string memory _title, string memory _body, bool _isPublished) public {
        Post storage newPost = post[_id];
        newPost.id = _id;
        newPost.title = _title;
        newPost.owner = msg.sender;
        newPost.body = _body;
        newPost.isPublished = _isPublished;
        newPost.createdAt = block.timestamp;

        if (_isPublished){
            newPost.publishedAt = block.timestamp;
        }
        _id++;
    }

So we created a publicly available method. msg.sender this is a global variable accessible on the blockchain to get the user interacting with the contract at the moment. In solidity, block.timestamp gives the current time.
Note memory this is used to hold temporary values. It is erased between (external) function calls and is cheaper to use.

Get Post

To get a single post we are going to find it by using the id of the post as shown below.


    function getPost(uint256  id) public view  returns ( Post memory) {
        return post[id];
    }

The above function has visibility of public and view tells the EVM no state was modifier and is a getter method that returns a Post.

List Posts

We are going to return a list of all the posts.

function listPost() public view returns (Post [] memory){
        Post[] memory posts = new Post[](_id);
        for (uint i = 0; i < _id; i++) {
            posts[i] = post[_id];
        }
        return posts;
    }

We are just returning a list of posts since we can't return mapping we created a list of the length of the id counter.

Publish Post

Here we will update the state of a post and add the published date


    function publishPost(uint256 id, bool isPublished) public  returns (Post memory){
        // error handling
        require(posts[id].owner == msg.sender, "Not allowed");
        posts[id].isPublished = isPublished;
        posts[id].publishedAt = block.timestamp;
        return posts[id];
    }

You should have something like this now

// SPDX-License-Identifier: unlicensed
pragma solidity ^0.8.0;

contract Blog {
    uint256 _id;

    struct Post{
       uint256 id;
       string  title;
       address owner;
       string body;
       bool isPublished;
       uint256 createdAt;
       uint256 publishedAt;
    }

    mapping(uint256 => Post) posts;


    function createPost(string memory _title, string memory _body, bool _isPublished) public {
        Post storage newPost = posts[_id];
        newPost.id = _id;
        newPost.title = _title;
        newPost.owner = msg.sender;
        newPost.body = _body;
        newPost.isPublished = _isPublished;
        newPost.createdAt = block.timestamp;

        if (_isPublished){
            newPost.publishedAt = block.timestamp;
        }
        _id++;
    }

    function getPost(uint256  id) public view  returns ( Post memory) {
        return posts[id];
    }

    function listPost() public view returns (Post [] memory){
        Post[] memory result = new Post[](_id);
        for (uint i = 0; i < _id; i++) {
            result[i] = posts[_id];
        }
        return result;
    }

    function publishPost(uint256 id, bool isPublished) public  returns (Post memory){
        // error handling
        require(posts[id].owner == msg.sender, "Not allowed");
        posts[id].isPublished = isPublished;
        posts[id].publishedAt = block.timestamp;
        return posts[id];
    }
}

Now to test your smart contract go to deploy and smart contract tab and deploy it so you can test. If you hung on till the end you did it, congrats.

Building Rest API with Buildable and Twilio

Bensigo Egwey — Thu, 06 Oct 2022 13:09:41 +0000

Recently I came across Buildable and was impressed with what I can do with it, so I decided to share my knowledge which I believe could be of use to someone. Buildable makes API development easy for developers without having to worry about Devops related stuff and how to scale your API. Today will be Building a RESTful API for creating orders.
To start, you need to create an account with Buildable, which you can do by linking your Github account.

Creating Workflow

Go to app and create a new workflow

you can add a description if you wish and click the create button.
Notice you have the body, action, and response tabs as seen below

Body: Here you pass your request body when testing the API.
Header: For adding request headers e.g auth token
Action: Here you can add different actions you are given out of the box like stripe, database integration, and more you can also add some of your logic here if required.
Response: Here you add some logic and what you want to return as a response when the API is called.

Adding Functionality

We will be adding a new action to create an order to our database which we will use MongoDB.
Click new action and search for MongoDB and select insert document, this will give you the ability to insert a new document to your collection. You should have something like this below

Here we updated your collection name to "test-order"

  const { MONGODB_CONNECTION_KEY, collection, ...fieldsToInsert, productId } = input;

here we add the productId in the run function which will get from the body of the request to create an order

 const product = getProduct(productId)
  if (!product) {
    return {}
  }

checking if the product exists, if it does not we return an empty object

  const order = {
      _id,
      createdDate,
      createdAt,
      name: product.name,
      address: "test address",
      status: "pending",
      productId,
      amount: product.amount,
    }

    const db = await getConnection(MONGODB_CONNECTION_KEY)

    const results = await db.collection(collection).insertOne(order)

if the product exists will create an order object and insert it into our collection.
Our run function should look like this at the end

   const run = async (input) => {
  const { MONGODB_CONNECTION_KEY, collection } = input

  verifyInput(input)
  const { productId } = input
  // Write your logic here
  const product = getProduct(productId)
  if (!product) {
    return {}
  }
  try {
    const _id = cleanUUID()
    const createdDate = new Date()
    const createdAt = createdDate.getTime()

    const order = {
      _id,
      createdDate,
      createdAt,
      name: product.name,
      address: "test address",
      status: "pending",
      productId,
      amount: product.amount,
    }

    const db = await getConnection(MONGODB_CONNECTION_KEY)

    const results = await db.collection(collection).insertOne(order)

    return results
  } catch (error) {
    return {
      failed: true,
      message: error.message,
      data: {
        ...error.data,
      },
    }
  }
}

then now below the run function add this code

 const products = [
  {
    id: 1,
    productId: 101,
    name: "noodles",
    amount: 50,
    currency: "aed",
  },
  {
    id: 2,
    productId: 201,
    name: "Pepsi",
    amount: 20,
    currency: "aed",
  },
]
function getProduct(id) {
  return products.filter((p) => p.productId === id)[0]
}

which is just mock data and a function that checks if the product exists.
Go to the response and update the response tab to this

  async function response({ body, headers, env, $actions }) {
    // Write your logic here
    const order = $actions.createOrder;
    // create product
     if (!order){
       return {
        status: 404,
        body: {}
      }
     }
     const msg = `Your order ${order.insertedId.toString()} is being created successfully`
     await notifyUser(msg, 'xxxxxxx', env)
  // send SMS/email to tell user order have been created
    return {
      status: 200, // HTTP Response Status Code
      headers: {}, // Response Headers
      body: {
        ...order,
      },
    }
  }


async function notifyUser(msg, mobile, env) {
  const axios = require("axios");
  const client = require('twilio')(env.TWILIO_ACCOUNT_SID, env.TWILIO_AUTH_TOKEN ); 
 // the form should be your twilio number
  await client.messages.create({         
         to: mobile, body: msg, from: 'xxxxxx' }) 
}

So here we get the response from the action from $actions.createOrder if the project is empty means we don't have a product else it returns the order created and sends an SMS to notify the user the order has been created. To get your twilio credentials you need to create an account.

Testing The API

Now to test our API go to the body tab and add this snippet

{
  "productId": 101
}

now click the save button to save all we did and click the run button you should get something like this

{
  "acknowledged": true,
  "insertedId": "89bebecc38cb4db5ae9b68516ef0eceb"
}

Voila that how easy it is to create an API with Buildable. I hope you enjoyed this article, please don't forget to try using Buildable and sharing it with your friends. Also i will love to give kudos to Moe, Paul and Esther from Buildable.

Getting A Realtime GraphQL API in Minutes with Hasura

Bensigo Egwey — Mon, 23 Mar 2020 05:40:21 +0000

We live in a world where we want to try out our ideas so fast and building and setting up a good backend for Front end engineers is really difficult, that why we use BAAS(backend as a service) like Firebase, Hasura. To go further first we have to know what GraphQL and Hasura are.

What Is GraphQL?

GraphQl is a query language created by Facebook to query our data, which helps to solve the issue of over/under fetching and also helps with low bandwidth consumption of data. example of a query

 query {
    post{
      id
      title
      author{
        id
        name
      }
   }
}

To learn more GraphQL

What is Hasura?

Hasura is an engine that connects your Mirco-services and Database and generates a realtime GraphQl API(Application Programming Interface). That is really super 😎 and 🤯, the most amazing thing is Open source.
To learn more Hasura
In this series, we would be focusing on building a Todo list app using Hasura, Postgres, and Gatsby.js but in this part, we would focus on generating our API and later series we would be using Gatsby for the consumption of the GraphQL API.
To get started you go to hasura and click the button deploy to Heroku which deploy the backend in 30 seconds.

After you sign-in, you would be asked for the app name and region you want the server to be, I would be using todolist-gatsby-app as name and United Stated as my region, choose what best for you then click deploy

After the deploy is done you click on the view button which displays a Dashboard with GraphiQL UI and a Data UI where you can create a table and query your database.

you should have something like the screenshot above. Go to the Data menu and add the following field shown in the photo below and click the Add table button.

That all you need to create a graphQL API, now we go to the GraphiQL menu tab and we can query and mutate our todos table.
Let add data to your todos table by adding this mutation

mutation {
  insert_todos(objects: {name: "Learn more about Hasura", completed: false}){
    affected_rows
  }
}

while to query our table you use this

  query MyQuery {
  todos{
    id
    name
    completed
  }
}

and you get back this

  {
  "data": {
    "todos": [
      {
        "id": "524e3f9a-9033-497a-982c-78543f8b1c46",
        "name": "Learn more about Hasura",
        "completed": false
      }
    ]
  }
}

This is where we would be stoping for today. Thanks for reading and don't forget to follow me to get notified for next part of the series 😎.