djangobook.com

After Django 1.8, it was required that forms explicitly indicate which fields they wanted to display in class Meta, so you definitely need to do it in 2.2.6.

fields is an inclusive way to listing fields. If you explicitly want to list which fields are included in the form, you put them here. This means that if you ever change your model, the new fields in the model will not automatically be added to the form unless you set fields to __all__

exclude is unsurprisingly the opposite of that. It means that the form includes all fields except those explicitly listed in exclude. If you change your model, new fields will be added to the form unless you change what is in exclude.

The differences are not really that large in the grand scheme of things. It just depends on whether you want to explicitly specify what is included or what is excluded.

If you are on Linux just use the command python3 -m venv myvenv in the directory of your project and you're done!

You can't access self.user_context_id inside referenced_catalog = forms.ModelChoiceField(...) - that code runs when the module is loaded, not when the form is initialised.

Instead, you should set the queryset inside the __init__ method.

Assuming based on your post that you are using Django just to pull data from a database and serve it back to a client in JSON format, and that your templates will be rendered client-side (using, e.g. Angular) then you are correct that you likely won't be needing Django templates. However, you would still need some sort of models (whether you use Django models or something else) and also would need controllers (which Django calls views) in order to:

1. Do URL routing (that is, bind some URL to some controller/view function).
2. Do some kind of server-side processing. Even if your app is a single-page app and does a lot of client-side processing, you'll still likely need to implement different kinds of business requirements and validation on the server side. Some of these requirements you can likely attach to the models, but others you may need to implement in controllers.

So while your controllers (aka views) may be a lot "skinnier" due to the way you're structuring your app, they'll still be necessary to some extent. Models will always be necessary if you want some clean and consistent API to your DB.

EDIT: To expand more on this--while there is a Python library called Django REST Framework, it's really just there to assist you in building RESTful APIs. You can certainly build a RESTful API yourself using Django without leveraging it or any additional libraries. As the answer from user D. Shawley states in response to this question -- What exactly is RESTful programming? -- a RESTful API is basically just one where resources are identified by a persistent identifier (in this case, URIs), and where resources are manipulated using a common set of verbs (in this case, HTTP methods like GET, POST, DELETE, etc). So using this idea of URIs as nouns and HTTP methods as verbs, your Django framework might support the following RESTful operations:

• GET https://your-app.com/product/123 - this operation fetches a product identified by the ID 123
• POST https://your-app.com/product - this operation creates a new product
• PUT https://your-app.com/product/123 - this operation updates a product identified by the ID 123
• DELETE https://your-app.com/product/123 - this operation deletes a product identified by the ID 123

The data that come back from these operations doesn't necessarily need to be in any particular format (be it JSON, XML, or something else). In an application that closely adheres to the principles of REST, the client (consumer of your RESTful API, in this case your front-end app) would be able to specify (using the HTTP Accept header) which format they want to consume the data in.

I hope that's not too confusing, but really I want to make it clear that REST architecture is just a set of principles, and APIs that web programmers develop may not necessarily adhere to these principles 100%. Whether it's necessary for your application to strictly adhere to RESTful principles depends on your particular requirements. One question to ask yourself then is what are you hoping to accomplish by building a RESTful API using Django? For a lot of developers, the answer is simply "so that I have an easy-to-use interface for my Angular/React/etc. app to retrieve and update server-side resources."

This is a bit gnarly, but here's a potential solution if you don't want to give up on the Django framework:

The problem is that the method add_domain is buried deep in a huge method within syndication framework, and I don't see a clean way to override it. Since this method is used for both the feed URL and the feed items, a monkey patch of add_domain would need to consider this.

Django source: https://github.com/django/django/blob/master/django/contrib/syndication/views.py#L178

1: Subclass the Feed class you're using and do a copy-paste override of the huge method get_feed

2: Modify the line:

After the table displays some data correctly, you must also make sure the filter formset is displayed. I usually use something like this (in this case using {% load bootstrap3 %}

You can't serve static files. django with DEBUG mode turned off isn't responsible for that. Ngnix is better option with chache mechanisms for that. You should check out Heroku platform how they deploy production ready django projects with whitenoise for example. Github has a lot of examples of opensource projects powered with django that you can learn from

I had a similar problem and ended up designing my own permission system, because with the default django permission system, it is not possible to do per-object permissions.

I simply added a model LabAccess with a foreign key on django.contrib.auth.models.Group (because I often have multiple instructors by course) and another foreign key for the course. (This allows multiple groups be instructor in a course). Then, in each view for instructors, I check whether one of the groups the user belongs to has an item in the LabAccess table. The source code of this system is actually available, if you are interested.

Note that there are also django extensions that support per-object permissions, like (django-guardian)[http://django-guardian.readthedocs.io/en/stable/]. (I have no experience with it,)