INSTALLED_APPS = [
    'polls.apps.PollsConfig',
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
]

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'django',
        'USER': 'django',
        'PASSWORD': 'django',
        'HOST': '127.0.0.1',
        'PORT': '3306',
    }
}

from .person import Person
from .user import User
from .identity_card import IdentityCard
from .car import Car

DATABASE_ROUTERS = ['django2.router.django2_router.Django2Router', ]

def allow_migrate(self, db, app_label, model_name=None, **hints):
    if db == 'django2_db':  #如果指定了数据库
        return app_label == 'django2' #并且model被设置了正确的app_label，则可以执行迁移文件
    elif app_label == 'django2':
        return False

# 缓存设置
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
        'LOCATION': '127.0.0.1:11211',
        'TIMEOUT': 600,  # 单位秒，默认300s, 60s * 10 = 10min
        'KEY_PREFIX': 'myapp',  # 缓存键的字符串前缀
    }
}

from django.core.cache import caches
cache = caches['default']

#如果希望使用默认的default，也可以
from django.core.cache import cache

cache.set('user_list', user_list)
user_list = cache.get('user_list')
user_list = cache.delete('user_list')

# 缓存设置
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
        'LOCATION': '127.0.0.1:11211',
        'TIMEOUT': 600,  # 单位秒，默认300s, 60s * 10 = 10min
        'KEY_PREFIX': 'myapp',  # 缓存键的字符串前缀
    },
    "redis": {
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": "redis:https://127.0.0.1:6379/1",
        'TIMEOUT': 600,
        "OPTIONS": {
            "CLIENT_CLASS": "django_redis.client.DefaultClient",
            "SOCKET_CONNECT_TIMEOUT": 5,  # in seconds socket 建立连接超时设置
            "SOCKET_TIMEOUT": 5,  # in seconds 连接建立后的读写操作超时设置
            "COMPRESSOR": "django_redis.compressors.zlib.ZlibCompressor",  # 压缩支持
            "IGNORE_EXCEPTIONS": True,  # 如果redis服务关闭，不会引起异常，memcached默认支持
            "CONNECTION_POOL_KWARGS": {"max_connections": 100}  # 连接池
        }
    }
}
# redis记录异常日志
DJANGO_REDIS_LOG_IGNORED_EXCEPTIONS = True

from django.core.cache import caches
redis_cache = caches['redis']

redis_cache.set('user_list', user_list)
user_list = redis_cache.get('user_list')
user_list = redis_cache.delete('user_list')

from django import template
register = template.Library()
color = ((1, 'red'), (2, 'black'), (3, 'blue'))

# @register.filter使用方法，最多两个参数
# {{ car.carColor|getcolorstr }}
# {{ car.carColor|getcolorstr:param2 }} 前面的表示第一个参数
@register.filter
def getcolorstr(colorNum):
    return color[colorNum - 1][1]


# @register.simple_tag使用方法，不限制参数个数
# {% getcolorstr2 car.carColor %}
# {% getcolorstr2 param1 param2 param3 %}
@register.simple_tag
def getcolorstr2(colorNum):
    return color[colorNum - 1][1]

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR, 'templates')]
        ,
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
            'libraries': {  # Adding this section should work around the issue.
                'utils': 'myapp.libraries.utils',
            },
        },
    },
]

from django.shortcuts import render

def bad_request(request, exception, template_name='400.html'):
    return render(request, template_name)


def permission_denied(request, exception, template_name='403.html'):
    return render(request, template_name)


def page_not_found(request, exception, template_name='404.html'):
    context = {'exception': exception}
    return render(request, template_name, context=context)


def server_error(request, template_name='500.html'):
    return render(request, template_name)

handler400 = 'DjangoHelloWorld.views.bad_request' #模块名称.views.方法名称
handler403 = 'DjangoHelloWorld.views.permission_denied'
handler404 = 'DjangoHelloWorld.views.page_not_found'
handler500 = 'DjangoHelloWorld.views.server_error'

import json
from django.core.serializers import serialize, deserialize
from django.db import models
from django.db.models.query import QuerySet
from django.http import JsonResponse

# 反序列化
def json_to_list(json):
    if json[0] == '[':
        deserializedObjectList = deserialize('json', json)
    else:
        deserializedObjectList = deserialize('json', '[' + json + ']')
    list = []
    for deserializedObject in deserializedObjectList:
        list.append(deserializedObject.object)
    return list


# 序列化
def to_json(obj):
    if isinstance(obj, models.Model):
        obj = [obj]  # 因为serialize只支持可迭代对象，比如querySet对象
    data = serialize("json", obj)
    return data


# 该方法没有做严格的验证，只支持dict,models.Model,models.QuerySet，可以根据需要自行扩展
def render_json(data, dict_key='data', **response_kwargs):
    if isinstance(data, dict):
        return JsonResponse(data)
    data = to_json(data)
    if 'safe' in response_kwargs and response_kwargs['safe'] is False:
        pass
    else:
        data = {dict_key: data}  # 默认必须传递字典数据
    if isinstance(data, str):  # 由于非字典类型的数据会被当做字符串处理，即返回结果两边都有引号，所以此处将其转换为对象，否则ajax调用时不方便处理
        data = json.loads(data)
    return JsonResponse(data, **response_kwargs)

def user_query_json(request):
    user_list = User.objects.all()
    return JSONUtil.render_json(user_list, safe=False) # safe=False可以传递对象，否则必须传递一个dict，ajax请求时这样要设置safe=False，这样页面可以直接获取到对象

def user_query_json_get(request, user_id):
    user = User.objects.get(pk=user_id)
    # user = User.objects.filter(pk=user_id)
    return JSONUtil.render_json(user, dict_key='user', safe=True)

# -*- coding=utf-8 -*-
from django.core import serializers
from django.db import models
from django.db.models.query import QuerySet
from django.http import HttpResponse


def render_xml(data):
    data = to_xml(data)
    response = HttpResponse(data)
    response['Content-Type'] = 'application/xml'
    return response

# 序列化
def to_xml(data):
    if isinstance(data, models.Model):
        data = [data]  # 因为serialize只支持可迭代对象，比如querySet对象
    elif isinstance(data, QuerySet):
        data = data
    else:
        pass
    data = serializers.serialize("xml", data)
    return data

# 反序列化
def xml_to_list(xml):
    deserializedObjectList = serializers.deserialize("xml", xml)
    list = []
    for deserializedObject in deserializedObjectList:
        list.append(deserializedObject.object)
    return list

from utils import XMLUtil

def user_query_xml(request):
    user_list = User.objects.all()
    return XMLUtil.render_xml(user_list)

def user_query_xml_get(request, user_id):
    user = User.objects.get(pk=user_id)
    return XMLUtil.render_xml(user)

response = render(request, 'myapp/user/index.html', context)
response['Last-Modified'] = date.strftime('%a, %d %b %Y %H:%M:%S GMT')
return response

LANGUAGE_CODE = 'zh-hans'  # 英文是en，这里是中文，注意这里必须配置为zh-hans，而下面创建和编译语言文件是要使用zh_hans
USE_I18N = True
LOCALE_PATHS = (
    os.path.join(BASE_DIR, 'myapp/locale'), # 应用下的路径
    os.path.join(BASE_DIR, 'locale'),
)

from django.utils.translation import ugettext as _
 output = _('Today is %(month)s %(day)s.') % {'month': m, 'day': d}

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.locale.LocaleMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

path('i18n/', include('django.conf.urls.i18n')), #对应下面的{% url 'set_language' %}

LANGUAGES = (
    ('en', ('English')),
    ('zh-hans', ('中文简体')),
    ('zh-hant', ('中文繁體')),
)

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,  # 是否禁用logger，建议设置为False
    'formatters': {  # 日志格式，提供给handler使用，非必须，如果不设置格式，默认只会打印消息体
        'verbose': {  # 格式名称
            # INFO 2018-04-25 15:43:27,586 views 8756 123145350217728 这是一个日志
            'format': '%(levelname)s %(asctime)s %(module)s %(process)d %(thread)d %(message)s'
        },
        'simple': {
            # INFO  这是一个日志
            'format': '%(levelname)s %(message)s'
        },
        'standard': {
            # 2018-04-25 16:40:00,195 [Thread-7:123145575223296] [myapp.log:282] [views:user_query_json_get] [INFO]- 这是一个日志
            'format': '%(asctime)s [%(threadName)s:%(thread)d] [%(name)s:%(lineno)d] [%(module)s:%(funcName)s] [%(levelname)s]- %(message)s'
        },

    },
    'filters': {  # 过滤器，提供给handler使用，非必须
        'require_debug_true': {  # 要求DEBUG=True时才打印日志
            '()': 'django.utils.log.RequireDebugTrue',
        },
    },
    'handlers': {  # 处理器，设置日志记录方式，必须
        'console': {  # 处理器名称
            'level': 'DEBUG',  # 设置级别
            'filters': ['require_debug_true'],  # 设置过滤器，多个用逗号分割
            'class': 'logging.StreamHandler',  # 处理器，这里是控制台打印
            'formatter': 'verbose'  # 设置日志格式
        },
        'file': {
            'level': 'DEBUG',
            'class': 'logging.FileHandler',  # 记录到文件
            'filename': '/Users/hanqunfeng/python_workspace/log/file.log',
            'formatter': 'verbose'
        },
        'rotatingFile': {
            'level': 'DEBUG',
            'class': 'logging.handlers.RotatingFileHandler',  # 按文件大小切割日志
            # 'filename': 'log/all.log',  # 日志输出文件 默认在当前项目根路径下
            'filename': '/Users/hanqunfeng/python_workspace/log/rotatingFile.log',  # 日志输出文件
            'maxBytes': 1024 * 1024 * 5,  # 每个文件大小
            'backupCount': 5,  # 保留日志份数，只保留最后5份，如果都保留，设置为0，默认就是0
            'formatter': 'standard',  # 使用哪种formatters日志格式
        },
		'timedRotatingFile': {
		    'level': 'DEBUG',
		    'class': 'logging.handlers.TimedRotatingFileHandler',  # 按时间切割日志
		    'filename': '/Users/hanqunfeng/python_workspace/log/timedRotatingFile.log',  # 日志输出文件
		    'when': 'D',  # 按天分割
		    'backupCount': 5,  # 保留日志份数，只保留最后5份，如果都保留，设置为0，默认就是0
		    'formatter': 'standard',  # 使用哪种formatters日志格式
		},
    },
    'loggers': {#日志记录器
        'django': {#日志名称路径前缀，即logging.getLogger(__name__)获取logger对象时，_name__得到的前缀与之匹配即可，比如__name__得到的是django.server
            'handlers': ['console'],
            'propagate': True,
            'level': os.getenv('DJANGO_LOG_LEVEL', 'DEBUG'),  # 只有设置DEBUG = True时，该配置才会打印sql信息
        },
        'django.request': {
            'handlers': ['rotatingFile'],
            'level': 'ERROR',
            'propagate': False,  # 设置为False，表示不像其父级别传递日志内容
        },
        'myapp.log': { # 也可以这样创建logger对象，logging.getLogger('myapp.log')
            'handlers': ['file', 'timedRotatingFile'],
            'level': 'INFO',  # 这里的日志级别不能低于处理器中设置的日志级别
        },
    },
}

# 导入logging库
import logging
# 获取logger的一个实例
# logger = logging.getLogger(__name__)
logger = logging.getLogger('myapp.log')

# 方法中：
logger.info('这是一个日志')

EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
EMAIL_USE_SSL = True
EMAIL_HOST = 'smtp.163.com'
EMAIL_PORT = 465
EMAIL_HOST_USER = '[email protected]'  # 帐号
EMAIL_HOST_PASSWORD = 'xxxxxxx'  # 密码
DEFAULT_FROM_EMAIL = 'hanqf <[email protected]>'

from django.conf import settings
# 发送邮件
from django.core.mail import send_mail
send_mail('Subject here主题', 'Here is the message.消息', settings.DEFAULT_FROM_EMAIL,
          ['[email protected]'], fail_silently=False)

# 一次可以发送多组邮件
from django.core.mail import send_mass_mail

message1 = ('Subject here', 'Here is the message', settings.DEFAULT_FROM_EMAIL,
            ['[email protected]', '[email protected]'])
message2 = ('Another Subject', 'Here is another message', settings.DEFAULT_FROM_EMAIL, ['[email protected]'])
send_mass_mail((message1, message2), fail_silently=False)

# 可以这是抄送附件等
from django.core.mail import EmailMultiAlternatives
msg = EmailMultiAlternatives('主题', '内容', settings.DEFAULT_FROM_EMAIL, ['[email protected]'],
                             cc=['[email protected]'])
# msg.content_subtype = "html" # 设置邮件格式，html可以发送内容为html，不推荐这么使用，可以使用下面的方式
html_content = '<p>这是一封<strong>重要的</strong>邮件.</p>'
msg.attach_alternative(html_content, "text/html")  # 如果接收方的邮件支持html，则显示该信息，否则显示原「内容」
# 添加附件（可选）
msg.attach_file('/Users/hanqunfeng/python_workspace/STATIC_ROOT/polls/images/background.jpg')
# 发送
msg.send()

if __name__ == '__main__':
    # 加载环境配置
    import django, os
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "DjangoHelloWorld.settings")
    django.setup()
    # 以下是测试内容
    from myapp.models.user import User
    user_list = User.objects.all()
    xml = to_xml(user_list)
    print(xml)

from django.dispatch import Signal, receiver
# my_singal = Signal()
my_singal = Signal(providing_args=["key1", "key2"]) # 定义信号接收的参数，不指定参数也可以

@receiver(my_singal)
def my_callback(sender, **kwargs): # 接收器回调函数
    print(sender)
    print(kwargs)
    for key in kwargs:
        print(key)
        print(kwargs[key])
    print("Request finished!")

from signals.signals import my_singal
my_singal.send(sender=__name__, key1='qqq', key2=10, key3=100) # 实际上可以多发送一些参数

DEBUG = False # 此时很多问题就会出现，需要增加很多额外的配置才能正常工作，这也是为了包含生产环境吧

ALLOWED_HOSTS = ['127.0.0.1']
# ALLOWED_HOSTS = ['*', ]  # 允许所有机器访问

STATIC_URL = 'https://localhost/static/'      # apache部署的静态文件服务器访问地址

STATIC_ROOT = "/Users/hanqunfeng/python_workspace/STATIC_ROOT/"  #apache 服务目录

# 上传文件路径
MEDIA_URL = 'https://localhost/media/'
MEDIA_ROOT = '/Users/hanqunfeng/python_workspace/MEDIA/'

photo = models.ImageField(upload_to="photo", default="default/django.jpeg")  # 路径相对于MEDIA_ROOT的配置

from django.conf import settings  # import the settings file

def settings_constant(request):
    # return the value you want as a dictionnary. you may add multiple values in there.
    return {'MEDIA_URL': settings.MEDIA_URL, 'DEBUG': settings.DEBUG}

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR, 'templates')]
        ,
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
                'polls.context_processors.settings_constant', #应用名称.文件名称.方法名称
            ],
        },
    },
]

input_img = request.FILES['photo']
question.photo = input_img
question.save()