def upload(request):
if request.user.username != UPLOAD_USER:
return render_to_response('address/error',
{'message': '你需要使用 %s 来登录！' % UPLOAD_USER})
file_obj = request.FILES.get('file', None)
if file_obj:
import csv
import StringIO
buf = StringIO.StringIO(file_obj['content'])
try:
reader = csv.reader(buf)
except:
return render_to_response('address/error',
{'message': '你需要上传一个csv格式的文件！'})
for row in reader:
objs = addresses.get_list(name__exact=row[0])
if not objs:
obj = addresses.Address(name=row[0],
gender=row[1],
telphone=row[2],
mobile=row[3],
room=row[4])
else:
obj = objs[0]
obj.gender = row[1]
obj.telphone = row[2]
obj.mobile = row[3]
obj.room = row[4]
obj.save()
return HttpResponseRedirect('/address/')
else:
return render_to_response('address/error', {'message': '你需要上传一个文件！'})
def upload(request):
if request.user.username != UPLOAD_USER:
return render_to_response('address/error', {'message':'你需要使用 %s 来登录！' % UPLOAD_USER})
file_obj = request.FILES.get('file', None)
if file_obj:
import csv
import StringIO
buf = StringIO.StringIO(file_obj['content'])
try:
reader = csv.reader(buf)
except:
return render_to_response('address/error', {'message':'你需要上传一个csv格式的文件！'})
for row in reader:
objs = addresses.get_list(name__exact=row[0])
if not objs:
obj = addresses.Address(name=row[0], gender=row[1], telphone=row[2], mobile=row[3], room=row[4])
else:
obj = objs[0]
obj.gender = row[1]
obj.telphone = row[2]
obj.mobile = row[3]
obj.room = row[4]
obj.save()
return HttpResponseRedirect('/address/')
else:
return render_to_response('address/error', {'message':'你需要上传一个文件！'})
def login(request):
username = request.POST.get("username", None)
if username:
request.session["username"] = username
username = request.session.get("username", None)
if username:
return render_to_response("login", {"username": username})
else:
return render_to_response("login")
def template_filter_index(request):
if not doc:
return missing_docutils_page(request)
saved_tagset = template.registered_tags.copy(), template.registered_filters.copy()
load_all_installed_template_libraries()
filters = []
for filtername in template.registered_filters:
title, body, metadata = doc.parse_docstring(template.registered_filters[filtername][0].__doc__)
if title:
title = doc.parse_rst(title, 'filter', 'filter:' + filtername)
if body:
body = doc.parse_rst(body, 'filter', 'filter:' + filtername)
for key in metadata:
metadata[key] = doc.parse_rst(metadata[key], 'filter', 'filter:' + filtername)
metadata['AcceptsArgument'] = template.registered_filters[filtername][1]
library = template.registered_filters[filtername][0].__module__.split('.')[-1]
if library == 'template_loader' or library == 'defaultfilters':
library = None
filters.append({
'name' : filtername,
'title' : title,
'body' : body,
'meta' : metadata,
'library' : library,
})
template.registered_tags, template.registered_filters = saved_tagset
return render_to_response('admin_doc/template_filter_index', {'filters': filters}, context_instance=DjangoContext(request))
def edit(request, pagename):
"""显示编辑存在页面"""
page = wikis.get_object(pagename__exact=pagename)
return render_to_response('wiki/edit', {
'pagename': pagename,
'content': page.content
})
def index(request):
import datetime
feed_list = feeds.get_list(feed_type__exact='planet', order_by=['title'])
post_list = posts.get_list(feed__feed_type__exact='planet', order_by=['-modified'], limit=40)
post_short_list = posts.get_list(feed__feed_type__exact='planet', modified__gt = (datetime.datetime.now() - datetime.timedelta(hours=24)), order_by=['-modified'], offset=41, limit=100)
delicious_list = posts.get_list(feed__feed_type__exact='delicious', order_by=['-modified'], limit=20)
return render_to_response('planetex/index', {'feeds':feed_list, 'posts':post_list, 'posts_short':post_short_list, 'delicious':delicious_list})
def g(request, *args, **kwargs):
result = function(request, *args, **kwargs)
if isinstance(result, dict):
ctx = extensions.DjangoContext(request)
return extensions.render_to_response(template_name, result, ctx)
else:
return result
def logout(request, next_page=None):
"Logs out the user and displays 'You are logged out' message."
try:
del request.session[users.SESSION_KEY]
except KeyError:
return render_to_response('registration/logged_out', context_instance=DjangoContext(request))
else:
# Redirect to this page until the session has been cleared.
return HttpResponseRedirect(next_page or request.path)
def password_change(request):
new_data, errors = {}, {}
form = PasswordChangeForm(request.user)
if request.POST:
new_data = request.POST.copy()
errors = form.get_validation_errors(new_data)
if not errors:
form.save(new_data)
return HttpResponseRedirect('%sdone/' % request.path)
return render_to_response('registration/password_change_form', {'form': formfields.FormWrapper(form, new_data, errors)},
context_instance=DjangoContext(request))
def torrent(request, t_id):
torrent = get_object_or_404(torrents, pk=t_id)
try:
fetcher = fetchers.get_object(pk=torrent.id)
except fetchers.FetcherDoesNotExist:
fetcher = None
msgs = messages.get_list(order_by=['-logged'], limit=30, torrent__id__exact=torrent.id)
return render_to_response('aurora/torrent', {
'torrent': torrent,
'fetcher': fetcher,
'aurora_messages': msgs,
})
def subscribe(request):
if request.GET:
url = request.GET['url']
fds = feedfinder.getFeeds(url)
return render_to_response('aggemam/subscribe', {'url': url,
'feeds': fds})
elif request.POST:
subs = []
for url in request.POST.getlist('feeds'):
try:
feed = feeds.get_object(url__exact=url)
except feeds.FeedDoesNotExist:
feed = feeds.Feed(url=url, update=True)
feed.save()
sub = subscriptions.Subscription(user=request.user, feed=feed)
sub.save()
subs.append(sub)
return render_to_response('aggemam/subscribed', {'subscriptions': subs})
def password_reset(request, is_admin_site=False):
new_data, errors = {}, {}
form = PasswordResetForm()
if request.POST:
new_data = request.POST.copy()
errors = form.get_validation_errors(new_data)
if not errors:
if is_admin_site:
form.save(request.META['HTTP_HOST'])
else:
form.save()
return HttpResponseRedirect('%sdone/' % request.path)
return render_to_response('registration/password_reset_form', {'form': formfields.FormWrapper(form, new_data, errors)},
context_instance=DjangoContext(request))
def model_index(request):
if not doc:
return missing_docutils_page(request)
models = []
for app in meta.get_installed_model_modules():
for model in app._MODELS:
opts = model._meta
models.append({
'name' : '%s.%s' % (opts.app_label, opts.module_name),
'module' : opts.app_label,
'class' : opts.module_name,
})
return render_to_response('admin_doc/model_index', {'models': models}, context_instance=DjangoContext(request))
def index(request, pagename=""):
"""显示正常页面，对页面的文字做特殊的链接处理"""
if pagename:
#查找是否已经存在页面
pages = wikis.get_list(pagename__exact=pagename)
if pages:
#存在则调用页面模板进行显示
return process('wiki/page', pages[0])
else:
#不存在则进入编辑画面
return render_to_response('wiki/edit', {'pagename': pagename})
else:
page = wikis.get_object(pagename__exact='FrontPage')
return process('wiki/page', page)
def index(request, pagename=""):
"""显示正常页面，对页面的文字做特殊的链接处理"""
if pagename:
#查找是否已经存在页面
pages = wikis.get_list(pagename__exact=pagename)
if pages:
#存在则调用页面模板进行显示
return process('wiki/page', pages[0])
else:
#不存在则进入编辑画面
return render_to_response('wiki/edit', {'pagename':pagename})
else:
page = wikis.get_object(pagename__exact='FrontPage')
return process('wiki/page', page)
def _display_login_form(request, error_message=''):
request.session.set_test_cookie()
if request.POST and request.POST.has_key('post_data'):
# User has failed login BUT has previously saved post data.
post_data = request.POST['post_data']
elif request.POST:
# User's session must have expired; save their post data.
post_data = _encode_post_data(request.POST)
else:
post_data = _encode_post_data({})
return render_to_response('admin/login', {
'title': 'Log in',
'app_path': request.path,
'post_data': post_data,
'error_message': error_message
}, context_instance=DjangoContext(request))
def flag(request, comment_id):
"""
Flags a comment. Confirmation on GET, action on POST.
Templates: `comments/flag_verify`, `comments/flag_done`
Context:
comment
the flagged `comments.comments` object
"""
try:
comment = comments.get_object(pk=comment_id, site__id__exact=SITE_ID)
except comments.CommentDoesNotExist:
raise Http404
if request.POST:
userflags.flag(comment, request.user)
return HttpResponseRedirect('%sdone/' % request.path)
return render_to_response('comments/flag_verify', {'comment': comment}, context_instance=DjangoContext(request))
def template_detail(request, template):
templates = []
for site_settings_module in settings.ADMIN_FOR:
settings_mod = __import__(site_settings_module, '', '', [''])
for dir in settings_mod.TEMPLATE_DIRS:
template_file = os.path.join(dir, "%s.html" % template)
templates.append({
'file' : template_file,
'exists' : os.path.exists(template_file),
'contents' : lambda: os.path.exists(template_file) and open(template_file).read() or '',
'site_id' : settings_mod.SITE_ID,
'site' : sites.get_object(pk=settings_mod.SITE_ID),
'order' : list(settings_mod.TEMPLATE_DIRS).index(dir),
})
return render_to_response('admin_doc/template_detail', {
'name': template,
'templates': templates,
}, context_instance=DjangoContext(request))
def view_index(request):
if not doc:
return missing_docutils_page(request)
views = []
for site_settings_module in settings.ADMIN_FOR:
settings_mod = __import__(site_settings_module, '', '', [''])
urlconf = __import__(settings_mod.ROOT_URLCONF, '', '', [''])
view_functions = extract_views_from_urlpatterns(urlconf.urlpatterns)
for (func, regex) in view_functions:
views.append({
'name' : func.__name__,
'module' : func.__module__,
'site_id': settings_mod.SITE_ID,
'site' : sites.get_object(pk=settings_mod.SITE_ID),
'url' : simplify_regex(regex),
})
return render_to_response('admin_doc/view_index', {'views': views}, context_instance=DjangoContext(request))
def login(request):
try:
user = users.get_object(username__exact=request.POST["username"])
if not user.check_password(request.POST["password"]):
raise users.UserDoesNotExist
# set the session's user active
request.session[users.SESSION_KEY] = user.id
try:
nextpage = request.GET["next"]
except KeyError:
nextpage = "/gappy/"
return HttpResponseRedirect(nextpage)
except KeyError:
return render_to_response("gappy/login")
except users.UserDoesNotExist:
t = loader.get_template("gappy/login")
c = Context({"error":"Some login information was wrong."})
return HttpResponse(t.render(c))
def comment_was_posted(request):
"""
Display "comment was posted" success page
Templates: `comment_posted`
Context:
object
The object the comment was posted on
"""
obj = None
if request.GET.has_key('c'):
content_type_id, object_id = request.GET['c'].split(':')
try:
content_type = contenttypes.get_object(pk=content_type_id)
obj = content_type.get_object_for_this_type(pk=object_id)
except ObjectDoesNotExist:
pass
return render_to_response('comments/posted', {'object': obj}, context_instance=DjangoContext(request))
def login(request):
"Displays the login form and handles the login action."
manipulator = AuthenticationForm(request)
redirect_to = request.REQUEST.get(REDIRECT_FIELD_NAME, '')
if request.POST:
errors = manipulator.get_validation_errors(request.POST)
if not errors:
# Light security check -- make sure redirect_to isn't garbage.
if not redirect_to or '://' in redirect_to or ' ' in redirect_to:
redirect_to = '/accounts/profile/'
request.session[users.SESSION_KEY] = manipulator.get_user_id()
request.session.delete_test_cookie()
return HttpResponseRedirect(redirect_to)
else:
errors = {}
request.session.set_test_cookie()
return render_to_response('registration/login', {
'form': formfields.FormWrapper(manipulator, request.POST, errors),
REDIRECT_FIELD_NAME: redirect_to,
'site_name': sites.get_current().name,
}, context_instance=DjangoContext(request))
def model_detail(request, model):
if not doc:
return missing_docutils_page(request)
try:
model = meta.get_app(model)
except ImportError:
raise Http404
opts = model.Klass._meta
# Gather fields/field descriptions
fields = []
for field in opts.fields:
fields.append({
'name' : field.name,
'data_type': get_readable_field_data_type(field),
'verbose' : field.verbose_name,
'help' : field.help_text,
})
for func_name, func in model.Klass.__dict__.items():
if callable(func) and len(inspect.getargspec(func)[0]) == 0:
try:
for exclude in MODEL_METHODS_EXCLUDE:
if func_name.startswith(exclude):
raise StopIteration
except StopIteration:
continue
verbose = func.__doc__
if verbose:
verbose = doc.parse_rst(doc.trim_docstring(verbose), 'model', 'model:' + opts.module_name)
fields.append({
'name' : func_name,
'data_type' : get_return_data_type(func_name),
'verbose' : verbose,
})
return render_to_response('admin_doc/model_detail', {
'name': '%s.%s' % (opts.app_label, opts.module_name),
'summary': "Fields on %s objects" % opts.verbose_name,
'fields': fields,
}, context_instance=DjangoContext(request))
def view_detail(request, view):
if not doc:
return missing_docutils_page(request)
mod, func = urlresolvers.get_mod_func(view)
try:
view_func = getattr(__import__(mod, '', '', ['']), func)
except (ImportError, AttributeError):
raise Http404
title, body, metadata = doc.parse_docstring(view_func.__doc__)
if title:
title = doc.parse_rst(title, 'view', 'view:' + view)
if body:
body = doc.parse_rst(body, 'view', 'view:' + view)
for key in metadata:
metadata[key] = doc.parse_rst(metadata[key], 'model', 'view:' + view)
return render_to_response('admin_doc/view_detail', {
'name': view,
'summary': title,
'body': body,
'meta': metadata,
}, context_instance=DjangoContext(request))
def template_validator(request):
"""
Displays the template validator form, which finds and displays template
syntax errors.
"""
# get a dict of {site_id : settings_module} for the validator
settings_modules = {}
for mod in settings.ADMIN_FOR:
settings_module = __import__(mod, "", "", [""])
settings_modules[settings_module.SITE_ID] = settings_module
manipulator = TemplateValidator(settings_modules)
new_data, errors = {}, {}
if request.POST:
new_data = request.POST.copy()
errors = manipulator.get_validation_errors(new_data)
if not errors:
request.user.add_message("The template is valid.")
return render_to_response(
"admin/template_validator",
{"title": "Template validator", "form": formfields.FormWrapper(manipulator, new_data, errors)},
context_instance=DjangoContext(request),
)
def vote(request, comment_id, vote):
"""
Rate a comment (+1 or -1)
Templates: `karma_vote_accepted`
Context:
comment
`comments.comments` object being rated
"""
rating = {'up': 1, 'down': -1}.get(vote, False)
if not rating:
raise Http404, "Invalid vote"
if request.user.is_anonymous():
raise Http404, "Anonymous users cannot vote"
try:
comment = comments.get_object(pk=comment_id)
except comments.CommentDoesNotExist:
raise Http404, "Invalid comment ID"
if comment.user_id == request.user.id:
raise Http404, "No voting for yourself"
karma.vote(request.user.id, comment_id, rating)
# Reload comment to ensure we have up to date karma count
comment = comments.get_object(pk=comment_id)
return render_to_response('comments/karma_vote_accepted', {'comment': comment}, context_instance=DjangoContext(request))
def template_tag_index(request):
import sys
if not doc:
return missing_docutils_page(request)
# We have to jump through some hoops with registered_tags to make sure
# they don't get messed up by loading outside tagsets
saved_tagset = template.registered_tags.copy(), template.registered_filters.copy()
load_all_installed_template_libraries()
# Gather docs
tags = []
for tagname in template.registered_tags:
title, body, metadata = doc.parse_docstring(template.registered_tags[tagname].__doc__)
if title:
title = doc.parse_rst(title, 'tag', 'tag:' + tagname)
if body:
body = doc.parse_rst(body, 'tag', 'tag:' + tagname)
for key in metadata:
metadata[key] = doc.parse_rst(metadata[key], 'tag', 'tag:' + tagname)
library = template.registered_tags[tagname].__module__.split('.')[-1]
if library == 'template_loader' or library == 'defaulttags':
library = None
tags.append({
'name' : tagname,
'title' : title,
'body' : body,
'meta' : metadata,
'library' : library,
})
# Fix registered_tags
template.registered_tags, template.registered_filters = saved_tagset
return render_to_response('admin_doc/template_tag_index', {'tags': tags}, context_instance=DjangoContext(request))
def delete(request, comment_id):
"""
Deletes a comment. Confirmation on GET, action on POST.
Templates: `comments/delete_verify`, `comments/delete_done`
Context:
comment
the flagged `comments.comments` object
"""
try:
comment = comments.get_object(pk=comment_id, site__id__exact=SITE_ID)
except comments.CommentDoesNotExist:
raise Http404
if not comments.user_is_moderator(request.user):
raise Http404
if request.POST:
# If the comment has already been removed, silently fail.
if not comment.is_removed:
comment.is_removed = True
comment.save()
m = moderatordeletions.ModeratorDeletion(None, request.user.id, comment.id, None)
m.save()
return HttpResponseRedirect('%sdone/' % request.path)
return render_to_response('comments/delete_verify', {'comment': comment}, context_instance=DjangoContext(request))
def direct_to_template(request, template, **kwargs):
"""
Render a given template with any extra URL parameters in the context as
``{{ params }}``.
"""
return render_to_response(template, {'params' : kwargs}, context_instance=DjangoContext(request))
def index(request):
return render_to_response('list', {'address': address})
def edit(request, pagename):
"""显示编辑存在页面"""
page = wikis.get_object(pagename__exact=pagename)
return render_to_response('wiki/edit', {'pagename':pagename, 'content':page.content})
def post_comment(request):
"""
Post a comment
Redirects to the `comments.comments.comment_was_posted` view upon success.
Templates: `comment_preview`
Context:
comment
the comment being posted
comment_form
the comment form
options
comment options
target
comment target
hash
security hash (must be included in a posted form to succesfully
post a comment).
rating_options
comment ratings options
ratings_optional
are ratings optional?
ratings_required
are ratings required?
rating_range
range of ratings
rating_choices
choice of ratings
"""
if not request.POST:
raise Http404, "Only POSTs are allowed"
try:
options, target, security_hash = request.POST['options'], request.POST['target'], request.POST['gonzo']
except KeyError:
raise Http404, "One or more of the required fields wasn't submitted"
photo_options = request.POST.get('photo_options', '')
rating_options = normalize_newlines(request.POST.get('rating_options', ''))
if comments.get_security_hash(options, photo_options, rating_options, target) != security_hash:
raise Http404, "Somebody tampered with the comment form (security violation)"
# Now we can be assured the data is valid.
if rating_options:
rating_range, rating_choices = comments.get_rating_options(base64.decodestring(rating_options))
else:
rating_range, rating_choices = [], []
content_type_id, object_id = target.split(':') # target is something like '52:5157'
try:
obj = contenttypes.get_object(pk=content_type_id).get_object_for_this_type(pk=object_id)
except ObjectDoesNotExist:
raise Http404, "The comment form had an invalid 'target' parameter -- the object ID was invalid"
option_list = options.split(',') # options is something like 'pa,ra'
new_data = request.POST.copy()
new_data['content_type_id'] = content_type_id
new_data['object_id'] = object_id
new_data['ip_address'] = request.META.get('REMOTE_ADDR')
new_data['is_public'] = comments.IS_PUBLIC in option_list
manipulator = PublicCommentManipulator(request.user,
ratings_required=comments.RATINGS_REQUIRED in option_list,
ratings_range=rating_range,
num_rating_choices=len(rating_choices))
errors = manipulator.get_validation_errors(new_data)
# If user gave correct username/password and wasn't already logged in, log them in
# so they don't have to enter a username/password again.
if manipulator.get_user() and new_data.has_key('password') and manipulator.get_user().check_password(new_data['password']):
request.session[users.SESSION_KEY] = manipulator.get_user_id()
if errors or request.POST.has_key('preview'):
class CommentFormWrapper(formfields.FormWrapper):
def __init__(self, manipulator, new_data, errors, rating_choices):
formfields.FormWrapper.__init__(self, manipulator, new_data, errors)
self.rating_choices = rating_choices
def ratings(self):
field_list = [self['rating%d' % (i+1)] for i in range(len(rating_choices))]
for i, f in enumerate(field_list):
f.choice = rating_choices[i]
return field_list
comment = errors and '' or manipulator.get_comment(new_data)
comment_form = CommentFormWrapper(manipulator, new_data, errors, rating_choices)
return render_to_response('comments/preview', {
'comment': comment,
'comment_form': comment_form,
'options': options,
'target': target,
'hash': security_hash,
'rating_options': rating_options,
'ratings_optional': comments.RATINGS_OPTIONAL in option_list,
'ratings_required': comments.RATINGS_REQUIRED in option_list,
'rating_range': rating_range,
'rating_choices': rating_choices,
}, context_instance=DjangoContext(request))
elif request.POST.has_key('post'):
# If the IP is banned, mail the admins, do NOT save the comment, and
# serve up the "Thanks for posting" page as if the comment WAS posted.
if request.META['REMOTE_ADDR'] in BANNED_IPS:
mail_admins("Banned IP attempted to post comment", str(request.POST) + "\n\n" + str(request.META))
else:
manipulator.do_html2python(new_data)
comment = manipulator.save(new_data)
return HttpResponseRedirect("/comments/posted/?c=%s:%s" % (content_type_id, object_id))
else:
raise Http404, "The comment form didn't provide either 'preview' or 'post'"
def post_free_comment(request):
"""
Post a free comment (not requiring a log in)
Redirects to `comments.comments.comment_was_posted` view on success.
Templates: `comment_free_preview`
Context:
comment
comment being posted
comment_form
comment form object
options
comment options
target
comment target
hash
security hash (must be included in a posted form to succesfully
post a comment).
"""
if not request.POST:
raise Http404, "Only POSTs are allowed"
try:
options, target, security_hash = request.POST['options'], request.POST['target'], request.POST['gonzo']
except KeyError:
raise Http404, "One or more of the required fields wasn't submitted"
if comments.get_security_hash(options, '', '', target) != security_hash:
raise Http404, "Somebody tampered with the comment form (security violation)"
content_type_id, object_id = target.split(':') # target is something like '52:5157'
content_type = contenttypes.get_object(pk=content_type_id)
try:
obj = content_type.get_object_for_this_type(pk=object_id)
except ObjectDoesNotExist:
raise Http404, "The comment form had an invalid 'target' parameter -- the object ID was invalid"
option_list = options.split(',')
new_data = request.POST.copy()
new_data['content_type_id'] = content_type_id
new_data['object_id'] = object_id
new_data['ip_address'] = request.META['REMOTE_ADDR']
new_data['is_public'] = comments.IS_PUBLIC in option_list
manipulator = PublicFreeCommentManipulator()
errors = manipulator.get_validation_errors(new_data)
if errors or request.POST.has_key('preview'):
comment = errors and '' or manipulator.get_comment(new_data)
return render_to_response('comments/free_preview', {
'comment': comment,
'comment_form': formfields.FormWrapper(manipulator, new_data, errors),
'options': options,
'target': target,
'hash': security_hash,
}, context_instance=DjangoContext(request))
elif request.POST.has_key('post'):
# If the IP is banned, mail the admins, do NOT save the comment, and
# serve up the "Thanks for posting" page as if the comment WAS posted.
if request.META['REMOTE_ADDR'] in BANNED_IPS:
from django.core.mail import mail_admins
mail_admins("Practical joker", str(request.POST) + "\n\n" + str(request.META))
else:
manipulator.do_html2python(new_data)
comment = manipulator.save(new_data)
return HttpResponseRedirect("/comments/posted/?c=%s:%s" % (content_type_id, object_id))
else:
raise Http404, "The comment form didn't provide either 'preview' or 'post'"
