Python Django管理员，添加项目表单中的限制选择列表

我有三节模型课

游览

游客

照片

为了能够向巡演添加照片，用户必须注册巡演

我试图在管理面板“旅游”->“添加照片”表单中只显示所选旅游中列出的游客列表

最简单的方法是什么

我的模型（那里的大多数代码与问题无关，但我想这可能会有所帮助）：

class旅游（models.Model）：
请求字段=[“主键”、“姓名”、“电子邮件”、“电话号码”、“facebook\u id”，
“电话已验证”、“禁止使用”、“公交车id”]
name=models.CharField（最大长度=200）
email=models.EmailField（）
电话号码=models.CharField（最大长度=30，
空=真，
空白=真，
默认值=”）
facebook_id=models.CharField（最大长度=255，
空=真，
空白=真，
默认值=”）
phone\u verification\u hash=models.CharField（最大长度=100，
空白=真，
空=真，
默认值=”）
phone_已验证=models.BooleanField（默认值=False）
is_banked=models.BooleanField（默认值=False）
backoffice_notes=models.CharField（blank=True，null=True，default=”“，max_length=250）
总线=模型。外键（总线，空白=真，空=真，相关的_name=“游客”）
is_admin_added=models.BooleanField（默认值=False）
创建日期=models.DateTimeField（默认值=lambda:timezone.make_aware（datetime.datetime.now（），timezone.get_默认值\u timezone（））.replace（微秒=0））
修改的_date=models.DateTimeField（默认值=lambda:timezone.make_aware（datetime.datetime.now（），timezone.get_默认值_timezone（））。替换（微秒=0），自动_now=True）
lang=models.CharField（选项=（“he”，“Hebrew”），（“en”，“English”），），默认值为“he”，最大长度为100）
def需要电话验证（自我）：
返回bool（self.phone\u号码）且未验证self.phone\u
def已通过电话验证（自我验证）：
"""
他能收到短信吗？
"""
返回bool（self.phone_号码）并验证self.phone_
def已验证（自我）：
返回bool（self.facebook\u id）
def登录已验证（自我）：
"""
他能上传照片吗？
"""
返回非自我。是否禁止和\
（self.is\u phone\u verified（）或self.is\u facebook\u verified（））或\
添加了self.u管理吗
def验证电话（自）：
ans=self.send\u校验码（）
返回ans
def发送验证码（自我）：
random.seed（timezone.make_aware（datetime.datetime.now（），timezone.get_default_timezone（）））
验证代码=str（int（random.random（）*9000+1000））
如果sms\u验证\u发送（self.phone\u号码，验证\u代码）：
self.phone\u verification\u hash=hashlib.sha1（verify\u code）.hexdigest（）
self.save（）
其他：
引发异常（“坏短信服务器”）
返回验证代码
def接收\验证\代码（自我、提交\代码）：
如果hashlib.sha1（已提交的_代码）.hexdigest（）=\
self.phone\u验证\u散列：
self.phone\u已验证=真
self.save（）
返回真值
返回错误
def ___; unicode（自）：
返回u“%s（%s，%s）”%（self.name、self.email、self.phone\u号码）
def到dict（自身）：
obj={}
对于self.REQ_字段中的字段名称：
obj[field\u name]=getattr（self，field\u name）
返回obj
def图像_名称（自身）：
希伯来语测试=任何（u“\u0590”0:
如果self.start_和_running（）：
供游客自用。请告知游客。全部（）
联系人（游客，“已加入”通知单，本人）
自我。告知游客。移除（游客）
def状态（自我）：
返回{“id”：self.id，
“头衔”：自我头衔，
“天计数”：（self.end\u时间-self.start\u时间）。天，
“photo_count”：self.photos.count（），
“photo\u removed\u count”：self.photos.filter（is\u removed=True）
.count（），
“tourism_count”：self.tourism.count（）}
def相册链接（自我、游客id）：
query=Tour.encode\u链接（self.id，tourism\u id）
relative_url=build_url（“Pictures_应用程序：相册”，get={“query”：query}）
msg=“http://%s%s”%（Site.objects.get\u current（）.domain，relative\u url）
返回消息
def幻灯片放映链接（自我、游客id）：
query=Tour.encode\u链接（self.id，tourism\u id）
相对url=构建url（'Pictures\u应用程序：幻灯片放映'，get={“查询”：查询}）
msg=“http://%s%s”%（Site.objects.get\u current（）.domain，relative\u url）
返回消息
def运输公司（自身）：
tc=self.photos.exists（）和self.photos.all（）[0].bus.transportation\u company
返回tc
def管理链接（自）：
relative\u url=build\u url（'admin:pictours\u app\u touractive\u change'，args=（self.id，））
msg=“http://%s%s”%（Site.objects.get\u current（）.domain，relative\u url）
返回消息
@静力学方法
def编码链接（旅游id、旅游id）：
编码=旅游者id*大的基本数量+旅游者id
返回编码
@静力学方法
def解码链接（查询）：
int\u query=query和int（query）
pk=int\u查询/BIG\u PRIM\u NUM
游客id=int\u查询%BIG\u PRIM\u NUM
返回（主键、游客识别号）
def验证相册链接（自）：
返回self.album\u链接（-1）

班级照片（模特。模特）：

REQ_字段=[“pk”，“s3_url”]
s3_url=models.URLField（“照片存储url”，最大长度=250）
s3\u url\u processed=models.ImageField（“已处理照片”，
最大长度=250，
上传到=照片上传路径，
空=真）
s3\u url\u相册=models.ImageField（“相册大小照片”，
最大长度=250，
上传到=照片上传路径，
空=真）
s
class Tourist(models.Model):

REQ_FIELDS = ["pk", "name", "email", "phone_number", "facebook_id",
              "phone_is_verified", "is_banned", "bus_id"]

name = models.CharField(max_length = 200)
email = models.EmailField()
phone_number = models.CharField(max_length = 30,
                                null=True,
                                blank=True,
                                default="")
facebook_id = models.CharField(max_length = 255,
                               null=True,
                               blank=True,
                               default="")
phone_verification_hash = models.CharField(max_length=100,
                                           blank=True,
                                           null=True,
                                           default="")
phone_is_verified = models.BooleanField(default = False)
is_banned = models.BooleanField(default = False)
backoffice_notes = models.CharField(blank=True, null=True, default="", max_length=250)
bus = models.ForeignKey(Bus, blank = True, null = True, related_name="tourists")
is_admin_added = models.BooleanField(default = False)

creation_date = models.DateTimeField(default=lambda: timezone.make_aware(datetime.datetime.now(),timezone.get_default_timezone()).replace(microsecond=0))
modified_date = models.DateTimeField(default=lambda: timezone.make_aware(datetime.datetime.now(),timezone.get_default_timezone()).replace(microsecond=0), auto_now=True)

lang = models.CharField(choices =(("he", "Hebrew"), ("en", "English"),), default = "he", max_length = 100)

def need_phone_verification(self):
    return bool(self.phone_number) and not self.phone_is_verified

def is_phone_verified(self):
    """
    can he receive sms?
    """
    return bool(self.phone_number) and self.phone_is_verified

def is_facebook_verified(self):
    return bool(self.facebook_id)

def login_is_verified(self):
    """
    can he upload photos?
    """
    return not self.is_banned and \
               (self.is_phone_verified() or self.is_facebook_verified()) or \
               self.is_admin_added

def verify_phone(self):
    ans = self.send_verification_code()
    return ans

def send_verification_code( self ):
    random.seed( timezone.make_aware(datetime.datetime.now(),timezone.get_default_timezone()) )
    verify_code = str( int(random.random() * 9000 + 1000))

    if sms_verify_send( self.phone_number, verify_code ):
        self.phone_verification_hash = hashlib.sha1(verify_code).hexdigest()
        self.save()
    else:
        raise Exception("Bad SMS Server")
    return verify_code

def receive_verification_code( self, submitted_code ):
    if hashlib.sha1(submitted_code).hexdigest() == \
            self.phone_verification_hash:

        self.phone_is_verified = True
        self.save()
        return True
    return False

def __unicode__(self):
    return u"%s (%s, %s)" % ( self.name, self.email, self.phone_number )

def to_dict(self):
    obj = {}
    for field_name in self.REQ_FIELDS:
        obj[field_name] = getattr(self, field_name)
    return obj

def image_name(self):

    hebrew_test = any(u"\u0590" <= c <= u"\u05EA" for c in self.name)
    if hebrew_test:
        # if the name is in hebrew we flip it over so it will display 
        # correctly
        self.name= self.name[::-1]

    ans = self.name
    if self.is_phone_verified():
        if hebrew_test:
            ans = "(%s) %s" % (self.phone_number[-4:], self.name )
        else:
            ans = "%s (%s)" % (self.name, self.phone_number[-4:] )
    return ans

REQ_FIELDS = ["pk", "title", "start_time", "end_time", "display_order",
              "is_cancelled" ]

title = models.CharField(max_length = 200)
start_time = models.DateTimeField()
end_time = models.DateTimeField()
custom_logo = models.FileField(help_text="Please use a png file",
                               upload_to='media/tour_logo',
                               blank=True,
                               null=True,
                               validators=[is_png_ext])
display_order = models.IntegerField(choices = ((1, 'First in, First out'),
                                               (2, 'First in, Last out'),
                                               (3, 'Equal among users'),
                                               (4, 'Equal among busses')))
is_cancelled = models.BooleanField(default = False)

busses = models.ManyToManyField(Bus, blank=True, null=True, related_name = "tours")
tourists = models.ManyToManyField(Tourist, blank=True, null=True, related_name = "tours")
tourists_to_be_informed = models.ManyToManyField(Tourist, blank=True, null=True, related_name = "tours_to_be_informed")
transportation_company_provider = models.ForeignKey(Transportation_company, related_name = "tours")

backoffice_notes = models.CharField(blank=True, null=True, default="", max_length=250)

client = models.ForeignKey(Client, related_name="tours")

is_album_sent = models.BooleanField("Was the Album sent", default = False)

tourist_validator_mail = models.EmailField(blank=True, null=True)

creation_date = models.DateTimeField(default=lambda: timezone.make_aware(datetime.datetime.now(),timezone.get_default_timezone()).replace(microsecond=0))
modified_date = models.DateTimeField(default=lambda: timezone.make_aware(datetime.datetime.now(),timezone.get_default_timezone()).replace(microsecond=0), auto_now=True)

def is_valid(self):
    start = self.start_time
    # now = datetime.datetime.now()
    # we us time-zone aware time
    now = timezone.make_aware(datetime.datetime.now(),timezone.get_default_timezone())


    return start < now and not self.is_album_sent and not self.is_cancelled

def __unicode__(self):
    return u"%s" % self.title

def to_dict(self):
    obj = {}
    for field_name in self.REQ_FIELDS:
        obj[field_name] = getattr(self, field_name)
    return obj

def compare_date(self, curr ):
    """
    checks if time is before tour started ( then is with minus )
    or in the tour time ( with value 0 )
    or after ( with plus )
    """
    start = self.start_time
    end = self.end_time
    if curr < start:
        return -1
    if end < curr:
        return 1
    return 0

def began_and_running(self):
    # we us time-zone aware time
    time_now = timezone.make_aware(datetime.datetime.now(),timezone.get_default_timezone())
    began_and_running = self.start_time < time_now and self.photos.count() > 4
    return began_and_running

def inform(self):
    from views import contact
    if self.tourists_to_be_informed.count() > 0:
        if self.began_and_running():
            for tourist in self.tourists_to_be_informed.all():
                contact(tourist, "joined_past_notice", self)
                self.tourists_to_be_informed.remove(tourist)

def stats(self):
    return {"id": self.id,
            "title": self.title,
            "day_count": (self.end_time - self.start_time).days,
            "photo_count": self.photos.count(),
            "photo_removed_count": self.photos.filter(is_removed=True)
                                              .count(),
            "tourist_count": self.tourists.count()}

def album_link(self, tourist_id):
    query = Tour.encode_link(self.id, tourist_id)
    relative_url = build_url("pictours_app:album", get = {"query": query})

    msg = "http://%s%s" % (Site.objects.get_current().domain, relative_url)
    return msg

def slideshow_link(self, tourist_id):
    query = Tour.encode_link(self.id, tourist_id)
    relative_url = build_url('pictours_app:slideshow', get = {"query": query})

    msg = "http://%s%s" % (Site.objects.get_current().domain, relative_url)
    return msg

def transportation_company(self):
    tc = self.photos.exists() and self.photos.all()[0].bus.transportation_company
    return tc

def admin_link(self):
    relative_url = build_url('admin:pictours_app_touractive_change', args = (self.id,))

    msg = "http://%s%s" % (Site.objects.get_current().domain, relative_url)
    return msg

@staticmethod
def encode_link(tour_id, tourist_id):
    encoded = tour_id * BIG_PRIM_NUM + tourist_id
    return encoded

@staticmethod
def decode_link(query):
    int_query = query and int(query)
    pk = int_query / BIG_PRIM_NUM
    tourist_id = int_query % BIG_PRIM_NUM
    return (pk, tourist_id)

def validate_album_link(self):
    return self.album_link( -1 )

REQ_FIELDS = ["pk", "s3_url"]

s3_url = models.URLField("Photo storage url", max_length=250)
s3_url_processed = models.ImageField("Processed photo",
                                     max_length=250,
                                     upload_to=Photo_upload_path,
                                     null = True)

s3_url_album = models.ImageField("Album size photo",
                                 max_length=250,
                                 upload_to=Photo_upload_path,
                                 null = True)

s3_url_thumbnail = models.ImageField("Thumbnail size photo",
                                     max_length=250,
                                     upload_to=Photo_upload_path,
                                     null = True)

tour = models.ForeignKey(Tour, related_name="photos")

tourist = models.ForeignKey(Tourist,
                            related_name="photos")

bus = models.ForeignKey(Bus, related_name="photos")

description = models.CharField("backoffice notes",
                               max_length=250,
                               null=True,
                               blank=True,
                               default="")

is_featured = models.BooleanField(default = False)
is_removed = models.BooleanField(default = False)
tourist_removed = models.ForeignKey( Tourist,
                                     related_name="removed_photos",
                                     verbose_name="Tourist who removed photo",
                                     help_text="Valid when photo is removed",
                                     null=True,
                                     blank=True)

creation_date = models.DateTimeField(
    default=lambda: timezone.make_aware(datetime.datetime.now(),timezone.get_default_timezone()).replace(microsecond=0),
    editable=False)

# creation_date = models.DateTimeField(
#     default=lambda: datetime.datetime.now(pytz.timezone('US/Pacific')).replace(microsecond=0),
#     editable=False,
#     blank=True)



modified_date = models.DateTimeField(
    default=lambda: timezone.make_aware(datetime.datetime.now(),timezone.get_default_timezone()).replace(microsecond=0),
    auto_now=True)

def save(self, *args, **kwargs):
    from views import handle_photo
    self.bus = self.tourist.bus
    handle_photo(self, self.tour.client)
    self.tour.inform()
    super(Photo, self).save(*args, **kwargs)  # Call the "real" save() method.

def to_dict(self):
    obj = {}
    for field_name in self.REQ_FIELDS:
        obj[field_name] = getattr(self, field_name)
    return obj

def __unicode__(self):
    return u"<photo>tourist: %s @tour: %s" % (self.tourist, self.tour)