web/warpauth/views/profile.py

-from django.shortcuts import render
-from django.http import HttpResponse, HttpResponseBadRequest, HttpResponseNotAllowed, HttpResponseNotFound
-from django.shortcuts import redirect
-from django.contrib.auth.decorators import login_required
-from warpauth.ldap_connector import LDAPConnector
-from warpauth.models import LdapUser
-from warpauth.util import *
-
-
-##
-# http://www.python-ldap.org/doc/html/ldap.html#ldap.LDAPObject
-##
-
-@login_required(login_url='/login/', redirect_field_name=None)
-def index(request):
-    pages["error"] = ""
-    pages["success"] = False
-    pages['ldap_groups'] = request.user.ldap_user.group_names
-    return HttpResponse(render(request, 'warpauth/profile.html', pages))
-
-
-@login_required(login_url='/login/', redirect_field_name=None)
-def change_password(request):
-    pages["error"] = ""
-    pages["success"] = False
-
-    if request.method != 'POST':
-        redirect("/")
-
-    if "old_pw" not in request.POST or "new_pw" not in request.POST or "new_pw_confirm" not in request.POST:
-        pages["error"] = "Please fill in all fields"
-    elif request.POST["new_pw"] != request.POST["new_pw_confirm"]:
-        pages["error"] = "Password confirmation did not match"
-    else:
-        ldap_connector = LDAPConnector()
-        ret = ldap_connector.change_password(request.user.ldap_user.dn, request.POST["old_pw"], request.POST["new_pw"])
-        if ret == -1:
-            pages["error"] = "Old password did not match"
-        else:
-            pages["success"] = True
-    return HttpResponse(render(request, 'warpauth/profile.html', pages))

web/warpfood/views.py

-from django.shortcuts import render
-from django.http import HttpResponse, HttpResponseBadRequest, HttpResponseNotAllowed, HttpResponseNotFound
-from django.shortcuts import redirect
-from django.contrib.auth.decorators import login_required
-from warpfood.util import *
-from warpfood.models import *
-from reportlab.pdfgen import canvas
-from django.http import HttpResponse
-from reportlab.platypus import SimpleDocTemplate
-from reportlab.platypus.tables import Table, TableStyle, colors
-
-#
-# ToDo: Hidden Field Paid default value to false
-# ToDo: Insert TemplateTag for Euro Format
-# ToDo: Implement Datetime Field for Estimated Order Time
-# ToDo: Username with hidden Field. Maybe insecure
-#
-
-def index(request):
-    pages['error'] = ""
-    if request.method == 'POST':
-        form = FoodSheetForm(request.POST)
-        if form.is_valid:
-            form.save()
-        else:
-            pages['error'] = form.errors
-    pages['food_sheets'] = FoodSheet.objects.all()
-    pages['pizza_services'] = FoodService.objects.all()
-    pages['create_food_sheet'] = FoodSheetForm()
-    return HttpResponse(render(request, 'warpfood/main.html', pages))
-
-
-def view(request, sheet_id=0):
-    pages['error'] = ""
-    if request.method == 'POST':
-        form = FoodOrderForm(request.POST)
-        if form.is_valid():
-            form.save()
-        else:
-            pages['error'] = form.errors
-            print(pages['error'])
-
-    if sheet_id != 0:
-        sheet = FoodSheet.objects.get(id=sheet_id)
-        pages['sheet'] = sheet
-        pages['orders'] = FoodOrder.objects.filter(sheet=sheet)
-        total_price = 0
-        for order in pages['orders']:
-            total_price += order.price
-        pages['order_sum'] = format_euro(total_price)
-        if request.user.is_authenticated():
-            pages['create_food_order'] = FoodOrderForm(initial={'sheet': sheet_id, 'user': request.user, 'paid': True})
-        else:
-            pages['create_food_order'] = FoodOrderFormExt(initial={'sheet': sheet_id, 'paid': True})
-
-        # ToDO: remove DEBUG
-
-        products = FoodProduct.objects.filter(food_service=sheet.food_service)
-        pages['food_products'] = {}
-        for product in products:
-            if product.food_category.name not in pages['food_products']:
-                pages['food_products'][product.food_category.name] = []
-            pages['food_products'][product.food_category.name].append(product)
-        print pages['food_products']
-    return HttpResponse(render(request, 'warpfood/view.html', pages))
-
-@login_required(login_url='/login/', redirect_field_name=None)
-def toggle_closed(request, sheet_id=0):
-    if sheet_id != 0:
-        sheet = FoodSheet.objects.get(id=sheet_id)
-        sheet.closed = not sheet.closed
-        sheet.save()
-
-    return redirect("/pizza/view/%s" % (sheet_id))
-
-
-def toggle_paid(request, order_id=0):
-    if order_id != 0:
-        order = FoodOrder.objects.get(id=order_id)
-        order.paid = not order.paid
-        order.save()
-        return redirect("/pizza/view/%s" % (order.sheet.id))
-
-
-@login_required(login_url='/login/', redirect_field_name=None)
-def export_sheet(request, sheet_id=0):
-    response = HttpResponse(content_type='application/pdf')
-    sheet = FoodSheet.objects.get(id=sheet_id)
-    response['Content-Disposition'] = 'attachment; filename="abbc.pdf"'
-    cm = 2.54
-    elements = []
-
-    doc = SimpleDocTemplate(response, showBoundary=1)
-
-    """
-    info_table = Table((sheet.pizza_service.name,sheet.pizza_service.phone),
-            [70,70],
-            [24]
-        )
-    """
-    data = [
-            ('User', 'Article', 'Size', 'Price', 'Comment', 'Paid'),
-    ]
-
-    for order in FoodOrder.objects.filter(sheet=sheet):
-        data.append(('', order.article, order.size, order.price, '', order.paid))
-
-    pizza_table = Table(data,
-            [70,70,70,70,70,70],
-            [24, 16,16]
-        )
-    """
-    t.setStyle(
-        TableStyle([
-        ('GRID', (1,1), (-2,-2), 0.25, colors.red),
-        ('BOX', (0,0), (-1,-1), 0.25, colors.blue, None, (2,2,1)),
-        ])
-    )
-    """
-    story = [info_table,pizza_table]
-    doc.build(story)
-    return response

web/warpmain/urls.py

-from django.conf.urls import url
-from warpmain.views import main
-from warpmain.views.admin import dashboard, news
-
-# ToDo: Use name tag of URL for Page Title
-urlpatterns = [
-
-    url(r'^$', main.index, name='News'),
-
-    url(r'^about/$', main.about, name='About'),
-    url(r'^administration/$', dashboard.index, name='admin_dashboard'),
-    url(r'^administration/news/$', news.news, name='admin_news'),
-
-
-]
-

web/warpmain/views/__init__.py

-__author__ = 'chris'

web/warpmain/views/admin/dashboard.py

-from django.shortcuts import render
-from django.http import HttpResponse
-from django.contrib.auth.decorators import login_required
-from warpauth.util import *
-
-
-@login_required(login_url='/login/', redirect_field_name=None)
-def index(request):
-    return HttpResponse(render(request, 'warpmain/admin/dashboard.html', pages))
-

web/warpmain/views/admin/news.py

-from django.shortcuts import render, redirect
-from django.http import HttpResponse
-from django.contrib.auth.decorators import login_required
-from warpauth.util import *
-from warpmain.models import News, NewsForm
-
-# ToDo: Not ready yet
-
-@login_required(login_url='/login/', redirect_field_name=None)
-def news(request, news_id=0):
-    if request.method == "POST":
-        news_form = NewsForm(request.POST)
-        if news_form.is_valid():
-            news = news_form.save()
-            news.user = request.user.ldap_username
-            news.save()
-            return redirect("/administration/news/")
-        else:
-            pages['create_news_form'] = news_form
-
-    else:
-        pages['news_list'] = News.objects.order_by("created")
-        pages['create_news_form'] = NewsForm()
-        if news_id != 0:
-            pages['create_news_form'] = NewsForm(News.objects.get(id=news_id))
-
-    return HttpResponse(render(request, 'warpmain/admin/news.html', pages))
-
-@login_required(login_url='/login/', redirect_field_name=None)
-def news_delete(request, news_id=0):
-    pass
\ No newline at end of file

web/warpmain/views/main.py

-from django.shortcuts import render
-from django.http import HttpResponse
-from django.contrib.auth.decorators import login_required
-from warpauth.util import *
-from warpmain.models import News
-
-
-@login_required(login_url='/login/', redirect_field_name=None)
-def index(request):
-    pages['news_list'] = News.objects.order_by("created")
-    return HttpResponse(render(request, 'warpmain/main.html', pages))
-
-def about(request):
-    return HttpResponse(render(request, 'warpmain/about.html', pages))

web/warpzone/urls.py

-import django
-from django.conf.urls import include, url
-from django.contrib import admin
-from django.conf import settings
-
-urlpatterns = [
-    url(r'^admin/', include(admin.site.urls)),
-    url(r'^media/(?P<path>.*)$', 'django.views.static.serve', {'document_root': settings.MEDIA_ROOT, }),
-    url(r'^', include('warpmain.urls')),
-    url(r'^', include('warpauth.urls')),
-    url(r'^', include('warpfood.urls')),
-]

web_docker/Dockerfile

-From debian:jessie
-
-RUN apt-get update && apt-get install -y \
-	debconf-utils \
-	apt-utils \
-	ssh \
-	less \
-	ldap-utils \
-	rsyslog \
-	nano \
-	python \
-	python-pip \
-	python-ldap \
-	python-dev \
-	build-essential \
-	libfreetype6-dev \
-	python-imaging \
-	libjpeg-dev
-
-RUN apt-get -y install libsasl2-dev python-dev libldap2-dev libssl-dev
-
-RUN pip install django \
-		django-ldapdb \
-		django-auth-ldap \
-		reportlab \
-		--upgrade
-
-RUN apt-get install -y python-bootstrapform
-COPY entrypoint.sh /opt/entrypoint.sh
-EXPOSE 22 8000
-
-VOLUME ["/opt/warpauth"]
-
-ENTRYPOINT sh /opt/entrypoint.sh
-

web_docker/build.sh

-docker build -t warpauth_web .

web_docker/entrypoint.sh

-service rsyslog restart
-cd /opt/warpauth;
-
-python manage.py makemigrations
-python manage.py migrate
-
-python manage.py runserver 0.0.0.0:8000
-
-bash
-

web_docker/run.sh

-docker run \
-	-v /home/chris/Documents/warpzone/pycharm/web:/opt/warpauth \
-	--link ldap:ldap \
-	-p 8000:8000 \
-	-itd \
-	warpauth_web

www/Dockerfile

+From debian:buster
+
+# Common Packages
+RUN apt-get update && apt-get install -y \
+    debconf-utils apt-utils rsyslog less nano \
+    ldap-utils \
+    build-essential \
+    libfreetype6-dev \
+    libjpeg-dev \
+    libsasl2-dev \
+    libldap2-dev \
+    libssl-dev \
+    gettext \
+    git \
+    nginx \
+    libmariadb-dev
+
+# Python Packages
+RUN apt-get update && apt-get install -y \
+	python3 \
+	python3-pip \
+	python3-dev \
+	python3-bootstrapform
+
+RUN pip3 install --upgrade pip
+
+RUN pip3 install \
+    django==1.10 \
+    django-ldapdb \
+    django-auth-ldap \
+    reportlab \
+    djangorestframework \
+    ldap3 \
+    uwsgi \
+    django-two-factor-auth \
+    matterhook \
+    markdown \
+    django-mysql \
+    mysqlclient \
+    bcrypt \
+    --upgrade
+
+RUN pip3 install git+https://github.com/nkunihiko/django-bootstrap3-datetimepicker.git
+
+RUN ln -s /opt/nginx/nginx_warpinfra.conf /etc/nginx/sites-enabled/
+RUN rm /etc/nginx/sites-enabled/default
+
+RUN mkdir /opt/socket/
+
+#COPY misc/ldapdb_base.py /usr/local/lib/python3.4/dist-packages/ldapdb/backends/ldap/base.py
+COPY misc/entrypoint.sh /opt/entrypoint.sh
+COPY misc/entrypoint_dev.sh /opt/entrypoint_dev.sh
+RUN chmod +x /opt/entrypoint*
+
+ADD web /opt/warpinfra/
+ADD nginx /opt/nginx
+
+EXPOSE 8000 443 80
+
+VOLUME ["/opt/nginx", "/opt/warpinfra"]
+
+ENTRYPOINT sh /opt/entrypoint.sh
+
+
+#COPY ldapdb_fields.py /usr/local/lib/python2.7/dist-packages/ldapdb/models/fields.py
+

www/build.sh

+SCRIPT=`realpath $0`
+SCRIPTPATH=`dirname $SCRIPT`
+docker build -t warpinfra $SCRIPTPATH/.

www/conf/config.example.ini

+[common]
+# Possible Apps: warpmain, warpauth, warpfood, warpapi, warppay
+APPS = warpmain, warpauth, warpfood, warppay, warpapi
+INSTANCE_NAME = 'EXTERN-TEST'
+GIT_COMMIT = 'fa684d694f5c7bdd915511d3e486ceaf076646af'
+DEPLOY_DATE = '28.03.2017'
+
+[debug]
+DEBUG = true
+
+[security]
+SECRET_KEY = '4m4c(_$ubwued9p-insp!950g&r0yu851bp287$2a3ydj^y=0='
+PW_RESET_TOKEN_LIFETIME = 5
+ALLOWED_HOSTS = infra.warpzone.ms
+
+[mattermost]
+API_KEY = bohtwe6zy7y43p5n36skph7ejy
+
+[ldap]
+LDAP_HOST = ldap
+LDAP_BIND_DN = cn=admin,dc=warpzone,dc=ms
+LDAP_PASSWORD = 
+
+LDAP_USER_SEARCH_PATH = ou=users,dc=warpzone,dc=ms
+LDAP_GROUP_SEARCH_PATH = dc=warpzone,dc=ms
+LDAP_USER_SEARCH_FILTER = (uid=%(user)s)
+
+LDAP_GROUP_IS_ACTIVE = cn=active,ou=groups,dc=warpzone,dc=ms
+LDAP_GROUP_IS_STAFF = cn=superuser,ou=groups,ou=warpauth,ou=infrastructure,dc=warpzone,dc=ms
+LDAP_GROUP_SUPERUSER = cn=superuser,ou=groups,ou=warpauth,ou=infrastructure,dc=warpzone,dc=ms
+
+[email]
+SMTP_HOST = smtp.warpzone.ms
+SMTP_PORT = 25
+SMTP_USERNAME = noreply@warpzone.ms
+SMTP_PASSWORD = 
+SMTP_EMAIL_FROM = noreply@warpzone.ms
+SMTP_USE_TLS = True
+SUBJECT_PREFIX = '[WarpInfra] '
+
+[misc]
+LOG_PATH = /var/log/
\ No newline at end of file

www/misc/entrypoint.sh

+#!/bin/bash
+#service rsyslog restart
+
+cd /opt/warpinfra;
+python3 manage.py migrate
+python3 manage.py compilemessages
+python3 manage.py collectstatic --noinput
+
+cp -r /opt/warpinfra/static /opt/socket/
+uwsgi --ini /opt/nginx/uwsgi.ini --py-autoreload 1
+
+tail -f /var/log/uwsgi.log

www/misc/entrypoint_dev.sh

+#!/bin/bash
+#service rsyslog restart
+
+cd /opt/warpinfra;
+python3 manage.py migrate
+python3 manage.py compilemessages
+python3 manage.py collectstatic --noinput
+python3 manage.py runserver 0.0.0.0:80
+

www/misc/ldapdb_base.py

+# -*- coding: utf-8 -*-
+# This software is distributed under the two-clause BSD license.
+# Copyright (c) The django-ldapdb project
+
+from __future__ import unicode_literals
+
+import ldap
+import django
+
+if django.VERSION < (1, 8):
+    from django.db.backends import (BaseDatabaseFeatures, BaseDatabaseOperations,
+                                    BaseDatabaseWrapper)
+    from django.db.backends.creation import BaseDatabaseCreation
+else:
+    from django.db.backends.base.features import BaseDatabaseFeatures
+    from django.db.backends.base.operations import BaseDatabaseOperations
+    from django.db.backends.base.base import BaseDatabaseWrapper
+    from django.db.backends.base.creation import BaseDatabaseCreation
+    from django.db.backends.base.validation import BaseDatabaseValidation
+
+
+class DatabaseCreation(BaseDatabaseCreation):
+    def create_test_db(self, *args, **kwargs):
+        """
+        Creates a test database, prompting the user for confirmation if the
+        database already exists. Returns the name of the test database created.
+        """
+        pass
+
+    def destroy_test_db(self, *args, **kwargs):
+        """
+        Destroy a test database, prompting the user for confirmation if the
+        database already exists. Returns the name of the test database created.
+        """
+        pass
+
+
+class DatabaseCursor(object):
+    def __init__(self, ldap_connection):
+        self.connection = ldap_connection
+
+
+class DatabaseFeatures(BaseDatabaseFeatures):
+    def __init__(self, connection):
+        self.connection = connection
+        self.supports_transactions = False
+
+
+class DatabaseOperations(BaseDatabaseOperations):
+    compiler_module = "ldapdb.backends.ldap.compiler"
+
+    def quote_name(self, name):
+        return name
+
+    def no_limit_value(self):
+        return -1
+
+
+class LdapDatabase(object):
+    # Base class for all exceptions
+    Error = ldap.LDAPError
+
+    class DatabaseError(Error):
+        """Database-side errors."""
+
+    class OperationalError(
+            DatabaseError,
+            ldap.ADMINLIMIT_EXCEEDED,
+            ldap.AUTH_METHOD_NOT_SUPPORTED,
+            ldap.AUTH_UNKNOWN,
+            ldap.BUSY,
+            ldap.CONFIDENTIALITY_REQUIRED,
+            ldap.CONNECT_ERROR,
+            ldap.INAPPROPRIATE_AUTH,
+            ldap.INVALID_CREDENTIALS,
+            ldap.OPERATIONS_ERROR,
+            ldap.RESULTS_TOO_LARGE,
+            ldap.SASL_BIND_IN_PROGRESS,
+            ldap.SERVER_DOWN,
+            ldap.SIZELIMIT_EXCEEDED,
+            ldap.STRONG_AUTH_NOT_SUPPORTED,
+            ldap.STRONG_AUTH_REQUIRED,
+            ldap.TIMELIMIT_EXCEEDED,
+            ldap.TIMEOUT,
+            ldap.UNAVAILABLE,
+            ldap.UNAVAILABLE_CRITICAL_EXTENSION,
+            ldap.UNWILLING_TO_PERFORM,
+    ):
+        """Exceptions related to the database operations, out of the programmer control."""
+
+    class IntegrityError(
+            DatabaseError,
+            ldap.AFFECTS_MULTIPLE_DSAS,
+            ldap.ALREADY_EXISTS,
+            ldap.CONSTRAINT_VIOLATION,
+            ldap.TYPE_OR_VALUE_EXISTS,
+    ):
+        """Exceptions related to database Integrity."""
+
+    class DataError(
+            DatabaseError,
+            ldap.INVALID_DN_SYNTAX,
+            ldap.INVALID_SYNTAX,
+            ldap.NOT_ALLOWED_ON_NONLEAF,
+            ldap.NOT_ALLOWED_ON_RDN,
+            ldap.OBJECT_CLASS_VIOLATION,
+            ldap.UNDEFINED_TYPE,
+    ):
+        """Exceptions related to invalid data"""
+
+    class InterfaceError(
+            ldap.CLIENT_LOOP,
+            ldap.DECODING_ERROR,
+            ldap.ENCODING_ERROR,
+            ldap.LOCAL_ERROR,
+            ldap.LOOP_DETECT,
+            ldap.NO_MEMORY,
+            ldap.PROTOCOL_ERROR,
+            ldap.REFERRAL_LIMIT_EXCEEDED,
+            ldap.USER_CANCELLED,
+            Error,
+    ):
+        """Exceptions related to the pyldap interface."""
+
+    class InternalError(
+            DatabaseError,
+            ldap.ALIAS_DEREF_PROBLEM,
+            ldap.ALIAS_PROBLEM,
+    ):
+        """Exceptions encountered within the database."""
+
+    class ProgrammingError(
+            DatabaseError,
+            ldap.CONTROL_NOT_FOUND,
+            ldap.FILTER_ERROR,
+            ldap.INAPPROPRIATE_MATCHING,
+            ldap.NAMING_VIOLATION,
+            ldap.NO_SUCH_ATTRIBUTE,
+            ldap.NO_SUCH_OBJECT,
+            ldap.PARAM_ERROR,
+    ):
+        """Invalid data send by the programmer."""
+
+    class NotSupportedError(
+            DatabaseError,
+            ldap.NOT_SUPPORTED,
+    ):
+        """Exception for unsupported actions."""
+
+
+class DatabaseWrapper(BaseDatabaseWrapper):
+    vendor = 'ldap'
+
+    Database = LdapDatabase
+
+    # NOTE: These are copied from the mysql DatabaseWrapper
+    operators = {
+        'exact': '= %s',
+        'iexact': 'LIKE %s',
+        'contains': 'LIKE BINARY %s',
+        'icontains': 'LIKE %s',
+        'regex': 'REGEXP BINARY %s',
+        'iregex': 'REGEXP %s',
+        'gt': '> %s',
+        'gte': '>= %s',
+        'lt': '< %s',
+        'lte': '<= %s',
+        'startswith': 'LIKE BINARY %s',
+        'endswith': 'LIKE BINARY %s',
+        'istartswith': 'LIKE %s',
+        'iendswith': 'LIKE %s',
+    }
+
+    def __init__(self, *args, **kwargs):
+        super(DatabaseWrapper, self).__init__(*args, **kwargs)
+
+        # Charset used for LDAP text *values*
+        self.charset = "utf-8"
+        self.creation = DatabaseCreation(self)
+        self.features = DatabaseFeatures(self)
+        self.ops = DatabaseOperations(self)
+        self.settings_dict['SUPPORTS_TRANSACTIONS'] = True
+        self.autocommit = True
+
+        if django.VERSION >= (1, 8):
+            self.validation = BaseDatabaseValidation(self)
+
+    def close(self):
+        if hasattr(self, 'validate_thread_sharing'):
+            # django >= 1.4
+            self.validate_thread_sharing()
+        if self.connection is not None:
+            self.connection.unbind_s()
+            self.connection = None
+
+    def get_connection_params(self):
+        """Compute appropriate parameters for establishing a new connection.
+
+        Computed at system startup.
+        """
+        return {
+            'uri': self.settings_dict['NAME'],
+            'tls': self.settings_dict.get('TLS', False),
+            'bind_dn': self.settings_dict['USER'],
+            'bind_pw': self.settings_dict['PASSWORD'],
+            'options': self.settings_dict.get('CONNECTION_OPTIONS', {}),
+        }
+
+    def get_new_connection(self, conn_params):
+        """Build a connection from its parameters."""
+        connection = ldap.initialize(conn_params['uri'], bytes_mode=False)
+
+        options = conn_params['options']
+        for opt, value in options.items():
+            connection.set_option(opt, value)
+
+        if conn_params['tls']:
+            connection.start_tls_s()
+
+        connection.simple_bind_s(
+            conn_params['bind_dn'],
+            conn_params['bind_pw'],
+        )
+        return connection
+
+    def init_connection_state(self):
+        """Initialize python-side connection state."""
+        pass
+
+    def _commit(self):
+        pass
+
+    def _cursor(self):
+        self.ensure_connection()
+        return DatabaseCursor(self.connection)
+
+    def _rollback(self):
+        pass
+
+    def _set_autocommit(self, autocommit):
+        pass
+
+    def add_s(self, dn, modlist):
+        cursor = self._cursor()
+        return cursor.connection.add_s(dn, modlist)
+
+    def delete_s(self, dn):
+        cursor = self._cursor()
+        return cursor.connection.delete_s(dn)
+
+    def modify_s(self, dn, modlist):
+        cursor = self._cursor()
+        return cursor.connection.modify_s(dn, modlist)
+
+    def rename_s(self, dn, newrdn):
+        cursor = self._cursor()
+        return cursor.connection.rename_s(dn, newrdn)
+
+    def search_s(self, base, scope, filterstr='(objectClass=*)',
+                 attrlist=None):
+        cursor = self._cursor()
+        results = cursor.connection.search_s(base, scope, filterstr, attrlist)
+        output = []
+        for dn, attrs in results:
+            # skip referrals
+            if dn is not None:
+                output.append((dn, attrs))
+        return output
\ No newline at end of file

www/misc/ldapdb_fields.py

+# -*- coding: utf-8 -*-
+# This software is distributed under the two-clause BSD license.
+# Copyright (c) The django-ldapdb project
+
+from __future__ import unicode_literals
+
+from ldapdb import escape_ldap_filter
+import datetime
+from django.db.models import fields
+
+
+class CharField(fields.CharField):
+    def __init__(self, *args, **kwargs):
+        defaults = {'max_length': 200}
+        defaults.update(kwargs)
+        super(CharField, self).__init__(*args, **defaults)
+
+    def from_ldap(self, value, connection):
+        if len(value) == 0:
+            return ''
+        else:
+            return value[0].decode(connection.charset)
+
+    def get_db_prep_lookup(self, lookup_type, value, connection,
+                           prepared=False):
+        "Returns field's value prepared for database lookup."
+        if lookup_type == 'endswith':
+            return ["*%s" % escape_ldap_filter(value)]
+        elif lookup_type == 'startswith':
+            return ["%s*" % escape_ldap_filter(value)]
+        elif lookup_type in ['contains', 'icontains']:
+            return ["*%s*" % escape_ldap_filter(value)]
+        elif lookup_type == 'exact':
+            return [escape_ldap_filter(value)]
+        elif lookup_type == 'in':
+            return [escape_ldap_filter(v) for v in value]
+
+        raise TypeError("CharField has invalid lookup: %s" % lookup_type)
+
+    def get_db_prep_save(self, value, connection):
+        if not value:
+            return None
+        return [value.encode(connection.charset)]
+
+    def get_prep_lookup(self, lookup_type, value):
+        "Perform preliminary non-db specific lookup checks and conversions"
+        if lookup_type == 'endswith':
+            return "*%s" % escape_ldap_filter(value)
+        elif lookup_type == 'startswith':
+            return "%s*" % escape_ldap_filter(value)
+        elif lookup_type in ['contains', 'icontains']:
+            return "*%s*" % escape_ldap_filter(value)
+        elif lookup_type == 'exact':
+            return escape_ldap_filter(value)
+        elif lookup_type == 'in':
+            return [escape_ldap_filter(v) for v in value]
+
+        raise TypeError("CharField has invalid lookup: %s" % lookup_type)
+
+
+class ImageField(fields.Field):
+    def from_ldap(self, value, connection):
+        if len(value) == 0:
+            return ''
+        else:
+            return value[0]
+
+    def get_db_prep_lookup(self, lookup_type, value, connection,
+                           prepared=False):
+        "Returns field's value prepared for database lookup."
+        return [self.get_prep_lookup(lookup_type, value)]
+
+    def get_db_prep_save(self, value, connection):
+        if not value:
+            return None
+        return [value]
+
+    def get_prep_lookup(self, lookup_type, value):
+        "Perform preliminary non-db specific lookup checks and conversions"
+        raise TypeError("ImageField has invalid lookup: %s" % lookup_type)
+
+
+class IntegerField(fields.IntegerField):
+    def from_ldap(self, value, connection):
+        if len(value) == 0:
+            return 0
+        else:
+            return int(value[0])
+
+    def get_db_prep_lookup(self, lookup_type, value, connection,
+                           prepared=False):
+        "Returns field's value prepared for database lookup."
+        return [self.get_prep_lookup(lookup_type, value)]
+
+    def get_db_prep_save(self, value, connection):
+        if value is None:
+            return None
+        return [str(value).encode(connection.charset)]
+
+    def get_prep_lookup(self, lookup_type, value):
+        "Perform preliminary non-db specific lookup checks and conversions"
+        if lookup_type in ('exact', 'gte', 'lte'):
+            return value
+        raise TypeError("IntegerField has invalid lookup: %s" % lookup_type)
+
+
+class FloatField(fields.FloatField):
+    def from_ldap(self, value, connection):
+        if len(value) == 0:
+            return 0.0
+        else:
+            return float(value[0])
+
+    def get_db_prep_lookup(self, lookup_type, value, connection,
+                           prepared=False):
+        "Returns field's value prepared for database lookup."
+        return [self.get_prep_lookup(lookup_type, value)]
+
+    def get_db_prep_save(self, value, connection):
+        if value is None:
+            return None
+        return [str(value).encode(connection.charset)]
+
+    def get_prep_lookup(self, lookup_type, value):
+        "Perform preliminary non-db specific lookup checks and conversions"
+        if lookup_type in ('exact', 'gte', 'lte'):
+            return value
+        raise TypeError("FloatField has invalid lookup: %s" % lookup_type)
+
+
+class ListField(fields.Field):
+
+    def from_ldap(self, value, connection):
+        return [x.decode(connection.charset) for x in value]
+
+    def get_db_prep_lookup(self, lookup_type, value, connection,
+                           prepared=False):
+        "Returns field's value prepared for database lookup."
+        return [self.get_prep_lookup(lookup_type, value)]
+
+    def get_db_prep_save(self, value, connection):
+        if not value:
+            return None
+        return [x.encode(connection.charset) for x in value]
+
+    def get_prep_lookup(self, lookup_type, value):
+        "Perform preliminary non-db specific lookup checks and conversions"
+        if lookup_type == 'contains':
+            return escape_ldap_filter(value)
+        raise TypeError("ListField has invalid lookup: %s" % lookup_type)
+
+    def from_db_value(self, value, expression, connection, context):
+        if not value:
+            return []
+        return value
+
+    def to_python(self, value):
+        if not value:
+            return []
+        return value
+
+
+class DateField(fields.DateField):
+    """
+    A text field containing date, in specified format.
+    The format can be specified as 'format' argument, as strptime()
+    format string. It defaults to ISO8601 (%Y-%m-%d).
+
+    Note: 'lte' and 'gte' lookups are done string-wise. Therefore,
+    they will onlywork correctly on Y-m-d dates with constant
+    component widths.
+    """
+
+    def __init__(self, *args, **kwargs):
+        if 'format' in kwargs:
+            self._date_format = kwargs.pop('format')
+        else:
+            self._date_format = '%Y-%m-%d'
+        super(DateField, self).__init__(*args, **kwargs)
+
+    def from_ldap(self, value, connection):
+        if len(value) == 0:
+            return None
+        else:
+            return datetime.datetime.strptime(value[0],
+                                              self._date_format).date()
+
+    def get_db_prep_lookup(self, lookup_type, value, connection,
+                           prepared=False):
+        "Returns field's value prepared for database lookup."
+        return [self.get_prep_lookup(lookup_type, value)]
+
+    def get_db_prep_save(self, value, connection):
+        if not value:
+            return None
+        if not isinstance(value, datetime.date) \
+                and not isinstance(value, datetime.datetime):
+            raise ValueError(
+                'DateField can be only set to a datetime.date instance')
+
+        return [value.strftime(self._date_format)]
+
+    def get_prep_lookup(self, lookup_type, value):
+        "Perform preliminary non-db specific lookup checks and conversions"
+        if lookup_type in ('exact',):
+            return value
+        raise TypeError("DateField has invalid lookup: %s" % lookup_type)
\ No newline at end of file

www/nginx/nginx_warpinfra.conf

+upstream django {
+    server unix:///opt/socket/warpinfra.sock;
+}
+
+server {
+    listen      80;
+    server_name _;
+    charset     utf-8;
+
+    client_max_body_size 100M;   # adjust to taste
+
+    location /static {
+        alias /opt/warpinfra/static; # your Django project's static files - amend as required
+    }
+
+    # Finally, send all non-media requests to the Django server.
+    location / {
+        uwsgi_pass  django;
+        include     /opt/nginx/uwsgi_params; # the uwsgi_params file you installed
+    }
+
+#    return 301 https://$host$request_uri;
+}
+
+# configuration of the server
+server {
+
+    listen      443;
+    server_name _;
+    charset     utf-8;
+    
+    
+    ssl    on;
+    ssl_certificate         /opt/nginx/warpinfra.crt;
+    ssl_certificate_key     /opt/nginx/warpinfra.key;
+
+    # max upload size
+    client_max_body_size 100M;   # adjust to taste
+
+    # Django media
+#    location /media  {
+#        alias /opt/flaghunter/media;  # your Django project's media files - amend as required
+#    }
+
+    location /static {
+        alias /opt/warpinfra/static; # your Django project's static files - amend as required
+    }
+
+    # Finally, send all non-media requests to the Django server.
+    location / {
+        uwsgi_pass  django;
+        include     /opt/nginx/uwsgi_params; # the uwsgi_params file you installed
+    }
+}