Comment utiliser django modèles avec des clés étrangères dans différents DBs?

Le Problème

*Note: ceci est une extension de Vitaly Fadeev la réponse de

En raison d'un désir de maintenir l'intégrité référentielle, Django ne permet pas pour les clés étrangères qui s'étendent sur plusieurs bases de données: https://docs.djangoproject.com/en/dev//topics/db/multi-db/#limitations-of-multiple-databases. Même si cela est souhaité, 99% de toutes les demandes, dans certains cas, il est utile d'être capable de créer une telle association dans l'ORM, même si vous ne pouvez pas assurer l'intégrité référentielle.

Une Solution

J'ai créé un Gist qui utilise la solution proposée ici par Vitaly Fadeev enveloppé comme une sous-classe de la Django champ ForeignKey. Cette solution ne nécessite pas de modifier Django fichiers de Base mais au lieu d'utiliser ce type de champ au lieu de cela, dans le cas que vous en avez besoin.

Exemple D'Utilisation

# app1/models.py
from django.db import models

class ClientModel(models.Model)
    name = models.CharField()
    class Meta:
        app_label = 'app1'

# app2/models.py
from django.db import models
from some_location.related import SpanningForeignKey

class WidgetModel(models.Model):
    client = SpanningForeignKey('app1.ClientModel', default=None, null=True,
                                blank=True, verbose_name='Client')

L'Essentiel

Le résumé est disponible ici: https://gist.github.com/gcko/de1383080e9f8fb7d208

Copié ici pour en faciliter l'accès:

from django.core import exceptions
from django.db.models.fields.related import ForeignKey
from django.db.utils import ConnectionHandler, ConnectionRouter

connections = ConnectionHandler()
router = ConnectionRouter()


class SpanningForeignKey(ForeignKey):

    def validate(self, value, model_instance):
        if self.rel.parent_link:
            return
        # Call the grandparent rather than the parent to skip validation
        super(ForeignKey, self).validate(value, model_instance)
        if value is None:
            return

        using = router.db_for_read(self.rel.to, instance=model_instance)
        qs = self.rel.to._default_manager.using(using).filter(
            **{self.rel.field_name: value}
        )
        qs = qs.complex_filter(self.get_limit_choices_to())
        if not qs.exists():
            raise exceptions.ValidationError(
                self.error_messages['invalid'],
                code='invalid',
                params={
                    'model': self.rel.to._meta.verbose_name, 'pk': value,
                    'field': self.rel.field_name, 'value': value,
                },  # 'pk' is included for backwards compatibility
            )

Après la rupture de ma tête quelques jours, j'ai réussi à obtenir ma Clé Étrangère SUR LA MÊME BANQUE!

Peut être fait une variation sur le FORMULAIRE pour demander une CLÉ ÉTRANGÈRE dans une autre banque!

Tout d'abord, ajoutez une RECHARGE de DOMAINES, à la fois directement (fissure) de mon formulaire, en fonction _init_

app.form.py

# -*- coding: utf-8 -*-
from django import forms
import datetime
from app_ti_helpdesk import models as mdp
#classe para formulario de Novo HelpDesk
class FormNewHelpDesk(forms.ModelForm):
class Meta:
model = mdp.TblHelpDesk
fields = (
"problema_alegado",
"cod_direcionacao",
"data_prevista",
"hora_prevista",
"atendimento_relacionado_a",
"status",
"cod_usuario",
)
def __init__(self, *args, **kwargs):
#-------------------------------------
#  using remove of kwargs
#-------------------------------------
db = kwargs.pop("using", None)
# CASE use Unique Key`s
self.Meta.model.db = db
super(FormNewHelpDesk, self).__init__(*args,**kwargs)
#-------------------------------------
#   recreates the fields manually
from copy import deepcopy
self.fields = deepcopy( forms.fields_for_model( self.Meta.model, self.Meta.fields, using=db ) )
#
#-------------------------------------
#### follows the standard template customization, if necessary
self.fields['problema_alegado'].widget.attrs['rows'] = 3
self.fields['problema_alegado'].widget.attrs['cols'] = 22
self.fields['problema_alegado'].required = True
self.fields['problema_alegado'].error_messages={'required': 'Necessário informar o motivo da solicitação de ajuda!'}
self.fields['data_prevista'].widget.attrs['class'] = 'calendario'
self.fields['data_prevista'].initial = (datetime.timedelta(4)+datetime.datetime.now().date()).strftime("%Y-%m-%d")
self.fields['hora_prevista'].widget.attrs['class'] = 'hora'
self.fields['hora_prevista'].initial =datetime.datetime.now().time().strftime("%H:%M")
self.fields['status'].initial = '0'                 #aberto
self.fields['status'].widget.attrs['disabled'] = True
self.fields['atendimento_relacionado_a'].initial = '07'
self.fields['cod_direcionacao'].required = True
self.fields['cod_direcionacao'].label = "Direcionado a"
self.fields['cod_direcionacao'].initial = '2'
self.fields['cod_direcionacao'].error_messages={'required': 'Necessário informar para quem é direcionado a ajuda!'}
self.fields['cod_usuario'].widget = forms.HiddenInput()

l'appel de la Forme à partir de la Vue

app.view.py

form = forms.FormNewHelpDesk(request.POST or None, using=banco)

Maintenant, le changement dans le Code source de DJANGO

Seuls les champs de type ForeignKey, ManyToManyField et OneToOneField pouvez utiliser le 'aide', donc ajouté un SI ...

django.forms.models.py

# line - 133: add using=None
def fields_for_model(model, fields=None, exclude=None, widgets=None, formfield_callback=None, using=None):
# line - 159
if formfield_callback is None:
#----------------------------------------------------
from django.db.models.fields.related import (ForeignKey, ManyToManyField, OneToOneField)
if type(f) in (ForeignKey, ManyToManyField, OneToOneField):
kwargs['using'] = using
formfield = f.formfield(**kwargs)
#----------------------------------------------------
elif not callable(formfield_callback):
raise TypeError('formfield_callback must be a function or callable')
else:
formfield = formfield_callback(f, **kwargs)

ALTER SUIVRE FICHIER

django.db.models.base.py

modifier

# line 717
qs = model_class._default_manager.filter(**lookup_kwargs)

pour

# line 717
qs = model_class._default_manager.using(getattr(self, 'db', None)).filter(**lookup_kwargs)

Prêt 😀