├── .flake8
├── .github
    └── workflows
    │   ├── release.yml
    │   └── test.yml
├── .gitignore
├── .versionrc.json
├── AUTHORS
├── CHANGELOG.md
├── LICENSE
├── MANIFEST.in
├── Makefile
├── OSSMETADATA
├── README.rst
├── codegen.py
├── django_mongoengine
    ├── __init__.py
    ├── apps.py
    ├── contrib
    │   ├── __init__.py
    │   └── drf_spectacular.py
    ├── document.py
    ├── fields
    │   ├── __init__.py
    │   ├── djangoflavor.py
    │   └── internal.py
    ├── forms
    │   ├── __init__.py
    │   ├── document_options.py
    │   ├── documents.py
    │   ├── fields.py
    │   ├── utils.py
    │   └── widgets.py
    ├── mongo_admin
    │   ├── __init__.py
    │   ├── actions.py
    │   ├── apps.py
    │   ├── decorators.py
    │   ├── helpers.py
    │   ├── management
    │   │   ├── __init__.py
    │   │   └── commands
    │   │   │   ├── __init__.py
    │   │   │   └── createmongodbsuperuser.py
    │   ├── options.py
    │   ├── sites.py
    │   ├── static
    │   │   ├── dict.js
    │   │   ├── helper.js
    │   │   └── jquery-1.8.0.min.js
    │   ├── templates
    │   │   └── mongo_admin
    │   │   │   └── index.html
    │   ├── util.py
    │   ├── validation.py
    │   └── views.py
    ├── mongo_auth
    │   ├── __init__.py
    │   ├── admin.py
    │   ├── backends.py
    │   ├── managers.py
    │   └── models.py
    ├── paginator.py
    ├── queryset.py
    ├── sessions.py
    ├── utils
    │   ├── __init__.py
    │   ├── monkey.py
    │   └── wrappers.py
    └── views
    │   ├── __init__.py
    │   ├── detail.py
    │   ├── edit.py
    │   ├── embedded.py
    │   ├── list.py
    │   └── templates
    │       └── _forms.html
├── docs
    ├── Makefile
    ├── _static
    │   └── debugtoolbar.png
    ├── _themes
    │   ├── README
    │   ├── flask
    │   │   ├── static
    │   │   │   └── flasky.css_t
    │   │   └── theme.conf
    │   ├── flask_small
    │   │   ├── layout.html
    │   │   ├── static
    │   │   │   └── flasky.css_t
    │   │   └── theme.conf
    │   └── flask_theme_support.py
    ├── changelog.rst
    ├── conf.py
    ├── examples.rst
    ├── index.rst
    └── make.bat
├── example
    └── tumblelog
    │   ├── Pipfile
    │   ├── manage.py
    │   ├── requirements.txt
    │   └── tumblelog
    │       ├── __init__.py
    │       ├── admin.py
    │       ├── forms.py
    │       ├── models.py
    │       ├── settings.py
    │       ├── templates
    │           ├── _delete.html
    │           ├── _details.html
    │           ├── _forms.html
    │           ├── _messages.html
    │           ├── base.html
    │           └── tumblelog
    │           │   └── post_list.html
    │       ├── urls.py
    │       ├── views.py
    │       └── wsgi.py
├── pyproject.toml
├── pyrightconfig.json
├── pytest.ini
├── sg-rules
    └── 0.6.0-rewrite-blank.yml
├── tests
    ├── __init__.py
    ├── forms
    │   ├── __init__.py
    │   ├── models.py
    │   └── tests.py
    ├── settings.py
    ├── test_document_options.py
    ├── test_models.py
    ├── test_utils
    │   ├── __init__.py
    │   └── test_monkey.py
    └── views
    │   ├── __init__.py
    │   ├── detail.py
    │   ├── edit.py
    │   ├── forms.py
    │   ├── list.py
    │   ├── models.py
    │   ├── templates
    │       ├── registration
    │       │   └── login.html
    │       └── views
    │       │   ├── about.html
    │       │   ├── apple_detail.html
    │       │   ├── artist_detail.html
    │       │   ├── artist_form.html
    │       │   ├── author_confirm_delete.html
    │       │   ├── author_detail.html
    │       │   ├── author_form.html
    │       │   ├── author_list.html
    │       │   ├── author_objects.html
    │       │   ├── author_view.html
    │       │   ├── book_archive.html
    │       │   ├── book_archive_day.html
    │       │   ├── book_archive_month.html
    │       │   ├── book_archive_week.html
    │       │   ├── book_archive_year.html
    │       │   ├── book_detail.html
    │       │   ├── book_list.html
    │       │   ├── confirm_delete.html
    │       │   ├── detail.html
    │       │   ├── form.html
    │       │   ├── list.html
    │       │   └── page_template.html
    │   ├── tests.py
    │   ├── urls.py
    │   └── views.py
└── uv.lock


/.flake8:
--------------------------------------------------------------------------------
 1 | # vim: set ft=dosini:
 2 | [flake8]
 3 | ignore =
 4 |     E501,
 5 |     E123,
 6 |     E221,
 7 |     E231,
 8 |     E241,
 9 |     E272,
10 |     E731,
11 |     N806,
12 |     C901
13 | exclude =
14 |     .git,
15 |     __pycache__,
16 |     dist,
17 |     node_modules
18 | max-complexity = 10
19 | 


--------------------------------------------------------------------------------
/.github/workflows/release.yml:
--------------------------------------------------------------------------------
 1 | name: Release
 2 | on:
 3 |   push:
 4 |     tags:
 5 |       - v*
 6 | env:
 7 |   GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 8 | jobs:
 9 |   Release:
10 |     runs-on: ubuntu-latest
11 |     steps:
12 |       - uses: actions/checkout@v3
13 |       - name: Set up Python
14 |         uses: astral-sh/setup-uv@v5
15 |         with:
16 |           python-version: "3.10"
17 |       - name: Build artifacts
18 |         run: |
19 |           uvx --from build python -m build --installer uv
20 |       - name: Create release
21 |         uses: softprops/action-gh-release@v2
22 |         with:
23 |           files: dist/*
24 | 


--------------------------------------------------------------------------------
/.github/workflows/test.yml:
--------------------------------------------------------------------------------
 1 | # Docs:
 2 | #  - https://docs.github.com/en/actions/guides/about-service-containers
 3 | #  - https://github.com/actions/example-services/blob/main/.github/workflows/mongodb-service.yml
 4 | name: CI
 5 | on:
 6 |   push:
 7 |     branches:
 8 |       - master
 9 |   pull_request:
10 | jobs:
11 |   Test:
12 |     runs-on: ubuntu-latest
13 |     strategy:
14 |       matrix:
15 |         python:
16 |           - "3.9"
17 |           - "3.10"
18 |           - "3.11"
19 |           - "3.12"
20 |           - "3.13"
21 |           - "pypy3.10"
22 |         django:
23 |           - "Django>=4.2,<4.3"
24 |           - "Django>=5.0,<5.1"
25 |           - "Django>=5.1,<5.2"
26 |         exclude:
27 |           - python: "3.9"
28 |             django: "Django>=5.0,<5.1"
29 |           - python: "3.9"
30 |             django: "Django>=5.1,<5.2"
31 |     env:
32 |       GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
33 |       DJANGO: ${{ matrix.django }}
34 |     services:
35 |       mongodb:
36 |         image: mongo
37 |         ports:
38 |           - 27017:27017
39 |     steps:
40 |       - uses: actions/checkout@v3
41 |       - name: Set up Python ${{ matrix.python-version }}
42 |         uses: astral-sh/setup-uv@v5
43 |         with:
44 |           enable-cache: true
45 |           python-version: ${{ matrix.python }}
46 |       - name: Set up env
47 |         run: |
48 |           uv sync --group dev
49 |           uv pip install -q "${{ matrix.django }}"
50 |       - name: Run tests
51 |         run: |
52 |           uv run ruff check .
53 |           uv run ruff format --check .
54 |           uv run python -m pytest
55 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | !.gitignore
 2 | *~
 3 | *.py[co]
 4 | .*.sw[po]
 5 | *.egg
 6 | docs/.build
 7 | docs/_build
 8 | build/
 9 | dist/
10 | env/
11 | .venv
12 | Pipfile.lock
13 | .settings
14 | .project
15 | .coverage
16 | .pydevproject
17 | tests/bugfix.py
18 | *.egg-info
19 | 


--------------------------------------------------------------------------------
/.versionrc.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "host": "github.com",
 3 |   "owner": "MongoEngine",
 4 |   "repository": "django-mongoengine",
 5 |   "bumpFiles": [
 6 |     {
 7 |       "filename": "VERSION",
 8 |       "type": "plain-text"
 9 |     }
10 |   ]
11 | }
12 | 


--------------------------------------------------------------------------------
/AUTHORS:
--------------------------------------------------------------------------------
1 | Ross Lawley <ross.lawley@gmail.com>
2 | Jan Schrewe <jan@schafproductions.com>
3 | Wilson Júnior <wilsonpjunior@gmail.com>
4 | Maxime Verger-Del Bove <mvergerdelbove@work4labs.com>
5 | Harry Marr <harry@hmarr.com>
6 | Thiago Avelino <thiagoavelinoster@gmail.com>
7 | Sergey Tereschenko <serg.partizan@gmail.com>
8 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
  1 | # Changelog
  2 | 
  3 | All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
  4 | 
  5 | ## [0.6.0-beta.5](https://github.com/MongoEngine/django-mongoengine/compare/v0.6.0-beta.4...v0.6.0-beta.5) (2025-04-20)
  6 | 
  7 | ## [0.6.0-beta.4](https://github.com/MongoEngine/django-mongoengine/compare/v0.6.0-beta.3...v0.6.0-beta.4) (2025-04-20)
  8 | 
  9 | ## [0.6.0-beta.3](https://github.com/MongoEngine/django-mongoengine/compare/v0.6.0-beta.2...v0.6.0-beta.3) (2024-12-28)
 10 | 
 11 | 
 12 | ### Bug Fixes
 13 | 
 14 | * Drop pypy 3.9 support ([cf5a89b](https://github.com/MongoEngine/django-mongoengine/commit/cf5a89bd0953091e9028cf18496c977ebe7e4145))
 15 | 
 16 | ## [0.6.0-beta.2](https://github.com/MongoEngine/django-mongoengine/compare/v0.6.0-beta.1...v0.6.0-beta.2) (2023-11-16)
 17 | 
 18 | 
 19 | ### Bug Fixes
 20 | 
 21 | * Fix BooleanField ([e5a87c6](https://github.com/MongoEngine/django-mongoengine/commit/e5a87c6ed7b23018410903524915ad7a0e182ead))
 22 | 
 23 | ## [0.6.0-beta.1](https://github.com/MongoEngine/django-mongoengine/compare/v0.6.0-beta.0...v0.6.0-beta.1) (2023-11-16)
 24 | 
 25 | 
 26 | ### Features
 27 | 
 28 | * Switch to ruff formatter ([3183d28](https://github.com/MongoEngine/django-mongoengine/commit/3183d286f152d418acf49ecee8b3c3dc49d6b53c))
 29 | 
 30 | ## [0.6.0-beta.0](https://github.com/MongoEngine/django-mongoengine/compare/v0.5.7-beta.1...v0.6.0-beta.0) (2023-11-15)
 31 | 
 32 | 
 33 | ### ⚠ BREAKING CHANGES
 34 | 
 35 | * Removed `blank` argument support for fields, use mongoengine `required` instead.
 36 |   `ast-grep` can be used to automatically rewrite old code:
 37 | 
 38 |   ```
 39 |   ast-grep scan -r sg-rules/0.6.0-rewrite-blank.yml . -i
 40 |   ```
 41 |   Be careful to review, clean it up and test.
 42 | 
 43 | * Switch to mongoengine style field arguments. Drop old django ([#200](https://github.com/MongoEngine/django-mongoengine/issues/200)) ([9d56f6a](https://github.com/MongoEngine/django-mongoengine/commit/9d56f6a58ccee93e2acae7af0a8d81d9aa43ae5b))
 44 | 
 45 | ### [0.5.7-beta.1](https://github.com/MongoEngine/django-mongoengine/compare/v0.5.7-beta.0...v0.5.7-beta.1) (2023-11-04)
 46 | 
 47 | 
 48 | ### Bug Fixes
 49 | 
 50 | * Fix typing_extensions dependency ([6fa3394](https://github.com/MongoEngine/django-mongoengine/commit/6fa339407c32ae4b49589d9f5f1b1628c7458cf7))
 51 | 
 52 | ### [0.5.7-beta.0](https://github.com/MongoEngine/django-mongoengine/compare/v0.5.6...v0.5.7-beta.0) (2023-11-04)
 53 | 
 54 | 
 55 | ### Bug Fixes
 56 | 
 57 | * More work on typing support; add black and ruff ([b9a0e0e](https://github.com/MongoEngine/django-mongoengine/commit/b9a0e0ec420faaec30a3d6a2f37d53ecf5461c6e))
 58 | 
 59 | ### [0.5.6](https://github.com/MongoEngine/django-mongoengine/compare/v0.5.6-beta.0...v0.5.6) (2023-11-03)
 60 | 
 61 | 
 62 | ### Bug Fixes
 63 | 
 64 | * **typing:** Add static types for dynamic classes ([5c843e6](https://github.com/MongoEngine/django-mongoengine/commit/5c843e60f6cd26ebc232dac66b56c626a5808e73))
 65 | 
 66 | ### [0.5.6-beta.0](https://github.com/MongoEngine/django-mongoengine/compare/v0.5.5...v0.5.6-beta.0) (2023-08-16)
 67 | 
 68 | 
 69 | ### Features
 70 | 
 71 | * Update test matrix; drop python 3.7 ([1bca66a](https://github.com/MongoEngine/django-mongoengine/commit/1bca66ad9238420790077c025424ff6c42cb61cb))
 72 | 
 73 | 
 74 | ### Bug Fixes
 75 | 
 76 | * Fix queryset comparison for django 4.2 ([da5f2b5](https://github.com/MongoEngine/django-mongoengine/commit/da5f2b5aab6a850a8217284bf6d24235db847edc))
 77 | 
 78 | ### [0.5.5](https://github.com/MongoEngine/django-mongoengine/compare/v0.5.4...v0.5.5) (2023-08-10)
 79 | 
 80 | 
 81 | ### Bug Fixes
 82 | 
 83 | * **admin:** Use page_num without +1 (just like django does) ([#186](https://github.com/MongoEngine/django-mongoengine/issues/186)) ([8377bff](https://github.com/MongoEngine/django-mongoengine/commit/8377bff9126fb9a8409064e8ff0d87072ae6cb10))
 84 | 
 85 | ### [0.5.4](https://github.com/MongoEngine/django-mongoengine/compare/v0.5.3...v0.5.4) (2022-05-27)
 86 | 
 87 | 
 88 | ### Bug Fixes
 89 | 
 90 | * Fix package metadata ([a2496b4](https://github.com/MongoEngine/django-mongoengine/commit/a2496b4854d67f843f1aae5e9ae0c36bf67a3c74))
 91 | 
 92 | ### [0.5.3](https://github.com/MongoEngine/django-mongoengine/compare/v0.5.2...v0.5.3) (2022-05-27)
 93 | 
 94 | 
 95 | ### Bug Fixes
 96 | 
 97 | * Properly set attributes for auto created field ([3b9c039](https://github.com/MongoEngine/django-mongoengine/commit/3b9c039791991be2b01693c9c561fbcd82ad7564))
 98 | 
 99 | ### [0.5.2](https://github.com/MongoEngine/django-mongoengine/compare/v0.5.1...v0.5.2) (2022-05-26)
100 | 
101 | 
102 | ### Bug Fixes
103 | 
104 | * Fix create without id ([41bc837](https://github.com/MongoEngine/django-mongoengine/commit/41bc837916fca5f8226b4c1b0491db8766477f1f))
105 | 
106 | ### [0.5.1](https://github.com/MongoEngine/django-mongoengine/compare/v0.5.0...v0.5.1) (2022-05-26)
107 | 
108 | 
109 | ### Bug Fixes
110 | 
111 | * Add placeholders for get_path_to_parent/get_path_from_parent ([3653d21](https://github.com/MongoEngine/django-mongoengine/commit/3653d21b979d351b3dd411dbcd74d55e331fbddf))
112 | * Use django-patched ObjectIdField for auto created primary keys. ([5fde4a6](https://github.com/MongoEngine/django-mongoengine/commit/5fde4a6e17d11cab1e53d32a00b15b3ac55ef209))
113 | 
114 | ## [0.5.0](https://github.com/MongoEngine/django-mongoengine/compare/v0.4.5...v0.5.0) (2022-05-14)
115 | 
116 | 
117 | ### Features
118 | 
119 | * Clean up deprecated code for django-4 ([c82cbc6](https://github.com/MongoEngine/django-mongoengine/commit/c82cbc641a78c59e46b5b0e7be0e2867260e17c0)), closes [#156](https://github.com/MongoEngine/django-mongoengine/issues/156)
120 | * Drop django 2.2, add django 4.0 ([6c3d068](https://github.com/MongoEngine/django-mongoengine/commit/6c3d068b305a8f0ba88597ddeb97281a31f204fe))
121 | 
122 | 
123 | ### Bug Fixes
124 | 
125 | * Fix 'StringField' object has no attribute 'flatchoices' ([#161](https://github.com/MongoEngine/django-mongoengine/issues/161)) ([db3860d](https://github.com/MongoEngine/django-mongoengine/commit/db3860d39fa29819fde71953e905f117f680a3be))
126 | * Fix invalid import EMPTY_CHANGELIST_VALUE in django >= 3 ([e8a75e8](https://github.com/MongoEngine/django-mongoengine/commit/e8a75e8e5860545ecfbadaf1b1285495022bd7cb))
127 | * **deps:** Move pytests dependency int dev-dependencies ([f7e37a7](https://github.com/MongoEngine/django-mongoengine/commit/f7e37a75e6612a4243ccc9abdb22f2dc72f53d9e))
128 | 
129 | ### [0.4.6](https://github.com/MongoEngine/django-mongoengine/compare/v0.4.5...v0.4.6) (2021-04-11)
130 | 
131 | 
132 | ### Bug Fixes
133 | 
134 | * **deps:** Move pytests dependency int dev-dependencies ([f7e37a7](https://github.com/MongoEngine/django-mongoengine/commit/f7e37a75e6612a4243ccc9abdb22f2dc72f53d9e))
135 | 
136 | ### [0.4.5](https://github.com/MongoEngine/django-mongoengine/compare/v0.4.5-beta.4...v0.4.5) (2021-04-11)
137 | 
138 | 
139 | ### Features
140 | 
141 | * Remove six ([773c791](https://github.com/MongoEngine/django-mongoengine/commit/773c79169b08ccd71f958e1855a2c47b1c7ebb7e))
142 | * **drf-spectacular:** AutoSchema generator for drf-spectacular support. ([2ef9529](https://github.com/MongoEngine/django-mongoengine/commit/2ef9529e330d482957acf582a56ac7aeabe853c6))
143 | * Support Django 3.2
144 | 
145 | ### Bug Fixes
146 | 
147 | * Add missing __init__.py ([bb11d36](https://github.com/MongoEngine/django-mongoengine/commit/bb11d36cf754bfd19bcff1e643fabd28c44f9e38))
148 | 
149 | 
150 | ### 2016-01-27
151 | 
152 | * Support for django 1.9, minimum django version: 1.7
153 | * Moved `django_mongoengine.mongo_auth.MongoUser` to `django_mongoengine.mongo_auth.models.MongoUser`
154 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2010-2012 See AUTHORS.
 2 | 
 3 | Some rights reserved.
 4 | 
 5 | Redistribution and use in source and binary forms, with or without
 6 | modification, are permitted provided that the following conditions are
 7 | met:
 8 | 
 9 | * Redistributions of source code must retain the above copyright
10 |   notice, this list of conditions and the following disclaimer.
11 | 
12 | * Redistributions in binary form must reproduce the above
13 |   copyright notice, this list of conditions and the following
14 |   disclaimer in the documentation and/or other materials provided
15 |   with the distribution.
16 | 
17 | * The names of the contributors may not be used to endorse or
18 |   promote products derived from this software without specific
19 |   prior written permission.
20 | 
21 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 | 


--------------------------------------------------------------------------------
/MANIFEST.in:
--------------------------------------------------------------------------------
 1 | include MANIFEST.in
 2 | include README.rst
 3 | include LICENSE
 4 | include AUTHORS
 5 | include VERSION
 6 | recursive-include django_mongoengine *.html *.css *.js *.png *.gif *.woff *.ttf *.svg *.eot
 7 | recursive-include docs *
 8 | recursive-exclude docs *.pyc
 9 | recursive-exclude docs *.pyo
10 | prune docs/_build
11 | prune docs/_themes/.git
12 | prune tests/
13 | prune example/
14 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | release:
 2 | 	standard-version
 3 | 
 4 | release-beta:
 5 | 	standard-version -p beta
 6 | 
 7 | publish:
 8 | 	rm -rf dist
 9 | 	python -m build --installer uv
10 | 	twine check dist/*
11 | 	twine upload dist/*
12 | 	git push --follow-tags
13 | 
14 | test:
15 | 	pytest
16 | 
17 | codegen:
18 | 	python codegen.py
19 | 	ruff format django_mongoengine/fields/__init__.py
20 | 	ruff django_mongoengine/ --fix  # It doesn't work with filename.
21 | 


--------------------------------------------------------------------------------
/OSSMETADATA:
--------------------------------------------------------------------------------
1 | osslifecycle=deprecated
2 | 


--------------------------------------------------------------------------------
/README.rst:
--------------------------------------------------------------------------------
  1 | ==================
  2 | Django-MongoEngine
  3 | ==================
  4 | 
  5 | |stand-with-ukraine|
  6 | 
  7 | |lifecycle| |gitter|
  8 | 
  9 | .. |lifecycle| image:: https://img.shields.io/osslifecycle/MongoEngine/django-mongoengine
 10 |    :alt: OSS Lifecycle
 11 | 
 12 | .. |gitter| image:: https://badges.gitter.im/gitterHQ/gitter.png
 13 |    :target: https://gitter.im/MongoEngine/django-mongoengine
 14 |    :alt: Gitter chat
 15 | 
 16 | .. |stand-with-ukraine| image:: https://raw.githubusercontent.com/vshymanskyy/StandWithUkraine/main/banner2-direct.svg
 17 |    :target: https://stand-with-ukraine.pp.ua
 18 |    :alt: Stand With Ukraine
 19 | 
 20 | THIS IS UNSTABLE PROJECT, IF YOU WANT TO USE IT - FIX WHAT YOU NEED
 21 | 
 22 | Right now we're targeting to get things working on Django 4.2;
 23 | 
 24 | WARNING: This project is not in good state, and is likely to break with django updates. Do not use it for any new projects.
 25 | 
 26 | Recommended way for new projects is `django-mongodb-backend <https://github.com/mongodb/django-mongodb-backend>`_.
 27 | 
 28 | Working / Django 4.2
 29 | ------------------------
 30 | 
 31 | * [ok] sessions
 32 | * [ok] models/fields, fields needs testing
 33 | * [ok] views
 34 | * [ok] auth
 35 | * [?] admin - partially working, some things broken
 36 | 
 37 | Current status
 38 | -------------------------------------------------------------------------------
 39 | 
 40 | Many parts of projects rewritten/removed;
 41 | Instead of copying django code i try to subclass/reuse/even monkey-patch;
 42 | Everything listed above is working; admin - just base fuctions
 43 | like changelist/edit, not tested with every form type; need's more work.
 44 | 
 45 | Some code just plaholder to make things work;
 46 | `django/forms/document_options.py` - dirty hack absolutely required to
 47 | get thigs work with django. It replaces mongo _meta on model/class and
 48 | provide django-like interface.
 49 | It get's replaced after class creation via some metaclass magick.
 50 | 
 51 | Fields notes
 52 | ------------
 53 | 
 54 | * Project uses mongoengine style argument `required=False`, not django style `blank=False`,
 55 |   to be compatible with mongo-types.
 56 |   **All your fields are optional by default.**
 57 | 
 58 | 
 59 | TODO
 60 | ----
 61 | 
 62 | * Sync some files/docs that removed from mongoengine: https://github.com/seglberg/mongoengine/commit/a34f4c1beb93f430c37da20c8fd96ce02a0f20c1?diff=unified
 63 | * Add docs for integrating: https://github.com/hmarr/django-debug-toolbar-mongo
 64 | * Take a look at django-mongotools: https://github.com/wpjunior/django-mongotools
 65 | 
 66 | Connecting
 67 | ==========
 68 | 
 69 | In your **settings.py** file, add following lines::
 70 | 
 71 |     MONGODB_DATABASES = {
 72 |         "default": {
 73 |             "name": database_name,
 74 |             "host": database_host,
 75 |             "password": database_password,
 76 |             "username": database_user,
 77 |             "tz_aware": True, # if you using timezones in django (USE_TZ = True)
 78 |         },
 79 |     }
 80 | 
 81 |     INSTALLED_APPS += ["django_mongoengine"]
 82 | 
 83 | Documents
 84 | =========
 85 | Inhherit your documents from ``django_mongoengine.Document``,
 86 | and define fields using ``django_mongoengine.fields``.::
 87 | 
 88 |     from django_mongoengine import Document, EmbeddedDocument, fields
 89 | 
 90 |     class Comment(EmbeddedDocument):
 91 |         created_at = fields.DateTimeField(
 92 |             default=datetime.datetime.now, editable=False,
 93 |         )
 94 |         author = fields.StringField(verbose_name="Name", max_length=255)
 95 |         email  = fields.EmailField(verbose_name="Email")
 96 |         body = fields.StringField(verbose_name="Comment")
 97 | 
 98 |     class Post(Document):
 99 |         created_at = fields.DateTimeField(
100 |             default=datetime.datetime.now, editable=False,
101 |         )
102 |         title = fields.StringField(max_length=255)
103 |         slug = fields.StringField(max_length=255, primary_key=True)
104 |         comments = fields.ListField(
105 |             fields.EmbeddedDocumentField('Comment'), required=False,
106 |         )
107 | 
108 | 
109 | Sessions
110 | ========
111 | Django allows the use of different backend stores for its sessions. MongoEngine
112 | provides a MongoDB-based session backend for Django, which allows you to use
113 | sessions in your Django application with just MongoDB. To enable the MongoEngine
114 | session backend, ensure that your settings module has
115 | ``'django.contrib.sessions.middleware.SessionMiddleware'`` in the
116 | ``MIDDLEWARE_CLASSES`` field  and ``'django.contrib.sessions'`` in your
117 | ``INSTALLED_APPS``. From there, all you need to do is add the following line
118 | into your settings module::
119 | 
120 |     SESSION_ENGINE = 'django_mongoengine.sessions'
121 |     SESSION_SERIALIZER = 'django_mongoengine.sessions.BSONSerializer'
122 | 
123 | Django provides session cookie, which expires after
124 | ```SESSION_COOKIE_AGE``` seconds, but doesn't delete cookie at sessions
125 | backend, so ``'mongoengine.django.sessions'`` supports  `mongodb TTL <http://docs.mongodb.org/manual/tutorial/expire-data/>`_.
126 | 
127 | .. note:: ``SESSION_SERIALIZER`` is only necessary in Django>1.6 as the default
128 |    serializer is based around JSON and doesn't know how to convert
129 |    ``bson.objectid.ObjectId`` instances to strings.
130 | 
131 | 
132 | How to run example app
133 | ----------------------
134 | .. code::
135 | 
136 |     uv sync --group dev
137 |     uv pip install -r example/tumblelog/requirements.txt
138 |     uv run python example/tumblelog/manage.py runserver
139 | 
140 | 
141 | How to run tests
142 | ----------------
143 | .. code::
144 | 
145 |     uv run python -m pytest
146 | 


--------------------------------------------------------------------------------
/codegen.py:
--------------------------------------------------------------------------------
 1 | def generate_fields():
 2 |     """
 3 |     Typing support cannot handle monkey-patching at runtime, so we need to generate fields explicitly.
 4 |     """
 5 |     from mongoengine import fields
 6 |     from django_mongoengine.fields import djangoflavor as mixins
 7 | 
 8 |     fields_code = str(_fields)
 9 |     for fname in fields.__all__:
10 |         mixin_name = fname if hasattr(mixins, fname) else "DjangoField"
11 |         fields_code += f"class {fname}(_mixins.{mixin_name}, _fields.{fname}):\n    pass\n"
12 | 
13 |     return fields_code
14 | 
15 | 
16 | _fields = """
17 | from mongoengine import fields as _fields
18 | from . import djangoflavor as _mixins
19 | from django_mongoengine.utils.monkey import patch_mongoengine_field
20 | 
21 | for f in ["StringField", "ObjectIdField"]:
22 |     patch_mongoengine_field(f)
23 | 
24 | """
25 | 
26 | if __name__ == "__main__":
27 |     fname = "django_mongoengine/fields/__init__.py"
28 |     # This content required, because otherwise mixins import does not work.
29 |     open(fname, "w").write("from mongoengine.fields import *")
30 |     content = generate_fields()
31 |     open(fname, "w").write(content)
32 | 


--------------------------------------------------------------------------------
/django_mongoengine/__init__.py:
--------------------------------------------------------------------------------
 1 | from .document import Document, DynamicDocument, DynamicEmbeddedDocument, EmbeddedDocument
 2 | from .queryset import QuerySet, QuerySetNoCache
 3 | 
 4 | __all__ = [
 5 |     "QuerySet",
 6 |     "QuerySetNoCache",
 7 |     "Document",
 8 |     "DynamicDocument",
 9 |     "EmbeddedDocument",
10 |     "DynamicEmbeddedDocument",
11 | ]
12 | 
13 | try:
14 |     from django import VERSION as _django_version
15 | 
16 |     if _django_version < (3, 2):
17 |         default_app_config = "django_mongoengine.apps.DjangoMongoEngineConfig"
18 | except ImportError:
19 |     pass
20 | 


--------------------------------------------------------------------------------
/django_mongoengine/apps.py:
--------------------------------------------------------------------------------
 1 | from django.apps import AppConfig
 2 | from django.conf import settings
 3 | from django.core.exceptions import ImproperlyConfigured
 4 | from mongoengine import connection
 5 | 
 6 | 
 7 | class DjangoMongoEngineConfig(AppConfig):
 8 |     """Simple AppConfig which does not do automatic discovery."""
 9 | 
10 |     name = "django_mongoengine"
11 |     verbose_name = "Django-MongoEngine"
12 | 
13 |     def ready(self):
14 |         if not hasattr(settings, "MONGODB_DATABASES"):
15 |             raise ImproperlyConfigured("Missing `MONGODB_DATABASES` in settings.py")
16 | 
17 |         for alias, conn_settings in settings.MONGODB_DATABASES.items():
18 |             connection.register_connection(alias, **conn_settings)
19 | 


--------------------------------------------------------------------------------
/django_mongoengine/contrib/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/MongoEngine/django-mongoengine/298cdcf59b21fe590958f57f27bf28e7192fcc4e/django_mongoengine/contrib/__init__.py


--------------------------------------------------------------------------------
/django_mongoengine/contrib/drf_spectacular.py:
--------------------------------------------------------------------------------
 1 | from django.db import models
 2 | from drf_spectacular import openapi
 3 | from drf_spectacular.openapi import OpenApiTypes, build_basic_type
 4 | from mongoengine.fields import BaseField
 5 | from rest_framework import serializers
 6 | 
 7 | from django_mongoengine.forms.document_options import PkWrapper
 8 | 
 9 | SUPPORTED_FIELDS = (PkWrapper, BaseField)
10 | 
11 | 
12 | class AutoSchema(openapi.AutoSchema):
13 |     """
14 |     Schema supporting basic MongoEngine integration,
15 |     while falling back to default for not django-mongoengine fields.
16 |     """
17 | 
18 |     def _map_model_field(self, model_field, direction):
19 |         if isinstance(model_field, SUPPORTED_FIELDS):
20 |             if hasattr(model_field, "get_internal_type"):
21 |                 internal_type = getattr(models, model_field.get_internal_type())
22 |                 field_cls = serializers.ModelSerializer.serializer_field_mapping.get(internal_type)
23 |                 if field_cls:
24 |                     return self._map_serializer_field(field_cls(), direction)
25 |             return build_basic_type(OpenApiTypes.STR)
26 |         return super()._map_model_field(model_field, direction)
27 | 


--------------------------------------------------------------------------------
/django_mongoengine/document.py:
--------------------------------------------------------------------------------
  1 | # ruff: noqa: F811
  2 | from __future__ import annotations
  3 | 
  4 | from functools import partial
  5 | from typing import TYPE_CHECKING, Any
  6 | 
  7 | from bson.objectid import ObjectId
  8 | from django.db.models import Model
  9 | from django.db.models.base import ModelState
 10 | from mongoengine import DoesNotExist
 11 | from mongoengine import document as me
 12 | from mongoengine.base import metaclasses as mtc
 13 | from mongoengine.errors import FieldDoesNotExist
 14 | 
 15 | from .fields import ObjectIdField
 16 | from .forms.document_options import DocumentMetaWrapper
 17 | from .queryset import QuerySetManager
 18 | 
 19 | if TYPE_CHECKING:
 20 |     from mongoengine.fields import StringField
 21 |     from typing_extensions import Self
 22 | 
 23 | # TopLevelDocumentMetaclass is using ObjectIdField to create default pk field,
 24 | # if one's not set explicitly.
 25 | # We need to know it's not editable and auto_created.
 26 | mtc.ObjectIdField = partial(ObjectIdField, editable=False, auto_created=True)
 27 | 
 28 | 
 29 | def django_meta(meta, *top_bases):
 30 |     class metaclass(meta):
 31 |         def __new__(cls, name, bases, attrs):
 32 |             change_bases = len(bases) == 1 and (bases[0].__name__ == "temporary_meta")
 33 |             if change_bases:
 34 |                 new_bases = top_bases
 35 |             else:
 36 |                 new_bases = ()
 37 |                 for b in bases:
 38 |                     if getattr(b, "swap_base", False):
 39 |                         new_bases += top_bases
 40 |                     else:
 41 |                         new_bases += (b,)
 42 |             new_cls = meta.__new__(cls, name, new_bases, attrs)
 43 |             new_cls._meta = DocumentMetaWrapper(new_cls)
 44 |             return new_cls
 45 | 
 46 |     return type.__new__(metaclass, "temporary_meta", (), {})
 47 | 
 48 | 
 49 | class DjangoFlavor:
 50 |     id: StringField
 51 |     objects = QuerySetManager["Self"]()
 52 |     _default_manager = QuerySetManager["Self"]()
 53 |     _get_pk_val = Model.__dict__["_get_pk_val"]
 54 |     _meta: DocumentMetaWrapper | dict[str, Any]
 55 |     DoesNotExist: type[DoesNotExist]
 56 | 
 57 |     def __init__(self, *args, **kwargs):
 58 |         self._state = ModelState()
 59 |         self._state.db = self._meta.get("db_alias", me.DEFAULT_CONNECTION_NAME)
 60 |         super().__init__(*args, **kwargs)
 61 | 
 62 |     def _get_unique_checks(self, exclude=None):
 63 |         # XXX: source: django/db/models/base.py
 64 |         # used in modelform validation
 65 |         unique_checks, date_checks = [], []
 66 |         return unique_checks, date_checks
 67 | 
 68 |     def serializable_value(self, field_name):
 69 |         """
 70 |         Returns the value of the field name for this instance. If the field is
 71 |         a foreign key, returns the id value, instead of the object. If there's
 72 |         no Field object with this name on the model, the model attribute's
 73 |         value is returned directly.
 74 | 
 75 |         Used to serialize a field's value (in the serializer, or form output,
 76 |         for example). Normally, you would just access the attribute directly
 77 |         and not use this method.
 78 |         """
 79 |         try:
 80 |             field = self._meta.get_field(field_name)
 81 |         except FieldDoesNotExist:
 82 |             return getattr(self, field_name)
 83 |         value = field.to_mongo(getattr(self, field.name))
 84 |         if isinstance(value, ObjectId):
 85 |             return str(value)
 86 |         return value
 87 | 
 88 | 
 89 | class Document(
 90 |     django_meta(
 91 |         mtc.TopLevelDocumentMetaclass,
 92 |         DjangoFlavor,
 93 |         me.Document,
 94 |     )
 95 | ):
 96 |     swap_base = True
 97 | 
 98 | 
 99 | class DynamicDocument(django_meta(mtc.TopLevelDocumentMetaclass, DjangoFlavor, me.DynamicDocument)):
100 |     swap_base = True
101 | 
102 | 
103 | class EmbeddedDocument(django_meta(mtc.DocumentMetaclass, DjangoFlavor, me.EmbeddedDocument)):
104 |     swap_base = True
105 | 
106 | 
107 | class DynamicEmbeddedDocument(
108 |     django_meta(mtc.DocumentMetaclass, DjangoFlavor, me.DynamicEmbeddedDocument)
109 | ):
110 |     swap_base = True
111 | 
112 | 
113 | if TYPE_CHECKING:
114 | 
115 |     class Document(DjangoFlavor, me.Document): ...
116 | 
117 |     class DynamicDocument(DjangoFlavor, me.DynamicDocument): ...
118 | 
119 |     class EmbeddedDocument(DjangoFlavor, me.EmbeddedDocument):
120 |         _instance: Document
121 | 
122 |     class DynamicEmbeddedDocument(DjangoFlavor, me.DynamicEmbeddedDocument): ...
123 | 


--------------------------------------------------------------------------------
/django_mongoengine/fields/__init__.py:
--------------------------------------------------------------------------------
  1 | from mongoengine import fields as _fields
  2 | from . import djangoflavor as _mixins
  3 | from django_mongoengine.utils.monkey import patch_mongoengine_field
  4 | 
  5 | for f in ["StringField", "ObjectIdField"]:
  6 |     patch_mongoengine_field(f)
  7 | 
  8 | 
  9 | class StringField(_mixins.StringField, _fields.StringField):
 10 |     pass
 11 | 
 12 | 
 13 | class URLField(_mixins.URLField, _fields.URLField):
 14 |     pass
 15 | 
 16 | 
 17 | class EmailField(_mixins.EmailField, _fields.EmailField):
 18 |     pass
 19 | 
 20 | 
 21 | class IntField(_mixins.IntField, _fields.IntField):
 22 |     pass
 23 | 
 24 | 
 25 | class LongField(_mixins.DjangoField, _fields.LongField):
 26 |     pass
 27 | 
 28 | 
 29 | class FloatField(_mixins.FloatField, _fields.FloatField):
 30 |     pass
 31 | 
 32 | 
 33 | class DecimalField(_mixins.DecimalField, _fields.DecimalField):
 34 |     pass
 35 | 
 36 | 
 37 | class BooleanField(_mixins.BooleanField, _fields.BooleanField):
 38 |     pass
 39 | 
 40 | 
 41 | class DateTimeField(_mixins.DateTimeField, _fields.DateTimeField):
 42 |     pass
 43 | 
 44 | 
 45 | class DateField(_mixins.DjangoField, _fields.DateField):
 46 |     pass
 47 | 
 48 | 
 49 | class ComplexDateTimeField(_mixins.DjangoField, _fields.ComplexDateTimeField):
 50 |     pass
 51 | 
 52 | 
 53 | class EmbeddedDocumentField(_mixins.EmbeddedDocumentField, _fields.EmbeddedDocumentField):
 54 |     pass
 55 | 
 56 | 
 57 | class ObjectIdField(_mixins.DjangoField, _fields.ObjectIdField):
 58 |     pass
 59 | 
 60 | 
 61 | class GenericEmbeddedDocumentField(_mixins.DjangoField, _fields.GenericEmbeddedDocumentField):
 62 |     pass
 63 | 
 64 | 
 65 | class DynamicField(_mixins.DjangoField, _fields.DynamicField):
 66 |     pass
 67 | 
 68 | 
 69 | class ListField(_mixins.ListField, _fields.ListField):
 70 |     pass
 71 | 
 72 | 
 73 | class SortedListField(_mixins.DjangoField, _fields.SortedListField):
 74 |     pass
 75 | 
 76 | 
 77 | class EmbeddedDocumentListField(_mixins.DjangoField, _fields.EmbeddedDocumentListField):
 78 |     pass
 79 | 
 80 | 
 81 | class DictField(_mixins.DictField, _fields.DictField):
 82 |     pass
 83 | 
 84 | 
 85 | class MapField(_mixins.DjangoField, _fields.MapField):
 86 |     pass
 87 | 
 88 | 
 89 | class ReferenceField(_mixins.ReferenceField, _fields.ReferenceField):
 90 |     pass
 91 | 
 92 | 
 93 | class CachedReferenceField(_mixins.DjangoField, _fields.CachedReferenceField):
 94 |     pass
 95 | 
 96 | 
 97 | class LazyReferenceField(_mixins.DjangoField, _fields.LazyReferenceField):
 98 |     pass
 99 | 
100 | 
101 | class GenericLazyReferenceField(_mixins.DjangoField, _fields.GenericLazyReferenceField):
102 |     pass
103 | 
104 | 
105 | class GenericReferenceField(_mixins.DjangoField, _fields.GenericReferenceField):
106 |     pass
107 | 
108 | 
109 | class BinaryField(_mixins.DjangoField, _fields.BinaryField):
110 |     pass
111 | 
112 | 
113 | class GridFSError(_mixins.DjangoField, _fields.GridFSError):
114 |     pass
115 | 
116 | 
117 | class GridFSProxy(_mixins.DjangoField, _fields.GridFSProxy):
118 |     pass
119 | 
120 | 
121 | class FileField(_mixins.FileField, _fields.FileField):
122 |     pass
123 | 
124 | 
125 | class ImageGridFsProxy(_mixins.DjangoField, _fields.ImageGridFsProxy):
126 |     pass
127 | 
128 | 
129 | class ImproperlyConfigured(_mixins.ImproperlyConfigured, _fields.ImproperlyConfigured):
130 |     pass
131 | 
132 | 
133 | class ImageField(_mixins.ImageField, _fields.ImageField):
134 |     pass
135 | 
136 | 
137 | class GeoPointField(_mixins.DjangoField, _fields.GeoPointField):
138 |     pass
139 | 
140 | 
141 | class PointField(_mixins.DjangoField, _fields.PointField):
142 |     pass
143 | 
144 | 
145 | class LineStringField(_mixins.DjangoField, _fields.LineStringField):
146 |     pass
147 | 
148 | 
149 | class PolygonField(_mixins.DjangoField, _fields.PolygonField):
150 |     pass
151 | 
152 | 
153 | class SequenceField(_mixins.DjangoField, _fields.SequenceField):
154 |     pass
155 | 
156 | 
157 | class UUIDField(_mixins.DjangoField, _fields.UUIDField):
158 |     pass
159 | 
160 | 
161 | class EnumField(_mixins.DjangoField, _fields.EnumField):
162 |     pass
163 | 
164 | 
165 | class MultiPointField(_mixins.DjangoField, _fields.MultiPointField):
166 |     pass
167 | 
168 | 
169 | class MultiLineStringField(_mixins.DjangoField, _fields.MultiLineStringField):
170 |     pass
171 | 
172 | 
173 | class MultiPolygonField(_mixins.DjangoField, _fields.MultiPolygonField):
174 |     pass
175 | 
176 | 
177 | class GeoJsonBaseField(_mixins.DjangoField, _fields.GeoJsonBaseField):
178 |     pass
179 | 
180 | 
181 | class Decimal128Field(_mixins.DjangoField, _fields.Decimal128Field):
182 |     pass
183 | 


--------------------------------------------------------------------------------
/django_mongoengine/fields/internal.py:
--------------------------------------------------------------------------------
1 | INTERNAL_DJANGO_FIELDS_MAP = {
2 |     "StringField": "CharField",
3 | }
4 | 


--------------------------------------------------------------------------------
/django_mongoengine/forms/__init__.py:
--------------------------------------------------------------------------------
1 | from .documents import *  # noqa: F403
2 | from .utils import *  # noqa: F403
3 | 


--------------------------------------------------------------------------------
/django_mongoengine/forms/document_options.py:
--------------------------------------------------------------------------------
  1 | import sys
  2 | 
  3 | from django.core.exceptions import FieldDoesNotExist
  4 | from django.db.models.options import Options
  5 | from django.utils.encoding import smart_str
  6 | from django.utils.text import capfirst
  7 | 
  8 | try:
  9 |     from django.db.models.options import get_verbose_name as camel_case_to_spaces
 10 | except ImportError:
 11 |     from django.utils.text import camel_case_to_spaces, format_lazy
 12 | 
 13 | from mongoengine.fields import ReferenceField
 14 | 
 15 | 
 16 | class PkWrapper:
 17 |     """Used to wrap the Primary Key so it can mimic Django's expectations"""
 18 | 
 19 |     editable = False
 20 |     remote_field = None
 21 | 
 22 |     def __init__(self, wrapped):
 23 |         self.obj = wrapped
 24 | 
 25 |     def __getattr__(self, attr):
 26 |         if attr in dir(self.obj):
 27 |             return getattr(self.obj, attr)
 28 |         raise AttributeError(f"{self} has no {attr}")
 29 | 
 30 |     def __setattr__(self, attr, value):
 31 |         if attr != "obj" and hasattr(self.obj, attr):
 32 |             setattr(self.obj, attr, value)
 33 |         super().__setattr__(attr, value)
 34 | 
 35 |     def value_to_string(self, obj):
 36 |         """
 37 |         Returns a string value of this field from the passed obj.
 38 |         This is used by the serialization framework.
 39 |         """
 40 |         return smart_str(obj.pk)
 41 | 
 42 |     def get_internal_type(self):
 43 |         return "CharField"
 44 | 
 45 | 
 46 | class DocumentMetaWrapper:
 47 |     """
 48 |     Used to store mongoengine's _meta dict to make the document admin
 49 |     as compatible as possible to django's meta class on models.
 50 |     """
 51 | 
 52 |     _pk = None
 53 |     pk_name = None
 54 |     object_name = None
 55 |     model_name = None
 56 |     verbose_name = None
 57 |     has_auto_field = False
 58 |     abstract = False
 59 |     object_name = None
 60 |     proxy = []
 61 |     virtual_fields = []
 62 |     concrete_fields = []
 63 |     proxied_children = []
 64 |     parents = {}
 65 |     private_fields = []
 66 |     many_to_many = []
 67 |     related_fkey_lookups = []
 68 |     swapped = False
 69 |     _field_cache = None
 70 |     document = None
 71 |     _meta = None
 72 |     try:
 73 |         default_apps = Options.default_apps
 74 |     except AttributeError:
 75 |         pass
 76 |     app_config = Options.__dict__["app_config"]
 77 |     try:
 78 |         _property_names = Options.__dict__["_property_names"]
 79 |     except KeyError:
 80 |         pass
 81 | 
 82 |     def __init__(self, document):
 83 |         if isinstance(document._meta, DocumentMetaWrapper):
 84 |             meta = document._meta._meta
 85 |         else:
 86 |             meta = document._meta
 87 |         self.document = document
 88 |         self._meta = meta or {}
 89 |         self.model = document
 90 |         self.concrete_model = document
 91 |         self.concrete_fields = document._fields.values()
 92 |         self.object_name = document.__name__
 93 |         self.model_name = self.object_name.lower()
 94 |         self.fields = self.concrete_fields
 95 |         try:
 96 |             self.apps = self.default_apps
 97 |         except AttributeError:
 98 |             pass
 99 |         try:
100 |             self.object_name = self.document.__name__
101 |         except AttributeError:
102 |             self.object_name = self.document.__class__.__name__
103 | 
104 |         self.verbose_name = self.get_verbose_name()
105 | 
106 |         # EmbeddedDocuments don't have an id field.
107 |         try:
108 |             self.pk_name = self._meta["id_field"]
109 |             self._init_pk()
110 |         except KeyError:
111 |             pass
112 | 
113 |     @property
114 |     def label(self):
115 |         return "%s.%s" % (self.app_label, self.model_name)
116 | 
117 |     @property
118 |     def label_lower(self):
119 |         return "%s.%s" % (self.app_label, self.model_name)
120 | 
121 |     @property
122 |     def app_label(self) -> str:
123 |         if "app_label" in self._meta:
124 |             return self._meta["app_label"]
125 |         else:
126 |             model_module = sys.modules[self.document.__module__]
127 |             return model_module.__name__.split(".")[-2]
128 | 
129 |     def get_path_to_parent(self, parent):
130 |         # This is just placeholders.
131 |         # If you depend on this, port it from django.
132 |         return []
133 | 
134 |     def get_path_from_parent(self, parent):
135 |         return []
136 | 
137 |     def get_verbose_name(self):
138 |         """
139 |         Returns the verbose name of the document.
140 | 
141 |         Checks the original meta dict first. If it is not found
142 |         then generates a verbose name from from the object name.
143 |         """
144 |         if "verbose_name" in self._meta:
145 |             return self._meta["verbose_name"]
146 |         else:
147 |             return capfirst(camel_case_to_spaces(self.object_name))
148 | 
149 |     @property
150 |     def verbose_name_raw(self):
151 |         return str(self.verbose_name)
152 | 
153 |     @property
154 |     def verbose_name_plural(self):
155 |         if "verbose_name_plural" in self._meta:
156 |             return self.meta["verbose_name_plural"]
157 |         else:
158 |             return format_lazy("{}s", self.verbose_name)
159 | 
160 |     @property
161 |     def pk(self):
162 |         if not hasattr(self._pk, "attname"):
163 |             self._init_pk()
164 |         return self._pk
165 | 
166 |     def get_fields(self, include_parents=True, include_hidden=False):
167 |         # XXX: simple placeholder; TODO: handle options;
168 |         return self.concrete_fields
169 | 
170 |     def _init_pk(self):
171 |         """
172 |         Adds a wrapper around the documents pk field. The wrapper object gets the attributes
173 |         django expects on the pk field, like name and attname.
174 | 
175 |         The function also adds a _get_pk_val method to the document.
176 |         """
177 |         if self.id_field is None:
178 |             return
179 | 
180 |         try:
181 |             pk_field = getattr(self.document, self.id_field)
182 |             self._pk = PkWrapper(pk_field)
183 |             self._pk.name = self.id_field
184 |             self._pk.attname = self.id_field
185 |         except AttributeError:
186 |             return
187 | 
188 |     def get_add_permission(self):
189 |         return "add_%s" % self.object_name.lower()
190 | 
191 |     def get_change_permission(self):
192 |         return "change_%s" % self.object_name.lower()
193 | 
194 |     def get_delete_permission(self):
195 |         return "delete_%s" % self.object_name.lower()
196 | 
197 |     def get_ordered_objects(self):
198 |         return []
199 | 
200 |     def get_field_by_name(self, name):
201 |         """
202 |         Returns the (field_object, model, direct, m2m), where field_object is
203 |         the Field instance for the given name, model is the model containing
204 |         this field (None for local fields), direct is True if the field exists
205 |         on this model, and m2m is True for many-to-many relations. When
206 |         'direct' is False, 'field_object' is the corresponding RelatedObject
207 |         for this field (since the field doesn't have an instance associated
208 |         with it).
209 | 
210 |         Uses a cache internally, so after the first access, this is very fast.
211 |         """
212 |         try:
213 |             try:
214 |                 return self._field_cache[name]
215 |             except TypeError:
216 |                 self._init_field_cache()
217 |                 return self._field_cache[name]
218 |         except KeyError:
219 |             raise FieldDoesNotExist("%s has no field named %r" % (self.object_name, name))
220 | 
221 |     def _init_field_cache(self):
222 |         if self._field_cache is None:
223 |             self._field_cache = {}
224 | 
225 |         for f in self.document._fields.values():
226 |             if isinstance(f, ReferenceField):
227 |                 document = f.document_type
228 |                 self._field_cache[document._meta.model_name] = (f, document, False, False)
229 |             else:
230 |                 self._field_cache[f.name] = (f, None, True, False)
231 | 
232 |         return self._field_cache
233 | 
234 |     def get_field(self, name, many_to_many=True):
235 |         """
236 |         Returns the requested field by name. Raises FieldDoesNotExist on error.
237 |         """
238 |         return self.get_field_by_name(name)[0]
239 | 
240 |     def __getattr__(self, name):
241 |         try:
242 |             return self._meta[name]
243 |         except KeyError as e:
244 |             raise AttributeError(*e.args)
245 | 
246 |     def __setattr__(self, name, value):
247 |         if not hasattr(self, name):
248 |             self._meta[name] = value
249 |         else:
250 |             super().__setattr__(name, value)
251 | 
252 |     def __getitem__(self, key):
253 |         return self._meta[key]
254 | 
255 |     def __setitem__(self, key, value):
256 |         self._meta[key] = value
257 | 
258 |     def __contains__(self, key):
259 |         return key in self._meta
260 | 
261 |     def get(self, key, default=None):
262 |         try:
263 |             return self.__getitem__(key)
264 |         except KeyError:
265 |             return default
266 | 
267 |     def get_parent_list(self):
268 |         return []
269 | 
270 |     def get_all_related_objects(self, *args, **kwargs):
271 |         return []
272 | 
273 |     def iteritems(self):
274 |         return self._meta.iteritems()
275 | 
276 |     def items(self):
277 |         return self._meta.items()
278 | 


--------------------------------------------------------------------------------
/django_mongoengine/forms/fields.py:
--------------------------------------------------------------------------------
  1 | from django import forms
  2 | from django.core.exceptions import ValidationError
  3 | from django.utils.translation import gettext_lazy as _
  4 | 
  5 | from django_mongoengine.forms.widgets import Dictionary, EmbeddedFieldWidget
  6 | 
  7 | 
  8 | class ReferenceField(forms.ModelChoiceField):
  9 |     pass
 10 | 
 11 | 
 12 | class DocumentMultipleChoiceField(forms.ModelMultipleChoiceField):
 13 |     pass
 14 | 
 15 | 
 16 | class DictField(forms.Field):
 17 |     """
 18 |     DictField for mongo forms
 19 |     """
 20 | 
 21 |     error_messages = {
 22 |         "length": _("Ensure the keys length is less than or equal to %s."),
 23 |         "invalid_key": _("Ensure the keys are not : %s."),
 24 |         "illegal": _("Ensure the keys does not contain any illegal character : %s."),
 25 |         "depth": _("Ensure the dictionary depth is less than or equal to %s."),
 26 |     }
 27 | 
 28 |     # Mongo reserved keywords
 29 |     invalid_keys = ["err", "errmsg"]
 30 |     # Mongo prohibit . in keys
 31 |     illegal_characters = ["."]
 32 |     # limit key length for efficiency
 33 |     key_limit = 200
 34 |     # limit depth for dictionaries
 35 |     max_depth = None
 36 | 
 37 |     def __init__(self, max_depth=None, flags=None, sub_attrs=None, attrs=None, *args, **kwargs):
 38 |         if "error_messages" in kwargs.keys():
 39 |             kwargs["error_messages"].update(self.error_messages)
 40 |         else:
 41 |             kwargs["error_messages"] = self.error_messages
 42 | 
 43 |         self.max_depth = max_depth if max_depth and max_depth >= 0 else None
 44 | 
 45 |         if "widget" not in kwargs.keys():
 46 |             schema = None
 47 |             # Here it needs to be clearer, because this is only useful when creating an object,
 48 |             # if no default value is provided, default is callable
 49 |             if "initial" in kwargs and not callable(kwargs["initial"]):
 50 |                 if isinstance(kwargs["initial"], dict):
 51 |                     schema = kwargs["initial"]
 52 | 
 53 |             # here if other parameters are passed, like max_depth and flags, then we hand them to the dict
 54 |             kwargs["widget"] = Dictionary(
 55 |                 max_depth=max_depth, flags=flags, schema=schema, sub_attrs=sub_attrs
 56 |             )
 57 | 
 58 |         super().__init__(*args, **kwargs)
 59 | 
 60 |     def prepare_value(self, value):
 61 |         return value
 62 | 
 63 |     def to_python(self, value):
 64 |         value = self.get_dict(value)
 65 |         return value
 66 | 
 67 |     def clean(self, value):
 68 |         self.max_depth = self.widget.max_depth
 69 |         value = self.to_python(value)
 70 |         self.validate(value)
 71 |         return value
 72 | 
 73 |     def get_dict(self, a_list):
 74 |         """
 75 |         A function that return a dictionary from a list of lists, with any depth
 76 |         """
 77 |         d = {}
 78 |         for k in a_list:
 79 |             if isinstance(k, list):
 80 |                 if isinstance(k[1], list) and k[0]:
 81 |                     d.update({k[0]: self.get_dict(k[1])})
 82 |                 elif k[0]:
 83 |                     d.update({k[0]: k[1]})
 84 |         return d
 85 | 
 86 |     def validate(self, value, depth=0):
 87 |         # we should not use the super.validate method
 88 |         if self.max_depth is not None and depth > self.max_depth:
 89 |             raise ValidationError(self.error_messages["depth"] % self.max_depth)
 90 |         for k, v in value.items():
 91 |             self.run_validators(k)
 92 |             if k in self.invalid_keys:
 93 |                 raise ValidationError(self.error_messages["invalid_key"] % self.invalid_keys)
 94 |             if len(k) > self.key_limit:
 95 |                 raise ValidationError(self.error_messages["length"] % self.key_limit)
 96 |             for u in self.illegal_characters:
 97 |                 if u in k:
 98 |                     raise ValidationError(self.error_messages["illegal"] % self.illegal_characters)
 99 |             if isinstance(v, dict):
100 |                 self.validate(v, depth + 1)
101 | 
102 | 
103 | class EmbeddedDocumentField(forms.MultiValueField):
104 |     def __init__(self, form, *args, **kwargs):
105 |         self.form = form()
106 |         # Set the widget and initial data
107 |         kwargs["widget"] = EmbeddedFieldWidget(self.form.fields)
108 |         kwargs["initial"] = [f.initial for f in self.form.fields.values()]
109 |         kwargs["require_all_fields"] = False
110 |         super().__init__(fields=tuple(self.form.fields.values()), *args, **kwargs)
111 | 
112 |     def bound_data(self, data, initial):
113 |         return data
114 | 
115 |     def prepare_value(self, value):
116 |         return value
117 | 
118 |     def compress(self, data_list):
119 |         data = {}
120 |         if data_list:
121 |             data = {f.name: data_list[i] for i, f in enumerate(self.form)}
122 |             f = self.form.__class__(data)
123 |             f.is_valid()
124 |             return f.cleaned_data
125 |         return data
126 | 
127 |     def clean(self, value):
128 |         return self.to_python(super().clean(value))
129 | 
130 |     def to_python(self, value):
131 |         obj = self.form._meta.model()
132 |         [obj.__setattr__(k, value[k]) for k in value.keys()]
133 |         return obj
134 | 


--------------------------------------------------------------------------------
/django_mongoengine/forms/utils.py:
--------------------------------------------------------------------------------
 1 | from collections import OrderedDict
 2 | from functools import partial
 3 | 
 4 | from django.forms.fields import Field
 5 | 
 6 | 
 7 | def patch_document(function, instance):
 8 |     setattr(instance, function.__name__, partial(function, instance))
 9 | 
10 | 
11 | def get_declared_fields(bases, attrs, with_base_fields=True):
12 |     """
13 |     Create a list of form field instances from the passed in 'attrs', plus any
14 |     similar fields on the base classes (in 'bases'). This is used by both the
15 |     Form and ModelForm metaclasses.
16 | 
17 |     If 'with_base_fields' is True, all fields from the bases are used.
18 |     Otherwise, only fields in the 'declared_fields' attribute on the bases are
19 |     used. The distinction is useful in ModelForm subclassing.
20 |     Also integrates any additional media definitions.
21 |     """
22 | 
23 |     fields = [
24 |         (field_name, attrs.pop(field_name))
25 |         for field_name, obj in attrs.items()
26 |         if isinstance(obj, Field)
27 |     ]
28 |     fields.sort(key=lambda x: x[1].creation_counter)
29 | 
30 |     # If this class is subclassing another Form, add that Form's fields.
31 |     # Note that we loop over the bases in *reverse*. This is necessary in
32 |     # order to preserve the correct order of fields.
33 |     if with_base_fields:
34 |         for base in bases[::-1]:
35 |             if hasattr(base, "base_fields"):
36 |                 fields = list(base.base_fields.items()) + fields
37 |     else:
38 |         for base in bases[::-1]:
39 |             if hasattr(base, "declared_fields"):
40 |                 fields = list(base.declared_fields.items()) + fields
41 | 
42 |     return OrderedDict(fields)
43 | 


--------------------------------------------------------------------------------
/django_mongoengine/mongo_admin/__init__.py:
--------------------------------------------------------------------------------
 1 | from django.utils.module_loading import autodiscover_modules
 2 | 
 3 | from .decorators import register
 4 | from .options import DocumentAdmin
 5 | from .sites import site
 6 | 
 7 | __all__ = ["DocumentAdmin", "site", "register"]
 8 | 
 9 | 
10 | def autodiscover():
11 |     autodiscover_modules("admin", register_to=site)
12 | 
13 | 
14 | default_app_config = "django_mongoengine.mongo_admin.apps.MongoAdminConfig"
15 | 


--------------------------------------------------------------------------------
/django_mongoengine/mongo_admin/actions.py:
--------------------------------------------------------------------------------
  1 | """
  2 | Built-in, globally-available admin actions.
  3 | """
  4 | 
  5 | from django import template
  6 | from django.contrib.admin import helpers
  7 | from django.contrib.admin.actions import delete_selected as django_delete_selected
  8 | from django.contrib.admin.utils import get_deleted_objects, model_ngettext
  9 | from django.core.exceptions import PermissionDenied
 10 | from django.db import models
 11 | from django.shortcuts import render_to_response
 12 | from django.utils.translation import gettext_lazy as _
 13 | 
 14 | from django_mongoengine.utils import force_str
 15 | 
 16 | 
 17 | def delete_selected(modeladmin, request, queryset):
 18 |     if issubclass(modeladmin.model, models.Model):
 19 |         return django_delete_selected(modeladmin, request, queryset)
 20 |     else:
 21 |         return _delete_selected(modeladmin, request, queryset)
 22 | 
 23 | 
 24 | def _delete_selected(modeladmin, request, queryset):
 25 |     """
 26 |     Default action which deletes the selected objects.
 27 | 
 28 |     This action first displays a confirmation page whichs shows all the
 29 |     deleteable objects, or, if the user has no permission one of the related
 30 |     childs (foreignkeys), a "permission denied" message.
 31 | 
 32 |     Next, it delets all selected objects and redirects back to the change list.
 33 |     """
 34 |     opts = modeladmin.model._meta
 35 |     app_label = opts.app_label
 36 | 
 37 |     # Check that the user has delete permission for the actual model
 38 |     if not modeladmin.has_delete_permission(request):
 39 |         raise PermissionDenied
 40 | 
 41 |     # Populate deletable_objects, a data structure of all related objects that
 42 |     # will also be deleted.
 43 |     # TODO: Permissions would be so cool...
 44 |     deletable_objects, perms_needed, protected = get_deleted_objects(
 45 |         queryset, request, modeladmin.admin_site
 46 |     )
 47 | 
 48 |     # The user has already confirmed the deletion.
 49 |     # Do the deletion and return a None to display the change list view again.
 50 |     if request.POST.get("post"):
 51 |         if perms_needed:
 52 |             raise PermissionDenied
 53 |         n = len(queryset)
 54 |         if n:
 55 |             for obj in queryset:
 56 |                 obj_display = force_str(obj)
 57 |                 modeladmin.log_deletion(request, obj, obj_display)
 58 |                 # call the objects delete method to ensure signals are
 59 |                 # processed.
 60 |                 obj.delete()
 61 |             # This is what you get if you have to monkey patch every object in a changelist
 62 |             # No queryset object, I can tell ya. So we get a new one and delete that.
 63 |             # pk_list = [o.pk for o in queryset]
 64 |             # klass = queryset[0].__class__
 65 |             # qs = klass.objects.filter(pk__in=pk_list)
 66 |             # qs.delete()
 67 |             modeladmin.message_user(
 68 |                 request,
 69 |                 _("Successfully deleted %(count)d %(items)s.")
 70 |                 % {"count": n, "items": model_ngettext(modeladmin.opts, n)},
 71 |             )
 72 |         # Return None to display the change list page again.
 73 |         return None
 74 | 
 75 |     if len(queryset) == 1:
 76 |         objects_name = force_str(opts.verbose_name)
 77 |     else:
 78 |         objects_name = force_str(opts.verbose_name_plural)
 79 | 
 80 |     if perms_needed or protected:
 81 |         title = _("Cannot delete %(name)s") % {"name": objects_name}
 82 |     else:
 83 |         title = _("Are you sure?")
 84 | 
 85 |     context = {
 86 |         "title": title,
 87 |         "objects_name": objects_name,
 88 |         "deletable_objects": [deletable_objects],
 89 |         "queryset": queryset,
 90 |         "perms_lacking": perms_needed,
 91 |         "protected": protected,
 92 |         "opts": opts,
 93 |         "root_path": modeladmin.admin_site.root_path,
 94 |         "app_label": app_label,
 95 |         "action_checkbox_name": helpers.ACTION_CHECKBOX_NAME,
 96 |     }
 97 | 
 98 |     # Display the confirmation page
 99 |     return render_to_response(
100 |         modeladmin.delete_selected_confirmation_template
101 |         or [
102 |             "admin/%s/%s/delete_selected_confirmation.html" % (app_label, opts.object_name.lower()),
103 |             "admin/%s/delete_selected_confirmation.html" % app_label,
104 |             "admin/delete_selected_confirmation.html",
105 |         ],
106 |         context,
107 |         context_instance=template.RequestContext(request),
108 |     )
109 | 
110 | 
111 | delete_selected.short_description = _("Delete selected %(verbose_name_plural)s")
112 | 


--------------------------------------------------------------------------------
/django_mongoengine/mongo_admin/apps.py:
--------------------------------------------------------------------------------
 1 | from django.apps import AppConfig
 2 | from django.core import checks
 3 | from django.utils.translation import gettext_lazy as _
 4 | 
 5 | 
 6 | def check_admin_app(**kwargs):
 7 |     from .sites import system_check_errors
 8 | 
 9 |     return system_check_errors
10 | 
11 | 
12 | class SimpleMongoAdminConfig(AppConfig):
13 |     """Simple AppConfig which does not do automatic discovery."""
14 | 
15 |     name = "django_mongoengine.mongo_admin"
16 |     verbose_name = _("Administration")
17 | 
18 |     def ready(self):
19 |         checks.register(check_admin_app, checks.Tags.admin)
20 | 
21 | 
22 | class MongoAdminConfig(SimpleMongoAdminConfig):
23 |     def ready(self):
24 |         super().ready()
25 |         self.module.autodiscover()
26 | 


--------------------------------------------------------------------------------
/django_mongoengine/mongo_admin/decorators.py:
--------------------------------------------------------------------------------
 1 | def register(*models, **kwargs):
 2 |     """
 3 |     Registers the given model(s) classes and wrapped ModelAdmin class with
 4 |     admin site:
 5 | 
 6 |     @register(Author)
 7 |     class AuthorAdmin(admin.ModelAdmin):
 8 |         pass
 9 | 
10 |     A kwarg of `site` can be passed as the admin site, otherwise the default
11 |     admin site will be used.
12 |     """
13 |     from .options import DocumentAdmin
14 |     from .sites import AdminSite, site
15 | 
16 |     def _model_admin_wrapper(admin_class):
17 |         admin_site = kwargs.pop("site", site)
18 | 
19 |         if not isinstance(admin_site, AdminSite):
20 |             raise ValueError("site must subclass AdminSite")
21 | 
22 |         if not issubclass(admin_class, DocumentAdmin):
23 |             raise ValueError("Wrapped class must subclass ModelAdmin.")
24 | 
25 |         admin_site.register(models, admin_class=admin_class)
26 | 
27 |         return admin_class
28 | 
29 |     return _model_admin_wrapper
30 | 


--------------------------------------------------------------------------------
/django_mongoengine/mongo_admin/helpers.py:
--------------------------------------------------------------------------------
  1 | from django.contrib.admin.helpers import AdminField
  2 | from django.contrib.admin.helpers import AdminForm as DjangoAdminForm
  3 | from django.contrib.admin.helpers import AdminReadonlyField as DjangoAdminReadonlyField
  4 | from django.contrib.admin.helpers import Fieldline as DjangoFieldLine
  5 | from django.contrib.admin.helpers import Fieldset as DjangoFieldSet
  6 | from django.contrib.admin.helpers import InlineAdminForm as DjangoInlineAdminForm
  7 | from django.contrib.admin.helpers import InlineAdminFormSet as DjangoInlineAdminFormSet
  8 | from django.contrib.admin.helpers import InlineFieldset as DjangoInlineFieldset
  9 | from django.contrib.admin.utils import lookup_field
 10 | from django.core.exceptions import ObjectDoesNotExist
 11 | from django.utils.encoding import smart_str
 12 | from django.utils.html import conditional_escape
 13 | from django.utils.safestring import mark_safe
 14 | 
 15 | from django_mongoengine.mongo_admin.util import (
 16 |     display_for_field,
 17 |     help_text_for_field,
 18 |     label_for_field,
 19 | )
 20 | 
 21 | 
 22 | class AdminForm(DjangoAdminForm):
 23 |     def __iter__(self):
 24 |         for name, options in self.fieldsets:
 25 |             yield Fieldset(
 26 |                 self.form,
 27 |                 name,
 28 |                 readonly_fields=self.readonly_fields,
 29 |                 model_admin=self.model_admin,
 30 |                 **options,
 31 |             )
 32 | 
 33 | 
 34 | class Fieldset(DjangoFieldSet):
 35 |     def __iter__(self):
 36 |         for field in self.fields:
 37 |             yield Fieldline(self.form, field, self.readonly_fields, model_admin=self.model_admin)
 38 | 
 39 | 
 40 | class Fieldline(DjangoFieldLine):
 41 |     def __iter__(self):
 42 |         for i, field in enumerate(self.fields):
 43 |             if field in self.readonly_fields:
 44 |                 yield AdminReadonlyField(
 45 |                     self.form, field, is_first=(i == 0), model_admin=self.model_admin
 46 |                 )
 47 |             else:
 48 |                 yield AdminField(self.form, field, is_first=(i == 0))
 49 | 
 50 | 
 51 | class AdminReadonlyField(DjangoAdminReadonlyField):
 52 |     def __init__(self, form, field, is_first, model_admin=None):
 53 |         label = label_for_field(field, form._meta.model, model_admin)
 54 |         # Make self.field look a little bit like a field. This means that
 55 |         # {{ field.name }} must be a useful class name to identify the field.
 56 |         # For convenience, store other field-related data here too.
 57 |         if callable(field):
 58 |             class_name = field.__name__ != "<lambda>" and field.__name__ or ""
 59 |         else:
 60 |             class_name = field
 61 |         self.field = {
 62 |             "name": class_name,
 63 |             "label": label,
 64 |             "field": field,
 65 |             "help_text": help_text_for_field(class_name, form._meta.model),
 66 |         }
 67 |         self.form = form
 68 |         self.model_admin = model_admin
 69 |         self.is_first = is_first
 70 |         self.is_checkbox = False
 71 |         self.is_readonly = True
 72 | 
 73 |     def contents(self):
 74 |         from django.contrib.admin.templatetags.admin_list import _boolean_icon
 75 | 
 76 |         field, obj, model_admin = self.field["field"], self.form.instance, self.model_admin
 77 |         try:
 78 |             f, attr, value = lookup_field(field, obj, model_admin)
 79 |         except (AttributeError, ValueError, ObjectDoesNotExist):
 80 |             result_repr = self.model_admin.get_empty_value_diplay()
 81 |         else:
 82 |             if f is None:
 83 |                 boolean = getattr(attr, "boolean", False)
 84 |                 if boolean:
 85 |                     result_repr = _boolean_icon(value)
 86 |                 else:
 87 |                     result_repr = smart_str(value)
 88 |                     if getattr(attr, "allow_tags", False):
 89 |                         result_repr = mark_safe(result_repr)
 90 |             else:
 91 |                 if value is None:
 92 |                     result_repr = self.model_admin.get_empty_value_diplay()
 93 |                 # HERE WE NEED TO CHANGE THIS TEST
 94 |                 # elif isinstance(f.rel, ManyToManyRel):
 95 |                 #     result_repr = ", ".join(map(unicode, value.all()))
 96 |                 else:
 97 |                     result_repr = display_for_field(value, f)
 98 |         return conditional_escape(result_repr)
 99 | 
100 | 
101 | class InlineAdminFormSet(DjangoInlineAdminFormSet):
102 |     """
103 |     A wrapper around an inline formset for use in the admin system.
104 |     """
105 | 
106 |     def __iter__(self):
107 |         for form, original in zip(self.formset.initial_forms, self.formset.get_queryset()):
108 |             yield InlineAdminForm(
109 |                 self.formset,
110 |                 form,
111 |                 self.fieldsets,
112 |                 self.opts.prepopulated_fields,
113 |                 original,
114 |                 self.readonly_fields,
115 |                 model_admin=self.opts,
116 |             )
117 |         for form in self.formset.extra_forms:
118 |             yield InlineAdminForm(
119 |                 self.formset,
120 |                 form,
121 |                 self.fieldsets,
122 |                 self.opts.prepopulated_fields,
123 |                 None,
124 |                 self.readonly_fields,
125 |                 model_admin=self.opts,
126 |             )
127 |         yield InlineAdminForm(
128 |             self.formset,
129 |             self.formset.empty_form,
130 |             self.fieldsets,
131 |             self.opts.prepopulated_fields,
132 |             None,
133 |             self.readonly_fields,
134 |             model_admin=self.opts,
135 |         )
136 | 
137 | 
138 | class InlineAdminForm(DjangoInlineAdminForm, AdminForm):
139 |     """
140 |     A wrapper around an inline form for use in the admin system.
141 |     """
142 | 
143 |     def __init__(
144 |         self,
145 |         formset,
146 |         form,
147 |         fieldsets,
148 |         prepopulated_fields,
149 |         original,
150 |         readonly_fields=None,
151 |         model_admin=None,
152 |     ):
153 |         self.formset = formset
154 |         self.model_admin = model_admin
155 |         self.original = original
156 |         self.show_url = original and hasattr(original, "get_absolute_url")
157 |         AdminForm.__init__(self, form, fieldsets, prepopulated_fields, readonly_fields, model_admin)
158 | 
159 |     def pk_field(self):
160 |         # if there is no pk field then it's an embedded form so return none
161 |         if hasattr(self.formset, "_pk_field"):
162 |             return DjangoInlineAdminForm.pk_field(self)
163 |         else:
164 |             return None
165 | 
166 |     def __iter__(self):
167 |         for name, options in self.fieldsets:
168 |             yield InlineFieldset(
169 |                 self.formset,
170 |                 self.form,
171 |                 name,
172 |                 self.readonly_fields,
173 |                 model_admin=self.model_admin,
174 |                 **options,
175 |             )
176 | 
177 | 
178 | class InlineFieldset(DjangoInlineFieldset):
179 |     def __iter__(self):
180 |         fk = getattr(self.formset, "fk", None)
181 |         for field in self.fields:
182 |             if fk and fk.name == field:
183 |                 continue
184 |             yield Fieldline(self.form, field, self.readonly_fields, model_admin=self.model_admin)
185 | 


--------------------------------------------------------------------------------
/django_mongoengine/mongo_admin/management/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/MongoEngine/django-mongoengine/298cdcf59b21fe590958f57f27bf28e7192fcc4e/django_mongoengine/mongo_admin/management/__init__.py


--------------------------------------------------------------------------------
/django_mongoengine/mongo_admin/management/commands/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/MongoEngine/django-mongoengine/298cdcf59b21fe590958f57f27bf28e7192fcc4e/django_mongoengine/mongo_admin/management/commands/__init__.py


--------------------------------------------------------------------------------
/django_mongoengine/mongo_admin/management/commands/createmongodbsuperuser.py:
--------------------------------------------------------------------------------
  1 | """
  2 | Management utility to create superusers.
  3 | """
  4 | 
  5 | import getpass
  6 | import re
  7 | import sys
  8 | 
  9 | from django.core import exceptions
 10 | from django.core.management.base import BaseCommand, CommandError
 11 | from django.utils.translation import gettext as _
 12 | 
 13 | from django_mongoengine.mongo_auth.models import MongoUser
 14 | from django_mongoengine.sessions import DEFAULT_CONNECTION_NAME
 15 | 
 16 | 
 17 | def get_default_username():
 18 |     return "admin"
 19 | 
 20 | 
 21 | RE_VALID_USERNAME = re.compile(r"[\w.@+-]+$")
 22 | 
 23 | EMAIL_RE = re.compile(
 24 |     r"(^[-!#$%&'*+/=?^_`{}|~0-9A-Z]+(\.[-!#$%&'*+/=?^_`{}|~0-9A-Z]+)*"  # dot-atom
 25 |     r'|^"([\001-\010\013\014\016-\037!#-\[\]-\177]|\\[\001-\011\013\014\016-\177])*"'  # quoted-string
 26 |     r")@(?:[A-Z0-9-]+\.)+[A-Z]{2,6}$",
 27 |     re.IGNORECASE,
 28 | )  # domain
 29 | 
 30 | 
 31 | def is_valid_email(value):
 32 |     if not EMAIL_RE.search(value):
 33 |         raise exceptions.ValidationError(_("Enter a valid e-mail address."))
 34 | 
 35 | 
 36 | class Command(BaseCommand):
 37 |     help = "Used to create a superuser."
 38 | 
 39 |     def add_arguments(self, parser):
 40 |         parser.add_argument(
 41 |             "--username",
 42 |             dest="username",
 43 |             default=None,
 44 |             help="Specifies the username for the superuser.",
 45 |         )
 46 |         parser.add_argument(
 47 |             "--email",
 48 |             dest="email",
 49 |             default=None,
 50 |             help="Specifies the email address for the superuser.",
 51 |         )
 52 |         parser.add_argument(
 53 |             "--noinput",
 54 |             action="store_false",
 55 |             dest="interactive",
 56 |             default=True,
 57 |             help=(
 58 |                 "Tells Django to NOT prompt the user for input of any kind. "
 59 |                 "You must use --username and --email with --noinput, and "
 60 |                 "superusers created with --noinput will not be able to log "
 61 |                 "in until they're given a valid password."
 62 |             ),
 63 |         )
 64 |         parser.add_argument(
 65 |             "--database",
 66 |             action="store",
 67 |             dest="database",
 68 |             default=DEFAULT_CONNECTION_NAME,
 69 |             help='Specifies the database to use. Default is "default".',
 70 |         )
 71 | 
 72 |     def handle(self, *args, **options):
 73 |         username = options.get("username", None)
 74 |         email = options.get("email", None)
 75 |         interactive = options.get("interactive")
 76 |         verbosity = int(options.get("verbosity", 1))
 77 | 
 78 |         # Do quick and dirty validation if --noinput
 79 |         if not interactive:
 80 |             if not username or not email:
 81 |                 raise CommandError("You must use --username and --email with --noinput.")
 82 |             if not RE_VALID_USERNAME.match(username):
 83 |                 raise CommandError("Invalid username. Use only letters, digits, and underscores")
 84 |             try:
 85 |                 is_valid_email(email)
 86 |             except exceptions.ValidationError:
 87 |                 raise CommandError("Invalid email address.")
 88 | 
 89 |         # If not provided, create the user with an unusable password
 90 |         password = None
 91 | 
 92 |         # Prompt for username/email/password. Enclose this whole thing in a
 93 |         # try/except to trap for a keyboard interrupt and exit gracefully.
 94 |         if interactive:
 95 |             default_username = get_default_username()
 96 |             try:
 97 |                 # Get a username
 98 |                 while 1:
 99 |                     if not username:
100 |                         input_msg = "Username"
101 |                         if default_username:
102 |                             input_msg += " (leave blank to use %r)" % default_username
103 |                         username = input(input_msg + ": ")
104 |                     if default_username and username == "":
105 |                         username = default_username
106 |                     if not RE_VALID_USERNAME.match(username):
107 |                         sys.stderr.write(
108 |                             "Error: That username is invalid. Use only letters, digits and underscores.\n"
109 |                         )
110 |                         username = None
111 |                         continue
112 |                     try:
113 |                         MongoUser.objects.get(username=username)
114 |                     except MongoUser.DoesNotExist:
115 |                         break
116 |                     else:
117 |                         sys.stderr.write("Error: That username is already taken.\n")
118 |                         username = None
119 | 
120 |                 # Get an email
121 |                 while 1:
122 |                     if not email:
123 |                         email = input("E-mail address: ")
124 |                     try:
125 |                         is_valid_email(email)
126 |                     except exceptions.ValidationError:
127 |                         sys.stderr.write("Error: That e-mail address is invalid.\n")
128 |                         email = None
129 |                     else:
130 |                         break
131 | 
132 |                 # Get a password
133 |                 while 1:
134 |                     if not password:
135 |                         password = getpass.getpass()
136 |                         password2 = getpass.getpass("Password (again): ")
137 |                         if password != password2:
138 |                             sys.stderr.write("Error: Your passwords didn't match.\n")
139 |                             password = None
140 |                             continue
141 |                     if password.strip() == "":
142 |                         sys.stderr.write("Error: Blank passwords aren't allowed.\n")
143 |                         password = None
144 |                         continue
145 |                     break
146 |             except KeyboardInterrupt:
147 |                 sys.stderr.write("\nOperation cancelled.\n")
148 |                 sys.exit(1)
149 | 
150 |         MongoUser.objects.create_superuser(username, email, password)
151 |         if verbosity >= 1:
152 |             self.stdout.write("Superuser created successfully.\n")
153 | 


--------------------------------------------------------------------------------
/django_mongoengine/mongo_admin/sites.py:
--------------------------------------------------------------------------------
 1 | from django.contrib.admin import sites
 2 | from mongoengine.base import TopLevelDocumentMetaclass
 3 | 
 4 | from django_mongoengine.forms.document_options import DocumentMetaWrapper
 5 | from django_mongoengine.mongo_admin.options import DocumentAdmin
 6 | 
 7 | # from django_mongoengine.mongo_admin import actions
 8 | 
 9 | system_check_errors = []
10 | 
11 | 
12 | class AdminSite(sites.AdminSite):
13 |     index_template = "mongo_admin/index.html"
14 | 
15 |     def register(self, model_or_iterable, admin_class=None, **options):
16 |         if isinstance(model_or_iterable, TopLevelDocumentMetaclass) and not admin_class:
17 |             admin_class = DocumentAdmin
18 | 
19 |         if isinstance(model_or_iterable, TopLevelDocumentMetaclass):
20 |             model_or_iterable._meta = DocumentMetaWrapper(model_or_iterable)
21 |             model_or_iterable = [model_or_iterable]
22 | 
23 |         super().register(model_or_iterable, admin_class, **options)
24 | 
25 |     def unregister(self, model_or_iterable):
26 |         if isinstance(model_or_iterable, TopLevelDocumentMetaclass):
27 |             model_or_iterable = [model_or_iterable]
28 | 
29 |         super().unregister(model_or_iterable)
30 | 
31 | 
32 | # This global object represents the default admin site, for the common case.
33 | # You can instantiate AdminSite in your own code to create a custom admin site.
34 | site = AdminSite(name="mongo_admin")
35 | 


--------------------------------------------------------------------------------
/django_mongoengine/mongo_admin/static/helper.js:
--------------------------------------------------------------------------------
 1 | $(document).ready(function(){
 2 | 
 3 |     /*----------------------------------------------------------------------*/
 4 |     var DEBUG = false;
 5 | 
 6 |     function print_array(a,name){
 7 |         debug('--------------------');
 8 |         if ($.isArray(a)){
 9 |             for (var key in a){
10 |                 if (key === 'length' || !a.hasOwnProperty(key)) continue;
11 |                 debug(name+'['+key+'] = '+a[key]);
12 |             }
13 |         }
14 |     }
15 |     /*----------------------------------------------------------------------*/
16 | 
17 |     /************************************************************************
18 |         Transform full read-only dictionaries in text
19 |     ************************************************************************/
20 | 
21 |     var readonly_dicts = $('p:contains({)');
22 |     debug(readonly_dicts);
23 |     readonly_dicts.each(function(){
24 |         var text = $(this).text();
25 |         text = text.replace(/u'/g, '');
26 |         text = text.replace(/'/g, '');
27 |         $(this).html(get_html(text));
28 |     });
29 | 
30 |     function get_html(text){
31 |         debug('------ENTERING get_html');
32 |         var html = '<ul>';
33 |         var pairs = get_pairs(text);
34 |         debug(pairs);
35 |         for (var i = 0; i < pairs.length; i++){
36 |             if (pairs[i][1].contains('{')){
37 |                 html += '<li>' + pairs[i][0] + ': ' + get_html(pairs[i][1]) + '</li>';
38 |             }
39 |             else {
40 |                 html += '<li>' + pairs[i][0] + ': ' + pairs[i][1] + '</li>';
41 |             }
42 |         }
43 |         return html + '</ul>';
44 |     }
45 | 
46 |     function get_pairs(text){
47 |         text = text.slice(1,-1);
48 |         //checker si indexOf({) existe et est plus petit que indexOf(,),
49 |         //si oui, on ne fait rien sur le premier et on passe au 2e ? comment ?
50 |         var pairs = text.split(', ', 1);
51 |         for (var i = 0; i < pairs.length; i++){
52 |                 pairs[i] = pairs[i].split(': ');
53 |         }
54 |         debug('------PAIRS : ');
55 |         debug(pairs);
56 |         return pairs;
57 |     }
58 | 
59 |     function debug(text) {
60 |         if (DEBUG) {
61 |             console.log(text)
62 |         }
63 |     }
64 | });


--------------------------------------------------------------------------------
/django_mongoengine/mongo_admin/templates/mongo_admin/index.html:
--------------------------------------------------------------------------------
1 | {% extends "admin/index.html" %}
2 | {% block sidebar %}
3 | {# disable LogEntry display #}
4 | {% endblock %}
5 | 


--------------------------------------------------------------------------------
/django_mongoengine/mongo_admin/util.py:
--------------------------------------------------------------------------------
 1 | from django.core.exceptions import FieldDoesNotExist
 2 | from django.forms.utils import pretty_name
 3 | from django.utils import formats
 4 | from django.utils.encoding import smart_str
 5 | from mongoengine import fields
 6 | 
 7 | 
 8 | class RelationWrapper:
 9 |     """
10 |     Wraps a document referenced from a ReferenceField with an Interface similiar to
11 |     django's ForeignKeyField.rel
12 |     """
13 | 
14 |     def __init__(self, document):
15 |         self.to = document
16 | 
17 | 
18 | def label_for_field(name, model, model_admin=None, return_attr=False):
19 |     attr = None
20 |     try:
21 |         field = model._meta.get_field_by_name(name)[0]
22 |         label = field.name.replace("_", " ")
23 |     except FieldDoesNotExist:
24 |         if name == "__str__":
25 |             label = smart_str(model._meta.verbose_name)
26 |         else:
27 |             if callable(name):
28 |                 attr = name
29 |             elif model_admin is not None and hasattr(model_admin, name):
30 |                 attr = getattr(model_admin, name)
31 |             elif hasattr(model, name):
32 |                 attr = getattr(model, name)
33 |             else:
34 |                 message = "Unable to lookup '%s' on %s" % (name, model._meta.object_name)
35 |                 if model_admin:
36 |                     message += " or %s" % (model_admin.__class__.__name__,)
37 |                 raise AttributeError(message)
38 | 
39 |             if hasattr(attr, "short_description"):
40 |                 label = attr.short_description
41 |             elif callable(attr):
42 |                 if attr.__name__ == "<lambda>":
43 |                     label = "--"
44 |                 else:
45 |                     label = pretty_name(attr.__name__)
46 |             else:
47 |                 label = pretty_name(name)
48 |     if return_attr:
49 |         return (label, attr)
50 |     else:
51 |         return label
52 | 
53 | 
54 | def display_for_field(value, field):
55 |     from django.contrib.admin.templatetags.admin_list import _boolean_icon
56 |     from django.contrib.admin.views.main import EMPTY_CHANGELIST_VALUE
57 | 
58 |     # if field.flatchoices:
59 |     #     return dict(field.flatchoices).get(value, EMPTY_CHANGELIST_VALUE)
60 |     # NullBooleanField needs special-case null-handling, so it comes
61 |     # before the general null test.
62 |     if isinstance(field, fields.BooleanField):
63 |         return _boolean_icon(value)
64 |     elif value is None:
65 |         return EMPTY_CHANGELIST_VALUE
66 |     elif isinstance(field, fields.DateTimeField):
67 |         return formats.localize(value)
68 |     elif isinstance(field, fields.DecimalField):
69 |         return formats.number_format(value, field.decimal_places)
70 |     elif isinstance(field, fields.FloatField):
71 |         return formats.number_format(value)
72 |     else:
73 |         return smart_str(value)
74 | 
75 | 
76 | def help_text_for_field(name, model):
77 |     try:
78 |         help_text = model._meta.get_field_by_name(name)[0].help_text
79 |     except FieldDoesNotExist:
80 |         help_text = ""
81 |     return smart_str(help_text, strings_only=True)
82 | 


--------------------------------------------------------------------------------
/django_mongoengine/mongo_admin/views.py:
--------------------------------------------------------------------------------
  1 | from django.contrib.admin.options import IncorrectLookupParameters
  2 | from django.contrib.admin.views.main import ORDER_VAR, ChangeList
  3 | from django.core.exceptions import ImproperlyConfigured, SuspiciousOperation
  4 | from django.core.paginator import InvalidPage
  5 | 
  6 | 
  7 | class DocumentChangeList(ChangeList):
  8 |     def __init__(self, *args, **kwargs):
  9 |         super().__init__(*args, **kwargs)
 10 |         self.pk_attname = self.lookup_opts.pk_name
 11 | 
 12 |     def get_results(self, request):
 13 |         paginator = self.model_admin.get_paginator(request, self.queryset, self.list_per_page)
 14 |         # Get the number of objects, with admin filters applied.
 15 |         result_count = paginator.count
 16 | 
 17 |         # Get the total number of objects, with no admin filters applied.
 18 |         # Perform a slight optimization: Check to see whether any filters were
 19 |         # given. If not, use paginator.hits to calculate the number of objects,
 20 |         # because we've already done paginator.hits and the value is cached.
 21 |         if len(self.queryset._query) == 1:
 22 |             full_result_count = result_count
 23 |         else:
 24 |             full_result_count = self.root_queryset.count()
 25 | 
 26 |         can_show_all = result_count <= self.list_max_show_all
 27 |         multi_page = result_count > self.list_per_page
 28 | 
 29 |         # Get the list of objects to display on this page.
 30 |         if (self.show_all and can_show_all) or not multi_page:
 31 |             result_list = self.queryset.clone()
 32 |         else:
 33 |             try:
 34 |                 result_list = paginator.page(self.page_num).object_list
 35 |             except InvalidPage:
 36 |                 raise IncorrectLookupParameters
 37 | 
 38 |         self.result_count = result_count
 39 |         self.full_result_count = full_result_count
 40 |         self.result_list = result_list
 41 |         self.can_show_all = can_show_all
 42 |         self.multi_page = multi_page
 43 |         self.paginator = paginator
 44 | 
 45 |     def _get_default_ordering(self):
 46 |         try:
 47 |             ordering = super()._get_default_ordering()
 48 |         except AttributeError:
 49 |             ordering = []
 50 |             if self.model_admin.ordering:
 51 |                 ordering = self.model_admin.ordering
 52 |             elif self.lookup_opts.ordering:
 53 |                 ordering = self.lookup_opts.ordering
 54 |         return ordering
 55 | 
 56 |     def get_ordering(self, request=None, queryset=None):
 57 |         """
 58 |         Returns the list of ordering fields for the change list.
 59 |         First we check the get_ordering() method in model admin, then we check
 60 |         the object's default ordering. Then, any manually-specified ordering
 61 |         from the query string overrides anything. Finally, a deterministic
 62 |         order is guaranteed by ensuring the primary key is used as the last
 63 |         ordering field.
 64 |         """
 65 |         if queryset is None:
 66 |             # with Django < 1.4 get_ordering works without fixes for mongoengine
 67 |             return super().get_ordering()
 68 | 
 69 |         params = self.params
 70 |         ordering = list(self.model_admin.get_ordering(request) or self._get_default_ordering())
 71 |         if ORDER_VAR in params:
 72 |             # Clear ordering and used params
 73 |             ordering = []
 74 |             order_params = params[ORDER_VAR].split(".")
 75 |             for p in order_params:
 76 |                 try:
 77 |                     none, pfx, idx = p.rpartition("-")
 78 |                     field_name = self.list_display[int(idx)]
 79 |                     order_field = self.get_ordering_field(field_name)
 80 |                     if not order_field:
 81 |                         continue  # No 'admin_order_field', skip it
 82 |                     ordering.append(pfx + order_field)
 83 |                 except (IndexError, ValueError):
 84 |                     continue  # Invalid ordering specified, skip it.
 85 | 
 86 |         # Add the given query's ordering fields, if any.
 87 |         try:
 88 | 
 89 |             def sign(t):
 90 |                 return t[1] > 0 and "+" or "-"
 91 | 
 92 |             qs_ordering = [sign(t) + t[0] for t in queryset._ordering]
 93 |             ordering.extend(qs_ordering)
 94 |         except:  # noqa: E722
 95 |             pass
 96 | 
 97 |         # Ensure that the primary key is systematically present in the list of
 98 |         # ordering fields so we can guarantee a deterministic order across all
 99 |         # database backends.
100 |         pk_name = self.lookup_opts.pk.name
101 |         if not (set(ordering) & {"pk", "-pk", pk_name, "-" + pk_name}):
102 |             # The two sets do not intersect, meaning the pk isn't present. So
103 |             # we add it.
104 |             ordering.append("pk")
105 |         return ordering
106 | 
107 |     def get_queryset(self, request=None):
108 |         # First, we collect all the declared list filters.
109 |         qs = self.root_queryset.clone()
110 | 
111 |         (
112 |             self.filter_specs,
113 |             self.has_filters,
114 |             remaining_lookup_params,
115 |             search_may_have_duplicates,
116 |             has_active_filters,
117 |         ) = self.get_filters(request)
118 | 
119 |         # Then, we let every list filter modify the queryset to its liking.
120 |         for filter_spec in self.filter_specs:
121 |             new_qs = filter_spec.queryset(request, qs)
122 |             if new_qs is not None:
123 |                 qs = new_qs
124 | 
125 |         try:
126 |             # Finally, we apply the remaining lookup parameters from the query
127 |             # string (i.e. those that haven't already been processed by the
128 |             # filters).
129 |             qs = qs.filter(**remaining_lookup_params)
130 |             # TODO: This should probably be mongoengine exceptions
131 |         except (SuspiciousOperation, ImproperlyConfigured):
132 |             # Allow certain types of errors to be re-raised as-is so that the
133 |             # caller can treat them in a special way.
134 |             raise
135 |         except Exception as e:
136 |             # Every other error is caught with a naked except, because we don't
137 |             # have any other way of validating lookup parameters. They might be
138 |             # invalid if the keyword arguments are incorrect, or if the values
139 |             # are not in the correct type, so we might get FieldError,
140 |             # ValueError, ValidationError, or ?.
141 |             raise IncorrectLookupParameters(e)
142 | 
143 |         # Set ordering.
144 |         ordering = self.get_ordering(request, qs)
145 |         qs = qs.order_by(*ordering)
146 | 
147 |         # Apply search results
148 |         qs, search_may_have_duplicates = self.model_admin.get_search_results(
149 |             request,
150 |             qs,
151 |             self.query,
152 |         )
153 | 
154 |         return qs
155 | 


--------------------------------------------------------------------------------
/django_mongoengine/mongo_auth/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/MongoEngine/django-mongoengine/298cdcf59b21fe590958f57f27bf28e7192fcc4e/django_mongoengine/mongo_auth/__init__.py


--------------------------------------------------------------------------------
/django_mongoengine/mongo_auth/admin.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/MongoEngine/django-mongoengine/298cdcf59b21fe590958f57f27bf28e7192fcc4e/django_mongoengine/mongo_auth/admin.py


--------------------------------------------------------------------------------
/django_mongoengine/mongo_auth/backends.py:
--------------------------------------------------------------------------------
 1 | from django.contrib.auth import backends as django_backends
 2 | 
 3 | 
 4 | class MongoEngineBackend:
 5 |     """Authenticate using MongoEngine and mongoengine.django.auth.User."""
 6 | 
 7 |     supports_object_permissions = False
 8 |     supports_anonymous_user = False
 9 |     supports_inactive_user = False
10 | 
11 |     authenticate = django_backends.ModelBackend.__dict__["authenticate"]
12 |     get_user = django_backends.ModelBackend.__dict__["get_user"]
13 |     try:
14 |         user_can_authenticate = django_backends.ModelBackend.__dict__["user_can_authenticate"]
15 |     except KeyError:
16 |         pass  # it's okay for django < 1.9
17 | 


--------------------------------------------------------------------------------
/django_mongoengine/mongo_auth/managers.py:
--------------------------------------------------------------------------------
  1 | from importlib import import_module
  2 | 
  3 | from django.conf import settings
  4 | from django.contrib.auth.models import UserManager
  5 | from django.db.models import BooleanField, CharField, DateTimeField
  6 | from django.utils.translation import gettext_lazy as _
  7 | from mongoengine.errors import DoesNotExist
  8 | 
  9 | MONGOENGINE_USER_DOCUMENT = getattr(
 10 |     settings, "MONGOENGINE_USER_DOCUMENT", "django_mongoengine.mongo_auth.models.User"
 11 | )
 12 | 
 13 | 
 14 | def get_user_document():
 15 |     """Get the user document class used for authentication.
 16 | 
 17 |     This is the class defined in settings.MONGOENGINE_USER_DOCUMENT, which
 18 |     defaults to `mongoengine.django.auth.User`.
 19 | 
 20 |     """
 21 | 
 22 |     name = MONGOENGINE_USER_DOCUMENT
 23 |     dot = name.rindex(".")
 24 |     module = import_module(name[:dot])
 25 |     return getattr(module, name[dot + 1 :])
 26 | 
 27 | 
 28 | class MongoUserManager(UserManager):
 29 |     """A User manager wich allows the use of MongoEngine documents in Django.
 30 | 
 31 |     To use the manager, you must tell django.contrib.auth to use MongoUser as
 32 |     the user model. In you settings.py, you need:
 33 | 
 34 |         INSTALLED_APPS = (
 35 |             ...
 36 |             'django.contrib.auth',
 37 |             'django_mongoengine.mongo_auth',
 38 |             ...
 39 |         )
 40 |         AUTH_USER_MODEL = 'mongo_auth.MongoUser'
 41 | 
 42 |     Django will use the model object to access the custom Manager, which will
 43 |     replace the original queryset with MongoEngine querysets.
 44 | 
 45 |     By default, `mongo_auth.User` will be used to store users. You
 46 |     can specify another document class in MONGOENGINE_USER_DOCUMENT in your
 47 |     settings.py.
 48 | 
 49 |     The User Document class has the same requirements as a standard custom user
 50 |     model: https://docs.djangoproject.com/en/dev/topics/auth/customizing/
 51 | 
 52 |     In particular, the User Document class must define USERNAME_FIELD and
 53 |     REQUIRED_FIELDS.
 54 |     """
 55 | 
 56 |     def contribute_to_class(self, model, name):
 57 |         super().contribute_to_class(model, name)
 58 |         self.dj_model = self.model
 59 |         self.model = get_user_document()
 60 | 
 61 |         self.dj_model.USERNAME_FIELD = self.model.USERNAME_FIELD
 62 |         username = CharField(_("username"), max_length=30, unique=True)
 63 |         username.contribute_to_class(self.dj_model, self.dj_model.USERNAME_FIELD)
 64 | 
 65 |         self.dj_model.REQUIRED_FIELDS = self.model.REQUIRED_FIELDS
 66 |         for name in self.dj_model.REQUIRED_FIELDS:
 67 |             field = CharField(_(name), max_length=30)
 68 |             field.contribute_to_class(self.dj_model, name)
 69 | 
 70 |         is_staff = BooleanField(_("is_staff"), default=False)
 71 |         is_staff.contribute_to_class(self.dj_model, "is_staff")
 72 | 
 73 |         is_active = BooleanField(_("is_active"), default=False)
 74 |         is_active.contribute_to_class(self.dj_model, "is_active")
 75 | 
 76 |         is_superuser = BooleanField(_("is_superuser"), default=False)
 77 |         is_superuser.contribute_to_class(self.dj_model, "is_superuser")
 78 | 
 79 |         last_login = DateTimeField(_("last_login"), auto_now_add=True)
 80 |         last_login.contribute_to_class(self.dj_model, "last_login")
 81 | 
 82 |         date_joined = DateTimeField(_("date_joined"), auto_now_add=True)
 83 |         date_joined.contribute_to_class(self.dj_model, "date_joined")
 84 | 
 85 |     def get(self, *args, **kwargs):
 86 |         try:
 87 |             return self.get_queryset().get(*args, **kwargs)
 88 |         except DoesNotExist:
 89 |             # ModelBackend expects this exception
 90 |             raise self.dj_model.DoesNotExist
 91 | 
 92 |     @property
 93 |     def db(self):
 94 |         raise NotImplementedError
 95 | 
 96 |     def get_queryset(self):
 97 |         return get_user_document().objects
 98 | 
 99 |     def create_superuser(self, username, email, password, **extra_fields):
100 |         """since we use mongo as our database, we don't use
101 |         django's rule to create a superuser, such as 'python manage.py createsuperuser'.
102 |         We use mongo's rule --'python manage.py createmongosuperuser instead.
103 |         """
104 |         return get_user_document().create_superuser(username, password, email)
105 | 


--------------------------------------------------------------------------------
/django_mongoengine/paginator.py:
--------------------------------------------------------------------------------
 1 | from django.core.paginator import Paginator
 2 | from django.utils.functional import cached_property
 3 | 
 4 | 
 5 | class Paginator(Paginator):
 6 |     @cached_property
 7 |     def count(self):
 8 |         try:
 9 |             return self.object_list.count()
10 |         except TypeError:
11 |             return len(self.object_list)
12 | 


--------------------------------------------------------------------------------
/django_mongoengine/queryset.py:
--------------------------------------------------------------------------------
  1 | from __future__ import annotations
  2 | 
  3 | from typing import TYPE_CHECKING, Generic, TypeVar
  4 | 
  5 | from django.db.models.query import QuerySet as DjangoQuerySet
  6 | from django.db.models.utils import resolve_callables
  7 | from mongoengine import queryset as qs
  8 | from mongoengine.errors import NotUniqueError
  9 | 
 10 | from .utils.monkey import patch_typing_support
 11 | 
 12 | if TYPE_CHECKING:
 13 |     from .document import Document
 14 | 
 15 | _M = TypeVar("_M", bound="Document")
 16 | 
 17 | patch_typing_support()
 18 | 
 19 | 
 20 | class QueryWrapper:
 21 |     # XXX: copy funcs from django; now it's just wrapper
 22 |     select_related = False
 23 |     order_by = []
 24 | 
 25 |     def __init__(self, q, ordering):
 26 |         self.q = q
 27 |         self.order_by = ordering or []
 28 | 
 29 | 
 30 | class BaseQuerySet(Generic[_M]):
 31 |     """
 32 |     A base queryset with django-required attributes
 33 |     """
 34 | 
 35 |     @property
 36 |     def model(self) -> type[_M]:
 37 |         return self._document
 38 | 
 39 |     @property
 40 |     def query(self):
 41 |         return QueryWrapper(self._query, self._ordering)
 42 | 
 43 |     @property
 44 |     def _prefetch_related_lookups(self):
 45 |         # Originally used in django for prefetch_related(),
 46 |         # see https://docs.djangoproject.com/en/1.9/ref/models/querysets/#prefetch-related
 47 |         # returning empty list to presume that no query prefetch is required
 48 |         return []
 49 | 
 50 |     def iterator(self):
 51 |         return self
 52 | 
 53 |     def get_queryset(self):
 54 |         return self
 55 | 
 56 |     def latest(self, field_name):
 57 |         return self.order_by("-" + field_name).first()
 58 | 
 59 |     def earliest(self, field_name):
 60 |         return self.order_by(field_name).first()
 61 | 
 62 |     def exists(self) -> bool:
 63 |         return bool(self)
 64 | 
 65 |     def _clone(self):
 66 |         return self.clone()
 67 | 
 68 |     @property
 69 |     def ordered(self):
 70 |         """
 71 |         Returns True if the QuerySet is ordered -- i.e. has an order_by()
 72 |         clause or a default ordering on the model.
 73 |         """
 74 |         if self._ordering:
 75 |             return True
 76 |         elif self._document._meta.ordering:
 77 |             return True
 78 |         else:
 79 |             return False
 80 | 
 81 |     def get_or_create(self, defaults=None, **kwargs):
 82 |         """
 83 |         Look up an object with the given kwargs, creating one if necessary.
 84 |         Return a tuple of (object, created), where created is a boolean
 85 |         specifying whether an object was created.
 86 |         """
 87 |         try:
 88 |             return self.get(**kwargs), False
 89 |         except self.model.DoesNotExist:
 90 |             params = self._extract_model_params(defaults, **kwargs)
 91 |             # Try to create an object using passed params.
 92 |             try:
 93 |                 params = dict(resolve_callables(params))
 94 |                 return self.create(**params), True
 95 |             except NotUniqueError:
 96 |                 try:
 97 |                     return self.get(**kwargs), False
 98 |                 except self.model.DoesNotExist:
 99 |                     pass
100 |                 raise
101 | 
102 |     def update_or_create(self, defaults=None, **kwargs):
103 |         """
104 |         Look up an object with the given kwargs, updating one with defaults
105 |         if it exists, otherwise create a new one.
106 |         Return a tuple (object, created), where created is a boolean
107 |         specifying whether an object was created.
108 |         """
109 |         defaults = defaults or {}
110 |         self._for_write = True
111 |         obj, created = self.get_or_create(defaults, **kwargs)
112 |         if created:
113 |             return obj, created
114 |         for k, v in resolve_callables(defaults):
115 |             setattr(obj, k, v)
116 |         obj.save()
117 |         return obj, False
118 | 
119 |     _extract_model_params = DjangoQuerySet.__dict__["_extract_model_params"]
120 | 
121 | 
122 | class QuerySet(BaseQuerySet[_M], qs.QuerySet[_M]):
123 |     pass
124 | 
125 | 
126 | class QuerySetNoCache(BaseQuerySet[_M], qs.QuerySetNoCache[_M]):
127 |     pass
128 | 
129 | 
130 | class QuerySetManager(Generic[_M], qs.QuerySetManager):
131 |     default = QuerySet
132 |     if TYPE_CHECKING:
133 | 
134 |         def __get__(self, instance: object, cls: type[_M]) -> QuerySet[_M]: ...
135 | 


--------------------------------------------------------------------------------
/django_mongoengine/sessions.py:
--------------------------------------------------------------------------------
  1 | import logging
  2 | 
  3 | from bson import json_util
  4 | from django.conf import settings
  5 | from django.contrib.sessions.backends.base import CreateError, SessionBase
  6 | from django.core.exceptions import SuspiciousOperation
  7 | from django.utils import timezone
  8 | from django.utils.encoding import force_str
  9 | from mongoengine import fields
 10 | from mongoengine.connection import DEFAULT_CONNECTION_NAME
 11 | from mongoengine.document import Document
 12 | from mongoengine.queryset import OperationError
 13 | 
 14 | MONGOENGINE_SESSION_DB_ALIAS = getattr(
 15 |     settings, "MONGOENGINE_SESSION_DB_ALIAS", DEFAULT_CONNECTION_NAME
 16 | )
 17 | 
 18 | # a setting for the name of the collection used to store sessions
 19 | MONGOENGINE_SESSION_COLLECTION = getattr(
 20 |     settings, "MONGOENGINE_SESSION_COLLECTION", "django_session"
 21 | )
 22 | 
 23 | # a setting for whether session data is stored encoded or not
 24 | MONGOENGINE_SESSION_DATA_ENCODE = getattr(settings, "MONGOENGINE_SESSION_DATA_ENCODE", True)
 25 | 
 26 | 
 27 | class MongoSession(Document):
 28 |     session_key = fields.StringField(primary_key=True, max_length=40)
 29 |     session_data = fields.StringField() if MONGOENGINE_SESSION_DATA_ENCODE else fields.DictField()
 30 |     expire_date = fields.DateTimeField()
 31 | 
 32 |     meta = {
 33 |         "collection": MONGOENGINE_SESSION_COLLECTION,
 34 |         "db_alias": MONGOENGINE_SESSION_DB_ALIAS,
 35 |         "allow_inheritance": False,
 36 |         "indexes": [{"fields": ["expire_date"], "expireAfterSeconds": 0}],
 37 |     }
 38 | 
 39 |     def get_decoded(self):
 40 |         return SessionStore().decode(self.session_data)
 41 | 
 42 | 
 43 | class SessionStore(SessionBase):
 44 |     """A MongoEngine-based session store for Django."""
 45 | 
 46 |     def load(self):
 47 |         try:
 48 |             s = MongoSession.objects(session_key=self.session_key, expire_date__gt=timezone.now)[0]
 49 |             if MONGOENGINE_SESSION_DATA_ENCODE:
 50 |                 return self.decode(force_str(s.session_data))
 51 |             else:
 52 |                 return s.session_data
 53 |         except (IndexError, SuspiciousOperation) as e:
 54 |             if isinstance(e, SuspiciousOperation):
 55 |                 logger = logging.getLogger("django.security.%s" % e.__class__.__name__)
 56 |                 logger.warning(force_str(e))
 57 |             self._session_key = None
 58 |             return {}
 59 | 
 60 |     def exists(self, session_key):
 61 |         return bool(MongoSession.objects(session_key=session_key).first())
 62 | 
 63 |     def create(self):
 64 |         while True:
 65 |             self._session_key = self._get_new_session_key()
 66 |             try:
 67 |                 self.save(must_create=True)
 68 |             except CreateError:
 69 |                 continue
 70 |             self.modified = True
 71 |             return
 72 | 
 73 |     def save(self, must_create=False):
 74 |         if self.session_key is None:
 75 |             self.create()
 76 |         data = self._get_session(no_load=must_create)
 77 |         s = MongoSession(session_key=self.session_key)
 78 |         if MONGOENGINE_SESSION_DATA_ENCODE:
 79 |             s.session_data = self.encode(data)
 80 |         else:
 81 |             s.session_data = data
 82 |         s.expire_date = self.get_expiry_date()
 83 |         try:
 84 |             s.save(force_insert=must_create)
 85 |         except OperationError:
 86 |             if must_create:
 87 |                 raise CreateError
 88 |             raise
 89 | 
 90 |     def delete(self, session_key=None):
 91 |         if session_key is None:
 92 |             if self.session_key is None:
 93 |                 return
 94 |             session_key = self.session_key
 95 |         MongoSession.objects(session_key=session_key).delete()
 96 | 
 97 | 
 98 | class BSONSerializer:
 99 |     """
100 |     Serializer that can handle BSON types (eg ObjectId).
101 |     """
102 | 
103 |     def dumps(self, obj):
104 |         return json_util.dumps(obj, separators=(",", ":")).encode("ascii")
105 | 
106 |     def loads(self, data):
107 |         return json_util.loads(data.decode("ascii"))
108 | 


--------------------------------------------------------------------------------
/django_mongoengine/utils/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/MongoEngine/django-mongoengine/298cdcf59b21fe590958f57f27bf28e7192fcc4e/django_mongoengine/utils/__init__.py


--------------------------------------------------------------------------------
/django_mongoengine/utils/monkey.py:
--------------------------------------------------------------------------------
 1 | import importlib
 2 | import importlib.util
 3 | from types import MethodType
 4 | 
 5 | from mongoengine.queryset import QuerySet, QuerySetNoCache
 6 | 
 7 | from django_mongoengine.fields.djangoflavor import DjangoField
 8 | 
 9 | 
10 | def get_patched_django_module(modname: str, **kwargs):
11 |     # Patch module in-place
12 |     # https://docs.python.org/3/library/importlib.html#importlib-examples
13 |     mod = importlib.import_module(modname)
14 | 
15 |     spec = importlib.util.spec_from_file_location(mod.__name__, mod.__file__)
16 |     assert spec
17 |     assert spec.loader
18 |     module = importlib.util.module_from_spec(spec)
19 |     spec.loader.exec_module(module)
20 | 
21 |     for k, v in kwargs.items():
22 |         setattr(module, k, v)
23 |     return module
24 | 
25 | 
26 | def patch_mongoengine_field(field_name: str):
27 |     """
28 |     patch mongoengine.[field_name] for comparison support
29 |     becouse it's required in django.forms.models.fields_for_model
30 |     importing using mongoengine internal import cache
31 |     """
32 |     from mongoengine import common
33 | 
34 |     field = common._import_class(field_name)
35 |     for k in ["__eq__", "__lt__", "__hash__", "attname", "get_internal_type"]:
36 |         if k not in field.__dict__:
37 |             setattr(field, k, DjangoField.__dict__[k])
38 | 
39 | 
40 | def patch_typing_support():
41 |     """
42 |     Patch classes to support generic types
43 |     """
44 | 
45 |     for model in [QuerySet, QuerySetNoCache]:
46 |         model.__class_getitem__ = MethodType(lambda cls, _: cls, QuerySet)  # type: ignore
47 | 


--------------------------------------------------------------------------------
/django_mongoengine/utils/wrappers.py:
--------------------------------------------------------------------------------
 1 | class WrapDocument(type):
 2 |     """
 3 |     Wrapper for views to include wrapped `model` attribute
 4 |     """
 5 | 
 6 |     def __new__(cls, name, bases, attrs):
 7 |         document = attrs.get("document")
 8 |         if document:
 9 |             try:
10 |                 attrs["model"] = document
11 |             except AttributeError:
12 |                 attrs["model"] = property(lambda self: self.document)
13 |         return super().__new__(cls, name, bases, attrs)
14 | 
15 | 
16 | def copy_class(source):
17 |     def decorator(cls):
18 |         def f(k):
19 |             return k not in cls.__dict__ and not k.startswith("__")
20 | 
21 |         for k in filter(f, source.__dict__.keys()):
22 |             setattr(cls, k, source.__dict__[k])
23 |         return cls
24 | 
25 |     return decorator
26 | 


--------------------------------------------------------------------------------
/django_mongoengine/views/__init__.py:
--------------------------------------------------------------------------------
 1 | from .detail import DetailView
 2 | from .edit import CreateView, DeleteView, UpdateView
 3 | from .embedded import EmbeddedDetailView
 4 | from .list import ListView
 5 | 
 6 | __all__ = [
 7 |     "ListView",
 8 |     "DetailView",
 9 |     "EmbeddedDetailView",
10 |     "CreateView",
11 |     "UpdateView",
12 |     "DeleteView",
13 | ]
14 | 


--------------------------------------------------------------------------------
/django_mongoengine/views/detail.py:
--------------------------------------------------------------------------------
 1 | from django.core.exceptions import ImproperlyConfigured
 2 | from django.views.generic import detail as djmod
 3 | from django.views.generic.base import TemplateResponseMixin, View
 4 | 
 5 | from django_mongoengine.utils.wrappers import WrapDocument, copy_class
 6 | 
 7 | 
 8 | class SingleObjectMixin(djmod.SingleObjectMixin, metaclass=WrapDocument):
 9 |     document = None
10 | 
11 |     def get_context_object_name(self, obj):
12 |         """
13 |         Get the name to use for the object.
14 |         """
15 |         if self.context_object_name:
16 |             return self.context_object_name
17 |         elif hasattr(obj, "_meta"):
18 |             return obj._meta.model_name
19 |         else:
20 |             return None
21 | 
22 | 
23 | class SingleObjectTemplateResponseMixin(TemplateResponseMixin):
24 |     template_name_field = None
25 |     template_name_suffix = "_detail"
26 | 
27 |     def get_template_names(self):
28 |         """
29 |         Return a list of template names to be used for the request. May not be
30 |         called if render_to_response is overridden. Returns the following list:
31 | 
32 |         * the value of ``template_name`` on the view (if provided)
33 |         * the contents of the ``template_name_field`` field on the
34 |           object instance that the view is operating upon (if available)
35 |         * ``<app_label>/<model_name><template_name_suffix>.html``
36 |         """
37 |         try:
38 |             names = super().get_template_names()
39 |         except ImproperlyConfigured:
40 |             # If template_name isn't specified, it's not a problem --
41 |             # we just start with an empty list.
42 |             names = []
43 | 
44 |             # If self.template_name_field is set, grab the value of the field
45 |             # of that name from the object; this is the most specific template
46 |             # name, if given.
47 |             if self.object and self.template_name_field:
48 |                 name = getattr(self.object, self.template_name_field, None)
49 |                 if name:
50 |                     names.insert(0, name)
51 | 
52 |             # The least-specific option is the default <app>/<model>_detail.html;
53 |             # only use this if the object in question is a model.
54 |             opts = None
55 |             if hasattr(self.object, "_meta"):
56 |                 opts = self.object._meta
57 |             elif hasattr(self, "model") and self.model is not None:
58 |                 opts = self.model._meta
59 |             if opts:
60 |                 names.append(
61 |                     "%s/%s%s.html" % (opts.app_label, opts.model_name, self.template_name_suffix)
62 |                 )
63 | 
64 |             # If we still haven't managed to find any template names, we should
65 |             # re-raise the ImproperlyConfigured to alert the user.
66 |             if not names:
67 |                 raise
68 | 
69 |         return names
70 | 
71 | 
72 | @copy_class(djmod.BaseDetailView)
73 | class BaseDetailView(SingleObjectMixin, View):
74 |     __doc__ = djmod.BaseDetailView.__doc__
75 | 
76 | 
77 | class DetailView(SingleObjectTemplateResponseMixin, BaseDetailView):
78 |     pass
79 | 


--------------------------------------------------------------------------------
/django_mongoengine/views/edit.py:
--------------------------------------------------------------------------------
 1 | from django.core.exceptions import ImproperlyConfigured
 2 | 
 3 | from django_mongoengine.forms.documents import documentform_factory
 4 | from django_mongoengine.utils.monkey import get_patched_django_module
 5 | from django_mongoengine.utils.wrappers import WrapDocument, copy_class
 6 | 
 7 | from .detail import SingleObjectMixin, SingleObjectTemplateResponseMixin
 8 | 
 9 | djmod = get_patched_django_module(
10 |     "django.views.generic.edit",
11 |     model_forms=get_patched_django_module(
12 |         "django.forms.models",
13 |         modelform_factory=documentform_factory,
14 |     ),
15 | )
16 | 
17 | try:
18 |     FormMixin = djmod.FormMixinBase
19 | except AttributeError:
20 |     # django 1.10
21 |     FormMixin = djmod.FormMixin
22 | 
23 | 
24 | class WrapDocumentForm(WrapDocument, FormMixin):
25 |     pass
26 | 
27 | 
28 | class DocumentFormFixin(SingleObjectMixin):
29 |     def get_success_url(self):
30 |         """
31 |         Returns the supplied URL.
32 |         """
33 |         if self.success_url:
34 |             url = self.success_url.format(**self.object._data)
35 |         else:
36 |             try:
37 |                 url = self.object.get_absolute_url()
38 |             except AttributeError:
39 |                 raise ImproperlyConfigured(
40 |                     "No URL to redirect to.  Either provide a url or define"
41 |                     " a get_absolute_url method on the Model."
42 |                 )
43 |         return url
44 | 
45 | 
46 | @copy_class(djmod.CreateView)
47 | class CreateView(
48 |     SingleObjectTemplateResponseMixin,
49 |     DocumentFormFixin,
50 |     djmod.BaseCreateView,
51 |     metaclass=WrapDocumentForm,
52 | ):
53 |     __doc__ = djmod.CreateView.__doc__
54 | 
55 | 
56 | @copy_class(djmod.UpdateView)
57 | class UpdateView(
58 |     SingleObjectTemplateResponseMixin,
59 |     DocumentFormFixin,
60 |     djmod.BaseUpdateView,
61 |     metaclass=WrapDocumentForm,
62 | ):
63 |     __doc__ = djmod.UpdateView.__doc__
64 | 
65 | 
66 | @copy_class(djmod.DeleteView)
67 | class DeleteView(
68 |     SingleObjectTemplateResponseMixin,
69 |     DocumentFormFixin,
70 |     djmod.BaseDeleteView,
71 |     metaclass=WrapDocumentForm,
72 | ):
73 |     __doc__ = djmod.DeleteView.__doc__
74 | 


--------------------------------------------------------------------------------
/django_mongoengine/views/embedded.py:
--------------------------------------------------------------------------------
  1 | from django.core.exceptions import ImproperlyConfigured
  2 | 
  3 | from .detail import DetailView
  4 | from .edit import WrapDocumentForm, djmod
  5 | 
  6 | 
  7 | class EmbeddedFormMixin(djmod.FormMixin):
  8 |     """
  9 |     A mixin that provides a way to show and handle a documentform in a request.
 10 |     """
 11 | 
 12 |     embedded_form_class = None
 13 |     embedded_context_name = "embedded_form"
 14 | 
 15 |     def get_form_class(self):
 16 |         """
 17 |         Returns the form class to use in this view
 18 |         """
 19 |         if self.embedded_form_class:
 20 |             return self.embedded_form_class
 21 |         else:
 22 |             raise ImproperlyConfigured(
 23 |                 "No embedded form class provided. An embedded form class must be provided."
 24 |             )
 25 | 
 26 |     def get_form(self, form_class=None):
 27 |         """
 28 |         Returns an instance of the form to be used in this view.
 29 |         """
 30 |         if form_class is None:
 31 |             form_class = self.get_form_class()
 32 |         return form_class(self.object, **self.get_form_kwargs())
 33 | 
 34 |     def get_embedded_object(self):
 35 |         """
 36 |         Returns an instance of the embedded object. By default this is a freshly created
 37 |         instance. Override for something cooler.
 38 |         """
 39 |         if hasattr(self, "embedded_object"):
 40 |             return self.embedded_object()
 41 |         else:
 42 |             klass = self.get_form_class()
 43 |             return klass.Meta.document()
 44 | 
 45 |     def get_form_kwargs(self):
 46 |         """
 47 |         Returns the keyword arguments for instantiating the form.
 48 |         """
 49 |         kwargs = super().get_form_kwargs()
 50 |         kwargs.update({"instance": self.get_embedded_object()})
 51 |         if "initial" not in kwargs:
 52 |             kwargs["initial"] = {}
 53 |         return kwargs
 54 | 
 55 |     def get_success_url(self):
 56 |         object = getattr(self, "object", self.get_object())
 57 |         if self.success_url:
 58 |             url = self.success_url % object.__dict__
 59 |         else:
 60 |             try:
 61 |                 url = object.get_absolute_url()
 62 |             except AttributeError:
 63 |                 raise ImproperlyConfigured(
 64 |                     "No URL to redirect to.  Either provide a url or define"
 65 |                     " a get_absolute_url method on the document."
 66 |                 )
 67 |         return url
 68 | 
 69 |     def form_valid(self, form):
 70 |         self.embedded_object = form.save()
 71 |         return super().form_valid(form)
 72 | 
 73 |     def get_context_data(self, **kwargs):
 74 |         context = super().get_context_data(**kwargs)
 75 | 
 76 |         self.object = getattr(self, "object", self.get_object())
 77 |         if "form" in kwargs:
 78 |             form = kwargs["form"]
 79 |         else:
 80 |             form = self.get_form(self.get_form_class())
 81 |         context[self.embedded_context_name] = form
 82 | 
 83 |         return context
 84 | 
 85 | 
 86 | class ProcessEmbeddedFormMixin:
 87 |     """
 88 |     A mixin that processes an embedded form on POST.
 89 |     Does not implement any GET handling.
 90 |     """
 91 | 
 92 |     def post(self, request, *args, **kwargs):
 93 |         self.object = self.get_object()
 94 |         form_class = self.get_form_class()
 95 |         form = self.get_form(form_class)
 96 |         if form.is_valid():
 97 |             return self.form_valid(form)
 98 |         else:
 99 |             return self.form_invalid(form)
100 |         super().post(request, *args, **kwargs)
101 | 
102 | 
103 | class BaseEmbeddedFormMixin(EmbeddedFormMixin, ProcessEmbeddedFormMixin):
104 |     """
105 |     A Mixin that handles an embedded form on POST and
106 |     adds the form into the template context.
107 |     """
108 | 
109 | 
110 | class EmbeddedDetailView(
111 |     BaseEmbeddedFormMixin,
112 |     DetailView,
113 |     metaclass=WrapDocumentForm,
114 | ):
115 |     """
116 |     Renders the detail view of a document and and adds a
117 |     form for an embedded object into the template.
118 | 
119 |     See BaseEmbeddedFormMixin for details on the form.
120 |     """
121 | 


--------------------------------------------------------------------------------
/django_mongoengine/views/list.py:
--------------------------------------------------------------------------------
 1 | from mongoengine.queryset import QuerySet
 2 | 
 3 | from django_mongoengine.paginator import Paginator
 4 | from django_mongoengine.utils.monkey import get_patched_django_module
 5 | from django_mongoengine.utils.wrappers import WrapDocument, copy_class
 6 | 
 7 | __all__ = [
 8 |     "MultipleObjectMixin",
 9 |     "ListView",
10 | ]
11 | 
12 | djmod = get_patched_django_module(
13 |     "django.views.generic.list",
14 |     QuerySet=QuerySet,
15 | )
16 | 
17 | 
18 | class MultipleObjectMixin(djmod.MultipleObjectMixin, metaclass=WrapDocument):
19 |     paginator_class = Paginator
20 | 
21 | 
22 | class MultipleObjectTemplateResponseMixin(
23 |     djmod.MultipleObjectTemplateResponseMixin,
24 |     metaclass=WrapDocument,
25 | ):
26 |     pass
27 | 
28 | 
29 | @copy_class(djmod.ListView)
30 | class ListView(MultipleObjectTemplateResponseMixin, djmod.BaseListView):
31 |     __doc__ = djmod.ListView.__doc__
32 |     paginator_class = Paginator
33 | 


--------------------------------------------------------------------------------
/django_mongoengine/views/templates/_forms.html:
--------------------------------------------------------------------------------
 1 | <fieldset>
 2 | {% for field in form.visible_fields %}
 3 | <div class="clearfix {% if field.errors %}error{% endif %}">
 4 |   {{ field.label_tag }}
 5 |   <div class="input">
 6 |     {{ field }}
 7 |     {% if field.errors or field.help_text %}
 8 |       <span class="help-inline">
 9 |       {% if field.errors %}
10 |         {{ field.errors|join:' ' }}
11 |       {% else %}
12 |         {{ field.help_text }}
13 |       {% endif %}
14 |       </span>
15 |     {% endif %}
16 |   </div>
17 | </div>
18 | {% endfor %}
19 | {% csrf_token %}
20 | <div style="display:none">{% for h in form.hidden_fields %} {{ h }}{% endfor %}</div>
21 | </fieldset>
22 | 


--------------------------------------------------------------------------------
/docs/Makefile:
--------------------------------------------------------------------------------
  1 | # Makefile for Sphinx documentation
  2 | #
  3 | 
  4 | # You can set these variables from the command line.
  5 | SPHINXOPTS    =
  6 | SPHINXBUILD   = sphinx-build
  7 | PAPER         =
  8 | BUILDDIR      = _build
  9 | 
 10 | # Internal variables.
 11 | PAPEROPT_a4     = -D latex_paper_size=a4
 12 | PAPEROPT_letter = -D latex_paper_size=letter
 13 | ALLSPHINXOPTS   = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
 14 | 
 15 | .PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest
 16 | 
 17 | help:
 18 | 	@echo "Please use \`make <target>' where <target> is one of"
 19 | 	@echo "  html       to make standalone HTML files"
 20 | 	@echo "  dirhtml    to make HTML files named index.html in directories"
 21 | 	@echo "  singlehtml to make a single large HTML file"
 22 | 	@echo "  pickle     to make pickle files"
 23 | 	@echo "  json       to make JSON files"
 24 | 	@echo "  htmlhelp   to make HTML files and a HTML help project"
 25 | 	@echo "  qthelp     to make HTML files and a qthelp project"
 26 | 	@echo "  devhelp    to make HTML files and a Devhelp project"
 27 | 	@echo "  epub       to make an epub"
 28 | 	@echo "  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
 29 | 	@echo "  latexpdf   to make LaTeX files and run them through pdflatex"
 30 | 	@echo "  text       to make text files"
 31 | 	@echo "  man        to make manual pages"
 32 | 	@echo "  changes    to make an overview of all changed/added/deprecated items"
 33 | 	@echo "  linkcheck  to check all external links for integrity"
 34 | 	@echo "  doctest    to run all doctests embedded in the documentation (if enabled)"
 35 | 
 36 | clean:
 37 | 	-rm -rf $(BUILDDIR)/*
 38 | 
 39 | html:
 40 | 	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
 41 | 	@echo
 42 | 	@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
 43 | 
 44 | dirhtml:
 45 | 	$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
 46 | 	@echo
 47 | 	@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
 48 | 
 49 | singlehtml:
 50 | 	$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
 51 | 	@echo
 52 | 	@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
 53 | 
 54 | pickle:
 55 | 	$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
 56 | 	@echo
 57 | 	@echo "Build finished; now you can process the pickle files."
 58 | 
 59 | json:
 60 | 	$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
 61 | 	@echo
 62 | 	@echo "Build finished; now you can process the JSON files."
 63 | 
 64 | htmlhelp:
 65 | 	$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
 66 | 	@echo
 67 | 	@echo "Build finished; now you can run HTML Help Workshop with the" \
 68 | 	      ".hhp project file in $(BUILDDIR)/htmlhelp."
 69 | 
 70 | qthelp:
 71 | 	$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
 72 | 	@echo
 73 | 	@echo "Build finished; now you can run "qcollectiongenerator" with the" \
 74 | 	      ".qhcp project file in $(BUILDDIR)/qthelp, like this:"
 75 | 	@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/flask-unittest.qhcp"
 76 | 	@echo "To view the help file:"
 77 | 	@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/flask-unittest.qhc"
 78 | 
 79 | devhelp:
 80 | 	$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
 81 | 	@echo
 82 | 	@echo "Build finished."
 83 | 	@echo "To view the help file:"
 84 | 	@echo "# mkdir -p $$HOME/.local/share/devhelp/flask-unittest"
 85 | 	@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/flask-unittest"
 86 | 	@echo "# devhelp"
 87 | 
 88 | epub:
 89 | 	$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
 90 | 	@echo
 91 | 	@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
 92 | 
 93 | latex:
 94 | 	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
 95 | 	@echo
 96 | 	@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
 97 | 	@echo "Run \`make' in that directory to run these through (pdf)latex" \
 98 | 	      "(use \`make latexpdf' here to do that automatically)."
 99 | 
100 | latexpdf:
101 | 	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
102 | 	@echo "Running LaTeX files through pdflatex..."
103 | 	make -C $(BUILDDIR)/latex all-pdf
104 | 	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
105 | 
106 | text:
107 | 	$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
108 | 	@echo
109 | 	@echo "Build finished. The text files are in $(BUILDDIR)/text."
110 | 
111 | man:
112 | 	$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
113 | 	@echo
114 | 	@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
115 | 
116 | changes:
117 | 	$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
118 | 	@echo
119 | 	@echo "The overview file is in $(BUILDDIR)/changes."
120 | 
121 | linkcheck:
122 | 	$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
123 | 	@echo
124 | 	@echo "Link check complete; look for any errors in the above output " \
125 | 	      "or in $(BUILDDIR)/linkcheck/output.txt."
126 | 
127 | doctest:
128 | 	$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
129 | 	@echo "Testing of doctests in the sources finished, look at the " \
130 | 	      "results in $(BUILDDIR)/doctest/output.txt."
131 | 


--------------------------------------------------------------------------------
/docs/_static/debugtoolbar.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/MongoEngine/django-mongoengine/298cdcf59b21fe590958f57f27bf28e7192fcc4e/docs/_static/debugtoolbar.png


--------------------------------------------------------------------------------
/docs/_themes/README:
--------------------------------------------------------------------------------
 1 | Flask Sphinx Styles
 2 | ===================
 3 | 
 4 | This repository contains sphinx styles for Flask and Flask related
 5 | projects.  To use this style in your Sphinx documentation, follow
 6 | this guide:
 7 | 
 8 | 1. put this folder as _themes into your docs folder.  Alternatively
 9 |    you can also use git submodules to check out the contents there.
10 | 2. add this to your conf.py:
11 | 
12 |    sys.path.append(os.path.abspath('_themes'))
13 |    html_theme_path = ['_themes']
14 |    html_theme = 'flask'
15 | 
16 | The following themes exist:
17 | 
18 | - 'flask' - the standard flask documentation theme for large
19 |   projects
20 | - 'flask_small' - small one-page theme.  Intended to be used by
21 |   very small addon libraries for flask.
22 | 
23 | The following options exist for the flask_small theme:
24 | 
25 |    [options]
26 |    index_logo = ''              filename of a picture in _static
27 |                                 to be used as replacement for the
28 |                                 h1 in the index.rst file.
29 |    index_logo_height = 120px    height of the index logo
30 |    github_fork = ''             repository name on github for the
31 |                                 "fork me" badge
32 | 


--------------------------------------------------------------------------------
/docs/_themes/flask/static/flasky.css_t:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * flasky.css_t
  3 |  * ~~~~~~~~~~~~
  4 |  *
  5 |  * Sphinx stylesheet -- flasky theme based on nature theme.
  6 |  *
  7 |  * :copyright: Copyright 2007-2010 by the Sphinx team, see AUTHORS.
  8 |  * :license: BSD, see LICENSE for details.
  9 |  *
 10 |  */
 11 |  
 12 | @import url("basic.css");
 13 |  
 14 | /* -- page layout ----------------------------------------------------------- */
 15 |  
 16 | body {
 17 |     font-family: 'Georgia', serif;
 18 |     font-size: 17px;
 19 |     background-color: #ddd;
 20 |     color: #000;
 21 |     margin: 0;
 22 |     padding: 0;
 23 | }
 24 | 
 25 | div.document {
 26 |     background: #fafafa;
 27 | }
 28 | 
 29 | div.documentwrapper {
 30 |     float: left;
 31 |     width: 100%;
 32 | }
 33 | 
 34 | div.bodywrapper {
 35 |     margin: 0 0 0 230px;
 36 | }
 37 | 
 38 | hr {
 39 |     border: 1px solid #B1B4B6;
 40 | }
 41 |  
 42 | div.body {
 43 |     background-color: #ffffff;
 44 |     color: #3E4349;
 45 |     padding: 0 30px 30px 30px;
 46 |     min-height: 34em;
 47 | }
 48 | 
 49 | img.floatingflask {
 50 |     padding: 0 0 10px 10px;
 51 |     float: right;
 52 | }
 53 |  
 54 | div.footer {
 55 |     position: absolute;
 56 |     right: 0;
 57 |     margin-top: -70px;
 58 |     text-align: right;
 59 |     color: #888;
 60 |     padding: 10px;
 61 |     font-size: 14px;
 62 | }
 63 |  
 64 | div.footer a {
 65 |     color: #888;
 66 |     text-decoration: underline;
 67 | }
 68 |  
 69 | div.related {
 70 |     line-height: 32px;
 71 |     color: #888;
 72 | }
 73 | 
 74 | div.related ul {
 75 |     padding: 0 0 0 10px;
 76 | }
 77 |  
 78 | div.related a {
 79 |     color: #444;
 80 | }
 81 |  
 82 | div.sphinxsidebar {
 83 |     font-size: 14px;
 84 |     line-height: 1.5;
 85 | }
 86 | 
 87 | div.sphinxsidebarwrapper {
 88 |     padding: 0 20px;
 89 | }
 90 | 
 91 | div.sphinxsidebarwrapper p.logo {
 92 |     padding: 20px 0 10px 0;
 93 |     margin: 0;
 94 |     text-align: center;
 95 | }
 96 |  
 97 | div.sphinxsidebar h3,
 98 | div.sphinxsidebar h4 {
 99 |     font-family: 'Garamond', 'Georgia', serif;
100 |     color: #222;
101 |     font-size: 24px;
102 |     font-weight: normal;
103 |     margin: 20px 0 5px 0;
104 |     padding: 0;
105 | }
106 | 
107 | div.sphinxsidebar h4 {
108 |     font-size: 20px;
109 | }
110 |  
111 | div.sphinxsidebar h3 a {
112 |     color: #444;
113 | }
114 |  
115 | div.sphinxsidebar p {
116 |     color: #555;
117 |     margin: 10px 0;
118 | }
119 |  
120 | div.sphinxsidebar ul {
121 |     margin: 10px 0;
122 |     padding: 0;
123 |     color: #000;
124 | }
125 |  
126 | div.sphinxsidebar a {
127 |     color: #444;
128 |     text-decoration: none;
129 | }
130 | 
131 | div.sphinxsidebar a:hover {
132 |     text-decoration: underline;
133 | }
134 |  
135 | div.sphinxsidebar input {
136 |     border: 1px solid #ccc;
137 |     font-family: 'Georgia', serif;
138 |     font-size: 1em;
139 | }
140 |  
141 | /* -- body styles ----------------------------------------------------------- */
142 |  
143 | a {
144 |     color: #004B6B;
145 |     text-decoration: underline;
146 | }
147 |  
148 | a:hover {
149 |     color: #6D4100;
150 |     text-decoration: underline;
151 | }
152 | 
153 | div.body {
154 |     padding-bottom: 40px; /* saved for footer */
155 | }
156 |  
157 | div.body h1,
158 | div.body h2,
159 | div.body h3,
160 | div.body h4,
161 | div.body h5,
162 | div.body h6 {
163 |     font-family: 'Garamond', 'Georgia', serif;
164 |     font-weight: normal;
165 |     margin: 30px 0px 10px 0px;
166 |     padding: 0;
167 | }
168 |  
169 | div.body h1 { margin-top: 0; padding-top: 20px; font-size: 240%; }
170 | div.body h2 { font-size: 180%; }
171 | div.body h3 { font-size: 150%; }
172 | div.body h4 { font-size: 130%; }
173 | div.body h5 { font-size: 100%; }
174 | div.body h6 { font-size: 100%; }
175 |  
176 | a.headerlink {
177 |     color: white;
178 |     padding: 0 4px;
179 |     text-decoration: none;
180 | }
181 |  
182 | a.headerlink:hover {
183 |     color: #444;
184 |     background: #eaeaea;
185 | }
186 |  
187 | div.body p, div.body dd, div.body li {
188 |     line-height: 1.4em;
189 | }
190 | 
191 | div.admonition {
192 |     background: #fafafa;
193 |     margin: 20px -30px;
194 |     padding: 10px 30px;
195 |     border-top: 1px solid #ccc;
196 |     border-bottom: 1px solid #ccc;
197 | }
198 | 
199 | div.admonition p.admonition-title {
200 |     font-family: 'Garamond', 'Georgia', serif;
201 |     font-weight: normal;
202 |     font-size: 24px;
203 |     margin: 0 0 10px 0;
204 |     padding: 0;
205 |     line-height: 1;
206 | }
207 | 
208 | div.admonition p.last {
209 |     margin-bottom: 0;
210 | }
211 | 
212 | div.highlight{
213 |     background-color: white;
214 | }
215 | 
216 | dt:target, .highlight {
217 |     background: #FAF3E8;
218 | }
219 | 
220 | div.note {
221 |     background-color: #eee;
222 |     border: 1px solid #ccc;
223 | }
224 |  
225 | div.seealso {
226 |     background-color: #ffc;
227 |     border: 1px solid #ff6;
228 | }
229 |  
230 | div.topic {
231 |     background-color: #eee;
232 | }
233 |  
234 | div.warning {
235 |     background-color: #ffe4e4;
236 |     border: 1px solid #f66;
237 | }
238 |  
239 | p.admonition-title {
240 |     display: inline;
241 | }
242 |  
243 | p.admonition-title:after {
244 |     content: ":";
245 | }
246 | 
247 | pre, tt {
248 |     font-family: 'Consolas', 'Menlo', 'Deja Vu Sans Mono', 'Bitstream Vera Sans Mono', monospace;
249 |     font-size: 0.9em;
250 | }
251 | 
252 | img.screenshot {
253 | }
254 | 
255 | tt.descname, tt.descclassname {
256 |     font-size: 0.95em;
257 | }
258 | 
259 | tt.descname {
260 |     padding-right: 0.08em;
261 | }
262 | 
263 | img.screenshot {
264 |     -moz-box-shadow: 2px 2px 4px #eee;
265 |     -webkit-box-shadow: 2px 2px 4px #eee;
266 |     box-shadow: 2px 2px 4px #eee;
267 | }
268 | 
269 | table.docutils {
270 |     border: 1px solid #888;
271 |     -moz-box-shadow: 2px 2px 4px #eee;
272 |     -webkit-box-shadow: 2px 2px 4px #eee;
273 |     box-shadow: 2px 2px 4px #eee;
274 | }
275 | 
276 | table.docutils td, table.docutils th {
277 |     border: 1px solid #888;
278 |     padding: 0.25em 0.7em;
279 | }
280 | 
281 | table.field-list, table.footnote {
282 |     border: none;
283 |     -moz-box-shadow: none;
284 |     -webkit-box-shadow: none;
285 |     box-shadow: none;
286 | }
287 | 
288 | table.footnote {
289 |     margin: 15px 0;
290 |     width: 100%;
291 |     border: 1px solid #eee;
292 | }
293 | 
294 | table.field-list th {
295 |     padding: 0 0.8em 0 0;
296 | }
297 | 
298 | table.field-list td {
299 |     padding: 0;
300 | }
301 | 
302 | table.footnote td {
303 |     padding: 0.5em;
304 | }
305 | 
306 | dl {
307 |     margin: 0;
308 |     padding: 0;
309 | }
310 | 
311 | dl dd {
312 |     margin-left: 30px;
313 | }
314 |  
315 | pre {
316 |     background: #eee;
317 |     padding: 7px 30px;
318 |     margin: 15px -30px;
319 |     line-height: 1.3em;
320 | }
321 | 
322 | dl pre {
323 |     margin-left: -60px;
324 |     padding-left: 60px;
325 | }
326 | 
327 | dl dl pre {
328 |     margin-left: -90px;
329 |     padding-left: 90px;
330 | }
331 |  
332 | tt {
333 |     background-color: #ecf0f3;
334 |     color: #222;
335 |     /* padding: 1px 2px; */
336 | }
337 | 
338 | tt.xref, a tt {
339 |     background-color: #FBFBFB;
340 |     text-decoration: none!important;
341 | }
342 | 
343 | a:hover tt {
344 |     background: #EEE;
345 | }
346 | 


--------------------------------------------------------------------------------
/docs/_themes/flask/theme.conf:
--------------------------------------------------------------------------------
1 | [theme]
2 | inherit = basic
3 | stylesheet = flasky.css
4 | pygments_style = flask_theme_support.FlaskyStyle
5 | 


--------------------------------------------------------------------------------
/docs/_themes/flask_small/layout.html:
--------------------------------------------------------------------------------
 1 | {% extends "basic/layout.html" %}
 2 | {% block header %}
 3 |   {{ super() }}
 4 |   {% if pagename == 'index' %}
 5 |   <div class=indexwrapper>
 6 |   {% endif %}
 7 | {% endblock %}
 8 | {% block footer %}
 9 |   {% if pagename == 'index' %}
10 |   </div>
11 |   {% endif %}
12 | {% endblock %}
13 | {# do not display relbars #}
14 | {% block relbar1 %}{% endblock %}
15 | {% block relbar2 %}
16 |   {% if theme_github_fork %}
17 |     <a href="http://github.com/{{ theme_github_fork }}"><img style="position: fixed; top: 0; right: 0; border: 0;"
18 |     src="http://s3.amazonaws.com/github/ribbons/forkme_right_darkblue_121621.png" alt="Fork me on GitHub" /></a>
19 |   {% endif %}
20 | {% endblock %}
21 | {% block sidebar1 %}{% endblock %}
22 | {% block sidebar2 %}{% endblock %}
23 | 


--------------------------------------------------------------------------------
/docs/_themes/flask_small/static/flasky.css_t:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * flasky.css_t
  3 |  * ~~~~~~~~~~~~
  4 |  *
  5 |  * Sphinx stylesheet -- flasky theme based on nature theme.
  6 |  *
  7 |  * :copyright: Copyright 2007-2010 by the Sphinx team, see AUTHORS.
  8 |  * :license: BSD, see LICENSE for details.
  9 |  *
 10 |  */
 11 |  
 12 | @import url("basic.css");
 13 |  
 14 | /* -- page layout ----------------------------------------------------------- */
 15 |  
 16 | body {
 17 |     font-family: 'Georgia', serif;
 18 |     font-size: 17px;
 19 |     color: #000;
 20 |     background: white;
 21 |     margin: 0;
 22 |     padding: 0;
 23 | }
 24 | 
 25 | div.documentwrapper {
 26 |     float: left;
 27 |     width: 100%;
 28 | }
 29 | 
 30 | div.bodywrapper {
 31 |     margin: 40px auto 0 auto;
 32 |     width: 700px;
 33 | }
 34 | 
 35 | hr {
 36 |     border: 1px solid #B1B4B6;
 37 | }
 38 |  
 39 | div.body {
 40 |     background-color: #ffffff;
 41 |     color: #3E4349;
 42 |     padding: 0 30px 30px 30px;
 43 | }
 44 | 
 45 | img.floatingflask {
 46 |     padding: 0 0 10px 10px;
 47 |     float: right;
 48 | }
 49 |  
 50 | div.footer {
 51 |     text-align: right;
 52 |     color: #888;
 53 |     padding: 10px;
 54 |     font-size: 14px;
 55 |     width: 650px;
 56 |     margin: 0 auto 40px auto;
 57 | }
 58 |  
 59 | div.footer a {
 60 |     color: #888;
 61 |     text-decoration: underline;
 62 | }
 63 |  
 64 | div.related {
 65 |     line-height: 32px;
 66 |     color: #888;
 67 | }
 68 | 
 69 | div.related ul {
 70 |     padding: 0 0 0 10px;
 71 | }
 72 |  
 73 | div.related a {
 74 |     color: #444;
 75 | }
 76 |  
 77 | /* -- body styles ----------------------------------------------------------- */
 78 |  
 79 | a {
 80 |     color: #004B6B;
 81 |     text-decoration: underline;
 82 | }
 83 |  
 84 | a:hover {
 85 |     color: #6D4100;
 86 |     text-decoration: underline;
 87 | }
 88 | 
 89 | div.body {
 90 |     padding-bottom: 40px; /* saved for footer */
 91 | }
 92 |  
 93 | div.body h1,
 94 | div.body h2,
 95 | div.body h3,
 96 | div.body h4,
 97 | div.body h5,
 98 | div.body h6 {
 99 |     font-family: 'Garamond', 'Georgia', serif;
100 |     font-weight: normal;
101 |     margin: 30px 0px 10px 0px;
102 |     padding: 0;
103 | }
104 | 
105 | {% if theme_index_logo %}
106 | div.indexwrapper h1 {
107 |     text-indent: -999999px;
108 |     background: url({{ theme_index_logo }}) no-repeat center center;
109 |     height: {{ theme_index_logo_height }};
110 | }
111 | {% endif %}
112 |  
113 | div.body h2 { font-size: 180%; }
114 | div.body h3 { font-size: 150%; }
115 | div.body h4 { font-size: 130%; }
116 | div.body h5 { font-size: 100%; }
117 | div.body h6 { font-size: 100%; }
118 |  
119 | a.headerlink {
120 |     color: white;
121 |     padding: 0 4px;
122 |     text-decoration: none;
123 | }
124 |  
125 | a.headerlink:hover {
126 |     color: #444;
127 |     background: #eaeaea;
128 | }
129 |  
130 | div.body p, div.body dd, div.body li {
131 |     line-height: 1.4em;
132 | }
133 | 
134 | div.admonition {
135 |     background: #fafafa;
136 |     margin: 20px -30px;
137 |     padding: 10px 30px;
138 |     border-top: 1px solid #ccc;
139 |     border-bottom: 1px solid #ccc;
140 | }
141 | 
142 | div.admonition p.admonition-title {
143 |     font-family: 'Garamond', 'Georgia', serif;
144 |     font-weight: normal;
145 |     font-size: 24px;
146 |     margin: 0 0 10px 0;
147 |     padding: 0;
148 |     line-height: 1;
149 | }
150 | 
151 | div.admonition p.last {
152 |     margin-bottom: 0;
153 | }
154 | 
155 | div.highlight{
156 |     background-color: white;
157 | }
158 | 
159 | dt:target, .highlight {
160 |     background: #FAF3E8;
161 | }
162 | 
163 | div.note {
164 |     background-color: #eee;
165 |     border: 1px solid #ccc;
166 | }
167 |  
168 | div.seealso {
169 |     background-color: #ffc;
170 |     border: 1px solid #ff6;
171 | }
172 |  
173 | div.topic {
174 |     background-color: #eee;
175 | }
176 |  
177 | div.warning {
178 |     background-color: #ffe4e4;
179 |     border: 1px solid #f66;
180 | }
181 |  
182 | p.admonition-title {
183 |     display: inline;
184 | }
185 |  
186 | p.admonition-title:after {
187 |     content: ":";
188 | }
189 | 
190 | pre, tt {
191 |     font-family: 'Consolas', 'Menlo', 'Deja Vu Sans Mono', 'Bitstream Vera Sans Mono', monospace;
192 |     font-size: 0.85em;
193 | }
194 | 
195 | img.screenshot {
196 | }
197 | 
198 | tt.descname, tt.descclassname {
199 |     font-size: 0.95em;
200 | }
201 | 
202 | tt.descname {
203 |     padding-right: 0.08em;
204 | }
205 | 
206 | img.screenshot {
207 |     -moz-box-shadow: 2px 2px 4px #eee;
208 |     -webkit-box-shadow: 2px 2px 4px #eee;
209 |     box-shadow: 2px 2px 4px #eee;
210 | }
211 | 
212 | table.docutils {
213 |     border: 1px solid #888;
214 |     -moz-box-shadow: 2px 2px 4px #eee;
215 |     -webkit-box-shadow: 2px 2px 4px #eee;
216 |     box-shadow: 2px 2px 4px #eee;
217 | }
218 | 
219 | table.docutils td, table.docutils th {
220 |     border: 1px solid #888;
221 |     padding: 0.25em 0.7em;
222 | }
223 | 
224 | table.field-list, table.footnote {
225 |     border: none;
226 |     -moz-box-shadow: none;
227 |     -webkit-box-shadow: none;
228 |     box-shadow: none;
229 | }
230 | 
231 | table.footnote {
232 |     margin: 15px 0;
233 |     width: 100%;
234 |     border: 1px solid #eee;
235 | }
236 | 
237 | table.field-list th {
238 |     padding: 0 0.8em 0 0;
239 | }
240 | 
241 | table.field-list td {
242 |     padding: 0;
243 | }
244 | 
245 | table.footnote td {
246 |     padding: 0.5em;
247 | }
248 | 
249 | dl {
250 |     margin: 0;
251 |     padding: 0;
252 | }
253 | 
254 | dl dd {
255 |     margin-left: 30px;
256 | }
257 |  
258 | pre {
259 |     padding: 0;
260 |     margin: 15px -30px;
261 |     padding: 8px;
262 |     line-height: 1.3em;
263 |     padding: 7px 30px;
264 |     background: #eee;
265 |     border-radius: 2px;
266 |     -moz-border-radius: 2px;
267 |     -webkit-border-radius: 2px;
268 | }
269 | 
270 | dl pre {
271 |     margin-left: -60px;
272 |     padding-left: 60px;
273 | }
274 | 
275 | tt {
276 |     background-color: #ecf0f3;
277 |     color: #222;
278 |     /* padding: 1px 2px; */
279 | }
280 | 
281 | tt.xref, a tt {
282 |     background-color: #FBFBFB;
283 | }
284 | 
285 | a:hover tt {
286 |     background: #EEE;
287 | }
288 | 


--------------------------------------------------------------------------------
/docs/_themes/flask_small/theme.conf:
--------------------------------------------------------------------------------
 1 | [theme]
 2 | inherit = basic
 3 | stylesheet = flasky.css
 4 | nosidebar = true
 5 | pygments_style = flask_theme_support.FlaskyStyle
 6 | 
 7 | [options]
 8 | index_logo = ''
 9 | index_logo_height = 120px
10 | github_fork = ''
11 | 


--------------------------------------------------------------------------------
/docs/_themes/flask_theme_support.py:
--------------------------------------------------------------------------------
 1 | # flasky extensions.  flasky pygments style based on tango style
 2 | from pygments.style import Style
 3 | from pygments.token import (
 4 |     Comment,
 5 |     Error,
 6 |     Generic,
 7 |     Keyword,
 8 |     Literal,
 9 |     Name,
10 |     Number,
11 |     Operator,
12 |     Other,
13 |     Punctuation,
14 |     String,
15 |     Whitespace,
16 | )
17 | 
18 | 
19 | class FlaskyStyle(Style):
20 |     background_color = "#f8f8f8"
21 |     default_style = ""
22 | 
23 |     styles = {
24 |         # No corresponding class for the following:
25 |         # Text:                     "", # class:  ''
26 |         Whitespace: "underline #f8f8f8",  # class: 'w'
27 |         Error: "#a40000 border:#ef2929",  # class: 'err'
28 |         Other: "#000000",  # class 'x'
29 |         Comment: "italic #8f5902",  # class: 'c'
30 |         Comment.Preproc: "noitalic",  # class: 'cp'
31 |         Keyword: "bold #004461",  # class: 'k'
32 |         Keyword.Constant: "bold #004461",  # class: 'kc'
33 |         Keyword.Declaration: "bold #004461",  # class: 'kd'
34 |         Keyword.Namespace: "bold #004461",  # class: 'kn'
35 |         Keyword.Pseudo: "bold #004461",  # class: 'kp'
36 |         Keyword.Reserved: "bold #004461",  # class: 'kr'
37 |         Keyword.Type: "bold #004461",  # class: 'kt'
38 |         Operator: "#582800",  # class: 'o'
39 |         Operator.Word: "bold #004461",  # class: 'ow' - like keywords
40 |         Punctuation: "bold #000000",  # class: 'p'
41 |         # because special names such as Name.Class, Name.Function, etc.
42 |         # are not recognized as such later in the parsing, we choose them
43 |         # to look the same as ordinary variables.
44 |         Name: "#000000",  # class: 'n'
45 |         Name.Attribute: "#c4a000",  # class: 'na' - to be revised
46 |         Name.Builtin: "#004461",  # class: 'nb'
47 |         Name.Builtin.Pseudo: "#3465a4",  # class: 'bp'
48 |         Name.Class: "#000000",  # class: 'nc' - to be revised
49 |         Name.Constant: "#000000",  # class: 'no' - to be revised
50 |         Name.Decorator: "#888",  # class: 'nd' - to be revised
51 |         Name.Entity: "#ce5c00",  # class: 'ni'
52 |         Name.Exception: "bold #cc0000",  # class: 'ne'
53 |         Name.Function: "#000000",  # class: 'nf'
54 |         Name.Property: "#000000",  # class: 'py'
55 |         Name.Label: "#f57900",  # class: 'nl'
56 |         Name.Namespace: "#000000",  # class: 'nn' - to be revised
57 |         Name.Other: "#000000",  # class: 'nx'
58 |         Name.Tag: "bold #004461",  # class: 'nt' - like a keyword
59 |         Name.Variable: "#000000",  # class: 'nv' - to be revised
60 |         Name.Variable.Class: "#000000",  # class: 'vc' - to be revised
61 |         Name.Variable.Global: "#000000",  # class: 'vg' - to be revised
62 |         Name.Variable.Instance: "#000000",  # class: 'vi' - to be revised
63 |         Number: "#990000",  # class: 'm'
64 |         Literal: "#000000",  # class: 'l'
65 |         Literal.Date: "#000000",  # class: 'ld'
66 |         String: "#4e9a06",  # class: 's'
67 |         String.Backtick: "#4e9a06",  # class: 'sb'
68 |         String.Char: "#4e9a06",  # class: 'sc'
69 |         String.Doc: "italic #8f5902",  # class: 'sd' - like a comment
70 |         String.Double: "#4e9a06",  # class: 's2'
71 |         String.Escape: "#4e9a06",  # class: 'se'
72 |         String.Heredoc: "#4e9a06",  # class: 'sh'
73 |         String.Interpol: "#4e9a06",  # class: 'si'
74 |         String.Other: "#4e9a06",  # class: 'sx'
75 |         String.Regex: "#4e9a06",  # class: 'sr'
76 |         String.Single: "#4e9a06",  # class: 's1'
77 |         String.Symbol: "#4e9a06",  # class: 'ss'
78 |         Generic: "#000000",  # class: 'g'
79 |         Generic.Deleted: "#a40000",  # class: 'gd'
80 |         Generic.Emph: "italic #000000",  # class: 'ge'
81 |         Generic.Error: "#ef2929",  # class: 'gr'
82 |         Generic.Heading: "bold #000080",  # class: 'gh'
83 |         Generic.Inserted: "#00A000",  # class: 'gi'
84 |         Generic.Output: "#888",  # class: 'go'
85 |         Generic.Prompt: "#745334",  # class: 'gp'
86 |         Generic.Strong: "bold #000000",  # class: 'gs'
87 |         Generic.Subheading: "bold #800080",  # class: 'gu'
88 |         Generic.Traceback: "bold #a40000",  # class: 'gt'
89 |     }
90 | 


--------------------------------------------------------------------------------
/docs/changelog.rst:
--------------------------------------------------------------------------------
 1 | =========
 2 | Changelog
 3 | =========
 4 | 
 5 | 
 6 | Changes in -master-
 7 | ===================
 8 | * working sessions
 9 | * forms?
10 | * added support for embedded fields
11 | 
12 | 
13 | Changes in 0.1
14 | ===============
15 | 
16 | * Released to PyPi
17 | 


--------------------------------------------------------------------------------
/docs/conf.py:
--------------------------------------------------------------------------------
  1 | #
  2 | # This file is execfile()d with the current directory set to its containing dir.
  3 | #
  4 | # Note that not all possible configuration values are present in this
  5 | # autogenerated file.
  6 | #
  7 | # All configuration values have a default; values that are commented out
  8 | # serve to show the default.
  9 | 
 10 | import os
 11 | import sys
 12 | 
 13 | # If extensions (or modules to document with autodoc) are in another directory,
 14 | # add these directories to sys.path here. If the directory is relative to the
 15 | # documentation root, use os.path.abspath to make it absolute, like shown here.
 16 | sys.path.append(os.path.abspath("_themes"))
 17 | 
 18 | # -- General configuration -----------------------------------------------------
 19 | 
 20 | # If your documentation needs a minimal Sphinx version, state it here.
 21 | # needs_sphinx = '1.0'
 22 | 
 23 | # Add any Sphinx extension module names here, as strings. They can be extensions
 24 | # coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
 25 | extensions = ["sphinx.ext.autodoc", "sphinx.ext.intersphinx"]
 26 | 
 27 | # Add any paths that contain templates here, relative to this directory.
 28 | templates_path = ["_templates"]
 29 | 
 30 | # The suffix of source filenames.
 31 | source_suffix = ".rst"
 32 | 
 33 | # The encoding of source files.
 34 | # source_encoding = 'utf-8-sig'
 35 | 
 36 | # The master toctree document.
 37 | master_doc = "index"
 38 | 
 39 | # General information about the project.
 40 | project = "Django-MongoEngine"
 41 | copyright = "2011-2013, MongoEngine"
 42 | 
 43 | # The version info for the project you're documenting, acts as replacement for
 44 | # |version| and |release|, also used in various other places throughout the
 45 | # built documents.
 46 | #
 47 | # The short X.Y version.
 48 | version = "0.1"
 49 | # The full version, including alpha/beta/rc tags.
 50 | release = "0.1"
 51 | 
 52 | # The language for content autogenerated by Sphinx. Refer to documentation
 53 | # for a list of supported languages.
 54 | # language = None
 55 | 
 56 | # There are two options for replacing |today|: either, you set today to some
 57 | # non-false value, then it is used:
 58 | # today = ''
 59 | # Else, today_fmt is used as the format for a strftime call.
 60 | # today_fmt = '%B %d, %Y'
 61 | 
 62 | # List of patterns, relative to source directory, that match files and
 63 | # directories to ignore when looking for source files.
 64 | exclude_patterns = ["_build"]
 65 | 
 66 | # The reST default role (used for this markup: `text`) to use for all documents.
 67 | # default_role = None
 68 | 
 69 | # If true, '()' will be appended to :func: etc. cross-reference text.
 70 | # add_function_parentheses = True
 71 | 
 72 | # If true, the current module name will be prepended to all description
 73 | # unit titles (such as .. function::).
 74 | # add_module_names = True
 75 | 
 76 | # If true, sectionauthor and moduleauthor directives will be shown in the
 77 | # output. They are ignored by default.
 78 | # show_authors = False
 79 | 
 80 | # The name of the Pygments (syntax highlighting) style to use.
 81 | # pygments_style = 'sphinx'
 82 | 
 83 | # A list of ignored prefixes for module index sorting.
 84 | # modindex_common_prefix = []
 85 | 
 86 | 
 87 | # -- Options for HTML output ---------------------------------------------------
 88 | 
 89 | # The theme to use for HTML and HTML Help pages.  See the documentation for
 90 | # a list of builtin themes.
 91 | html_theme = "flask_small"
 92 | 
 93 | html_theme_options = {"index_logo": "", "github_fork": None}
 94 | # Theme options are theme-specific and customize the look and feel of a theme
 95 | # further.  For a list of options available for each theme, see the
 96 | # documentation.
 97 | # html_theme_options = {}
 98 | 
 99 | # Add any paths that contain custom themes here, relative to this directory.
100 | html_theme_path = ["_themes"]
101 | 
102 | # The name for this set of Sphinx documents.  If None, it defaults to
103 | # "<project> v<release> documentation".
104 | # html_title = None
105 | 
106 | # A shorter title for the navigation bar.  Default is the same as html_title.
107 | # html_short_title = None
108 | 
109 | # The name of an image file (relative to this directory) to place at the top
110 | # of the sidebar.
111 | # html_logo = None
112 | 
113 | # The name of an image file (within the static path) to use as favicon of the
114 | # docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
115 | # pixels large.
116 | # html_favicon = None
117 | 
118 | # Add any paths that contain custom static files (such as style sheets) here,
119 | # relative to this directory. They are copied after the builtin static files,
120 | # so a file named "default.css" will overwrite the builtin "default.css".
121 | html_static_path = ["_static"]
122 | 
123 | # If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
124 | # using the given strftime format.
125 | # html_last_updated_fmt = '%b %d, %Y'
126 | 
127 | # If true, SmartyPants will be used to convert quotes and dashes to
128 | # typographically correct entities.
129 | # html_use_smartypants = True
130 | 
131 | # Custom sidebar templates, maps document names to template names.
132 | # html_sidebars = {}
133 | 
134 | # Additional templates that should be rendered to pages, maps page names to
135 | # template names.
136 | # html_additional_pages = {}
137 | 
138 | # If false, no module index is generated.
139 | # html_domain_indices = True
140 | 
141 | # If false, no index is generated.
142 | # html_use_index = True
143 | 
144 | # If true, the index is split into individual pages for each letter.
145 | # html_split_index = False
146 | 
147 | # If true, links to the reST sources are added to the pages.
148 | # html_show_sourcelink = True
149 | 
150 | # If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
151 | # html_show_sphinx = True
152 | 
153 | # If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
154 | # html_show_copyright = True
155 | 
156 | # If true, an OpenSearch description file will be output, and all pages will
157 | # contain a <link> tag referring to it.  The value of this option must be the
158 | # base URL from which the finished HTML is served.
159 | # html_use_opensearch = ''
160 | 
161 | # If nonempty, this is the file name suffix for HTML files (e.g. ".xhtml").
162 | # html_file_suffix = ''
163 | 
164 | # Output file base name for HTML help builder.
165 | htmlhelp_basename = "django-mongoenginedoc"
166 | 
167 | 
168 | # -- Options for LaTeX output --------------------------------------------------
169 | 
170 | # The paper size ('letter' or 'a4').
171 | # latex_paper_size = 'letter'
172 | 
173 | # The font size ('10pt', '11pt' or '12pt').
174 | # latex_font_size = '10pt'
175 | 
176 | # Grouping the document tree into LaTeX files. List of tuples
177 | # (source start file, target name, title, author, documentclass [howto/manual]).
178 | latex_documents = [
179 |     (
180 |         "index",
181 |         "django-mongoengine.tex",
182 |         "Django-MongoEngine Documentation",
183 |         "Ross Lawley",
184 |         "manual",
185 |     ),
186 | ]
187 | 
188 | # The name of an image file (relative to this directory) to place at the top of
189 | # the title page.
190 | # latex_logo = None
191 | 
192 | # For "manual" documents, if this is true, then toplevel headings are parts,
193 | # not chapters.
194 | # latex_use_parts = False
195 | 
196 | # If true, show page references after internal links.
197 | # latex_show_pagerefs = False
198 | 
199 | # If true, show URL addresses after external links.
200 | # latex_show_urls = False
201 | 
202 | # Additional stuff for the LaTeX preamble.
203 | # latex_preamble = ''
204 | 
205 | # Documents to append as an appendix to all manuals.
206 | # latex_appendices = []
207 | 
208 | # If false, no module index is generated.
209 | # latex_domain_indices = True
210 | 
211 | 
212 | # -- Options for manual page output --------------------------------------------
213 | 
214 | # One entry per manual page. List of tuples
215 | # (source start file, name, description, authors, manual section).
216 | man_pages = [
217 |     ("index", "django-mongoengine", "Django-MongoEngine Documentation", ["Ross Lawley"], 1)
218 | ]
219 | 


--------------------------------------------------------------------------------
/docs/examples.rst:
--------------------------------------------------------------------------------
 1 | =========
 2 | Examples
 3 | =========
 4 | 
 5 | Embedded Fields
 6 | ===============
 7 | **models.py**::
 8 | 
 9 |     from django.db import models
10 |     from django_mongoengine import Document, EmbeddedDocument, fields
11 | 
12 |     class Product(Document):
13 |         name = fields.StringField()
14 |         retail_price = fields.DecimalField(
15 |             max_digits=15, decimal_places=2, default=0)
16 |         inventory_price = fields.DecimalField(
17 |             max_digits=15, decimal_places=2, default=0)
18 | 
19 |     class ContactInfo(EmbeddedDocument):
20 |         web = fields.URLField(help_text=_("""List of languages for your application (the first one will be the default language)"""))
21 |         email = fields.EmailField(verbose_name=_('e-mail address'))
22 |         phone = fields.StringField(verbose_name=_('phone number'))
23 | 
24 |     class Application(Document):
25 |         name = fields.StringField(max_length=255, required=True)
26 |         contact = fields.EmbeddedDocumentField(ContactInfo)
27 |         LOCALES = (('es', 'Spanish'), ('en', 'English'), ('de', 'German'), ('fr', 'French'), ('it', 'Italian'), ('ru', 'Russian'))
28 |         locales = fields.ListField(fields.StringField(choices=LOCALES), help_text=_("""List of languages for your application (the first one will be the default language)"""))
29 | 
30 | 
31 | **forms.py**::
32 | 
33 |     class ContactInfoForm(DocumentForm):
34 |         class Meta:
35 |             document = ContactInfo
36 |             widgets = {
37 |                 'web': URLInput(attrs={'class': 'form-control'}),
38 |                 'email': EmailInput(attrs={'class': 'form-control'}),
39 |                 'phone': TextInput(attrs={'class': 'form-control'})
40 |             }
41 | 
42 |     class ApplicationForm(DocumentForm):
43 |         contact = forms.fields.EmbeddedDocumentField(ContactInfoForm)
44 |         class Meta:
45 |             document = Application
46 |             fields = ('name', 'locales', 'contact')
47 |             widgets = {
48 |                 'name': TextInput(attrs={'class': 'form-control', 'required': 'required'}),
49 |                 'locales':  SelectMultiple(attrs={'class': 'form-control chosen-select', 'required': 'required'})
50 |             }
51 | 


--------------------------------------------------------------------------------
/docs/index.rst:
--------------------------------------------------------------------------------
 1 | Django-MongoEngine
 2 | ==================
 3 | 
 4 | A Django extension that provides integration with `MongoEngine <http://mongoengine.org/>`_.
 5 | 
 6 | It provides Forms support for your models.
 7 | 
 8 | 
 9 | Quick links
10 | ===========
11 | 
12 | .. toctree::
13 |     :maxdepth: 1
14 | 
15 |     changelog.rst
16 |     examples.rst
17 | 
18 | 
19 | Installing Django-MongoEngine
20 | =============================
21 | 
22 | Install with **pip**
23 | 
24 | ::
25 | 
26 |     pip install django-mongoengine
27 | 
28 | 
29 | Configuration
30 | =============
31 | 
32 | Basic setup is easy, just fetch the extension
33 | 
34 | ::
35 |     TODO - write the docs
36 | 
37 | 
38 | Django DebugToolBar
39 | ===================
40 | 
41 | Taken from: https://github.com/hmarr/django-debug-toolbar-mongo
42 | 


--------------------------------------------------------------------------------
/docs/make.bat:
--------------------------------------------------------------------------------
  1 | @ECHO OFF
  2 | 
  3 | REM Command file for Sphinx documentation
  4 | 
  5 | if "%SPHINXBUILD%" == "" (
  6 | 	set SPHINXBUILD=sphinx-build
  7 | )
  8 | set BUILDDIR=_build
  9 | set ALLSPHINXOPTS=-d %BUILDDIR%/doctrees %SPHINXOPTS% .
 10 | if NOT "%PAPER%" == "" (
 11 | 	set ALLSPHINXOPTS=-D latex_paper_size=%PAPER% %ALLSPHINXOPTS%
 12 | )
 13 | 
 14 | if "%1" == "" goto help
 15 | 
 16 | if "%1" == "help" (
 17 | 	:help
 18 | 	echo.Please use `make ^<target^>` where ^<target^> is one of
 19 | 	echo.  html       to make standalone HTML files
 20 | 	echo.  dirhtml    to make HTML files named index.html in directories
 21 | 	echo.  singlehtml to make a single large HTML file
 22 | 	echo.  pickle     to make pickle files
 23 | 	echo.  json       to make JSON files
 24 | 	echo.  htmlhelp   to make HTML files and a HTML help project
 25 | 	echo.  qthelp     to make HTML files and a qthelp project
 26 | 	echo.  devhelp    to make HTML files and a Devhelp project
 27 | 	echo.  epub       to make an epub
 28 | 	echo.  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter
 29 | 	echo.  text       to make text files
 30 | 	echo.  man        to make manual pages
 31 | 	echo.  changes    to make an overview over all changed/added/deprecated items
 32 | 	echo.  linkcheck  to check all external links for integrity
 33 | 	echo.  doctest    to run all doctests embedded in the documentation if enabled
 34 | 	goto end
 35 | )
 36 | 
 37 | if "%1" == "clean" (
 38 | 	for /d %%i in (%BUILDDIR%\*) do rmdir /q /s %%i
 39 | 	del /q /s %BUILDDIR%\*
 40 | 	goto end
 41 | )
 42 | 
 43 | if "%1" == "html" (
 44 | 	%SPHINXBUILD% -b html %ALLSPHINXOPTS% %BUILDDIR%/html
 45 | 	echo.
 46 | 	echo.Build finished. The HTML pages are in %BUILDDIR%/html.
 47 | 	goto end
 48 | )
 49 | 
 50 | if "%1" == "dirhtml" (
 51 | 	%SPHINXBUILD% -b dirhtml %ALLSPHINXOPTS% %BUILDDIR%/dirhtml
 52 | 	echo.
 53 | 	echo.Build finished. The HTML pages are in %BUILDDIR%/dirhtml.
 54 | 	goto end
 55 | )
 56 | 
 57 | if "%1" == "singlehtml" (
 58 | 	%SPHINXBUILD% -b singlehtml %ALLSPHINXOPTS% %BUILDDIR%/singlehtml
 59 | 	echo.
 60 | 	echo.Build finished. The HTML pages are in %BUILDDIR%/singlehtml.
 61 | 	goto end
 62 | )
 63 | 
 64 | if "%1" == "pickle" (
 65 | 	%SPHINXBUILD% -b pickle %ALLSPHINXOPTS% %BUILDDIR%/pickle
 66 | 	echo.
 67 | 	echo.Build finished; now you can process the pickle files.
 68 | 	goto end
 69 | )
 70 | 
 71 | if "%1" == "json" (
 72 | 	%SPHINXBUILD% -b json %ALLSPHINXOPTS% %BUILDDIR%/json
 73 | 	echo.
 74 | 	echo.Build finished; now you can process the JSON files.
 75 | 	goto end
 76 | )
 77 | 
 78 | if "%1" == "htmlhelp" (
 79 | 	%SPHINXBUILD% -b htmlhelp %ALLSPHINXOPTS% %BUILDDIR%/htmlhelp
 80 | 	echo.
 81 | 	echo.Build finished; now you can run HTML Help Workshop with the ^
 82 | .hhp project file in %BUILDDIR%/htmlhelp.
 83 | 	goto end
 84 | )
 85 | 
 86 | if "%1" == "qthelp" (
 87 | 	%SPHINXBUILD% -b qthelp %ALLSPHINXOPTS% %BUILDDIR%/qthelp
 88 | 	echo.
 89 | 	echo.Build finished; now you can run "qcollectiongenerator" with the ^
 90 | .qhcp project file in %BUILDDIR%/qthelp, like this:
 91 | 	echo.^> qcollectiongenerator %BUILDDIR%\qthelp\flask-unittest.qhcp
 92 | 	echo.To view the help file:
 93 | 	echo.^> assistant -collectionFile %BUILDDIR%\qthelp\flask-unittest.ghc
 94 | 	goto end
 95 | )
 96 | 
 97 | if "%1" == "devhelp" (
 98 | 	%SPHINXBUILD% -b devhelp %ALLSPHINXOPTS% %BUILDDIR%/devhelp
 99 | 	echo.
100 | 	echo.Build finished.
101 | 	goto end
102 | )
103 | 
104 | if "%1" == "epub" (
105 | 	%SPHINXBUILD% -b epub %ALLSPHINXOPTS% %BUILDDIR%/epub
106 | 	echo.
107 | 	echo.Build finished. The epub file is in %BUILDDIR%/epub.
108 | 	goto end
109 | )
110 | 
111 | if "%1" == "latex" (
112 | 	%SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex
113 | 	echo.
114 | 	echo.Build finished; the LaTeX files are in %BUILDDIR%/latex.
115 | 	goto end
116 | )
117 | 
118 | if "%1" == "text" (
119 | 	%SPHINXBUILD% -b text %ALLSPHINXOPTS% %BUILDDIR%/text
120 | 	echo.
121 | 	echo.Build finished. The text files are in %BUILDDIR%/text.
122 | 	goto end
123 | )
124 | 
125 | if "%1" == "man" (
126 | 	%SPHINXBUILD% -b man %ALLSPHINXOPTS% %BUILDDIR%/man
127 | 	echo.
128 | 	echo.Build finished. The manual pages are in %BUILDDIR%/man.
129 | 	goto end
130 | )
131 | 
132 | if "%1" == "changes" (
133 | 	%SPHINXBUILD% -b changes %ALLSPHINXOPTS% %BUILDDIR%/changes
134 | 	echo.
135 | 	echo.The overview file is in %BUILDDIR%/changes.
136 | 	goto end
137 | )
138 | 
139 | if "%1" == "linkcheck" (
140 | 	%SPHINXBUILD% -b linkcheck %ALLSPHINXOPTS% %BUILDDIR%/linkcheck
141 | 	echo.
142 | 	echo.Link check complete; look for any errors in the above output ^
143 | or in %BUILDDIR%/linkcheck/output.txt.
144 | 	goto end
145 | )
146 | 
147 | if "%1" == "doctest" (
148 | 	%SPHINXBUILD% -b doctest %ALLSPHINXOPTS% %BUILDDIR%/doctest
149 | 	echo.
150 | 	echo.Testing of doctests in the sources finished, look at the ^
151 | results in %BUILDDIR%/doctest/output.txt.
152 | 	goto end
153 | )
154 | 
155 | :end
156 | 


--------------------------------------------------------------------------------
/example/tumblelog/Pipfile:
--------------------------------------------------------------------------------
 1 | [[source]]
 2 | name = "pypi"
 3 | url = "https://pypi.org/simple"
 4 | verify_ssl = true
 5 | 
 6 | [dev-packages]
 7 | 
 8 | [packages]
 9 | django-bootstrap3 = "*"
10 | Pillow = "*"
11 | django-mongoengine = {path = "./../.."}
12 | 
13 | [requires]
14 | python_version = "3.7"
15 | 


--------------------------------------------------------------------------------
/example/tumblelog/manage.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | import os
 3 | import sys
 4 | 
 5 | if __name__ == "__main__":
 6 |     os.environ.setdefault("DJANGO_SETTINGS_MODULE", "tumblelog.settings")
 7 | 
 8 |     from django.core.management import execute_from_command_line
 9 | 
10 |     execute_from_command_line(sys.argv)
11 | 


--------------------------------------------------------------------------------
/example/tumblelog/requirements.txt:
--------------------------------------------------------------------------------
1 | Pillow
2 | django-bootstrap3
3 | 


--------------------------------------------------------------------------------
/example/tumblelog/tumblelog/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/MongoEngine/django-mongoengine/298cdcf59b21fe590958f57f27bf28e7192fcc4e/example/tumblelog/tumblelog/__init__.py


--------------------------------------------------------------------------------
/example/tumblelog/tumblelog/admin.py:
--------------------------------------------------------------------------------
 1 | from tumblelog.models import BlogPost, Image, Music, Quote, Video
 2 | 
 3 | from django_mongoengine import mongo_admin as admin
 4 | 
 5 | 
 6 | @admin.register(BlogPost)
 7 | class BlogPostAdmin(admin.DocumentAdmin):
 8 |     pass
 9 | 
10 | 
11 | @admin.register(Image)
12 | class ImageAdmin(admin.DocumentAdmin):
13 |     pass
14 | 
15 | 
16 | @admin.register(Music)
17 | class MusicAdmin(admin.DocumentAdmin):
18 |     pass
19 | 
20 | 
21 | @admin.register(Quote)
22 | class QuoteAdmin(admin.DocumentAdmin):
23 |     pass
24 | 
25 | 
26 | @admin.register(Video)
27 | class VideoAdmin(admin.DocumentAdmin):
28 |     pass
29 | 


--------------------------------------------------------------------------------
/example/tumblelog/tumblelog/forms.py:
--------------------------------------------------------------------------------
 1 | from tumblelog import models
 2 | 
 3 | from django_mongoengine import forms
 4 | 
 5 | 
 6 | class CommentForm(forms.EmbeddedDocumentForm):
 7 |     class Meta:
 8 |         document = models.Comment
 9 |         embedded_field = "comments"
10 |         exclude = ("created_at",)
11 | 


--------------------------------------------------------------------------------
/example/tumblelog/tumblelog/models.py:
--------------------------------------------------------------------------------
 1 | from django.urls import reverse
 2 | 
 3 | import datetime
 4 | 
 5 | from django_mongoengine import Document, EmbeddedDocument, fields
 6 | 
 7 | 
 8 | class Comment(EmbeddedDocument):
 9 |     created_at = fields.DateTimeField(
10 |         default=datetime.datetime.now,
11 |         editable=False,
12 |     )
13 |     author = fields.StringField(verbose_name="Name", max_length=255, required=True)
14 |     email = fields.EmailField(verbose_name="Email", required=True)
15 |     body = fields.StringField(verbose_name="Comment", required=True)
16 | 
17 | 
18 | class Post(Document):
19 |     created_at = fields.DateTimeField(
20 |         default=datetime.datetime.now,
21 |         editable=False,
22 |     )
23 |     title = fields.StringField(max_length=255, required=True)
24 |     slug = fields.StringField(max_length=255, primary_key=True, required=True)
25 |     comments = fields.ListField(
26 |         fields.EmbeddedDocumentField(Comment, required=True),
27 |         default=[],
28 |     )
29 |     strings = fields.ListField(
30 |         fields.StringField(required=True),
31 |         default=[],
32 |     )
33 | 
34 |     def get_absolute_url(self):
35 |         return reverse("post", kwargs={"slug": self.slug})
36 | 
37 |     def __str__(self):
38 |         return self.title
39 | 
40 |     @property
41 |     def post_type(self):
42 |         return self.__class__.__name__
43 | 
44 |     meta = {
45 |         "indexes": ["-created_at", "slug"],
46 |         "ordering": ["-created_at"],
47 |         "allow_inheritance": True,
48 |     }
49 | 
50 | 
51 | class BlogPost(Post):
52 |     body = fields.StringField(required=True)
53 | 
54 | 
55 | class Video(Post):
56 |     embed_code = fields.StringField(required=True)
57 | 
58 | 
59 | class Image(Post):
60 |     image = fields.ImageField(required=True)
61 | 
62 | 
63 | class Quote(Post):
64 |     body = fields.StringField(required=True)
65 |     author = fields.StringField(verbose_name="Author Name", max_length=255, required=True)
66 | 
67 | 
68 | class Music(Post):
69 |     url = fields.StringField(max_length=100, verbose_name="Music Url", required=True)
70 |     music_parameters = fields.DictField(verbose_name="Music Parameters", required=True)
71 | 


--------------------------------------------------------------------------------
/example/tumblelog/tumblelog/settings.py:
--------------------------------------------------------------------------------
  1 | # Django settings for tumblelog project.
  2 | import os
  3 | import sys
  4 | 
  5 | PROJECT_ROOT = os.path.dirname(__file__)
  6 | sys.path.insert(0, os.path.realpath(os.path.join(PROJECT_ROOT, "../../../")))
  7 | 
  8 | 
  9 | DEBUG = True
 10 | 
 11 | ADMINS = (
 12 |     # ('Your Name', 'your_email@example.com'),
 13 | )
 14 | 
 15 | MANAGERS = ADMINS
 16 | 
 17 | # MongoDB settings
 18 | MONGODB_DATABASES = {"default": {"name": "django_mongoengine"}}
 19 | 
 20 | 
 21 | DATABASES = {"default": {"ENGINE": "django.db.backends.dummy"}}
 22 | 
 23 | # Local time zone for this installation. Choices can be found here:
 24 | # http://en.wikipedia.org/wiki/List_of_tz_zones_by_name
 25 | # although not all choices may be available on all operating systems.
 26 | # On Unix systems, a value of None will cause Django to use the same
 27 | # timezone as the operating system.
 28 | # If running in a Windows environment this must be set to the same as your
 29 | # system time zone.
 30 | TIME_ZONE = "Europe/London"
 31 | 
 32 | # Language code for this installation. All choices can be found here:
 33 | # http://www.i18nguy.com/unicode/language-identifiers.html
 34 | LANGUAGE_CODE = "en-gb"
 35 | 
 36 | SITE_ID = 1
 37 | 
 38 | # If you set this to False, Django will make some optimizations so as not
 39 | # to load the internationalization machinery.
 40 | USE_I18N = True
 41 | 
 42 | # If you set this to False, Django will not use timezone-aware datetimes.
 43 | USE_TZ = True
 44 | 
 45 | # Absolute filesystem path to the directory that will hold user-uploaded files.
 46 | # Example: "/home/media/media.lawrence.com/media/"
 47 | MEDIA_ROOT = ""
 48 | 
 49 | # URL that handles the media served from MEDIA_ROOT. Make sure to use a
 50 | # trailing slash.
 51 | # Examples: "http://media.lawrence.com/media/", "http://example.com/media/"
 52 | MEDIA_URL = ""
 53 | 
 54 | # Absolute path to the directory static files should be collected to.
 55 | # Don't put anything in this directory yourself; store your static files
 56 | # in apps' "static/" subdirectories and in STATICFILES_DIRS.
 57 | # Example: "/home/media/media.lawrence.com/static/"
 58 | STATIC_ROOT = ""
 59 | 
 60 | # URL prefix for static files.
 61 | # Example: "http://media.lawrence.com/static/"
 62 | STATIC_URL = "/static/"
 63 | 
 64 | # Additional locations of static files
 65 | STATICFILES_DIRS = (
 66 |     # Put strings here, like "/home/html/static" or "C:/www/django/static".
 67 |     # Always use forward slashes, even on Windows.
 68 |     # Don't forget to use absolute paths, not relative paths.
 69 | )
 70 | 
 71 | # Make this unique, and don't share it with anybody.
 72 | SECRET_KEY = "d2h8yt+x2g0$+e#9$z5z$auy%v0axov(wt3o*bj1#h^1+x^n(!"
 73 | 
 74 | MIDDLEWARE = [
 75 |     "django.middleware.security.SecurityMiddleware",
 76 |     "django.contrib.sessions.middleware.SessionMiddleware",
 77 |     "django.middleware.common.CommonMiddleware",
 78 |     "django.middleware.csrf.CsrfViewMiddleware",
 79 |     "django.contrib.auth.middleware.AuthenticationMiddleware",
 80 |     "django.contrib.messages.middleware.MessageMiddleware",
 81 |     "django.middleware.clickjacking.XFrameOptionsMiddleware",
 82 | ]
 83 | 
 84 | 
 85 | ROOT_URLCONF = "tumblelog.urls"
 86 | 
 87 | # Python dotted path to the WSGI application used by Django's runserver.
 88 | WSGI_APPLICATION = "tumblelog.wsgi.application"
 89 | 
 90 | 
 91 | TEMPLATES = [
 92 |     {
 93 |         "BACKEND": "django.template.backends.django.DjangoTemplates",
 94 |         "DIRS": [os.path.join(os.path.realpath(os.path.dirname(__file__)), "../templates")],
 95 |         "OPTIONS": {
 96 |             "context_processors": [
 97 |                 "django.contrib.auth.context_processors.auth",
 98 |                 "django.template.context_processors.debug",
 99 |                 "django.template.context_processors.i18n",
100 |                 "django.template.context_processors.media",
101 |                 "django.template.context_processors.request",
102 |                 "django.template.context_processors.static",
103 |                 "django.template.context_processors.tz",
104 |                 "django.contrib.messages.context_processors.messages",
105 |             ],
106 |             "loaders": [
107 |                 "django.template.loaders.filesystem.Loader",
108 |                 "django.template.loaders.app_directories.Loader",
109 |             ],
110 |         },
111 |     },
112 | ]
113 | 
114 | 
115 | INSTALLED_APPS = (
116 |     "django.contrib.auth",
117 |     "django.contrib.contenttypes",
118 |     "django.contrib.sessions",
119 |     "django.contrib.messages",
120 |     "django.contrib.staticfiles",
121 |     "django.contrib.admin",
122 |     "django_mongoengine",
123 |     "django_mongoengine.mongo_auth",
124 |     "django_mongoengine.mongo_admin",
125 |     "bootstrap3",
126 |     "tumblelog",
127 | )
128 | 
129 | AUTH_USER_MODEL = "mongo_auth.MongoUser"
130 | 
131 | AUTHENTICATION_BACKENDS = ("django_mongoengine.mongo_auth.backends.MongoEngineBackend",)
132 | 
133 | SESSION_ENGINE = "django_mongoengine.sessions"
134 | 
135 | 
136 | INTERNAL_IPS = (
137 |     "127.0.0.1",
138 |     "10.0.2.2",
139 | )
140 | 
141 | 
142 | # A sample logging configuration. The only tangible logging
143 | # performed by this configuration is to send an email to
144 | # the site admins on every HTTP 500 error when DEBUG=False.
145 | # See http://docs.djangoproject.com/en/dev/topics/logging for
146 | # more details on how to customize your logging configuration.
147 | LOGGING = {
148 |     "version": 1,
149 |     "disable_existing_loggers": False,
150 |     "filters": {"require_debug_false": {"()": "django.utils.log.RequireDebugFalse"}},
151 |     "handlers": {
152 |         "mail_admins": {
153 |             "level": "ERROR",
154 |             "filters": ["require_debug_false"],
155 |             "class": "django.utils.log.AdminEmailHandler",
156 |         }
157 |     },
158 |     "loggers": {
159 |         "django.request": {
160 |             "handlers": ["mail_admins"],
161 |             "level": "ERROR",
162 |             "propagate": True,
163 |         },
164 |     },
165 | }
166 | 


--------------------------------------------------------------------------------
/example/tumblelog/tumblelog/templates/_delete.html:
--------------------------------------------------------------------------------
 1 | {% extends "_details.html" %}{% load bootstrap3 %}
 2 | {% block aftercontent %}
 3 | <div class="alert alert-danger">
 4 |   Delete this object? It can not be restored.
 5 | </div>
 6 | <form class="form" action="." method="post">
 7 |   {% csrf_token %}
 8 |   <div class="actions">
 9 |     <input type="submit" class="btn btn-danger" value="Confirm deletion">
10 |   </div>
11 | </form>
12 | {% endblock %}
13 | 


--------------------------------------------------------------------------------
/example/tumblelog/tumblelog/templates/_details.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}{% load bootstrap3 %}
 2 | 
 3 | {% block page_header %}
 4 |   <div class="page-header">
 5 |     <h1>{{ post.title }}</h1>
 6 |   </div>
 7 | {% endblock %}
 8 | 
 9 | {% block content %}
10 |   {% if post.body and not post.author %}
11 |     <p>{{ post.body|linebreaksbr }}<p>
12 |   {% endif %}
13 |   {% if post.embed_code %}
14 |     {{ post.embed_code|safe }}
15 |   {% endif %}
16 |   {% if post.image %}
17 |     <p><img src="{% url 'image_file' slug=post.slug %}" width="{{ post.image.size.0 }}" height="{{ post.image.size.1 }}" /><p>
18 |   {% endif %}
19 |   {% if post.music_parameters %}
20 |     <p><a href="{{ post.url }}">Check out this song !</a></p>
21 |     <p>Music info :<br/>
22 |       <ul>
23 |       {% for key, value in post.music_parameters.items %}
24 |         <li>{{ key }} :
25 |           {% if value.items %}
26 |             <ul>
27 |               {% for k, v in value.items%}
28 |                 <li>{{ k }} : {{ v }}</li>
29 |               {% endfor %}
30 |             </ul>
31 |           {% else %}
32 |             {{ value }}
33 |           {% endif %}
34 |         </li>
35 |       {% endfor %}
36 |       </ul>
37 |     </p>
38 |   {% endif %}
39 |   {% if post.author %}
40 |     <blockquote>{{ post.body|linebreaksbr }}</blockquote>
41 |     <p>{{ post.author }}</p>
42 |   {% endif %}
43 |   <p>{{ post.created_at }}</p>
44 |   {% block aftercontent %}
45 |   <div class="btn-group">
46 |     <a href="{% url 'post_update' slug=post.slug %}" class="btn btn-default"><i class="glyphicon glyphicon-edit"></i> edit</a>
47 |     <a href="{% url 'post_delete' slug=post.slug %}" class="btn btn-default"><i class="glyphicon glyphicon-remove"></i> delete</a>
48 |   </div>
49 |   <hr>
50 |   <h2>Comments</h2>
51 |   {% if post.comments %}
52 |     {% for comment in post.comments %}
53 |        <p>{{ comment.body }}</p>
54 |        <p><strong>{{ comment.author }}</strong> <small>on {{ comment.created_at }}</small></p>
55 |       {{ comment.text }}
56 |     {% endfor %}
57 |   {% else %}
58 |     <p>No comments, be the first to comment!</p>
59 |   {% endif %}
60 |   <h2>Add a comment</h2>
61 |   <form class="form" action="." method="post">
62 |     {% csrf_token %}
63 |     {% bootstrap_form form %}
64 |     <div class="actions">
65 |       <input type="submit" class="btn primary" value="comment">
66 |     </div>
67 |   </form>
68 |   {% endblock %}
69 | 
70 |   {{ embedded_form }}
71 | {% endblock %}
72 | 


--------------------------------------------------------------------------------
/example/tumblelog/tumblelog/templates/_forms.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}{% load bootstrap3 %}
 2 | 
 3 | {% block page_header %}
 4 |   <div class="page-header">
 5 |     <h1>{{ form.instance.slug|yesno:"Edit post,Create new post"|title }}</h1>
 6 |   </div>
 7 | {% endblock %}
 8 | 
 9 | 
10 | {% block content %}
11 |   {% if form.errors %}
12 |     <div class="alert alert-error">
13 |       <button class="close" data-dismiss="alert">×</button>
14 |       There are problems with the form data - please review
15 |     </div>
16 |   {% endif %}
17 |   <form action="." class="form col-md-7" method="post" enctype="multipart/form-data">
18 |     {% csrf_token %}
19 |     {% bootstrap_form form %}
20 | 
21 |     <div class="actions">
22 |       <input type="submit" class="btn primary" value="{{ form.instance.slug|yesno:"Edit post,Create new post" }}">
23 |     </div>
24 |   </form>
25 | {% endblock %}
26 | 


--------------------------------------------------------------------------------
/example/tumblelog/tumblelog/templates/_messages.html:
--------------------------------------------------------------------------------
1 | {% if messages %}
2 |   {% for message in messages %}
3 |     <div class="alert {% if message.tags %}alert-{{ message.tags|lower }}{% else %}info{% endif %}">
4 |       <button class="close" data-dismiss="alert">×</button>
5 |       {{ message }}
6 |     </div>
7 |   {% endfor %}
8 | {% endif %}


--------------------------------------------------------------------------------
/example/tumblelog/tumblelog/templates/base.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>{% load bootstrap3 %}
 2 | <html lang="ru">
 3 |   <head>
 4 |     <meta charset="utf-8">
 5 |     <title>My Tumblelog</title>
 6 | 
 7 |     {% bootstrap_css %}
 8 |     <style>
 9 |       .navbar-brand small {
10 |         color: #999;
11 |         display:block;
12 |         font-size:12px;
13 |       }
14 | 
15 |       .navbar-toggle {top:10px}
16 | 
17 |       @media (min-width:768px) {
18 | 
19 |         .navbar-brand {
20 |           padding-top: 7px;
21 |         }
22 | 
23 |       }
24 |     </style>
25 |   </head>
26 | 
27 |   <body>
28 |     <header class="navbar navbar-inverse navbar-static-top" role="banner">
29 |       <div class="container">
30 |         <div class="navbar-header">
31 |           <a href="/" class="navbar-brand">
32 |             My Tumblelog
33 |             <small>Starring MongoDB and MongoEngine</small>
34 |           </a>
35 |         </div>
36 |         <nav class="navbar-collapse">
37 |           {% block top_nav %}{% endblock %}
38 |         </nav>
39 |       </div>
40 |     </header>
41 | 
42 |     <div class="container">
43 |       <div class="row">
44 |         <div class="col-md-9" role="main">
45 |           {% block page_header %}{% endblock %}
46 |           {% include "_messages.html" %}
47 |           {% block content %}{% endblock %}
48 |         </div>
49 |       </div>
50 |     </div>
51 |     <footer style="margin-top: 40px; margin-bottom: 20px; text-align: center; color: #888;">
52 |       <div class="container">
53 |         <p>Project is example application for testing features of django_mongoengine.</p>
54 |       </div>
55 |     </footer>
56 |     {% block js_footer %}
57 |     {% bootstrap_javascript jquery=1 %}
58 |     {% endblock %}
59 |   </body>
60 | </html>
61 | 


--------------------------------------------------------------------------------
/example/tumblelog/tumblelog/templates/tumblelog/post_list.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}{% load bootstrap3 %}
 2 | 
 3 | {% block top_nav %}
 4 | <ul class="nav navbar-nav navbar-right">
 5 |   <li>
 6 |     <a href="{% url 'admin:index' %}">Admin</a>
 7 |   </li>
 8 |   <li class="dropdown">
 9 |     <a href="#" class="dropdown-toggle" data-toggle="dropdown">Create <b class="caret"></b></a>
10 |     <ul class="dropdown-menu">
11 |       <li>
12 |         <a href="{% url 'post_new' post_type='post' %}"><i class="icon-edit"></i> Post</a>
13 |       </li>
14 |       <li>
15 |         <a href="{% url 'post_new' post_type='image' %}"><i class="icon-camera"></i> Image</a>
16 |       </li>
17 |       <li>
18 |         <a href="{% url 'post_new' post_type='video' %}"><i class="icon-play-circle"></i> Video</a>
19 |       </li>
20 |       <li>
21 |         <a href="{% url 'post_new' post_type='quote' %}"><i class="icon-user"></i> Quote</a>
22 |       </li>
23 |       <li>
24 |         <a href="{% url 'post_new' post_type='music' %}"><i class="icon-music"></i> Music</a>
25 |       </li>
26 |     </ul>
27 |   </li>
28 | </ul>
29 | {% endblock %}
30 | 
31 | {% block content %}
32 |     {% for post in posts_list %}
33 |       <h2><a href="{% url 'post' slug=post.slug %}">{{ post.title }}</a></h2>
34 |       {% if post.post_type == 'BlogPost' %}
35 |         <p>{{ post.body|truncatewords:20 }}</p>
36 |       {% endif %}
37 |       {% if post.post_type == 'Video' %}
38 |         {{ post.embed_code|safe }}
39 |       {% endif %}
40 |       {% if post.post_type == 'Image' %}
41 |         <p><img src="{% url 'image_file' slug=post.slug %}" width="100px" height="100px" /><p>
42 |       {% endif %}
43 |       {% if post.post_type == 'Quote' %}
44 |         <blockquote>{{ post.body|truncatewords:13 }}</blockquote>
45 |         <p>{{ post.author }}</p>
46 |       {% endif %}
47 |       <p>
48 |         {{ post.created_at }} |
49 |         {% with total=post.comments|length %}
50 |             {{ total }} comment{{ total|pluralize }}
51 |         {% endwith %}
52 |       </p>
53 |       <hr />
54 |     {% endfor %}
55 | 
56 |     {% bootstrap_pagination page_obj %}
57 | {% endblock %}
58 | 


--------------------------------------------------------------------------------
/example/tumblelog/tumblelog/urls.py:
--------------------------------------------------------------------------------
 1 | from django.urls import include
 2 | from django.urls import re_path as url
 3 | from tumblelog.views import (
 4 |     AddPostView,
 5 |     DeletePostView,
 6 |     ImageFileView,
 7 |     PostDetailView,
 8 |     PostIndexView,
 9 |     TestSessionView,
10 |     UpdatePostView,
11 | )
12 | 
13 | from django_mongoengine import mongo_admin
14 | 
15 | post_patterns = [
16 |     url(r"^$", PostDetailView.as_view(), name="post"),
17 |     url(r"^edit/$", UpdatePostView.as_view(), name="post_update"),
18 |     url(r"^delete/$", DeletePostView.as_view(), name="post_delete"),
19 | ]
20 | 
21 | 
22 | urlpatterns = [
23 |     url(r"^test-session/", TestSessionView.as_view()),
24 |     url(r"^$", PostIndexView.as_view(), name="post_index"),
25 |     url(r"^new/$", AddPostView.as_view(), name="post_new"),
26 |     url(
27 |         r"^new/(?P<post_type>(post|video|image|quote|music))/$",
28 |         AddPostView.as_view(),
29 |         name="post_new",
30 |     ),
31 |     url(r"^admin/", mongo_admin.site.urls),
32 |     url(r"^image-file/(?P<slug>[a-zA-Z0-9-]+)/", ImageFileView.as_view(), name="image_file"),
33 |     url(r"^(?P<slug>[a-zA-Z0-9-]+)/", include(post_patterns)),
34 | ]
35 | 


--------------------------------------------------------------------------------
/example/tumblelog/tumblelog/views.py:
--------------------------------------------------------------------------------
 1 | from django.http import HttpResponse
 2 | from django.views.generic import View
 3 | from tumblelog import forms
 4 | from tumblelog.models import BlogPost, Image, Music, Post, Quote, Video
 5 | 
 6 | from django_mongoengine.forms.fields import DictField
 7 | from django_mongoengine.views import (
 8 |     CreateView,
 9 |     DeleteView,
10 |     DetailView,
11 |     EmbeddedDetailView,
12 |     ListView,
13 |     UpdateView,
14 | )
15 | 
16 | 
17 | class PostIndexView(ListView):
18 |     document = Post
19 |     context_object_name = "posts_list"
20 |     paginate_by = 5
21 | 
22 | 
23 | class PostDetailView(EmbeddedDetailView):
24 |     document = Post
25 |     template_name = "_details.html"
26 |     context_object_name = "post"
27 |     embedded_context_name = "form"
28 |     embedded_form_class = forms.CommentForm
29 |     success_message = "Comment Posted!"
30 | 
31 | 
32 | class AddPostView(CreateView):
33 |     success_url = "/"
34 |     template_name = "_forms.html"
35 |     doc_map = {"post": BlogPost, "video": Video, "image": Image, "quote": Quote, "music": Music}
36 |     success_message = "Post Added!"
37 |     fields = "__all__"
38 | 
39 |     @property
40 |     def document(self):
41 |         post_type = self.kwargs.get("post_type", "post")
42 |         return self.doc_map.get(post_type)
43 | 
44 |     def get_form(self, form_class=None):
45 |         form = super().get_form(form_class)
46 |         music_parameters = form.fields.get("music_parameters", None)
47 |         if music_parameters is not None:
48 |             schema = {
49 |                 "Artist": "",
50 |                 "Title": "",
51 |                 "Album": "",
52 |                 "Genre": "",
53 |                 "Label": "",
54 |                 "Release dates": {"UK": "", "US": "", "FR": ""},
55 |             }
56 |             music_parameters = DictField(initial=schema, flags=["FORCE_SCHEMA"])
57 |             form.fields["music_parameters"] = music_parameters
58 |         return form
59 | 
60 | 
61 | class DeletePostView(DeleteView):
62 |     context_object_name = "post"
63 |     document = Post
64 |     success_url = "/"
65 |     template_name = "_delete.html"
66 | 
67 | 
68 | class UpdatePostView(UpdateView):
69 |     document = Post
70 |     template_name = "_forms.html"
71 |     fields = "__all__"
72 | 
73 |     def get_form_class(self):
74 |         from django_mongoengine.forms.documents import documentform_factory
75 | 
76 |         return documentform_factory(self.object.__class__, fields=self.fields)
77 | 
78 | 
79 | class ImageFileView(DetailView):
80 |     document = Image
81 | 
82 |     def get(self, request, *args, **kwargs):
83 |         image = self.get_object().image
84 |         return HttpResponse(
85 |             image.read(),
86 |             content_type="image/%s" % image.format.lower(),
87 |         )
88 | 
89 | 
90 | class TestSessionView(View):
91 |     def get(self, request, *args, **kwargs):
92 |         test_data = request.session.get("test", None)
93 |         request.session["test"] = "abc123"
94 |         return HttpResponse("test=%s" % test_data)
95 | 


--------------------------------------------------------------------------------
/example/tumblelog/tumblelog/wsgi.py:
--------------------------------------------------------------------------------
 1 | """
 2 | WSGI config for tumblelog project.
 3 | 
 4 | This module contains the WSGI application used by Django's development server
 5 | and any production WSGI deployments. It should expose a module-level variable
 6 | named ``application``. Django's ``runserver`` and ``runfcgi`` commands discover
 7 | this application via the ``WSGI_APPLICATION`` setting.
 8 | 
 9 | Usually you will have the standard Django WSGI application here, but it also
10 | might make sense to replace the whole Django WSGI application with a custom one
11 | that later delegates to the Django one. For example, you could introduce WSGI
12 | middleware here, or combine a Django application with an application of another
13 | framework.
14 | 
15 | """
16 | 
17 | import os
18 | 
19 | os.environ.setdefault("DJANGO_SETTINGS_MODULE", "tumblelog.settings")
20 | 
21 | # This application object is used by any WSGI server configured to use this
22 | # file. This includes Django's development server, if the WSGI_APPLICATION
23 | # setting points here.
24 | from django.core.wsgi import get_wsgi_application  # noqa: E402
25 | 
26 | application = get_wsgi_application()
27 | 
28 | # Apply WSGI middleware here.
29 | # from helloworld.wsgi import HelloWorldApplication
30 | # application = HelloWorldApplication(application)
31 | 


--------------------------------------------------------------------------------
/pyproject.toml:
--------------------------------------------------------------------------------
 1 | [project]
 2 | name = "django-mongoengine"
 3 | description = "Django support for MongoDB via MongoEngine"
 4 | readme = {file = "README.rst", content-type = "text/x-rst"}
 5 | authors = [
 6 |     {name = "Ross Lawley", email = "ross.lawley@gmail.com"},
 7 | ]
 8 | dynamic = ["version"]
 9 | license = {text = "BSD"}
10 | requires-python = "<4.0,>=3.9"
11 | 
12 | classifiers = [
13 |     "Development Status :: 4 - Beta",
14 |     "Environment :: Web Environment",
15 |     "Intended Audience :: Developers",
16 |     "License :: OSI Approved :: BSD License",
17 |     "Operating System :: OS Independent",
18 |     "Programming Language :: Python",
19 |     "Programming Language :: Python :: 3",
20 |     "Topic :: Internet :: WWW/HTTP :: Dynamic Content",
21 |     "Topic :: Software Development :: Libraries :: Python Modules",
22 |     "Framework :: Django"
23 | ]
24 | dependencies = [
25 |     "django<5,>=4.2",
26 |     "mongoengine>=0.14",
27 | ]
28 | 
29 | [project.urls]
30 | "Homepage" = "https://github.com/mongoengine/django-mongoengine"
31 | "Download" = "https://github.com/mongoengine/django-mongoengine/tarball/master"
32 | 
33 | [dependency-groups]
34 | dev = [
35 |     "flake8",
36 |     "pdbpp",
37 |     "pytest",
38 |     "pytest-cov",
39 |     "pytest-django",
40 |     "pytest-sugar",
41 |     "ruff",
42 |     "sphinx",
43 |     "typing-extensions",
44 |     "mongo-types @ git+https://github.com/sbdchd/mongo-types.git@main",
45 |     "django-types",
46 |     "build>=1.2.2.post1",
47 | ]
48 | 
49 | [tool.ruff]
50 | line-length = 100
51 | [tool.ruff.lint]
52 | select = [
53 |     "E",
54 |     "F",
55 |     "FA",
56 |     "T20",
57 |     "TCH",
58 |     "C4",
59 | ]
60 | ignore = ["E501"]
61 | [tool.ruff.lint.pyflakes]
62 | extend-generics = [
63 |     "mongoengine.queryset.QuerySetManager",
64 |     "mongoengine.queryset.QuerySet",
65 |     "mongoengine.queryset.QuerySetNoCache",
66 |     "django_mongoengine.queryset.QuerySetManager",
67 |     "django_mongoengine.queryset.QuerySet",
68 |     "django_mongoengine.queryset.QuerySetNoCache",
69 | ]
70 | [tool.ruff.format]
71 | # Use `\n` line endings for all files
72 | line-ending = "lf"
73 | 
74 | [build-system]
75 | requires = ["hatchling", "hatch-vcs"]
76 | build-backend = "hatchling.build"
77 | 
78 | [tool.hatch.build]
79 | include = ["django_mongoengine/**"]
80 | 
81 | [tool.hatch.build.targets.wheel]
82 | packages = ["django_mongoengine"]
83 | 
84 | [tool.hatch.version]
85 | source = "vcs"
86 | 


--------------------------------------------------------------------------------
/pyrightconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "include": [
 3 |     "django_mongoengine"
 4 |   ],
 5 |   "exclude": [
 6 |     "**/__pycache__"
 7 |   ],
 8 |   "ignore": [
 9 |     "src/fornex/*/migrations/*"
10 |   ],
11 |   "pythonVersion": "3.9",
12 |   "pythonPlatform": "Linux",
13 |   "reportGeneralTypeIssues": "information"
14 | }
15 | 


--------------------------------------------------------------------------------
/pytest.ini:
--------------------------------------------------------------------------------
1 | [pytest]
2 | DJANGO_SETTINGS_MODULE=tests.settings
3 | python_files = tests.py test_*.py *_tests.py tests/*.py
4 | addopts =
5 |     --no-cov-on-fail
6 |     --cov-report=""
7 |     --cov django_mongoengine
8 |     --maxfail=5
9 | 


--------------------------------------------------------------------------------
/sg-rules/0.6.0-rewrite-blank.yml:
--------------------------------------------------------------------------------
 1 | id: fix-blank
 2 | language: Python
 3 | rule:
 4 |   all:
 5 |     - kind: keyword_argument
 6 |     - regex: blank=True
 7 |     - inside:
 8 |         kind: assignment
 9 |         stopBy: end
10 | fix: required=False
11 | 
12 | ---
13 | 
14 | id: add-required-by-default
15 | language: Python
16 | rule:
17 |   all:
18 |     - pattern: fields.$C($$$A)
19 |     - regex: '[A-Z]\w+'
20 |     - not:
21 |         any:
22 |           - regex: required=
23 |           - regex: blank=
24 |           - regex: primary_key=
25 |           - regex: default=
26 |           - regex: null=True
27 | transform:
28 |   MAYBE_COMMA:
29 |     replace:
30 |       source: $$$A
31 |       replace: '^.+[^,]$'
32 |       by: ', '
33 | fix: fields.$C($$$A$MAYBE_COMMArequired=True)
34 | 


--------------------------------------------------------------------------------
/tests/__init__.py:
--------------------------------------------------------------------------------
 1 | from django.test import SimpleTestCase, TransactionTestCase
 2 | from mongoengine import connect
 3 | from mongoengine.connection import get_db
 4 | 
 5 | __all__ = ["MongoTestCase"]
 6 | 
 7 | 
 8 | class MongoTestCase(SimpleTestCase):
 9 |     """
10 |     TestCase class that clear the collection between the tests
11 |     """
12 | 
13 |     try:
14 |         assertQuerySetEqual = TransactionTestCase.__dict__["assertQuerySetEqual"]
15 |     except KeyError:
16 |         # https://docs.djangoproject.com/en/4.2/topics/testing/tools/#django.test.TransactionTestCase.assertQuerySetEqual
17 |         # Drop this after supporting only django > 4.2
18 |         assertQuerySetEqual = TransactionTestCase.__dict__["assertQuerysetEqual"]
19 | 
20 |     def __init__(self, methodName="runtest"):
21 |         from django.conf import settings
22 | 
23 |         connect(settings.MONGODB_DATABASES["default"]["name"])
24 |         self.db = get_db()
25 |         super().__init__(methodName)
26 | 
27 |     def dropCollections(self):
28 |         for collection in self.db.list_collection_names():
29 |             if collection.startswith("system."):
30 |                 continue
31 |             self.db.drop_collection(collection)
32 | 
33 |     def tearDown(self):
34 |         self.dropCollections()
35 | 


--------------------------------------------------------------------------------
/tests/forms/__init__.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 | 


--------------------------------------------------------------------------------
/tests/forms/models.py:
--------------------------------------------------------------------------------
 1 | from django.db import models
 2 | 
 3 | from django_mongoengine import Document, fields
 4 | 
 5 | 
 6 | class MongoDoc(Document):
 7 |     year = fields.IntField(required=True)
 8 |     file = fields.FileField(upload_to="test", required=True)
 9 | 
10 | 
11 | class DjangoModel(models.Model):
12 |     year = models.IntegerField()
13 |     file = models.FileField(upload_to="test")
14 | 


--------------------------------------------------------------------------------
/tests/settings.py:
--------------------------------------------------------------------------------
  1 | # Django settings for tumblelog project.
  2 | import os
  3 | import sys
  4 | 
  5 | PROJECT_ROOT = os.path.dirname(__file__)
  6 | sys.path.append(os.path.join(PROJECT_ROOT, "../../../"))
  7 | 
  8 | 
  9 | DEBUG = True
 10 | 
 11 | ADMINS = (
 12 |     # ('Your Name', 'your_email@example.com'),
 13 | )
 14 | 
 15 | MANAGERS = ADMINS
 16 | 
 17 | # MongoDB Databases
 18 | MONGODB_DATABASES = {"default": {"name": "django_mongoengine_test"}}
 19 | 
 20 | # Local time zone for this installation. Choices can be found here:
 21 | # http://en.wikipedia.org/wiki/List_of_tz_zones_by_name
 22 | # although not all choices may be available on all operating systems.
 23 | # On Unix systems, a value of None will cause Django to use the same
 24 | # timezone as the operating system.
 25 | # If running in a Windows environment this must be set to the same as your
 26 | # system time zone.
 27 | TIME_ZONE = "Europe/London"
 28 | 
 29 | # Language code for this installation. All choices can be found here:
 30 | # http://www.i18nguy.com/unicode/language-identifiers.html
 31 | LANGUAGE_CODE = "en-gb"
 32 | 
 33 | SITE_ID = 1
 34 | 
 35 | # If you set this to False, Django will make some optimizations so as not
 36 | # to load the internationalization machinery.
 37 | USE_I18N = True
 38 | 
 39 | # If you set this to False, Django will not use timezone-aware datetimes.
 40 | USE_TZ = True
 41 | 
 42 | # Absolute filesystem path to the directory that will hold user-uploaded files.
 43 | # Example: "/home/media/media.lawrence.com/media/"
 44 | MEDIA_ROOT = ""
 45 | 
 46 | # URL that handles the media served from MEDIA_ROOT. Make sure to use a
 47 | # trailing slash.
 48 | # Examples: "http://media.lawrence.com/media/", "http://example.com/media/"
 49 | MEDIA_URL = ""
 50 | 
 51 | # Absolute path to the directory static files should be collected to.
 52 | # Don't put anything in this directory yourself; store your static files
 53 | # in apps' "static/" subdirectories and in STATICFILES_DIRS.
 54 | # Example: "/home/media/media.lawrence.com/static/"
 55 | STATIC_ROOT = ""
 56 | 
 57 | # URL prefix for static files.
 58 | # Example: "http://media.lawrence.com/static/"
 59 | STATIC_URL = "/static/"
 60 | 
 61 | # Additional locations of static files
 62 | STATICFILES_DIRS = (
 63 |     # Put strings here, like "/home/html/static" or "C:/www/django/static".
 64 |     # Always use forward slashes, even on Windows.
 65 |     # Don't forget to use absolute paths, not relative paths.
 66 | )
 67 | 
 68 | # List of finder classes that know how to find static files in
 69 | # various locations.
 70 | STATICFILES_FINDERS = (
 71 |     "django.contrib.staticfiles.finders.FileSystemFinder",
 72 |     "django.contrib.staticfiles.finders.AppDirectoriesFinder",
 73 |     #    'django.contrib.staticfiles.finders.DefaultStorageFinder',
 74 | )
 75 | 
 76 | # Make this unique, and don't share it with anybody.
 77 | SECRET_KEY = "d2h8yt+x2g0$+e#9$z5z$auy%v0axov(wt3o*bj1#h^1+x^n(!"
 78 | 
 79 | MIDDLEWARE_CLASSES = (
 80 |     "django.contrib.sessions.middleware.SessionMiddleware",
 81 |     "django.contrib.auth.middleware.AuthenticationMiddleware",
 82 |     "django.contrib.messages.middleware.MessageMiddleware",
 83 |     "django.middleware.common.CommonMiddleware",
 84 | )
 85 | 
 86 | ROOT_URLCONF = "tests.views.urls"
 87 | 
 88 | # Python dotted path to the WSGI application used by Django's runserver.
 89 | WSGI_APPLICATION = "tumblelog.wsgi.application"
 90 | 
 91 | INSTALLED_APPS = (
 92 |     "django.contrib.auth",
 93 |     "django.contrib.contenttypes",
 94 |     "django.contrib.sessions",
 95 |     "django.contrib.sites",
 96 |     "django.contrib.messages",
 97 |     "django.contrib.staticfiles",
 98 |     "django_mongoengine",
 99 |     "tests.views",
100 |     "tests.forms",
101 | )
102 | 
103 | 
104 | # A sample logging configuration. The only tangible logging
105 | # performed by this configuration is to send an email to
106 | # the site admins on every HTTP 500 error when DEBUG=False.
107 | # See http://docs.djangoproject.com/en/dev/topics/logging for
108 | # more details on how to customize your logging configuration.
109 | LOGGING = {
110 |     "version": 1,
111 |     "disable_existing_loggers": False,
112 |     "filters": {"require_debug_false": {"()": "django.utils.log.RequireDebugFalse"}},
113 |     "handlers": {
114 |         "mail_admins": {
115 |             "level": "ERROR",
116 |             "filters": ["require_debug_false"],
117 |             "class": "django.utils.log.AdminEmailHandler",
118 |         }
119 |     },
120 |     "loggers": {
121 |         "django.request": {
122 |             "handlers": ["mail_admins"],
123 |             "level": "ERROR",
124 |             "propagate": True,
125 |         },
126 |     },
127 | }
128 | 
129 | TEMPLATES = [
130 |     {
131 |         "BACKEND": "django.template.backends.django.DjangoTemplates",
132 |         "DIRS": [],
133 |         "APP_DIRS": True,
134 |         "OPTIONS": {},
135 |     },
136 | ]
137 | 


--------------------------------------------------------------------------------
/tests/test_document_options.py:
--------------------------------------------------------------------------------
1 | from django_mongoengine.fields import ObjectIdField
2 | 
3 | from .views.models import City
4 | 
5 | 
6 | def test_id_field_uses_custom_class():
7 |     f = City._meta.get_field("id")
8 |     assert isinstance(f, ObjectIdField)
9 | 


--------------------------------------------------------------------------------
/tests/test_models.py:
--------------------------------------------------------------------------------
 1 | from .views.models import Artist, City
 2 | 
 3 | 
 4 | def test_create():
 5 |     City.objects.create(name="Dnipro")
 6 | 
 7 | 
 8 | def test_get_or_create():
 9 |     Artist.objects.get_or_create(id="1", defaults={"name": "The Doors"})
10 |     Artist.objects.get_or_create(id="1", defaults={"name": "The Doors"})
11 | 
12 | 
13 | def test_update_or_create():
14 |     Artist.objects.update_or_create(id="1", defaults={"name": "The Doors"})
15 |     Artist.objects.update_or_create(id="1", defaults={"name": "The Doors"})
16 | 


--------------------------------------------------------------------------------
/tests/test_utils/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/MongoEngine/django-mongoengine/298cdcf59b21fe590958f57f27bf28e7192fcc4e/tests/test_utils/__init__.py


--------------------------------------------------------------------------------
/tests/test_utils/test_monkey.py:
--------------------------------------------------------------------------------
 1 | import importlib
 2 | 
 3 | from mongoengine.queryset import QuerySet
 4 | 
 5 | from django_mongoengine.utils.monkey import get_patched_django_module
 6 | 
 7 | 
 8 | def test_monkey_patch():
 9 |     patched = get_patched_django_module("django.views.generic.list", QuerySet=QuerySet)
10 | 
11 |     assert patched.QuerySet is QuerySet
12 | 
13 |     original = importlib.import_module("django.views.generic.list")
14 | 
15 |     assert original.QuerySet is not QuerySet
16 | 


--------------------------------------------------------------------------------
/tests/views/__init__.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 | 


--------------------------------------------------------------------------------
/tests/views/detail.py:
--------------------------------------------------------------------------------
 1 | from django.core.exceptions import ImproperlyConfigured
 2 | 
 3 | from .models import Artist, Author, Page
 4 | from .tests import TestCase
 5 | 
 6 | 
 7 | class DetailViewTest(TestCase):
 8 |     def test_simple_object(self):
 9 |         res = self.client.get("/detail/obj/")
10 |         self.assertEqual(res.status_code, 200)
11 |         self.assertEqual(res.context["object"], {"foo": "bar"})
12 |         self.assertTemplateUsed(res, "views/detail.html")
13 | 
14 |     def test_detail_by_pk(self):
15 |         res = self.client.get("/detail/author/1/")
16 |         self.assertEqual(res.status_code, 200)
17 |         self.assertEqual(res.context["object"], Author.objects.get(pk="1"))
18 |         self.assertEqual(res.context["author"], Author.objects.get(pk="1"))
19 |         self.assertTemplateUsed(res, "views/author_detail.html")
20 | 
21 |     def test_detail_by_custom_pk(self):
22 |         res = self.client.get("/detail/author/bycustompk/1/")
23 |         self.assertEqual(res.status_code, 200)
24 |         self.assertEqual(res.context["object"], Author.objects.get(pk="1"))
25 |         self.assertEqual(res.context["author"], Author.objects.get(pk="1"))
26 |         self.assertTemplateUsed(res, "views/author_detail.html")
27 | 
28 |     def test_detail_by_slug(self):
29 |         res = self.client.get("/detail/author/byslug/scott-rosenberg/")
30 |         self.assertEqual(res.status_code, 200)
31 |         self.assertEqual(res.context["object"], Author.objects.get(slug="scott-rosenberg"))
32 |         self.assertEqual(res.context["author"], Author.objects.get(slug="scott-rosenberg"))
33 |         self.assertTemplateUsed(res, "views/author_detail.html")
34 | 
35 |     def test_detail_by_custom_slug(self):
36 |         res = self.client.get("/detail/author/bycustomslug/scott-rosenberg/")
37 |         self.assertEqual(res.status_code, 200)
38 |         self.assertEqual(res.context["object"], Author.objects.get(slug="scott-rosenberg"))
39 |         self.assertEqual(res.context["author"], Author.objects.get(slug="scott-rosenberg"))
40 |         self.assertTemplateUsed(res, "views/author_detail.html")
41 | 
42 |     def test_verbose_name(self):
43 |         res = self.client.get("/detail/artist/1/")
44 |         self.assertEqual(res.status_code, 200)
45 |         self.assertEqual(res.context["object"], Artist.objects.get(pk="1"))
46 |         self.assertEqual(res.context["artist"], Artist.objects.get(pk="1"))
47 |         self.assertTemplateUsed(res, "views/artist_detail.html")
48 | 
49 |     def test_template_name(self):
50 |         res = self.client.get("/detail/author/1/template_name/")
51 |         self.assertEqual(res.status_code, 200)
52 |         self.assertEqual(res.context["object"], Author.objects.get(pk="1"))
53 |         self.assertEqual(res.context["author"], Author.objects.get(pk="1"))
54 |         self.assertTemplateUsed(res, "views/about.html")
55 | 
56 |     def test_template_name_suffix(self):
57 |         res = self.client.get("/detail/author/1/template_name_suffix/")
58 |         self.assertEqual(res.status_code, 200)
59 |         self.assertEqual(res.context["object"], Author.objects.get(pk="1"))
60 |         self.assertEqual(res.context["author"], Author.objects.get(pk="1"))
61 |         self.assertTemplateUsed(res, "views/author_view.html")
62 | 
63 |     def test_template_name_field(self):
64 |         res = self.client.get("/detail/page/1/field/")
65 |         self.assertEqual(res.status_code, 200)
66 |         self.assertEqual(res.context["object"], Page.objects.get(pk="1"))
67 |         self.assertEqual(res.context["page"], Page.objects.get(pk="1"))
68 |         self.assertTemplateUsed(res, "views/page_template.html")
69 | 
70 |     def test_context_object_name(self):
71 |         res = self.client.get("/detail/author/1/context_object_name/")
72 |         self.assertEqual(res.status_code, 200)
73 |         self.assertEqual(res.context["object"], Author.objects.get(pk="1"))
74 |         self.assertEqual(res.context["thingy"], Author.objects.get(pk="1"))
75 |         self.assertFalse("author" in res.context)
76 |         self.assertTemplateUsed(res, "views/author_detail.html")
77 | 
78 |     def test_duplicated_context_object_name(self):
79 |         res = self.client.get("/detail/author/1/dupe_context_object_name/")
80 |         self.assertEqual(res.status_code, 200)
81 |         self.assertEqual(res.context["object"], Author.objects.get(pk="1"))
82 |         self.assertFalse("author" in res.context)
83 |         self.assertTemplateUsed(res, "views/author_detail.html")
84 | 
85 |     def test_invalid_url(self):
86 |         self.assertRaises(AttributeError, self.client.get, "/detail/author/invalid/url/")
87 | 
88 |     def test_invalid_queryset(self):
89 |         self.assertRaises(ImproperlyConfigured, self.client.get, "/detail/author/invalid/qs/")
90 | 


--------------------------------------------------------------------------------
/tests/views/forms.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | 
 3 | from django import forms
 4 | 
 5 | from django_mongoengine.forms import DocumentForm
 6 | 
 7 | from .models import Author
 8 | 
 9 | 
10 | class AuthorForm(DocumentForm):
11 |     name = forms.CharField()
12 |     slug = forms.SlugField()
13 | 
14 |     class Meta:
15 |         document = Author
16 |         fields = "__all__"
17 | 


--------------------------------------------------------------------------------
/tests/views/list.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | 
  3 | from django.core.exceptions import ImproperlyConfigured
  4 | 
  5 | from .models import Artist, Author
  6 | from .tests import TestCase
  7 | 
  8 | 
  9 | class ListViewTests(TestCase):
 10 |     def test_items(self):
 11 |         res = self.client.get("/list/dict/")
 12 |         self.assertEqual(res.status_code, 200)
 13 |         self.assertTemplateUsed(res, "views/list.html")
 14 |         self.assertEqual(res.context["object_list"][0]["first"], "John")
 15 | 
 16 |     def test_queryset(self):
 17 |         res = self.client.get("/list/authors/")
 18 |         self.assertEqual(res.status_code, 200)
 19 |         self.assertTemplateUsed(res, "views/author_list.html")
 20 |         self.assertEqual(list(res.context["object_list"]), list(Author.objects.all()))
 21 |         self.assertIs(res.context["author_list"], res.context["object_list"])
 22 |         self.assertIsNone(res.context["paginator"])
 23 |         self.assertIsNone(res.context["page_obj"])
 24 |         self.assertFalse(res.context["is_paginated"])
 25 | 
 26 |     def test_paginated_queryset(self):
 27 |         self._make_authors(100)
 28 |         res = self.client.get("/list/authors/paginated/")
 29 |         self.assertEqual(res.status_code, 200)
 30 |         self.assertTemplateUsed(res, "views/author_list.html")
 31 |         self.assertEqual(len(res.context["object_list"]), 30)
 32 |         self.assertIs(res.context["author_list"], res.context["object_list"])
 33 |         self.assertTrue(res.context["is_paginated"])
 34 |         self.assertEqual(res.context["page_obj"].number, 1)
 35 |         self.assertEqual(res.context["paginator"].num_pages, 4)
 36 |         self.assertEqual(res.context["author_list"][0].name, "Author 00")
 37 |         self.assertEqual(list(res.context["author_list"])[-1].name, "Author 29")
 38 | 
 39 |     def test_paginated_queryset_shortdata(self):
 40 |         # Test that short datasets ALSO result in a paginated view.
 41 |         res = self.client.get("/list/authors/paginated/")
 42 |         self.assertEqual(res.status_code, 200)
 43 |         self.assertTemplateUsed(res, "views/author_list.html")
 44 |         self.assertEqual(list(res.context["object_list"]), list(Author.objects.all()))
 45 |         self.assertIs(res.context["author_list"], res.context["object_list"])
 46 |         self.assertEqual(res.context["page_obj"].number, 1)
 47 |         self.assertEqual(res.context["paginator"].num_pages, 1)
 48 |         self.assertFalse(res.context["is_paginated"])
 49 | 
 50 |     def test_paginated_get_page_by_query_string(self):
 51 |         self._make_authors(100)
 52 |         res = self.client.get("/list/authors/paginated/", {"page": "2"})
 53 |         self.assertEqual(res.status_code, 200)
 54 |         self.assertTemplateUsed(res, "views/author_list.html")
 55 |         self.assertEqual(len(res.context["object_list"]), 30)
 56 |         self.assertIs(res.context["author_list"], res.context["object_list"])
 57 |         self.assertEqual(res.context["author_list"][0].name, "Author 30")
 58 |         self.assertEqual(res.context["page_obj"].number, 2)
 59 | 
 60 |     def test_paginated_get_last_page_by_query_string(self):
 61 |         self._make_authors(100)
 62 |         res = self.client.get("/list/authors/paginated/", {"page": "last"})
 63 |         self.assertEqual(res.status_code, 200)
 64 |         self.assertEqual(len(res.context["object_list"]), 10)
 65 |         self.assertIs(res.context["author_list"], res.context["object_list"])
 66 |         self.assertEqual(res.context["author_list"][0].name, "Author 90")
 67 |         self.assertEqual(res.context["page_obj"].number, 4)
 68 | 
 69 |     def test_paginated_get_page_by_urlvar(self):
 70 |         self._make_authors(100)
 71 |         res = self.client.get("/list/authors/paginated/3/")
 72 |         self.assertEqual(res.status_code, 200)
 73 |         self.assertTemplateUsed(res, "views/author_list.html")
 74 |         self.assertEqual(len(res.context["object_list"]), 30)
 75 |         self.assertIs(res.context["author_list"], res.context["object_list"])
 76 |         self.assertEqual(res.context["author_list"][0].name, "Author 60")
 77 |         self.assertEqual(res.context["page_obj"].number, 3)
 78 | 
 79 |     def test_paginated_page_out_of_range(self):
 80 |         self._make_authors(100)
 81 |         res = self.client.get("/list/authors/paginated/42/")
 82 |         self.assertEqual(res.status_code, 404)
 83 | 
 84 |     def test_paginated_invalid_page(self):
 85 |         self._make_authors(100)
 86 |         res = self.client.get("/list/authors/paginated/?page=frog")
 87 |         self.assertEqual(res.status_code, 404)
 88 | 
 89 |     def test_paginated_custom_paginator_class(self):
 90 |         self._make_authors(7)
 91 |         res = self.client.get("/list/authors/paginated/custom_class/")
 92 |         self.assertEqual(res.status_code, 200)
 93 |         self.assertEqual(res.context["paginator"].num_pages, 1)
 94 |         # Custom pagination allows for 2 orphans on a page size of 5
 95 |         self.assertEqual(len(res.context["object_list"]), 7)
 96 | 
 97 |     def test_paginated_custom_paginator_constructor(self):
 98 |         self._make_authors(7)
 99 |         res = self.client.get("/list/authors/paginated/custom_constructor/")
100 |         self.assertEqual(res.status_code, 200)
101 |         # Custom pagination allows for 2 orphans on a page size of 5
102 |         self.assertEqual(len(res.context["object_list"]), 7)
103 | 
104 |     def test_paginated_non_queryset(self):
105 |         res = self.client.get("/list/dict/paginated/")
106 |         self.assertEqual(res.status_code, 200)
107 |         self.assertEqual(len(res.context["object_list"]), 1)
108 | 
109 |     def test_verbose_name(self):
110 |         res = self.client.get("/list/artists/")
111 |         self.assertEqual(res.status_code, 200)
112 |         self.assertTemplateUsed(res, "views/list.html")
113 |         self.assertEqual(list(res.context["object_list"]), list(Artist.objects.all()))
114 |         self.assertIs(res.context["artist_list"], res.context["object_list"])
115 |         self.assertIsNone(res.context["paginator"])
116 |         self.assertIsNone(res.context["page_obj"])
117 |         self.assertFalse(res.context["is_paginated"])
118 | 
119 |     def test_allow_empty_false(self):
120 |         res = self.client.get("/list/authors/notempty/")
121 |         self.assertEqual(res.status_code, 200)
122 |         Author.objects.all().delete()
123 |         res = self.client.get("/list/authors/notempty/")
124 |         self.assertEqual(res.status_code, 404)
125 | 
126 |     def test_template_name(self):
127 |         res = self.client.get("/list/authors/template_name/")
128 |         self.assertEqual(res.status_code, 200)
129 |         self.assertEqual(list(res.context["object_list"]), list(Author.objects.all()))
130 |         self.assertIs(res.context["author_list"], res.context["object_list"])
131 |         self.assertTemplateUsed(res, "views/list.html")
132 | 
133 |     def test_template_name_suffix(self):
134 |         res = self.client.get("/list/authors/template_name_suffix/")
135 |         self.assertEqual(res.status_code, 200)
136 |         self.assertEqual(list(res.context["object_list"]), list(Author.objects.all()))
137 |         self.assertIs(res.context["author_list"], res.context["object_list"])
138 |         self.assertTemplateUsed(res, "views/author_objects.html")
139 | 
140 |     def test_context_object_name(self):
141 |         res = self.client.get("/list/authors/context_object_name/")
142 |         self.assertEqual(res.status_code, 200)
143 |         self.assertEqual(list(res.context["object_list"]), list(Author.objects.all()))
144 |         self.assertNotIn("authors", res.context)
145 |         self.assertIs(res.context["author_list"], res.context["object_list"])
146 |         self.assertTemplateUsed(res, "views/author_list.html")
147 | 
148 |     def test_duplicate_context_object_name(self):
149 |         res = self.client.get("/list/authors/dupe_context_object_name/")
150 |         self.assertEqual(res.status_code, 200)
151 |         self.assertEqual(list(res.context["object_list"]), list(Author.objects.all()))
152 |         self.assertNotIn("authors", res.context)
153 |         self.assertNotIn("author_list", res.context)
154 |         self.assertTemplateUsed(res, "views/author_list.html")
155 | 
156 |     def test_missing_items(self):
157 |         self.assertRaises(ImproperlyConfigured, self.client.get, "/list/authors/invalid/")
158 | 
159 |     def _make_authors(self, n):
160 |         Author.objects.all().delete()
161 |         for i in range(n):
162 |             Author.objects.create(id="%s" % i, name="Author %02i" % i, slug="a%s" % i)
163 | 


--------------------------------------------------------------------------------
/tests/views/models.py:
--------------------------------------------------------------------------------
 1 | from bson.objectid import ObjectId
 2 | from django.urls import reverse
 3 | 
 4 | from django_mongoengine import Document, fields
 5 | 
 6 | 
 7 | def object_id() -> str:
 8 |     return str(ObjectId())
 9 | 
10 | 
11 | class Artist(Document):
12 |     id = fields.StringField(primary_key=True, default=object_id)
13 |     name = fields.StringField(max_length=100, required=True)
14 | 
15 |     class Meta:
16 |         ordering = (["name"],)
17 |         verbose_name = ("professional artist",)
18 |         verbose_name_plural = "professional artists"
19 | 
20 |     def __str__(self):
21 |         return self.name or ""
22 | 
23 |     def get_absolute_url(self):
24 |         return reverse("artist_detail", args=(self.id,))
25 | 
26 | 
27 | class Author(Document):
28 |     id = fields.StringField(primary_key=True, default=object_id)
29 |     name = fields.StringField(max_length=100, required=True)
30 |     slug = fields.StringField(required=True)
31 | 
32 |     _meta = {"ordering": ["name"], "exclude": "id"}
33 | 
34 |     def __str__(self):
35 |         return self.name or ""
36 | 
37 | 
38 | class Book(Document):
39 |     id = fields.StringField(primary_key=True, default=object_id)
40 |     name = fields.StringField(max_length=300, required=True)
41 |     slug = fields.StringField(required=True)
42 |     pages = fields.IntField(required=True)
43 |     authors = fields.ListField(fields.ReferenceField(Author, required=True))
44 |     pubdate = fields.DateTimeField(required=True)
45 | 
46 |     _meta = {"ordering": ["-pubdate"]}
47 | 
48 |     def __str__(self):
49 |         return self.name or ""
50 | 
51 | 
52 | class Page(Document):
53 |     id = fields.StringField(primary_key=True, default=object_id)
54 |     content = fields.StringField(required=True)
55 |     template = fields.StringField(max_length=300, required=True)
56 | 
57 | 
58 | class City(Document):
59 |     name = fields.StringField(max_length=100, required=True)
60 | 


--------------------------------------------------------------------------------
/tests/views/templates/registration/login.html:
--------------------------------------------------------------------------------
1 | An empty login template.


--------------------------------------------------------------------------------
/tests/views/templates/views/about.html:
--------------------------------------------------------------------------------
1 | <h1>About</h1>
2 | {% now "U.u" %}


--------------------------------------------------------------------------------
/tests/views/templates/views/apple_detail.html:
--------------------------------------------------------------------------------
1 | This is a {% if tasty %}tasty {% endif %}{{ apple.color }} apple{{ extra }}


--------------------------------------------------------------------------------
/tests/views/templates/views/artist_detail.html:
--------------------------------------------------------------------------------
1 | This is an {{ artist }}.


--------------------------------------------------------------------------------
/tests/views/templates/views/artist_form.html:
--------------------------------------------------------------------------------
1 | A form: {{ form }}


--------------------------------------------------------------------------------
/tests/views/templates/views/author_confirm_delete.html:
--------------------------------------------------------------------------------
1 | Are you sure?


--------------------------------------------------------------------------------
/tests/views/templates/views/author_detail.html:
--------------------------------------------------------------------------------
1 | This is an {{ author }}.


--------------------------------------------------------------------------------
/tests/views/templates/views/author_form.html:
--------------------------------------------------------------------------------
1 | A form: {{ form }}


--------------------------------------------------------------------------------
/tests/views/templates/views/author_list.html:
--------------------------------------------------------------------------------
1 | {% for item in object_list %}
2 |   {{ item }}
3 | {% endfor %}


--------------------------------------------------------------------------------
/tests/views/templates/views/author_objects.html:
--------------------------------------------------------------------------------
1 | {% for item in object_list %}
2 |   {{ item }}
3 | {% endfor %}


--------------------------------------------------------------------------------
/tests/views/templates/views/author_view.html:
--------------------------------------------------------------------------------
1 | This is an alternate template_name_suffix for an {{ author }}.


--------------------------------------------------------------------------------
/tests/views/templates/views/book_archive.html:
--------------------------------------------------------------------------------
1 | Archive of books from {{ date_list }}.


--------------------------------------------------------------------------------
/tests/views/templates/views/book_archive_day.html:
--------------------------------------------------------------------------------
1 | Archive for {{ day }}. Previous day is {{ previous_day }}


--------------------------------------------------------------------------------
/tests/views/templates/views/book_archive_month.html:
--------------------------------------------------------------------------------
1 | Books in {{ month }}.


--------------------------------------------------------------------------------
/tests/views/templates/views/book_archive_week.html:
--------------------------------------------------------------------------------
1 | Archive for {{ week }}.


--------------------------------------------------------------------------------
/tests/views/templates/views/book_archive_year.html:
--------------------------------------------------------------------------------
1 | Archive of books from {{ year }}.


--------------------------------------------------------------------------------
/tests/views/templates/views/book_detail.html:
--------------------------------------------------------------------------------
1 | This is {{ book }}.


--------------------------------------------------------------------------------
/tests/views/templates/views/book_list.html:
--------------------------------------------------------------------------------
1 | {% for item in object_list %}
2 |   {{ item }}
3 | {% endfor %}


--------------------------------------------------------------------------------
/tests/views/templates/views/confirm_delete.html:
--------------------------------------------------------------------------------
1 | Generic: Are you sure?


--------------------------------------------------------------------------------
/tests/views/templates/views/detail.html:
--------------------------------------------------------------------------------
1 | Look, an {{ object }}.


--------------------------------------------------------------------------------
/tests/views/templates/views/form.html:
--------------------------------------------------------------------------------
1 | A generic form: {{ form }}


--------------------------------------------------------------------------------
/tests/views/templates/views/list.html:
--------------------------------------------------------------------------------
1 | {% for item in object_list %}
2 |   {{ item }}
3 | {% endfor %}


--------------------------------------------------------------------------------
/tests/views/templates/views/page_template.html:
--------------------------------------------------------------------------------
1 | This is some content: {{ content }}


--------------------------------------------------------------------------------
/tests/views/tests.py:
--------------------------------------------------------------------------------
 1 | import datetime
 2 | 
 3 | from tests import MongoTestCase
 4 | 
 5 | from .models import Artist, Author, Book, Page
 6 | 
 7 | 
 8 | class TestCase(MongoTestCase):
 9 |     def setUp(self):
10 |         Artist.drop_collection()
11 |         Author.drop_collection()
12 |         Book.drop_collection()
13 |         Page.drop_collection()
14 | 
15 |         Artist(id="1", name="Rene Magritte").save()
16 | 
17 |         Author(id="1", name="Roberto Bolaño", slug="roberto-bolano").save()
18 |         scott = Author(id="2", name="Scott Rosenberg", slug="scott-rosenberg").save()
19 | 
20 |         Book(
21 |             **{
22 |                 "id": "1",
23 |                 "name": "2066",
24 |                 "slug": "2066",
25 |                 "pages": "800",
26 |                 "authors": [scott],
27 |                 "pubdate": datetime.datetime(2008, 10, 1),
28 |             }
29 |         ).save()
30 | 
31 |         Book(
32 |             **{
33 |                 "id": "2",
34 |                 "name": "Dreaming in Code",
35 |                 "slug": "dreaming-in-code",
36 |                 "pages": "300",
37 |                 "authors": [scott],
38 |                 "pubdate": datetime.datetime(2006, 5, 1),
39 |             }
40 |         ).save()
41 | 
42 |         Page(
43 |             **{
44 |                 "id": "1",
45 |                 "template": "views/page_template.html",
46 |                 "content": "I was once bitten by a moose.",
47 |             }
48 |         ).save()
49 | 
50 | 
51 | from .detail import *  # noqa
52 | from .edit import *  # noqa
53 | from .list import *  # noqa
54 | 


--------------------------------------------------------------------------------
/tests/views/urls.py:
--------------------------------------------------------------------------------
  1 | from django.urls import re_path as url
  2 | from django.views.decorators.cache import cache_page
  3 | from django.views.generic import TemplateView
  4 | 
  5 | from . import views
  6 | 
  7 | urlpatterns = [
  8 |     # TemplateView
  9 |     url(r"^template/no_template/$", TemplateView.as_view()),
 10 |     url(r"^template/simple/(?P<foo>\w+)/$", TemplateView.as_view(template_name="views/about.html")),
 11 |     url(
 12 |         r"^template/custom/(?P<foo>\w+)/$",
 13 |         views.CustomTemplateView.as_view(template_name="views/about.html"),
 14 |     ),
 15 |     url(
 16 |         r"^template/cached/(?P<foo>\w+)/$",
 17 |         cache_page(2.0)(TemplateView.as_view(template_name="views/about.html")),
 18 |     ),
 19 |     # DetailView
 20 |     url(r"^detail/obj/$", views.ObjectDetail.as_view()),
 21 |     url(r"^detail/artist/(?P<pk>\d+)/$", views.ArtistDetail.as_view(), name="artist_detail"),
 22 |     url(r"^detail/author/(?P<pk>\d+)/$", views.AuthorDetail.as_view(), name="author_detail"),
 23 |     url(
 24 |         r"^detail/author/bycustompk/(?P<foo>\d+)/$", views.AuthorDetail.as_view(pk_url_kwarg="foo")
 25 |     ),
 26 |     url(r"^detail/author/byslug/(?P<slug>[\w-]+)/$", views.AuthorDetail.as_view()),
 27 |     url(
 28 |         r"^detail/author/bycustomslug/(?P<foo>[\w-]+)/$",
 29 |         views.AuthorDetail.as_view(slug_url_kwarg="foo"),
 30 |     ),
 31 |     url(
 32 |         r"^detail/author/(?P<pk>\d+)/template_name_suffix/$",
 33 |         views.AuthorDetail.as_view(template_name_suffix="_view"),
 34 |     ),
 35 |     url(
 36 |         r"^detail/author/(?P<pk>\d+)/template_name/$",
 37 |         views.AuthorDetail.as_view(template_name="views/about.html"),
 38 |     ),
 39 |     url(
 40 |         r"^detail/author/(?P<pk>\d+)/context_object_name/$",
 41 |         views.AuthorDetail.as_view(context_object_name="thingy"),
 42 |     ),
 43 |     url(
 44 |         r"^detail/author/(?P<pk>\d+)/dupe_context_object_name/$",
 45 |         views.AuthorDetail.as_view(context_object_name="object"),
 46 |     ),
 47 |     url(r"^detail/page/(?P<pk>\d+)/field/$", views.PageDetail.as_view()),
 48 |     url(r"^detail/author/invalid/url/$", views.AuthorDetail.as_view()),
 49 |     url(r"^detail/author/invalid/qs/$", views.AuthorDetail.as_view(queryset=None)),
 50 |     # Create/UpdateView
 51 |     url(r"^edit/artists/create/$", views.ArtistCreate.as_view()),
 52 |     url(r"^edit/artists/(?P<pk>\d+)/update/$", views.ArtistUpdate.as_view()),
 53 |     url(r"^edit/authors/create/naive/$", views.NaiveAuthorCreate.as_view()),
 54 |     url(
 55 |         r"^edit/authors/create/redirect/$",
 56 |         views.NaiveAuthorCreate.as_view(success_url="/edit/authors/create/"),
 57 |     ),
 58 |     url(
 59 |         r"^edit/authors/create/interpolate_redirect/$",
 60 |         views.NaiveAuthorCreate.as_view(success_url="/edit/author/{id}/update/"),
 61 |     ),
 62 |     url(r"^edit/authors/create/$", views.AuthorCreate.as_view()),
 63 |     url(r"^edit/authors/create/special/$", views.SpecializedAuthorCreate.as_view()),
 64 |     url(r"^edit/author/(?P<pk>\d+)/update/naive/$", views.NaiveAuthorUpdate.as_view()),
 65 |     url(
 66 |         r"^edit/author/(?P<pk>\d+)/update/redirect/$",
 67 |         views.NaiveAuthorUpdate.as_view(success_url="/edit/authors/create/"),
 68 |     ),
 69 |     url(
 70 |         r"^edit/author/(?P<pk>\d+)/update/interpolate_redirect/$",
 71 |         views.NaiveAuthorUpdate.as_view(success_url="/edit/author/{id}/update/"),
 72 |     ),
 73 |     url(r"^edit/author/(?P<pk>\d+)/update/$", views.AuthorUpdate.as_view()),
 74 |     url(r"^edit/author/update/$", views.OneAuthorUpdate.as_view()),
 75 |     url(r"^edit/author/(?P<pk>\d+)/update/special/$", views.SpecializedAuthorUpdate.as_view()),
 76 |     url(r"^edit/author/(?P<pk>\d+)/delete/naive/$", views.NaiveAuthorDelete.as_view()),
 77 |     url(
 78 |         r"^edit/author/(?P<pk>\d+)/delete/redirect/$",
 79 |         views.NaiveAuthorDelete.as_view(success_url="/edit/authors/create/"),
 80 |     ),
 81 |     url(r"^edit/author/(?P<pk>\d+)/delete/$", views.AuthorDelete.as_view()),
 82 |     url(r"^edit/author/(?P<pk>\d+)/delete/special/$", views.SpecializedAuthorDelete.as_view()),
 83 |     # ListView
 84 |     url(r"^list/dict/$", views.DictList.as_view()),
 85 |     url(r"^list/dict/paginated/$", views.DictList.as_view(paginate_by=1)),
 86 |     url(r"^list/artists/$", views.ArtistList.as_view(), name="artists_list"),
 87 |     url(r"^list/authors/$", views.AuthorList.as_view(), name="authors_list"),
 88 |     url(r"^list/authors/paginated/$", views.AuthorList.as_view(paginate_by=30)),
 89 |     url(r"^list/authors/paginated/(?P<page>\d+)/$", views.AuthorList.as_view(paginate_by=30)),
 90 |     url(r"^list/authors/notempty/$", views.AuthorList.as_view(allow_empty=False)),
 91 |     url(
 92 |         r"^list/authors/template_name/$", views.AuthorList.as_view(template_name="views/list.html")
 93 |     ),
 94 |     url(
 95 |         r"^list/authors/template_name_suffix/$",
 96 |         views.AuthorList.as_view(template_name_suffix="_objects"),
 97 |     ),
 98 |     url(
 99 |         r"^list/authors/context_object_name/$",
100 |         views.AuthorList.as_view(context_object_name="author_list"),
101 |     ),
102 |     url(
103 |         r"^list/authors/dupe_context_object_name/$",
104 |         views.AuthorList.as_view(context_object_name="object_list"),
105 |     ),
106 |     url(r"^list/authors/invalid/$", views.AuthorList.as_view(queryset=None)),
107 |     url(
108 |         r"^list/authors/paginated/custom_class/$",
109 |         views.AuthorList.as_view(paginate_by=5, paginator_class=views.CustomPaginator),
110 |     ),
111 |     url(r"^list/authors/paginated/custom_constructor/$", views.AuthorListCustomPaginator.as_view()),
112 | ]
113 | 


--------------------------------------------------------------------------------
/tests/views/views.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | 
  3 | from django.contrib.auth.decorators import login_required
  4 | from django.core.paginator import Paginator
  5 | from django.urls import reverse
  6 | from django.utils.decorators import method_decorator
  7 | from django.views.generic import TemplateView
  8 | 
  9 | from django_mongoengine import views
 10 | 
 11 | from .forms import AuthorForm
 12 | from .models import Artist, Author, Page  # Book
 13 | 
 14 | 
 15 | class CustomTemplateView(TemplateView):
 16 |     template_name = "views/about.html"
 17 | 
 18 |     def get_context_data(self, **kwargs):
 19 |         return {"params": kwargs, "key": "value"}
 20 | 
 21 | 
 22 | class ObjectDetail(views.DetailView):
 23 |     template_name = "views/detail.html"
 24 | 
 25 |     def get_object(self):
 26 |         return {"foo": "bar"}
 27 | 
 28 | 
 29 | class ArtistDetail(views.DetailView):
 30 |     queryset = Artist.objects.all()
 31 | 
 32 | 
 33 | class AuthorDetail(views.DetailView):
 34 |     queryset = Author.objects.all()
 35 | 
 36 | 
 37 | class PageDetail(views.DetailView):
 38 |     queryset = Page.objects.all()
 39 |     template_name_field = "template"
 40 | 
 41 | 
 42 | class DictList(views.ListView):
 43 |     """A ListView that doesn't use a model."""
 44 | 
 45 |     queryset = [{"first": "John", "last": "Lennon"}, {"first": "Yoko", "last": "Ono"}]
 46 |     template_name = "views/list.html"
 47 | 
 48 | 
 49 | class ArtistList(views.ListView):
 50 |     template_name = "views/list.html"
 51 |     queryset = Artist.objects.all()
 52 | 
 53 | 
 54 | class AuthorList(views.ListView):
 55 |     queryset = Author.objects.all().order_by("name")
 56 | 
 57 | 
 58 | class CustomPaginator(Paginator):
 59 |     def __init__(self, queryset, page_size, orphans=0, allow_empty_first_page=True):
 60 |         super().__init__(
 61 |             queryset, page_size, orphans=2, allow_empty_first_page=allow_empty_first_page
 62 |         )
 63 | 
 64 | 
 65 | class AuthorListCustomPaginator(AuthorList):
 66 |     paginate_by = 5
 67 | 
 68 |     def get_paginator(self, queryset, page_size, orphans=0, allow_empty_first_page=True):
 69 |         return super().get_paginator(
 70 |             queryset, page_size, orphans=2, allow_empty_first_page=allow_empty_first_page
 71 |         )
 72 | 
 73 | 
 74 | class ArtistCreate(views.CreateView):
 75 |     document = Artist
 76 |     fields = "__all__"
 77 | 
 78 | 
 79 | class NaiveAuthorCreate(views.CreateView):
 80 |     queryset = Author.objects.all()
 81 |     fields = "__all__"
 82 | 
 83 | 
 84 | class AuthorCreate(views.CreateView):
 85 |     document = Author
 86 |     success_url = "/list/authors/"
 87 |     fields = "__all__"
 88 | 
 89 | 
 90 | class SpecializedAuthorCreate(views.CreateView):
 91 |     document = Author
 92 |     form_class = AuthorForm
 93 |     template_name = "views/form.html"
 94 |     context_object_name = "thingy"
 95 | 
 96 |     def get_success_url(self):
 97 |         return reverse(
 98 |             "author_detail",
 99 |             args=[
100 |                 self.object.id,
101 |             ],
102 |         )
103 | 
104 | 
105 | class AuthorCreateRestricted(AuthorCreate):
106 |     post = method_decorator(login_required)(AuthorCreate.post)
107 | 
108 | 
109 | class ArtistUpdate(views.UpdateView):
110 |     document = Artist
111 |     fields = "__all__"
112 | 
113 | 
114 | class NaiveAuthorUpdate(views.UpdateView):
115 |     queryset = Author.objects.all()
116 |     fields = "__all__"
117 | 
118 | 
119 | class AuthorUpdate(views.UpdateView):
120 |     document = Author
121 |     success_url = "/list/authors/"
122 |     fields = "__all__"
123 | 
124 | 
125 | class OneAuthorUpdate(views.UpdateView):
126 |     success_url = "/list/authors/"
127 |     fields = "__all__"
128 | 
129 |     def get_object(self):
130 |         return Author.objects.get(pk="1")
131 | 
132 | 
133 | class SpecializedAuthorUpdate(views.UpdateView):
134 |     document = Author
135 |     form_class = AuthorForm
136 |     template_name = "views/form.html"
137 |     context_object_name = "thingy"
138 | 
139 |     def get_success_url(self):
140 |         return reverse("author_detail", args=[self.object.id])
141 | 
142 | 
143 | class NaiveAuthorDelete(views.DeleteView):
144 |     queryset = Author.objects.all()
145 | 
146 | 
147 | class AuthorDelete(views.DeleteView):
148 |     document = Author
149 |     success_url = "/list/authors/"
150 | 
151 | 
152 | class SpecializedAuthorDelete(views.DeleteView):
153 |     queryset = Author.objects.all()
154 |     template_name = "views/confirm_delete.html"
155 |     context_object_name = "thingy"
156 | 
157 |     def get_success_url(self):
158 |         return reverse("authors_list")
159 | 


--------------------------------------------------------------------------------