[Django#3] Getting started with simple application

Developer

[Django#3] Getting started with simple application

rocksea 2015. 7. 10. 19:14

Getting started with simple application

지난 포스팅에 이어 Application 개발 심화 과정을 다루고자 한다.

http://rocksea.tistory.com/308

이번 포스팅에서는 기본적인 Restful 기반의 App 개발에 대해서 다루고자 한다.

기본적인 인증, 권한, DBPool관리, json데이터를 이용한 기본적인 Restful 방식의

Web Application을 구현 할 것이다.

step1. setting.py 설정

일단 기본적인 앱을 만들기 위해 settings.py에 대한 정보를 몇가지 설정해 줘야한다.

App이 추가되면 INSTALLED_APPS 에 추가를 한다.

INSTALLED_APPS = (

'django.contrib.admin',

'django.contrib.auth',

'django.contrib.contenttypes',

'django.contrib.sessions',

'django.contrib.messages',

'django.contrib.staticfiles',

#2015.07.06 by rocksea - polls

'polls',

)

Django Templates Engine을 사용하여 view를 구성하기 위해 html파일 위치를

지정한다.

TEMPLATES = [

{

'BACKEND': 'django.template.backends.django.DjangoTemplates',

'DIRS': [

'/home/work/trabi',

'APP_DIRS': True,

'OPTIONS': {

'context_processors': [

'django.template.context_processors.debug',

'django.template.context_processors.request',

'django.contrib.auth.context_processors.auth',

'django.contrib.messages.context_processors.messages',

]

step2. MySQL Connection Pool 설정

pip를 이용하여 Connection Pool 모듈을 설치합니다.

$ pip install django-mysqlpool

Engine 부분을 아래와 같이 수정해준다.

DATABASES = {

'default': {

#'ENGINE': 'django.db.backends.mysql',

'ENGINE': 'django_mysqlpool.backends.mysqlpool',

'NAME': 'rocksea',

'HOST': '192.168.0.210',

'PORT': '3306',

'USER': 'rocksea',

'PASSWORD': 'gogo1234'

}

step3. Auth app 생성

사용자 인증을 위해 auth 앱을 생성한다.

$ python manage.py startapp auth

auth/html/login_view.html

로그인 화면을 임시로 만든다. 주의할점은 Login시 "csrfmiddlewaretoken" 을

추가해주어야 한다. 그렇지 않으면 POST전송 시 403 Forbidden 에러가 발생한다.

<html>
<head>
<title>
</title>
</head>
<body>
<form action="/auth/loginAction" method="POST">
  <input type="text" name="username" value="rocksea" /><BR/>
  <input type="text" name="password" value="1234" /><BR/>
  <input type="submit" value="confirm" />
  <div style="display:none">
    <input type="hidden" name="csrfmiddlewaretoken" value="{{ csrf_token }}">
  </div>
</form>
</body>
</html>

auth/urls.py

url과 Login View Controller객체를 Mapping한다.

from django.conf.urls import include, url
import views

urlpatterns = [
  url(r'^$', views.index, name='index'),
  url(r'^loginAction', views.loginAction, name='loginAction'),
  url(r'^login', views.login, name='login'),
]

auth/views.py

contrib.auth의 authenticate를 통해 로그인 인증을 처리한 뒤, login()를 통해

로그인 처리 후 serializer를 이용하여 XML or JSON형태의 결과를 날린다.

from django.http import HttpResponse
from django.shortcuts import render
from django.contrib.auth import authenticate, login
from django.shortcuts import render
from django.core import serializers

# Create your views here.
def index(request):
  return HttpResponse("Hello, world. You're at the polls main index.")

def loginView(request):
  return render(request, 'auth/html/login_view.html')

def loginAction(request):
    username = request.POST['username']
    password = request.POST['password']
    user = authenticate(username=username, password=password)
    if user is not None:
        if user.is_active:
            login(request, user)
            # XML or JSON Serializer
            data = serializers.serialize('json', [user])
            # Redirect to a success page.
            return HttpResponse(data)
        else:
            # Return a 'disabled account' error message
            return HttpResponse("Disable account.")
    else:
        # Return an 'invalid login' error message.
        return HttpResponse("Invalid account.")

[그림 1] 로그인 화면

[그림 2] 로그인 완료 시 JSON 출력 화면

step3. flight app 생성 및 DB Table 생성

이제 본격적으로 DB Access를 통해 Business Logic 한 Cycle을 구현해 본다.

예제에선 항공권 스케쥴 DB 구현을 통해 Business Logic을 구현하였다.

$ python manage.py startapp flight

flight/models.py

생성할 모델을 추가한다.

from django.db import models

# Create your models here.
class Nation(models.Model):
  nation_nm = models.CharField(max_length=200)
  nation_cd = models.CharField(max_length=10)
  pub_dt = models.DateTimeField('date published')

class Kind(models.Model):
  flight_nm = models.CharField(max_length=200)
  flight_cd = models.CharField(max_length=10)
  pub_dt = models.DateTimeField('date published')

class Airport(models.Model):
  nation = models.ForeignKey(Nation)
  airport_nm = models.CharField(max_length=200)
  airport_cd = models.CharField(max_length=10)
  pub_dt = models.DateTimeField('date published')

class Schedule(models.Model):
  flight_kind = models.IntegerField()
  start_airport = models.IntegerField()
  arrival_airport = models.IntegerField()
  start_dt = models.DateTimeField()
  arrival_dt = models.DateTimeField()
  last_dt = models.DateTimeField()
  status_cd = models.CharField(max_length=10)
  pub_dt = models.DateTimeField('date published')

class Reservation(models.Model):
  start_airport = models.IntegerField()
  arrival_airport = models.IntegerField()
  start_flight = models.IntegerField()
  arrival_flight = models.IntegerField()
  start_dt = models.DateTimeField()
  arrival_dt = models.DateTimeField()
  last_dt = models.DateTimeField()
  status_cd = models.CharField(max_length=10)
  pub_dt = models.DateTimeField('date published')

이제 모델을 정의하여 DB 테이블을 생성하도록 한다.

$ python manage.py makemigrations

Migrations for 'flight':

0001_initial.py:

- Create model Airport

- Create model Kind

- Create model Nation

- Create model Reservation

- Create model Schedule

- Add field nation to airport

아래 명령을 통해 DB SQL문 확인을 해본다.

$ python manage.py sqlmigrate flight 0001

BEGIN;

CREATE TABLE `flight_airport` (`id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY, `airport_nm` varchar(200) NOT NULL, `airport_cd` varchar(10) NOT NULL, `pub_dt` datetime NOT NULL);

CREATE TABLE `flight_kind` (`id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY, `flight_nm` varchar(200) NOT NULL, `flight_cd` varchar(10) NOT NULL, `pub_dt` datetime NOT NULL);

CREATE TABLE `flight_nation` (`id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY, `nation_nm` varchar(200) NOT NULL, `nation_cd` varchar(10) NOT NULL, `pub_dt` datetime NOT NULL);

CREATE TABLE `flight_reservation` (`id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY, `start_airport` integer NOT NULL, `arrival_airport` integer NOT NULL, `start_flight` integer NOT NULL, `arrival_flight` integer NOT NULL, `start_dt` datetime NOT NULL, `arrival_dt` datetime NOT NULL, `last_dt` datetime NOT NULL, `status_cd` varchar(10) NOT NULL, `pub_dt` datetime NOT NULL);

CREATE TABLE `flight_schedule` (`id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY, `flight_kind` integer NOT NULL, `start_airport` integer NOT NULL, `arrival_airport` integer NOT NULL, `start_dt` datetime NOT NULL, `arrival_dt` datetime NOT NULL, `last_dt` datetime NOT NULL, `status_cd` varchar(10) NOT NULL, `pub_dt` datetime NOT NULL);

ALTER TABLE `flight_airport` ADD COLUMN `nation_id` integer NOT NULL;

ALTER TABLE `flight_airport` ALTER COLUMN `nation_id` DROP DEFAULT;

CREATE INDEX `flight_airport_5f138da4` ON `flight_airport` (`nation_id`);

ALTER TABLE `flight_airport` ADD CONSTRAINT `flight_airport_nation_id_4da2ef1ec385691_fk_flight_nation_id` FOREIGN KEY (`nation_id`) REFERENCES `flight_nation` (`id`);

COMMIT;

이제 실제 물리적인 DBMS의 Schema에 추가하도록 한다.

$ python manage.py migrate

Operations to perform:

Synchronize unmigrated apps: staticfiles, messages

Apply all migrations: flight, sessions, admin, polls, auth, contenttypes

Synchronizing apps without migrations:

Creating tables...

Running deferred SQL...

Installing custom SQL...

Running migrations:

Rendering model states... DONE

Applying flight.0001_initial... OK

DB Table에 추가된 모습을 확인 해 볼 수 있다.

mysql> show tables;

+----------------------------+

| Tables_in_rocksea |

+----------------------------+

| auth_group |

| auth_group_permissions |

| auth_permission |

| auth_user |

| auth_user_groups |

| auth_user_user_permissions |

| django_admin_log |

| django_content_type |

| django_migrations |

| django_session |

| flight_airport |

| flight_kind |

| flight_nation |

| flight_reservation |

| polls_choice |

| polls_question |

+----------------------------+

* Migration이 잘못될 경우 초기화 하는 방법

$ rm <app-dir>/migrations/*

$ python manage.py schemamigration <app-name> --initial

$ python manage.py migrate <app-name> 0001 --fake --delete-ghost-migrations

step4. flight 정보 입력

http://<host-ip>:8000/admin/ 에 접속하여 각 객체에 기본 정보를 입력한다.

[그림 3] 관리자 접속 화면

이제 Application을 실행을 위한 코드를 셋팅하고 Business Logic을 작성한다.

trabi/urls.py

flight url에 객체를 추가한다.

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

urlpatterns = [
    # Examples:
    # url(r'^$', 'trabi.views.home', name='home'),
    # url(r'^blog/', include('blog.urls')),

    url(r'^admin/', include(admin.site.urls)),
    url(r'^polls/', include('polls.urls')),
    url(r'^auth/', include('auth.urls')),
    url(r'^flight/', include('flight.urls')),
]

flight/urls.py

url 객체와 View Controller를 추가한다.

from django.conf.urls import include, url
import views

urlpatterns = [
  url(r'^nation/list', views.nationsList, name='NationsList'),
  url(r'^schedule/regSchdl', views.regSchedule, name='regSchedule'),
]

flight/views.py

View Controller에 관리자에서 입력한 데이터를 출력해보는 코드를 작성하였다.

from django.http import HttpResponse
from django.shortcuts import render
from django.contrib.auth import authenticate, login
from django.shortcuts import render
from django.core import serializers
from .models import Nation, Kind, Airport, Schedule, Reservation

# Create your views here.
def nationsList(request):
  data = serializers.serialize('json', Nation.objects.all())
  return HttpResponse(data)

def regSchedule(request):
  data = serializers.serialize('json', Nation.objects.all())
  return HttpResponse(data)

이제 Server를 실행하여 확인해 본다.

$ python manage.py runserver 0.0.0.0:8000

[그림 4] 데이터 JSON 출력 화면

이상 하나의 Cycle을 돌아 보았으니 응용해서 여러 Application을 개발 해 보도록 한다.