Django REST API using code first approach

In the previous post we have set up the application with JWT authentication.

In this post we will learn about how to use a code first approach to create api through which you can add, edit, delete and read the data in the table.
Given below are the steps -
1) Create a model with name and desc as text fields.

class mytable(models.Model):
    name=models.CharField(max_length=200)
    desc=models.TextField()

2) Migrate the changes to the database by
    a) Cerate the list of changes to be migrated to the database using the command - python manage.py makemigrations
    b) Add the changes to the table - python manage.py migrate
   
3) Create a file called serializers.py inside the app and add the code below -
   

class mytables(serializers.ModelSerializer):
        class Meta:
            model=mytable
            fields=('name','desc')
    

4) Next we need to add views to define the web api in views.py:
    a) Add the below imports into the code -
        from django.shortcuts import render
        from azure.servicebus._http import HTTPResponse
        from .models import *
        from .serializers import *
        from rest_framework.views import APIView
       
    b) Add the below code for reading the data in the table -
   

        class my_list(APIView):
            def get(self,request,format=None):
            dat=mytable.objects.all() #to get all the data from the table
            serialized=mytables(dat,many=True) #to serialize the data
            return Response(serialized.data) #to return the serialized data

   
    c) To insert data into the table -

        @api_view(('POST','PUT'))
        def test_insertmod(request):
            try:
                indata=request.POST.get('name')
                indesc=request.POST.get('desc')
                inkey=request.POST.get('key')
                testinstance=mytable.objects.create(id=inkey,name=indata, desc=indesc)
                return Response('Successfully inserted')
            except Exception as e:
                print(e)
                return(e)

   
    d) To update the data in the table
   
   

        @api_view(('POST','PUT'))
        def test_insertmod(request):
            try:
                indata=request.POST.get('name')
                indesc=request.POST.get('desc')
                inkey=request.POST.get('key')
                testinstance=mytable.objects.create(id=inkey,name=indata, desc=indesc)
                return Response('Successfully inserted')
            except Exception as e:
                print(e)
                return(e)

   
    e) To delete the data in the table -
   

@api_view(('POST','PUT'))
def test_deletemod(request):
    try:
        indata=request.POST.get('name')
        testinstance=mytable.objects.get(name=indata)
        testinstance.delete()
        return Response('Successfully deleted')
    except Exception as e:
        print(e)
        return(e)

5) Now that we have the views in place, we need to make the urls so that the views can be accessible -

    url(r'^mylist/', views.my_list.as_view()),
    url(r'^modinsert/',views.test_insertmod),
    url(r'^modupdate/',views.test_updatemod),
    url(r'^moddelete/',views.test_deletemod),

Now that we are done, start the django project and use the postman in chrome to test it -

Please ensure that you have the url authorized using the link http://127.0.0.1:8000/webs/auth-jwt/ and authenticating the api using the userid and password.

1) To insert data into the table - http://127.0.0.1:8000/webs/modinsert/
   

   

2) To read the data in the table use the url - http://127.0.0.1:8000/webs/mylist/

3) To update the data in the table use the url - http://127.0.0.1:8000/webs/modupdate/

4) To delete a key in the table use the link - http://127.0.0.1:8000/webs/moddelete/

   

Setting up Django Rest API with JWT authentication - Part 1

In this post, I will cover how to setup project and application for REST API and secure it using JWT.

Software used -
1) OS - Windows 10
2) Python - 3.6 (command: Python --version)
3) Django - 1.11.2 (Command: python -c "import django; print(django.get_version())")
4) Django Rest Framework - 3.6.3
5) Django Rest Framework JWT - 1.11.0 dist
6) Eclipse IDE

Setting up of Project and folder structures

Step 1 - Create a django project by clicking on File > New > Other and then selecting PyDev Django Project

Step 2 - Open command prompt and go to the location where the project is present and type the below command -
    django-admin.py startproject djangowebs
   
    Then in order to create an app inside the project you need to use
    python manage.py webs
    You can have any name of your choice in place of webs.

Configuration of the database and authentication    

Step 3 - Open the settings.py in your project and add the below one in place of the existing DATABASES (This will be pointing to sqllite3 by default). I have used postgres in this case.

    DATABASES = {
        'default': {
            'ENGINE': 'django.db.backends.postgresql_psycopg2',
            'NAME': '<Name of the database>',
            'USER': '<Name of the user having access to db>',
            'PASSWORD': '<PASSWORD>',
            'HOST': '<Server name or ipaddress>',
            'PORT': '<Port number, if it is default it can be left blank>',
        }
    }

   
Step 4 - Now, lets move the authentication tables into the database. This is done in 3 steps:
    a) To allow django to make scripts for migration using the command -
        python manage.py makemigrations
    b) To make the changes into the database based on the configurations made in Step 3 -
        python manage.py migrate
    Once this is done, login into the database and ensure that the new tables and functions (in case of postgres) appear in the database.
    c) To create a superuser who has complete access to the entire db and application.
        python manage.py createsuperuser
        This will prompt you for userid and password along with confirmation of password.
       
    Once you add this, start the app: this usually will be http://127.0.0.1:8000/admin
    login using the superuser created above and it should allow you to login.


Django App Settings:

Step 5 - Add the below to your INSTALLED_APPS

    'webs',  -> This will be the app you just created in step 2
    'rest_framework.authtoken', -> This is used for authentication
    'rest_framework_jwt',  -> This is used for authentication via JSON Web Tokens (JWT)

Your INSTALLED_APPS should look like the below:

        INSTALLED_APPS = [
            'django.contrib.admin',
            'django.contrib.auth',
            'django.contrib.contenttypes',
            'django.contrib.sessions',
            'django.contrib.messages',
            'django.contrib.staticfiles',
            'rest_framework',
            'webs',
            'rest_framework.authtoken',
            'rest_framework_jwt',
        ]

Step 6 - In order to use JWT based authentication you need to add REST_FRAMEWORK. Please ensure the order is maintained as shown in the snippet below:

        REST_FRAMEWORK = {
            'DEFAULT_AUTHENTICATION_CLASSES': (
                'rest_framework_jwt.authentication.JSONWebTokenAuthentication',
                'rest_framework.authentication.TokenAuthentication',
                'rest_framework.authentication.BasicAuthentication',
                'rest_framework.authentication.SessionAuthentication',
            ),
            'DEFAULT_PERMISSION_CLASSES': (
                'rest_framework.permissions.IsAuthenticated',
                #'rest_framework.permissions.AllowAny', (To be used instead of IsAuthenticated if you do not want any authentication for the web API)
            )
        }

Step 7 - Add the below for JWT settings:

       

JWT_AUTH = {
            'JWT_ENCODE_HANDLER':'rest_framework_jwt.utils.jwt_encode_handler',
            'JWT_DECODE_HANDLER':'rest_framework_jwt.utils.jwt_decode_handler',
            'JWT_PAYLOAD_HANDLER':'rest_framework_jwt.utils.jwt_payload_handler',
            'JWT_PAYLOAD_GET_USER_ID_HANDLER':'rest_framework_jwt.utils.jwt_get_user_id_from_payload_handler',
            'JWT_RESPONSE_PAYLOAD_HANDLER':'rest_framework_jwt.utils.jwt_response_payload_handler',
            'JWT_SECRET_KEY': SECRET_KEY,
            'JWT_GET_USER_SECRET_KEY': None,
            'JWT_PUBLIC_KEY': None,
            'JWT_PRIVATE_KEY': None,
            'JWT_ALGORITHM': 'HS256',
            'JWT_VERIFY': True,
            'JWT_VERIFY_EXPIRATION': True,
            'JWT_LEEWAY': 0,
            'JWT_EXPIRATION_DELTA': datetime.timedelta(seconds=300),
            'JWT_AUDIENCE': None,
            'JWT_ISSUER': None,
            'JWT_ALLOW_REFRESH': True,
            'JWT_REFRESH_EXPIRATION_DELTA': datetime.timedelta(days=7),
            'JWT_AUTH_HEADER_PREFIX': ('JWT','Bearer'),
            'JWT_AUTH_COOKIE': None,
        }

       
Step 8 - Setting up urls in the project to make it understand the app which you have installed.

        url(r'^webs/',include('webs.urls')),
       
        Your urls.py in the main project file should look like:
       

        from django.conf.urls import url, include
        from django.contrib import admin

        urlpatterns = [
            url(r'^admin/', admin.site.urls),
            url(r'^webs/',include('webs.urls')),
        ]

       

Step 9 - Setting up the app urls for authentication related tasks
       
        imports which need to be added:
       

        from rest_framework_jwt.views import obtain_jwt_token
        from rest_framework_jwt.views import refresh_jwt_token
        from rest_framework_jwt.views import verify_jwt_token

       
        urls which need to be added within urlpatterns -
       

        url(r'^auth-jwt/', obtain_jwt_token),
        url(r'^auth-jwt-refresh/', refresh_jwt_token),
        url(r'^auth-jwt-verify/', verify_jwt_token),

       
To test the above application -

1) use http://127.0.0.1:8000/admin and provide userid and password used for superadmin, it should allow you to login.
2) To test the JWT part, install postman plugin in chrome, then provide the url along with User ID and password used for super admin in header and you can see the token as shown in the image below. 

In the up coming posts, I shall cover
1) Creating CRUD rest api using code first approach.
2) Creating CRUD rest api using database first approach using sqlalchemy
3) Creating CRUD rest api using stored procedure / functions in database and not using any ORM.

Connecting to Active Directory using Python

This post speaks about connecting to Active Directory using python - 

python provides the ldap3 for python which can be used to connect to active directory servers. The below code will take the userid and password of the user and check it against active directory to verify the user and his credentials.

import sys
from ldap3 import Server, Connection, ALL, NTLM, ALL_ATTRIBUTES, ALL_OPERATIONAL_ATTRIBUTES, AUTO_BIND_NO_TLS, SUBTREE
from ldap3.core.exceptions import LDAPCursorError

server_name = 'your server name or ipaddress'
domain_name = 'your domain name'
user_name = <username of the user>
password = <password of the user>


format_string = '{:40}   {}'

server = Server(server_name, get_info=ALL)
conn = Connection(server, user='{}\\{}'.format(domain_name, user_name), password=)
if not conn.bind():
    print("error")
else:
    print("sucessful")
   
print(format_string.format('Group', 'Description'))

#CN to get the only the users and not the servers
conn.search('CN=users,dc=domain_name,dc=com'.format(domain_name), search_filter='(&(samAccountName=' + '' + '))',search_scope=SUBTREE,attributes=[ALL_ATTRIBUTES, ALL_OPERATIONAL_ATTRIBUTES])
for e in sorted(conn.entries):
    try:
        desc = e.description
    except LDAPCursorError:
        desc = ""
    print(format_string.format(str(e.name), desc))

This code will connect and print. However this code is not production ready code as you can see there is no exception handling, and the values are more or less hard coded in the code.

Send email using Python with To, Cc, and Bcc

So this is a very small post on how to send email in python where in there needs to be users in To, Cc and Bcc. 

Let us say we need to send mail with the below details - 
From address - abc@gmail.com
To address - def@gmail.com
Cc address - d@gmail.com, e@gmail.com
Bcc address - f@gmail.com 
Email subject - test
Email Body - test body
smtp - smtp.gmail.com
port - 587

*please note the email random.

Based on the above below is the code and explanation is above each one of the lines

import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.mime.base import MIMEBase
from email import encoders
import sys
import logging
import os
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))


def sendemail(fromaddr,senderpwd,smtp,port,msgSubject,msgBody,toaddr,cc,bcc):
      
    # instance of MIMEMultipart
    msg = MIMEMultipart()
    toaddr = toaddr 
    # storing the senders email address  
    msg['From'] = fromaddr
     
    # storing the receivers email address 
    msg['To'] = toaddr
    msg['Cc'] = cc
    msg['Bcc']= bcc
     
    # storing the subject 
    msg['Subject'] = msgSubject
     
    # string to store the body of the mail
    body = msgBody
     

     
    msg.attach(MIMEText(body, 'plain'))
     
    
      
    # creates SMTP session
    s = smtplib.SMTP(smtp, port)
     
    # start TLS for security
    s.starttls()
     
    # Authentication
    s.login(fromaddr, senderpwd)
     
    # Converts the Multipart msg into a string
    text = msg.as_string()
    msg.attach(body)
     
    # sending the mail
    s.sendmail(fromaddr, [toaddr,cc,bcc], text)
     
    # terminating the session
    s.quit()
    



def main():
    sendemail(' abc@gmail.com','randaompawd','smtp.gmail.com',587,'test','body test','def@gmail.com','d@gmail.com,e@gmail.com','f@gmail.com')
    
if __name__=="__main__":
    main()

Cross database query in Postgres

We might face a scenario where in you want to create a query across databases or want to refer to the data in other database. Now postgres does not directly allow the users to do this. We would require to do workaround for the same using dblink. 

Given below are the steps we need to follow - 

Step 1 -
install dblink using extension in the database as shown in the image below - 

once you add it, you should be able to see the extension as shown in the image below: 

Step 2 -
then have the user who has or does not have password, but make sure he has access to the foreign db.

Step 3
then use the below query. 

select dblink_connect('<servername of your choice>',
                      'host=<hostname or ip> 
                       port=<port number> 
                       dbname=<database for which the user needs to connect> 
                       user=<username> password=<password>'

select * from dblink('<servername used above>', 
                     <query>) as <alias>(return columns along with datatype eg - id integer, name text)

example -

SELECT dblink_connect('test2server', 'host=127.0.0.1 port=5432 dbname=test2 user=testuser'); 
select *
from dblink('test2server',
           'select * from users')
           AS users_test2(id integer,name text)

you can have a user with or without password depending on your usecase

Visitor Pattern

Definition -

    Allows one or more operations to be applied at run time allowing the operations to be decided at runtime rather than compile time.


Scenario -
   
    Let us take the same example of a car customization plant where you can customize the windshield color, wheel, color, stripes.
1) We will have an interface called customizable which will be implemented by the components which can be customized based on the users wish else it will use the default. The following things can be customized - windshield color, stripes, wheel.

package VisitorPattern;

public interface customizable {
    
    public void addtocar(customizer c);

}

2) We will have concrete classes for the same windshieldcolor, stripes, wheel.
windshield.java

package VisitorPattern;

public class windowshield implements customizable{
    
    String color;
    
    public windowshield(String color) {
        this.color=color;
    }

    @Override
    public void addtocar(customizer c) {
        
        c.addcomponent(this);
        
    }
    

}

stripes.java

package VisitorPattern;

public class stripes implements customizable{
    
    String stripestyle;
    
    public stripes(String stripestyle) {
        this.stripestyle=stripestyle;
    }

    @Override
    public void addtocar(customizer c) {
        
        c.addcomponent(this);
        
    }
    
    

}

wheel.java

package VisitorPattern;

public class wheel implements customizable {

    String style;
    
    public wheel(String style) {
        this.style=style;
    }
    
    @Override
    public void addtocar(customizer c) {
        
        c.addcomponent(this);
        
    }

}

3) We will have a component called customizer which will be an interface and will have the call to all the customizable components. The interface will enable us to extend in future and be used as a standard across different types of vehicles in future.

package VisitorPattern;

public interface customizer {
    
    public void addcomponent(windowshield w);
    public void addcomponent(wheel wl);
    public void addcomponent(stripes s);

}

4) We will have implementer which is a concrete implementation of the customizer.

package VisitorPattern;

public class customizerimpl implements customizer {
    
    

    @Override
    public void addcomponent(windowshield w) {
        
        System.out.println("Adding windshield of color: "+w.color);
        
    }

    @Override
    public void addcomponent(wheel wl) {
        
        System.out.println("Adding wheel of style: "+wl.style);
        
    }

    @Override
    public void addcomponent(stripes s) {
        
        System.out.println("Adding stripes of style: "+s.stripestyle);
        
    }

}

To see this pattern in action use the code below - 

package VisitorPattern;

import java.util.ArrayList;

public class visitordemo {

    public static void main(String[] args) {
        
        ArrayList<customizable> customcomp=new ArrayList<customizable>();
        customcomp.add(new windowshield("Blue"));
        customcomp.add(new wheel("Yokohama Pro ++"));
        customcomp.add(new stripes("Stripe1"));
        
        customizer creator=new customizerimpl();
        
        for(customizable tempc: customcomp) {
            tempc.addtocar(creator);
        }

    }

}

Place to use -
1) When you want to call different functionalities based on user input and it might be unrelated objects which might be passed based on scenario.

The code for the above is present in the link

Template Pattern

Definition -

    As the name states, this pattern will provide a template of steps to be followed inorder to complete a task or part of a task.

There will be an interface or an abstract class which will be used by concrete classes and implement or extend all the steps.
Scenario -
   
    Let us take the same example of a car manufacturing plant where in the plant manufactures a car or sedan. The process to build either car is the same hence -
1) We will have an abstract class called buildcar with the following functions - getchassis, addwheel, addengine, addseats. 

package TemplatePattern;

public abstract class buildcar {
    
    public abstract void getchassis();
    public abstract void addengine();
    public abstract void addwheels();
    
    public final void build() {
        getchassis();
        addengine();
        addwheels();
        System.out.println("Completed building");
    }

}

2) We will have two concrete classes called hatchback and sedan.
hatchback.java
 

package TemplatePattern;

public class hatchback extends buildcar {

    @Override
    public void getchassis() {
        
        System.out.println("Getting chassis for a hatchback");
        
    }

    @Override
    public void addengine() {
        
        System.out.println("Adding engine to hatchback");
        
    }

    @Override
    public void addwheels() {
        
        System.out.println("Adding wheels to hatchback");
        
    }

}

sedan.java
 

package TemplatePattern;

public class sedan extends buildcar {

    @Override
    public void getchassis() {
        
        System.out.println("Getting chassis for a sedan");
        
    }

    @Override
    public void addengine() {
        
        System.out.println("Adding engine to sedan");
        
    }

    @Override
    public void addwheels() {

        System.out.println("Adding wheels to sedan");
        
    }

}

3) The below code shows the demo for the same

package TemplatePattern;

public class templatedemo {

    public static void main(String[] args) {
        
        buildcar bc=new hatchback();
        bc.build();
        

    }

}

Place to use -
1) When have a scenario which can be made into templates.
2) You want to control what happens at each step and avoid rewriting the code in multiple places.

The code used above is present in the link

Strategy Pattern

Definition -

    This is a pattern where in the client can choose among the options available to perform a specific task.
   
Scenario -
   
    Lets take a scenario where in you want the user to login via either forms authentication or google or facebook id. In this case you can apply the strategy pattern where in the same task of authentication is done but the method by which the authentication is done is different.
   
Based on the above -
1) We will have an interface called iauthenticate with a function called authenticateuser.

package StrategyPattern;

public interface iauthenticate {
    
    
    public boolean authenticateuser();

}

2) We will have two concrete classes called formsauthentication and googleauthentication.
formsauthentication.java
 

package StrategyPattern;

public class formsauth implements iauthenticate{

    String user;
    String password;
    
    public formsauth(String usr, String pwd) {
        this.user=usr;
        this.password=pwd;
    }
    
    @Override
    public boolean authenticateuser() {
        String pwd=getauthdetails(this.user);
        if(pwd==this.password) {
            return true;
        }
        else {
            return false;
        }
        
    }

    
    public String getauthdetails(String user) {
        
        return "*******";
        
    }

}

googleauthentication.java

package StrategyPattern;

public class googleauthentication implements iauthenticate {

    
    String user;
    String token;
    
    public googleauthentication(String usr,String tkn) {
        this.user=usr;
        this.token=tkn;
    }
    
    public String getauthdetails(String user) {
        //get the token from google
        return "axr4550313djrldoepcvjrmvrortjvlr";
    }

    @Override
    public boolean authenticateuser() {
        String temptkn=getauthdetails(this.user);
        if(this.token==temptkn) {
            return true;
        }
        return false;
    }

}

3) We will have a class called strategydemo which will have the option chosen by the user to authenticate and gain access into the system.
 

package StrategyPattern;

public class Strategydemo {
    
    public static void main(String args[]) {
        
        iauthenticate ia=null;
        String authtype="forms";
        
        if(authtype.equalsIgnoreCase("forms")) {
            ia=new formsauth("user1","*******");
        }else if(authtype.equalsIgnoreCase("Google")) {
            ia=new googleauthentication("user1","axr4550313djrldoepcvjrmvrortjvlr");
        }
        
        if(ia.authenticateuser()) {
            System.out.println("Authentication successful");
        }
        
    }

}

Place to use -
1) When you want to choose a technique to perform a functionality but you want to provide flexibility in terms how this can be achieved.

The code used above is present in the link here

State Pattern

Definition -

    This is a pattern where in the object changes its behavior based on the state.
   
Scenario -
Let us consider a scenario where in the windshield of your car has to start the wiper if the rain starts or it needs to enable polarized light depending on the intensity of light.

Based on the above -
1) A interface called eventstate which will have a method called performaction.

package StatePattern;

public interface eventstate {
    
    public void performaction();

}

2) A class rain which will implement the eventstate.

package StatePattern;

public class rain implements eventstate {

    @Override
    public void performaction() {
        
        System.out.println("Wiper will be turned on");
        
    }

}

3) A class day which will implement the eventstate.

package StatePattern;

public class day implements eventstate {

    @Override
    public void performaction() {
        
        System.out.println("Wiper will be turned on");
        
    }

}

4) A windshieldcontext which will perform action based on state.

package StatePattern;

public class windshieldcontext implements eventstate {
    
    eventstate es;
    
    public void setcontext(eventstate e) {
        this.es=e;
    }

    @Override
    public void performaction() {
        
        this.es.performaction();
        
    }

}

5) The client code for the same is given below

package StatePattern;

public class statedemo {
    
    public static void main(String args[]) {
        eventstate es;
        windshieldcontext ws=new windshieldcontext();
        String states="Rain";
        if(states.equalsIgnoreCase("Rain")) {
            es=new rain();
            ws.setcontext(es);
        }
        else if(states.equalsIgnoreCase("Day")) {
            es=new day();
            ws.setcontext(es);
        }
        
        ws.performaction();
        
    }

}

Place to use -
1) When you have want the object to behave different in different scenarios and at the sametime decouple the systems so that the conditions are decided only in run time and not in compile time.

The code for the above is present in the link here

Observer Pattern

Definition -

    It provides a proxy implementation for another object and controls access to the real object.

These are patterns which you would be using unknowingly (if you are new to design patterns) in the click event listener or the event listeners.
Scenario -

1) Let us have a class called obsrvvalue which will have a variable whose value is being observed. This is called observable.

package ObserverPattern;

import java.util.Observable;

public class obsrvvalue extends Observable {
    
    private int val=0;
    
    public obsrvvalue(int newval) {
        this.val=newval;
    }
    
    public void setnewval(int newval) {
        this.val=newval;
        setChanged();
        notifyObservers();
    }
    
    

}

2) Let us have a class called observerobject which will observe the observable object and check if the value is same or not and report.

package ObserverPattern;

import java.util.Observable;
import java.util.Observer;

public class observerobject implements Observer{
    
    
    private obsrvvalue obs=null;
    
    public observerobject(obsrvvalue o) {
        this.obs=o;
    }

    @Override
    public void update(Observable arg0, Object arg1) {
        if(arg0==arg1) {
            System.out.println("Both are equal");
        }
        else {
            System.out.println("The value is updated");
        }
        
    }

}

3) To see the pattern in demo use the code below

package ObserverPattern;

public class observerdemo {
    
    public static void main(String args[]) {
        
        obsrvvalue o=new obsrvvalue(10);
        observerobject oo= new observerobject(o);
        o.addObserver(oo);
        o.setnewval(10);
    }

}

Place to use -
1) When you have listener waiting to act if the object changes.

The code for the above is present in the link here

Memento Pattern

Definition -

    This pattern provides ability to make efficient use of resources when there are too many objects created by reusing some or all of them.
   
Scenario -

    The most common example and the best suited that example you will see for this is a file editor where in the file gets saved after sometime and if the system shuts down unexpectedly on restart the system will give you an option to recover a saved state. This is one of the best example you can get for this.
Based on the above -
1) There will be a class filesavedstate which will server memory of the previously automated saved state.

package Memento;

public class filesavedstate {
    private String data;
    
    public filesavedstate(String state) {
        this.data=state;
    }
    
    public String getdata() {
        return this.data;
    }

}

2) There will be a class called file which will be modified by a program and saves its state into the filesavedstate class and obtains it if necessary.

package Memento;

public class file {
    
    public String filedata;
    filesavedstate fs;
    public file(String content) {
        this.filedata=content;
    }
    
    public void savestate() {
        fs=new filesavedstate(this.filedata);
    }
    
    public void getsaveddata() {
        String saveddata=fs.getdata();
        System.out.println("The saved data is :"+saveddata);
    }
    

    public static void main(String[] args) {
        
        file f=new file("Trying to show a demo");
        f.savestate();
        f.getsaveddata();
    }

}

Place to use -
1) When you want to save a state of the object and use it for later.
2) Useful in editors.

The code for the above can be found in the link here

Mediator Pattern

Definition -

    This provides the ability to have effective communication between two modules or objects within the same module. This provides centralized control over the system.

Scenario -

    Let us take an example of an object wanting to write into a filesystem. In this case we will have a mediator to which all the objects will communicate and write into the file.
Based on the above scenario -
1) filemediatorinterface class who provides the implmentation guidelines 

package MediatorPattern;

public interface ifilemediator {
    
    public void addrequest(filemod f);
    
    public void addfile(File f);
    
    public void givecontrol(File f, filemod fm);
    

}

2) A filemod class which wants to modify a file.

package MediatorPattern;

public class filemod {
    
    String modname;
    File filename;
    
    public filemod(String name, File file) {
        this.modname=name;
        this.filename=file;
    }
    
    public void modifyfile(File f) {
        System.out.println("Modifying file : "+f.filename);
    }

}

3) A File class which is the one to be modified.

package MediatorPattern;

public class File {
    
    public String filename;
    
    public File(String name) {
        this.filename=name;
    }
    

}

4) A filemediator which controls which object gets to perform action.

package MediatorPattern;

import java.util.ArrayList;

public class filemediatorImpl implements ifilemediator{
    
    ArrayList<filemod> fm=new ArrayList<filemod>();
    
    ArrayList<File> f=new ArrayList<File>();
    

    @Override
    public void addrequest(filemod f) {
        
        System.out.println("Adding request :"+f.modname+ " into the queue");
        fm.add(f);
        
    }

    @Override
    public void givecontrol(File f, filemod fm) {
        
        System.out.println("Giving control to filemod "+fm.modname+" over the file "+f.filename);
        fm.modifyfile(f);
        
    }

    @Override
    public void addfile(File f) {
        
        System.out.println("Fetching file "+f.filename+ " for modification");
        
    }

}

Place to use -
1) When you have too many objects from a system speaking too many objects of other system.
2) You have very structured communication channel

The code for the above is present in the link here

Interpreter Pattern

Definition -

    The use of an interpreter that used to interpret the requests from the client through the use of representations.

Scenario -

    Let us take an example of currency conversion where in a client wants to convert money from USD to either INR or Euros. The system uses the conversion factor to calculate the amount and send it back to the client.
   
   
Based on the above scenario -
1) An interpreter called currencyconverter.

package InterpretorPattern;

public class currencyconvertor {
    
    double cusdtoinr=60.0;
    double cusdtoeur=1.3;
    
    public double getusdtoinr(double sourceamount) {
        return sourceamount*cusdtoinr;
    }
    
    public double getusdtoeur(double sourceamount) {
        return sourceamount * cusdtoeur;
    }

}

2) A class which will have the actual interpretation called convertor.

<pre style="font-family: Andale Mono, Lucida Console, Monaco, fixed, monospace; color: #000000; background-color: #eee;font-size: 12px;border: 1px dashed #999999;line-height: 14px;padding: 5px; overflow: auto; width: 100%"><code>package InterpretorPattern;

public interface convertor {
    
    double convert(currencyconvertor cc);

}

</code></pre>

3) A class called USDtoINR and another called USDtoEur

usdtoeurjava

package InterpretorPattern;

public class usdtoeur implements convertor {
    
    private double amt;
    
    public usdtoeur(double curr) {
        this.amt=curr;
    }

    @Override
    public double convert(currencyconvertor cc) {
        return cc.getusdtoeur(amt);
    }

}

usdtoinr.java
 

package InterpretorPattern;

public class usdtoinr implements convertor{

    private double amt;
    
    public usdtoinr(double curr) {
        this.amt=curr;
    }
    
    @Override
    public double convert(currencyconvertor cc) {
        return cc.getusdtoinr(amt);
    }

}

4) A client which will use the interpreter to covert the value.

package InterpretorPattern;

public class interpretordemo {
    
    
    
    
    public static void main(String args[]) {
        
        System.out.println("Converting $100 to EUR");
        double amt=100;
        double convertedamt=0;
        currencyconvertor cc=new currencyconvertor();    
        String converttocurr="EUR";
        
        convertor c=null;
        
        if(converttocurr.equalsIgnoreCase("INR")) {
            
            c=new usdtoinr(amt);
            convertedamt=c.convert(cc);
            System.out.println("The converted amount in INR is: "+convertedamt);
            
        } else {
            
            c=new usdtoeur(amt);
            convertedamt=c.convert(cc);
            System.out.println("The converted amount in EUR is: "+convertedamt);
            
        }
        
        
    }
    
    
    
    

}

Place to use -
1) It can be used in places where you want one format to be converted into another format.
2) It can be used in places where you are checking for grammar or evaluating an expression written on an UI.


To be careful about -
1) Performance of the code can be an issue, so you need to use this pattern very carefully.

The link for the code is present in the link here

Command Pattern

Definition -
    It provides a generic interface to all the classes which implement it to execute certain commands. This can be treated like the director in the builder pattern.


Scenario -

    Let us take an example of the production line itself, where the client places an order for a vehicle and depending on the order a hatchback or a sedan car is created.
In this case -
1. The interface called order which have an execute funtion to process the request of the client. Note, we can name the function with any name, for the sake of understanding it has named as execute.
 

package CommandPattern;

public interface order {
    
    public void execute();

}

2. hatchback is a class which will implement order and create a hatchback.
 

package CommandPattern;

public class hatchback implements order {

    @Override
    public void execute() {
        
        System.out.println("Creating a hatchback");
        
    }

}

3. sedan is a class which will implement order and create a sedan.

package CommandPattern;

public class sedan implements order {

    @Override
    public void execute() {
        
        System.out.println("Creating a sedan");
        
    }

}

4. A class called router which will hold the order object and invokes the method.

package CommandPattern;

public class router {
    
    String typeofcar=null;
    order o=null;
    
    
    
    public void createcar(String type) {
        if(type.equalsIgnoreCase("Hatchback")) {
            o=new hatchback();
        }else if(type.equalsIgnoreCase("Sedan")) {
            o=new sedan();
        }
        
        o.execute();
    }
    
}

5. Client class which will order for a hatchback or a sedan.
   

package CommandPattern;

public class commandpattern {
    
    public static void main(String args[]) {
        
        router r=new router();
        r.createcar("Hatchback");
        r.createcar("Sedan");
        
        
    }

}

Place to use -
1) When you want the client and the implmentor to be independent of each other.
2) When the request processor need not be known to the client during compile time.
3) One interface to do varying operations based on varying commands at varying time.

Place not to use -
1) Can create maintainence nightmare because if the system has lot of commands then it can cause confusions.
2) If the command parameters vary in future then it can cause change in the entire implementation.
The link for the code above is in the link here

Chain of Responsibility Pattern

Definition -
    This is a pattern where in there are a series of handlers which cater to a specific part or order of the request. In this pattern the client will not know who is addressing the request. The handlers decide among themselves who will server a particular request.
    This can also result in none of the handlers serving the request.


Scenario -
Lets take an example of a warehouse machine whose job is sort the incoming materials based on the type. For simplicity lets take there are two types of containers with tags of solid and liquid.
In this we will have a
1. The object here is a package so we will declare a class called pckg. 

 

package ChainofCommandPattern;

public class pckg {
    
    String type;
    
    public pckg(String objtype) {
        this.type=objtype;
    }
    
    public String gettype() {
        return this.type;
    }

}

2. A packagehandler which will have the functions that needs to be implemented. 
 

package ChainofCommandPattern;

public interface packagehandler {
    
    void setnext(packagehandler ph);
    void handlerequest(pckg pkg);

}

3. A solidpackagehandler and liquidpackagehandler which will have respective functions to handle the package.
solidpackagehandler.java
 

package ChainofCommandPattern;

public class solidpackagehandler implements packagehandler {

    packagehandler next;
    
    @Override
    public void setnext(packagehandler ph) {
        
        next=ph;
        
    }

    @Override
    public void handlerequest(pckg pkg) {
        
        if(pkg.type.equalsIgnoreCase("Solid")) {
            
            System.out.println("Handled the Solid object");
            
        } else if(pkg.type.equalsIgnoreCase("Liquid")) {
            next.handlerequest(pkg);
        }
        
    }

}

liquidpackagehandler.java

package ChainofCommandPattern;

public class liquidpackagehandler implements packagehandler{
    
    packagehandler next;

    @Override
    public void setnext(packagehandler ph) {
        
        next=ph;
        
    }

    @Override
    public void handlerequest(pckg pkg) {
        
        if(pkg.type.equalsIgnoreCase("Liquid")) {
            
            System.out.println("Handled the Liquid object");
            
        } else if(pkg.type.equalsIgnoreCase("Solid")) {
            next.handlerequest(pkg);
        }
        
    }
    
    

}

4. Finally a client which will use the above classes.

package ChainofCommandPattern;

public class chainofcommandclient {
    
    public static void main(String args[]) {
        
        packagehandler pckg1=new solidpackagehandler();
        packagehandler pckg2=new liquidpackagehandler();
        
        pckg1.setnext(pckg2);
        
        pckg1.handlerequest(new pckg("Solid"));
        pckg2.handlerequest(new pckg("Liquid"));
        
    }

}

   

Place to use -
1. When you have multiple handlers which can process the same request.
2. A request not being handled by any handler is an accepted scenario.



Place not to use -
1. Can be slower since it has to follow a specified path.
2. A request might not be addressed by the system implementing this pattern.
3. It can be difficult to maintain if the system has too many handlers and complex routes.

Proxy Pattern

Definition -

    It provides a proxy implementation for another object and controls access to the real object.
   
Scenario -

    let us consider an example of Manufacturing of a car in a plant which produces a hatchback and a sedan.
based on the above scenario -
1) We will have an interface called car.

package ProxyPattern;

public interface car {
    
    public void manufacture();

}

2) We will have concrete classes called hatchback and sedan
hatchback.java
 

public class hatchback implements car {

    @Override
    public void manufacture() {
        
        System.out.println("Manufacturing a hatchback");
        
    }

}

sedan.java

package ProxyPattern;

public class sedan implements car {

    @Override
    public void manufacture() {
        
        System.out.println("Manufacturing a sedan");
        
    }

}

3) We will have an handler called carhandler which will be responsible for invoking the classes based on request.

package ProxyPattern;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class carhandler implements InvocationHandler {
    
    public Object realcar=null;
    
    public carhandler(Object realcar) {
        this.realcar=realcar;
    }
    

    @Override
    public Object invoke(Object duplicate, Method arg1, Object[] arg2) throws Throwable {
        
        Object temp=arg1.invoke(realcar, arg2);
        return temp;
    }

}

4) To see the pattern in action use the code below - 

package ProxyPattern;

import java.lang.reflect.Proxy;

public class proxydemo {

    public static void main(String[] args) {
        
        
        car ht=new hatchback();
        carhandler ch=new carhandler(ht);
        car duplicate = (car) Proxy.newProxyInstance(ht.getClass().getClassLoader(),ht.getClass().getInterfaces(),ch);
        
        duplicate.manufacture();

    }

}

Place to use -
1) When the object created is external to the system.
2) Requires access to the original object and in some cases allowing to have modified functionalities.


The code used above can be found in the link here

Facade Pattern

Definition -

    This provides a standard interface for all the interfaces in the system or sub system.   

Scenario -

    Let us take an example of building a house, the components walls, roof needs to come together in order to complete it. If you would approach to start this without the pattern then you would have to handle too many scenarios to ensure the classes are called in particular order. The facade pattern is used to make the job easier.
   
Based on the above scenario -
1) A class called walls which will build all the walls.

package FacadePattern;

public class walls {
    
    public void buildwalls() {
        System.out.println("Building walls");
    }


}

2) A class called roof which will build the roof.

package FacadePattern;

public class roofs {
    
    public void buildroofs() {
        System.out.println("Building roofs");
    }

}

3) A class called housefacade which will take care of the calling a class by the interface instead of calling roof and walls separately.
 

package FacadePattern;

public class housefacade {
    
    private walls wall=new walls();
    private roofs roof=new roofs();
    
    public void build() {
        wall.buildwalls();
        roof.buildroofs();
    }

}

4) To see the pattern in action use the code below 

package FacadePattern;

public class facadedemo {
    
    public static void main(String args[]) {
        
        housefacade house=new housefacade();
        house.build();
        
    }
    
}

Place to use -
1) Use this when you have too many interfaces and you want to simplify the interaction with the client.
2) People generally use this while building web services since a single web services will have multiple methods. 

The source for the above can be found in the link here