We have recently developed a site into the gatsby.

We have a blog site and hosted it on a different domain but now we want to move to one place at our main site. now, we have challenges for displaying dynamic blogs on the gatsby site.

Finally, I found that gatsby provides support to render dynamic blogs as a static page. when build created that time fetch the blogs from the server and create a static page for all the blogs.

Gatsby is a very good platform and manages such a kind of thing easily.

So, I will show you how to create static pages from the API response into the Gatsby site.

Here are the steps you need to follow correctly.

Steps 1

Create a one blog file where you want to load a blog in your design.

For an ex. I created a file `blog/index.js` inside the component directory and the code looks like this,

Steps 2

Open a file `gatsby-node.js`

Declare the const for the API URL at the beginning of the file.

const blogURL = 'http://blog-api.com/api/posts';
We need to create an instance of the  `node-fetch` for fetching a data from API server.

const fetch = require(`node-fetch`);

Import the path for a resolve the page while creating a static page.

const path = require('path');
See the example how to create a static page from APIs. code look's like,
exports.createPages = (async ({graphql, actions}) => {
    const blogs = await fetch(blogURL);
    blogs.data.forEach((blog) => {
        createPage({
            path: 'blog/' + blog.slug,
            component: path.resolve(`./src/components/blog/index.js`),
            context: {
                // Data passed to context is available
                // in page queries as GraphQL variables.
                slug: blog.slug,
                blog: blog,
            },
        })
    })
Now we are done, and you can access blogpage via slug.

Generate Custom Validation Class

namespace App\Rules;
use Illuminate\Contracts\Validation\Rule;
use Ramsey\Uuid\Uuid;
class UuidExists implements Rule
{
   
    protected $table;
    protected $column;

    public function __construct($table, $column)
    {
        $this->table = $table;
        $this->column = $column;
    }

    public function passes($attribute, $value)
    {
        $value = Uuid::fromString(strtolower($value))->getBytes();
        return \DB::table($this->table)->where($this->column, $value)->exists();
    }

    public function message()
    {
        return 'The validation error message.';
    }
}

\Validator::extend('uuid_exists', function ($attribute, $value, $parameters, $validator) {
 	list($table, $column) = $parameters;
  	return (new UuidExists($table, $column))->passes($attribute, $value);
});

'tenant_id' => ['required', 'uuid_exists:tenant_id,uuid']

Here we will learn, how to import annotations saved in the database using PDFTron.

In my last blog, we have learned how to save annotation in the database.

Events for import annotation

At the time of document load, we will get all annotations saved in the database using AJAX call and then we'll import that annotation. Now the question is if we import annotation than that will be drawn and again annotation changed event will fire and again annotation will be saved (as I say in my last blog), so this will become an infinite flow, but we can overcome this problem by checking if an annotation is imported or not. If an annotation is not imported then only we'll do save annotation in the database process otherwise we'll ignore it.\

When we draw any annotation "annotationChanged" event will be fired, and check if it is an imported annotation, then we can ignore it(eg, save annotation process).

Here is an example of how to import annotation from the database.

Example

WebViewer({
    path: 'path_to_the_PDFTron_'lib'_folder_on_your_server',
    css: 'webviewer_css',
    licenseKey: 'YOUR_PDF_TRON_LICENSE_KEY',
    initialDoc: 'YOUR_FILE URL' //url of a file to load
}, document.getElementById('viewer'))
    .then(function (instance) {
        let docViewer = instance.docViewer;
        let annotManager = instance.annotManager;
       
        annotManager.on('annotationChanged', (annots, action, e) => {
            //if annotation is imported we'll return
            if (e.imported) return;
            //when document will loaded we'll get annotations fro db
            docViewer.on('documentLoaded', function () {
                $.ajax({
                    url: `URL_TO_SAVE_ANNOTATION`,
                    type: 'GET',
                    success: function (result) {
                        if (result.success) {
                            result.data.forEach(annotationObj => {
                                annotManager.importAnnotations(annotationObj.annotation);
                            });
                        }
                    },
                    error: function (result) {
                        console.log(result);
                    }
                });
            });
        });
    });

Here we will learn how to send real-time notifications using Pusher + Laravel.

First of all, you need to create an account in the Pusher and get API keys from there.

Setting up your Laravel application

Now we need to install Pusher SDK, you can install it by the composer using the below command,

composer require pusher/pusher-php-server

After the composer is done, we will need to configure Laravel to use Pusher as its broadcast driver, update the below variables in the .env file,

PUSHER_APP_ID=123456
BROADCAST_DRIVER=pusher

// Get the API Keys from your pusher dashboard

PUSHER_APP_ID=XXXXX
PUSHER_APP_KEY=XXXXXXX
PUSHER_APP_SECRET=XXXXXXX

Open config/app.phpand uncomment the "App\Providers\BroadcastServiceProvider::class".

Now we need an event that will broadcast to the pusher driver. Let's create a NotificationEvent.

php artisan make:event NotificationEvent

This command will create a below file

namespace App\Events;
use Illuminate\Queue\SerializesModels;
use Illuminate\Foundation\Events\Dispatchable;
use Illuminate\Broadcasting\InteractsWithSockets;
use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
class NotificationEvent implements ShouldBroadcast
{
    use Dispatchable, InteractsWithSockets, SerializesModels;
    public $username;
    public $message;
    public function __construct($username)
    {
        $this->username = $username;
        $this->message  = "{$username} send you a notification";
    }
    public function broadcastOn()
    {
        //it is a broadcasting channel you need to add this route in channels.php file
        return ['notification-send'];
    }
}

Add broadcasting route in channels.php file

Broadcast::channel('notification-send', function ($user) {
    return true;
}); 

Cache Event at Javascript Side

// Initiate the Pusher JS library

var pusher = new Pusher('YOUR_API_KEY', {
    encrypted: true
});

// Subscribe to the channel we used in our Laravel Event

var channel = pusher.subscribe('notification-send');

channel.bind('App\\Events\\NotificationEvent', function(data) {
    // this is called when the event notification is received...
});

Testing and Setup

Using the below route we can send a notification.

Route::get('test', function () {
    event(new App\Events\NotificationEvent('Monika'));
    return "Event has been sent!";
});

In the last blog, we have discussed two perspectives namely Financial Perspective and Internal Process perspective out of four perspectives of BSC. let's look at the remaining two perspectives.

Customer Perspective:

We all know that the 'Customer is the king of market'  and that's why we need to ensure that we have satisfied customer Group in Market. 

Each organization serves a specific need in the market and this is done with a target group in mind, for instance, the Quality, Price, Service, and acceptable margins on the products and/or services.

The organization always try to meet customers' expectation in the market and that's why any organization need to keep eyes on the market and ready to adapt changes quickly.

The existence of alternatives( competitors ) has a huge influence on customers' expectations and we need to focus on overall market trends to build satisfied buyers in the market.

This perspective answer the question:

"How attractive should we appear to our customers?"

In short we need to focus on three points-

1. Target Group in Market
2.  Expectation of the Customers
3.  Our Competitors 
4. after focusing on these points definitely, we will able to lure maximum potential customers in the market.

Learning and Growth Perspective:

In today's comitative era, if we are not ready/capable to learn something new then it's next to impossible to survive in the market as 'nothing is constant only the change is constant '  Here the only knowledge is not important but advancing knowledge plays a vital role. The organization's learning ability and innovation indicated whether an organization is capable of continuous improvement and growth in a dynamic environment. The dynamic environment subject to change on daily basis due to new laws, economical changes, technological changes, or even increasing competition.

This perspective answer the questions:

"How can we sustain our ability to achieve our chosen strategy ?"  

To know more about the BSC please read my upcoming weekly Blog.

Dear, Friend in this blog we discussion google ad integration. Many companies work in client base & product base. Product base company in very very important ad integration in the app. Multiple types of AD available like a Facebook ad, start-up ad, google ad, etc. Today we learning google ad integration. 

Type of Google AD:

• Banner AD
• Interstitial Ad
• Rewarded Video Ad
• Native Ad

1.Banner Ad

- Banner Ads occupy only a portion of the screen depending on the ad size that is created. It comes in multiple sizes Standard, Medium, Large, Full-Size, Leaderboard, and Smart Banner. Smart banners are very useful when you target multiple device sizes and fit the same ad depending on the screen size.

2.Interstitial Ads

- Interstitial ads occupy the full screen of the app. Basically, they will show on a timely basis, between screen transition or when the user is done with a task.

Open AndroidManifest.xml and add MyApplication to tag.

<meta-data
    android:name="com.google.android.gms.ads.APPLICATION_ID"
    android:value="ca-app-pub-3940256099942544/6300978111"/>

What is Performance Testing?

Performance testing, which is a non-functional testing method performed to determine system parameters in terms of responsiveness and stability under various workloads.  Performance testing measures the quality characteristics of a system, such as scalability, reliability, and resource use. 

Types of Performance Testing

There are mainly six types of performance testing Let's see in detail.

Load Testing

It is the simplest form of testing conducted to understand the behavior of the system under a specific load.  The load tests will determine the measurement of important business critical transactions and will also monitor the load on the database, application server, etc. 

Stress Testing

It is performed to find the upper limit capacity of the system and also to determine how the system is operating if the current load greatly exceeds the expected maximum. 

Spike Testing

The Spike test is performed by suddenly increasing the number of users by a very large amount and measuring system performance.  The main objective is to determine whether the system will be able to carry the workload. 

Scalability testing 

 It Measures performance based on the software's ability to increase or decrease performance measurement attributes.  For example, a scalability test could be performed based on the number of user requests. 

Volume Testing

Under large test volume no.  From.  The data is filled in a database and the overall behavior of the program system is monitored.  The goal is to check the performance of the software application under different database sizes. 

Endurance Testing

It is done to make sure the software can handle the expected load over a long period of time.

 We will see full performance testing process points in our next article, to be continue..

GIF logo file formats are not as widely used as they once were. They have a very limited color spectrum (only 256 colors out of millions in JPG) so solid color logos are a good candidate for this format. A special feature of the GIF file is that it supports smooth animation. You can create frames with frame animations and file sizes will be negligible as long as you keep the color flat and smooth (from red to blue). GIF files are pixel-based and do not expand well.

EPS and AI logo file formats are a sacred grail of file formats. They are made up of dots and lines, not pixels, allowing infinite scaling and expansion without losing quality. Many business owners and executives ignore these logo file formats because they cannot open them normally. Many common MS Office fee programs do not open the EPS logo file format. EPS files can also support pixels, which also makes this file format difficult. Software such as Adobe Illustrator, InDesign, or Photoshop can work with this file format and optimize and save almost any logo file format you need. Illustrator will allow resizing, color mode change, and more.

PDF logo file formats can also be difficult as PDF color mode can disguise spectra and resolution. Some common office fee software will open or import PDFs but one way to tell if the resolution is good is to zoom in very closely to the logo. If the edges stay crisp, you’re in business and a graphic designer who can use something in print and digital applications. If the edges become blurred or pixelated, you will be limited in the use and extension of this particular logo file format.

SVG files have become more common on websites and digital access and are considered the standard format for displaying vector graphics on the web. SVG logo file formats allow a resizable logo format that does not lose image quality as it is expanded or reduced. This is especially important with responsive web design where the logo file can be resized depending on the digital device the website is viewing. Another major advantage for the SVG logo file format is the relatively small file size - which allows a digital file to load on a website very quickly. Support is limited to SVG but website design is an important place for their use.