Rodando aplicações Django no IRIS

Descrição

Este é um modelo para um aplicativo Django que pode ser implantado no IRIS como um aplicativo Web nativo.

Instalação

1. Clone o repositório
2. Crie um ambiente virtual
3. Instale os requisitos
4. Rode o arquivo docker-compose

git clone
cd iris-django-template
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
docker-compose up

Uso

A URL base é http://localhost:53795/django/.

Endpoints

• /iris - Retorna um objeto JSON com as 10 principais classes presentes no namespace IRISAPP.
• /interop - Um endpoint de ping para testar a estrutura de interoperabilidade do IRIS.
• /api/posts -Um endpoint CRUD simples para um objeto Post.
• /api/comments - Um endpoint CRUD simples para um objeto Comment.

Como desenvolver deste modelo

Veja o artigo de introdução ao WSGI: wsgi-introduction.

TL;DR: Você pode ativar ou desativar o sinalizador DEBUG no portal de segurança para que as alterações sejam refletidas no aplicativo à medida que você desenvolve.

Apresentação do código

A aplicação Django é estruturada como se segue:

• app - Pasta do projeto Django
  • app - Pasta da aplicação Django para configuração
    • settings.py - Arquivo de definições Django
    • urls.py - Arquivo de configuração de URL Django para conectar as visualizações às URLs
    • wsgi.py - Arquivo do Django WSGI
    • asgi.py - Arquivo do Django AGI
  • community - Pasta da aplicação Django para o aplicativo da comunidade, com CRUD nos objetos de Post e Comment
    • models.py - Arquivo de modelos do Djando para os objetos Post e Comment
    • views.py - Arquivo de visualizações Django para cessar os objetos Post e Comment
    • serializers.py - Arquivo Django de serializadores para os objetos Post e Comentário. * admin.py - Arquivo Django de administração para adicionar CRUD à interface administrativa.
    • migrations - Pasta Django de migrações para construir o banco de dados.
    • fixtures - Pasta Django de fixtures com dados de demonstração
  • sqloniris - Pasta do aplicativo Django para o aplicativo SQL no IRIS.
    • views.py - Arquivo Django de views para consultar o namespace IRISAPP.
    • apps.py - Arquivo de configuração do aplicativo Django.
  • interop - Pasta do aplicativo Django para o aplicativo de interoperabilidade.
    • views.py - Arquivo Django de views para testar a estrutura de interoperabilidade.
    • apps.py - Arquivo de configuração do aplicativo Django.
  • manage.py - Arquivo de gerenciamento Django.

app/settings.py

Este arquivo contém as configurações Django para o aplicativo.

...

# Definição de aplicação

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'community',
    'sqloniris',
    'interop',
    'rest_framework'
]

...

REST_FRAMEWORK = {
    # Use as permissões padrão do Django `django.contrib.auth` ,
    # ou permita acesso de apenas leitura para usuários não autenticados
    'DEFAULT_PERMISSION_CLASSES': [
        'rest_framework.permissions.DjangoModelPermissionsOrAnonReadOnly'
    ],
    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.LimitOffsetPagination',
    'PAGE_SIZE': 20
}

...

DATABASES = {
    "default": {
        "ENGINE": "django_iris",
        "EMBEDDED": True,
        "NAMESPACE": "IRISAPP",
        "USER":"SuperUser",
        "PASSWORD":"SYS",
    }
}

Algumas definições importantes para notar:

• INSTALLED_APPS - Contém a lista de aplicativos instalados no projeto Django.
• community - O aplicativo Django para as operações CRUD nos objetos Post e Comentário.
• sqloniris - TO aplicativo Django para as operações SQL no IRIS.
• interop - O aplicativo Django para as operações de interoperabilidade.
• rest_framework - O framework Django REST para a API REST.
• REST_FRAMEWORK - Contém as configurações para o framework Django REST.
  • DEFAULT_PERMISSION_CLASSES - Somente usuários autenticados podem realizar operações CRUD.
  • DEFAULT_PAGINATION_CLASS - A classe de paginação para a API REST.
• DATABASES - Contém as configurações para a conexão com o banco de dados IRIS.
  • Aqui estamos usando o mecanismo django_iris para conectar ao banco de dados IRIS.

app/urls.py

Este arquivo contém a configuração de URL para o aplicativo Django.

from django.contrib import admin
from django.urls import path,include
from rest_framework import routers
from community.views import PostViewSet, CommentViewSet
from sqloniris.views import index
from interop.views import index as interop_index

router = routers.DefaultRouter()
router.register(r'posts', PostViewSet)
router.register(r'comments', CommentViewSet)


urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/', include(router.urls)),
    path('iris/', index),
    path('interop/', interop_index)
]

• router - Contém o roteador padrão para a API REST.
• routeer.register - Registra os viewsets Post e Comentário no roteador.
• urlpatterns - Contém os padrões de URL para o aplicativo Django
  • /admin/ - A interface administrativa Django.
  • /api/ -A API REST para os objetos Post e Comentário.
  • /iris/ - O endpoint SQL no IRIS.
  • /interop/ - O endpoint de interoperabilidade.

app/wsgi.py

Este arquivo contém a configuração WSGI para o aplicativo Django.

Este é o arquivo que temos que fornecer ao IRIS para executar o aplicativo Django.

Na seção Security->Applications->Web Applications, temos que fornecer o caminho para este arquivo.

• Application Name
  • app.wsgi
• Callable Name
  • application
• WSGI App directory
  • /irisdev/app/app

community/models.py

Este arquivo contém os modelos Django para os objetos Post e Comentário.

from django.db import models

# Create your models here.
class Post(models.Model):
    title = models.CharField(max_length=100)
    content = models.TextField()

class Comment(models.Model):
    content = models.TextField()
    post = models.ForeignKey(Post, on_delete=models.CASCADE, related_name='comments')

• Post - O modelo para o objeto Post.
  • title - O título do post.
  • content - O conteúdo do post.
• Comment - O modelo para o objeto Comentário.
  • content - O conteúdo do comentário.
  • post - A chave estrangeira para o objeto Post.
  • related_name - O nome relacionado para os comentários.

community/seializers.py

Este arquivo contém os serializadores Django para os objetos Post e Comentário.

Usando o framework Django REST, podemos serializar os modelos Django em objetos JSON.

from rest_framework import serializers
from community.models import Post, Comment

class PostSerializer(serializers.ModelSerializer):
    class Meta:
        model = Post
        fields = ('id', 'title', 'content', 'comments')

class CommentSerializer(serializers.ModelSerializer):
    class Meta:
        model = Comment
        fields = ('id', 'content', 'post')

• PostSerializer -O serializador para o objeto Post.
• CommentSerializer -O serializador para o objeto Comentário.
• fields - Os campos a serem serializados.

community/views.py

Este arquivo contém as views Django para os objetos Post e Comentário.

Usando o framework Django REST, podemos criar operações CRUD para os modelos Django.

from django.shortcuts import render
from rest_framework import viewsets

# Import the Post and Comment models
from community.models import Post, Comment

# Import the Post and Comment serializers
from community.serializers import PostSerializer, CommentSerializer

# Create your views here.
class PostViewSet(viewsets.ModelViewSet):
    queryset = Post.objects.all()
    serializer_class = PostSerializer

class CommentViewSet(viewsets.ModelViewSet):
    queryset = Comment.objects.all()
    serializer_class = CommentSerializer

• PostViewSet - O viewset para o objeto Post.
• CommentViewSet - O viewset para o objeto Comentário.
• queryset - O queryset para o viewset.
• serializer_class - A classe de serializador para o viewset.

sqloniris/views.py

Este arquivo contém as views Django para as operações SQL no IRIS.

from django.http import JsonResponse

import iris

def index(request):
    query = "SELECT top 10 * FROM %Dictionary.ClassDefinition"
    rs = iris.sql.exec(query)
    # Convert the result to a list of dictionaries
    result = []
    for row in rs:
        result.append(row)
    return JsonResponse(result, safe=False)

• index - A view para a operação SQL no IRIS.
• query - A consulta SQL a ser executada no banco de dados IRIS.
• rs - O conjunto de resultados da consulta.
• result - A lista de listas do conjunto de resultados.
• JsonResponse - A resposta JSON para a view, safe é definido como False para permitir lista de listas.

interop/views.py

Este arquivo contém as views Django para as operações de interoperabilidade.

from django.http import HttpResponse

from grongier.pex import Director

bs = Director.create_python_business_service('BS')

def index(request):
    result = bs.on_process_input(request)
    return HttpResponse(result, safe=False)

• bs - O objeto de serviço de negócios criado usando a classe Director .
• index -A view para a operação de interoperabilidade.
• result - A view para a operação de interoperabilidade.

Observação: não usamos JsonResponse para simplificar o código, podemos usá-lo se quisermos retornar um objeto JSON.

Solução de Problemas

Como executar o aplicativo Django em modo autônomo

Para executar o aplicativo Django em modo autônomo, podemos usar o seguinte comando:

cd /irisdev/app/app
python3 manage.py runserver 8001

Isso executará o aplicativo Django na porta padrão 8001.

Observação: você deve estar dentro do contêiner para executar este comando.

docker exec -it iris-django-template-iris-1 bash

Reiniciando o aplicativo no IRIS

Esteja no modo DEBUG, faça várias chamadas para o aplicativo e as alterações serão refletidas no aplicativo.

Como acessar o Portal de Gerenciamento do IRIS

Você pode acessar o Portal de Gerenciamento do IRIS acessando http://localhost:53795/csp/sys/UtilHome.csp.

Executar este template localmente

Para isso, você precisa ter o IRIS instalado em sua máquina.

Em seguida, você precisa criar um namespace chamado IRISAPP.

Instale os requisitos.

# Move to the app directory
cd /irisdev/app/app

# python manage.py flush --no-input
python3 manage.py migrate
# create superuser
export DJANGO_SUPERUSER_PASSWORD=SYS
python3 manage.py createsuperuser --no-input --username SuperUser --email admin@admin.fr

# load demo data
python3 manage.py loaddata community/fixtures/demo.json

# collect static files
python3 manage.py collectstatic --no-input --clear

# init iop
iop --init

# load production
iop -m /irisdev/app/app/interop/settings.py

# start production
iop --start Python.Production

Como servir arquivos estáticos

Para servir os arquivos estáticos no aplicativo Django, podemos usar o seguinte comando:

cd /irisdev/app
python3 manage.py collectstatic

Isso coletará os arquivos estáticos do aplicativo Django e os servirá no diretório /irisdev/app/static.

Para publicar os arquivos estáticos no IRIS, configure a seçãoSecurity->Applications->Web Applications.