Peatio is an open source cryptocurrency exchange web application. Here you will be going to have your own cryptocurrency exchange. For the installation of Peatio, you should have a fresh Ubuntu system along with minimum 4GB RAM and 1 TB SSD.

Prerequisites

Now Start with the installation of following technology stack required for the peatio configuration and installation.

1. Redis server

2. RabbitMQ

3. MySQL database

4. Bitcoind

5. Nginx with Passenger

6. JavaScript Runtime

Step 01: Install Redis with a stable version

Redis is basically used in peatio for storing session data as well as trading data, that needs to be transferred from one application to another.
 

sudo apt-get update

sudo apt-get install redis-server

Now you can configure the redis.conf file as per the requirements

sudo nano /etc/redis/redis.conf

Step 02: Install RabbitMQ Server

RabbitMQ is used for exchange the data between servers, applications, and processes.
It uses the Advanced Message Queuing Protocol (AMQP) to exchange the data between peatio and the coin servers like bitcoind, ethereum, rippled, etc.
 

Install the rabbitmq-server by using the following commands.

sudo apt-get update

sudo apt-get install rabbitmq-server

To start the rabbitmq-server first enable the rabbitmq management plugin and then restart it.

sudo rabbitmq-plugins enable rabbitmq_management

sudo service rabbitmq-server restart

Same like above command we can use start, stop and status for checking the status of rabbitmq-server.

Step03: Install MySQL Database

Here we are going to install the mysql database.

sudo apt-get update

sudo apt-get install mysql-server mysql-client libmysqlclient-dev

Step 04: Installation and Configuration of Bitcoind Server

Bitcoind is a program or daemon which implements bitcoin protocols for remote procedure call (RPC).
When the Bitcoind get installed in the Ubuntu system, it started syncing blocks of blockchain of Bitcoin. Once the difference between the current block and synced block is getting the same then we can make transaction form our local system.

Installation

First, install the dependencies then install bitcoind server.
 

sudo apt-get update

sudo apt-get install bitcoind

Configuration

Here we can configure the bitcoind server for testnet as well for real Bitcoin network.
 

mkdir -p ~/.bitcoin

touch ~/.bitcoin/bitcoin.conf

nano ~/.bitcoin/bitcoin.conf

Now insert the following lines into the bitcoin.conf file and replace with your ’s rpcuser and rpcpassword.

server=1

daemon=1

# If run on the test network instead of the real Bitcoin network

testnet=1

rpcuser=USERNAME

rpcpassword=PASSWORD

rpcport=18332

# Notify when receiving coins

walletnotify=/usr/local/sbin/rabbitmqadmin publish routing_key=peatio.deposit.coin payload='{"txid":"%s", "currency":"btc"}'

Now we can start bitcoind server using the following command or we can use bitcoin-cli for further operations.

bitcoind

Step 05: Nginx Installation

Nginx is an open-source web server which is used for low memory uses and high concurrency. It handles the high numbers of connections and acts as a load balancer to manage traffic and distribute it.
 

sudo apt-get update

sudo apt-get install nginx

sudo ufw allow 'Nginx HTTP'

systemctl status nginx

Now configure the default config file to setup Nginx with reverse proxy

open file ‘/etc/nginx/sites-available/default’ in an editor and replace the file content with the following

#

# ATTENTION!

#

# Make sure to add the next line to /etc/hosts.

#

server {

server_name http://localhost:3000;

listen 80 default_server;

location ~ ^/(?:trading|trading-ui-assets)\/ {

proxy_pass http://localhost:5000;

}

location / {

proxy_pass http://localhost:3000;

}

}

Make sure to replace http://localhost:3000 with your actual server.

You can verify the syntax of the config file is valid or not.

sudo nginx -t

and then restart the nginx server

sudo systemctl restart nginx

Step 06: Install JavaScript Runtime

The JavaScript Runtime is used for assets pipeline to work.

curl -sL https://deb.nodesource.com/setup_8.x | sudo bash -

sudo apt-get install nodejs

Installation & Configuration of Peatio

First, take the clone of peatio form GitHub

mkdir cryptocurrency_exchange

cd cryptocurrency_exchange

git clone https://github.com/rubykube/peatio.git

cd peatio

use rvm 2.5.1

bundle install

now prepare the configuration files

bin/init_config

install and run the yarn

npm install -g yarn

bundle exec rake tmp:create yarn:install

Setup bitcoind rpc endpoints

Edit ‘config/seed/currencies.yml’

Replace ‘username:password’ and ‘port’

remember username:password should only contain letters and numbers not email address as a username.

Setup database for peatio

Edit ‘config/database.yml’ replace your database username and password. And run the commands.

bundle exec rake db:create

bundle exec rake db:migrate

bundle exec rake currencies:seed

bundle exec rake markets:seed

Run daemons

in the peatio directory

god -c lib/daemons/daemons.god

you can use commands like god start, god restart and god status daemon

Setup Authentication

By default peatio uses the google authentication, you can also use barong for the authentication.
Change the sign in provider as per your requirement in “/config/application.yml”

Run Peatio

Here we can start the server and run the Peatio application.
 

bundle exec rails s -p 3000

Here we can see the Peatio is running now.

A few clients ask us for what good reason we utilize Ruby on Rails to create web applications rather than the various web systems and languages. There are numerous purposes behind our choice, yet before I leave on an exchange of the favorable circumstances of Ruby on Rails, I should initially clarify what Ruby on Rails really is. 

RUBY ON RAILS 

Rails is a development tool which gives web developers a framework, providing structure for all the code they write.
The Rails framework helps developers to build Websites and Applications because it abstracts and simplifies common repetitive tasks.

Rails is written in Ruby, the programming language which is additionally utilized close by Rails. Ruby is to Rails as PHP is to Symfony and Zend, or as Python is to Django. The intrigue of Ruby to engineers lies in the polish and briskness of the language. 

One of the key standards of Ruby on Rails advancement (from this time forward 'Rails') is tradition over design. This implies the software engineer does not need to invest a great deal of energy arranging records so as to get setup, Rails accompanies a lot of traditions which help accelerate advancement. 

Another characteristic of Rails is the emphasis on RESTful application plan. REST (Representational State Transfer) is a style of programming engineering based around the customer server relationship. It empowers a consistent structure inside applications, which implies they can without much of a stretch be uncovered as an API (Application Programming Interface). 

From a project management point of view, the Ruby on Rails people group advocates Agile Web Development – an iterative improvement technique, that empowers shared and adaptable methodology, which is especially appropriate for Web Application Development with quick evolving prerequisites. 

In the course of the most recent couple of years Ruby on Rails development has picked up a vast and eager after, however, let's consider the fundamental pros of Rails. 

WHY WE PREFER TO USE RUBY ON RAILS: 

• The way toward writing computer programs is a lot quicker than with different systems and languages, somewhat as a result of the article arranged nature of Ruby and the huge accumulation of open source code accessible inside the Rails people group. 
• The Rails traditions additionally make it simple for engineers to move between various Rails ventures, as each task will, in general, pursue a similar structure and coding rehearses. 
• Rails is useful for Rapid Application Development (RAD), as the structure makes it simple to oblige changes. 
• Ruby code is truly readable and for the most part self-reporting. This expands efficiency, as there is less need to work out independent documentation, making it less demanding for different designers to get existing ventures. 
• Rails has built up a solid spotlight on testing, and has great testing systems. 
• Rails and the vast majority of its libraries are open source, so unlike other commercial development frameworks there are no licensing costs involved.

Ruby on Rails is the framework that provides the code to build most of the part of the application. When we develop the feature, the job is to write the parts of the application that help to perform a specific task. Ruby on Rails contains different sub-framework to complete feature, one of them is Active Job. When rails application requires to perform the queuing backend job Active Job framework can be used to declare job and make it run.

The active job can be used to send emails, calculate billing, send notifications, scheduled clean-ups. It divides the job in small chunks and runs in parallel. Our effort is to provide the customers with a user-friendly and flexible web application.

This can be approached when server response time is effective. So put jobs that take more time of server to execute in a queue and serve in the backend. Scheduling the task in queue backend distribute traffic on the server by allowing to complete the job when the server is free.

To schedule backend job and run the job resque-scheduler, delayed_job gems can be used.

I worked on the project Google Review management that requires to send the notification to the users whenever there is a new google review comes in application. If I have performed send notification in real time to users that will decrease the response time of server. To achieve this, I found the solution to use Active Job framework.

How to create the Active job in rails?

Active Job framework has a rails generator to create job.

$ rails generate job email_notifier

Above will generate the below structure.

invoke test_unit

create test/jobs/email_notifier_job_test.rb

create app/jobs/email_notifier_job.rb

Created job will be as below

class EmailNotifierJob < ApplicationJob

queue_as :default

def perform(*emails)

# perform notification task

end

end

ApplicationJob is the base class for Active Job.

Keep Job in the Queue

1] To enqueue the job to be performed as soon as the queuing system is free.

EmailNotifierJob.perform_later user

2]Schedule job in the queue to be performed tomorrow at noon use

EmailNotifierJob.set(wait_until: Date.tomorrow.noon).perform_later(user)

Execution process of Active Job

To process the queueing backend job in production, need to set up the third party queueing rails library. Rails have its own in-process queuing structure that holds the job in RAM. In case of process crash and resetting system, there can be chances to lost all the scheduled backend task work as default async backend. For backend scheduling, active Job has built-in adapters for multiple queuing backends (Sidekiq, Resque, Delayed Job, Scheduler and others ).

Setup Backend

# config/application.rb

module ReviewApp

class Application < Rails::Application

config.active_job.queue_adapter = :sidekiq

end

end

Begin Job in Backend

This job serves the Action mailer’s #deliver_later features which are used to send mails in the background as scheduled. Now a day ’s, it is commonly feature require in web application.

Let us consider the adapter of rails library sidekiq .Method #deliver_later sends emails asynchronously to multiple users. Therefore sidekiq start working using this method after Active job setup. Mailers are queued in the queue mailers.

To start sidekiq processing that enqueue:

bundle exec sidekiq -q default -q mailers

In Job queue to send the notification using actionmailer sidekiq as backend

NotifyUserMailer.notify_new_review(user).deliver_later.

We can also use other rails adaptor, it depends on the requirement to perform Active job in Rails.

What is E-commerce?

E-commerce i.e electronic commerce or internet commerce is nothing but the process of buying and selling of goods or services, or the transfer of money and data online i.e using the internet or electronic network. From mobile shopping to online payment, e-commerce encloses a wide variety of data, systems, and tools for both online buyers and sellers.

Most businesses with an e-commerce presence in short e-business use an e-commerce store and/or an e-commerce platform in order to conduct both online marketing and sales activities and to supervise plans and fulfillment.

E-commerce platforms are generally of two types:

1. E-commerce webstore with Single-vendor

2. E-commerce Marketplace with Multi-vendor

Types of E-commerce Models:

Generally, there are four main models of e-commerce where almost every transaction between takes place between consumers and businesses can be categorized into:

1. B2C

2. B2B

3. C2C

4. C2B

Let’s look at each type of e-commerce models in a bit more detail.

1. Business to Consumer (B2C):

B2C e-commerce encloses transactions made between a business and a consumer.

It refers to the sale of a good or service to an individual consumer by an individual business.

e.g: You buy shoes from an online shoe retailer.

This is one of the most widely used transaction models in the e-commerce context.

2. Business to Business (B2B):

B2B e-commerce encloses transactions made between businesses, such as a manufacturer and a wholesaler or retailer.

It refers to the sale of a good or service from one business to another business.

e.g: A business sells software-as-a-service (SaaS) for other businesses to use.

3. Consumer to Consumer (C2C):

C2C e-commerce business model is one of the earliest forms of e-commerce model.

It refers to the sale of goods or services between customers.

 e.g: You sell your old furniture’s on eBay or Amazon to another customer.

4. Consumer to Business (C2B):

When a consumer sells their own products or services to a business or organization, this kind of transaction is called C2B.

That is Individual consumers make their products or services available for business buyers.

An example of this would be a kind of business model like iStockPhoto, in which stock photos are available online for purchase directly from different photographers.

Shopify E-commerce Platform:

Shopify is “all in one” e-commerce platform which allows you to build an online store with the great user experience. It’s a fully featured hosted platform which is easy to use and quick to set up.

If you’re looking to sell products online with less experience in web development or coding, Shopify can be the e-commerce platform to achieve this.

Key features of Shopify:

• Admin/Dashboard: They provide a dashboard/admin.

• Theme Store: Shopify provides free and paid themes from the Shopify Theme Store to make your store look great.

• Product Management: In Shopify, Product Management is easy. You can easily add Images from URL, manage variations of your products like product with different sizes or colors.

• Payments methods: Shopify offers a wide range of payment methods with Shopify Payment which is Shopify's own payment provider to accept credit card payments and you can also choose Third Party Providers i.e. from over 70 credit card payment providers for your store.

• Marketing & SEO: Shopify offers built-in Search Engine Optimization (SEO) features.

• Analytics: Shopify provided with built-in analytics that helps you to keep track of your website’s progress over time.

• 24/7 support: A dedicated Support team available 24/7 to answer your questions.

Shopify provides 14 days trial period, you can try to see how it works for your business. There are different monthly Shopify Pricing Plans, if the merchants located in India, you can see the details here otherwise if they located outside of India, you can click here to see details.

As Shopify is an E-commerce platform (i.e with single-vendor), you can sell your own products online.

You can also convert your Shopify single-vendor app into multi-vendor Marketplace by installing Multi-Vendor Marketplace plugin from Shopify app store into your Shopify app.

So, if you want to sell products on your own E-commerce webstore, I would like to suggest you prefer Shopify.

A cryptocurrency is nothing but a digital currency. Cryptocurrency exchanges are the platforms where you can buy, sell or exchange cryptocurrencies with other digital currency or with other assets such as fiat money. Fiat currency is like paper money for example Rupees, Dollars whose value is decided by the government.

To start with the cryptocurrency exchange, you have to create an account in a cryptocurrency exchange. The exchange will then verify your account. When you want to buy the cryptocurrency, check the asks and when you want to sell the cryptocurrency, check the bids. The ask represents the lowest price sell order that is currently available in the market or the lowest price that someone is willing to go short. The bids represent the highest price buy order that is currently available in the market.

Peatio Cryptocurrency Exchange

Peatio is an open-source cryptocurrency exchange developed in Ruby On Rails framework. You can easily use the Peatio cryptocurrency exchange code as it is freely available to any user.

If you have an interest in the cryptocurrency exchange domain and want to make your own cryptocurrency exchange, you can achieve that easily by making use of the Peatio cryptocurrency exchange.

Peatio is divided into three application i.e Peatio, Barong and Peatio Trading UI.

It’s key features:

• Register/Login - User can register and login to the exchange.

• Trading market - the Trading market is the heart of Peatio exchange.

• Bids and Asks - In a trading market, the user can bid and ask the currencies. It gives the best match for bids and asks.

• Trade machine-engine – As it has high-performance machine-engine for trading, orders and transactions can take place automatically.

• Trading dashboard – It shows the data in real time for charts, orders, bids, asks, and markets.

• Markets – There is a multi-currency market.

• Orders – When user bid or ask, the order will get created in the exchange and once the price is matched for asks and bid order, the transaction takes place in the exchange.

• Funds – User can easily deposit/withdraw coins and fiat amount in the exchange.

• Transaction History – It has a transaction history page which shows the history of the transaction.

• Admin Dashboard

• Multiple currency support - There are many currencies supported by Peatio for exchange such as BCH, BTC, DASH, ETH, USD

• 2FA and KYC – For the user security purpose, 2FA and KYC is developed

   

Being an open source, you can easily do the customization of UI. You can also customize the functionality of Peatio Cryptocurrency Exchange. I have seen making use of this exchange in an application created by “Cryptex Technologies” who is a ‘Ruby On Rails’ expert.

In Peatio, they have linked three application i.e. Peatio, Barong and Peatio Trading UI together using Nginx reverse proxy setup. They have also customized the UI of Barong, Peatio and Peatio Trading UI. ‘Cryptex Technologies’ have also implemented the browser and the IP address for phishing from which the security can be improved while exchanging cryptocurrency. They have also set up servers like RabbitMQ Event API server, Redis server and MySQL database server which is required for exchanging the Bitcoin.

For more Details Please Visit: https://bit.ly/2srao8I

You cannot ignore online marketing, especially when you are a real estate broker or dealer. With potential customers using the Internet to search their future purchase a strong and powerful digital marketing strategy helps real estate brokers and dealers to stand out in the competition.

The industry of real estate has expanded enough where buyers are doing an extensive search online before actually making their final purchase decision. The buyers are searching for brokers, dealers, projects, and sellers online which makes online marketing even more beneficial for the real estate industry.

Some of the advantages of this Real Estate Web Applications are:-

● Upload unlimited properties images/videos

● Upload 360-degree virtual tour

● Listings with photos and videos

● Get directly connected to the customers

● Real-time messaging

● Setup an appointment online

● Search engine with powerful filters

● 24/7 online presence

● Location awareness and maps

Why real estate application?

You can build your own brand and also build trust among the customers and get directly connected with your prospective customers.

What are the requirements?

One of the biggest reasons many people stay away from investing in an application is believing that it requires advanced technical knowledge and web design experience to build and manage an application. It's quite the contrary.

You don't need any experience to set up your own online application and start investing in digital real estate application get this complete property selling solution in your domain in just 1 DAY with just one click and set up your own brand.

There are options to buy or rent websites.

In conclusion

Eventually, you will start building your brand and connects from the application. Then you can decide whether to sell your application for a profit or to continue to use it. The choice is yours!

Cryptex Technologies is a Real Estate App Development Company which has developed such an application and can set up the application in your domain in just 1 Day.

For DEMO click: https://bit.ly/2BvdY5B

Introduction 

React.js is a Javascript library for building interactive UI application. React.js is very popular nowadays because of its features like performance, virtual DOM, component_based application, etc. After completing development of React.js application next step is to deploy the application on the Production server. There are several ways to deploy React.js application on a production server. We can deploy React.js application using ngnix, apache2, pm2, etc on a production server.

Prerequisite:

• The production server instance with Ubuntu 16.04 Operating System.

• React-project-demo is an already developed project and ready to go live.

1) Deploy React Application using Nginx

Step #1: Installing Environment Dependencies

We’ll need to install node to get working with our React app. The following will do the job to get the latest version of Node at the time of running.

sudo apt-get update

curl -sL https://deb.nodesource.com/setup_9.x | sudo -E bash -

sudo apt-get install -y nodejs

sudo apt-get install -y build-essential

This install Node,
npm and the build tools that come in handy for npm.

Clone your project repository on Step #2:
server instance

sudo mkdir /var/www

cd /var/www/

Take the clone or paste the code in the current directory, then change the directory:

cd react-project-demo

Install the project on the system:

sudo npm install 

Then you need to create the optimized production build of the project:

sudo npm run build

Step #3: Install and Configure Nginx to serve your application

sudo apt-get install nginx

sudo nano /etc/nginx/sites-available/default

and paste the below code:

server {

listen 80 default_server;

root /var/www/react-project-demo/build;

server_name localhost;

index index.html index.htm;

error_page 404 /;

location / {

}

}

Now you need to start your server:

sudo service nginx start

To restart application service:

sudo service nginx restart

To stop application service:

sudo service nginx  stop

You can check the nginx logs in the following files :

/var/log/nginx/access.log
/var/log/nginx/error.log

2) Deploy React Application using pm2:

pm2 is NPM package, using which one can start react application in detached mode.

Install Node & npm from step #1 of first method, then run following command:

npm i -g pm2 

This installs PM2, aka Process Manager. It’s going to help us handle running our app in the background of your server.

To run the react application:

pm2 start npm -- start 

To check the log of pm2:

pm2 logs

Other useful commands of pm2:

To make sure its running and to check its port number use:

pm2 list

to stop all the running instance of pm2:

pm2 stop all

to save the current running state:

pm2 save

to auto start on machine restarts:

pm2 startup

to disable autostart on machine restarts:

pm2 unstartup

manually restored saved processes:

pm2 resurrect

Similarly, we can use apache2 to deploy our React.js application on the production server.

Introduction

Capistrano is an automation tool for executing commands on the server through SSH. Capistrano basically a script which provides various commands to execute which helps to deploy the code on the server. It helps to reduce the manual efforts to deploy code and use the same command to deploy code every time. In this document, I am going to describe how to deploy your application from GitHub to the production server.

Capistrano Flow

The Capistrano have main flow as follows:

1. First, you need to install and configure Capistrano in your application.

2. Once the installation and configuration are done every time you have to push the latest code to GitHub and then run Capistrano script to deploy it to the server.

Step 1: Install the following gems in Gemfile.

gem 'capistrano', require: false

gem 'capistrano-rails', require: false

gem 'capistrano-rvm', require: false

gem 'capistrano-bundler'

Step 2: Run following commands to install these gems and initialize Capistrano

$ bundle install

$ bundle exec cap install

Step 3: Capfile

require 'We need to uncomment some lines according to our requirement. As I want to run bundle install automatically I have uncommented line capistrano/bundler'. In the same way for precompiling assets and running migration require 'capistrano/rails/assets' , require 'capistrano/rails/migrations'. As I am using RVM, I have uncommented the line require "capistrano/rvm". Similarly I am using GitHub for code deployment require "capistrano/scm/git"

, install_plugin Capistrano::SCM:: Git.

 Step 4: config/deploy.rb

deploy. In rb file mention name of the application. Then mention GitHub repository path as I have mentioned ‘git@github.com:username/application_name.git’.

Mention username and password of your GitHub repository. We also have to connect server where we have to deploy our application with GitHub. For that, we have to enter ssh public key in settings of GitHub so that it will connect GitHub with the server.

Step 5: config/deploy/production.rb

There are two ways to define servers. First one is with simple role-based syntax and another one is extended server based syntax. You should use only one from both, not both of them. In this, we have to set the environment of our rails application like ‘production’. Mention the branch of your code and also the path of application folder on the server in front of ‘deploy_to’.

(b) production.rb

Step 6: Run script

Now, run following command to run the script.

$ cap deploy production

Step 7: Server Setting

In this tutorial, we simply cloned our application code from GitHub to our server. While first time deployment of code it will use a defined directory structure on the server.

1. ‘release’ folder holds all deployments in a folder. Every time you run Capistrano to deploy code, it makes clones GitHub repository to a new subdirectory inside release.

2. ‘current’ folder is a symlink pointing to the latest release inside the releases folder. This symlink will update at every deployment. If deployment fails in any step the current symlink still points to the old release.

3. ‘repo’ folder holds the copy of GitHub repository.

4. ‘shared’ folder contains the configuration which will not be taken from the GitHub repository. As Capistrano deploy works by cloning the GitHub repository into a release It will contain files like (e.g. config/database.yml and config/secrets.yml). You have to put those files in shared and instruct Capistrano to symlink them to release directory on every deploy. This is done through the linked_files and linked_dirs configuration options in deploy.rb file.

Mention the path to the current folder in configuration settings of the server as it contains the latest code from GitHub repository and then restarts the server.I have mention the path like DocumentRoot /home/path/to/your_rails_app/current/public in /etc/apache2/sites-available/application_name.conf file.

  An Introduction to RabbitMQ:

 
RabbitMQ is a message broker software in Ruby on Rails framework where web applications connect to the queue and transfer a message onto it.

When one application server sends the request to another application server, RabbitMQ works as a queue manager where requests handled and served one by one. 

Message transferring is done from one application to another through RabbitMQ. RabbitMQ uses the standard Advanced Message Queuing Protocol (AMQP) to keep message request in queues and serve easily. The message may contain any information like simple text transfer or task that need to process on another server.

This RabbitMQ software saves messages in a queue and keeps in a queue until receiving application get connected and start processing the messages.

Why should we use RabbitMQ in Ruby on Rails Development?

Message broker works on the producer, broker, and consumer logic. Message broker server allows consumer and producer server to respond request fast instead of using resources heavily at one time. Message broker is used to optimize the load on the server and provide services until application executes the task on the requested server. The requested server can be any third party application which performs the task.

Queued messages will be used to send the messages or task to multiple recipients from consumption that leads to the load balancing on the producer and consumer server.

Let take an example of ruby on rails server and bitcoin exchange server (i.e. bitcoind) for btc transaction working.

I have rails server running as producer and bitcoind server as a consumer.

Rails server send multiple request to bitcoind server continuously. There may be chances to slow down bitcoind because of multiple requests send to bitcoind server to process task.

In that case, RabbitMQ can fulfill the role of load balancing and messages passing by keeping the request coming from rails server in a queue and serve request one by one to bitcoind server.

Bitcoind server will take a task from the queue and start processing.                                                           

AMQP role in RabbitMQ:

AMQP store and forward messages to consumers, same as SMTP protocol which is used to deliver mail to mailboxes. Messages start from producer application to the exchanges that help to redirect in queues. Lastly, queues deliver task to the consumer application. It's now consumer's server responsibility to take the messages from queues to process as required. 

A virtual channel is used to establish the connection between publishing messages from the queue. All process exchanges done over the channels.

How to use RabbitMQ in Rails application?

Using Bunny ruby RabbitMQ client, we can integrate RabbitMq with rails application. There are some gems available to start with RabbitMQ in ruby like

Bunny help rails application to interoperate with the consumer application, it can be built in any technologies irrespective of the size and complexity of the application. Also, add anampq gem in rails Gemfile to use AMQP protocol services.

RabbitMQ installation commands in Ubuntu:

1] Step 1: Update system
   

2] Step 2: Install Erlang

RabbitMQ is written in Erlang, you need to install Erlang before you can use RabbitMQ:

3] Step 3: Install RabbitMQ

4] Step 4: Start the Server

Thus if you are looking for web development services which is faster, reliable, redundant and scalable then you can definitely opt for Ruby on Rails RabbitMQ. Hire RoR developers for developing a robust messaging software.

Action Cable is a powerful feature introduced in Rails 5. Using action cable one can develop real-time web applications. Action cable uses Web Sockets to create full duplex communication between application’s server and client.

Using action cable feature we can create any real-time functionality like live chatting, which updates chats, show new messages, notifications, etc without reloading of the page. Action cable basically keeps ruby on rails server data and client data updated using web sockets which make the application more feasible to use.

Action cable is not supported by RAILS VERSION > 5.

PREREQUISITES:

This ruby gem requires jQuery. If jQuery is not present in the project then simply add “jquery_rails” gem to gemfile.rb and redis-server in the system.

STEPS REQUIRED TO USE ACTION CABLE:

Add following in Gemfile.rb file :

gem 'redis', '~> 4.0'

Also add following in application.js file :

//= require rails-ujs

//= require jquery

//= require turbolinks

//= require_tree

Thats all about installation process.

Let’s see an EXAMPLE :

For creating Notification model, controller and views using scaffold command just run :

rails g scaffold Notification name:string

Then create a Channel , we call this channel “WebNotifications”.

rails generate channel WebNotifications

And we add some CoffeeScript files to show notifications to all users in javascripts/page.coffee:

App.room = App.cable.subscriptions.create "WebNotificationsChannel",

received: (data) ->

$('#notification div').append '<li>' + data['notification'] + '</li>'

$('#notifications-count,.notifications-count').text data['count'] 

And finally we need to add the below code to the channels web_notifications_channel.rb.

class WebNotificationsChannel < ApplicationCable::Channel

def subscribed

stream_from "web_notifications_channel"

end

def unsubscribed

end

end

Changes in notifications_controller.rb file To call the action cable: 

def create

@notfication = Notfication.new(notfication_params)

respond_to do |format|

if @notfication.save

format.html { redirect_to @notfication, notice: 'Notfication was successfully created.' }

format.json { render :show, status: :created, location: @notfication }

else

format.html { render :new }

format.json { render json: @notfication.errors, status: :unprocessable_entity }

end

end

ActionCable.server.broadcast 'web_notifications_channel', notification: @notfication.name, count: Notification.all.count

end

Changes in app/views/layouts/application.html.erb file : I have added simple notification navigation in the application layouts.

<ul class="nav navbar-nav navbar-right">

<li class="dropdown">

<a href="#" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">Notification (<b class="notifications-count">2</b>)</a>

<ul class="dropdown-menu notify-drop">

<div class="notify-drop-title">

<div class="row">

<div class="col-md-6 col-sm-6 col-xs-6">Notifications (<b id="notifications-count">2</b>)</div>

<div class="col-md-6 col-sm-6 col-xs-6 text-right"><a href="" class="rIcon allRead" data-tooltip="tooltip" data-placement="bottom" title="tümü okundu."><i class="fa fa-dot-circle-o"></i></a></div>

</div>

</div>

<!-- end notify title -->

<!-- notify content -->

<div class="drop-content" id="notification">

<% Notfication.all.each do |notification| %>

<li>

<div class="col-md-3 col-sm-3 col-xs-3">

<%= notification.name %>

</div>

</li>

<% end %>

</div>

</ul>

</li>

</ul>

We need to do simple configuration setup in the cable.yml file.

redis: &redis

adapter: redis

url: redis://localhost:6379/1


production: *redis

development: *redis

test: *redis

To start the application first we need to start the redis-server the command to start the redis-server is:

redis-server

The Redis-server will be started then you can serve your application.
Following are the snapshots of output scenarios:

Creating new Notifications:

The result will be shown like that By using the action cable it will update the Notification to all live users.

In Ruby on Rails web development, using Action Cable RoR developers can show the live notifications to all users. These notifications can be of any type like Messaging, Sending push notification etc.

As software testing is moving from manual into automation at very fast speed, at times testers get into a scenario where they need to opt what needs to be automated, when to automate and why to opt for automated software testing?

If you are a software tester, this blog will help you to choose one from the two testing methods.

Software testers generally perform manual testing in the following scenarios:

1. When an application is at the initial stage of development. As application flow and feel and change over developing period it's better to go for manual testing then automating it. Automation can be done only when the application is stable.

2. When negative testing of the application is to be done because it's more reliable to depend on manual testing.

3. When regression is not required multiple times i.e. there are no multiple executions of test cases.

4. When there are some functionalities which cannot be automated like Captcha.

What is Automated Software Testing?

It is a process in which specific tools are used to execute scripts or test and compare the results. There are various tools available in the market to automate different types of software testing like QTP, Selenium, etc.

Starting with automation first need to take in consideration the following to avoid any confusion.

• Is the build stable?

• Does the application requires testing same functionality many times(Regression/Sanity/Smoke)

• Will writing automated test case save time?

• Do we have that much time to invest in automated testing?

If the answer to this question is YES then you can opt for automation testing for the application. Choosing the right framework for application is all dependent on what you are going to test.

And yes a team of experts for software testing to carry out the process is really important aspect followed by proper planning and strategy.

When to Choose Automated Software Testing?

1. Regression Testing: When we need to test the same test case or functionality multiple times. As testing the same functionality manually make people bore and error chances increase.

2. Large No. of Test Cases: When there is a large number of test cases to execute, it’s better to go with automation where just running the test suite will solve the problem.

3. Time management: As said above executing a large number of test cases manually will take a lot of time and money. So the time can be saved if we are using automation testing.

4. Performance: It's not possible to invest thousands of users to test the performance of any application. Automated testing can generate the required amount of user to interact with application and network.

5. Accuracy: It can be obtained with the help of regression/sanity/smoke testing: one has to just run the script. Manually there is a chance of missing any scenario.

Nowadays, data handling is a big responsibility for every web and mobile application. Arrays make the process easier and it can handle any list of data. Once you have data in an array, you can easily sort it, remove duplicates, change its order to either ascending or descending and many more.

In Ruby programming, there are many methods for Array object i.e. Map, Collect, Select, Reject, Each, Inject, Reduce, Detect and Find. Most of the Ruby on Rails developers uses these methods in their web applications.

In this blog, we have outlined the difference between all the methods.

Let’s have a look at them to choose the one which is best suitable for your requirement.

1. Map

The map method takes each element from the array and evaluates
given block on it. Output will be in the form of an array containing evaluated results without changing the original array.

2. Map!

If you want to modify the original array by replacing the output array elements with the original array elements then you can use the map! method.

3. Collect

There is no difference between collect and map method both methods work same. Similarly map! and collect! methods are also same.

4. Select

The select method takes each element from the array and evaluates given block on it. If block or statement evaluates to true the original elements gets added into the output array. In this case output array and original array are different. If you want to replace the original array to the output array, you can use select! Method.

5. Reject

The reject method is exactly opposite to the select method. It will take each element of the array in the block to evaluate. The output array will consist of all the elements in the original array for which block evaluates to false. The reject! method is also opposite to the select! method.

6. Each

The each method will iterate over array taking each element from it for evaluation. It will return the original array, but not evaluated one. Now, it depends on you what kind of operation you want to perform in the block.

7. Inject

The inject method takes two arguments, one as an accumulator and other as each element in the array. Accumulator accumulates the evaluated values. This returns the final value of the accumulator as a result. The initial value of the accumulator can be defined if not define it takes the first element of the array as initial value.

8. Reduce

Reduce method is similar to the inject method.

9. Detect

The detect method is similar to the select method, but the only difference is its output. The detect method also evaluates a block for each element of the array, but returns the first element in the array for which the block evaluates to true or statement in the block evaluates to true.

10. Find

Find method is similar to Detect method.

If you want to create Rails Application dependent on API only and you have a requirement to provide Token based authentication in your application. So you can use JWT+ KNOCK token based Authentication solution.

Knock is an authentication solution for Rails API-only application based on JSON Web Tokens.

JWT is JSON based web tokens.

Advantages of using JWT and Knock in Ruby on Rails Application:

• JWT:

1. It is lightweight

2. It is easy to use

3. It is stateless

• Knock:

1. Seamless JWT authentication for Rails API

2. It is easy to implement and maintain.

3. It allows customization.

Step 1: Create Rails API Project

rails new project_name --api -d mysql 

where

# --api specifies the rails application is API based

# -d mysql specifies that we use mysql database in this application

Step 2 : Add gem

Add following gem into project_name/Gemfile

gem 'knock' 

gem 'jwt'

gem file looks like

Figure 1: Gemfile for JWT and Knock

Next to run command on terminal for installing gem in application.

bundle install 

Step 3. Setup a basic Knock structure.

Run following command

rails generate knock:install 

rails generate knock:token_controller user

Now run the following commands to setup your Rails application.

rails generate model users 

rails generate controller users 

rails generate controller home

If you add custom model so you can do it

Figure 2: Migration File

Run following command to create User table

rake db:migrate 

Step 4 . Authorization/Knock Setup:

File Location: project_name/config/initializers/knock.rb

Figure 3: Knock.rb file

Step 5. Setup your User model with some basic validation.

File Location: project_name/app/model/user.rb

Your user model look like this.

Figure 4: User.rb file

Now you can setup controller to access the Authentication.

Add include Knock::Authenticable 

File Location: project_name/app/controller/application_controller.rb

Figure 4: Application Controller
 

Also each and every method call pass though knock authentication.

Add before_action :authentication_user, only[:auth]

Here auth is a method to check client is authorized.

In home controller there is index method and auth method for login.

File Location: project_name/app/controller/api/v1/home_controller.rb

Figure 6: Home Controller

File Location: project_name/app/controller/api/v1/users_controller.rb

In user controller there is index, current method for current user data and create method for creating new user. Also you can add update and delete method.

Add authentication on required method with help of authentication_user , authorize_as_admin, and authorize method.

Figure 7: User Controller

Final Step: Test API

We test API with help of Postman.

1. User creation API: API endpoint is http://localhost:3000/api/v1/users/create

We send parameter in body for user creation so that API method type POST. After calling API we get successful response with status 200 and and message “User was created ”.

After user creation we go to login API, but for application login we need a token so we need to call token API.

Figure 8: User create API

2. API Endpoint: http://localhost:3000/api/v1/user_token

For user token we need to send email id and password in body of method type POST.

If email id and password is valid to API we get jwt token from knock in response.

Great we now got token. With help of this we access knock authorized method.

Figure 9: User_token API

3. Login API:

API Endpoint: http://localhost:3000/api/vi1/auth

we sent jwt token in header of API and content type is applicationJson.

Authentication: Bearer jwt token

content type: : applicationJson.

If everything is OK, then we get successful response.

Figure 10: Login with jwt token

These two gems Knock + JWT can help us to develop token based API in Rails 5 very easily and will save the overall time required in Ruby on Rails development.

In this blog we will discuss about Unit Testing, the very first thing that we need to know is when the Unit Testing is being performed. Unit testing is the initial level of software testing, that is performed on the application source code mainly by the developer. The main motive of Unit Testing is to isolate a section of code and verify it’s correctness.

What is Unit Testing:

A level of software testing where the individual units or components of a software or web applications are tested by developer is called Unit Testing. It is an important aspect of Software Testing. It is a component of test-driven development (TDD).

Benefits of Unit Testing:

1. Defects revealed by a unit test are easy to locate and relatively easy to repair. Unit testing verifies the accuracy of the each unit.

2. In unit testing procedure – the developer needs to write test cases for all functions and methods so that whenever a change is required, it can be fixed quickly in later date and the module also works correctly.

3. Unit testing improves the quality of the code. It helps the programmer to write the better code. It identifies every defect that may have come up before code is sent further for regression testing.

4. If a test fails, then only the latest changes need to be made in the code and need to debug. So It’s better to say unit testing helps to simplify the debugging process.

5. Codes are more reusable. In order to make unit testing possible, codes need to be modular. This means that codes are easier to reuse.

Gems to perform Unit Testing in your Ruby on Rails web application:

There are several gems available in Ruby on Rails application framework to perform the unit testing.

• rspec_rails: Rspec is an automated test case, used to test the code written by developer while creating the application.

• factory_girl_rails: create dummy data while performing testing.

• minitest: It is also used to perform the unit testing in your rails application.

These 3 gems given above are used for Test Driven Development (TDD) environment.

• database cleaner: Used to cleanup the database in Ruby while testing.

Most of the Ruby on Rails Developers use the best practices for carrying unit testing on individual units of source code or program modules.

Unit Test Case Best Practices:

• You Should always follow the proper naming conventions for your unit testing, i.e. clear and consistent naming conventions for the unit tests.

• If any changes done in the requirements then your unit test case should not be affected. Your test cases should be independent.

• Always follow “test as your code" approach. The more code you write without testing, the more paths you have to check for errors.

• If any changes needs to done in the code for the corresponding module, make sure that you have the unit test case for that particular module and need to pass the test case before any implementation done.

Conclusion:

Developer should make Unit testing a part of their regime to make neat and clean, reusable, and bug free codes. Also by using unit testing the quality of code will be improved. Unit testing helps to reduce the cost of bug fixes.

We have gone through many web applications and mobile applications which do not reload the entire page but instead reloads only the required section. These are nothing but Single Page Applications (SPA) which are developed using Angular. A good example of SPA is Gmail where we have noticed that when we click on the inbox, it only reloads and displays that email in the e-mail list sections.

Introduction to Angular:

Angular is a TypeScript-base open-source front-end platform and framework led by the Angular Team at Google used for building client-side web applications. Angular itself is written in TypeScript, which is a superset of JavaScript and used for front end development.

Installation:

In order to start with the installation, we first need to make sure that we have nodejs and npm installed with the latest version.

We can install nodejs on Ubuntu OS by running the following command on terminal:

• sudo apt-get update

• sudo apt-get install nodejs

To install npm, we run the following one-line command on terminal:

• sudo apt-get install npm

To check the versions of Node.js and npm installed, we run following command:

• nodejs –v

• npm –v

Let’s install Angular CLI by running the following command:

• npm install –g @angular/cli

IDEs for Angular:

We can use any of the IDE i.e., WebStorm, Atom, Visual Studio Code, etc. But usually, Visual Studio Code is preferred.

Architectural Blocks of Angular:

The main building blocks of an Angular application are:

• Modules

• Components

• Templates

• Metadata

• Data binding

• Directives

• Services

• Dependency injection

In this blog, we will have an overview of Angular Modules and Angular Components.

Angular Modules:

We have Angular modules or we can say NgModules which maintains the modularity of Angular apps. Every Angular app has at least one module as the root module. Conventionally, it is named as AppModule. Typically, an app contains many functional modules. In angular, any module is a class with the @NgModule decorator.

The NgModule decorator is a function that takes metadata object whose properties describe the module. The properties are as follows:

• declarations: Here, we have to declare the classes that are related to views (i.e. The components, the directives, and the pipes that belong to this NgModule).

• exports: Here, we have to mention the classes that should be accessible to the components of other modules.

• imports: Here, we have to mention the modules whose classes are needed by the component of this NgModule.

• providers: Here, we have to mention the Services present in one of the modules which are to be used in the other modules or components. Once a service is included in the providers it becomes accessible in all parts of that application

• bootstrap: Here, we have to mention the root component which is the main view of the application. This root NgModule only has this property and it indicates the component that is to be bootstrapped.

The root module (i.e. src/app/app.module.ts) by default looks like:

Image: The Root Module in Angular

Angular Components

Every Angular application has a root component i.e. AppComponent which is bootstrapped inside the main module. In angular, each component defines a class with the application data and logic and is associated with a view i.e. HTML template to be displayed in a target environment.

The root component (i.e. src/app/app.component.ts) by default looks like:

Image: The Root Component in Angular

Advantages of Angular:

• Angular is faster, lighter and easier framework which is built to create faster performance applications that are smaller in size and easier to develop.

• It provides high performance, offline, and zero-step installation. So, Angular is pretty much easy to work with.

• Angular is universal that means we can use any technology with it for serving the application like node.js, .NET, PHP, Ruby on Rails and other servers.

• Angular is productive as:

• It generates UI templates quickly with simple and powerful template syntax.

• Angular CLI with Command line tools.

Apart from front end development we use Ruby on Rails framework for backend development. Hope this blog would be informative to understand the basic building blocks of Angular.

Introduction to FontAwesome 5:

Font Awesome 5 is upgraded version of Font Awesome 4, It has a more attractive icon with big improvement icons as compare to Font Awesome 4

Some improved points are listed below:

• FontAwesome 5 icons are drawn now with SVG.

• Now we have to reference Javascript file with SVG embedded in place of CSS file ( In FontAwesome 4 we use CSS file only ).

However, version 5 is now redesigned and rewritten from scratch.

Now, Let us see the changes in FontAwesome 5

Different icon styles:

In Version 5, there are 3 different styles:

i) Solid Style

ii) Regular Style

iii) Light Style

“Brand Icons” are separated out into their own style and is easy to use. Version 4 had one prefix only “-fa” and Version 5 has four prefixes. To set a style of any icon with ease, every prefix has different Javascript and SVG file. If we want to use them, we need to import Javascript and SVG file. Some as mentioned below.

Table: Font Awesome 5 Details

Syntax

Version 4’s Syntax

1)<i class=”fa fa-rocket”></i>

Version 5’s Syntax

1)<i class=”fas fa-rocket”></i>-----------“fas ‘s’ for Solid”

2)<i class=”far fa-rocket”></i>----------- “far ‘r’ for Regular”

3)<i class=”fal fa-rocket”></i>----------- “fal ‘l’ for Light”

Note:- Some Icon name changed in the upgraded version.

How to use FontAwesome 5:

Step1: Add Assets for FontAwesome 5 (Version 5)

Download cdn which is required for version 5

Web Font & CSS files

1. css/solid.css

2. css/regular.css

3. css/brand.css

4. css/fontawesome.css

5. css/light.css

6. For all CSS, we can use css/all.css

JS & SVG files

1. js/solid-.js

2. js/regular.js

3. js/brand.js

4. js/fontawesome .js

5. js/light.js

6. For all js, we can use js/all.js

There is one more file that is “ Shims ” file.

Shim file is created to be used as band-aids until you get time to upgrade. Version 4 allows you to keep v4 icon name, aliases, and syntax while mapping Version 5. If we want to use then add below extra line to our Version 5

<link rel=”stylesheet” href=”https://use.fontawesome.com/releases/v5.2.0/css/v4-shim.css”>

v4-shim is used for both Web Fonts + CSS and SVG + JS Frameworks.

If we want to use new and fancy SVG+JS of rendering icon, then switch the “css/all.css” into “js/all.js” also “css/v4-shims.css” into “js/v4-shims.js“

Step2: Add syntax in your HTML file

For Example:

<i class=”fal fa-rocket”></i>

<i class=”far fa-rocket”></i>

<i class=”fas fa-rocket”></i>

An effect you can see in below image:

Image: Font Awesome 5 Comparison

Note: In FontAwesome 5 some icon name are changed, if we don’t want to use them then, we have to add shim file. Version 5 has lots of icon but some icons are paid, if we want to use then we need to buy PRO Version .

Advantages:

1) Icon are designed using SVG and Javascript.

2) Icon Fonts are Ligatures and auto-accessibility.

3) Icon can be re-written, redesigned using CSS and JS.

A scheduled task is very important in Ruby on Rails application. Ruby on Rails does not have this type of “out-of-the-box” feature, but we can use the Cron job to achieve the purpose. Cron can be scheduled to send a reminder email, or scheduling to crawl something from another website on daily basis. In this blog, let’s quickly go through how to use Cron job.

What is CRON?

Cron task is a time-based job scheduler in Unix-like computer operating systems. Cron can be used to schedule jobs to run periodically at fixed times, dates, or intervals. Cron is most suitable for scheduling repetitive tasks in Ruby on Rails applications.

Let’s take an example of sending a daily digest email to persons or users. In this case, we might have a mailer like this using crontab:

#STEP 1.

The user can run any method from the terminal. Here I’m running an action inside a model i.e schedule_rb_method.

Open “app/models/reminder.rb” and then add the method for running an action as shown below.

Run rails runner “Reminder.schedule_rb_method” command inside the project path on the terminal, to check method is running or not.

#STEP 2.

Set the default rvm to the project.

run rvm --default use 2.5.0