Introduction

CSS Grid is new layout supported browsers. If we compare to with Bootstrap then CSS Grid does not require to include any external libraries, By adding CSS rules to parent (Grid Container) and to child elements (Grid Items).

CSS Grid is a two-dimensional grid layout, we can work with columns and rows. In comparison to Flexboxes (which is one-dimensional), the CSS Grid layout system provides you to build more complex layouts. It is possible we can use both: Flexbox and Grid Layout in CSS

In Bootstrap Grid Layout system it’s much cleaner to define the layout structure in CSS only. You don't need to include layout definition within your codes. This makes the code easier to read and you are able to quickly adapt the layout if needed without needing to rearrange your code.

Terminology

Grid Container

The grid container is the parent element of a grid layout system. The CSS rule display: grid needs to be applied to this container in order to active the CSS Grid layout mode.

Grid Line

Grid lines are the lines which define the structure of the grid and are dividing the grid into cells. Lines in a grid can be either vertically (dividing the grid into columns) or horizontally (dividing the grid into rows).

Each grid line has a unique number starting from 1 on the left side of the grid / on top of the grid. This line numbering is used to define the grid area. You’ll see a practical example later on.

Grid Cell

A grid cell is the smallest unit inside a grid and is the area between two adjacent column grid lines and two adjacent row grid lines.

Grid Area

Inside a grid, a grid area can be any area which is surrounded by four lines. Each area can comprise of any number of cells.

Grid Item

Any direct child elements of the parent grid container are called grid items.

 Defining Grid Column And Rows

grid-template-columns / grid-template-rows

The next step is to define grid columns and rows. This is done by adding CSS properties grid-template-columns and grid-template-rows to the definition of class container:

Location of Grid Items

grid-column-start / grid-column-end / grid-row-start / grid-row-end

So far our example showed that the defined grid elements are put into the grid cells one by another. Each grid item is placed inside one grid cell. You can change the grid item’s location and define that a grid item should span across multiple grid cells by using CSS properties grid-column-start, grid-column-end, grid-row-start, and grid-row-end.

To specify the location with these properties we’re referring to specific grid lines. Remember the lines are automatically numbered starting by 1 (both in a row and column direction).

Browser Support

Since the beginning of 2017 CSS Grid layout support has been shipped with the public released of all majors browsers like Firefox, Chrome, Opera, and Safari.

The IE/Edge version of the specification is prefixed with an -ms prefix and the properties implemented in IE/Edge. This means that the default CSS property names like:

grid-template-columns needs to be changed in IE/Edge to  -ms-grid-columns

First, lets get into what is Shopify?

Shopify is an e-commerce platform for online stores.

Shopify gives us a platform for creating our own online shopping stores.

What is Liquid?

Liquid is an open source template language created by Shopify and which is written in Ruby. All the Shopify themes are built using liquid so we can say it is the backbone of Shopify and is used to load the dynamic content of online stores.

Liquid acts as a bridge between the web layout and the website data.

Basically, a template language makes it possible to re-use the static elements that define the layout of a webpage, while dynamically loading the pages with data from a Shopify store. The static elements are of-course written in HTML, and the dynamic elements are written in Liquid.

How does Liquid work with Shopify?

1. User requests a URL of a Shopify store in the browser.

2. Shopify works out to find which store is being requested.

3. For the requested store, Shopify selects the required liquid template from the active theme directory.

4. The liquid content place-holder is replaced with the real data stored on the Shopify platform for the requested e-Commerce website.

5. After that, the compiled HTML file is sent to the browser.

6. The browser processes the HTML file and fetches all other required assets(images, JS, CSS, etc.) files.

Liquid Syntax:

Liquid code can be categorized mainly into three things: Objects, Tags, and Filters.

Objects:

• For displaying any object and or any variable name, we can use the output tag denoted by {{ …. }} double curly braces.

• For example, we can display the title of a page using {{ page.title }}. Here, Liquid is rendering the value of the object with the name page.title.

• Objects uses the dot syntax in-order to fetch any properties of an object.

Tags:

• Tags are used to create the logic and control flow part for the templates.

• The {% …. %} curly braces with a percent sign are used to denote a logic.

For example:

If the user is logged in and his name is Jay, then the above code will display - Hello Jay

Filters:

• Liquid filters are used to modify the output of any numbers, strings, objects, and variables.

• They are denoted by a pipe character “ | ” and are placed within an output tag {{ }}.

For example:

Liquid Collections:

• Liquid collection is different from product collection. Generally, a bunch of products that are grouped together logically is called a product collection and in Liquid, a collection is the number of objects that are all the same.

• Example: Collection of product images, etc

Conclusion:

Liquid is a powerful template language while working on the Shopify platform. And its similarity with HTML and ability to load the dynamic data makes it a great choice to create eCommerce websites with Shopify.

Introduction to ElasticSearch:

Elasticsearch is an open-source full-text search, real-time distributed engine. Developed on Java programming language, which enables Elasticsearch to run on different platforms.

Accessible from RESTful web service interface for querying and indexing massive amounts of structured data.

Elasticsearch can also be used as a data store engine.

General Feature:

Elasticsearch is scalable up to petabytes of structured and unstructured data. It can be used as a replacement of document stores like MongoDB where all the data store in a document.

The good thing about ElasticSearch is that, it an open source platform and available under the Apache license version 2.0.

Elasticsearch uses denormalization to improve the search performance.

Elasticsearch Advantages:

Elasticsearch is real time, in other words, after one second the added document is searchable in this engine. It is distributed from the cluster, which makes it easy to scale and integrate into any big organization.

Elasticsearch provides JSON objects as responses, which makes it possible to invoke the Elasticsearch server with a large number of different programming languages.

It also provides the feature of backup the data. Creates full backups easily by using the concept of the gateway.

Installation of ElasticSearch in Linux OS:

To begin, run the following command to import the Elasticsearch public GPG key into APT:

1]wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo apt-key add -

2]echo "deb https://artifacts.elastic.co/packages/6.x/apt stable main" | sudo tee -a /etc/apt/sources.list.d/elastic-6.x.list

3] sudo apt update

4] sudo apt install elasticsearch

Open the file for configuration

5] sudo nano /etc/elasticsearch/elasticsearch.yml

Add network.host: localhost

6] sudo systemctl start elasticsearch

7] To enable Elasticsearch to start up every time your server boots:

sudo systemctl enable elasticsearch

8] Test whether your Elasticsearch service is running by sending an HTTP request:

Run command on terminal

curl -X GET "localhost:9200”

Output will get in response:

{ "name" : "ZlJ0k2h", "cluster_name" : "elasticsearch", "cluster_uuid" : "beJf9oPSTbecP7_i8pRVCw", "version" : { "number" : "6.4.2", "build_flavor" : "default", "build_type" : "deb", "build_hash" : "04711c2", "build_date" : "2018-09-26T13:34:09.098244Z", "build_snapshot" : false, "lucene_version" : "7.4.0", "minimum_wire_compatibility_version" : "5.6.0", "minimum_index_compatibility_version" : "5.0.0" }, "tagline" : "You Know, for Search" }

Domain where we can use the ElasticSearch:

We can use the ElasticSearch where we have a huge amount of datasets and search data easily. Blog search document, E-commerce product sites, Geosearch data feature are the some domain where we can use the ElasticSearch.

Indexing in Elasticsearch:

Let’s say I have created an article in database

article#1 -> “global article"

article#2 -> “rails article"

article#3 -> “ruby on rails"

An inverted index for these records will be like this:

global -> article#1

article -> article#1, article#2

ruby-> article#3

In the inverted index,article#1 article#2 are the indices for ElasticSearch data. Now, searching for the word “article” uses the inverted index and return article#1 and article#2 directly.

Integration of Elasticsearch in Rails:

For integrating ElasticSearch, I created one rails application where simply implemented Article creation with fields Article title and content of the article. Also added one search form where I can search the text related to Articles.

To start using ElasticSearch add gems in Gemfile:

gem 'elasticsearch-model'

gem 'elasticsearch-rails’

Then we have to make the elastic search in the model we want to implement global search like below:

require 'elasticsearch/model'

class Article < ActiveRecord::Base

include Elasticsearch::Model

include Elasticsearch::Model::Callbacks

def self.search(query)

__elasticsearch__.search(

{

query: {

multi_match: {

query: query,

fields: ['title^10', 'text']

}

}

}

)

end

settings index: { number_of_shards: 1 } do

mappings dynamic: 'false' do

indexes :title, analyzer: 'english'

indexes :text, analyzer: 'english'

end

end

end

Article.__elasticsearch__.client.indices.delete index: Article.index_name rescue nil

# Create the new index with the new mapping

Article.__elasticsearch__.client.indices.create \

index: Article.index_name,

body: { settings: Article.settings.to_hash, mappings: Article.mappings.to_hash }

# Index all article records from the DB to Elasticsearch

Article.import

To create the indices in a model where a search will be execute ElasticSearch provide the method:

Article.__elasticsearch__.client.indices.create

To delete the indices use

Article.__elasticsearch__.client.indices.delete

There are many features provided by the ElasticSearch like keyword Analyser to search any text data using the keyword.

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

#STEP 3.

Creating a Crontab:

Cron is driven by a crontab (cron table) file, a configuration file that specifies shell commands to run periodically on a given schedule.

Users can have their own individual Crontab files in the system.

It’s pretty easy to start working with cron jobs in rails. You can start editing your cron tasks using the crontab command on your terminal:

Open your terminal: run crontab -e

This command will open a text file in your terminal’s default editor.

#STEP 4.

We are going to enter a line into this crontab file. It will have the following structure:

[timings] [switch to your app directory] && [path to ruby] script/runner -e [environment] “[model class name] . [ (run method name) path to cron log]”

By looking at the above line to understand: Run a task every day at 10 am.

1. If you try and save your crontab and you receive errors, make sure the whole command is in one line on your terminal.

2. If your model method runs OK, you should either get some mail as mentioned in the cron. However, if there is an error, you must check your cron method to check the log you created in rails to understand the error.

    

Crontab Syntax:

Once you’re in the editor, you can start creating and editing cron tasks in rails. To schedule a cron task, you need to define when the task will run, then define the command to trigger that task.

There are 5 variables that can be changed inside a cron task in Ruby on Rails application:

• 1st variable: Minute, which can be specified from 0 to 59 min

• 2nd variable: Hour, which can be specified from 0 to 23 hr

• 3rd variable: Day of Month, which can be specified from 1 to 23 day

• 4th variable: Month, which can be specified from 1 to 12 month

• 5th variable: Day of Week, which can be specified from 0 - 6 (Sunday = 0) week days

If the variable is a “*” it means for all.

If the variable is a series of number split by a comma “,”, it means OR condition on each of the specified number in Cronjobs.

Example:

Timing Format: 
minute   hour   day   month   weekday
0 30      *      *      *      *   example command to be executed

While cron jobs are useful and can get the job done in many instances, you should be careful in your decision of how to implement scheduled and delayed tasks in Ruby on Rails application.

In rails, Cronjobs are best for tasks that are not highly critical or essential to your application’s functionality or performance. They should also execute in a reasonably short amount of time so that they don’t bog down your rails server(s).

Every University has thousands of applications streaming in for each course. A single application has a minimum of three stages – the document submitted by the student, his/her interview and finally, uploading the financial proof. Managing all of this singularly is a huge challenge.

There is a strong need for providing a common platform for application management. Offshore System for Student Management, a software developed and managed by Cryptex Technologies, India is the perfect one-stop solution for this. This application is developed using Ruby on Rails technology.

It is integrated with a dashboard showcasing the various features of this application, you can easily navigate around to make your work easier.

The dashboard has options for viewing the student application checklist, interview scheduling and feedback, advanced search functionality, along with the financial document submission and COE.

A database of a thousand and more entries can be filtered according to the search requirement. You can generate reports for specified time durations in the form of graphs and charts.

An export data feature is introduced in this to export the online data directly to your desktop.

Another added feature of OSSM is that of accessing the information of the agent via whom the student has applied. This helps during future decision making, giving a constructive insight into the work done by each of the agents.

Having a consolidated application for admission procedure is a one-time solution for eliminating all the manual efforts and errors.

Contact us if your needs are similar to this and we will build a smooth student management platform for you.

Cryptex Technologies

Plot No.8, Gopal Nagar,Nagpur-440022,
Maharashtra, India

Contact No: +91-712-223-2300

Email ID: info@cryptextechnologies.com

Redis is an open source very fast, non-relational, in-memory data structure store. It stores data in the form of a key-value pair. Redis has a support of data structure like sets, hashes, strings, list. Redis is mostly used for the cache store.

When to use Redis?

Redis is used when we have a performance issue related to scalability. For example when we have data in the database which is not going to change frequently then you use Redis to cache that data to remove the load from the MySql or PgSql server.

How to use Redis in Ruby on rails?

In order to use Redis in Ruby on Rails application you have to follow the steps given below:

Step 1:

Add the following gem into the Gemfile of application and run the “bundle install” command.

Step 2:

Next is to create redis.rb file in config/initializers directory and add the following code into that file 

In the above code “app_name” is the Namespace of my application. Gem “redis-namespace” organize everything under one application wise namespace, when multiple applications use same Redis server.

Step 3:

Next, to instruct rails to use Redis as a cache store we have added following code into application.rb file.

Step 4:

In the below code I have written a query in booths_controller.rb file to fetch all booths of size 16m2. And write a helper method in booths_helper.rb to fetch the data from Redis.

In the above code when we call the new_booth method of booths_controller, it will call the fetch_booths_16 helper method.

In this fetch_booths_16 method, the booths_16 will get nil value because no data is pushed into redis yet. We then instruct rails to push booths_16 data into redis. Then after a subsequent call to this method, data will be fetched from redis.

Since we are loading data in new_booths as a json we have to change when you call @booth_size_16.name to @booth_size_16[“name”] because data is in the form of json.

Advantages of using Redis:

• Support for rich data structure types: hash, string, set, list, sorted etc.

• Data is stored in memory and retrieve quickly: Redis store data in memory so instead of requesting data from the server it will fetch from memory and retrieve data very quickly

• Redis is used to speed up service response.

• Redis is a very fast non-relational and NoSQL key-value pair data store.

• Redis allows to insert a large amount of data into its cache very easily: Sometimes a situation comes like we have to load a thousand pieces of data into cache in a short period of time. This can be done by Redis, with mass insertion feature of it.

• Redis uses “Redis hashing” which is its own hashing mechanism: Datastore in redis in the form of key-value pair i.e. string field and a string value.

Redis offers efficient caching mechanism and it will take very less time to implement this cache mechanism. But outcomes of using this will get high-performing cache system in our application.

So this is the way you can improve the performance and increase the scalability of Rails application to a great extent.

In this blog, you are going to learn about the deployment of rails application on the production server with its configuration setting in Apache. For this, you need to have Ruby, Rails, MySQL installed in your server system.

Let’s begin with the process of deploying the Rails application.

Step 1: Add the code copy to the server.

          For adding code to the server, you need to take a copy of the code on your server by login using sftp.

$ sftp user@yourserver.com

$ put samplecode

Step 2: Installation of project and configuration settings.

          Install all libraries of the project and make configuration settings including configuration of database.yml and secrets.yml by using following commands. For this, you need to login to the server using ssh and go to the project folder.

$ ssh user@yourserver.com

$ cd samplecode

          Rails app has ruby versions and you have to use that specific version to run the application. So, use the ruby version of the application.

$ rvm use (ruby version)

          Install all libraries of the project, set the database and compile assets. Rails have some specific commands to do that.

$ bundle install

$ rake db:create RAILS_ENV=production

$ rake db:migrate RAILS_ENV=production

$ rake assets:precompile RAILS_ENV=production

          Rails provide a secret key which you have to mention it into the config/secret.yml file of the application to maintain the security.

$ rake secret

Above command provide a secret key, add it to the config/secrets.yml file of you RoR project.

Step 3: Apache settings

          You have to do apache settings to run the application in production mode on apache server. For this first, you have to create samplecode.conf file in etc/apache2/sites-available/ path.

The file content will look like as in Image 1. Where you have to mention the domain of your application like www.myapp.com and server name like myapp.com. With this, you also have to mention the path of a public folder of the application and ruby version of the application.

Image 1: Samplecode.conf File

You need to create the symlink of the file samplecode.conf to the sites-enabled folder.  It is created for apache and virtual host settings. This virtual host setting will tell Apache where your application is located. Replace myapp.com with your application name and as well as mention path to ruby with the ruby version of the application into the samplecode.conf file.

          If you start the application on some port and not on some domain like www.myapp.com, you need to specify the port number in the conf file in place of port “80” at the top of the file. And then mention that port to the ports.conf file which is located at /etc/apache/ports.conf.

Image 2: Ports.conf File

In the above image, you can see how to mention port, like I have mentioned port 3000 to be heard by apache while serving the page. At last restart the apache server by using the following command. It will run the application on the link like 127.0.0.0:3000 or if it is for a domain then it will run on www.myapp.com or myapp.com.

$ sudo restart apache2 restart

In this way, you can start a rails app on the production server.

In my coding lifetime, I have enhanced and improved my coding style after client feedback and guidance. I have learned over the years of time, that there aspects and points that has utmost importance in the coding of Ruby on Rails (RoR) application.

We as developers start writing code without actually analyzing and understanding the code requirement as well. A messed up code is no one’s favorite and not to be delivered.

I am sharing my thumb rules that will surely help you as it did to me.

Rule No. 1: Indent your code

What if you are given a much messed up code to update? I am sure you will get frustrated; in order to write very clear code keep it well indented. In Ruby on rails, though the auto-generated code is four space indented style we should use two spaces to intend our block of code as this is most widely adapted style. This improves the readability of our code.

Rule No. 2: Name it well!

Naming convention should be followed as this is helpful for us to understand the purpose of it and at certain places, active record in ruby also works on the basis of names.

Active record uses the same naming convention in order to find out how the mapping between the models and database tables are created.

Say for example a class “Category”, should have a database table called “Categories”. The rails pluralization mechanism is very powerful such that it is capable of pluralizing both regular and irregular words.

When it comes to naming a variable, you should follow CamelCase form, which says that the first word should start with a small letter and the next word should start with a capital letter, e.g. “categoryOne”.

When the table name has two words, it should be separated by “_” , e.g. “book_categoryies”. When it comes to model class, it should be singular with the first letter of each word capitalization e.g. “CategoryBook”.

Similarly, the name of methods should be such that it should define the purpose of that method, for e.g. “category_list”.

Rule No. 3: Less If else, Less complex

If else statement is a block of condition where you check the condition if it is true or false.

Using the number of if-else statement creates makes the code bulky. It will increase the number of lines in the code, which can be reduced or should not be used at all. It also makes the code complex and not easy to understand.

Rule No. 4: Use of a number of variables

What do variables do in rails? It allocates the memory for which it is assigned for. When the expression can be directly assigned or can be directly passed, a variable should not be used as this will be the unnecessary allocation of memory, unnecessary declaration of a variable.

In Ruby on rails development, we have four different types of variables global variables, class variables, instance variable and local variables.

Global variables are accessible globally in the application which means it can be modified from any part of the program hence it let to lack of security of our code.

Hence it is recommended not to use global variables.

Always try to replace instance variable with local variable as local variables are accessed locally which ensures the security of our code.

Rule No. 5: Put-up a comment there

Comments are the description written in the source code within the special character so that it should be ignored by the compiler.

What if, you get a new project with some classes having methods in it? Will you be able to understand the purpose of it?

Even, if the method name is good enough? No, sometimes only method names do not help in recognizing or understanding the main purpose of the method or how it works, hence your method should be well commented in order to let others also understand its basic purpose.

Rule No. 6: Don’t put too much logic in the view, make use of helpers, create them!

Views are specially meant for displaying the data hence it should not have too much logic, this can be done by making use of helpers, if the piece of code is used many times in a view, make a helper and call it in a view.

So, these are my six thumb rules while writing code, from the time that I have become the developer. These have helped me and can be taken as consideration to make your code scalable, robust and secure.

This will add sparkle to your code, which will eventually make your client happy! :)  

If you have a different lookout, let me know your views, in the comments section below.

Automated testing is extremely on the boom, across the board nowadays and obviously Ruby has its own arrangements to make it work for Ruby on Rails developers. One of these is RSpec, a madly prevalent tool for mechanized testing. The fortunate thing about it is we can test almost every part of RoR Application easily.

Rspec is easy to get it up and running, expressive way to write test cases, easy to use and also fast.

Let’s start with assembling all the components together to start with:

To begin it’s necessary to install Ruby. You can do it from here for Windows OS:  http://www.rubyinstaller.org

After completing installation let’s check if Ruby is installed properly along with version number.

• For this go to command prompt and type:

                 ruby -v

        You will get the following result.

• Next, you need to install RSpec gem. Gem is Ruby library which can be used in one’s own code.
• Go to command prompt and type the following :

       gem install rspec

       You will get the following output:

    Done installing documentation for diff-lcs, rspec-support, rspec-mocks,

rspec-expectations, rspec-core, rspec after 22 seconds 

6 gems installed

• To start with Selenium in Ruby you also need to install the gem selenium-webdriver which will act as a binder for Ruby from the command line.

Type the following command to install ‘selenium-webdriver’:

gem install selenium-webdriver

• Now, create directory i.e. folder to store Rspec scripts. Open your command prompt and change the directory path to the one where you would be saving your scripts.

Example: If your directory name is ‘sample_scripts’ on desktop:

C:\Desktop\sample_scripts>

Let’s start with writing script in Rspec.

So for this open any editor. Here, I have used sublime.

• Write the following code in the sublime editor and save it. Save it with name sample.rb

• To run the script go to command prompt and type:

C:\Desktop\sample_scripts>rspec sample.rb

 You will get the output as following after executing the script:

 Finished in 0.002 seconds (files took 0.11101 seconds to load)   1 example, 0 failures

Keywords in Rspec:

As this is targeted to new coders, you need to know some keywords which are meant to be used in your code. This helps in understanding the protocol to be followed while coding.

• describe..... do

Description of the collection of related test cases

• it......do

Individual test cases

• Before() and After()

Optional test statements run before and after each or all test cases.

So, let’s hope you have understood the significance of using RSpec while automation testing.

This reduces your time to test & increases the efficiency of testing.

The code quality is needless to mention becomes high.

All these steps are for test-driven development (TDD) environment if you want to know how to use RSpec in Behaviour Driven Development (BDD) please refer our previous blog about it.

Aren’t we testers meant to have this as our focus? This is all about the beginning of using RSpec in your Ruby on Rails Development process.

When working in a team, you may have come across a situation wherein there are many copies of Code of your Ruby on Rails Application and then you really don't know if it has been updated,well-organized or well merged, for that matter, haven’t you?

Well, GitHub is your solution to the same.GitHub is that platform that I rely a lot on my coding. Be it organizing, updated code or merging code, this platform takes care of it all.

GitHub is a code hosting platform for version control and collaboration. It is a very useful tool that allows you to work in any geographical location.

GitHub is the most powerful platform for management and review of the code. Github is used for managing the code on the single platform. Using GitHub you can track the changes of each commit. Github also provides public and private repositories. The public repository is most commonly used for open source software applications.

Let’s learn:

• How to create a repository in a GitHub?
• How to create new branches and manage these branches in  GitHub?
• How to push your code in GitHub?
• How to manage commits?
• How to create and manage pull request GitHub?.

I’ll start considering you a RoR developer and then, of course, you know how to create your account in GitHub. Well, You should know that!

        On Logging into GitHub, you’ll find many options and parameters but for a kick-start to committing codes in GitHub, first, you need to create a repository.

     Create a repository in a GitHub :

The GitHub repository is a  virtual directory or space where we can access your project, its files, and all related data.

On click of new repository button, you will be redirected to new directory form page. You need to follow the below steps to create a new repository in GitHub.

1. Write a valid name for the repository
2. Write a short and simple description of the project.
3. Click on new repository button to submit the form for creating the repository.

After successful submission of the form, you will be redirected to the Setup page of the created repository.

First of all, take a clone for the projects, you need to make your backup is ready!. Use the following command.

git clone https://github.com/Test/sample-app.git

Then you need to change the directory

cd sample-app

If you want to create a new branch by command line and switch to that branch you can use the below command.

git checkout -b  NC-2018-06-charts-data

Your  branch name should be short and descriptive

You can also change the current working branch by using the below command.

git checkout  NC-2018-06-charts-data

Push the code:

Now, once whatever changes you have made in the file you can track by using the below command.

git status

The above commands will list out all of the changes in files.

You can also check what contents and lines have been modified by using the below command. It will list out the changes, the Green color will show the line added and the red color will show line removed

git diff “file_path”

If the files are ready to push you can add these files by using the below command.

git add “file_path”

You can also remove the file from your local system and the remote system.

First, you need to delete the files locally then after executing the command “git status” it will list out the files that have been removed locally, then you need to run.

git remove “file_path”

After adding all the files you can commit the code on the remote server.

git commit -m “The commit message”

After adding all the files you can push the code on a remote server by using the command.

git push origin Rs-2018-06-charts-data

Manage commits:

IF you have NOT pushed your changes to the remote repository and just committed the code and then you may want to remove the commit, use.

git reset HEAD~1

If you have pushed your changes and you may want to revert to the previous commit then you need to run the below command.

git revert HEAD