Relations entre Google et le moteur d'application

StackOverflow https://stackoverflow.com/questions/1210321

Question

J'essaie de relier mes modèles à l'aide de ReferenceProperty, mais je n'ai pas beaucoup de chance. J'ai 3 niveaux: groupe, sujet, puis avantages et inconvénients. Comme dans un groupe, de nombreux sujets peuvent être abordés, chacun pouvant comporter de nombreux avantages et inconvénients.

Je suis capable de stocker de nouveaux groupes, mais je ne sais pas comment stocker les sujets sous ces groupes. Je souhaite créer un lien depuis une page avec un lien "Nouveau sujet". sous chaque groupe, cela les amène à un simple formulaire (1 champ pour le moment). Évidemment, l'URL devra avoir une sorte de référence à l'identifiant du groupe ou quelque chose du genre.

Voici mes modèles: 

class Groups(db.Model):

    group_user = db.UserProperty()
    group_name = db.StringProperty(multiline=True)
    group_date = db.DateTimeProperty(auto_now_add=True)


class Topics(db.Model):

    topic_user = db.UserProperty()
    topic_name = db.StringProperty(multiline=True)
    topic_date = db.DateTimeProperty(auto_now_add=True)
    topic_group = db.ReferenceProperty(Groups, collection_name='topics')

class Pro(db.Model):

    pro_user = db.UserProperty()
    pro_content = db.StringProperty(multiline=True)
    pro_date = db.IntegerProperty(default=0)
    pro_topic = db.ReferenceProperty(Topics, collection_name='pros')    

class Con(db.Model):

    con_user = db.UserProperty()
    con_content = db.StringProperty(multiline=True)
    con_date = db.IntegerProperty(default=0)
    con_topic = db.ReferenceProperty(Topics, collection_name='cons')

Et une fonction pour la page actuelle, je veux afficher la liste des groupes, puis sous leurs sujets: 

class Summary(webapp.RequestHandler):
    def get(self):

        groups_query = Groups.all()
        groups = groups_query.fetch(1000)
        template_values = {

            'groups': groups,           
        }

        path = os.path.join(os.path.dirname(__file__), 'summary.html')
        self.response.out.write(template.render(path, template_values))

Et enfin le html: 

<html>
  <body>
    <a href="/newgroup">New Group</a>
    <br>
    {% for group in groups %}

    <font size="24">{{ group.group_name|escape }}</font><br> by <b>{{ group.group_user }}</b> at <b>{{ group.group_date }}</b> {{ group.raw_id }}
    <br>
    <a href="/newtopic?id={{group.key.id}}" >New topice </a>
    <br>
    <blockquote>
        {{ topics.topics_name }}
    </blockquote>


    {% endfor %}
  </body>
</html>
Était-ce utile?

La solution

Quelque chose qui a des effets secondaires, tels que la modification du magasin (en créant un nouvel objet par exemple) doit NE PAS être un HTTP GET - GET ne devrait essentiellement faire que " lire " opérations. Ce n'est pas de la pédanterie, c'est un élément clé de la sémantique HTTP - les navigateurs, les caches, les mandataires, etc., sont autorisés à agir sur GET en tant qu'opérations en lecture seule (par exemple en mettant en cache les résultats et en ne transmettant pas de requête au serveur). peut le satisfaire à partir du cache).

Pour les modifications, utilisez des verbes HTTP tels que POST (principalement parce que tous les navigateurs l’implémentent correctement) ou pour des opérations spécialisées PUT (créer de nouveaux objets) ou DELETE (supprimer des objets). Je suppose que vous utiliserez POST pour prendre en charge divers navigateurs.

Pour obtenir un POST depuis un navigateur, vous avez besoin de l'assistant Javascript ou d'un ancien formulaire simple avec method = post - je vais supposer ce dernier par souci de simplicité.

Si vous utilisez Django 1.0 (que le moteur d'applications prend en charge maintenant), il dispose de ses propres mécanismes pour créer, valider et accepter des formulaires basés sur des modèles. D'autres cadres ont leurs propres couches avancées similaires.

Si vous souhaitez éviter les " riches " Si vous souhaitez implémenter à la main des modèles pour vos formulaires HTML, dirigez-les (via une sorte de dispatch d'URL, par exemple dans app.yaml) vers un de vos gestionnaires implémentant avec un def post (self): , récupérez les données de la requête, validez-les, créez le nouvel objet, mettez-le, affichez une page d'accusé de réception.

Quelles parties de la procédure ne vous sont pas claires? Le titre de votre question se concentre spécifiquement sur les propriétés de référence, mais je ne sais pas quel problème elles vous posent en particulier. D'après le texte de votre question, vous semblez être sur la bonne voie à leur sujet.

Modifier : le PO a maintenant précisé dans un commentaire que son problème était de savoir comment créer quelque chose comme: 

"<a href="/newtopic?id={{group.key.id}}" >New topic </a>"

travailler. Il y a plus d'une façon de faire ça. Si l'URL newtopic est desservie par un formulaire statique, le gestionnaire de la publication "Action". de cette forme pourrait revenir à cette id = via l'en-tête Referer: (une faute d'orthographe notoire mais non corrigible), mais c'est un peu maladroit et fragile. Il est préférable que l'URI newtopic soit servi par un gestionnaire dont le def get obtient le id = de la demande et l'insère dans le modèle de formulaire résultant - par exemple, dans une champ de saisie caché. Le modèle de ce formulaire contient-il (parmi les autres champs): 

<INPUT TYPE=hidden NAME=thegroupid VALUE={{ theid }}> </INPUT>

placez theid dans le contexte avec lequel vous rendez ce modèle, et ce sera dans la requête que le def post de l'action recevant le formulaire obtiendra finalement.

Autres conseils

Juste pour répondre à la question des autres, comme vous l'avez probablement compris: 

class NewTopic(webapp.RequestHandler):
    def get(self):
      groupId = self.request.get('group')
      # either get the actual group object from the DB and initialize topic with topic_group=object as in 'Nick Johnson's answer, or do as follows
      topic = Topic()
      topic.name = self.request.get("topicname")
      topic.reference = groupId
      topic.put()

Merci pour la réponse.

Oui, je suis au courant du post contre get. La classe que j'ai postée était juste d'imprimer tous les groupes ().

Mon problème est que je ne sais pas comment utiliser les modèles pour conserver les données de manière hiérarchique, avec les groupes > Sujets > Avantages / inconvénients

La saisie de données est assez simple et j'utilise: 

class NewGroupSubmit(webapp.RequestHandler):
    def post(self):

        group = Groups()
        if users.get_current_user():
            group.group_user = users.get_current_user()     
        group.group_name = self.request.get('groupname')

        group.put()
        self.redirect('/summary')

J'ai besoin d'une autre fonction pour ajouter un nouveau sujet, qui le stocke dans ce groupe. Supposons qu'un groupe soit " Voitures " par exemple; les sujets peuvent être "Ferrari", "Porsche", "BMW", puis le pour / le contre pour chaque sujet. Je me rends compte que je suis un peu vague, mais c’est parce que je suis très novice en matière de base de données relationnelle et que je n’ai pas tout à fait la terminologie.

Je ne suis pas sûr du problème que vous rencontrez. Tout ce que vous listez a l’air bien: les propriétés de référence sont configurées en fonction de ce à quoi on pourrait s’attendre de votre description. Le seul problème que je vois est que dans votre modèle, vous faites référence à une variable "topic", qui n'est définie nulle part, et que vous ne parcourez pas les sujets d'un groupe où que ce soit. Vous pouvez le faire comme ceci: 

<html>
  <body>
    <a href="/newgroup">New Group</a>
    <br>
    {% for group in groups %}

    <font size="24">{{ group.group_name|escape }}</font><br> by <b>{{ group.group_user }}</b> at <b>{{ group.group_date }}</b> {{ group.raw_id }}
    <br>
    <a href="/newtopic?id={{group.key.id}}" >New topice </a>
    <br>
    Topics:
    <ul>
      {% for topic in group.topics %}
        <li>{{topic.topic_name}}</li>
      {% endfor %}
    </ul>
    {% endfor %}
  </body>
</html>

Pour créer un nouveau sujet, utilisez simplement le constructeur, en passant les arguments requis: 

mytopic = Topic(topic_name="foo", topic_group=somegroup)

Ici, somegroup devrait être soit un objet Group, soit une clé pour un objet Group.

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top