def openid_createuser(request):
person = openidgae.get_current_person(request, http.HttpResponse())
email = person.get_email()
res = util_externals.reponse_if_exists(email)
if res is not None:
return res
nick = util_externals.get_nick_from_email(email)
params = {
'nick': nick,
'password': util.generate_password(),
'first_name': person.get_field_value('firstname', 'none'),
'last_name': person.get_field_value('lastname', 'none'),
'fromopenid': True,
'email':email,
}
actor_ref = util_externals.user_create('google', params, util.display_nick(email), email)
# NOTE: does not provide a flash message
response = util.RedirectFlash('/', 'Welcome to %s' % util.get_metadata('SITE_NAME'))
user.set_user_cookie(response, actor_ref)
return response
def index(request):
response = HttpResponse()
person = openidgae.get_current_person(request, response)
if (person is not None) and (person.usertype >= openidgae.models.USERTYPE_SCRUMMASTER):
blog_entries = skram.blog.models.BlogEntry.all()
else:
blog_entries = skram.blog.models.BlogEntry.all().filter('is_published =', True)
payload = dict(blog_entries=blog_entries)
return render(request, response, 'index.html', payload)
def delete_blog_comment(request, blog_title, comment_id):
try:
blog_comment = models.Comment.get_by_id(int(comment_id));
if blog_comment is None:
raise ObjectDoesNotExist('Blog comment does not exist!')
if blog_comment.created_by.key() != openidgae.get_current_person(request, HttpResponse()).key():
return HttpResponse(content='Unauthorized user!', status=403)
blog_comment.delete()
except Exception, e:
logging.error('Exception: ' + str(e))
return HttpResponse(content='Exception: ' + str(e), status=400)
def render(request, response, template, payload):
person = openidgae.get_current_person(request, response)
payload['lip'] = person
payload['user_is_registred'] = (person is not None) and \
(person.usertype >= openidgae.models.USERTYPE_USER)
payload['user_is_scrummaster'] = (person is not None) and \
(person.usertype >= openidgae.models.USERTYPE_SCRUMMASTER)
payload['user_is_admin'] = (person is not None) and \
(person.usertype >= openidgae.models.USERTYPE_ADMINISTRATOR)
return render_to_response(template,
payload,
context_instance=RequestContext(request))
def render(template_name, request, response, extra_values={}):
values = {
'lip': openidgae.get_current_person(request, response)
}
values.update(extra_values)
#path = os.path.join(DIRNAME, 'templates', template_name)
#return template.render(path, values)
import django.template
import django.template.loader
t = django.template.loader.get_template(template_name)
return t.render(django.template.Context(values))
def create_comment(request, blog_title):
try:
blog_entry = models.BlogEntry.get_by_key_name(blog_title)
if blog_entry is None:
raise ObjectDoesNotExist('Blog entry does not exist!')
if not blog_entry.comments_allowed:
return HttpResponse(content='Commenting is not allowed!', status=403)
blog_comment = models.Comment(text = request.POST['blog-comment'],
blog_entry = blog_entry,
created_by = openidgae.get_current_person(request, HttpResponse()))
blog_comment.put()
except Exception, e:
logging.error('Exception: ' + str(e))
return HttpResponse(content='Exception: ' + str(e), status=400)
def get_current_user(request=None,response=None):
'''get the current user'''
if settings.LOCAL:
person = CyclePerson()
person.email = "*****@*****.**"
person.access_token = "oauth_token_secret=fH3AB3e3Ok9GsyiwbD73rikT&oauth_token=1%2FRmFT2U_qh2KdxM0UPcgiZbxPSE39U0ZYNu8LGDPkq0Q"#
person.put()
details = PersonDetails.all().filter('person=', person).get()
if not details:
details = PersonDetails(person = person)
details.put()
return person
logging.info("calling openidgae.get_current_person")
return openidgae.get_current_person(request,response)
def create_or_update(request, blog_entry=None):
if request.POST:
# The POST request includes form data - validate it
blog_entry_form = forms.BlogEntryForm(request.POST, instance=blog_entry)
if blog_entry_form.is_valid():
if blog_entry is None:
blog_entry = blog_entry_form.save(commit=False)
blog_entry.created_by = openidgae.get_current_person(request, HttpResponse())
blog_entry.put()
else:
blog_entry = blog_entry_form.save()
return HttpResponseRedirect(blog_entry.get_absolute_url())
else:
response_status = 400;
else:
# The POST request does not include form data
blog_entry_form = forms.BlogEntryForm(instance=blog_entry)
response_status = 200;
payload = dict(blog_entry_form=blog_entry_form, blog_entry=blog_entry)
response = skram.views.render(request, HttpResponse(), 'edit_blog_entry.html', payload)
response.status_code = response_status;
return response
def render(request, response, template, payload):
payload['recents'] = models.Poll.all().order('-created_on').fetch(20)
payload['lip'] = openidgae.get_current_person(request, response)
return render_to_response(template, payload)
def join_join(request):
if request.user:
raise exception.AlreadyLoggedInException()
redirect_to = request.REQUEST.get('redirect_to', '/')
account_types = api.get_config_values(api.ROOT, 'account_type')
# get the submitted vars
nick = request.REQUEST.get('nick', '');
first_name = request.REQUEST.get('first_name', '');
last_name = request.REQUEST.get('last_name', '');
email = request.REQUEST.get('email', '');
password = request.REQUEST.get('password', '');
confirm = request.REQUEST.get('confirm', '');
hide = request.REQUEST.get('hide', '');
country_tag = request.REQUEST.get('country_tag', '')
if request.POST:
try:
# TODO validate
params = util.query_dict_to_keywords(request.POST)
if hide:
params['privacy'] = 2
# XXX: Check if the data come from a openid account
# @author: [email protected]
fromopenid = request.POST.get('fromopenid', False) and True
if fromopenid:
try:
person = openidgae.get_current_person(request, http.HttpResponse())
except:
raise exception.ServiceError
email = person.get_email()
if email == params['email']:
params['password'] = util.generate_password()
else:
raise exception.ServiceError
# ENDXXX
validate.email(email)
if not mail.is_allowed_to_send_email_to(email):
raise exception.ValidationError("Cannot send email to that address")
# TODO start transaction
if api.actor_lookup_email(api.ROOT, email):
raise exception.ValidationError(
'That email address is already associated with a member.')
actor_ref = api.user_create(api.ROOT, **params)
actor_ref.access_level = "delete"
api.post(actor_ref,
nick=actor_ref.nick,
message='Joined %s!' % (util.get_metadata('SITE_NAME')))
if fromopenid:
api.email_associate(api.ROOT, actor_ref.nick, email)
else:
# send off email confirmation
api.activation_request_email(actor_ref, actor_ref.nick, email)
logging.info('setting firsttime_%s from register page' % actor_ref.nick)
memcache.client.set('firsttime_%s' % nick, True)
# TODO end transaction
welcome_url = util.qsa('/', {'redirect_to': redirect_to})
# NOTE: does not provide a flash message
response = http.HttpResponseRedirect(welcome_url)
user.set_user_cookie(response, actor_ref)
return response
except:
exception.handle_exception(request)
# for legal section
legal_component = component.include('legal', 'dummy_legal')
legal_html = legal_component.embed_join()
# for sidebar
sidebar_green_top = True
area = "join"
c = template.RequestContext(request, locals())
t = loader.get_template('join/templates/join.html')
return http.HttpResponse(t.render(c))
def inner(request, *args, **kwargs):
lip = openidgae.get_current_person(request, HttpResponse())
if (lip is None) or (lip.usertype < min_authorization_level):
return HttpResponse(content='401 unauthorized', status=401)
return func(request, *args, **kwargs)
