Secure your customer journeys with Authsignal. Drop flexible authentication flows into your customer journeys today. Deploy passkeys and out-of-the-box passwordless (MFA) authentication in hours. Authsignal is a drop-in authentication platform. Focused on enabling enterprise and mid-market businesses to seamlessly authenticate customer identity, mitigate fraud, and secure customer data. Partnering with modern consumer-focused enterprises, Authsignal enables a flexible and contextual approach to authentication. Underpinned by a powerful no-code-rules engine Product and Fraud teams leverage Authsignal to secure customer flows, reduce customer friction, and mitigate risk and fraud. Built to drop into any identity stack, out-of-the-box integrations via OpenID Connect (OIDC), Microsoft Azure b2c, ForgeRock, and Ping Identity deliver rapid deployment times and significant cost savings. Customer service and fraud teams gain complete observability of their customer journeys with a single view of customer actions and audit trail reporting dashboards. Authsignal’s identity stream delivers a real-time view of actions and behavior. Authsignal enables businesses to easily deploy passwordless authentication, eKYC, biometric authentication, customer journey orchestration, fraud detection, and mitigation powered by a no-code fraud rules engine for rapid policy deployment. Mitigate risk and fraud with a no-code-rules engine and deliver seamless customer experiences with a hosted and fully customizable UI. www.authsignal.com Authsignal makes it easy to protect customer data, deliver seamless customer authentication experiences

Authsignal

authsignal

LONDON, United Kingdom, May 23rd, 2023/Chainwire/--AltSignals (ASI), the revolutionary new AI-powered trading signals provider, continues to make waves in the crypto world by announcing its has stormed past the $750k milestone. token presale AltSignals' native token, ASI, has achieved success during its presale phase and continues to demonstrate growth. ASI is currently available at $0.015 during stage 1 of its presale, with the imminent second stage set to increase the price by 25% to $0.01875. The value will eventually increase to $0.02274 at the end of the presale before listing on exchanges, at a 52% rise from today’s price. Rod Phim, CEO of AltSignals, welcomed the good news. “We’re thrilled that people have shown confidence in us and what we bring to the table. We have already seen the impact AI has had on a variety of industries, and we’re using this cutting-edge technology to better serve our users. Passing $750k in our current presale raise shows how promising our offering is. The news couldn’t have come at a better time to coincide with the product development, as discussed in our recent AMA.” AltSignals' new AI layer, ActualizeAI, will diligently scan the markets 24/7, providing real-time trading insights and opportunities that can be factored into the programs that generate the signals. The developers will aim to use this additional data to improve the accuracy of their existing trading signals and increase the reliability of the service consistently over time. The AltSignals team is currently focused on developing trading objectives and strategies, including programming risk levels. Building this into the AI will be essential for catering to a wide range of users engaging in both traditional markets and digital assets. Risk analysis is being supported by a data-acquiring exercise that looks at historical price data, fundamental data, and other data streams, which will be cleansed and pre-processed before being fed into the AI engine. has a significant user base who are actively trading using its indicator service and will become the first cohort to test the new AI. AltSignals The team confirms the confidence has grown in AltSignals during its ASI token presale and is generating growth metrics around digital asset communities around the future of the token. Phim added, “We hope the $750k raise milestone encourages more people to potentially invest in our offering and token, as we clearly have a proven track record of success after thriving for 5 years in what is a very competitive market.” About AltSignals AltSignals has been providing leading algorithm-based indicators and signals to its 52,000 members since 2017. Priding itself on transparency, the strength of its service and indicators is backed up by almost 500 reviews on Trustpilot, with an average score of 4.9/5. The business plans to grow on the achievements of its existing proposition by developing a new AI layer, ActualizeAI, to massively increase the accuracy of its trading signals and provide its users with invaluable indicators to keep them ahead of the markets. Find out more about AltSignals and participate in ASI’s presale . here Contact CEO Rod Phim AltSignals press@altsignals.io This story was distributed as a release by Chainwire under HackerNoon’s Brand As An Author Program. Learn more about the program here: https://business.hackernoon.com/brand-as-author

AltSignals Continues to Conquer the Crypto World As Presale Passes $750k Milestone

AltSignals continúa conquistando el mundo criptográfico a medida que la preventa supera el hito de $ 750k

AltSignals continue de conquérir le monde de la cryptographie alors que la prévente franchit le cap des 750 000 $

AltSignals ने क्रिप्टो दुनिया को जीतना जारी रखा क्योंकि प्रेस्ले ने $ 750k माइलस्टोन पास किया

AltSignals はプレセールで 75 万ドルのマイルストーンを突破し、暗号通貨の世界を征服し続けます

AltSignals continua a conquistar o mundo das criptomoedas enquanto a pré-venda ultrapassa o marco de $ 750.000

AltSignals tiếp tục chinh phục thế giới tiền điện tử khi Presale vượt qua cột mốc $750k

随着预售突破 75 万美元的里程碑，AltSignals 继续征服加密货币世界

Boost your Golang backend with the API: A seamless guide to setting up and utilizing supabase for efficient database operations and authentication. supabase Summary has emerged as a compelling open-source alternative to Firebase, offering a suite of tools including a database, authentication, real-time subscriptions, and storage. For Golang developers, integrating it can seem daunting due to the lack of proper library support. supabase However, the library provides a simplified way to interact with in your Golang projects. This article will guide you through setting up the library and demonstrate its use in a Golang backend project, ensuring you can leverage ’s powerful features with minimal hassle. supa supabase supa supabase Installation To begin, install in your Golang project. supa go get github.com/lengzuo/supa Setting Up Supabase in Your Golang Project Before diving into the code, ensure you have setup a supabase project. From your supabase project dashboard, note down the and the . These will be required to connect your Golang application to supabase. Project Ref Project API keys Configuration Import the library along with other necessary packages in your Golang project. supa package main

import (
	"fmt"
	"github.com/lengzuo/supa"
)

func main() {
    conf := supabase.Config{
        // Your project api key, you can use either `anon` or `service_role`.
        // but i will suggest you to use `service_role` as your api key and keep it secret.
		ApiKey:     "your-project-api-key",
        // Retrieve your project ref from project url
        // eg: https://this-your-project-ref.supabase.co
		ProjectRef: "your-project-ref",
        // Set it `false` in production to avoid extra log print.
		Debug:      true,
	}
	supaClient, err := supabase.New(conf)
	if err != nil {
		fmt.Println("failed in init supa client: ", err)
		return
	}
} Replace and according from your project. your-project-api-key your-project-ref supabase Use Case func signUp(supaClient *supabase.Client) {
  body := dto.SignUpRequest{
		Email:    "user@email.com",
		Password: "user-password",
	}
	resp, err := supaClient.Auth.SignUp(ctx, body)
    if err != nil {
        var supaErr catch.Exception
        // use this to catch the error of http status code != 2xx 
		if errors.As(err, &supaErr) {
			log.Error("status: %d, err: %s", supaErr.StatusCode(), supaErr.Error())
			return
		}
        fmt.Println("failed in sign up: ", err)
        return
    }
    bytes, _ := json.Marshal(resp)
    fmt.Printf("sign up success: %s", bytes)
}


func signInWithPassword(supaClient *supabase.Client) {
	body := dto.SignInRequest{
		Email:    "user@email.com",
		Password: "user-password",
	}
	resp, err := supaClient.Auth.SignInWithPassword(ctx, body)
    if err != nil {
       ...
    }
    bytes, _ := json.Marshal(resp)
    fmt.Printf("sign in with password success: %s", bytes)
}

func getAuthUser(supaClient *supabase.Client) {
    token = "logged-in-access-token"
	user, err := supaClient.Auth.User(ctx, token)
    if err != nil {
       ...
    }
    bytes, _ := json.Marshal(resp)
    fmt.Printf("sign in with password success: %s", bytes)
} There are more example functions such as and in the repo for your reference. RPC DB operation Github Conclusion In my personal experience with other Golang libraries, I find the library to be the most developer-friendly. It offers extensive authentication APIs such as SignInWithOTP, SignInWithOAuth, and more. Additionally, it allows developers to pass in for each operation. supabase supa context Besides that, it streamlines the process of integrating a robust backend database and authentication. With just a few lines of code, you can harness the power of supabase in your applications, making your development process more efficient and dynamic.

How to Accelerate Your Golang Backend With Supabase API

In most cases, Tableau tasks are scheduled to run at designated times, however, there may be occasions where the flexibility is not sufficient. If you're looking for a more flexible way to work with Tableau, you might want to check out the Tableau Server Client. It’s a Python library for the Tableau Server REST API. Using the TSC library, you can manage and change many of the Tableau Server and Tableau Cloud resources programmatically. Step 1: Authentication The provided Python code establishes a connection to Tableau Server using the Tableau Server Client (TSC) library. It authenticates using the provided account credentials and establishes a connection to the specified Tableau Server site. Once authenticated, the code allows access to Tableau Server resources for tasks such as querying data, publishing workbooks, and managing server content. import pandas as pd
import tableauserverclient as TSC

tableau_auth = TSC.TableauAuth('account', 'password', site_id='site_id')
server = TSC.Server('http://localhost', use_server_version=True)
server.auth.sign_in(tableau_auth) Make sure to replace ' ', ' ', and ' ' with actual credentials before running the code. account password site_id Step 2: List All Tasks and Find Task ID This code signs in to Tableau Server using provided authentication credentials, then retrieves all tasks from the server and creates a dataframe to store the , , and for each task. Taskid schedule_item task_type # get all tasks and find the Taskid
with server.auth.sign_in(tableau_auth):
    all_tasks, pagination_item = server.tasks.get()
    df_tasks = pd.DataFrame()
    df_tasks['Taskid'] = [task.id for task in all_tasks]
    df_tasks['schedule_item'] = [task.schedule_item for task in all_tasks]
    df_tasks['task_type'] = [task.task_type for task in all_tasks]
print(df_tasks) You can easily navigate through the dataframe to locate the specific task you wish to work with and then proceed to copy its corresponding Taskid in preparation for the next step. Step 3: Run or Delete a Task run a task You could use the following code to runs the specified extract refresh task, make sure to replace the with the actual id that you want to work with. id # replace the id 
with server.auth.sign_in(tableau_auth):
    task = server.tasks.get_by_id('9f9e9d9c-8b8a-8f8e-7d7c-7b7a6f6d6e6d')
    server.tasks.run(task)
    print("successfully refreshed") delete a task Deleting a task may not be as frequently utilized as running one, but it is just as straightforward. With the following code, you can smoothly delete a task. # delete a task
with server.auth.sign_in(tableau_auth):
    server.tasks.delete('9f9e9d9c-8b8a-8f8e-7d7c-7b7a6f6d6e6d')
    print("successfully deleted") References Tableau Server Client (Python) Tableau REST API Help Thank you for taking the time to explore data-related insights with me. I appreciate your engagement. If you find this information helpful, I invite you to follow me or connect with me on . Happy exploring!👋 LinkedIn

Using Python to Refresh Tableau Dashboard

Are you looking for a way to programmatically access and retrieve data from the Tableau Server? Python can be a powerful tool for automating this process using . Tableau's REST API In this blog, we will walk through the process of using Python to extract data from the Tableau Server and provide a working example that demonstrates how to access information such as views, projects, and workbooks. Connecting to Tableau Server and Authenticating First, we'll need to set up the Python environment and install the necessary libraries. We will be using the library to interact with the Tableau Server through its REST API. tableauserverclient Here's how to set up the initial authentication and connection to the Tableau Server: import tableauserverclient as TSC

tableau_auth = TSC.TableauAuth('USERNAME', 'PASSWORD', site_id='')
server = TSC.Server('http://SERVER_URL', use_server_version=True)
server.auth.sign_in(tableau_auth) Once authenticated, we can start accessing data from the Tableau Server. The following examples demonstrate how to retrieve information about views, projects, and workbooks. Retrieving Views In Tableau, views are individual visualizations or charts created within a Tableau workbook. These can include bar charts, line graphs, scatter plots, pie charts, maps, and other types of visual representations of data. Views are created by dragging and dropping fields from the data pane onto the view canvas and configuring the layout and properties. On Tableau Server, these views can be shared, accessed, and managed by users with appropriate permissions. Retrieving views through Tableau's REST API using Python refers to accessing information about these visualizations stored on the Tableau Server. # view
views = []
for view in TSC.Pager(server.views):
    views.append(view.name)

print(views) Retrieving Projects In Tableau, projects are used to organize and manage related content such as workbooks, data sources, views, and other resources. They enable the grouping of content and control access based on user permissions. Each project can have unique permissions, allowing for easier management and security of different types of content. Projects can also be nested to create a hierarchical structure for organizing content on the Tableau Server. Overall, projects provide a way to organize, manage, and control access to content within the Tableau Server. Print the Names of All Projects With the first code snippet, you could print the name of all projects by using the following code: # project get
with server.auth.sign_in(tableau_auth):
    # get all projects on site
    all_project_items, pagination_item = server.projects.get()
    
    print([proj.name for proj in all_project_items]) Create a DataFrame Containing All Attributes of the Project The project resources for Tableau are defined in the class. The class corresponds to the project resources that you can access using the Tableau Server REST API. In addition to the , it also has , , , and attributes. ProjectItem name content_permissions description id parent_id If you want to save all of them into a dataframe, you could use the following code: # project get
with server.auth.sign_in(tableau_auth):
    # get all projects on site
    all_projects, pagination_item = server.projects.get()

    df_projects = pd.DataFrame({
        'name': [project.name for project in all_projects],
        'content_permissions': [project.content_permissions for project in all_projects],
        'description': [project.description for project in all_projects],
        'id': [project.id for project in all_projects],
        'parent_id': [project.parent_id for project in all_projects]
    }) Retrieving Workbooks The workbook resources for Tableau are defined in the class. The class corresponds to the workbook resources you can access using the Tableau REST API. Some workbook methods take an instance of the class as arguments. The workbook item specifies the project. WorkbookItem WorkbookItem Print Names of the First 100 Workbooks With the first code snippet, you could print the name of all workbooks by using the following code: with server.auth.sign_in(tableau_auth):
  all_workbooks_items, pagination_item = server.workbooks.get()  
  # print names of first 100 workbooks
  print([workbook.name for workbook in all_workbooks_items]) Retrieve all the Workbooks and Save Them in a Dataframe. If the number of workbooks exceeds 100, you can use instead of to retrieve all workbooks. server.workbooks.all() server.workbooks.get() The following code snippet allows you to fetch all workbooks. In addition to the four attributes mentioned, you can refer to the for more information. WorkbookItem class # workbook
with server.auth.sign_in(tableau_auth):
    all_workbooks_items = server.workbooks.all()

    df_workbook = pd.DataFrame({
        'name': [workbook.name for workbook in all_workbooks_items],
        'project_id': [workbook.project_id for workbook in all_workbooks_items],
        'project_name': [workbook.project_name for workbook in all_workbooks_items],
        'webpage_url': [workbook.webpage_url for workbook in all_workbooks_items]
    }) Thank you for taking the time to explore data-related insights with me. I appreciate your engagement. If you find this information helpful, I invite you to follow me, or connect with me on . Happy exploring!👋 LinkedIn Also published here

How to Use Python to Retrieve Data Through Tableau REST API

User Authentication in Android using Firebase (Java)

Autenticación de usuarios en Android usando Firebase (Java)

Authentification de l'utilisateur dans Android à l'aide de Firebase (Java)

फायरबेस (जावा) का उपयोग करके एंड्रॉइड में उपयोगकर्ता प्रमाणीकरण

Firebase (Java) を使用した Android でのユーザー認証

Autenticação do usuário no Android usando Firebase (Java)

Xác thực người dùng trong Android bằng Firebase (Java)

使用 Firebase (Java) 在 Android 中进行用户身份验证

Flashbots can be real lifesavers sometimes. Let’s look at a real-life event One of our wallets had been hacked some time back, and all the Ether in that wallet was taken out. It was an issue but the bigger issue was that this wallet was the owner of a contract we deployed and it still had the ownership, but it didn’t have any Ether left, so we couldn’t transfer the Ownership to another wallet as we couldn’t pay for gas fees. Well, just load the wallet with some Ether and transfer the tokens. It’s so easy, right? Well not really! There was a high probability that the person who hacked the wallet had set up a bot that would immediately take out all the assets transferred to the wallet. So, if we transfered any Ether to the wallet, there was a high probability that it would be taken out immediately. What’s the solution then? It’s simple. We needed to transfer some Ether to the wallet and transfer the ownership of the contract before the bot that was set up by the hacker could perform any action. It had to be fast and  this meant it had to be done in a single block Could we do it manually? , that’s when the Flashbots come to rescue Noooo Let’s understand some terms first Maximal Extractable Value (MEV) Maximal Extractable Value (MEV) represents excess value captured by miners (or validators) from users in a cryptocurrency network. This excess value often comes from reordering user'’ transactions to maximize fees or inserting new transactions that allow a miner to front-run users’ transactions. More: Maximal extractable value (MEV) | ethereum.org Flashbots Flash boats refer to automated programs that use high-speed communication and data processing technologies to execute trades on decentralized exchanges (DEXs) or other types of blockchain-based trading platforms. Like traditional flash bots, these programs use algorithms to analyze market data and identify trading opportunities in real-time. They can make trades based on a wide range of factors, such as changes in the prices of various cryptocurrencies or tokens, news events, and changes in market liquidity. Back to the problem For this article, I’ve tried to replicate a similar scenario to the one described earlier. We have a wallet that has been hacked, the hacker has taken out all the Eth from that wallet, but that wallet still has some ERC20 tokens left inside it, we want to take these tokens out and transfer them to another wallet. Let’s see the code You can clone the starter code from this . First of all, set the environment variables Repo TOKENS=Address of ERC20 token which we need to takeout of that wallet  
RESCUER=Private key of wallet in which we want to transfer those tokens
HACKED_WALLET=Private key of wallet that has been hacked Let’s define some constants first const provider = new providers.JsonRpcProvider('<https://rpc.ankr.com/eth_goerli>')
const authSigner = Wallet.createRandom()
const flashbotProvider = await FlashbotsBundleProvider.create(
        provider,
        authSigner,
        FLASHBOTS_URL
    )
const rescuer = new Wallet(RESCUER).connect(provider)
const hackedWallet = new Wallet(HACKED_WALLET).connect(provider) We have created all the signers we need, and we are using Ankr as the RPC providers. We will be using a method from called . flashbotProvider sendBundle This method takes an array of Transactions that we want to perform in a single block, and as a second argument, it takes the number of blocks in which we want to include the transactions. Cool? Alright. Let’s get the current block number first. provider.on('block', async (blockNo) => {
	const targetBlock = blockNo + 1;
}) Out target block is the next block that is to be produced. And now let’s use the method sendBundle const resp = await flashbotProvider.sendBundle([
            {
                signer: rescuer,
                transaction: {
                    chainId: 5,
                    type: 2,
                    to: hackedWallet.address,
                    value: utils.parseEther('0.01'),
                    maxFeePerGas: utils.parseUnits('20', 'gwei'),
                    maxPriorityFeePerGas: utils.parseUnits('13', 'gwei')
                }
            },
            {
                signer: hackedWallet,
                transaction: {
                    chainId: 5,
                    type: 2,
                    to: TOKENS,
                    gasLimit: '70000',
                    data: iface.encodeFunctionData("transfer", [
                        rescuer.address,
                        utils.parseEther('200')
                    ]),
                    maxFeePerGas: utils.parseUnits('20', 'gwei'),
                    maxPriorityFeePerGas: utils.parseUnits('13', 'gwei')
                }
            }
        ], targetBlock) Basically, we will be performing two transactions We need to transfer some Ether to the wallet that has been hacked to provide it with the gas fees that will be used to transfer the ERC20 tokens to the rescuer wallet. We now call the transfer function from the ERC20 contract using the signer of the hacked wallet and transfer all the tokens to the rescuer wallet. These transactions can be anything Like transfer, an NFT, Transfer Ownership of a contract, call any contract method. And that’s it. Also published here. Want to connect? DM me on twitter @ or pateldeep_eth Linkedin Want to explore more examples? https://github.com/flashbots/searcher-sponsored-tx Also, Read How to Find Length of String in Solidity — From the Smart Contract of “ens” Permanent File Storage for Web3 Apps With Arweave, Bundlr, Next.js, RainbowKit, and Wagmi How to develop and deploy smart contracts with Foundry & Openzeppelin

Using Flash Bots to Rescue Assets from a Compromised Wallet

Hey devs, welcome to this tutorial; we will build a real-time Todo App with React, NextJs + Firebase. The full code of this project is available in this repository The explanation of this article is in this video Before we start writing code, I want to tell you that I expect you to have basic knowledge of React.Js and Next.Js If you are not familiar with React and Next, go through these documentations ReactJs Documentation NextJs Documentation Here’s what we are going to build After completing this tutorial, our app will look like this Here’s our tech stack for this project : We will ReactJs for building the UI of this app. ReactJs : NextJs is a react-based framework for building modern web apps. It provides benefits like and many benefits NextJs Server Side Rendering SEO : We will use firebase as a backend of this app. We will store data in **.** It provides many functions for creating real-time apps. (Our todo app will be real-time) Firebase Firestore : ChakraUI is a styling framework. It has styled components ready to be used in-app. It provides responsiveness, dark mode, an eye-appealing color scheme, and so on. ChakraUI Why are we using Firebase in our project? Firebase provides so much functionality that it is hard to ignore. It provides Social Auth with just 4–5 lines of code. We will implement in our Project using firebase Google Auth Some features of Firebase are: Authentication Real-Time Server Low-Security Risk Social Auth Minimal Setup Table of Contents Create Firebase Project Create Methods to Interact with Firestore Create React Components (Add Todo, Auth, TodoList) npm run dev 😁 Let’s begin with creating the next app Type the following command to install the next app npx create-next-app next-firebase-todo Install the required dependencies Chakra UI npm i @chakra-ui/react @emotion/react @emotion/styled framer-motion 2. Firebase npm i firebase Create Firebase Project Go to Firebase Console Click on Create a Project Name your project and tick the box, and Click Continue We don’t need Google Analytics for the Project. So, untoggle that button and click Continue After your project has been created, you will see your project Dashboard As Icon suggests, the first button is for the project, the second for and the third for IOS Android, Web Apps. We are creating a web app, so we are gonna click on that. Name your web app and click Register app Copy this code and click on Continue to Console : Save this code somewhere. We will need it later in our project. Note On the left side, click on Build We will only need two features of firebase from this list. — For adding Google Sign In — For Storing User Todos Authentication FireStore Database Now, let's Enable these two features first. Click on Authentication Click Get Started We are only gonna use Google Authentication, so click on Google Enable Google Authentication, Select Project Support Email, and click Save We have successfully enabled Google Auth in our Firebase Project Now let us enable the Firestore Database. Go to the left Sidebar, Click on Build, and Click Firestore Database Click on Create database Select and click and Click start in test mode Next, Enable Now we have enabled both and the required for our Project Authentication Firestore Database Now let’s start coding Let’s go to and copy-paste the following pages/_app.js import { ChakraProvider } from "@chakra-ui/react";
function MyApp({ Component, pageProps }) {
return (
<ChakraProvider>
<Component {...pageProps} />
</ChakraProvider>
);
}
export default MyApp; We just wrapped inside <Component {…pageProps} /> <ChakraProvider> Chakra UI’s official Documentation suggests this. Now we are going to set up firebase in our web app. Let us create a new folder at the project root named firebase Create a file named inside directory index.js firebase Now paste the code I told you to copy earlier(firebase config) import { initializeApp } from "firebase/app";
import { getAuth } from "firebase/auth";
import { getFirestore } from "firebase/firestore";
// replace this firebase conFigvariable with your own
const firebaseConfig = {
apiKey: "AIzaSyClH1YdssQHAA0peMtQ_wj2A4Crnc4fEgU",
authDomain: "medium-firebase-next-todo.firebaseapp.com",
projectId: "medium-firebase-next-todo",
storageBucket: "medium-firebase-next-todo.appspot.com",
messagingSenderId: "989711683222",
appId: "1:989711683222:web:bc878dca5a5d251177fcb7",
};
const app = initializeApp(firebaseConfig);
const auth = getAuth(app);
const db = getFirestore(app);
export { auth, db }; What we did here is we just pasted the firebase config. We additionally created two variables and which are the and respectively. auth db firebase auth module firestore module, Let’s add a new dependency to our project, which is react-icons npm install react-icons --save React Icons library lets you add beautiful icons to your project. Now let us create methods to create and interact with todos Methods to Interact with Firestore Create a directory at the root of your project named api and create a file todo.js and copy and paste the following code in todo.js import { db } from "../firebase";
import {
collection,
addDoc,
updateDoc,
doc,
deleteDoc,
} from "firebase/firestore";
const addTodo = async ({ userId, title, description, status }) => {
try {
await addDoc(collection(db, "todo"), {
user: userId,
title: title,
description: description,
status: status,
createdAt: new Date().getTime(),
});
} catch (err) {}
};
const toggleTodoStatus = async ({ docId, status }) => {
try {
const todoRef = doc(db, "todo", docId);
await updateDoc(todoRef, {
status,
});
} catch (err) {
console.log(err);
}
};
const deleteTodo = async (docId) => {
try {
const todoRef = doc(db, "todo", docId);
await deleteDoc(todoRef);
} catch (err) {
console.log(err);
}
};
export { addTodo, toggleTodoStatus, deleteTodo }; Now let’s create an Authentication hook for checking auth status of the user. Create a directory named hooks and create a file in directory useAuth.js hooks and copy and paste the following code in useAuth.js import { useEffect, useState } from "react";
import { auth } from "../firebase";
const useAuth = () => {
const [user, setUser] = useState(null);
const [isLoggedIn, setIsLoggedIn] = useState(false);
useEffect(() => {
auth.onAuthStateChanged((user) => {
setIsLoggedIn(user && user.uid ? true : false);
setUser(user);
});
});
return { user, isLoggedIn };
};
export default useAuth; What we did is created a useAuth hook that returns the current and Boolean. user isLoggedIn Every time the auth status changes, the method inside the is called. onAuthStateChanged This functionality is given by firebase itself Now let’s create UI Create React Components Create directory at the root of your web app components We will create 3 components in our app AddTodo — for adding a new todo Auth — for adding Login/Logout Button TodoList — for viewing all existing todos properly Let’s start with AddTodo. Create inside directory AddTodo.jsx components Copy and paste the following code inside AddTodo.jsx import React from "react";
import {
Box,
Input,
Button,
Textarea,
Stack,
Select,
useToast,
} from "@chakra-ui/react";
import useAuth from "../hooks/useAuth";
import { addTodo } from "../api/todo";
const AddTodo = () => {
const [title, setTitle] = React.useState("");
const [description, setDescription] = React.useState("");
const [status, setStatus] = React.useState("pending");
const [isLoading, setIsLoading] = React.useState(false);
const toast = useToast();
const { isLoggedIn, user } = useAuth();
const handleTodoCreate = async () => {
if (!isLoggedIn) {
toast({
title: "You must be logged in to create a todo",
status: "error",
duration: 9000,
isClosable: true,
});
return;
}
setIsLoading(true);
const todo = {
title,
description,
status,
userId: user.uid,
};
await addTodo(todo);
setIsLoading(false);
setTitle("");
setDescription("");
setStatus("pending");
toast({ title: "Todo created successfully", status: "success" });
};
return (
<Box w="40%" margin={"0 auto"} display="block" mt={5}>
<Stack direction="column">
<Input
placeholder="Title"
value={title}
onChange={(e) => setTitle(e.target.value)}
/>
<Textarea
placeholder="Description"
value={description}
onChange={(e) => setDescription(e.target.value)}
/>
<Select value={status} onChange={(e) => setStatus(e.target.value)}>
<option
value={"pending"}
style={{ color: "yellow", fontWeight: "bold" }}
>
Pending ⌛
</option>
<option
value={"completed"}
style={{ color: "green", fontWeight: "bold" }}
>
Completed ✅
</option>
</Select>
<Button
onClick={() => handleTodoCreate()}
disabled={title.length < 1 || description.length < 1 || isLoading}
variantColor="teal"
variant="solid"
>
Add
</Button>
</Stack>
</Box>
);
};
export default AddTodo; Now create inside directory Auth.jsx component and copy and paste the following code inside it import React from "react";
import { Box, Button, Link, Text, useColorMode } from "@chakra-ui/react";
import { signInWithPopup, GoogleAuthProvider } from "firebase/auth";
import { FaGoogle, FaMoon, FaSun } from "react-icons/fa";
import { auth } from "../firebase";
import useAuth from "../hooks/useAuth";
const Auth = () => {
const { toggleColorMode, colorMode } = useColorMode();
const { isLoggedIn, user } = useAuth();
const handleAuth = async () => {
const provider = new GoogleAuthProvider();
signInWithPopup(auth, provider)
.then((result) => {
// This gives you a Google Access Token. You can use it to access the Google API.
const credential = GoogleAuthProvider.credentialFromResult(result);
const token = credential.accessToken;
// The signed-in user info.
const user = result.user;
// ...
})
.catch((error) => {
// Handle Errors here.
const errorCode = error.code;
const errorMessage = error.message;
// The email of the user's account used.
const email = error.customData.email;
// The AuthCredential type that was used.
const credential = GoogleAuthProvider.credentialFromError(error);
// ...
});
};
return (
<Box position={"fixed"} top="5%" right="5%">
<Button onClick={() => toggleColorMode()}>
{colorMode == "dark" ? <FaSun /> : <FaMoon />}
</Button>{" "}
{isLoggedIn && (
<>
<Text color="green.500">{user.email}</Text>
<Link color="red.500" onClick={() => auth.signOut()}>
Logout
</Link>
</>
)}
{!isLoggedIn && (
<Button leftIcon={<FaGoogle />} onClick={() => handleAuth()}>
Login with Google
</Button>
)}
</Box>
);
};
export default Auth; Now let’s create the component inside directory. TodoList.jsx components And copy and paste the following code inside it import {
Badge,
Box,
Heading,
SimpleGrid,
Text,
useToast,
} from "@chakra-ui/react";
import React, { useEffect } from "react";
import useAuth from "../hooks/useAuth";
import { collection, onSnapshot, query, where } from "firebase/firestore";
import { db } from "../firebase";
import { FaToggleOff, FaToggleOn, FaTrash } from "react-icons/fa";
import { deleteTodo, toggleTodoStatus } from "../api/todo";
const TodoList = () => {
const [todos, setTodos] = React.useState([]);
const {  user } = useAuth();
const toast = useToast();
const refreshData = () => {
if (!user) {
setTodos([]);
return;
}
const q = query(collection(db, "todo"), where("user", "==", user.uid));
onSnapshot(q, (querySnapchot) => {
let ar = [];
querySnapchot.docs.forEach((doc) => {
ar.push({ id: doc.id, ...doc.data() });
});
setTodos(ar);
});
};
useEffect(() => {
refreshData();
}, [user]);
const handleTodoDelete = async (id) => {
if (confirm("Are you sure you wanna delete this todo?")) {
deleteTodo(id);
toast({ title: "Todo deleted successfully", status: "success" });
}
};
const handleToggle = async (id, status) => {
const newStatus = status == "completed" ? "pending" : "completed";
await toggleTodoStatus({ docId: id, status: newStatus });
toast({
title: `Todo marked ${newStatus}`,
status: newStatus == "completed" ? "success" : "warning",
});
};
return (
<Box mt={5}>
<SimpleGrid columns={{ base: 1, md: 3 }} spacing={8}>
{todos &&
todos.map((todo) => (
<Box
p={3}
boxShadow="2xl"
shadow={"dark-lg"}
transition="0.2s"
_hover={{ boxShadow: "sm" }}
>
<Heading as="h3" fontSize={"xl"}>
{todo.title}{" "}
<Badge
color="red.500"
bg="inherit"
transition={"0.2s"}
_hover={{
bg: "inherit",
transform: "scale(1.2)",
}}
float="right"
size="xs"
onClick={() => handleTodoDelete(todo.id)}
>
<FaTrash />
</Badge>
<Badge
color={todo.status == "pending" ? "gray.500" : "green.500"}
bg="inherit"
transition={"0.2s"}
_hover={{
bg: "inherit",
transform: "scale(1.2)",
}}
float="right"
size="xs"
onClick={() => handleToggle(todo.id, todo.status)}
>
{todo.status == "pending" ? <FaToggleOff /> : <FaToggleOn />}
</Badge>
<Badge
float="right"
opacity="0.8"
bg={todo.status == "pending" ? "yellow.500" : "green.500"}
>
{todo.status}
</Badge>
</Heading>
<Text>{todo.description}</Text>
</Box>
))}
</SimpleGrid>
</Box>
);
};
export default TodoList; We have created all the required components, now we are gonna place them in our app. Go to and remove all the contents and paste the following content pages/index.js import { Container } from "@chakra-ui/react";
import AddTodo from "../components/AddTodo";
import Auth from "../components/Auth";
import TodoList from "../components/TodoList";
export default function Home() {
return (
<Container maxW="7xl">
<Auth />
<AddTodo />
<TodoList />
</Container>
);
} And we are done. npm run dev We have completed the coding of the app. Go to your terminal and type npm run dev and goto in your browser localhost:3000 You will see something like this Now you can and start adding Todo’s log in with Google Get the full code here Watch the explanation video here Follow me on Twitter Also Published Here

Creating a Todo App with NextJs & Firebase

Authentication using the Amazon Cognito to an Angular application

Introduction is a development platform for building WEB, mobile and desktop applications using HTML, CSS and TypeScript (JavaScript). Currently, Angular is at version 14 and Google is the main maintainer of the project. Angular is an authentication service with simple tools to help developers build applications. Supabase Prerequisites Before you start, you need to install and configure the tools: git Node.js and npm Angular CLI IDE (e.g. ) Visual Studio Code Getting started Create and configure the account on the Supabase Let's create the account. Access the site and click on the button . 1. https://supabase.io/ Start your project Click on the button . 2. Continue with GitHub Fill in the fields , and click on the button to login with your GitHub account and if you don't have an account, click on the button to create a new account. there is a step-by-step guide to creating a GitHub account. 3. Username or email address Password Sign in Create an account In this tutorial Click on the button . 4. Authorize supabase Click on the button . 5. New project Click on the menu with the organization name created automatically. 6. Select an , fill in the fields and , select a and click on the button . 7. Organization Name Database Password Region Create new project Wait for the project creation. 8. Click on the button to copy the key that has been generated, in my case, the key was copied. Click on the button to copy the URL that has been generated, in my case, the URL was copied because this key and URL will be configured in the Angular application. 9. Copy eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJyb2xlIjoiYW5vbiIsImlhdCI6MTYzNTA4NjA1MCwiZXhwIjoxOTUwNjYyMDUwfQ.CzFuYS6XKvEwW5OsAAPAcHvuo-NVE4PUwDSKgqK9Yas Copy https://wzlpmcsxrxogtctlznel.supabase.co Click on the menu to setting up the database schema. 10. SQL Click on the card . 11. User Management Starter Click on the button . 12. RUN Ready! Account created, key generated and database schema configured. 13. Create the Angular application Let's create the application with the Angular base structure using the with the route file and the SCSS style format. 1. @angular/cli ng new angular-supabase --routing true --style scss
CREATE angular-supabase/README.md (1062 bytes)
CREATE angular-supabase/.editorconfig (274 bytes)
CREATE angular-supabase/.gitignore (604 bytes)
CREATE angular-supabase/angular.json (3267 bytes)
CREATE angular-supabase/package.json (1080 bytes)
CREATE angular-supabase/tsconfig.json (783 bytes)
CREATE angular-supabase/.browserslistrc (703 bytes)
CREATE angular-supabase/karma.conf.js (1433 bytes)
CREATE angular-supabase/tsconfig.app.json (287 bytes)
CREATE angular-supabase/tsconfig.spec.json (333 bytes)
CREATE angular-supabase/src/favicon.ico (948 bytes)
CREATE angular-supabase/src/index.html (301 bytes)
CREATE angular-supabase/src/main.ts (372 bytes)
CREATE angular-supabase/src/polyfills.ts (2820 bytes)
CREATE angular-supabase/src/styles.scss (80 bytes)
CREATE angular-supabase/src/test.ts (788 bytes)
CREATE angular-supabase/src/assets/.gitkeep (0 bytes)
CREATE angular-supabase/src/environments/environment.prod.ts (51 bytes)
CREATE angular-supabase/src/environments/environment.ts (658 bytes)
CREATE angular-supabase/src/app/app-routing.module.ts (245 bytes)
CREATE angular-supabase/src/app/app.module.ts (393 bytes)
CREATE angular-supabase/src/app/app.component.scss (0 bytes)
CREATE angular-supabase/src/app/app.component.html (24617 bytes)
CREATE angular-supabase/src/app/app.component.spec.ts (1103 bytes)
CREATE angular-supabase/src/app/app.component.ts (221 bytes)
✔ Packages installed successfully.
    Successfully initialized git. Install and configure the Bootstrap CSS framework. Do steps 2 and 3 of the post . 2. Adding the Bootstrap CSS framework to an Angular application Configure the variable with the Supabase URL and the variable with the Supabase key in the and files as below. 3. supabase.url supabase.key src/environments/environment.ts src/environments/environment.prod.ts supabase: {
  url: 'https://wzlpmcsxrxogtctlznel.supabase.co',
  key: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJyb2xlIjoiYW5vbiIsImlhdCI6MTYzNTA4NjA1MCwiZXhwIjoxOTUwNjYyMDUwfQ.CzFuYS6XKvEwW5OsAAPAcHvuo-NVE4PUwDSKgqK9Yas',
}, Install the library. 4. @supabase/supabase-js npm install @supabase/supabase-js Create the service. 5. SupabaseService ng generate service supabase --skip-tests=true
CREATE src/app/supabase.service.ts (137 bytes) Change the file and add the lines as below. 6. supabase.service.ts import { Injectable } from '@angular/core';
import { AuthChangeEvent, createClient, Session, SupabaseClient, User } from '@supabase/supabase-js';

import { environment } from '../environments/environment';

export interface IUser {
  email: string;
  name: string;
  website: string;
  url: string;
}

@Injectable({
  providedIn: 'root',
})
export class SupabaseService {

  private supabaseClient: SupabaseClient;

  constructor() {
    this.supabaseClient = createClient(environment.supabase.url, environment.supabase.key);
  }

  public getUser(): User|null {
    return this.supabaseClient.auth.user();
  }

  public getSession(): Session|null {
    return this.supabaseClient.auth.session();
  }

  public getProfile(): PromiseLike<any> {
    const user = this.getUser();

    return this.supabaseClient.from('profiles')
    .select('username, website, avatar_url')
    .eq('id', user?.id)
    .single();
  }

  public authChanges(callback: (event: AuthChangeEvent, session: Session | null) => void): any {
    return this.supabaseClient.auth.onAuthStateChange(callback);
  }

  public signIn(email: string): Promise<any> {
    return this.supabaseClient.auth.signIn({
      email,
    });
  }

  public signOut(): Promise<any> {
    return this.supabaseClient.auth.signOut();
  }

  public updateProfile(userUpdate: IUser): any {
    const user = this.getUser();

    const update = {
      username: userUpdate.name,
      website: userUpdate.website,
      id: user?.id,
      updated_at: new Date(),
    };

    return this.supabaseClient.from('profiles').upsert(update, {
      returning: 'minimal', // Do not return the value after inserting
    });
  }

} Create the component. 7. SignInComponent ng generate component sign-in --skip-tests=true
CREATE src/app/sign-in/sign-in.component.scss (0 bytes)
CREATE src/app/sign-in/sign-in.component.html (22 bytes)
CREATE src/app/sign-in/sign-in.component.ts (279 bytes)
UPDATE src/app/app.module.ts (493 bytes) Change the file. Import the and services and create the method as below. 8. src/app/sign-in/sign-in.component.ts Router SupabaseService signIn import { Component } from '@angular/core';
import { Router } from '@angular/router';
import { IUser, SupabaseService } from '../supabase.service';

@Component({
  selector: 'app-sign-in',
  templateUrl: './sign-in.component.html',
  styleUrls: ['./sign-in.component.scss'],
})
export class SignInComponent {

  loading: boolean;
  user: IUser;

  constructor(private router: Router,
              private supabaseService: SupabaseService) {
    this.loading = false;
    this.user = {} as IUser;
  }

  public signIn(): void {
    this.loading = true;
    this.supabaseService.signIn(this.user.email)
    .then(() => {
    }).catch(() => {
      this.loading = false;
    });
  }

} Change the file. Add the lines as below. 9. src/app/sign-in/sign-in.component.html <div class="row justify-content-center my-5">
  <div class="col-4">
    <div class="card">
      <div class="card-body">
        <div class="row">
          <div class="col mb-2">
            <label for="email" class="form-label">Email:</label>
            <input type="email" id="email" name="email" #email="ngModel" [(ngModel)]="user.email" class="form-control form-control-sm">
          </div>
        </div>
        <div class="row">
          <div class="col d-grid">
            <button type="button" (click)="signIn()" class="btn btn-sm btn-success" [disabled]="loading">
              <span class="spinner-border spinner-border-sm" role="status" aria-hidden="true" *ngIf="loading"></span>
              Sign in
            </button>
          </div>
        </div>
      </div>
    </div>
  </div>
</div> Create the component. 10. ProfileComponent ng generate component profile --skip-tests=true
CREATE src/app/profile/profile.component.scss (0 bytes)
CREATE src/app/profile/profile.component.html (22 bytes)
CREATE src/app/profile/profile.component.ts (280 bytes)
UPDATE src/app/app.module.ts (642 bytes) Change the file. Import the service and create the method as below. 11. src/app/profile/profile.component.ts SupabaseService update import { Component, OnInit } from '@angular/core';
import { IUser, SupabaseService } from '../supabase.service';

@Component({
  selector: 'app-profile',
  templateUrl: './profile.component.html',
  styleUrls: ['./profile.component.scss'],
})
export class ProfileComponent implements OnInit {

  loading: boolean;
  user: IUser;

  constructor(private supabaseService: SupabaseService) {
    this.loading = false;
    this.user = {} as IUser;
  }

  public ngOnInit(): void {
    const session = this.supabaseService.getSession();

    if (session && session.user && session.user.email) {
      this.user.email = session.user.email;
    }

    this.supabaseService.getProfile()
    .then((success: any) => {
      if (success && success.profile) {
        this.user.name = success.profile.username;
        this.user.website = success.profile.website;
        this.user.url = success.profile.avatar_url;
      }
    });
  }

  public update(): void {
    this.loading = true;

    this.supabaseService.updateProfile(this.user)
    .then(() => {
      this.loading = false;
    }).catch(() => {
      this.loading = false;
    });
  }

} Change the file and add the lines as below. 12. src/app/profile/profile.component.html <div class="row justify-content-center my-5">
  <div class="col-4">
    <div class="row" *ngIf="user.url">
      <div class="col mb-2 text-center">
        <img [src]="user.url" class="rounded-circle">
      </div>
    </div>
    <div class="row">
      <div class="col mb-2">
        <label for="email" class="form-label">Email:</label>
        <input type="email" id="email" name="email" #email="ngModel" [(ngModel)]="user.email" disabled class="form-control form-control-sm">
      </div>
    </div>
    <div class="row">
      <div class="col mb-2">
        <label for="name" class="form-label">Name:</label>
        <input type="text" id="name" name="name" #name="ngModel" [(ngModel)]="user.name" class="form-control form-control-sm">
      </div>
    </div>
    <div class="row">
      <div class="col mb-2">
        <label for="website" class="form-label">Website:</label>
        <input type="text" id="website" name="website" #website="ngModel" [(ngModel)]="user.website" class="form-control form-control-sm">
      </div>
    </div>
    <div class="row">
      <div class="col d-grid">
        <button type="button" (click)="update()" class="btn btn-sm btn-dark" [disabled]="loading">
          <span class="spinner-border spinner-border-sm" role="status" aria-hidden="true" *ngIf="loading"></span>
          Save
        </button>
      </div>
    </div>
  </div>
</div> Change the file. Import the and services and create the and methods as below. 13. src/app/app.component.ts Router SupabaseService isAuthenticated signOut import { Component, OnInit } from '@angular/core';
import { Router } from '@angular/router';
import { SupabaseService } from './supabase.service';

@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.scss'],
})
export class AppComponent implements OnInit {

  session: any;

  constructor(private router: Router,
              private supabaseService: SupabaseService) {
    this.session = this.supabaseService.getSession();
  }

  public ngOnInit(): void {
    this.supabaseService.authChanges((_, session) => this.session = session);
  }

  public isAuthenticated(): boolean {
    if (this.session) {
      return true;
    }
    return false;
  }

  public signOut(): void {
    this.supabaseService.signOut()
    .then(() => {
      this.router.navigate(['/signIn']);
    });
  }

} Change the file and add the menu as below. 14. src/app/app.component.html <nav class="navbar navbar-expand-sm navbar-light bg-light">
  <div class="container-fluid">
    <a class="navbar-brand" href="#">Angular Supabase</a>

    <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#navbarContent" aria-controls="navbarSupportedContent" aria-expanded="false" aria-label="Toggle navigation">
      <span class="navbar-toggler-icon"></span>
    </button>

    <div id="navbarContent" class="collapse navbar-collapse">
      <ul class="navbar-nav me-auto mb-2 mb-lg-0">
        <li class="nav-item">
          <a class="nav-link" routerLink="/signIn" routerLinkActive="active" *ngIf="!isAuthenticated()">Sign in</a>
        </li>
        <li class="nav-item">
          <a class="nav-link" routerLink="/profile" routerLinkActive="active" *ngIf="isAuthenticated()">Profile</a>
        </li>
        <li class="nav-item">
          <a class="nav-link" routerLink="" (click)="signOut()" *ngIf="isAuthenticated()">Sign out</a>
        </li>
      </ul>
    </div>
  </div>
</nav>

<router-outlet></router-outlet> Change the file and add the routes as below. 15. src/app/app-routing.module.ts import { ProfileComponent } from './profile/profile.component';
import { SignInComponent } from './sign-in/sign-in.component';

const routes: Routes = [
  {
    path: '',
    redirectTo: 'signIn',
    pathMatch: 'full',
  },
  {
    path: 'profile',
    component: ProfileComponent,
  },
  {
    path: 'signIn',
    component: SignInComponent,
  },
  {
    path: '**',
    redirectTo: 'signIn',
  },
]; Change the file. Import the module and the and components as below. 16. src/app/app.module.ts FormsModule ProfileComponent SignInComponent import { FormsModule } from '@angular/forms';

import { ProfileComponent } from './profile/profile.component';
import { SignInComponent } from './sign-in/sign-in.component';

declarations: [
  AppComponent,
  ProfileComponent,
  SignInComponent,
],
imports: [
  BrowserModule,
  FormsModule,
  AppRoutingModule,
], Run the application with the command below. 17. npm start

> angular-supabase@1.0.0 start
> ng serve

✔ Browser application bundle generation complete.

Initial Chunk Files | Names         |      Size
vendor.js           | vendor        |   2.90 MB
styles.css          | styles        | 268.30 kB
polyfills.js        | polyfills     | 128.51 kB
scripts.js          | scripts       |  76.33 kB
main.js             | main          |  34.20 kB
runtime.js          | runtime       |   6.63 kB

                    | Initial Total |   3.40 MB

Build at: 2021-10-25T02:19:20.036Z - Hash: 2dc1cd0da7856970b0d8 - Time: 17203ms

Warning: /home/rodrigo/Development/Angular/angular-supabase/node_modules/@supabase/realtime-js/dist/module/RealtimeClient.js depends on 'websocket'. CommonJS or AMD dependencies can cause optimization bailouts.
For more info see: https://angular.io/guide/build#configuring-commonjs-dependencies



** Angular Live Development Server is listening on localhost:4200, open your browser on http://localhost:4200/ **


✔ Compiled successfully. Ready! Access the URL and check if the application is working. See the application working on and . 18. http://localhost:4200/ GitHub Pages Stackblitz Testing the application sign in Let's test the application sign in. Access the URL , fill in the field and click on the button . 1. http://localhost:4200/ Email Sign in Open the email with the subject and click on the link . 2. Confirm Your Signup Confirm your mail At this point, you are already signed in. Click on the menu . 3. Profile Fill in the fields and and click on the button . 4. Name Website Update Go back to the Supabase site and click on the menu . 5. New query Fill in the text field with content and click on the button . 6. SELECT * FROM profiles; RUN Check the updated fields and . 7. username website Ready! We test the application sign in and profile update. Supabase documentation is available at . 8. https://supabase.io/docs The application repository is available at . https://github.com/rodrigokamada/angular-supabase This tutorial was posted on my in Portuguese. blog

Authentication in an Angular Application Using Supabase

Today we will be discussing how we can set up a Flutter app and implement Google sign-in using Firebase. We'll be building a two-page app that allows users to log in using their Google Account. This is for a layer of security and to pull user's information associated with their Gmail accounts such as the user name and avatar image etc. Our final app will look like follows: Users can click on the "Sign In with Google" button, which will launch a view where users can provide their Google credentials. Upon success, control is returned to the user and Flutter navigates the user to the Welcome screen, where they can view their name, avatar, and be able to log out. Getting Started I have created my flutter application named . If you have not created any, then you can create a flutter app using the following command: social_login flutter create social_login Now we'll add the plugins required in this project. Open file and in dependencies add the plugins as: pubspec.yaml firebase_auth: ^0.16.0
google_sign_in: ^4.4.4
flutter_auth_buttons: ^0.5.0 Save the file and run: flutter pub get Build the UI Delete the code from the file and add the following code: main.dart // main.dart
import 'package:flutter/material.dart';
import 'login_page.dart';
void main() => runApp(MyApp());
class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      debugShowCheckedModeBanner: false,
      title: 'Flutter Login',
      theme: ThemeData(
        primarySwatch: Colors.amber,
      ),
      home: LoginPage(),
    );
  }
} Now we'll move ahead to the login page. // login_page.dart file
import 'package:flutter/material.dart';
import 'package:flutter_auth_buttons/flutter_auth_buttons.dart';
class LoginPage extends StatefulWidget {
  @override
  LoginPageState createState() => LoginPageState();
}
class LoginPageState extends State<LoginPage> {
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      body: Container(
        color: Colors.white,
        child: Center(
          child: Column(
            mainAxisSize: MainAxisSize.max,
            mainAxisAlignment: MainAxisAlignment.center,
            children: <Widget>[
              Image(
                image: AssetImage("assets/logo.png"),
                height: 150, 
                width: 150
              ),
              SizedBox(height: 50),
              GoogleSignInButton(
                onPressed: () {},
                darkMode: true
              ),
            ],
          ),
        ),
      ),
    );
  }
} Now we'll create a new file and name it as . Here we'll keep our code for authentication. auth.dart First, we'll import the packages required. // auth.dart
import 'package:firebase_auth/firebase_auth.dart';
import 'package:google_sign_in/google_sign_in.dart';
final FirebaseAuth _auth = FirebaseAuth.instance;
final GoogleSignIn googleSignIn = GoogleSignIn(); Here, we have created an instance of FirebaseAuth and GoogleSignIn. After creating an instance, we need methods as (to authenticate the user) and then (to just sign out from the current account). signIn signOut Let's create our methods in file. auth.dart // auth.dart
import 'package:firebase_auth/firebase_auth.dart';
import 'package:google_sign_in/google_sign_in.dart';
final FirebaseAuth _auth = FirebaseAuth.instance;
final GoogleSignIn googleSignIn = GoogleSignIn();
Future<String> signInWithGoogle() async {
  final GoogleSignInAccount googleSignInAccount = await googleSignIn.signIn();
  final GoogleSignInAuthentication googleSignInAuthentication =
      await googleSignInAccount.authentication;
  final AuthCredential credential = GoogleAuthProvider.getCredential(
    accessToken: googleSignInAuthentication.accessToken,
    idToken: googleSignInAuthentication.idToken,
  );
  final AuthResult authResult = await _auth.signInWithCredential(credential);
  final FirebaseUser user = authResult.user;
  assert(!user.isAnonymous);
  assert(await user.getIdToken() != null);
  final FirebaseUser currentUser = await _auth.currentUser();
  assert(user.uid == currentUser.uid);
  return 'signInWithGoogle succeeded: $user';
}
void signOutGoogle() async{
  await googleSignIn.signOut();
} We have created our functions but now we need to call our functions in our application to let the user authenticate. So let's call our function to work for us. We'll update our login page to call after clicking the sign-in button. signInWithGoogle() // login_page.dart file
class LoginPageState extends State<LoginPage> {
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      body: Container(
        color: Colors.white,
        child: Center(
          child: Column(
            mainAxisSize: MainAxisSize.max,
            mainAxisAlignment: MainAxisAlignment.center,
            children: <Widget>[
              Image(
                image: AssetImage("assets/logo.png"),
                height: 150, 
                width: 150
              ),
              SizedBox(height: 50),
              GoogleSignInButton(
                onPressed: () {
                  signInWithGoogle().whenComplete(() {
                    Navigator.of(context).push(
                      MaterialPageRoute(
                        builder: (context) {
                        return WelcomeScreen();
                        },
                      ),
                    );
                  });
                },
                darkMode: true
              ),
            ],
          ),
        ),
      ),
    );
  }
} Here, once our sign-in is successful, we are redirecting the user to the . WelcomeScreen Build UI for WelcomeScreen To do this, run the following code: // welcome_screen.dart file
import 'package:flutter/material.dart';
class WelcomeScreen extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      body: Container(
        child: Text(
          "Welcome $name to Flutter",
           style: TextStyle(
             fontSize: 30,
             fontFamily: 'DancingScript',
             fontWeight: FontWeight.bold,
           ),
        ),
      ),
    );
  }
} Set Up a Firebase Project To create a new firebase project, go to the firebase console. Click to for creating a new project. Add Project Now, enter your project name and click continue. Follow the steps until the creation of the project. This will lead you to the Project Overview page and from here we'll be able to add firebase to our flutter app. For that, click on the Android icon and follow the steps required to create an android app. Here, you have to add the . For generating the SHA-1 key, just hover over the help (?) and click See this page. This will redirect you to the Authenticating Your Client page where you'll find commands to generate the SHA key. SHA-1 hash Then click on Register App. Next, download the google-services.json file and add it to your project-directory -> android -> app and click Next. In the third step, add the given code to the respective files. Once done, click Next and continue to console. Lastly, go to the Authentication Page -> Users tab and click on the Set up sign-in method. In Sign-in providers under the Sign-in methods tab, hover over Google provider and edit to enable Google sign-in. With this, we are done with the Google sign-in set up for our flutter app. The iOS setup is a little similar to this, but we are not going to implement it in our flutter app now. Still, you can implement it if you wish to run it on an iOS emulator or iOS mobile. To access user data such as name and email in our app, we need to update our auth file. import 'package:firebase_auth/firebase_auth.dart';
import 'package:google_sign_in/google_sign_in.dart';
final FirebaseAuth _auth = FirebaseAuth.instance;
final GoogleSignIn googleSignIn = GoogleSignIn();
String name;
String email;
String imageUrl;
Future<String> signInWithGoogle() async {
  final GoogleSignInAccount googleSignInAccount = await googleSignIn.signIn();
  final GoogleSignInAuthentication googleSignInAuthentication =
  await googleSignInAccount.authentication;
  final AuthCredential credential = GoogleAuthProvider.getCredential(
    accessToken: googleSignInAuthentication.accessToken,
    idToken: googleSignInAuthentication.idToken,
  );
  final AuthResult authResult = await _auth.signInWithCredential(credential);
  final FirebaseUser user = authResult.user;
  assert(user.email != null);
  assert(user.displayName != null);
  assert(user.photoUrl != null);
  name = user.displayName;
  email = user.email;
  imageUrl = user.photoUrl;
  if (name.contains(" ")) {
    name = name.substring(0, name.indexOf(" "));
  }
  assert(!user.isAnonymous);
  assert(await user.getIdToken() != null);
  final FirebaseUser currentUser = await _auth.currentUser();
  assert(user.uid == currentUser.uid);
  
  return 'Successfully loggedin: $user';
}
void signOutGoogle() async {
  await googleSignIn.signOut();
} Complete UI of WelcomeScreen Now we'll complete our UI of WelcomeScreen using the following code: // WelcomeScreen.dart file
import 'package:flutter/material.dart';
import 'auth.dart';
import 'login_page.dart';
class WelcomeScreen extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text('Flutter Example'),
      ),
      drawer: name != null ? Drawer(
        child: ListView(
          padding: EdgeInsets.zero,
            children: <Widget>[
              DrawerHeader(
                decoration: BoxDecoration(
                  color: Colors.amberAccent,
                ),
                child: Column(
                  children: <Widget>[
                    Padding(
                      padding: EdgeInsets.zero,
                      child: CircleAvatar(
                        backgroundImage: NetworkImage(
                          imageUrl,
                        ),
                      radius: 40,
                      backgroundColor: Colors.transparent,
                    ),
                  ),
                  SizedBox(height: 10),
                  Text(
                    name,
                    style: TextStyle(
                    fontSize: 20,
                    color: Colors.black,
                    fontWeight: FontWeight.bold),
                  ),
                  SizedBox(height: 5),
                  Text(
                    email,
                    style: TextStyle(
                      fontSize: 16,
                      color: Colors.black,
                      fontWeight: FontWeight.normal
                    ),
                  ),
                ],
              ),
            ),
            ListTile(
              leading: Icon(
              Icons.exit_to_app,
              color: Colors.red,
            ),
            title: Text(
              "Sign Out",
              style: TextStyle(
                fontSize: 18,
                color: Colors.red,
              ),
            ),
            onTap: () {
              signOutGoogle();
              Navigator.of(context).pushAndRemoveUntil(
                MaterialPageRoute(builder: (context) {
                  return LoginPage();
                }), ModalRoute.withName('/'));
              }),
            ],
          ),
        ): null,
        body: Container(
          child: Center(
            child: Column(
              mainAxisAlignment: MainAxisAlignment.center,
              mainAxisSize: MainAxisSize.max,
              children: <Widget>[
                FlutterLogo(size: 100),
                SizedBox(height: 20),
                Text(
                  "Welcome $name to Flutter",
                  style: TextStyle(
                    fontSize: 30,
                    fontFamily: 'DancingScript',
                    fontWeight: FontWeight.bold,
                  ),
                ),
              ],
            ),
          ),
        ),
      );
    }
} Conclusion Once done, let's run our app to do authentication using Google. You can find the code on my . GitHub Repository I hope this is helpful.

Set up a Flutter app and Implement Google Sign-In Using Firebase

How To Connect AWS Amplify with React Native Application

React Router Flow & Adding TOTP MFA Authentication In , we looked at how to wire up a React application with with an identity provider. In this part, we will use to add a routing and auth flow that will only allow logged in users to view the application while redirecting users who are not logged in back to the sign up / sign in page. Part 1 React Router In Part 1 we used with to set up our authentication. The techniques we will be covering here in part two will work with any authentication provider and are not limited to Amazon Cognito. Amazon Cognito AWS Amplify We will continue from Part 1 with a React project that has an authentication service already added and continue from there. Our application will have a main route which hold forms for both user sign up and sign in. Authenticator The application routes that need user authentication before being allowed to view will be (taken from the ). private route components React Router documentation The component we will end up using will look like this: PrivateRoute The private route will either allow the user to continue to the component, or redirect to auth if the user is not logged in. Here is how this will look once we implement it: The that we will be rendering will not need to know anything about what is going on with Authentication, all of this logic will be handled by the component. component PrivateRoute Let’s put this all together now into a working application. To see the final project code, check out repo this Creating additional project files First, let’s go ahead and create all of the files we will be needing in the next steps. touch Authenticator.js SignIn.js SignUp.js Router.js Home.js Header.js Now that these files are created, we will walk through them one by one implementing the authentication flow. Authenticator component We will be needing a component to handle both the Sign In & Sign up states of the app, . Authenticator.js When the user is not logged in, we will automatically redirect them to this component. This component will have a state that will be toggled to either show the or component that we will be creating shortly. showSignIn SignIn SignUp This is a pretty basic component that allows us to encapsulate both the Sign In and Sign Up forms in one route. This could also be broken up into two different routes, but I’ve found this approach to be a little nicer and more concise. Header.js Let’s create a basic reusable header with some styling that we can use as the application header. Protected Routes Next, we need to create a couple of routes that we will be using as generic protected routes. We’ll encapsulate these two routes in a single file, . Home.js These routes will only be available when the user is logged in. You will notice that we do not have any logic here that looks to see if the user is logged in, all of the logic will be handled by the router implementation. Both of the two routes we create are wrapped with the higher order component that we import from React Router. This is because we want to have access to the history prop from React Router in case we need it, which we will if we want to programmatically send the user to another route. withRouter — Home is a component with only two real pieces of functionality: a method that calls the method to get and store the user’s so we will be able to greet the user by name, and a component that links us to another route. Home componentDidMount Auth.currentUserInfo username Link — This is a basic component that only has a single piece of functionality, a method that calls the method. When the user successfully signs out, we also reroute the user to the route that we will create in just a moment. Route1 signOut Auth.signOut auth SignIn.js We looked briefly at this Sign In functionality in part 1, and here we will be implementing almost exactly the same functionality with one difference: We will hide the confirmation code screen until the user successfully signs in with username and password. We do this to provide a better user experience. This component uses two main methods of the class: and . Auth signIn signUp If is successful, we redirect them to the route using the history prop that was provided to us by from React Router. signIn Home withRouter history.push('/') If the API call is unsuccessful, we log out the error message. SignUp.js We also implemented this exact functionality in Part 1 as far as signing up and confirming the sign up of a user. The main difference here is that we are also adding some logic / UI to only show the confirmation form if fHomethe user has successfully signed up. Router.js Finally, we have made our way to the bread and butter of the functionality of this application, the router. There is quite a bit of important functionality going on in this file, so we’ll walk through it in depth. — The main import to note here is the component. Redirect will navigate the user to a new location, & will override the current location in the history stack like server-side redirects do. We’ll look at how we implement this in just a second. We also import the three main routes that our application will consist of: , , and . Imports Redirect Authenticator Home Route1 — This component will serve as our container for any routes that we want to be protected and only accessed if the user is logged in. PrivateRoute We are initializing a couple of pieces of state in this component: & which are both set to false. loaded isAuthenticated — When the component is first loaded we want to check if the user is currently logged in, and if so allow them to see the route, and if not redirect them to the sign up page. We do this by calling the method. componentDidMount authenticate — authenticate calls the method which will only return successfully if there is a logged in user. If there is a user, we update the state to true and the state to true. If there is no currently authenticated user, we redirect the user to the Authenticator component by calling . authenticate Auth.currentAuthenticatedUser loaded isAuthenticated this.props.history.push('/auth') — We also create a listener to call a function whenever a route changes by calling . Whenever the route changes, this function will fire and we will check if the user is currently logged in. If they are, we allow them to continue and don’t do anything. If they are not logged in, the promise will catch. componentDidMount this.props.history.listen — In , we return a component from React Router. With the component you have three options to render a component, one of them being the prop, which we are using. In the prop, we check to see if the user is currently authenticated, and if so renders the component passed in as the prop, and if not redirects them to the route. render render Route Route **render** **render** component auth — The component defines the routes using either a component for unprotected routes, or a component for protected routes. Routes Routes Route PrivateRoute App.js We are done writing the code to implement the Auth functionality and we can now clean up the App.js file to use the Header and Router we created That’s it, you should be able to run the application and have complete sign up / sign in functionality! About TOTP (time-based one-time passwords) is quickly becoming the MFA of choice for many companies that place a high value on security as it is more secure than MFA with email. TOTP TOTP uses apps like Authy, Google Authenticator & Duo to implement temporary access tokens that expire every 30 to 60 seconds. Cognito and now AWS Amplify have added this feature, so let’s take a quick look at how we might extend our application to implement this. The first thing to keep in mind when thinking about TOTP is that you should not make it the MFA type of choice unless the user specifies that they would like to use it. This is because the adoption of TOTP is still relatively small. The flow should be like this: User signs up, default MFA type is email User signs in, and somewhere in the application (usually in some type of settings area) we give them the option to enable TOTP. User enables TOTP, show them QR code, and enable TOTP with their app of choice Offer the option to change MFA type back to email if the user would like to do so. In our existing app, one place that we could place this functionality in order to demo it could be in the component. Once the user is signed in we will give them the option to add TOTP in this route. Home The way you initially set up TOTP is with the method. This returns a promise that we will use to create a QR Code. Auth.setupTOTP Auth.setupTOTP(user).then(code => /* create qrcode */ ) Adding TOTP to the existing app We will use the qrcode.react package to show a QR Code: yarn add qrcode.react Home.js In , import QRCode: Home.js // somewhere below existing importsimport QRCode from 'qrcode.react' Because needs access to the object, we will need to get the object by calling in componentDidMount and adding it to the state: setupTOTP user user Auth.currentAuthenticatedUser componentDidMount() { // rest of existing code omitted} Auth.currentAuthenticatedUser().then(user => this.setState({ user })) Next, we can add an method that will set the QRCode that we will be using in the QRCode component: addTTOP addTTOP = () => {Auth.setupTOTP(this.state.user).then(code => {const authCode = "otpauth://totp/AWSCognito:" + this.state.user.username + "?secret=" + code + "&issuer=AWSCognito";this.setState({ qrCode: authCode })});} To learn more about how we created the uri and the API behind provisioning a TOTP token, check out link. authCode this We also want to set the preferred MFA type to TOTP for the user. We can do this with the method. Let’s create a new class method that will capture the challenge answer from the user (we will create the input for challengeAnswer in just a moment) and change the preferred MFA type: Auth.setPreferredMFA setPreferredMFA = (authType) => {Auth.verifyTotpToken(this.state.user,this.state.challengeAnswer).then(() => {Auth.setPreferredMFA(this.state.user, authType).then(data => console.log('MFA update success: ', data)).catch(err => console.log('MFA update error: ', err))})} Now, we can add a couple of lines showing the QRCode if it is defined, adding a form to input the TOTP code, and a couple of buttons to attach to the new methods: render() {<div>// previous code omitted<buttononClick={this.addTTOP}style={{ border: '1px solid #ddd', width: 125 }}><p>Add TOTP</p></button>{(this.state.qrCode !== '') && (<div><QRCode value={this.state.qrCode} /></div>)}<br /><buttononClick={() => this.setPreferredMFA('TOTP')}style={{ border: '1px solid #ddd', width: 125 }}><p>Prefer TOTP</p></button><br /><inputplaceholder='TOTP Code'onChange={e => this.setState({challengeAnswer: e.target.value})}style={{ border: '1px solid #ddd', height: 35 }}/></div>} SignIn.js Now, in the confirmSignIn method, we need to update the method to use the type of MFA that is attached to the current user. This information is available in the user object as , which we will pass in as the third argument to : signIn user.challengename Auth.confirmSignIn confirmSignIn = () => {const { history } = this.propsAuth.confirmSignIn(this.state.user, this.state.authCode, )// rest of code omitted} this.state.user.challengeName Now, when we login we can click Add TOTP, scan the QR code and switch our authentication type to TOTP. When we log out, we should now have to use the TOTP provider we used to scan the QR code in order to get back in. To see the final project code, check out repo. this My Name is . I am a Developer Advocate at working with projects like and , and the founder of . Nader Dabit AWS Mobile AppSync AWS Amplify React Native Training Currently I’m specializing in GraphQL with as well as authentication & authorization for applications, so if this interests you follow me for more future info & tutorials! AWS AppSync JavaScript If you enjoyed this article, and share it! Thanks for your time. please clap n number of times Images courtesy of Amazon Web Services, Inc

React Authentication in Depth Part 2

How to implement world 2 factor authentication (both email and TOTP) using , React Router, and Amazon Cognito React To view Part 2, implementing React Router & TOTP, click . here In this post, we’ll walk through how to implement real world user sign up and sign in with two factor authentication along with a routing and an authentication flow in a React web application. When the user is logged out, we will protect certain routes from being accessed and redirect them to sign in, and allow access these protected routes only when a user is signed in. We also want to check on route change whether the user is currently signed in, and if not redirect them to the sign in / sign up route. still The tools we will be using are Create React App, Glamor for styling, React Router for routing, Amazon Cognito for authentication, and for interacting with AWS services. AWS Amplify This is part 1 of a 2 part series and follows that was very well received. a similar post I did on React Native Authentication will show how to set up the authentication provider and methods that will interact with our provider, signing up and signing in a user. Part 1 will go into how to add React Router and implement a real world authentication flow, including protected routes, signing out, , and more. Part 2 TOTP Getting Started Creating the project and installing dependencies The first thing we will do is create our new project, install our dependencies, and set up the Authentication provider. First, let’s go ahead and create our React project using , and change into the new project’s directory: Create React App create-react-app react-authcd react-auth Next, let’s install React Router and using either npm or yarn: Glamor yarn add react-router-dom glamor or npm i react-router-dom glamor --save Adding the identity provider You can use any identity provider you would like, but we will be using along with the library and the to autogenerate the resources for us from the command line. Amazon Cognito AWS Amplify JavaScript AWS Amplify CLI If not already installed, go ahead and install the AWS Amplify CLI: npm i -g @aws-amplify/cli Next configure the CLI with AWS IAM credentials: amplify configure Click for a video walkthrough of how to create credentials and configure the CLI here Now, we’ll create a new project (choose the default for all options, or choose a name for your project if you would like) amplify init # Here you can choose your text editor of choice & the default for all other options. This creates a new Amplify project, as well as an file in the src directory. aws-exports.js Next we’ll add authentication (Amazon Cognito) and deploy the new configuration: amplify add auth # choose Y when asked if we would like to use the default configuration amplify push will enable Amazon Cognito in our project with default settings, including 2 factor authentication on signup with email (we will add TOTP later). amplify add auth Adding and testing basic user sign up Let’s go ahead and add basic user sign up form to our app to see if we can go ahead and sign up a user. We will be working with the class from AWS Amplify to interact with Amazon Cognito. Auth has quite a few different methods allowing everything from user sign up & sign in to changing and retrieving passwords and everything in between. Auth The main methods that we will be using are the following: — signs up a new user signUp signUp(username: string, password: string, attributes?: object) — submits 2 factor authentication for new user sign up confirmSignUp confirmSignUp(username: string, authenticationCode: string) — signs in an existing user signIn signIn(username: string, password: string) Now, let’s wire this up! The first thing we need to do is configure AWS Amplify at the root of our project, : src/index.js We will begin implementing authorization by allowing users to sign up. Let’s create a new component called , & place it in the src directory. Here, we will create a basic form that allows users to sign up: SignUp.js Next, let’s add some state: We’ve added the items we need to create a user and allow two factor authentication. We will need to also create inputs that will allow us to capture the user information as well as the authorization code. When the user signs up using the method, they will receive an authorization code via email, and will need to input this value into the form and we will then confirm that this code is correct by calling : signUp confirmSignUp Let’s now create the inputs, buttons, and the method that will record the input into our state: onChange Now we’ve created our UI, and we now only need to do one thing: call the Auth methods to sign up and confirm our user, so let’s add these within a couple of class methods now: Finally, we’ll import and use this component in : App.js Now, let’s try this out. You should be able to sign up, get an email with the authorization code, then input the code, and get a confirmation in your console when the user is created. Where is this user data now? We can see this in our console. To check this out, go to dashboard, click on “Manage your User Pools”, and then choose the name of your application, and click “Users and Settings”. There, you can view a list of users that have signed up for your app. Amazon Cognito Now, we can sign the user in! The sign in process is very similar to sign up. We capture the user’s username and password and call , which will sign the user in if successful: Auth.signIn(username, password) signIn() {Auth.signIn(this.state.username, this.state.password).then(user => console.log('user:', user)).catch(err => console.log('error signing in! :', err))} This code works, but we will continue by implementing proper user sign in in part 2 when we add routes to our app, but feel free to try it out and see if you can get it working before you see my implementation in Part 2. If we wanted to access the user data in the above response, we could get it from which would look like this: user.signInUserSession.idToken.payload There are multiple ways of getting this data though at any time once the user is logged in, including . For the full Auth API, click . Auth.currentAuthenticatedUser() here Once the user is logged in, their session is persisted in by Amplify until they call the method. So the user can leave the page, come back, and still be logged in! localStorage Auth.signOut In part two, we will continue by adding routing and styling as well as TOTP so you can work with Google Authenticator or your TOTP provider of choice vs SMS! My Name is . I am a Developer Advocate at working with projects like and , and the founder of . Nader Dabit AWS Mobile AppSync Amplify React Native Training Currently I’m specializing in GraphQL with AWS AppSync as well as authentication & authorization for JavaScript applications, so if this interests you follow me for more future info & tutorials! If you enjoyed this article, and share it! Thanks for your time. please clap n number of times

React Authentication in Depth

What is doing is brilliant. They simplified a customizable, distributed, non-relational database to the point where front end developers can build a viable without needing to invest in backend resources. This convenience can save developers valuable set-up time, but be warned that the basic implementation of firebase is not the answer for projects. firebase prototype right all your project requires a relational database and continuity to users, then you should use an SQL database to avoid the cost and embarrassment of trying to make those changes without affecting user experience. There are ways to customize data-structures , but mastering these tools is outside of the scope of this post. If here all you need is to keep track of users, basic aggregated information, or a single table of data, then using firebase is a great option. OAuth, WebSockets, free CDN, free hosting, and large enough limits that it only costs you once you have enough users to justify real investment. If As you begin to use firebase, you will note that is actually the website for the old, no-longer-viable firebase application. Seeing as google still owns firebase, this is a head scratcher to me. If you spend anytime digging through those old docs before realizing you are in the wrong place, you will understand my confusion and frustration. The link you want to save is actually . https://www.firebase.com/ https://firebase.google.com/ Initiating firebase in your project is as simple as creating a firebase.js file, instantiating firebase, and exporting that instantiation of the firebase database for use in your application. Firebase provides simple and secure OAuth with several options for providers. You just need to enable the sign in method you want to use and follow the steps for registering your application with that provider. Sign-In Providers with Firebase Here is an example of the code, including the exporting of the database and login/logout methods. 'use strict';import firebase from 'firebase'; const config = {apiKey: '##############',authDomain: 'turing-fridays.firebaseapp.com',databaseURL: ' ,storageBucket: '###########',messagingSenderId: '#########'};firebase.initializeApp(config); https://turing-fridays.firebaseio.com' const auth = firebase.auth();const provider = new firebase.auth.GithubAuthProvider(); export default firebase;export const signIn = () => auth.signInWithPopup(provider);export const signOut = () => auth.signOut(); In your application, you can now use firebase and access the user object. In an on-load function (I am using react’s ComponentDidMount), firebase will check if a user has an active authentication session. If so, I can set that user object aside for later use. If not, I can show a login screen. firebase.auth().onAuthStateChanged((newUser) => {this.setState({ user: newUser });}); You can also create a database reference object in your firebase.js file, export that, and have access to adding, updating, and deleting database objects from your application. export const reference = firebase.database().ref('messages'); Later in my app, I can use that reference: let message = { message: title.value }; reference.push(message);reference.update This is all the code you need to create a basic app using a central data-store and OAuth from firebase. You can go one step further by subscribing your app to firebase data, so as updates occur on the server they are proactively pushed to users. To do this, we can subscribe to a firebase ‘value’ event listener which triggers on a value change in firebase. I put this in my on-load function as well, directly beneath where I resolve the user. reference.limitToLast(100).on('value', (snapshot) => {const messages = snapshot.val() || {};this.setState({messages: map(messages, (val, key) => extend(val, { key }))});}); Firebase solves problems like OAuth, accessing that user data, WebSockets, and basic database features which can speed up the development cycle of basic apps and prototypes. As I mentioned initially, each project has unique needs. Its important to pick the technical stack which makes sense for your project rather than the technical stack which is easiest to the developer. Firebase is a great solution for proof of concepts and basic databasing needs, but is not a long term solution for most companies. you have a viable business it’s cheaper for you to use a custom backend. you don’t know if you have a viable business, then firebase is a simple answer to quickly get a product to market for testing. If If

Stories, News & Mentions about AUTHSIGNAL

Authsignal’s Stories on HackerNoon