Add django and sqlalchemy examples

django_example/admin.py

+from django.contrib import admin
+from django.db import models
+from .models import Client, Vehicle, Contract, FamilyReports, BMClass, Claims, BlackBox, Agent, Office
+
+class ClientAdmin(admin.ModelAdmin):
+    model = Client
+    list_display = ('name', 'surname', 'fiscalCode', 'email', 'phoneNumber')
+
+class VehicleAdmin(admin.ModelAdmin):
+    model = Vehicle
+    list_display = ('licensePlate', 'fiscalCode', 'model')
+
+class ContractAdmin(admin.ModelAdmin):
+    model = Contract
+    list_display = ('contractId', 'classBM', 'date', 'clientFiscalCode', 'licensePlate', 'renewal')
+
+class FamilyReportsAdmin(admin.ModelAdmin):
+    model = FamilyReports
+    list_display = ('fiscalCode1', 'fiscalCode2', 'relationship')
+
+class BMClassAdmin(admin.ModelAdmin):
+    model = BMClass
+    list_display = ('BMClass', 'basePremium')
+
+class ClaimsAdmin(admin.ModelAdmin):
+    model = Claims
+    list_display = ('licensePlate', 'totalCompensation', 'date', 'location', 'responsibility', 'compensationTimeDays')
+
+class BlackBoxAdmin(admin.ModelAdmin):
+    model = BlackBox
+    list_display = ('licensePlate', 'clientFiscalCode', 'blackBoxId')
+
+class AgentAdmin(admin.ModelAdmin):
+    model = Agent
+    list_display = ('name', 'surname', 'fiscalCode', 'agentId', 'officeId')
+
+class OfficeAdmin(admin.ModelAdmin):
+    model = Office
+    list_display = ('officeId', 'location')
+
+
+admin.site.register(Client, ClientAdmin)
+admin.site.register(Vehicle, VehicleAdmin)
+admin.site.register(Contract, ContractAdmin)
+admin.site.register(FamilyReports, FamilyReportsAdmin)
+admin.site.register(BMClass, BMClassAdmin)
+admin.site.register(Claims, ClaimsAdmin)
+admin.site.register(BlackBox, BlackBoxAdmin)
+admin.site.register(Agent, AgentAdmin)
+admin.site.register(Office, OfficeAdmin)

django_example/insert.py

+from insurancedb.models import BMClass
+
+bonus = BMClass(BMClass=2, basePremium=150.00)
+
+bonus.save()
+

django_example/models.py

+from django.db import models
+from phonenumber_field.modelfields import PhoneNumberField
+from django.core.validators import MaxValueValidator, MinValueValidator
+
+# Create your models here.
+
+SEX = ('M', 'F')
+MARITAL_STATUS = ('celibe', 'coniugato', 'vedovo', 'separato', 'divorziato')
+WHEEL_NUMBER = (2,4)
+FAMILY_REPORTS = ('primo', 'secondo', 'terzo')
+BONUSMALUS_CLASS = (0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18)
+
+
+class Client(models.Model):
+    name = models.CharField(max_length = 20)
+    surname = models.CharField(max_length = 20)
+    fiscalCode =  models.CharField(max_length = 16, primary_key = True)
+    residenceRoad = models.CharField(max_length = 30)
+    streetNumber = models.CharField(max_length = 5)
+    bithDay = models.DateField()
+    sex = models.CharField(max_length=1, choices = [(d,d) for d in SEX])
+    profession = models.CharField(max_length = 50)
+    maritalStatus = models.CharField(max_length = 10, choices = [(d,d) for d in MARITAL_STATUS])
+    phoneNumber = PhoneNumberField(blank = True, null = True)
+    email = models.EmailField(max_length = 70, blank = True, null = True)
+
+    def __str__(self):
+        return "{}, {}, {}".format(self.name, self.surname, self.fiscalCode)
+    class Meta:
+        ordering = ['surname']
+
+
+class Vehicle(models.Model):
+    licensePlate = models.CharField(max_length = 7, primary_key = True)
+    fiscalCode = models.ForeignKey(Client, on_delete = models.CASCADE)
+    engineSize = models.PositiveIntegerField()
+    model = models.CharField(max_length = 50)
+    kmTraveled = models.CharField(max_length = 20)
+    wheelNumber = models.PositiveSmallIntegerField(choices = [(d,d) for d in WHEEL_NUMBER])
+
+    def __str__(self):
+        return self.licensePlate
+
+
+class BMClass(models.Model):
+    BMClass = models.PositiveSmallIntegerField(choices = [(d,d) for d in BONUSMALUS_CLASS], primary_key = True)
+    basePremium = models.FloatField()
+
+    def __str__(self):
+        return "{}, {}".format(self.BMClass, self.basePremium)
+
+
+class Contract(models.Model):
+    contractId = models.CharField(max_length=15, primary_key = True)
+    date = models.DateTimeField(auto_now_add = True)
+    clientFiscalCode = models.ForeignKey(Client, on_delete = models.CASCADE)
+    licensePlate = models.ForeignKey(Vehicle, on_delete = models.CASCADE)
+    renewal = models.BooleanField()
+    classBM = models.ForeignKey(BMClass, null = True, on_delete = models.SET_NULL)
+    totalPremium = models.FloatField(blank = True)
+
+    def __str__(self):
+        return "{} on {}".format(self.clientFiscalCode, self.date.strftime('%d-%m-%Y'))
+
+
+class FamilyReports(models.Model):
+    fiscalCode1 = models.ForeignKey(Client, on_delete = models.CASCADE, related_name = "primo")
+    fiscalCode2 = models.ForeignKey(Client, on_delete = models.CASCADE, related_name = "secondo")
+    relationship = models.CharField(max_length=7, choices = [(d,d) for d in FAMILY_REPORTS])
+
+    class Meta:
+        unique_together = (("fiscalCode1", "fiscalCode2"),)
+
+    def __str__(self):
+        return self.relationship
+
+
+class Claims(models.Model):
+    licensePlate = models.ForeignKey(Vehicle, on_delete = models.CASCADE)
+    totalCompensation = models.FloatField()
+    date = models.DateTimeField(auto_now_add = True)
+    location = models.CharField(max_length = 30)
+    responsibility = models.FloatField(validators = [MinValueValidator(0), MaxValueValidator(100)])
+    compensationTimeDays = models.PositiveIntegerField(blank = True)
+    counterpartLicensePlate = models.CharField(max_length = 7)
+    counterpartInsuranceCompany = models.CharField(max_length = 50)
+    photo = models.ImageField(blank = True, null = True)
+
+    def __str__(self):
+        return "{} paid {}".format(self.licensePlate, self.totalCompensation)
+
+
+class BlackBox(models.Model):
+    blackBoxId = models.CharField(max_length=10, primary_key = True)
+    licensePlate = models.ForeignKey(Vehicle, on_delete = models.CASCADE)
+    clientFiscalCode = models.ForeignKey(Client, on_delete = models.CASCADE)
+    observationDate = models.DateTimeField(auto_now_add = True)
+    kmTraveled = models.FloatField(blank = True)
+    timeTraveledSeconds = models.FloatField(blank = True)
+    provinceTraveled = models.CharField(max_length = 30)
+    nationTraveled =  models.CharField(max_length = 30)
+    hourStarting = models.TimeField(auto_now = True)
+    hourClosing = models.TimeField(auto_now = True)
+    maxVelocity = models.PositiveSmallIntegerField(blank = True)
+    timeVelocityOverLimig = models.FloatField(blank = True)
+    kmVelocityOverLimit  = models.FloatField(blank = True)
+    totalTime = models.FloatField( blank = True)
+
+    def __str__(self):
+        return self.BlackBoxId
+
+
+class Office(models.Model):
+    officeId = models.AutoField(primary_key = True)
+    location = models.CharField(max_length = 30)
+
+    def __str__(self):
+        return "{}, {}".format(self.officeId, self.location)
+
+
+class Agent(models.Model):
+    name = models.CharField(max_length = 20)
+    surname = models.CharField(max_length = 20)
+    fiscalCode =  models.CharField(max_length = 16, primary_key = True)
+    agentId =  models.IntegerField(unique = True)
+    officeId = models.ForeignKey(Office, default = '', on_delete = models.SET_DEFAULT)
+
+    def __str__(self):
+        return "{}, {}, {}".format(self.name, self.surname, self.fiscalCode)
+    class Meta:
+        ordering = ['surname']
+
+

django_example/urls.py

+from django.contrib import admin
+from django.urls import path
+from . import views
+from django.views.generic.base import RedirectView
+
+urlpatterns = [
+    path('admin/', admin.site.urls),
+    path('', RedirectView.as_view(url = 'admin/')),
+    path('insurancedb/', views.insurancedb),
+    path('blackbox/', views.blackbox),
+    path('bmclass/', views.bmclass),
+    path('vehicle/', views.vehicle),
+    path('claims/', views.claims),
+    path('client/',  views.client),
+    path('contract/', views.contract),
+    path('familyreports/', views.familyreports),
+    path('agent/', views.agent),
+    path('office/', views.office),
+    path('add/', views.add)]

django_example/views.py

+from django.http import HttpResponse
+
+def insurancedb(request):
+    return HttpResponse('insurancedb')
+
+def blackbox(request):
+    return HttpResponse('blackbox')
+
+def bmclass(request):
+    return HttpResponse('bmclass')
+
+def vehicle(request):
+    return HttpResponse('vehicle')
+
+def claims(request):
+    return HttpResponse('claims')
+
+def client(request):
+    return HttpResponse('client')
+
+def contract(request):
+    return HttpResponse('contract')
+
+def familyreports(request):
+    return HttpResponse('familyreports')
+
+def agent(request):
+    return HttpResponse('agent')
+
+def office(request):
+    return HttpResponse('office')
+
+def add(request):
+    return HttpResponse('add')

euclid_example/README.md

+# ORM Example - Euclid
+
+    git clone https://www.ict.inaf.it/gitlab/odmc/orm_example.git
+    cd orm_example/euclid_example
+
+Crea l'ambiente di anaconda
+
+    conda create -n euclid_example
+    conda activate euclid_example
+    pip install django-extensions djangorestframework django-composite-field django-url-filter
+
+python manage.py migrate
+
+python manage.py shell
+
+python manage.py runserver
+
+add admin password
+
+
+## Start from scratch
+
+    django-admin startproject euclid_example
+    cd euclid_example
+    python manage.py startapp imagedb
+
+Also in settings.py you have to add the name of the app imagedb
+
+In the imagedb/models.py add the data model classes
+
+Once we have defined our data model in imagedb/models.py we need Django to create the corresponding DB schema
+
+python manage.py makemigrations

sqlalchemy_example/README.md

+
+Create the anaconda environment for this set of examples
+
+    conda create -n orm_sqlalchemy sqlalchemy
+
+## # To activate this environment, use
+#
+#     $ conda activate orm_sqlalchemy
+#
+# To deactivate an active environment, use
+#
+#     $ conda deactivate
+
+

sqlalchemy_example/example_1/create.py

+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from mapping import Base
+
+Base.metadata.create_all()

sqlalchemy_example/example_1/filter.py

+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from mapping import Car
+from mapping import Session
+from sqlalchemy.sql import and_ 
+
+# Create a Session object
+session = Session()
+
+# Query cars with name ending with 'en'
+results = session.query(Car).filter(Car.name.like('%en'))
+
+# Print the results
+print("Cars with name ending with 'en' are:")
+for car in results:
+    print(car.name)
+print()
+
+# Query cars filtered by id
+results = session.query(Car).filter(Car.id.in_([2, 4, 6, 8]))
+
+# Print the results
+print("Cars with id in [2, 4, 6, 8] are:")
+for car in results:
+    print(car.id, car.name)
+print()
+
+# Query cars filtered by price
+results = session.query(Car).filter(and_(Car.price > 10000,
+	                                     Car.price < 40000))
+
+# Print the results
+print("Cars with price between 10000 and 40000 are:")
+for car in results:
+    print(car.name, car.price)
+
+
+# Close session
+session.close()

sqlalchemy_example/example_1/insert.py

+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from mapping import Car
+from mapping import Session
+
+# Create a Session object
+session = Session()
+
+# Add instances of Car objects to the session
+session.add_all(
+   [Car(id=1, name='Audi', price=52642), 
+    Car(id=2, name='Mercedes', price=57127),
+    Car(id=3, name='Skoda', price=9000),
+    Car(id=4, name='Volvo', price=29000),
+    Car(id=5, name='Bentley', price=350000),
+    Car(id=6, name='Citroen', price=21000),
+    Car(id=7, name='Hummer', price=41400),
+    Car(id=8, name='Volkswagen', price=21600)])
+
+# Commit changes to database
+session.commit()
+
+# Close session
+session.close()

sqlalchemy_example/example_1/mapping.py

+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+
+from sqlalchemy import Column, Integer, String
+
+
+# Create a new Engine instance. 
+engine = create_engine('sqlite:///example_1.db')
+
+
+# Construct a base class for declarative class definitions
+# and bind it to engine
+Base = declarative_base(engine)
+
+
+# Declarative mapping for Car
+class Car(Base):
+    __tablename__ = "car"
+ 
+    id = Column(Integer, primary_key=True)
+    name = Column(String)  
+    price = Column(Integer)
+
+
+# Create a configurable Session factory.
+Session = sessionmaker(bind=engine)

sqlalchemy_example/example_1/read.py

+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from mapping import Car
+from mapping import Session
+
+# Create a Session object
+session = Session()
+
+# Query all the cars
+results = session.query(Car).all()
+
+# Print the results
+for car in results:
+    print("The price of", car.name, "is", car.price)
+
+# Close session
+session.close()

sqlalchemy_example/example_2/create.py

+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from mapping import Base
+
+Base.metadata.create_all()

sqlalchemy_example/example_2/filter.py

+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from mapping import Author, Book
+from mapping import Session
+
+# Create a Session object
+session = Session()
+
+# Query Author to select Lev Tolstoy
+results = session.query(Author).filter(Author.name=="Lev Tolstoy").first()
+
+# Print all books of Lev Tolstoy
+print('Books of Lev Tolstoy are:')
+for book in results.book:
+    print(book.title)
+print()
+
+# Query Book for the book Emma and get its author
+results = session.query(Book).filter(Book.title=="Emma").first()
+
+print('The author of', results.title, 'is', results.author.name)
+
+# Close session
+session.close()
+

sqlalchemy_example/example_2/insert.py

+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from mapping import Author, Book
+from mapping import Session
+
+# Create a Session object
+session = Session()
+
+# Add instances of Author and Book objects to the session
+session.add_all(
+   [Author(id=1, name='Lev Tolstoy'),
+	Author(id=2, name='Jane Austen'),
+	Author(id=3, name='Charles Dickens'),
+	Book(id=1, title='War and Peace', author_id=1),
+	Book(id=2, title='Anna Karenina', author_id=1),
+	Book(id=3, title='Emma', author_id=2),
+	Book(id=4, title='David Copperfield', author_id=3)])
+
+# Commit changes to database
+session.commit()
+
+# Close session
+session.close()

sqlalchemy_example/example_2/mapping.py

+from sqlalchemy import create_engine, event
+from sqlalchemy.engine import Engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy import Column, Integer, String, ForeignKey
+from sqlalchemy.orm import sessionmaker, relationship
+
+from sqlite3 import Connection as SQLite3Connection
+
+# Create a new Engine instance. 
+engine = create_engine('sqlite:///example_2.db')
+
+
+# Construct a base class for declarative class definitions
+# and bind it to engine
+Base = declarative_base(engine)
+
+# Declarative mapping for Author and Book classes
+class Author(Base):
+    __tablename__ = "author"
+
+    id = Column(Integer, primary_key=True)
+    name = Column(String)  
+
+    book = relationship("Book")
+
+class Book(Base):
+    __tablename__ = "book"
+
+    id = Column(Integer, primary_key=True)
+    title = Column(String)      
+    author_id = Column(Integer, ForeignKey("Author.id"))
+
+    author = relationship("Author")
+
+# Enable foreign key constraint in SQLite
+@event.listens_for(Engine, "connect")
+def _set_sqlite_pragma(dbapi_connection, connection_record):
+    if isinstance(dbapi_connection, SQLite3Connection):
+        cursor = dbapi_connection.cursor()
+        cursor.execute("PRAGMA foreign_keys=ON;")
+        cursor.close()
+
+# Create a configurable Session factory.
+Session = sessionmaker(bind=engine)

sqlalchemy_example/example_3/create.py

+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from mapping import Base
+
+Base.metadata.create_all()

sqlalchemy_example/example_3/filter.py

+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from mapping import Client, Person, Company
+from mapping import Session
+
+# Create a Session object
+session = Session()
+
+# Query Client with address via Flavia
+results = session.query(Client).filter(Client.address=='via Flavia')
+
+# Print results
+print('Clients in via Flavia are:')
+for client in results:
+    if client.type == 'person':
+    	print(client.id, client.name, client.surname)
+    elif client.type == 'company':
+    	print(client.id, client.company_name, client.industry)
+print()
+
+# Query Person with address via Flavia
+results = session.query(Person).filter(Person.address=='via Flavia')
+
+# Print results
+print('Persons in via Flavia are:')
+for client in results:
+    if client.type == 'person':
+    	print(client.id, client.name, client.surname)
+    elif client.type == 'company':
+    	print(client.id, client.company_name, client.industry)
+
+
+# Close session
+session.close()
+

sqlalchemy_example/example_3/insert.py

+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from mapping import Client, Person, Company
+from mapping import Session
+
+# Create a Session object
+session = Session()
+
+# Add instances of Person and Company objects to the session
+session.add_all([
+	Person(name='Mario', surname='Rossi', address='via Giulia'),
+	Person(name='Luigi', surname='Bianchi', address='via Flavia'),
+	Company(company_name='Acegas', industry='multi-utility', address='via del Teatro'),
+	Company(company_name='Illy', industry='coffee', address='via Flavia')
+    ])
+
+# Commit changes to database
+session.commit()
+
+# Close session
+session.close()

sqlalchemy_example/example_3/mapping.py

+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy import Column, Integer, String, ForeignKey
+from sqlalchemy.orm import sessionmaker, relationship
+
+# Create a new Engine instance. 
+engine = create_engine('sqlite:///example_3.db')
+
+
+# Construct a base class for declarative class definitions
+# and bind it to engine
+Base = declarative_base(engine)
+
+# Declarative mapping for Client
+class Client(Base):
+    __tablename__ = 'client'
+ 
+    id = Column(Integer, primary_key=True)
+    address = Column(String)
+    type = Column(String)
+
+    __mapper_args__ = {
+        'polymorphic_identity':'client',
+        'polymorphic_on':type
+        }
+
+# Declarative mapping for Person
+class Person(Client):
+    __tablename__ = 'person'
+
+    id = Column(Integer, ForeignKey('client.id'), primary_key=True)
+    name = Column(String)
+    surname = Column(String)
+
+    __mapper_args__ = {
+        'polymorphic_identity':'person',
+    }
+
+# Declarative mapping for Company
+class Company(Client):
+    __tablename__ = 'company'
+
+    id = Column(Integer, ForeignKey('client.id'), primary_key=True)
+    company_name = Column(String)
+    industry = Column(String)
+
+    client = relationship("Client")
+
+    __mapper_args__ = {
+        'polymorphic_identity':'company',
+    }
+
+# Create a configurable Session factory.
+Session = sessionmaker(bind=engine)