分页器（paginator）
分页器的使用
>>> from django.core.paginator import Paginator
>>> objects = ['john', 'paul', 'george', 'ringo']
>>> p = Paginator(objects, 2)
>>> p.count #数据总数
4
>>> p.num_pages #总页数
2
>>> type(p.page_range) # `<type 'rangeiterator'>` in Python 2.
<class 'range_iterator'>
>>> p.page_range #页码的列表
range(1, 3) # =========[1,2]
>>> page1 = p.page(1) #第1页的page对象
>>> page1
<Page 1 of 2>
>>> page1.object_list #第1页的数据
['john', 'paul']
>>> page2 = p.page(2)
>>> page2.object_list #第2页的数据
['george', 'ringo']
>>> page2.has_next() #是否有下一页
False
>>> page2.has_previous() #是否有上一页
True
>>> page2.has_other_pages() #是否有其他页
True
>>> page2.next_page_number() #下一页的页码
Traceback (most recent call last):
...
EmptyPage: That page contains no results
>>> page2.previous_page_number() #上一页的页码
1
>>> page2.start_index() # 本页第一条记录的序数（从1开始）
3
>>> page2.end_index() # 本页最后录一条记录的序数（从1开始）
4
>>> p.page(0) #错误的页，抛出异常
Traceback (most recent call last):
...
EmptyPage: That page number is less than 1
>>> p.page(3) #错误的页，抛出异常
Traceback (most recent call last):
...
EmptyPage: That page contains no results
实现一个分页效果：
Template:
{% load staticfiles %}
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
<link rel="stylesheet" href="{% static 'bootstrap.css' %}">
</head>
<body>
<div class="container">
<h4>分页器</h4>
<ul>
{% for book in book_list %}
<li>{{ book.title }} {{ book.price }}</li>
{% endfor %}
</ul>
<ul class="pagination" id="pager">
{% if book_list.has_previous %}
<li class="previous"><a href="/blog/?page={{ book_list.previous_page_number }}">上一页</a></li>
{% else %}
<li class="previous disabled"><a href="#">上一页</a></li>
{% endif %}
{% for num in paginator.page_range %}
{% if num == currentPage %}
<li class="item active"><a href="/blog/?page={{ num }}">{{ num }}</a></li>
{% else %}
<li class="item"><a href="/blog/?page={{ num }}">{{ num }}</a></li>
{% endif %}
{% endfor %}
{% if book_list.has_next %}
<li class="next"><a href="/blog/?page={{ book_list.next_page_number }}">下一页</a></li>
{% else %}
<li class="next disabled"><a href="#">下一页</a></li>
{% endif %}
</ul>
</div>
</body>
</html>
views：
from django.shortcuts import render,HttpResponse
# Create your views here.
from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
from app01.models import *
def index(request):
'''
批量导入数据:
Booklist=[]
for i in range(100):
Booklist.append(Book(title="book"+str(i),price=30+i*i))
Book.objects.bulk_create(Booklist)
'''
book_list=Book.objects.all()
paginator = Paginator(book_list, 10)
page = request.GET.get('page',1)
currentPage=int(page)
try:
print(page)
book_list = paginator.page(page)
except PageNotAnInteger:
book_list = paginator.page(1)
except EmptyPage:
book_list = paginator.page(paginator.num_pages)
return render(request,"index.html",locals())
一、COOKIE 与 SESSION
1、简介
1、cookie不属于http协议范围，由于http协议无法保持状态，但实际情况，我们却又需要“保持状态”，因此cookie就是在这样一个场景下诞生。
cookie的工作原理是：由服务器产生内容，浏览器收到请求后保存在本地；当浏览器再次访问时，浏览器会自动带上cookie，这样服务器就能通过cookie的内容来判断这个是“谁”了。
2、cookie虽然在一定程度上解决了“保持状态”的需求，但是由于cookie本身最大支持4096字节，以及cookie本身保存在客户端，可能被拦截或窃取，因此就需要有一种新的东西，它能支持更多的字节，并且他保存在服务器，有较高的安全性。这就是session。
问题来了，基于http协议的无状态特征，服务器根本就不知道访问者是“谁”。那么上述的cookie就起到桥接的作用。
我们可以给每个客户端的cookie分配一个唯一的id，这样用户在访问时，通过cookie，服务器就知道来的人是“谁”。然后我们再根据不同的cookie的id，在服务器上保存一段时间的私密资料，如“账号密码”等等。
3、总结而言：cookie弥补了http无状态的不足，让服务器知道来的人是“谁”；但是cookie以文本的形式保存在本地，自身安全性较差；所以我们就通过cookie识别不同的用户，对应的在session里保存私密的信息以及超过4096字节的文本。
4、另外，上述所说的cookie和session其实是共通性的东西，不限于语言和框架。
2、认证应用
cookie和session配合的认证机制
每当我们使用一款浏览器访问一个登陆页面的时候，一旦我们通过了认证。服务器端就会发送一组随机唯一的字符串（假设是123abc）到浏览器端，这个被存储在浏览端的东西就叫cookie。而服务器端也会自己存储一下用户当前的状态，比如login=true，username=hahaha之类的用户信息。但是这种存储是以字典形式存储的，字典的唯一key就是刚才发给用户的唯一的cookie值。那么如果在服务器端查看session信息的话，理论上就会看到如下样子的字典
{'123abc':{'login':true,'username:hahaha'}}
因为每个cookie都是唯一的，所以我们在电脑上换个浏览器再登陆同一个网站也需要再次验证。那么为什么说我们只是理论上看到这样子的字典呢？因为处于安全性的考虑，其实对于上面那个大字典不光key值123abc是被加密的，value值{'login':true,'username:hahaha'}在服务器端也是一样被加密的。所以我们服务器上就算打开session信息看到的也是类似与以下样子的东西
{'123abc':dasdasdasd1231231da1231231}
1、为什么要使用 Cookie 和 Session
由于 Http 协议的请求过程，是基于 TCP/IP 的，当客户端请求服务器，服务器处理后，进行响应，这个过程是无状态的。在有些时候，是需要保存一些客户端的请求信息，识别客户端的某些状态，智能的、有针对性的去分析某些客户端的习惯。这些时候，就需要去记录客户端的连接状态，识别请求的状态等。为了解决类似的事情，就需要使用到了 Cookie 和 Session。
2、Cookie 和 Session 的具体知识
（1）Cookie: 在客户端访问某个地址时，会将请求交到服务器进行处理，在发送请求的时候，浏览器会将页面的头部信息一并的交到服务器端进行处理。在处理的过程中，Cookie 在服务器端生成 ，在此同时，可以将一些需要保存的信息，存放到此 Cookie 中。生成 Cookie 对象时，需要确定具体的名称及具体的值，可以设置当前 Cookie 的过期时间，设置过期时间后，就相当于持久化了 Cookie 中的数据，此时的 Cookie 会以之前的 Cookie 名称，保存在客户端。
如果不设置过期时间，则当前 Cookie 的生命期是浏览器会话期间，一旦关闭了该浏览器，当前的Cookie 就会不存在了，此时的 Cookie 信息是保存在内存中。在服务器端，处理完后，会将生成的 Cookie ，随着 Http 响应，会在 Http 响应头中，加上Cookie 信息，浏览器接受到响应后，会按照 Http 响应头里的 Cookie ，在客户端建立 Cookie 。在下次客户进行请求的时候，Http 会附带着已经存储过的 Cookie ，一并发送到服务器。一个域，在客户端建立的所以 Cookie 都是可以共享的，只要 Cookie 没有过期。
（2）Session: Session 是在服务器端生成的，存储在服务器端，即存在内存中。可以对生成的 Session 设置过期时间，如果不设置过期时间，默认的 Session 过期时间是30 分钟（在不同的服务器中，它的过期时间略有不同，本文是以 Tomcat 来说的） 但是，Sesssion 的生成的同时，会生成一个与之相关联的的 SessionID ，此 SessionID的存储是需要 Cookie 来完成的。 SessionID 是以名称为 JSESSIONID，其值应该是一个既不会重复，又不容易被找到规律以仿造的字符串。SessionID会随着此次 Http 响应，一并返回到客户端，并保存在客户端中。到当前请求再次发出后，该 SessionID会随着 Http 头部，传到服务器中，服务器依据当前 SessionID 得到与之对应的 Session.
其中：通过 Cookie 的方式存储 Session 状态，只是其中一种方式。如果客户端禁用了 Cookie 的话，很多网站任然可以存储用户的信息。一种处理的方式是URL 重写，将 SesseionID 直接附加在请求地址的后面。另一种处理的方式是，使用隐藏自动的方式。就是服务器自动的在表单中，添加一个隐藏字段，以便在表单提交时，将 SesseionID 一起传到服务器，进行识别。
3、Cookie 和 Session 的具体使用
最近，我在写一个代码生成器的时候，我希望在我填写完数据库连接信息后，浏览器帮我把这些信息保存起来，以免每次我需要使用的时候，都去填写，浪费时间。下面是我具体的做法：
1 /** 2 * 存储数据库连接对象 3 * @author 高青 4 * 2014-6-14 5 * @param database 数据库连接对象 6 * @param request http 请求对象 7 * @param response http 响应对象 8 * @param jonArray 数据库中的所有表和 JSONArray 对象 9 * @return null 空 10 */ 11 private String storeDatabaseInfo(Database database, 12 HttpServletRequest request, HttpServletResponse response, 13 JSONArray jonArray) { 14 /* 15 * 判断： 16 * （1）如果 session 存在并且存储过 database 数据，则不再进行重复保存 17 * （2）如果，没有，则将数据存储到 Session 中 18 */ 19 20 HttpSession session = request.getSession(false); 21 if(session != null && session.getAttribute("database") != null){ 22 //（1）如果 session 存在并且存储过 database 数据，则不再进行重复保存 23 24 log.info("当前回话已经保存过 databse 的数据了，不再进行重复的保存！"); 25 }else{ 26 //（2）如果，没有，则将数据存储到 Session 中 27 28 session.setAttribute("database", database); 29 session.setMaxInactiveInterval(60*60); 30 } 31 32 /* 33 * 判断： 34 * （1）如果 request 中保存过，则不再进行重复保存 35 * （2）如果，没有，则将数据存储到 Cookie 中 36 */ 37 Cookie[] cookies = request.getCookies(); 38 if((cookies != null)){ 39 for (Cookie cookie : cookies) { 40 if (cookie.getName().equals("database")) { 41 log.info("当前Cookie 中，已经保存过 databse 的数据了，不再进行重复的保存！"); 42 43 //（1）如果 request 中保存过，则不再进行重复保存 44 return jonArray.toString(); 45 } 46 } 47 } 48 49 //（2）如果，没有，则将数据存储到 Cookie 中 50 String databaseInfoStr = database.getDatabaseType() + "_" + database.getUrl() + "_" + 51 database.getPort() + "_" + database.getUser() + "_" + 52 database.getPassword() + "_" + database.getDatabaseName() + "_" + database.getTable(); 53 Cookie databaseInfo = new Cookie("database", databaseInfoStr); 54 databaseInfo.setMaxAge(60*60); //设置 Cookie 的过期时间 55 databaseInfo.setHttpOnly(true); //设置 Cookie 的使用协议 56 databaseInfo.setPath("/CodeGenerator/"); //设置 Cookie 的使用域 57 response.addCookie(databaseInfo); 58 59 return null; 60 }
其中：特别注意的是，在生成 Cookie 后，如果不设置当前 Cookie 的使用，无论有没有设置 Cookie 的过期时间，当下次访问的时候，都是获取不到该名称对应的 Cookie 的。如果设置databaseInfo.setPath（“/”）使用在全局的环境中，所有的请求都可以使用该 Cookie ， 如果设置和项目相关的域，如：databaseInfo.setPath("/CodeGenerator/")，在只会在当前项目的访问下使用当前 Cookie 。
（4）Cookie 和 Session 的区别
首先，Cookie 是存储在客户端的，Session 是存储在服务器端的。
其次，在保存相对安全性低的信息时候，可以考虑使用 Cookie，在相对安全性要求高的信息时候，可以考试使用 Session。毕竟 Cookie 存在客户端，其他人可以查找并分析的。
最后，在对性能要求高的时候，不适合使用 Session 的，因为 Session 会一直存在服务器的，直到当前 Session 过期，而且 Cookie 存储是字符串类型的信息，而 Session 可以存储任何形式的信息，Session 也不存在访问域的限制。
个人觉得，在存储相对持久的信息时，应考虑使用 Cookie ,因为 Cookie 可以以文件的形式，存储在客户端。在进行一些登录的验证及信息拦截的时候，可以使用 Session。
Django实现的COOKIE
1、获取Cookie
request.COOKIES['key']
request.get_signed_cookie(key, default=RAISE_ERROR, salt='', max_age=None)
#参数：
default: 默认值
salt: 加密盐
max_age: 后台控制过期时间
2、设置Cookie
rep = HttpResponse(...) 或 rep ＝ render(request, ...) 或 rep ＝ redirect()
rep.set_cookie(key,value,...)
rep.set_signed_cookie(key,value,salt='加密盐',...)
参数：
''' def set_cookie(self, key, 键 value='', 值 max_age=None, 超长时间 expires=None, 超长时间 path='/', Cookie生效的路径， 浏览器只会把cookie回传给带有该路径的页面，这样可以避免将 cookie传给站点中的其他的应用。 / 表示根路径，特殊的：根路径的cookie可以被任何url的页面访问 domain=None, Cookie生效的域名 你可用这个参数来构造一个跨站cookie。 如， domain=".example.com" 所构造的cookie对下面这些站点都是可读的： www.example.com 、 www2.example.com
和an.other.sub.domain.example.com 。 如果该参数设置为 None ，cookie只能由设置它的站点读取。 secure=False, 如果设置为 True ，浏览器将通过HTTPS来回传cookie。 httponly=False 只能http协议传输，无法被JavaScript获取 （不是绝对，底层抓包可以获取到也可以被覆盖） ): pass '''
由于cookie保存在客户端的电脑上，所以，JavaScript和jquery也可以操作cookie。
<script src='/static/js/jquery.cookie.js'>
</script> $.cookie("key", value,{ path: '/' });
3 删除cookie
response.delete_cookie("cookie_key",path="/",domain=name)
cookie存储到客户端
优点：
数据存在在客户端，减轻服务器端的压力，提高网站的性能。
缺点：
安全性不高：在客户端机很容易被查看或破解用户会话信息
Django实现的SESSION
1、 基本操作
1、设置Sessions值 request.session['session_name'] ="admin" 2、获取Sessions值 session_name = request.session["session_name"] 3、删除Sessions值 del request.session["session_name"] 4、检测是否操作session值 if "session_name" is request.session :5、get(key, default=None)fav_color=request.session.get('fav_color','red')
6、pop(key)
fav_color = request.session.pop('fav_color')
7、keys()
8、items()
9、setdefault()
10、flush() 删除当前的会话数据并删除会话的Cookie。
这用于确保前面的会话数据不可以再次被用户的浏览器访问
例如，django.contrib.auth.logout() 函数中就会调用它。
11 用户session的随机字符串 request.session.session_key # 将所有Session失效日期小于当前日期的数据删除 request.session.clear_expired() request.session.exists("session_key") request.session.delete("session_key") request.session.set_expiry(value) * 如果value是个整数，session会在些秒数后失效。 * 如果value是个datatime或timedelta，session就会在这个时间后失效。 * 如果value是0,用户关闭浏览器session就会失效。 * 如果value是None,session会依赖全局session失效策略。2、 流程解析图
3、 示例
views:
def log_in(request): if request.method=="POST": username=request.POST['user'] password=request.POST['pwd'] user=UserInfo.objects.filter(username=username,password=password) if user: #设置session内部的字典内容 request.session['is_login']='true' request.session['username']=username #登录成功就将url重定向到后台的url return redirect('/backend/') #登录不成功或第一访问就停留在登录页面 return render(request,'login.html') def backend(request): print(request.session,"------cookie") print(request.COOKIES,'-------session') """ 这里必须用读取字典的get()方法把is_login的value缺省设置为False， 当用户访问backend这个url先尝试获取这个浏览器对应的session中的 is_login的值。如果对方登录成功的话，在login里就已经把is_login 的值修改为了True,反之这个值就是False的 """ is_login=request.session.get('is_login',False) #如果为真，就说明用户是正常登陆的 if is_login: #获取字典的内容并传入页面文件 cookie_content=request.COOKIES session_content=request.session username=request.session['username'] return render(request,'backend.html',locals()) else: """ 如果访问的时候没有携带正确的session， 就直接被重定向url回login页面 """ return redirect('/login/') def log_out(request): """ 直接通过request.session['is_login']回去返回的时候， 如果is_login对应的value值不存在会导致程序异常。所以 需要做异常处理 """ try: #删除is_login对应的value值 del request.session['is_login'] # OR---->request.session.flush() # 删除django-session表中的对应一行记录 except KeyError: pass #点击注销之后，直接重定向回登录页面 return redirect('/login/')
template:
===================================login.html================== <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> <form action="/login/" method="post"> <p>用户名: <input type="text" name="user"></p> <p>密码: <input type="password" name="pwd"></p> <p><input type="submit"></p> </form> </body> </html> ===================================backend.html================== <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> <h3>hello {{ username }}</h3> <a href="/logout/">注销</a> </body> </html>
4、session存储的相关配置
Django默认支持Session，并且默认是将Session数据存储在数据库中，即：django_session 表中。 a. 配置 settings.py SESSION_ENGINE = 'django.contrib.sessions.backends.db' # 引擎（默认） SESSION_COOKIE_NAME ＝ "sessionid" # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串（默认） SESSION_COOKIE_PATH ＝ "/" # Session的cookie保存的路径（默认） SESSION_COOKIE_DOMAIN = None # Session的cookie保存的域名（默认） SESSION_COOKIE_SECURE = False # 是否Https传输cookie（默认） SESSION_COOKIE_HTTPONLY = True # 是否Session的cookie只支持http传输（默认） SESSION_COOKIE_AGE = 1209600 # Session的cookie失效日期（2周）（默认） SESSION_EXPIRE_AT_BROWSER_CLOSE = False # 是否关闭浏览器使得Session过期（默认） SESSION_SAVE_EVERY_REQUEST = False # 是否每次请求都保存Session，默认修改之后才保存（默认）
a. 配置 settings.py SESSION_ENGINE = 'django.contrib.sessions.backends.cache' # 引擎 SESSION_CACHE_ALIAS = 'default' # 使用的缓存别名（默认内存缓存，也可以是memcache），此处别名依赖缓存的设置 SESSION_COOKIE_NAME ＝ "sessionid" # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串 SESSION_COOKIE_PATH ＝ "/" # Session的cookie保存的路径 SESSION_COOKIE_DOMAIN = None # Session的cookie保存的域名 SESSION_COOKIE_SECURE = False # 是否Https传输cookie SESSION_COOKIE_HTTPONLY = True # 是否Session的cookie只支持http传输 SESSION_COOKIE_AGE = 1209600 # Session的cookie失效日期（2周） SESSION_EXPIRE_AT_BROWSER_CLOSE = False # 是否关闭浏览器使得Session过期 SESSION_SAVE_EVERY_REQUEST = False # 是否每次请求都保存Session，默认修改之后才保存
a. 配置 settings.py SESSION_ENGINE = 'django.contrib.sessions.backends.file' # 引擎 SESSION_FILE_PATH = None # 缓存文件路径，如果为None，则使用tempfile模块获取一个临时地址tempfile.gettempdir() SESSION_COOKIE_NAME ＝ "sessionid" # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串 SESSION_COOKIE_PATH ＝ "/" # Session的cookie保存的路径 SESSION_COOKIE_DOMAIN = None # Session的cookie保存的域名 SESSION_COOKIE_SECURE = False # 是否Https传输cookie SESSION_COOKIE_HTTPONLY = True # 是否Session的cookie只支持http传输 SESSION_COOKIE_AGE = 1209600 # Session的cookie失效日期（2周） SESSION_EXPIRE_AT_BROWSER_CLOSE = False # 是否关闭浏览器使得Session过期 SESSION_SAVE_EVERY_REQUEST = False # 是否每次请求都保存Session，默认修改之后才保存
用户认证 auth模块
from django.contrib import auth
django.contrib.auth中提供了许多方法，这里主要介绍其中的三个：
1 、authenticate()
提供了用户认证，即验证用户名以及密码是否正确,一般需要username password两个关键字参数
如果认证信息有效，会返回一个 User 对象。authenticate()会在User 对象上设置一个属性标识那种认证后端认证了该用户，且该信息在后面的登录过程中是需要的。当我们试图登陆一个从数据库中直接取出来不经过authenticate()的User对象会报错的！！
user = authenticate(username='someone',password='somepassword')
2 、login(HttpRequest, user)
该函数接受一个HttpRequest对象，以及一个认证了的User对象
此函数使用django的session框架给某个已认证的用户附加上session id等信息。
from django.contrib.auth import authenticate, login
def my_view(request):
username = request.POST['username']
password = request.POST['password']
user = authenticate(username=username, password=password)
if user is not None:
login(request, user)
# Redirect to a success page.
...
else:
# Return an 'invalid login' error message.
...
3 、logout(request) 注销用户
from django.contrib.auth import logout def logout_view(request): logout(request) # Redirect to a success page.
该函数接受一个HttpRequest对象，无返回值。当调用该函数时，当前请求的session信息会全部清除。该用户即使没有登录，使用该函数也不会报错。
4 、user对象的 is_authenticated()
要求：
1 用户登陆后才能访问某些页面，
2 如果用户没有登录就访问该页面的话直接跳到登录页面
3 用户在跳转的登陆界面中完成登陆后，自动访问跳转到之前访问的地址
方法1:
def my_view(request):
if not request.user.is_authenticated():
return redirect('%s?next=%s' % (settings.LOGIN_URL, request.path))
方法2:
django已经为我们设计好了一个用于此种情况的装饰器：login_requierd()
from django.contrib.auth.decorators import login_required @login_required def my_view(request): ...
若用户没有登录，则会跳转到django默认的 登录URL '/accounts/login/ ' (这个值可以在settings文件中通过LOGIN_URL进行修改)。并传递 当前访问url的绝对路径 (登陆成功后，会重定向到该路径)。
User对象
User 对象属性：username， password（必填项）password用哈希算法保存到数据库
is_staff ： 用户是否拥有网站的管理权限.
is_active ： 是否允许用户登录, 设置为``False``，可以不用删除用户来禁止 用户登录
2.1 、is_authenticated()
如果是真正的 User 对象，返回值恒为 True 。 用于检查用户是否已经通过了认证。
通过认证并不意味着用户拥有任何权限，甚至也不检查该用户是否处于激活状态，这只是表明用户成功的通过了认证。 这个方法很重要, 在后台用request.user.is_authenticated()判断用户是否已经登录，如果true则可以向前台展示request.user.name
2.2 、创建用户
使用 create_user 辅助函数创建用户:
from django.contrib.auth.models import User
user = User.objects.create_user（username='',password='',email=''）
2.3 、check_password(passwd)
2.3 、check_password(passwd)
用户需要修改密码的时候 首先要让他输入原来的密码 ，如果给定的字符串通过了密码检查，返回 True
2.4 、修改密码
使用 set_password() 来修改密码
user = User.objects.get(username='')
user.set_password(password='')
user.save
2.5 、简单示例
注册：
def sign_up(request):
state = None
if request.method == 'POST':
password = request.POST.get('password', '')
repeat_password = request.POST.get('repeat_password', '')
email=request.POST.get('email', '')
username = request.POST.get('username', '')
if User.objects.filter(username=username):
state = 'user_exist'
else:
new_user = User.objects.create_user(username=username, password=password,email=email)
new_user.save()
return redirect('/book/')
content = {
'state': state,
'user': None,
}
return render(request, 'sign_up.html', content)
修改密码：
@login_required
def set_password(request):
user = request.user
state = None
if request.method == 'POST':
old_password = request.POST.get('old_password', '')
new_password = request.POST.get('new_password', '')
repeat_password = request.POST.get('repeat_password', '')
if user.check_password(old_password):
if not new_password:
state = 'empty'
elif new_password != repeat_password:
state = 'repeat_error'
else:
user.set_password(new_password)
user.save()
return redirect("/log_in/")
else:
state = 'password_error'
content = {
'user': user,
'state': state,
}
return render(request, 'set_password.html', content)