vote.save()\r
\r
def cancel_action(self):\r
- vote = self.vote.all()[0]\r
+ vote = self.vote\r
self.update_node_score(-vote.value)\r
vote.delete()\r
\r
DeleteAction(node=self.node, user=self.user, extra="BYFLAGGED").save()\r
\r
def cancel_action(self):\r
- self.flag.all()[0].delete()\r
+ self.flag.delete()\r
self.node.reset_flag_count_cache()\r
\r
@classmethod\r
if name in contexts
])
-
-#todo: probably this don't belong here, also this post_stored routine needs a lot of work
-user_logged_in = django.dispatch.Signal(providing_args=["user", "old_session"])
-
-#def post_stored_anonymous_content(user,old_session,**kwargs):
-# from forum.models import AnonymousQuestion, AnonymousAnswer
-# aq_list = AnonymousQuestion.objects.filter(session_key = old_session)
-# aa_list = AnonymousAnswer.objects.filter(session_key = old_session)
-# import settings
-# if settings.EMAIL_VALIDATION == 'on':#add user to the record
-# for aq in aq_list:
-# aq.author = user
-# aq.save()
-# for aa in aa_list:
-# aa.author = user
-# aa.save()
-# #maybe add pending posts message?
-# else: #just publish the questions
-# for aq in aq_list:
-# aq.publish(user)
-# for aa in aa_list:
-# aa.publish(user)
-#
-#user_logged_in.connect(post_stored_anonymous_content)
\ No newline at end of file
-from django.conf import settings
+from forum import settings
+from django.conf import settings as djsettings
def application_settings(context):
my_settings = {
'APP_TITLE' : settings.APP_TITLE,
'APP_DESCRIPTION' : settings.APP_DESCRIPTION,
'APP_INTRO' : settings.APP_INTRO,
'APP_LOGO' : settings.APP_LOGO,
- 'EMAIL_VALIDATION': settings.EMAIL_VALIDATION,
+ 'EMAIL_VALIDATION': 'off',
'FEEDBACK_SITE_URL': settings.FEEDBACK_SITE_URL,
- 'FORUM_SCRIPT_ALIAS': settings.FORUM_SCRIPT_ALIAS,
- 'LANGUAGE_CODE': settings.LANGUAGE_CODE,
+ 'FORUM_SCRIPT_ALIAS': djsettings.FORUM_SCRIPT_ALIAS,
+ 'LANGUAGE_CODE': djsettings.LANGUAGE_CODE,
'GOOGLE_SITEMAP_CODE':settings.GOOGLE_SITEMAP_CODE,
'GOOGLE_ANALYTICS_KEY':settings.GOOGLE_ANALYTICS_KEY,
'WIKI_ON':settings.WIKI_ON,
- 'RESOURCE_REVISION':settings.RESOURCE_REVISION,
- 'OSQA_SKIN':settings.OSQA_DEFAULT_SKIN,
+ 'OSQA_SKIN':djsettings.OSQA_DEFAULT_SKIN,
'APP_FAVICON':settings.APP_FAVICON,
}
return {'settings':my_settings}
from django.contrib.syndication.feeds import Feed, FeedDoesNotExist
from django.utils.translation import ugettext as _
from models import Question
-from django.conf import settings
+from forum import settings
class RssLastestQuestionsFeed(Feed):
title = settings.APP_TITLE + _(' - ')+ _('latest questions')
link = settings.APP_URL #+ '/' + _('question/')
from django.utils.safestring import mark_safe
from forum.utils.forms import NextUrlField, UserNameField, SetPasswordForm
-from django.conf import settings
+from forum import settings
import logging
class TitleField(forms.CharField):
from django.utils.translation import ugettext as _
from django.template import loader, Context, Template
from django.core.mail import EmailMultiAlternatives
-from django.conf import settings
+from forum import settings
from forum.models import KeyValue, Activity, User, QuestionSubscription
from forum.utils.mail import send_email
from forum.utils.forms import get_next_url
from django.utils.translation import ugettext as _
from forum.user_messages import create_message, get_and_delete_messages
-from django.conf import settings
+from forum import settings
from django.core.urlresolvers import reverse
import logging
from django.utils.safestring import mark_safe
from django.contrib.sitemaps import ping_google
import django.dispatch
-from django.conf import settings
+from forum import settings
import logging
user = models.ForeignKey(User, related_name="votes")\r
node = models.ForeignKey(Node, related_name="votes")\r
value = models.SmallIntegerField()\r
- action = models.ForeignKey(Action, unique=True, related_name="vote")\r
+ action = models.OneToOneField(Action, related_name="vote")\r
voted_at = models.DateTimeField(default=datetime.datetime.now)\r
\r
class Meta:\r
user = models.ForeignKey(User, related_name="flags")\r
node = models.ForeignKey(Node, related_name="flags")\r
reason = models.CharField(max_length=300)\r
- action = models.ForeignKey(Action, unique=True, related_name="flag")\r
+ action = models.OneToOneField(Action, related_name="flag")\r
flagged_at = models.DateTimeField(default=datetime.datetime.now)\r
\r
class Meta:\r
awarded_at = models.DateTimeField(default=datetime.datetime.now)\r
\r
trigger = models.ForeignKey(Action, related_name="awards", null=True)\r
- action = models.ForeignKey(Action, related_name="award", unique=True)\r
+ action = models.OneToOneField(Action, related_name="award")\r
\r
\r
class Meta:\r
-from forum.akismet import *\r
from base import *\r
from tag import Tag\r
\r
\r
@staticmethod\r
def isSpam(comment, data):\r
- if not settings.WORDPRESS_API_KEY:\r
- return False\r
- \r
- api = Akismet(settings.WORDPRESS_API_KEY, settings.APP_URL)\r
- return api.comment_check(comment, data)\r
+ return False\r
+ #if not settings.WORDPRESS_API_KEY:\r
+ # return False\r
+ #\r
+ #api = Akismet(settings.WORDPRESS_API_KEY, settings.APP_URL)\r
+ #return api.comment_check(comment, data)\r
\r
class Meta:\r
app_label = 'forum'\r
for m in MODULE_LIST:
try:
all.append(__import__('%s.%s' % (m.__name__, script_name), globals(), locals(), [m.__name__]))
- except Exception, e:
- #print m.__name__ + ":" + str(e)
+ except ImportError, e:
+ #repr(type(e)) + m.__name__ + ":" + str(e)
pass
+ except:
+ import sys, traceback
+ traceback.print_exc(file=sys.stdout)
return all
return origin\r
return decorator\r
\r
- raise Exception('Not an decoratable function: %s' % origin.name)\r
+ raise TypeError('Not a decoratable function: %s' % origin.__name__)\r
\r
def decorator(fn):\r
origin.decorate(fn, needs_origin)\r
return decorator\r
\r
\r
+def decorate_all(module):\r
+ [setattr(module, n, decoratable(f)) for n, f in\r
+ [(n, getattr(module, n)) for n in dir(module)]\r
+ if (callable(f)) and (not inspect.isclass(f)) and (f.__module__ == module.__name__)]\r
+\r
+\r
\r
\r
\r
from django.forms.widgets import Textarea
from django.utils.translation import ugettext_lazy as _
+from django.conf import settings as djsettings
-INTERNAL_VERSION = Setting('INTERNAL_VERSION', "59")
+OSQA_VERSION = Setting('OSQA_VERSION', "Development Version")
SETTINGS_PACK = Setting('SETTINGS_PACK', "default")
+APP_URL = djsettings.APP_URL
+FORUM_SCRIPT_ALIAS = djsettings.FORUM_SCRIPT_ALIAS
+
from basic import *
from email import *
from faq import *
from form import *
from moderation import *
+from users import *
BADGES_SET = SettingSet('badges', _('Badges config'), _("Configure badges on your OSQA site."), 500)
self.set_value(self.default)
def _parse(self, value):
- try:
- return self.base_type(value)
- except:
- return value
+ if not isinstance(value, self.base_type):
+ try:
+ return self.base_type(value)
+ except:
+ pass
+ return value
class Setting(object):
\r
APP_COPYRIGHT = Setting('APP_COPYRIGHT', u'Copyright OSQA, 2010. Some rights reserved under creative commons license.', BASIC_SET, dict(\r
label = _("Copyright notice"),\r
-help_text = _("The copyright notice visible at the footer of your page.")))
\ No newline at end of file
+help_text = _("The copyright notice visible at the footer of your page.")))\r
+\r
+FEEDBACK_SITE_URL = Setting('FEEDBACK_SITE_URL', '', BASIC_SET, dict(\r
+label = _("Feedback site url"),\r
+help_text = _("If you have a specific place to get feedback from your users, use this field and the fedback link on the footer will point there.")))
\ No newline at end of file
help_text = _("Your Google analytics key. You can get one at the <a href='http://www.google.com/analytics/'>Google analytics official website</a>"),\r
required=False))\r
\r
-WORDPRESS_API_KEY = Setting('WORDPRESS_API_KEY', '', EXT_KEYS_SET, dict(\r
-label = _("Wordpress API key"),\r
-help_text = _("Your Wordpress API key. You can get one at <a href='http://wordpress.com/'>http://wordpress.com/</a>"),\r
-required=False))\r
FORUM_SET = SettingSet('form', _('Form settings'), _("General settings for the OSQA forms."), 10)
+WIKI_ON = Setting('WIKI_ON', True, FORUM_SET, dict(
+label = _("Enable community wiki"),
+help_text = _("Can questions or answers be marked as community wiki."),
+required=False))
""" settings for questions """
import os
+from string import strip
from django import forms
from base import Setting
from django.utils.translation import ugettext as _
super(SettingsSetForm, self).__init__(data, *args, **kwargs)
for setting in set:
- if isinstance(setting, Setting.emulators.get(str, DummySetting)):
+ if isinstance(setting, (Setting.emulators.get(str, DummySetting), Setting.emulators.get(unicode, DummySetting))):
field = forms.CharField(**setting.field_context)
elif isinstance(setting, Setting.emulators.get(float, DummySetting)):
field = forms.FloatField(**setting.field_context)
else:
return data[name]
+class CommaStringListWidget(forms.Textarea):
+ def value_from_datadict(self, data, files, name):
+ if 'submit' in data:
+ return map(strip, data[name].split(','))
+ else:
+ return ', '.join(data[name])
+
+
+
--- /dev/null
+from forms import CommaStringListWidget
+from base import Setting, SettingSet
+from django.utils.translation import ugettext as _
+
+USERS_SET = SettingSet('users', _('Users settings'), _("General settings for the OSQA users."), 20)
+
+EDITABLE_SCREEN_NAME = Setting('EDITABLE_SCREEN_NAME', False, USERS_SET, dict(
+label = _("Editable screen name"),
+help_text = _("Allow users to alter their screen name."),
+required=False))
+
+MIN_USERNAME_LENGTH = Setting('MIN_USERNAME_LENGTH', 3, USERS_SET, dict(
+label = _("Minimum username length"),
+help_text = _("The minimum length (in character) of a username.")))
+
+RESERVED_USERNAMES = Setting('RESERVED_USERNAMES',
+[_('fuck'), _('shit'), _('ass'), _('sex'), _('add'), _('edit'), _('save'), _('delete'), _('manage'), _('update'), _('remove'), _('new')]
+, USERS_SET, dict(
+label = _("Disabled usernames"),
+help_text = _("A comma separated list of disabled usernames (usernames not allowed during a new user registration)."),
+widget=CommaStringListWidget))
+
+EMAIL_UNIQUE = Setting('EMAIL_UNIQUE', True, USERS_SET, dict(
+label = _("Force unique email"),
+help_text = _("Should each user have an unique email.")))
+
var visible = arrow.attr("src").indexOf("hide") > -1;
var path = $.i18n._('/') + "media/images/expander-arrow-" +
- (visible ? "show" : "hide") + ".gif" + "?v={{settings.RESOURCE_REVISION}}";
+ (visible ? "show" : "hide") + ".gif";
arrow.attr("src", path);
$("#rev-body-" + id).slideToggle("fast");
}
+import forum.views
+
import forum.badges
import forum.subscriptions
from forum.utils.mail import send_email\r
from django.utils.translation import ugettext as _\r
from forum.actions import AskAction, AnswerAction, CommentAction, AcceptAnswerAction, UserJoinsAction, QuestionViewAction\r
-from django.conf import settings\r
+from forum import settings\r
from django.db.models import Q, F\r
\r
def create_subscription_if_not_exists(question, user):\r
from django.utils.translation import ugettext as _
from django.utils.translation import ungettext
from django.utils import simplejson
-from django.conf import settings
+from forum import settings
from django.template.defaulttags import url as default_url
from forum import skins
url = skins.find_media_source(url)
if url:
url = '///' + settings.FORUM_SCRIPT_ALIAS + '/m/' + url
- return posixpath.normpath(url) + '?v=%d' % settings.RESOURCE_REVISION
+ return posixpath.normpath(url)
class ItemSeparatorNode(template.Node):
def __init__(self,separator):
url = skins.find_media_source(url)
url = prefix + url
- out = posixpath.normpath(url) + '?v=%d' % settings.RESOURCE_REVISION
+ out = posixpath.normpath(url)
return out.replace(' ','')
@register.tag(name='blockmedia')
import startup
import os.path
-from django.conf import settings
+from forum import settings
from django.conf.urls.defaults import *
from django.contrib import admin
from forum import views as app
url(r'^feeds/rss/$', RssLastestQuestionsFeed, name="latest_questions_feed"),
)
-
-if 'rosetta' in settings.INSTALLED_APPS:
- urlpatterns += patterns('',
- url(r'^rosetta/', include('rosetta.urls')),
- )
\ No newline at end of file
import re
from django.utils.translation import ugettext as _
from django.utils.safestring import mark_safe
-from django.conf import settings
+from forum import settings
from django.http import str_to_unicode
from forum.models import User
import urllib
username_re = re.compile(r'^[\w ]+$')
class UserNameField(StrippedNonEmptyCharField):
- RESERVED_NAMES = (u'fuck', u'shit', u'ass', u'sex', u'add',
- u'edit', u'save', u'delete', u'manage', u'update', 'remove', 'new')
def __init__(self,db_model=User, db_field='username', must_exist=False,skip_clean=False,label=_('choose a username'),**kw):
self.must_exist = must_exist
self.skip_clean = skip_clean
'missing':_('sorry, there is no user with this name'),
'multiple-taken':_('sorry, we have a serious error - user name is taken by several users'),
'invalid':_('user name can only consist of letters, empty space and underscore'),
+ 'toshort':_('user name is to short, please use at least %d characters') % settings.MIN_USERNAME_LENGTH
}
if 'error_messages' in kw:
error_messages.update(kw['error_messages'])
username = super(UserNameField, self).clean(username)
except forms.ValidationError:
raise forms.ValidationError(self.error_messages['required'])
+ if len(username) < settings.MIN_USERNAME_LENGTH:
+ raise forms.ValidationError(self.error_messages['toshort'])
if self.required and not username_re.search(username):
raise forms.ValidationError(self.error_messages['invalid'])
- if username in self.RESERVED_NAMES:
+ if username in settings.RESERVED_USERNAMES:
raise forms.ValidationError(self.error_messages['forbidden'])
try:
user = self.db_model.objects.get(
from django.core.mail import DNS_NAME\r
from smtplib import SMTP\r
import email.Charset\r
-from django.conf import settings\r
+from forum import settings\r
from django.template import loader, Context, Template\r
from forum.utils.html import sanitize_html\r
from forum.context import application_settings\r
msgRoot['Subject'] = subject\r
msgRoot['From'] = named(sender)\r
msgRoot['To'] = named(recipient)\r
- msgRoot.preamble = 'This is a multi-part message from %s.' % str(settings.APP_SHORT_NAME)\r
+ msgRoot.preamble = 'This is a multi-part message from %s.' % unicode(settings.APP_SHORT_NAME).encode('utf8')\r
\r
msgAlternative = MIMEMultipart('alternative')\r
msgRoot.attach(msgAlternative)\r
\r
def send_email(subject, recipients, template, context={}, sender=None, images=[], threaded=True):\r
if sender is None:\r
- sender = (str(settings.APP_SHORT_NAME), str(settings.DEFAULT_FROM_EMAIL))\r
+ sender = (unicode(settings.APP_SHORT_NAME), unicode(settings.DEFAULT_FROM_EMAIL))\r
\r
if not len(images):\r
images = [(os.path.join(str(settings.UPFILES_FOLDER), os.path.basename(str(settings.APP_LOGO))), 'logo')]\r
import meta
import auth
import admin
+
+#from forum.modules.decorators import decorate_all
+
+#decorate_all(readers)
+#decorate_all(writers)
+#decorate_all(commands)
+#decorate_all(users)
+#decorate_all(meta)
+#decorate_all(auth)
+#decorate_all(admin)
if set_name in ('minrep', 'badges', 'repgain'):
settings.SETTINGS_PACK.set_value("custom")
+
+ return HttpResponseRedirect(reverse('admin_set', args=[set_name]))
else:
form = SettingsSetForm(set)
provider_class = AUTH_PROVIDERS[request.session['auth_provider']].consumer
user_data = provider_class.get_user_data(request.session['assoc_key'])
+ if not user_data:
+ user_data = request.session.get('auth_consumer_data', {})
+
username = user_data.get('username', '')
email = user_data.get('email', '')
- if not email:
- email = request.session.get('auth_email_request', '')
-
if email:
request.session['auth_validated_email'] = email
user.backend = "django.contrib.auth.backends.ModelBackend"
login(request, user)
- #user_logged_in.send(user=user,old_session=old_session,sender=None)
temp_data = request.session.pop('temp_node_data', None)
if temp_data:
request.POST = temp_data
import datetime
-from django.conf import settings
+from forum import settings
from django.core.exceptions import ObjectDoesNotExist
from django.utils import simplejson
from django.http import HttpResponse, HttpResponseRedirect, HttpResponseForbidden
from django.core.urlresolvers import reverse
from django.contrib.auth.decorators import login_required
from forum.utils.decorators import ajax_method, ajax_login_required
+from forum.modules.decorators import decoratable
from decorators import command, CommandException
from forum import settings
import logging
""" % {'action': action, 'signin_url': reverse('auth_signin')})
)
-class SpamNotAllowedException(CommandException):
- def __init__(self, action = "comment"):
- super(SpamNotAllowedException, self).__init__(
- _("""Your %s has been marked as spam.""" % action)
- )
-
class NotEnoughLeftException(CommandException):
def __init__(self, action, limit):
super(NotEnoughLeftException, self).__init__(
}
}
+@decoratable
@command
def comment(request, id):
post = get_object_or_404(Node, id=id)
if len(comment_text) > settings.FORM_MAX_COMMENT_BODY:
raise CommandException(_("No more than %d characters on comment body.") % settings.FORM_MAX_COMMENT_BODY)
- data = {
- "user_ip":request.META["REMOTE_ADDR"],
- "user_agent":request.environ['HTTP_USER_AGENT'],
- "comment_author":request.user.username,
- "comment_author_email":request.user.email,
- "comment_author_url":request.user.website,
- "comment":comment_text
- }
- if Node.isSpam(comment_text, data):
- raise SpamNotAllowedException()
-
if 'id' in request.POST:
comment = get_object_or_404(Comment, id=request.POST['id'])
\r
response['success'] = True\r
except Exception, e:\r
- import sys, traceback\r
- traceback.print_exc(file=sys.stdout)\r
+ #import sys, traceback\r
+ #traceback.print_exc(file=sys.stdout)\r
\r
if isinstance(e, CommandException):\r
response = {\r
from django.core.urlresolvers import reverse
from django.template import RequestContext
from django.http import HttpResponseRedirect, HttpResponse
-from django.conf import settings
+from forum import settings
from forum.forms import FeedbackForm
from django.core.urlresolvers import reverse
from django.utils.translation import ugettext as _
import datetime
import logging
from urllib import unquote
-from django.conf import settings as django_settings
+from forum import settings as django_settings
from django.shortcuts import render_to_response, get_object_or_404
from django.http import HttpResponseRedirect, HttpResponse, HttpResponseForbidden, Http404, HttpResponsePermanentRedirect
from django.core.paginator import Paginator, EmptyPage, InvalidPage
\r
set_new_email(user, new_email)\r
\r
- #user.username = sanitize_html(form.cleaned_data['username'])\r
+ if settings.EDITABLE_SCREEN_NAME:\r
+ user.username = sanitize_html(form.cleaned_data['username'])\r
user.real_name = sanitize_html(form.cleaned_data['realname'])\r
user.website = sanitize_html(form.cleaned_data['website'])\r
user.location = sanitize_html(form.cleaned_data['city'])\r
from django.core.exceptions import PermissionDenied
from forum.actions import AskAction, AnswerAction, ReviseAction, RollbackAction, RetagAction
+from forum.modules.decorators import decoratable
from forum.forms import *
from forum.models import *
from forum.utils.forms import get_next_url
-from forum.views.commands import SpamNotAllowedException
def upload(request):#ajax upload file to a question or answer
return HttpResponse(result, mimetype="application/xml")
-
+@decoratable
def ask(request):
if request.POST and "text" in request.POST:
form = AskForm(request.POST)
if form.is_valid():
if request.user.is_authenticated():
- data = {
- "user_ip":request.META["REMOTE_ADDR"],
- "user_agent":request.environ['HTTP_USER_AGENT'],
- "comment_author":request.user.username,
- "comment_author_email":request.user.email,
- "comment_author_url":request.user.website,
- "comment":request.POST['text']
- }
- if Node.isSpam(request.POST['text'], data):
- raise SpamNotAllowedException("question")
-
question = AskAction(user=request.user).save(data=form.cleaned_data).node
return HttpResponseRedirect(question.get_absolute_url())
else:
'form': form,
}, context_instance=RequestContext(request))
+@decoratable
def answer(request, id):
question = get_object_or_404(Question, id=id)
if request.POST:
form = AnswerForm(question, request.POST)
if form.is_valid():
if request.user.is_authenticated():
- data = {
- "user_ip":request.META["REMOTE_ADDR"],
- "user_agent":request.environ['HTTP_USER_AGENT'],
- "comment_author":request.user.username,
- "comment_author_email":request.user.email,
- "comment_author_url":request.user.website,
- "comment":request.POST['text']
- }
- if Node.isSpam(request.POST['text'], data):
- raise SpamNotAllowedException("answer")
-
answer = AnswerAction(user=request.user).save(dict(question=question, **form.cleaned_data)).node
return HttpResponseRedirect(answer.get_absolute_url())
else:
--- /dev/null
+from forum.settings.base import Setting\r
+from forum.settings.extkeys import EXT_KEYS_SET\r
+from django.utils.translation import ugettext_lazy as _\r
+\r
+WORDPRESS_API_KEY = Setting('WORDPRESS_API_KEY', '', EXT_KEYS_SET, dict(\r
+label = _("Wordpress API key"),\r
+help_text = _("Your Wordpress API key. You can get one at <a href='http://wordpress.com/'>http://wordpress.com/</a>"),\r
+required=False))\r
--- /dev/null
+from django.utils.translation import ugettext as _
+from django.http import HttpResponse, HttpResponseRedirect
+from django.utils import simplejson
+from django.shortcuts import render_to_response
+from forum.modules.decorators import decorate
+from forum import views
+from lib.akismet import Akismet
+from forum.settings import APP_URL, OSQA_VERSION
+import settings
+
+
+def check_spam(param, comment_type):
+ def wrapper(origin, request, *args, **kwargs):
+ if request.POST and request.POST.get(param, None) and settings.WORDPRESS_API_KEY:
+ comment = request.POST[param]
+ data = {
+ "user_ip":request.META["REMOTE_ADDR"],
+ "user_agent":request.environ['HTTP_USER_AGENT'],
+ "comment_type": comment_type,
+ "comment":comment
+ }
+
+ if request.user.is_authenticated():
+ data.update({
+ "comment_author":request.user.username,
+ "comment_author_email":request.user.email,
+ "comment_author_url":request.user.website,
+ })
+
+ api = Akismet(settings.WORDPRESS_API_KEY, APP_URL, "OSQA/%s" % OSQA_VERSION)
+ if api.comment_check(comment, data):
+ if request.is_ajax():
+ response = {
+ 'success': False,
+ 'error_message': _("Sorry, but akismet thinks your %s is spam.") % comment_type
+ }
+ return HttpResponse(simplejson.dumps(response), mimetype="application/json")
+ else:
+ return render_to_response('modules/akismet/foundspam.html', {
+ 'action_name': comment_type
+ })
+
+ return origin(request, *args, **kwargs)
+ return wrapper
+
+
+decorate(views.writers.ask)(check_spam('text', _('question')))
+decorate(views.writers.answer)(check_spam('text', _('answer')))
+decorate(views.commands.comment)(check_spam('comment', _('comment')))
+
+
--- /dev/null
+{% extends "base_content.html" %}
+{% load i18n %}
+{% block title %}{% trans "Akismet message" %}{% endblock %}
+
+{% block content %}
+<div class="headNormal">
+{% blocktrans %}Akismet believes your {{ action_name }} is spam.{% endblocktrans %}
+</div>
+<div class="content">
+{% blocktrans %}
+We're sorry, but Akismet believes your {{ action_name }} is spam.<br />
+If you believe this is an error, please contact the forum administrator.
+{% endblocktrans %}
+</div>
+{% endblock %}
\ No newline at end of file
class MyOpenIdAuthConsumer(OpenIdAbstractAuthConsumer):
+ dataype2ax_schema = {
+ 'username': ('http://schema.openid.net/namePerson/friendly', 'friendly'),
+ 'email': 'http://schema.openid.net/contact/email',
+ 'web': 'http://schema.openid.net/contact/web/default',
+ 'birthdate': ('http://schema.openid.net/birthDate', 'birthDate'),
+ }
+
def get_user_url(self, request):
blog_name = request.POST['input_field']
return "http://%s.myopenid.com/" % blog_name
+import re
+
from django.utils.html import escape
from django.http import get_host
class OpenIdAbstractAuthConsumer(AuthenticationConsumer):
+ dataype2ax_schema = {
+ 'username': 'http://axschema.org/namePerson/friendly',
+ 'email': 'http://axschema.org/contact/email',
+ 'web': 'http://axschema.org/contact/web/default',
+ 'firstname': 'http://axschema.org/namePerson/first',
+ 'lastname': 'http://axschema.org/namePerson/last',
+ 'birthdate': 'http://axschema.org/birthDate',
+ }
+
def get_user_url(self, request):
try:
return request.POST['openid_identifier']
if request.session.get('force_email_request', True):
axr = AXFetchRequest()
- axr.add(AttrInfo("http://axschema.org/contact/email", 1, True, "email"))
+ for data_type, schema in self.dataype2ax_schema.items():
+ if isinstance(schema, tuple):
+ axr.add(AttrInfo(schema[0], 1, True, schema[1]))
+ else:
+ axr.add(AttrInfo(schema, 1, True, data_type))
+
auth_request.addExtension(axr)
trust_root = getattr(
settings, 'OPENID_TRUST_ROOT', get_url_host(request) + '/'
)
-
return auth_request.redirectURL(trust_root, redirect_to)
def process_authentication_request(self, request):
(k.encode('utf8'), v.encode('utf8')) for k, v in request.GET.items()
])
- #for i in query_dict.items():
- # print "%s : %s" % i
+ for i in query_dict.items():
+ print "%s : %s" % i
url = get_url_host(request) + request.path
openid_response = consumer.complete(query_dict, url)
if request.session.get('force_email_request', True):
try:
ax = AXFetchResponse.fromSuccessResponse(openid_response)
- email = ax.getExtensionArgs()['value.ext0.1']
- request.session['auth_email_request'] = email
+
+ axargs = ax.getExtensionArgs()
+
+ ax_schema2data_type = dict([(s, t) for t, s in self.dataype2ax_schema.items()])
+
+ available_types = dict([
+ (ax_schema2data_type[s], re.sub('^type\.', '', n))
+ for n, s in axargs.items() if s in ax_schema2data_type
+ ])
+
+ available_data = dict([
+ (t, axargs["value.%s.1" % s]) for t, s in available_types.items()
+ ])
+
+ print available_data
+
+
+ #email = ax.getExtensionArgs()['value.ext0.1']
+ #username = ax.getExtensionArgs()['value.ext0.2']
+
+ request.session['auth_consumer_data'] = {
+ 'email': '',
+ 'username': ''
+ }
+
except Exception, e:
- pass
+ import sys, traceback
+ traceback.print_exc(file=sys.stdout)
return request.GET['openid.identity']
elif openid_response.status == CANCEL:
# encoding:utf-8
import os.path
-from django.utils.translation import ugettext as _
-
-def check_local_setting(name, value):
- local_vars = locals()
- if name in local_vars and local_vars[name] == value:
- return True
- else:
- return False
SITE_SRC_ROOT = os.path.dirname(__file__)
LOG_FILENAME = 'django.osqa.log'
USE_I18N = True
LANGUAGE_CODE = 'en'
-EMAIL_VALIDATION = 'off' #string - on|off
-MIN_USERNAME_LENGTH = 1
-EMAIL_UNIQUE = False
-WIKI_ON = True
-FEEDBACK_SITE_URL = None #None or url
-EDITABLE_SCREEN_NAME = False #True or False - can user change screen name?
+EMAIL_VALIDATION = 'off' #string - on|off
DJANGO_VERSION = 1.1
-RESOURCE_REVISION=4
-
OSQA_DEFAULT_SKIN = 'default'
DISABLED_MODULES = ['books', 'recaptcha', 'project_badges']
-
-from forum.settings import *
\ No newline at end of file
projects / osqa.git / commitdiff