1. Choosing the Right Partition Key
   The partition key is the most important aspect of DynamoDB performance, as it determines how data is distributed across partitions. To ensure optimal performance, it’s important to choose a partition key that is both unique and evenly distributed. In real-time use cases, it’s also important to consider the potential for data growth and ensure that the partition key will continue to be evenly distributed as the data set grows.
   For example, let’s say you have a real-time e-commerce platform and you want to store customer data in DynamoDB. A good partition key for this use case would be the customer’s email address, as it is unique and will provide a good distribution of data across partitions.
2. Provisioning Adequate Read and Write Capacity Units
   DynamoDB performance is heavily dependent on the number of read and write capacity units that are provisioned. To ensure fast and consistent performance, it’s important to provision enough capacity to handle the expected traffic and to regularly monitor usage patterns to ensure that capacity remains sufficient. In real-time use cases, it’s especially important to ensure that there is sufficient capacity to handle spikes in traffic.
   For example, during a flash sale on your e-commerce platform, there may be a sudden increase in traffic. To ensure that your DynamoDB table can handle this spike in traffic, you should provision additional read and write capacity units.
3. Using Secondary Indexes Wisely
   DynamoDB supports secondary indexes, which can greatly improve query performance. However, it’s important to use them wisely, as they can also increase costs and slow performance if used improperly. In real-time use cases, secondary indexes can be especially useful for optimizing query performance and ensuring fast response times.
   For example, on your e-commerce platform, you may want to be able to retrieve customer data based on their purchase history. To do this efficiently, you can create a secondary index on the purchase history field and use it to quickly retrieve relevant customer data.
4. Avoiding Overuse of Scans
   DynamoDB provides the ability to scan tables, but overusing scans can result in slow performance and increased costs. To avoid this, it’s important to understand when and how to use scans effectively. In real-time use cases, it’s often more efficient to use queries or secondary indexes to retrieve data, as scans can take a long time to complete and may not provide the level of performance that is needed.
   For example, let’s say you want to retrieve all customer data from your e-commerce platform. Instead of using a scan, which would be slow and inefficient, you can use a query with the partition key and sort key to retrieve the data more quickly and efficiently.
5. Batch Writing and Reading
   DynamoDB provides the ability to batch write and read items, which can greatly improve performance and reduce costs. In real-time use cases, it’s important to take advantage of batch operations whenever possible to ensure fast and efficient data access.
   For example, when processing customer orders on your e-commerce platform, you can use batch write operations to efficiently store multiple orders.

In conclusion, by choosing the right partition key, provisioning adequate read and write capacity units, using secondary indexes wisely, avoiding overuse of scans, and batch writing and reading, you can ensure that your real-time applications are fast, efficient, and reliable. By taking these steps, you can fully leverage the capabilities of Amazon DynamoDB and achieve the best possible performance and results for your real-time applications.

Best Practices for Amazon DynamoDB in Real-Time Applications was originally published in VectoScalar on Medium, where people are continuing the conversation by highlighting and responding to this story.

‘closure’ is the combination of a function bundled together with references to its surrounding state (Lexical Environment).

Before we move any further , few things to be aware in order to understand Closures are :-

1- Execution Context

2- Call Stack

3- Scope Chain

The Execution Context.

There are two types of Execution Context :-

1- Global Execution Context (Global EC )

2- Local Execution Context (Local EC )

const name = 'Anup Verma'
function callMe(a,b){
let x = 5;
  console.log('params :: ',a,b,'name :: ',name ,'x :: ',x);
}
callMe(2,3);

Global and Local E.C for the above snippet would look like:-

NOTE :

The Local E.C of a function contains information regarding its “Arguments”, “this” keyword and “variables” declared inside it.

But , in case of an Arrow Function and Anonymous function , ‘this’ keyword and ‘Arguments’ are NOT present.

The Call Stack.

The place where all the Magic Happens.

The call stack is where each and every execution context is placed in a form of a stack and is executed and “popped out” once it is done executing.

Consider the following example.

const counting = function(){
  let count = 0; 
  return function(){
      count++;
      console.log('count :: ', count);
  }
}
const counter = counting();

counter(); //count :: 1
counter(); //count :: 2
counter(); //count :: 3

The Call Stack and the Execution contexts working together.

As you can see from the bottom two images , even though the counting function is no more present in the call stack , then too the “counter function” has the access to the variables in the Environment in which it was created
(i.e counting()).

Closures.

Any function always has the access to the variable environments of the Execution Context in which the function was created , Even after that Execution context is Gone.

“Counter()” function was born in the Execution context of ‘Counting()’ function , hence this ‘Counter()’ function will get access to the variable environment (i.e “count” )

WHAT is Closure ?

Closure is this Variable Environment Attached to the function , exactly as it was at the time and place when the function was created and the scope chain is ‘Preserved’ through this closure.

Thanks to this ‘closure’ a function does not lose connection to variables that existed at the function’s birth place.

Although this is one of those topics which people tend to forget , here are some intuitive examples/analogies to help you understand what closures are all about.

Informal Definition(s)

A closure gives a function ‘Access’ to all the variables of its parent function , even after the parent function has returned. The function keeps a “reference” to its outer SCOPE , which “preserves” the scope chain throughout.

It’s like a person who doesn’t lose connection to their HOME-TOWN , in this analogy,
Person -> Function
Home town -> Parent Scope

PERSON — — —> Connection — — —> HOME-TOWN( — — →Variables)

And the person does not lose connection to the variables stored in its parent scope i.e home town.

CONCLUSION

We don’t have to create “closures” Manually, this is something JavaScript does completely Automatically, also there is no way we can access these ‘closed-over’ variables explicitly i.e because “A Closure is NOT a tangible JavaScript Object.”

Closer look at Closures. was originally published in VectoScalar on Medium, where people are continuing the conversation by highlighting and responding to this story.

We can use the sendRawEmail method of SES to send emails with attachments. This method accepts only Multipurpose Internet Mail Extensions standard (MIME) type data as email content. Creating a MIME message yourself is a tedious task . But we can do this easily using mailcomposer package.

In this article we will see how we can send email with excel file as an attachment using mailcomposer.

Prerequisite for sending email using SES:

We can only send emails from and to verified email addresses or domains. We can verify any email address on AWS SES console by following the steps below:

STEP 1: Go to the AWS SES console and click Verified identities option.

STEP 2: Click on Create Identity option to create identity of your email address.

STEP 3: Select Email Address option in identity type to verify a particular email address . Then enter your email address and click on Create identity.

Step 4: Now click on the verification link sent on your email address to complete verification. Now you can see your email address is going to be displayed with identity status as ‘verified’ under verified identities on console.

Setup nodeJs app:

Now we will set up our node application

Run following commands in terminal:

npm init -y

npm i aws-sdk

npm i xlsx

npm i mailcomposer

aws-sdk — for calling SES sendRawEmail function

xlsx — for converting array of objects into excel file buffer

mailcomposer -for creating a MIME message for email

Create index.js file . This will be the main file where we write all our code.

Paste the below code in index.js file.

(async()=>{

const AWS = require('aws-sdk');
const XLSX = require('xlsx');
const mailcomposer= require('mailcomposer');

//create ses client with your AWS account access key id and secret access key
const sesClient = new AWS.SES({
    accessKeyId: YOUR_ACCESS_KEY_ID,
    secretAccessKey: YOUR_SECRET_ACCESS_KEY,
    region: "ap-south-1"
});

/**
    * To create excel file buffer from array of objects
    * @param {*} data    : [[], []] : For multiple sheets    [[]]: for single sheet 
    * @param {*} sheetNames : ['sheet1', 'sheet2'] names of sheet
    * @returns 
*/
const createExcelFileBufferUsingXlsx = (data,sheetNames)=>{
    
    const wb = XLSX.utils.book_new();                    
    if(Array.isArray(data) && data.length && Array.isArray(data[0])) {
        data.forEach((dataArray, idx) => {
            const ws = XLSX.utils.json_to_sheet(dataArray);            
            XLSX.utils.book_append_sheet(wb, ws, sheetNames[idx]);  
        })
    } 

    //creating buffer
    const wbOpts = { bookType: "xlsx", type: "buffer" };
    let fileBufferdata = XLSX.write(wb, wbOpts);

    console.info('fileBufferdata::', fileBufferdata);

    return fileBufferdata;
    
}

/**
 * To send email with attachment using mailcomposer
 * @param {*} sourceEmail 
 * @param {*} receiverEmail 
 * @param {*} fileBufferdata 
 * @returns 
 */
const sendRawEmailUsingMailcompose = async(sourceEmail,receiverEmail,fileBufferdata)=>{
    let sendRawEmailPromise ={};

    //creating object with mentioned options
    const mail = mailcomposer({
        from: sourceEmail,        //source email address
        to: [receiverEmail],      //array containing receiver’s email addresses
        subject:'Test mail',      //subject of email
        text: 'PFA excel file',   //plain text to display in mail body
        attachments: [{           //array of attachment object having below details
            filename: "test.xlsx",   //name of attachment
            content: fileBufferdata.toString('base64').replace(/([^\0]{76})/g, "$1\n"), // buffered file data as base64 encoded
            encoding: 'base64', //encoding type
        }],
      });

    console.info("mail", mail);
    
    return new Promise((resolve, reject) => {
        //building message to send in email
        mail.build((err, message) => {
          if (err) {
            reject(`Error sending raw email: ${err}`);
          }
          console.info("inside mail build");

          //sending email after attaching excel file
            sendRawEmailPromise = sesClient.sendRawEmail({RawMessage: {Data: message}}).promise();
            resolve(sendRawEmailPromise);
        });
        
    });

    
}

const sendSesEmail=async()=> {
    try {
       
        const sourceEmail= "abc@gmail.com";
        const receiverEmail= "xyz@gmail.com";

        const data= [
            {name:"user1", roll_no:1},
            {name:"user2", roll_no:2}
        ]

        console.info("sourceEmail, receiverEmail", sourceEmail, receiverEmail);
        console.info("data", data);

        const fileBufferdata= createExcelFileBufferUsingXlsx([data],["sheet1"]);
        
        const sesResponse =await sendRawEmailUsingMailcompose(sourceEmail, receiverEmail,fileBufferdata);
         
        console.info("sesResponse",sesResponse);
    } catch (error) {
        console.error(error);
    }
}

await sendSesEmail()
})();

Code Flow:

1. Firstly we have imported all required packages.
2. Then we have created an object of the SES service using aws-sdk. Here replace YOUR_ACCESS_KEY_ID and YOUR_SECRET_ACCESS_KEY with your aws account key id and secret access key in code.
3. sendSesEmail is our main function where all are processing will be done.
4. In this function we have first declared sourceEmail(verified email address from which we will send email) and receiverEmail(verified email address to which we will send email).
5. Then we have defined array of object which we will show in excel file.
6. After that we have called createExcelFileBufferUsingXlsx function which is using the xlsx package to convert our array of objects into an excel file buffer. We have passed array of objects and sheet name in argument.
7. In this function, json_to_sheet() — will convert array of objects into worksheet, book_new() — will create a new workbook in a sheet , book_append_sheet() — will append the worksheet to the workbook with sheet name passed in arguments (i.e sheet1) and write() — will convert the created excel file into buffer.
8. Then we have passed buffer data, source and receiver email in sendRawEmailUsingMailcomposer function. This function is where we will create our email body using mailcomposer and call the sesRawEmail function to send email.
9. Here we have first created a object of mailcomposer with options.
10. Then we built a mail message using the build function of mailcomposer and passed that message to the sendRawEmail function of SES service which will send the email.

That’s it, now we can run above code using node index.js command. This will send the email with the attached excel file to the receiver. You can see the email sent using the above code in below images.

Sending SES Email With An Attachment Using Mailcomposer was originally published in VectoScalar on Medium, where people are continuing the conversation by highlighting and responding to this story.

Setting Up a Recursive AWS Lambda Function

To set up a recursive AWS Lambda function, you’ll need to follow these steps:

1. Create a new Lambda function or use an existing one
2. Configure the function to trigger itself as an event
3. Include a termination condition to stop the recursion

Let’s take a closer look at each of these steps.

Step 1: Create a New Lambda Function

To create a new Lambda function, log in to the AWS Management Console and navigate to the Lambda dashboard. From there, click the “Create function” button to start the function creation process.

Follow the prompts to choose a runtime and select a blueprint (if desired). For the purposes of this article, we’ll assume you’re using Node.js as the runtime.

Step 2: Configure the Function to Trigger Itself

Next, you’ll need to configure the function to trigger itself as an event. To do this, you’ll need to create a new trigger and specify the function as the target.

For example, let’s say you want the function to trigger itself every time a new item is added to an Amazon DynamoDB table. You would create a DynamoDB trigger and specify your function as the target.

Step 3: Include a Termination Condition

It’s important to include a termination condition in your recursive Lambda function, as this will prevent the function from triggering itself indefinitely.
For example, the following code demonstrates how to implement a termination condition in a Node.js recursive Lambda function

const AWS = require('aws-sdk');

exports.handler = async (event, context, callback) => {
  try {
    // Initialize the DynamoDB client
    const dynamoDb = new AWS.DynamoDB.DocumentClient();

    // Define the parameters for the query
    const params = {
      TableName: 'records',
      Limit: 100,
      ExclusiveStartKey: event.lastEvaluatedKey
    };

    // Query the DynamoDB table for the next batch of records
    const data = await dynamoDb.scan(params).promise();

    // Process the records
    const processedRecords = data.Items.map(processRecord);

    // Check if there are more records to process
    if (!data.LastEvaluatedKey) {
      // If there are no more records, return the processed records
      return callback(null, processedRecords);
    }

    // Set the last evaluated key for the next iteration
    event.lastEvaluatedKey = data.LastEvaluatedKey;

    // Trigger the function again, passing the updated event data
    const result = await context.function.invoke(event);

    // Return the result
    callback(null, [...processedRecords, ...result]);
  } catch (error){
    console.log("error",error)
   }

This function queries a DynamoDB table named “records” in chunks of 100 items at a time, using the scan operation and the Limit and ExclusiveStartKey parameters. It processes the records using the processRecord function and stores the results in an array. The function triggers itself until there are no more records to process, as indicated by the absence of a LastEvaluatedKey in the query result. The function returns the processed records when there are no more records to process.

Handling Errors and Exceptions in Recursive Lambda Functions

As with any type of software, it’s important to handle errors and exceptions in your recursive Lambda functions to ensure that they run smoothly and don’t fail unexpectedly.

Here are a few best practices for handling errors and exceptions in recursive Lambda functions:

1. Use try/catch blocks to handle exceptions that may occur within the function body
2. Use the function callback to return errors or exceptions to the caller
3. Consider setting up an error reporting system, such as AWS CloudWatch

Summary

Setting up a recursive AWS Lambda function involves creating a new function, configuring the function to trigger itself as an event, and including a termination condition to stop the recursion. By following these steps and properly handling errors and exceptions, you can use recursive Lambda functions to process large datasets and perform complex operations in a cost-effective, scalable, and serverless way.

Recursive AWS Lambda Functions: An Overview was originally published in VectoScalar on Medium, where people are continuing the conversation by highlighting and responding to this story.

I’m using the K-means clustering algorithm to create a recommendation engine for an ecommerce application. As a result, I needed the Scikit-learn and pandas libraries, which increased the size of my deployment package beyond the AWS lambda package limits.

During the deployment of my stack I got this error:

Deployment Package Limits

When developing a serverless application, you should keep some soft and hard limits in mind for each AWS service. These restrictions are intended to protect both the customer and the provider from unintentional use. In addition, guardrails are provided to ensure that best practises are followed.
AWS Lambda has a hard limit of 50MB for compressed deployment packages and a hard limit of 250MB for uncompressed deployment packages.

How to deal with size limits when we are using libraries like scikit-learn, pandas etc?

To help with managing potentially large dependencies, functionality for compressing libraries is available (for example: pandas, numpy, scipy, and scikit-learn). To decompress them, you’ll need to make some changes to your code.

Firstly add the following configuration to your serverless.yml file.

custom:
  pythonRequirements:
    zip: true

Then add this piece of code to the beginning of our handler module in your handler.py file.

try:
  import unzip_requirements
except ImportError:
  pass

Note: Handler function in handler.py is the entry point of any lambda function. It is the first function that is executed when your lambda function is invoked.

These modification in your code resolve your issue of package size limit exceeded.

A Lambda Layer is another option for dealing with large dependencies.

For this include the layer option in your configuration in serverless.yml file.

custom:
  pythonRequirements:
    layer: true

A layer will be automatically produced after the requirements are compressed into a zip file. The reference must be added to the functions that will use the layer.

Add this reference to the function define in serverless.yml file.

functions:
  myfunction:
    handler: handler.myfunctions
    layers:
      - Ref: PythonRequirementsLambdaLayer

You can also add this custom configuration into your layer in serveless.yml file :

custom:
  pythonRequirements:
    layer:
      name: ${self:provider.stage}-layerName
      description: lambda layer for python requirements
      compatibleRuntimes:
        - python3.8
      licenseInfo: GPLv3
      allowedAccounts:
        - '*'

Key Note: We can also use theImage package type, which has a much larger file size limitation but it requires more configuration as compared to above mentioned methods.

We all know that when we build a machine learning model the algorithms which we use consist of high packages libraries. So, to overcome the lambda package size limit while deploying these model we can use the above approaches.

Keep Learning Keep Growing 🥂

How to fix the lambda package size limit exceeded error caused by python libraries was originally published in VectoScalar on Medium, where people are continuing the conversation by highlighting and responding to this story.

The React Native Cashfree SDK

Cashfree provides a dedicated SDK for React Native. The Cashfree React Native SDK allows us to integrate Cashfree Payment Gateway into our application and start collecting payments from our customers. The React Native SDK has been designed to minimise the complexity of handling and integrating payments in your React Native project.

It’s very easy to integrate Cashfree payments into our React Native Application and can be done in few steps.

Before we get to the SDK Integration first we have to create a free Cashfree account.

Create Account.

To create a account go to the Cashfree Payments website and click Create Account and fill all the required fields.
Once the account has been created we will have the access to the test and production environments in which we can simulate multiple features of the Cashfree Payments.

After Creating account you will have the option to activate your account you can choose to activate it later and explore the test environment.
Note: To use the production environment we have to activate our account.

Once the account is created then Integration can be done in 4 easy steps:

1. Installing the SDK

The SDK can be installed easily just navigate to your project folder and run “npm install react-native-cashfree-pg-sdk” command.
Once the installation is complete then open “info.plist” file inside project’s ios folder and add the following code.

<key>LSApplicationCategoryType</key>
<string></string>
<key>LSApplicationQueriesSchemes</key>
<array>
<string>phonepe</string>
<string>tez</string>
<string>paytmmp</string>
<string>bhim</string>
</array>

After adding the above code update pods by running following command
cd ios
pod install — repo-update

2. Create an order

Next step is to create the order for any payment merchant has to create an order. The order creation should be done from backend due to security reasons.

Cashfree provides 2 API for order creation
1. For production: https://api.cashfree.com/pg/orders
2. For Testing: https://sandbox.cashfree.com/pg/orders

Request:

Note: Client secret key and APP id mentioned above can be obtained from “https://merchant.cashfree.com/merchants/pg/developers/api-keys?env=test” link.

Response Body

If the order creation is successful we will get the 200 response and all the relevant order details.
We will save payments_session_id, order_token, cf_order_id and order_status at our end .
The “payment_session_id” is sent to the SDK for initiating payment as it contains all the necessary order details.

3. Initiate Payment- Drop Flow

Drop flow is the standard flow used by Cashfree for payments it handles all the Buisness logic and the UI components so that the payments can be done smoothly.

Next Step is to initiate the payment.
To initiate the Drop Checkout in the SDK follow the following steps.

• Create a CFSession object.
• Create a CFPaymentComponents object.
• Create a CFTheme object.
• Create a Drop Checkout Payment object.
• Set payment callback.
• Initiate the payment using the payment object created above

1. Create a CFSession object
   The SDK exposes a class CFSession class which accepts payments_session_id which we got in the response of order creation API.

import {
  CFEnvironment,
  CFSession,
} from 'cashfree-pg-api-contract';

try {
      const session = new CFSession(
        'payment_session_id',
        'order_id',
        CFEnvironment.SANDBOX
      );
        } catch (e: any) {
      console.log(e.message);
        }

The values for environment can only be SANDBOX and PRODUCTION.
SANDBOX for testing and PRODUCTION for production environment
Specify the Environment and pass payment_session_id and order_id received from the create order api response.

2. Create Payments components object
This object specifies payments mode which we want to show to our customers

const paymentModes = new CFPaymentComponentBuilder()
        .add(CFPaymentModes.CARD)
        .add(CFPaymentModes.UPI)
        .add(CFPaymentModes.NB)
        .add(CFPaymentModes.WALLET)
        .add(CFPaymentModes.PAY_LATER)
        .build();

3. Set a Theme
The CFThemeBuilder class used to create CFTheme used to set the theming for Drop checkout screen.

const theme = new CFThemeBuilder()
        .setNavigationBarBackgroundColor('#E64A19')
        .setNavigationBarTextColor('#FFFFFF')
        .setButtonBackgroundColor('#FFC107')
        .setButtonTextColor('#FFFFFF')
        .setPrimaryTextColor('#212121')
        .setSecondaryTextColor('#757575')
        .build();

4. Create a Drop Checkout Payment object

Use below code snippet for creating payment object for Drop Checkout

try {
  const dropPayment = new CFDropCheckoutPayment(
        session,
        paymentModes,
        theme
      );
    CFPaymentGatewayService.doPayment(dropPayment);
    } catch (e: any) {
        console.log(e.message);
    }

5. Setup Payment Callback
The SDK provides an interface CFCallback to receive callbacks from the SDK once the payment flow ends.

This protocol comprises of 2 methods:

1. public void onVerify(String orderID)
2. public void onError(CFErrorResponse cfErrorResponse, String orderID)

Code snippet demonstrating it’s usage:

import {
  CFErrorResponse,
  CFPaymentGatewayService,
} from 'react-native-cashfree-pg-sdk';

const App = () =>{

useEffect(() => {
    CFPaymentGatewayService.setCallback({
      onVerify(orderID: string): void {
        console.log('success ', orderID);
        mstStore.cartStore.emptyCart(mstStore.otpStore.userId);
        navigation.navigate(NAVIGATION.PaymentSuccess);
      },
      onError(error: CFErrorResponse, orderID: string): void {
        console.log('failed ', orderID);
        navigation.navigate(NAVIGATION.PaymentFailed);
      },
    });
    return () => CFPaymentGatewayService.removeCallback();
  }, []);
}

Now Combine all of the code above and its done follow the following code snippet .

import {
  CFErrorResponse,
  CFPaymentGatewayService,
} from 'react-native-cashfree-pg-sdk';

const App = () =>{

useEffect(() => {
    CFPaymentGatewayService.setCallback({
      onVerify(orderID: string): void {
        console.log('success ', orderID);
        mstStore.cartStore.emptyCart(mstStore.otpStore.userId);
        navigation.navigate(NAVIGATION.PaymentSuccess);
      },
      onError(error: CFErrorResponse, orderID: string): void {
        console.log('failed ', orderID);
        navigation.navigate(NAVIGATION.PaymentFailed);
      },
    });
    return () => CFPaymentGatewayService.removeCallback();
  }, []);

const  startCheckout = () => {
    try {
      const session = new CFSession(
        'payment_session_id',
        'order_id',
        CFEnvironment.SANDBOX
      );
      const paymentModes = new CFPaymentComponentBuilder()
        .add(CFPaymentModes.CARD)
        .add(CFPaymentModes.UPI)
        .add(CFPaymentModes.NB)
        .add(CFPaymentModes.WALLET)
        .add(CFPaymentModes.PAY_LATER)
        .build();
      const theme = new CFThemeBuilder()
        .setNavigationBarBackgroundColor('#E64A19')
        .setNavigationBarTextColor('#FFFFFF')
        .setButtonBackgroundColor('#FFC107')
        .setButtonTextColor('#FFFFFF')
        .setPrimaryTextColor('#212121')
        .setSecondaryTextColor('#757575')
        .build();
      const dropPayment = new CFDropCheckoutPayment(
        session,
        paymentModes,
        theme
      );
      CFPaymentGatewayService.doPayment(dropPayment);
    } catch (e: any) {
      console.log(e.message);
    }
  }
  }

Now Call the startCheckout function and pass the payment_session_id and order_id in the session object and then you will be able to make payments from the SDK.

After calling the startCheckout function you will be redirected to the following screen

Now choose your preferred payment method and click on pay in test environment you’ll be able to see two simulation options

1. To simulate Success
2. To Simulate Failure

After Clicking on Success or Failure the payment will be completed

4. Now all there is left to verify payment which will be done from backend and it’s done.

Thus, we have successfully integrated the Cashfree payment service in our React Native app easily.

Thank you

Hope you liked this article. Happy Learning!

Cashfree SDK integration in React Native App was originally published in VectoScalar on Medium, where people are continuing the conversation by highlighting and responding to this story.

In this article, we’ll learn how to secure our spring boot API using firebase authorization.

Introduction to Firebase Authentication

It is essential to authenticate users, and it is much harder if we have to write all this code on our own. This is done very easily with the help of Firebase. Firebase Authentication provides backend services, easy-to-use SDKs, and ready-made UI libraries to authenticate users to your app. It supports authentication using passwords, phone numbers, and popular federated identity providers like Google, Microsoft, Facebook, Twitter, and more.

How Authentication Works..?

We first get authentication credentials from the user to sign a user into our app.

• Credentials can be the user’s email address and password.
• The credential can be an OAuth token from an identity provider.

We then pass these credentials to the Firebase Authentication SDK. Backend services will then verify those credentials and return a response to the client.

And after a successful sign in-

• Firebase provides us an authentication token, which is then checked in whatever place we need to authenticate or authorize a user, be it front-end or back-end.
• We can access the user’s basic profile information.

Prerequisites

• Make sure that you have a server app.
• Admin Java SDK — Java 8+

Let’s get started:

Configure Firebase

First, enable the SignIn Methods. I enable Email/Password and Google and create a user. You can simply add a user using email/password.

Configuring Firebase in Spring Boot Project

To configure the firebase in the spring boot project first download the servicesAccountKey.json file from your Firebase Project setting.

Go to Project Setting -> Service Account-> Scroll down and click on create and then click on Generate new Private Key.

This will generate and download Private Key to access the Firebase Admin SDK.

*make sure to keep this file secure

Download the servicesAccountKey.json file and paste it into the resource folder of your spring boot project. This is the location where we access our private key.

Add the SDK

If you are setting up a new project, you need to install the SDK for the language of your choice. If you use Maven to build your application, you can add the following dependency to your pom.xml:

<dependency>
  <groupId>com.google.firebase</groupId>
  <artifactId>firebase-admin</artifactId>
  <version>9.0.0</version>
</dependency>

for reference, you can visit https://firebase.google.com/docs/admin/setup#windows

Retrieve ID tokens on clients

When a user or device successfully signs in, Firebase creates a corresponding ID token that uniquely identifies them and grants them access to several resources, such as Firebase Realtime Database and Cloud Storage. You can re-use that ID token to identify the user or device on your custom backend server. To retrieve the ID token from the client, make sure the user is signed in and then get the ID token from the signed-in user:

firebase.auth().currentUser.getIdToken(/* forceRefresh */ true).then(function(idToken) {
   // Send token to your backend via HTTPS
   // …
}).catch(function(error) {
   // Handle error
});

Once you have an ID token, you can send that JWT to your backend and validate it using the Firebase Admin SDK, or using a third-party JWT library if your server is written in a language that Firebase does not natively support.

Initialize Firebase SDK

//firebase service account

@Configuration
public class FirebaseInitialization { 

@Bean 
public void initialization() { 
try{ 
 
FileInputStream serviceAccount =
  new FileInputStream("./serviceAccountKey.json"); 
 
// serviceAccountKey.json file containing the key, store this json file to your resource folder

FirebaseOptions options = new FirebaseOptions.Builder()
  .setCredentials(GoogleCredentials.fromStream(serviceAccount))
  .build();
 
FirebaseApp.initializeApp(options);
 } catch (Exception error) { 
error.printStackTrace(); 
}
     }
 }

Verify ID tokens using the Firebase Admin SDK

The Firebase Admin SDK has a built-in method for verifying and decoding ID tokens. If the provided ID token has the correct format, is not expired, and is properly signed, the method returns the decoded ID token. You can grab the uid of the user or device from the decoded token.

Follow the Admin SDK setup instructions to initialize the Admin SDK with a service account. Then, use the verifyIdToken() method to verify an ID token:

/ idToken comes from the client app
FirebaseToken decodedToken = FirebaseAuth.getInstance().verifyIdToken(idToken);
String uid = decodedToken.getUid();

HTTP filter to check firebase token

public class FireBaseTokenFilter extends OncePerRequestFilter { 
/**
  * Authenticating user via fireBase authorizer verify fireBase token and extract
  * Uid and Email from token
  */
  @Override
  protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws ServletException, IOException {

    //Extracts token from header
    String token = request.getHeader("Authorization"); 

    //checks if token is there
    if (token == null ) 
      throw new ResponseStatusException(HttpStatus.UNAUTHORIZED,"Missing token!"); 
  
    FirebaseToken decodedToken = null;
    try { 
      //verifies token to firebase server 
      decodedToken = FirebaseAuth.getInstance().verifyIdToken(token); 
    } catch (FirebaseAuthException e) {
       throw new ResponseStatusException(HttpStatus.UNAUTHORIZED,"Error! "+e.toString()); 
        }
     //if token is invalid 
     if (decodedToken==null){ 
        throw new ResponseStatusException(HttpStatus.UNAUTHORIZED,"Invalid token!"); 
      }

    //Extract Uid and Email
    String uid= decodedToken.getUid();
    String email = decodedToken.getEmail();

    /*
    //set Uid and Email to request
    void setAttribute(java.lang.String name, java.lang.Object o)
    */

    request.setAttribute(“uid”, uid);
    request.setAttribute(“email”,email);

    chain.doFilter(request,response); 
    }
}

This is how we can authenticate any user in our spring boot application using firebase.

Thanks for reading!

Authenticating user via Firebase Authorizer using Spring Boot was originally published in VectoScalar on Medium, where people are continuing the conversation by highlighting and responding to this story.

MongoDB is a popular NoSQL database that organizations around the world use to store and manage large amounts of data. While MongoDB provides powerful tools for querying and analyzing data, it can be challenging to gain a comprehensive understanding of your data without visualizing it.

If you are new to MongoDB data analytics and visualization, you might be wondering how to get started. If this is the case, you’re lucky — there’s an easier way! In this blog post, we’ll cover some of the important key ways by which we can leverage MongoDB’s powerful visualization features to create charts and dashboards that make sense of our data.

Charts and dashboards are a great way to analyze and visualize the data stored in MongoDB databases. These charts can help you make better decisions, gain new insights, and optimize processes within your company. I’ll show you how to quickly create basic charts using MongoDB with a little setup and some coding knowledge required.

Let’s get started-

Suppose you have an e-commerce database, and it is spread over multiple collections containing thousands of documents in it. Now, if you are required to offer a dashboard with a visual representation of your data saved in MongoDB, then one of the solutions that come in our mind is to

1. Create and publish a set of back-end APIs that are designed for querying your MongoDB collection.
2. Select a library to make charts.
3. Use the data you’ve gotten from the back end to operate on an object data model as the charting library specifies.
4. Write front-end code to interact with your back-end APIs.

Now, what if I told you that we could do all the above-specified tasks by just using Charts on MongoDB Cloud, i.e., MongoDB Atlas, in just a few clicks with some additional features like

1. Auto refreshing(can also be customized)
2. Secured as role-based permissions are required to access
3. Layout can be configurable

You would be like 🥰🤗.

Let’s now quickly jump to Atlas and begin our expedition to learn.

https://www.mongodb.com/atlas

Sign up if you don’t have an account on Atlas or log in. Your console should look like this after creating a cluster. To create a cluster, hop on to the following link-

https://www.mongodb.com/docs/atlas/create-connect-deployments/

Click on Charts, and you will get land on the dashboard page with an empty dashboard already created with your username.

In most circumstances, you will already have a set of data. If you don’t have any data, then use the below link to load the sample data to Atlas.

https://www.mongodb.com/docs/atlas/sample-data/sample-mflix/

https://github.com/neelabalan/mongodb-sample-dataset/tree/main/sample_mflix

Now, let us create our first chart to display the total no. of movies we have in our collection.

We will be choosing the movie’s data source from our collections.

After selecting the movie’s data source, we will choose the chart type from the charts list.

1. Choose a chart type as Number from the drop-down menu.
2. Drag the field’_id’ from the fields list on the left to the aggregation column on its right.
3. Apply aggregation as a count method.
4. Rename the chart as No. of Movies.

Bonus: You can also filter the chart as per the requirements. I applied the filter on the country name to give me the total no. of movies in India.

Similarly, we can make another chart for ratings of the movies. We can choose a donut type for the purpose.

Feeling Simple and Easy. I hope you have liked the warm-up. Time to buckle up ⚡⚡⚡.

Now let’s create another chart with multiple fields. We are creating a bar chart of the Number of Movies in a Year and a line chart to show comparisons between average critic score and viewer review score. So, let us select grouped combo from the chart type.

1. Select the year as X-axis from fields on the left-hand side and also bin them to 10 to make it a decade.
2. Select ‘_id’ as columns and choose aggregation as count. It will create a bar chart.
3. For the line chart, select the ‘meter’ field from ‘tomatoes.viewer’ and apply aggregation to mean as we need an average score in each decade.
4. Repeat the above step and select the ‘meter’ field from ‘tomatoes.critic’.
5. Now in the filter section, select the ‘year’ with the minimum value inclusive.
6. Now plot the line chart onto the secondary axis and call it ‘rating.’

Bonus: We can also customize our charts. We can change the colors of the lines and bar, rewrite the name of the fields, and can also format the number type, and much more.

Now, let us jump to some coding parts. MongoDB charts allow you to write a query or add a missed or newly calculated field.

We will create a new chart, Most Prolific Actors, using a stacked bar type of chart. Here, we will be adding a new calculated field with the name ‘tomatometer,’ and the aggregation query to add the field is

{
  "$cond": [
    {
      "$gte": [
        "$tomatoes.critic.meter",
        0
      ]
    },
    {
      "$cond": [
        {
          "$gte": [
            "$tomatoes.critic.meter",
            60
          ]
        },
        "Fresh",
        "Rotten"
      ]
    },
    "Not Rated"
  ]
}

We will repeat almost all the steps stated above to create the chart. We will also limit the value to 10 results only.

We have covered almost most of our bases with the Charts. Now, let’s talk about Dashboard in MongoDB.

Dashboards are a combination of charts put together to show all of your data in one place. Dashboards are crucial for gaining insight into numerous focus points of your data in a single display because each chart uses data from a single MongoDB collection or view. Users can share dashboards with one another.

You can customize the layout of the charts, size, and position of the chart in the dashboard only. You can also place filters for the whole dashboards applicable to whole charts if they contain the same source data, or you can choose the chart to get filtered.

You can also apply role-based permissions for sharing for security reasons. Unauthenticated access can be accessed from anywhere, as authenticated access can only be accessed after verifying permissions.

Set up Dashboard permissions, following this simple documentation.

You can lock out the dashboard or share it in the organization itself.

Now comes the embedding part of the dashboard, which is one of the main features. Embedding a MongoDB dashboard into your web application can be a valuable way to provide users with an intuitive interface for interacting with the database. It can be handy for applications relying heavily on MongoDB to store and retrieve data.

You can use an iframe element to embed the dashboard into your own application. An iframe is an HTML element that allows you to embed another webpage within the current webpage. Here’s an example of how to use an iframe to embed the MongoDB dashboard:

<iframe
style="background: #FFFFFF;
border: none;
border-radius: 2px;
box-shadow: 0 2px 10px 0 rgba(70, 76, 79, .2);"
width="640" height="480" 
src="https://charts.mongodb.com/mongodb-charts-twsqq/embed/dashboards
?id=a1b2c3d4-a1b2-c3d4-9766-47b0b2daaff3&theme=light&attribution=false">
</iframe>

It will display the MongoDB dashboard within an iframe element in your application. You can customize the iframe size by adjusting the width and height attributes.

One thing to remember is that the MongoDB dashboard is designed to be used as a standalone application and may not fit seamlessly into your application’s layout. You may need some styling to make the dashboard look and feel like a natural part of your application.

Another option is using MongoDB JavaScript SDK to access your application’s dashboard data directly. It requires more setup, but it allows you to thoroughly integrate the dashboard functionality into your application.

To use the JavaScript SDK, you’ll need to install it by running the following command:

import ChartsEmbedSDK from "@mongodb-js/charts-embed-dom";

const sdk = new ChartsEmbedSDK({
  baseUrl: 'https://charts.mongodb.com/charts-charts-fixture-tenant-zdvkh',
});

// embed a chart
const chart = sdk.createChart({
  chartId: '48043c78-f1d9-42ab-a2e1-f2d3c088f864',
});

// render the chart into a container
chart
  .render(document.getElementById('chart'))
  .catch(() => window.alert('Chart failed to initialise'));

// refresh the chart whenever #refreshButton is clicked
document
  .getElementById('refreshButton')
  .addEventListener('click', () => chart.refresh());

// embed a dashboard
const dashboard = sdk.createDashboard({
  dashboardId: '61d02578-6148-4c87-9cad-1fbaef50a0d3',
});

// render the chart into a container
dashboard
  .render(document.getElementById('dashboard'))
  .catch(() => window.alert('Dashboard failed to initialise'));

Using the JavaScript SDK allows you to fully customize how dashboard functionality is integrated into your application. However, it requires more code and setup than an iframe and may only be suitable for some use cases.

Embedding the MongoDB dashboard into your own application is a great way to provide your users with an easy-to-use interface for managing their data. With just a few lines of code, you can bring the power of the MongoDB dashboard into your application.

Finally, charts and dashboards are essential to any analytics strategy, especially when using a document-based database. With MongoDB, there are many ways of visualizing data in charts and graphs. This collection of examples will help you leverage these features to create your own charts and dashboards with MongoDB.

Do explore more & expand with your significant use cases.

I hope you enjoyed reading & learned something new.

Don’t feel shy to appreciate with some claps.👏👏👏

Get Started Visualizing MongoDB Data with Charts and Dashboards was originally published in VectoScalar on Medium, where people are continuing the conversation by highlighting and responding to this story.

Currently my project pointing to 30 (Android 11).

> How to migrate android app to API level 31 (Android 12):-

Step 1) Update targetSdkVersion and compileSdkVersion

In order to update the target level upgrade targetSdkVersion and compileSdkVersion in app/build.gradle

android {
    compileSdkVersion 31

    defaultConfig {
        minSdkVersion 23
        targetSdkVersion 31
        applicationId "com.example.applicationname"
        versionCode 1
        versionName "1.0"
        resConfigs "en"
        multiDexEnabled true
    }

Step2) Add android:exported in android/app/src/main/AndroidManifest.xml

Add android:exported="true/false" attribute in <activity>...</activity>, <service>…</service>, <receiver>…</receiver> and <provider>…</provider> like:

When to use true and false :-

Whether the broadcast receiver can receive messages from non-system sources outside its application — “true" if it can, and "false" if not. If "false", the only messages the broadcast receiver can receive are those sent by the system, components of the same application, or applications with the same user ID.

If unspecified, the default value depends on whether the broadcast receiver contains intent filters. If the receiver contains at least one intent filter, then the default value is “true". Otherwise, the default value is "false".

In Short:-

We need to set exported as true if any components need to be accessible from outside of our app (either by OS or other apps).

NOTE: If we don't add android:exported="true/false". App will not run

Step 3) Update<uses-permissions /> and Libraries:-

You must have to update some user permission in android/app/src/main/AndroidManifest.xml. Consider official documentation for permission upgradation.

Step 4) Sync and run the application:-

Sync your application in android studio and try to run the application. It will run successfully.

If you face problem to run the application due to some other libraries then try upgrade the library to latest version which supports the API level 31 (Android 12).

• > Still having problem in running the application:-

1. Open android/app/src/main/AndroidManifest.xml file in Android Studio.
2. Open Merged Manifest which will show the error in errors section if there is any.

3. Find the errors in Merged Manifest and make the changes

4. Open AndroidManifest.xml from Merged Manifest of different libraries which are giving the android:exported error and add the android:exported="true/false" attribute.

5. Patch the library using below commands:

Supposing you have mylib.aar in your current directory, try the following:

$ unzip myLib.aar -d tempFolder # or other extracting tool
# Change whatever you need
$ jar cvf myNewLib.aar -C tempFolder/ .

6. Sync and run the application.

Migration of Android App API Level to 31 (Android 12) in React-Native was originally published in VectoScalar on Medium, where people are continuing the conversation by highlighting and responding to this story.

Let’s do some coding now!

1. Move to android/app/src/main/java/com/your-app-name/
2. Create a file PreventScreenshotModule.java or any name you want.

package com.your-app-name;

import com.facebook.react.bridge.ReactApplicationContext;
import com.facebook.react.bridge.ReactContextBaseJavaModule;
import com.facebook.react.bridge.ReactMethod;
import com.facebook.react.bridge.Promise;

import android.view.WindowManager;

import static com.facebook.react.bridge.UiThreadUtil.runOnUiThread;

public class PreventScreenshotModule extends ReactContextBaseJavaModule {
    private static final String PREVENT_SCREENSHOT_ERROR_CODE = "PREVENT_SCREENSHOT_ERROR_CODE";
    private final ReactApplicationContext reactContext;

    PreventScreenshotModule(ReactApplicationContext context) {
        super(context);
        reactContext = context;
    }

    @Override
    public String getName() {
        return "PreventScreenshotModule";
    }

    @ReactMethod
    public void forbid(Promise promise) {
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                try {
                    getCurrentActivity().getWindow().addFlags(WindowManager.LayoutParams.FLAG_SECURE);
                    promise.resolve("Screenshot taking locked.");
                } catch(Exception e) {
                    promise.reject(PREVENT_SCREENSHOT_ERROR_CODE, "Forbid screenshot taking failure.");
                }
            }
        });
    }

    @ReactMethod
    public void allow(Promise promise) {
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                try {
                    getCurrentActivity().getWindow().clearFlags(WindowManager.LayoutParams.FLAG_SECURE);
                    promise.resolve("Screenshot taking unlocked.");
                } catch (Exception e) {
                    promise.reject(PREVENT_SCREENSHOT_ERROR_CODE, "Allow screenshot taking failure.");
                }
            }
        });
    }
}

3. Now it’s time to create PreventScreenshotPackage.java in the same directory as above android/app/src/main/java/com/your-app-name/

package com.your-app-name;

import com.facebook.react.ReactPackage;
import com.facebook.react.bridge.NativeModule;
import com.facebook.react.bridge.ReactApplicationContext;
import com.facebook.react.uimanager.ViewManager;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class PreventScreenshotPackage implements ReactPackage {

    @Override
    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
        return Collections.emptyList();
    }

    @Override
    public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
        return Arrays.<NativeModule>asList(new PreventScreenshotModule(reactContext));
    }
}

4. Add this package to your MainApplication.java

@Override
protected List<ReactPackage> getPackages() {
    @SuppressWarnings("UnnecessaryLocalVariable")
    List<ReactPackage> packages = new PackageList(this).getPackages();
    packages.add(new PreventScreenshotPackage());

    return packages;
}

Now it’s time to access the methods defined in PreventScreenshotModule.java in your component/screen.

For accessing this, we’ll create a custom hook.

5. Navigate to src/hooks/ and create a hook with whatever name you like. I’m creating useCustomScreenshot.js

import { useEffect } from 'react';
import { NativeModules } from "react-native";
import { useNavigation } from "@react-navigation/native";

const useCustomScreenshot = () => {
  const navigation = useNavigation();

  const forbidScreenshot = async () => {
    try {
      const result = await NativeModules.PreventScreenshotModule.forbid();
      console.log(result);
    } catch (e) {
      console.log(e);
    }
  };

  const allowScreenshot = async () => {
    try {
      const result = await NativeModules.PreventScreenshotModule.allow();
      console.log(result);
    } catch (e) {
      console.log(e);
    }
  };

  useEffect(() => {
    navigation.addListener('blur', () => {
      // when user moves to some other screen 'blur' event will be triggered, 
      // again enable screenshot
      allowScreenshot();
    });
  }, []);

  return { allowScreenshot, forbidScreenshot };
};

export default useCustomScreenshot;

6. Now move to the screen where you need to disable the screen and use this piece of code there.

import React from "react";
import { View } from "react-native";
import { useFocusEffect } from "@react-navigation/native";

const HomeScreen = () => {
  const { forbidScreenshot } = useCustomScreenshot();

  useFocusEffect(
    useCallback(() => {
      forbidScreenshot();
    }, [])
  );

  return (
    <View style={styles.container}>
      <Text>Home</Text>
    </View>
  );
};

Done! This is all you need to make things work.

Note: This will also record a black screen while screen recording and show a black screen when screen is shared on a call.

Happy Coding!

Block screenshot in React Native for specific screen (Android) was originally published in VectoScalar on Medium, where people are continuing the conversation by highlighting and responding to this story.