Event Connectis in the Events Tech Industry

Event Connect

eventconnect

Using MinIO and Python to Create Scalable and Efficient Event-driven Applications

স্কেলযোগ্য এবং দক্ষ ইভেন্ট-চালিত অ্যাপ্লিকেশন তৈরি করতে MinIO এবং Python ব্যবহার করে

Verwenden von MinIO und Python zum Erstellen skalierbarer und effizienter ereignisgesteuerter Anwendungen

Uso de MinIO y Python para crear aplicaciones basadas en eventos escalables y eficientes

Utiliser MinIO et Python pour créer des applications événementielles évolutives et efficaces

स्केलेबल और कुशल इवेंट-संचालित एप्लिकेशन बनाने के लिए मिनियो और पायथन का उपयोग करना

MinIO と Python を使用してスケーラブルで効率的なイベント駆動型アプリケーションを作成する

MinIO 및 Python을 사용하여 확장 가능하고 효율적인 이벤트 기반 애플리케이션 만들기

Usando MinIO e Python para criar aplicativos orientados a eventos escalonáveis e eficientes

Использование MinIO и Python для создания масштабируемых и эффективных приложений, управляемых событиями

Ölçeklenebilir ve Verimli Olay Odaklı Uygulamalar Oluşturmak için MinIO ve Python'u Kullanmak

Sử dụng MinIO và Python để tạo các ứng dụng hướng sự kiện có khả năng mở rộng và hiệu quả

使用 MinIO 和 Python 创建可扩展且高效的事件驱动应用程序

Let's learn about via these 57 free stories. They are ordered by most time reading created on HackerNoon. Visit the to find the most read stories about any technology. Json /Learn Repo 1. Creating Developer-Friendly Data Services with Apache Cassandra Using data APIs and advanced data modeling will make it far easier for JSON-oriented developers to connect to Apache Cassandra. 2. Introducing Yet Another JWT Debugger Introducing a new JWT Debugger App - our way to contribute back to the developer community. The app is available on the web and as Desktop apps for Windows, Linux, and Mac. With JWT Debugger App we immediately highlight what really matters to you as a developer without any shenanigans. It is a very simple tool but we hope it will improve the developer experience. 3. How to Use .populate() With mongoDB How to use populate() method with mongoDB to itch data across referenced collections 4. How to Query Deeply Nested JSON Data in PSQL Recently I had to write a script, which should’ve changed some JSON data structure in a PSQL database. Here are some tricks I learned along the way. 5. How to Export Your HackerNoon Stories as a PDF The HackerNoon team is back at it with a new feature! You can now export your stories to a PDF or a JSON file. 6. The History of JSON and the People That Created It Douglas Crockford and Chip Morngingstar created the data exchange format that is now known as JSON. 7. Automate Simply With Webhook Automate anything with Webhook, a simple tool for your toolbox 8. With JSONB Data in PostgreSQL, You Can Get the Best of Both Worlds JSONB in PostgreSQL offers the best of relational and NoSQL. Here are two techniques that we use at AppLand to make JSONB data even more effective. 9. Custom Log Processor Integration – Fluentd vs Vector.dev By writing your tool, you gain more customization options, versatility, and other enhanced capabilities that can enrich your processing. 10. Defining Types: Using allOf in Swagger JSON Image by Devanath from Pixabay 11. 7 Kotlin Libraries Every Developer Should Know The most common Kotlin libraries that are used for cross-platform and Android development, testing, and documentation are considered in the article. 12. So, How are Observability and Monitoring Different, Actually? The similarities and differences between monitoring and observability and how to pair the two strategies 13. Ruby: How to read/write JSON File In Ruby read and write JSON file to hash can be achieved using File Handling. 14. How To Extract Key or Value From Hash in Ruby on Rails When I was recently working in one of the client projects, I had to
communicate with external MariaDB server to store records from
React/Rails app, that means I would get ActiveRecord hash from our app
which I had to convert to pure SQL query and send it to an external
server for storing. 15. A Quick Primer on Data Scraping Suppose you want to get large amounts of information from a website as quickly as possible. How can this be done? 16. Streamlining Form Validation with JSON Schema for Front-End and Back-End Efficiently validate forms with a single set of rules for both front-end and back-end using JSON Schema. 17. The Complete Microservice Tutorial: Introduction [Part 1] Project Link: https://github.com/Joker666/microservice-demo/ 18. An Interview with the Creator of JSON Douglas Crockford We had a nice chat with Douglas Crockford, a well-known American computer programmer who was involved in the development of the JavaScript language. 19. JSON Web Token: How To Secure Your Data With JWT A JSON Web Token (JWT) is an open standard (RFC 7519) that defines a way for securely transferring information between two parties. It can be used for an authentication system. As this information is digitally signed, it can be verified and trusted. 20. 8 Tips for Solving The JSON RPC Error In Metamask The most problem users come across is the internal JSON RPC error in Metamask. After a detailed search, I found there are numerous different solutions to it. 21. Hybrid Data Models: How To Have Your JSON Cake and Eat MariaDB Too By adding support for JSON, MariaDB provides the ultimate schema flexibility without sacrificing transactions or data integrity. 22. How To Do Data Mapping in Kumologica Data mapping is a key element in integration. Most of the prominent integration tools provide different capabilities for data mapping. In this article I thought of sharing on how data mapping can be achieved in Kumologica. Kumologica uses JSONata as the base for data mapping. JSONata is a Lightweight query and transformation language for JSON data. It supports complex queries expression which can be achieved with minimal syntax and has a location path semantics of Xpath 3.1. 23. How to Encode and Decode JSON with Scala-Circe Getting started with encoding and decoding JSON using Scala-Circe. 24. When Json Serializations Go Horribly Wrong From DateTime serialization issues, to the fact that serializing DateTime.MinValue causes a crash, because UTC time is less than minimal allowed DateTime value. 25. Fetch Data From a JSON File With a React & Redux App This guide explains how to use React and Redux to fetch data from JSON files in an easy and lightweight method through a real example and well explained steps. 26. Parsing JSON in C with Vely framework Parse JSON in C language with Vely framework 27. How to Use Data Science to Find the Best Seat in the Cinema (Part I) From the most popular seats to the most popular viewing times, we wanted to find out more about the movie trends in Singapore . So we created PopcornData — a website to get a glimpse of Singapore’s Movie trends — by scraping data, finding interesting insights, and visualizing them. 28. How To Query JSON in Couchbase via Collections and Scopes This week I’m attending the 3-day Couchbase Connect event and will be reporting on some of the topics that I find most interesting. 29. Extracting Information From Hash in Ruby on Rails When I was recently working in one of the client project, I had to communicate with external mariadb server to store records from react/rails app, that means I would get activerecord hash from our app which I had to convert to pure sql query and send it to external server for storing. If you have worked with sql queries previously then you must know that keys and values must be separated for insert operations like 30. Logging Vs. Monitoring: Best Practices for Logging [Part 2] Logging and Monitoring… this I tell you, brother. You can't have one without the other. 31. The Best Java Libraries that Every Developer Should Know This article describes Java libraries like Apache Commons, Guava, Log4j2, Logback, SLF4J, JUnit, TestNG, Mockito, Hamcrest, AssertJ, Jackson, Gson, JAXB, StAX 32. A Quick Guide to JSON Web Token [JWT] JSON Web Token (JWT) is an open standard (RFC 7519) for securely transmitting information between parties as JSON objects. 33. Improve Network API Performance For Your Apps Network APIs are everywhere in the modern world. If the data is the lifeblood of modern tech, then APIs are essentially vessels that carry it around distributed 34. Back-end Data and API Prototyping with Faker.js and JSON-Server Introduction 35. How to use Recursion to Traverse JSON Objects and the Filesystem I work primarily on application-level programs, so I tend to not use recursion very often. However, every now and then I need a function that is best solved recursively. It is important to be able to recognize when a problem is best solved recursively, and to be able to write it when the time comes. 36. Breaking Down MSON Template Queries Template Queries are dynamic templates constructed with MongoDB-style operators, which allow you to customize MSON components with less code. 37. Tree - AST Crushes JSON, XML, YAML, TOML, etc XML, JSON, TOML, YAML are bad relative to Tree data format 38. Debugging Gson, Moshi and Jackson JSON Frameworks in Production Parsing is a major source of production failures. Some are easy to track but some are insidious. Here's how you can debug them on the fly! 39. µjson — A minimal JSON parser and transformer in Go µjson is a minimal JSON parser and transformer that works on unstructured (and trusted) JSON. It works by parsing input and calling the given callback function when encountering each item. 40. Build Data-Driven Web App Without Backend During the last couple of decades websites' functionally has increased dramatically - from simple landing pages serving simple static ads to complex progressive web apps whose functionality close to native applications including user authorization, location tracking, bluetooth handling, and offline mode. 41. Using JSON Mapping to Work with APIs of Various Image Services Using JSON Mapping to Work with APIs of Various Image Services. This approach is applicable to any other services that are similar in type of returned results. 42. Coding 101: Who is Json? A.) Jason Voorhees (Friday the 13th) 43. Five Important Tips For Working With JWTs Nowadays, JSON Web Tokens are the most common way of proving identity information to APIs. The concepts behind JWTs are also quite easy to understand, and it takes only a couple of minutes to have the most basic authentication running. 44. Using Rainforest API With WordPress [A How-To Guide] Rainforest API is an alternative to the Amazon Product API provided to Amazon Associates. If you are thiking of building shopping comparisson sites with Amazon links and you don’t have an API key, or if you want to build a lot of pages very quickly without limitation, using Rainforest API is the answer. If you are serious about earning money as an Amazon Affiliate and want to make thousands of pages, do yourself a favor and start the project off right. 45. Writing Your First REST API: A How-to Guide As part of my Borum Jot project, I made a Web API for all my front-end platforms to create, retrieve, update, and delete (CRUD) data on the database. In this article, I'll discuss what exactly an API is and how I made my own Web API. 46. Today I Learned: Dealing with JSON DateTime when Unmarshal in Golang. Beware the date-time standard!! 47. What is SQL? And Where is it Used? What is SQL? Databases use it, query APIs use it, even energetic big data dashboards use it! Where did it come from and how are developers, DBAs, and app using. 48. Introducing Jdict Module in Python Providing attribute access to Python dictionary entries 49. 8 Most Popular Weather APIs for 2020 The climate is a hot issue and weather forecasting technology is suddenly cool. The urgent need for innovative weather and environmental conditions forecasting solutions is obvious whether you believe in climate change or not. 50. How to Win the Velo Writing Contest: A Detailed Cheat Sheet In order to display a non-static website - you'll need to have a data source and connect it with Velo. For example, you can create some sort of "fake API". 51. 3 Best Ways To Import JSON To Google Sheets [Ultimate Guide] 3 ways to pull JSON data into a Google Spreadsheet 52. How To Create a Simple Autocomplete Field And Connect it With Elasticsearch Autocomplete is a feature to predict the rest of a word a user is typing. It is an important feature to implement that can improve the user’s experience of your product. 53. How I'm Engineering a Versioned Database Storage Engine for Byte-Addressable NVM Feel free to contribute on GitHub 💚 54. JSON Web Auth Using Angular 8 and NodeJS The article is about interfacing an Angular 8 Project with a secure backend API. The Backend will be running on Node.JS. The security that will underlay the interfacing will be JSON Web Tokens. 55. Go: Handling JSON in MySQL 56. Querying Complex JSON Objects With SQL How many times have you run into a situation where you wish you could do a SQL join without getting duplicate rows back? What if we could get a list "column" returned instead? HarperDB’s ARRAY() function enables just that. In this post we’re going to take a look at a basic example of people with addresses and phone numbers. 57. Document Databases vs Relational Databases (Podcast Transcript) Amy Tom talks to Eric Bishard and Arun Vijayaraghavan about the differences between a Document Database and a Relational Database. Thank you for checking out the 57 most read stories about Json on HackerNoon. to find the most read stories about any technology. Visit the /Learn Repo

57 Stories To Learn About Json

In we have essentially three ways of making unrelated components communicate with each other: Vue Js Vuex Pinia Event Bus On the , we can read: official documentation In most circumstances, using a global event bus for communicating between components is discouraged. While it is often the simplest solution in the short term, it almost invariably proves to be a maintenance headache in the long term. So generally in the long run it is better to use Vuex. Also in the official documentation, you can see how the Event Bus implementation has changed from Vue 2 to Vue 3. Scaffolding the project In this tutorial, we will use the Vite build tool to scaffold the project. # npm 6.x
npm init vite@latest vue-event-bus-1 --template vue

# npm 7+, extra double-dash is needed:
npm init vite@latest vue-event-bus-1 -- --template vue Then we need to install an external library implementing the event emitter interface, in this case, . mitt npm install --save mitt The Project The project consists of two simple components, and when we click on the emit event button in String to change in  FirstComponent.vue becomes String changed thanks to the Event Bus FirstComponent.vue, SecondComponent.vue SecondComponent.vue The Code In main.js  we create an instance of mitt which is used globally import { ***createApp ***} from 'vue'
import mitt from 'mitt'
import App from './App.vue'


const emitter = mitt()
const app = ***createApp***(App)

app.config.globalProperties.emitter = emitter
app.mount('#app') Now we can access the emitter globally, so in we subscribe to the event emitted by FirstComponent.vue SecondComponent.vue. Let’s take a look at FirstComponent.vue <script>
export default {
  data: function () {
    return {
      testEvent: 'String to change'
    }
  },
  created (){
    this.emitter.on('my-event', (evt) => {
      this.testEvent = evt.eventContent;
    })
  }
}
</script> Now in SecondComponent.vue, let’s emit the event. <template>
    <div style="border: 1px solid black;">
        <h1>Second Component</h1>
        <button v-on:click="emitMyEvent">Emit Event</button>
    </div>
</template>

<script>
    export default {
        methods: {
          emitMyEvent() {
              this.emitter.emit('my-event', {'eventContent': 'String changed'})
          }
        }
    }
</script> You can find the code of this tutorial on github: https://github.com/CertosinoLab/mediumarticles/tree/vue-event-bus-1 Thank you for reading Also published here. Lead image by on Unsplash robin inizan

How to Use an Event Bus in Vue.js 3 

In a we looked at how to add chat to an Amazon Interactive Video Service (Amazon IVS) live stream. Chat rooms are a huge part of creating interactive live streaming experiences, but unfortunately they come with the inevitable possibility that some users may post messages that are insensitive or otherwise offensive. In this post, I'll show you a very simple, but effective way to moderate your Amazon IVS chat rooms to keep things fun and friendly. recent post Introducing Chat Moderation Review Handlers There are two ways to address chat moderation: manual and automated. The manual method, which we'll cover in a future post, requires a moderator (the broadcaster or another designated user) to 'flag' a chat message for removal via one of the Amazon IVS Chat SDKs . Flagging a message sends an event to all connected WebSocket clients that can be used to update or remove the offending message. The automated method, which we'll cover in this post, lets us utilize an AWS Lambda function to perform substitutions on the chat message or reject the delivery based on the business needs of the application. docs There are both pros and cons to both manual and automated moderation. One "pro" to manual moderation is that since it requires human intervention, you're less likely to have "false positives" that are possible with automated moderation. Another positive of manual intervention is that humans are generally better than machines at identifying messages that should be moderated. However, a "con" of manual moderation is that messages can only be removed they have been posted to a chat room room. And as the saying goes, "you can't put the toothpaste back in the tube". In other words, potentially offensive messages have already been viewed by your users - you can't make them "unsee" a message they may have already seen. after On the other hand, automated moderation gives us the ability to reject (or censor) harmful messages before they get posted to a chat room. But, as mentioned above, it's really difficult for chat messages to be properly moderated by a machine with a great deal of accuracy. Have you ever been in a chat room or posted a comment to a blog post that is purely innocent and had it rejected or censored incorrectly? It can be very frustrating for a chat user who submits a message saying "This person would be a real asset to our team" only to see "This person would be a real ***et to our team" posted to the chat room (or simply rejected)! With that said, the best approach for chat moderation is an individual decision for your application based on your intended audience and business needs. I suspect that many applications that require moderation would ultimately utilize a combination of manual and automated moderation. Now that we've talked about both possible approaches, let's dig into how you can use an AWS Lambda function to perform automated moderation for your Amazon IVS chat room. Adding a Message Review Handler When creating (or updating) an Amazon IVS chat room via the Amazon IVS console, AWS CLI, or one of the Amazon IVS SDKs, we can specify an AWS Lambda function that will serve as our message review handler. In this post, we'll focus on using the Amazon IVS console, but you can refer to the appropriate documentation if you'd like to use another method. To add a handler, scroll down to the* Message review handler* section while creating or editing an Amazon IVS chat room. By default, the 'Disabled' option will be selected. Let's change this by selecting . Handle with AWS Lambda This presents us with a few more options. The first option, lets us choose how we want to handle invalid responses, errors, and timeouts from our handler function. Again, this depends on your business needs. If you would rather reject messages in this case, select . If you choose , potentially harmful messages may be posted to your chat room. This is where a combination approach could provide you with a 'backup plan' so that a moderator could still remove messages that are missed by the handler for whatever reason. For this demo, I'll choose . Next, we'll need to specify the AWS Lambda function that will act as our handler. We'll create a new function via the console for this demo, so let's click on . Fallback result Deny Allow Allow Create Lambda function Clicking on this button will take us to the list of our current functions. On this page, click . Create function On the next page, enter the name ivs-chat-moderation-function, leave the defaults selected for the rest of the options, and then click . Create function Now let's update the code for our function. The tells us that the function will receive an event object in the following format: documentation {
  "Content": "string",
  "MessageId": "string",
  "RoomArn": "string",
  "Attributes": {"string": "string"},
  "Sender": {
    "Attributes": { "string": "string" },
    "UserId": "string",
    "Ip": "string"
  }
} In order to return a value from our function using Node, we must use an async function (see the for more info). The object that we return must use the following format: AWS Lambda documentation {
 "Content": "string",
 "ReviewResult": "string",
 "Attributes": {"string": "string"},
} The value that we set for ReviewResult must be or and will determine whether or not the message is delivered to the chat room. We can modify the message Content as necessary, meaning we can remove or replace potentially offensive or insensitive content and the message to be posted. Any additional attributes can be passed with . If you choose to send a of , you can pass a attribute which will be used to return a response to the client including the value specified as the . ALLOW DENY ALLOW Attributes ReviewResult DENY Reason 406 Not Acceptable Reason Refer to the for further information including length constraints and valid values. Chat Message Review Handler documentation Now we can modify the code of the function to replace a 'bad word' in the incoming content with asterisks. exports.handler = async (event) => {
  return {
    ReviewResult: 'ALLOW',
    Content: event.Content.replace(/bad word/ig, '*** ****'),
    Attributes: {
      username: event.Attributes.username
    }
  };
}; Let's head back to our chat room, refresh the list of functions, select our new function and click . Save changes Now we can post a message to our chat room and see what happens. Excellent! Our chat message handler was properly invoked and our 'bad word' was removed before it was posted to the chat room. In reality, you'd want to use a much more sophisticated solution for replacing harmful text than the simple regex that I'm using above. I've tested the library and found it to do a great job of censoring and identifying profane words in an incoming message. Feel free to use whatever solution works for you, but keep in mind that your function must return a response within 200ms or it will timeout, so third-party API calls may be out of the question. @2toad/profanity Here's an example of a handler that uses the library to censor harmful words: @2toad/profanity exports.censorChat = async (event) => {
  console.log('censorChat:', JSON.stringify(event, null, 2));
  return {
    ReviewResult: 'ALLOW',
    Content: profanity.censor(event.Content),
    Attributes: {
      username: event.Attributes.username
    }
  };
}; And an example of rejecting a message instead of censoring. exports.rejectInappropriateChat = async (event) => {
  console.log('rejectInappropriateChat:', JSON.stringify(event, null, 2));
  const profane = profanity.exists(event.Content);
  return {
    ReviewResult: profane ? 'DENY' : 'ALLOW',
    Content: profane ? '' : event.Content,
    Attributes: {
      username: event.Attributes.username
    }
  };
}; Summary In this post we learned about two different approaches to moderate chat messages: manual and automated. We then created an AWS Lambda function and associated it with an Amazon IVS chat room to perform automated chat moderation. In a future post, we'll look at how you can use the Amazon IVS Chat SDK to manually moderate chat messages. If you have any questions, leave a comment or reach out to me on . Twitter

Using an AWS Lambda Function to Moderate Amazon IVS Chat Messages

Uso de una función de AWS Lambda para moderar los mensajes de chat de Amazon IVS

Utilisation d'une fonction AWS Lambda pour modérer les messages de chat Amazon IVS

Amazon IVS चैट संदेशों को मॉडरेट करने के लिए AWS लैम्ब्डा फ़ंक्शन का उपयोग करना

AWS Lambda 関数を使用して Amazon IVS チャット メッセージをモデレートする

Usando uma função do AWS Lambda para moderar mensagens de bate-papo do Amazon IVS

Sử dụng hàm AWS Lambda để kiểm duyệt tin nhắn trò chuyện Amazon IVS

使用 AWS Lambda 函数调节 Amazon IVS 聊天消息

This post looks at how you could integrate your GitHub repo with Google Sheets in Ballerina, so that every time a particular event occurs in your GitHub repo, you would have it documented in a Google Sheet of your own. How cool is that! Be it an issue created under a label, a PR opened or even a commit to the repository, you could have it all recorded in a Google Sheet with Ballerina in a few simple steps. End goal The end goal would be to populate a Google sheet as below, on the fly as Github events are triggered! The source code of this project can be accessed on GitHub through link! this What is Ballerina? Ballerina is an open-source programming language for the cloud that makes it easier to use, combine, and create network services. For someone new to Ballerina, refer to for steps about getting started. In order to continue, you need to have Ballerina installed. Follow these steps for the installation. ballerina.io The following implementation uses the Swan Lake version of Ballerina. : Configure a GitHub webhook to listen to events Part 1 Initially, you need to expose the subscriber service in your local machine for the server to be able to access the URL. Therefore, we will use which allows exposing a web server running on your local machine to the internet. ngrok Step 1: Once you have ngrok, all you have to do is to run the following command to tell ngrok what port your web server is listening on. installed In our case, it is port 9090. ngrok http -bind-tls=true 9090 Once you have ngrok up and running, it'll look like this: We will be using the ngrok URL highlighted above, as the callback URL of the subscriber service. In our case it is, https://b3e0–112–134–171–11.ngrok.io Step 2: Next, we will register a GitHub webhook for the repository where we want to receive notifications. On the repository homepage, navigate to -> -> Settings Webhooks Add webhook Set the Payload URL to be the ngrok callback URL followed by the service path name of the ballerina service. In our case it is, https://b3e0–112–134–171–11.ngrok.io/events Set the Content type to and click on . application/json Add webhook Next, you should create a , which will be used as an alternative to using passwords for authentication to GitHub when using the GitHub API. Personal Access Token Login to your Github account and go to . Under click on , which will take you to an interface as below. https://github.com/settings/tokens Personal Access Tokens Generate new token For your new PAT, set an expiry date as you wish, and then select the scopes to specify exactly what type of access you need. For this application, we will select the scopes of and generate the token. Once created, make sure to copy your PAT since you won’t be able to see it again. repo, write:packages, admin:repo_hook, notifications, Now we write our code in Ballerina! First, create a ballerina project by running the following code in your terminal. We’ll call our project . gsheet_github_integration tharushijayasekara@Tharushi Test % bal new gsheet_github_integration
Created new package 'gsheet_github_integration' at gsheet_webhook_integration. This creates a project with a which contains our main method and a which includes the configurations of our project. Add the following code into the . main.bal Ballerina.toml main.bal import ballerina/websub;
import ballerina/io;

// Create a subscriber service to listen to Github events
@websub:SubscriberServiceConfig {
    target: [
        "https://api.github.com/hub", 
        // Set the path to your Github repository
        "https://github.com/TharushiJay/helloworld/events/*.json" 
    ],
    // Set the ngrok callback URL 
    callback: "https://6671-2402-d000-811c-7b4a-18dd-31bd-21f7-f9b2.ngrok.io", 
    httpConfig: {
        auth: {
            // Set your GitHub Personal Access Token (PAT)
            token: "ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" 
        }
    }
}

service /events on new websub:Listener(9090) {
    remote function onEventNotification(websub:ContentDistributionMessage event) 
                                                                returns error? {

        var retrievedContent = event.content;

        if (retrievedContent is json) {
            if (retrievedContent.action is string){

                Details details = { number: check retrievedContent.issue.number,
                                    action: check retrievedContent.action,
                                    url: check retrievedContent.issue.url,
                                    title: check retrievedContent.issue.title,
                                    time: check retrievedContent.issue.updated_at,
                                    user: check retrievedContent.sender.login };

                if (retrievedContent.issue is json) {

                    // If the event is related to an Issue
                    details.sheet = "Issue";
                    error? response = insertDetails(details);

                } else if (retrievedContent.pull_request is json) {
                    
                    // If the event is related to a Pull Request
                    details.sheet = "PR";
                    error? response = insertDetails(details);
                }
            }
        } else {
            io:println("Unrecognized content type");
        }
    }
} If we look at the code in detail, what we’ve done is create a to listen to the Github events, by setting the path to the repo, ngrok callback URL as well as the GitHub PAT that we just created for authentication. subscriber service The subscriber service is created using WebSub Subscriber Service. is a common mechanism based on HTTP webhooks to communicate between publishers of Web content and their subscribers. Validating and verifying subscription requests as well as distributing new content as it becomes available is done through hubs. More details on how to make the best use of the websub module can be found on Ballerina API docs . WebSub here Then each time an event notification is sent, we populate the data we need into a record of type After setting the event type as or , we pass the record into to document the event details on a Google sheet depending on the event type. Details. Issue PR insertDetails() Part 2: Integrating Google Sheets API For the next part of the implementation, we will create a Google Sheet called with 2 sheets to document details and details. Let’s note down the sheet ID, which is the below-highlighted part on the URL. GitHub Changes PR Issue Next, create another file in the same project called to access the Google Sheets API, and insert the following code. gsheet.bal import ballerinax/googleapis.sheets as sheets;

configurable string refreshToken = "1//04xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
configurable string clientId = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.apps.googleusercontent.com";
configurable string clientSecret = "GOCSPX-xxxxxxxxxxxxxxxxxxxxxxxxxxxxx";

// Configuring Google Sheets API
sheets:ConnectionConfig spreadsheetConfig = {
    auth: {
        clientId: clientId,
        clientSecret: clientSecret,
        refreshUrl: sheets:REFRESH_URL,
        refreshToken: refreshToken
    }
};

// A record to store PR/issue related data
public type Details record {
    int number;
    string action;
    string url;
    string title;
    string time;
    string user;
    string sheet?;
};

sheets:Client spreadsheetClient = check new (spreadsheetConfig);
string spreadsheetId = "1l4KUKQ0e5HKB35doSRcaF3QgNYvBAp99q_l5GS3J1B8";

public function insertDetails(Details details) returns error? {

    error? append = check spreadsheetClient->appendRowToSheet(spreadsheetId, details.sheet.toString(), 
    [details.number, details.action, details.url, details.title, details.time, details.user]);

} What we’ve done here is as simple as it looks. Simply calling the Google Sheets API to append the new row of data to our Google Sheet. The next task is figuring out the , , and used in the above code. refreshToken clientId clientSecret Open the page, log in to your relevant Google Account and create a new project. Google API Console Credentials 2. Give the project a name and click . Create 3. Click on to choose how you want to configure and register your app. Configure Consent Screen 4. Set the user type as and click . external Create 5. In the OAuth consent screen, enter an , , and and click on . app name User support email Developer contact information Save and Continue 6. In the screen, click and proceed to the next screen which is Test users. Scopes Save and continue 7. Under , add your email address and click . Test users Save and continue 8. Finally you will be presented with a summary to verify the details you entered. 9. As the next step, under click and click . Credentials Create credentials OAuth client ID 10. Enter the following details in the Create OAuth client ID screen and click Create. 11. This will generate a and that you should save for future use! Client ID Client Secret 12. From the left side menu, select search for and click on it to it. Library, Google Sheets API Enable 13. In order to obtain the refresh token, navigate to and click the OAuth 2.0 Configuration button in the top right corner of your screen. OAuth 2.0 Playground 14. Select , provide the obtained Client ID and Client Secret values and the window. Use your own OAuth credentials Close 15. Under Step 1, select from the list of APIs and select all the scopes. Google Sheets API v4 16. Click on button and select your Gmail account when you are asked and allow the scopes. Authorize APIs 17. Under Step 2, click the to generate and display the Access Token and Refresh Token. Exchange authorization code for tokens That brings us to the end of configuring the Google Sheets API! Use the refresh token, client ID, and client secret in our file and run the project using gsheet.bal bal run. The output would be as follows, which means that the service successfully started in port 9090. tharushijayasekara@Tharushi github-gsheet-integration % bal run
Compiling source
        tharushijayasekara/github_gsheet_integration:0.1.0
WARNING [gsheet.bal:(31:5,32:95)] unused variable 'append'
WARNING [gsheet.bal:(47:5,48:95)] unused variable 'append'
WARNING [main.bal:(17:5,17:5)] concurrent calls will not be made to this method since the method is not an 'isolated' method
WARNING [main.bal:(24:21,29:84)] unused variable 'issueResponse'
WARNING [main.bal:(33:21,38:95)] unused variable 'pullRequestResponse'

Running executable

time = 2022-04-10T22:18:14.755+05:30 level = WARN module = ballerina/websub message = "HTTPS is recommended but using HTTP" You will see the changes documented on our Google Sheet! Now, you have successfully configured a webhook for GitHub and received the events using a subscriber written in the Ballerina programming language! Thanks for following through to the end. To keep up-to-date on more interesting developments in Ballerina, visit . https://ballerina.io/

How to Integrate a GitHub Repo With Google Sheets Using Ballerina

Access User Location with Permission Handler in Flutter

Firebase Authentication with Email and Password in Flutter

COVID-19, we can all agree, that it has been arguably one of the hardest and most bizarre moments in our lives. Isolation at home, finding a balance between work and life, and a foggy, uncertain future. For me as a student, the messes of online learning, the abundance of fast-approaching deadlines, and a lack of motivation have made this period a time of chaos and confusion. When our class schedule for the next school year released a few months into the pandemic—with the hopeful anticipation that the pandemic would be over; alas, it was not—my social media was flooded with friends posting their schedules and asking who shared classes with them. As I responded to each person, comparing my classes with theirs to see which I share, I imagined the multitude of messages the recipient will get from everyone responding, let alone the extra efforts of keeping track of who’s in which class. The process just did not seem efficient, and so I thought to myself, “can I make something to simplify this process and make it easier for everyone?” My first instinct was to create a website; I have been interested in web development ever since I created my first website on Wix for a school project. This was the perfect opportunity for me to use whatever skills I had, on a powerful platform, to make something easier for my school community. From there, the project took off. I wanted to point out that this article will be focused more around my creation process. I had lots of help from the Velo forums (they’re great, check it out!), but if there is interest, I can try writing a more concise step-by-step guide. Method I knew straight away that this project will involve much more than just design, so I started looking into by Wix. Although I haven’t used it before, the custom code functionality Velo offers seemed suitable for my project, and so I began exploring how to use Wix and Velo together for this project. I came up with this following outline: Velo One of the requirements for this project was that . I didn’t want anyone being able to piggyback on other people’s contributions without contributing themselves. Member Restrictions: only people who contribute their schedule could view other people’s schedules This meant that I would have to create a custom to prevent anyone from signing up themselves, but also that I would need to create accounts for members manually. I don’t mind the extra labour, but this is something that I can improve on (see ). Velo login page Final Thoughts A typical flow for someone who has contributed their schedule begins on the page, then once they , would either reach the page or the page. Member Workflow: Home login Schedules My Schedules This will be where the bulk of Velo functionality comes into play. For each block of the school day, I will have a dropdown populated from a database where students can choose a class to view, which would auto-update the classmates through Velo. For the My Schedule page, the student’s classes will be already filled with their classmates. Schedule and My Schedule page: I’ll touch on each of these pages in this story, but feel free to explore and follow along with this demo website I made: . https://ericssites.wixsite.com/demo The Pages Home Page Two things I really love about Wix: the plethora of templates to choose from, and the drag-and-drop Editor. For me, I really have to see an idea in front of me in order to believe it, and the Editor enables me to do just that. I began by going through some of the pre-made templates and ended up choosing this theme: the large hero strip alongside the bold, clean font stood out to me, and from there I started to add my own touch to it. Fitness Trainer The hero strip consists of two call-to-action buttons, one to login and one that directs the user to the section. Directly underneath the hero is the section, alongside some statistics of the website. The and sections follow. Contribute About Contribute Contact The home page is where the bulk of my website design comes into play. With inspiration from design ideas online, I shaped my thoughts into reality using Wix. I went for a minimal and clean design, with each section separated by large headers. Wix made it really easy for me to make pixel-perfect edits with the drag-and-drop editor and easy customization; with my minimal web development knowledge I would never have dreamed of creating anything like this! Login Page Design-wise, the login page is quite simple: I used a lightbox that would overlay on top of the home page. This is the first area where Velo is present: it is used to send backend requests for logging in, applying the user token, and verifying the reCAPTCHA. How to implement this was all foreign to me at first, but the Velo API Reference Guide and some tutorials online (like and ) really helped me out! this one from Wix this one from Code Queen Schedules and My Schedules Page Here comes the fun stuff: the actual presentation of the schedules! The end goal was to enable the user to select a course from a dropdown to see the students in that class. Even before hopping into the design, I started exploring linking the Velo API with Wix databases to ensure that they work for my needs. After some ups and downs and lots of experimentation, I was able to work with multi-reference fields to link a class name with its block and its students, and use this structure to communicate with the Velo API. Although I had difficulties throughout, such as getting the dropdown to work or , I had lots of help from the Velo Forums that kept me going. finding a way to query multi-reference fields Although I won’t link my entire code because of how messy it is (I need to work on my effective programming skills 😅), let me walk you through what the main portion does. We start with a , which pulls data from the to create a for each block scheduled in the school year. repeater Blocks database repeater item Each then pulls data from the filtering only for classes during its period (i.e. the Block 1 item takes courses with a Block 1 tag, and so forth). This gets populated into a dropdown. repeater item Courses database, When a dropdown is changed by the user, an event handler fires. export function courseDropdown_change(event) {
    let $item = $w.at(event.context); // Determine which dropdown was clicked
    let selectedCourse = $item("#courseDropdown").value; // grab the value of the dropdown (the course selected)
    let selectedBlock = $item("#Blocks").getCurrentItem(); // then grab the current block from the item selected
    let selectedBlockID = selectedBlock["_id"]; // keep only ID It starts by storing the course name from the dropdown and the block selected from the event caller. let queryForID = wixData.query("Courses") // query the Courses database
        .eq("courseName", selectedCourse) // for the course name
        .eq("blocks", selectedBlockID) // and the block of the course
        .find()
        .then((resultsID) => {
            let courseID = resultsID.items[0]._id // set courseID to the ID of the course found from the query Then the code queries the Courses database through to get the ID of the course. This is required in the next step, albeit a little bit messy. queryReferenced() wixData.queryReferenced("Courses", courseID, "students") // Query the courses database for the ID and return the students column Once the course ID is retrieved, another is called to retrieve all the students from the Courses database. Although allows us to get values from multi-reference columns (which we need to get the students), it requires an ID to query first (which we got from the previous step) queryReferenced() queryReferenced() .then((results) => {
                    let studentsCombined = results.items.map(_ => _.title) // map all the values but keep only title (name)
                    studentsCombined = studentsCombined.map(title => title.replace(" ", " "))  // do some cleanup
                    studentsCombined = studentsCombined.sort().join(', ') 
                    $item("#classmatesText").text = studentsCombined; // Modify text to the students
                })
        });
} The resulting data is cleaned up, keeping only the names of each student from the result and joining names with commas. Then, a text object is updated with the result, and the classmates are shown! A loader GIF appears while this process happens so the user knows something is happening. A similar process is present for the page, except the dropdowns are replaced by text objects and an additional filter is applied so that only the current member’s courses show up. The member’s classmates also automatically update once the databases load. My Schedules Final Thoughts on Wix and Velo This was not the first time that I used Wix; I have used it a few times for some school projects. However, every time I decide to create a website, I always come back to Wix: the drag-and-drop editor, the plethora of designs and addable objects, and the no-thought hosting make it so easy for me to choose Wix over other tools. For this project, I have also come to appreciate the cleanliness of the database editor as well as the versatility and functionality brought by Velo. I have however, come across a few hiccups when using Wix, primarily regarding speed. The Editor would sometimes be slow or unresponsive (even on a blank canvas), and sometimes I would lose changes or had trouble making changes due the Editor being unresponsive. Though, throughout building the website there have been some noticeable speed improvements by Wix; and Editor X, the new product by Wix, has felt very responsive when I tried it out. For someone wanting to quickly create a website or web app, or someone who needs to see something to believe it, I strongly suggest Wix! There’s always room for improvement I admit, when I was creating this website, I was often looking for the quickest way out of problems. Although I understood the code I was writing, I often made quick compromises, leaving lots of room to make the code more efficient or to remove unnecessary steps. Restructuring the databases might enable me to speed up load times for the website. Having a dynamic database connected to Wix from the form where I collect responses, instead of having to manually parse through my classmates’ schedules, would help reduce the amount of manual labour I have to do. Nonetheless, I’m really happy that I have a working site that gets the job done, and these improvements are things I can note in future projects! And that’s it! Thank you Wix and Velo for allowing me to make my ideas into reality, and thank you HackerNoon for this amazing opportunity to share my story. I’d also like to thank my friends also for supporting me through this journey, and you especially for reading my story. Maybe the pandemic wasn’t all bad. This article is part of a writing contest hosted by Hacker Noon in partnership with Wix. Learn how to and take a shot at winning $2000. enter here

Building a Website to View Classmates: My Journey with Wix and Velo

Using LiveData in Coinverse pc — Ned Scher , Waterfall at Yosemite National Park (2015) Code in the wild is always better to learn from than slide samples. Here I’ll be sharing code from Coinverse’s Open App to showcase a live Unidirectional Data Flow (UDF) pattern which makes the app more readable, easier to develop for, and debug. The previous post, , outlines the strategy for loading a newsfeed and removing adjacent ads using UDF. This post shares both a basic live example, and a more complex structure to return multiple processes in one method using . Android Unidirectional Data Flow with LiveData MediatorLiveData By downloading the , you can run the code to explore, listen on-the-go, and watch the newsfeed of audiocast and video content. For access to features requiring authentication such as saving and dismissing content, you’ll need to implement the to set up a Firebase project outlined in . GitHub project 5 easy-ish steps Coinverse Open App — Set Up pc—My Mom’s Kenya safari (1980s) Brief UDF OverviewView Events, State, and Effects — Actions created by the user that effect the data displayed, or system level events like the app starting or stopping Events — Info that displays or helps determine a view, created in the business layer of logic State — One time user interface occurrences like navigation, dialogs, and toasts created by the business layer of logic Effects LiveData provides a simple, Android lifecycle aware, toolset to handle automatically updating data for events. LiveData Loading, Content, Error Network Requests Network requests returned with states wrapped in LiveData objects ensure that the ViewModel business logic layer accounts for the loading, successful content loaded, and error states. LCE { () ( packet: T) : Lce<T>() ( packet: T) : Lce<T>()
} sealed < > class Lce T < > : < > class Loading T Lce T data < > class Content T val data < > class Error T val View Event, State, and Effect — ContentSelected ContentSelected view event In this first case when video content is selected in the Adapter it triggers a view event in the The event is processed in the . ContentSelected ContentFragment.kt. ContentViewModel.kt (...): PagedListAdapter<Content, ContentAdapter.ViewHolder>(DIFF_CALLBACK) { contentSelected: LiveData<Event<ContentSelected>> () = _contentSelected _contentSelected = MutableLiveData<Event<ContentSelected>>() = OnClickListener { view -> (view.id) {
            preview, contentTypeLogo -> _contentSelected.value =
                    Event(ContentSelected(view.getTag(ADAPTER_POSITION_KEY) , content))
        }
    }
} class ContentAdapter val get private val private fun createOnClickListener (content: ) Content when as Int () { viewEvent: LiveData<Event<ContentViewEvent>> () = _viewEvent _viewEvent = MutableLiveData<Event<ContentViewEvent>>() {
        adapter = ContentAdapter(contentViewModel, _viewEvent).apply { .contentSelected.observe(viewLifecycleOwner, EventObserver { contentSelected ->
                _viewEvent.value = Event(ContentSelected(
                        getAdapterPosition(contentSelected.position), contentSelected.content))
            })
        } { .onResume()
        viewEvent.observe(viewLifecycleOwner, EventObserver { event ->
            contentViewModel.processEvent(event)
        })
    } : class ContentFragment Fragment private val get private val private fun initAdapters () this override fun onResume () super Because the is a video, the ViewModel updates the LiveData value of the view state with the object containing a video url. contentType contentToPlay FeedViewState ContentToPlay (application: Application) : AndroidViewModel(application) { { (event) { ContentViewEvent.ContentSelected -> { contentSelected = ContentViewEvent.ContentSelected(event.position, event.content) (contentSelected.content.contentType) {
                    YOUTUBE -> {
                        setContentLoadingStatus(contentSelected.content.id, View.GONE)
                        _viewEffect.value = Event(NotifyItemChanged(contentSelected.position))
                        _feedViewState.value = _feedViewState.value?.copy(contentToPlay =
                        MutableLiveData<Event<ContentResult.ContentToPlay>>().apply { .value = Event(ContentResult.ContentToPlay(
                                    contentSelected.position, contentSelected.content, , ))
                        })
                    }
                }
            }
        }
    }
} class ContentViewModel fun processEvent (event: ) ContentViewEvent when is val when this "" "" ( contentToPlay: LiveData<Event<ContentResult.ContentToPlay>>, ...) data class FeedViewState val ( position: , content: Content, filePath: String?, errorMessage: String) : Parcelable {...} data class ContentToPlay var Int var var val The Fragment observes the value change, and launches the Fragment to play the video. FeedViewState contentToPlay () { {
        contentViewModel.feedViewState.observe(viewLifecycleOwner, Observer { viewState ->
            viewState.contentToPlay.observe(viewLifecycleOwner, EventObserver { contentToPlay -> (feedType) {
                    MAIN, DISMISSED -> (childFragmentManager.findFragmentByTag(CONTENT_DIALOG_FRAGMENT_TAG) == )
                            ContentDialogFragment().newInstance(Bundle().apply {
                                putParcelable(CONTENT_TO_PLAY_KEY, contentToPlay)
                            }).show(childFragmentManager, CONTENT_DIALOG_FRAGMENT_TAG)
                }
            })
        })
    }
} : class ContentFragment Fragment private fun observeViewState () when if null In addition to the view state being updated in the ViewModel above, a view effect, is added and observed in the Fragment to update the RecyclerView cell that has been selected. NotifyItemChanged () { {
        contentViewModel.viewEffect.observe(viewLifecycleOwner, EventObserver { effect -> (effect) { ContentViewEffect.NotifyItemChanged -> adapter.notifyItemChanged(effect.position)
            }
        })
    }
} : class ContentFragment Fragment private fun observeViewEffects () when is MediatorLiveData — PlayerLoad PlayerLoad view event In the first case the event is straightforward because there is a view event and one piece of data, the object, returned in the view state. The event created from the , that retrieves the required information to play an audiocast, is more complicated because it requires two network requests. ContentSelected ContentToPlay PlayerLoad AudioFragment.kt () { viewEvent: LiveData<Event<ContentViewEvent>> () = _viewEvent _viewEvent = MutableLiveData<Event<ContentViewEvent>>() {
        ...
        contentToPlay = arguments!!.getParcelable(CONTENT_TO_PLAY_KEY)!! (savedInstanceState == )
            _viewEvent.value = Event(ContentViewEvent.PlayerLoad(
                    contentToPlay.content.id, contentToPlay.filePath!!,
                    contentToPlay.content.previewImage))
    }
} : class AudioFragment Fragment private val get private val override fun onCreate (savedInstanceState: ?) Bundle if null (application: Application) : AndroidViewModel(application) { playerViewState: LiveData<PlayerViewState> () = _playerViewState _playerViewState = MutableLiveData<PlayerViewState>() { (event) { ContentViewEvent.PlayerLoad ->
                _playerViewState.value = PlayerViewState(getContentPlayer(
                        event.contentId, event.filePath, event.previewImageUrl))
        }
    }
} class ContentViewModel val get private val fun processEvent (event: ) ContentViewEvent when is The returned requires retrieving information from two sources for both the file to play audio, and a converted Bitmap image to display in the notification player. PlayerViewState mp3 ( contentPlayer: LiveData<Event<ContentResult.ContentPlayer>>) data class PlayerViewState val { ( uri: Uri, image: ByteArray, errorMessage: String): ContentResult(), Parcelable {...}
} sealed class ContentResult data class ContentPlayer val val val The ViewModel could achieve getting both pieces of information by making one network request, waiting for it to return successfully, then make the second request. However, this creates more complicated and nested code. In order for the ViewModel to observe LiveData from the network requests it must be observed by the UI layer in the AudioFragment. The first network request must be observed, then within that method, the second request needs to be observed. This creates nested code within the ContentViewModel as well which gets ugly. LCE A Better Solution With MediatorLiveData A better solution is to return one LiveData object that contains both the and image using takes in two LiveData objects, returning the , and returning the image. only returns the LiveData once each LiveData item passed into the method has been populated with info, indicated by an emitted boolean in the code below. mp3 Bitmap MediatorLiveData . combineLiveData getContentUri mp3 bitmapToByteArray Bitmap combineLiveData ContentPlayer (application: Application) : AndroidViewModel(application) { =
            getContentUri(contentId, filePath).combineLiveData(bitmapToByteArray(imageUrl)) { a, b ->
                Event(ContentResult.ContentPlayer(a.peekEvent().uri, b.peekEvent().image,
                        getLiveDataErrors(a, b)
                ))
            } -> T) =
            MediatorLiveData<T>().also { result -> source1emitted = source2emitted = mergeF = { source1Value = .value source2Value = other.value (source1emitted && source2emitted)
                        result.value = onChange.invoke(source1Value!!, source2Value!!)
                }
                result.addSource( ) { source1emitted = ; mergeF.invoke() }
                result.addSource(other) { source2emitted = ; mergeF.invoke() }
            } =
            switchMap(repository.getContentUri(contentId, filePath)) { lce -> (lce) { Lce.Loading -> MutableLiveData() Lce.Content -> MutableLiveData<Event<ContentResult.ContentUri>>().apply {
                        value = Event(ContentResult.ContentUri(lce.packet.uri, ))
                    } Lce.Error -> {
                        Crashlytics.log(Log.ERROR, LOG_TAG, lce.packet.errorMessage)
                        MutableLiveData()
                    }
                }
            } = liveData {
        emitSource(switchMap(repository.bitmapToByteArray(url)) { lce -> (lce) { Lce.Loading -> liveData {} Lce.Content -> liveData {
                    emit(Event(ContentResult.ContentBitmap(lce.packet.image, lce.packet.errorMessage)))
                } Lce.Error -> liveData {
                    Crashlytics.log(Log.WARN, LOG_TAG, )
                }
            }
        })
    } =
            a.peekEvent().errorMessage.apply { ( .isNotEmpty()) }.apply {
                b.peekEvent().errorMessage.also { (it.isNotEmpty()) .plus( + it)
                }
            }
} class ContentViewModel private fun getContentPlayer (contentId: , filePath: , imageUrl: ) String String String /**
     * Sets the value to the result of a function that is called when both `LiveData`s have data
     * or when they receive updates after that.
     */ private LiveData . fun <T, A, B> <A> combineLiveData (other: < >, onChange: ( , B) LiveData B A var false var false val val this val if this true true private fun getContentUri (contentId: , filePath: ) String String when is is "" is private fun bitmapToByteArray (url: ) String when is is is "bitmapToByteArray error or null - " ${lce.packet.errorMessage} private fun getLiveDataErrors (a: < . >, b: < . >) Event ContentResult ContentUri Event ContentResult ContentBitmap if this this if this " " This allows for each of the two methods requiring a network request to handle their LCEs separately, and for one LiveData object to be observed from the in the AudioFragment. ContentPlayer () { contentToPlay: ContentResult.ContentToPlay contentViewModel: ContentViewModel {
        contentViewModel.playerViewState.observe(viewLifecycleOwner, Observer { viewState ->
            viewState?.contentPlayer?.observe(viewLifecycleOwner, EventObserver { contentPlayer -> })
        })
    }
} : class AudioFragment Fragment private lateinit var private lateinit var private fun observeViewState () //Launch audiocast! In addition to the live code I’ve created notes on LiveData and the UDF pattern including documentation notes, videos, and samples. I’m the creator of Coinverse. the app on Google Play, and me for more on Android engineering! Adam Hurwitz, Download follow

Sample App—Android Unidirectional Data Flow

Stories, News & Mentions about EVENTCONNECT

Eventconnect’s Stories on HackerNoon