Here are the examples of the python api django.contrib.auth.models.User.objects.get taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.
165 Examples
1
Example 1
def add_link(self, url, username, source_name, source_type, **kwargs):
"""
Shortcut attempts to add the URL. Performs necessary
normalizations, alias lookup, user creation, points assignment,
etc. before trying to create the Link. Raises OldMeme(old_link)
if a normalized version of this URL has been posted previously,
otherwise returns the new Link.
"""
# try this first
blacklist.check(url)
username = username.lower()
user = Alias.objects.get_user(username)
if user is None:
if settings.AUTO_USER_ADD and self.is_valid_username(username):
user = self.create_anonymous_user(username)
else:
try:
user = User.objects.get(username=settings.UNKNOWN_USERNAME)
except User.DoesNotExist:
user = self.create_anonymous_user(settings.UNKNOWN_USERNAME)
source = Source.objects.get_or_create(type=source_type, name=source_name)[0]
normalized = self.normalize_url(url)
try:
link = self.get(normalized=normalized, source=source)
if user != link.user:
link.reposts += 1
link.save()
profile = user.get_profile()
profile.posted_old += 1
profile.save()
poster_profile = link.user.get_profile()
poster_profile.reposts += 1
poster_profile.save()
raise OldMeme(link)
except self.model.DoesNotExist:
link = self.create(user=user, source=source, url=url, normalized=normalized, **kwargs)
profile = user.get_profile()
profile.posted_new += 1
profile.save()
return link
0
Example 2
Project: splunk-webframework Source File: basic.py
def test_createsuperuser_management_command(self):
"Check the operation of the createsuperuser management command"
# We can use the management command to create a superuser
new_io = StringIO()
call_command("createsuperuser",
interactive=False,
username="joe",
email="[email protected]",
stdout=new_io
)
command_output = new_io.getvalue().strip()
self.assertEqual(command_output, 'Superuser created successfully.')
u = User.objects.get(username="joe")
self.assertEqual(u.email, '[email protected]')
# created password should be unusable
self.assertFalse(u.has_usable_password())
# We can supress output on the management command
new_io = StringIO()
call_command("createsuperuser",
interactive=False,
username="joe2",
email="[email protected]",
verbosity=0,
stdout=new_io
)
command_output = new_io.getvalue().strip()
self.assertEqual(command_output, '')
u = User.objects.get(username="joe2")
self.assertEqual(u.email, '[email protected]')
self.assertFalse(u.has_usable_password())
call_command("createsuperuser",
interactive=False,
username="[email protected]",
email="[email protected]",
verbosity=0
)
u = User.objects.get(username="[email protected]")
self.assertEqual(u.email, '[email protected]')
self.assertFalse(u.has_usable_password())
0
Example 3
def process_message(self, message):
if message.processed:
return
text = message.text
tokenizer = RegexpTokenizer('\w+|\$[\d\.]+|\S+')
tokens = tokenizer.tokenize(text)
for t in tokens:
t_end = t[1:]
if t.startswith("@"):
try:
user = User.objects.get(username__iexact=t_end)
message.mentions.add(user)
if user != message.user:
try:
if message.reply_to is None:
MessageNotification.objects.get_or_create(
receiving_message=message,
receiving_user=user,
origin_message=message,
notification_type="mention_in_message",
)
else:
MessageNotification.objects.get_or_create(
receiving_message=message.reply_to,
receiving_user=user,
origin_message=message,
notification_type="mention_in_reply",
)
except IntegrityError:
pass
except User.DoesNotExist:
pass
elif t.startswith("#"):
try:
tag = Tag.objects.get(name__iexact=t_end)
message.tags.add(tag)
except Tag.DoesNotExist:
pass
elif t.startswith("*"):
try:
resource = Resource.objects.get(name__iexact=t_end)
message.resources.add(resource)
except Resource.DoesNotExist:
pass
message.processed = True
0
Example 4
Project: django-goflow Source File: models.py
def _forward_workitem_to_activity(self, target_activity):
'''
Passes the process instance embedded in the given workitem
to a new workitem that is associated with the destination activity.
@type target_activity: Activity
@param target_activity: the activity instance to which the workitem
should be forwarded
@rtype: WorkItem
@return: a workitem that has been passed on to the next
activity (and next user)
'''
instance = self.instance
# search a blocked workitem first
qwi = WorkItem.objects.filter(instance=instance, activity=target_activity, status='blocked')
if qwi.count() == 0:
wi = WorkItem.objects.create(instance=instance, activity=target_activity,
user=None, priority=self.priority)
created = True
log.info('forwarded to %s', target_activity.title)
Event.objects.create(name='creation by %s' % self.user.username, workitem=wi)
Event.objects.create(name='forwarded to %s' % target_activity.title, workitem=self)
wi.workitem_from = self
else:
created = False
wi = qwi[0]
if target_activity.join_mode == 'and':
nb_input_transitions = target_activity.nb_input_transitions()
if nb_input_transitions > 1:
if created:
# first worktem: block it
wi.block()
return
else:
wi.others_workitems_from.add(self)
if wi.others_workitems_from.all().count() + 1 < nb_input_transitions:
# keep blocked
return
else:
# check if the join is OK
if wi.check_join():
wi.status = 'inactive'
wi.save()
log.info('activity %s: workitem %s unblocked', target_activity.title, str(wi))
else:
return
else:
if not created:
# join_mode='and'
log.error('activity %s: join_mode must be and', target_activity.title)
self.fall_out()
wi.fall_out()
return
if target_activity.autostart:
log.info('run auto activity %s workitem %s', target_activity.title, str(wi))
try:
auto_user = User.objects.get(username=settings.WF_USER_AUTO)
except Exception:
error = 'a user named %s (settings.WF_USER_AUTO) must be defined for auto activities'
raise Exception(error % settings.WF_USER_AUTO)
wi.activate(actor=auto_user)
if wi.exec_auto_application():
wi.complete(actor=auto_user)
return wi
if target_activity.push_application:
target_user = wi.exec_push_application()
log.info('application pushed to user %s', target_user.username)
wi.user = target_user
wi.save()
Event.objects.create(name='assigned to %s' % target_user.username, workitem=wi)
WorkItem.objects.notify_if_needed(user=target_user)
else:
wi.pull_roles = wi.activity.roles.all()
wi.save()
WorkItem.objects.notify_if_needed(roles=wi.pull_roles)
return wi
0
Example 5
def test_post(self):
res = self.client['anonymous'].post(self.url_projects, content_type='application/json')
self.assertEquals(res.status_code, 401)
res = self.client['registered'].post(self.url_project, content_type='application/json')
self.assertContains(res, "POSTing to this url is not allowed", status_code=400)
res = self.client['registered'].post(self.url_projects)
self.assertContains(res, "Bad Request", status_code=400)
res = self.client['registered'].post(
self.url_projects, simplejson.dumps({'name': 'name of project'}),
content_type="application/json"
)
self.assertContains(res, "Field 'slug' is required to create", status_code=400)
res = self.client['registered'].post(
self.url_projects, simplejson.dumps({'slug': 'slug'}), content_type='application/json'
)
self.assertContains(res, "Field 'name' is required to create", status_code=400)
res = self.client['registered'].post(
self.url_projects, simplejson.dumps({'slug': 'slug', 'name': 'name'}),
content_type='application/json'
)
self.assertContains(res, "Field 'source_language_code' is required to create", status_code=400)
res = self.client['registered'].post(
self.url_projects, simplejson.dumps({
'slug': 'slug', 'name': 'name', 'owner': 'owner',
'source_language_code': 'en',
}),
content_type='application/json'
)
self.assertContains(res, "Owner cannot be set explicitly.", status_code=400)
res = self.client['registered'].post(
self.url_projects, simplejson.dumps({
'slug': 'api_project',
'name': 'Project from API',
'source_language_code': 'en',
'description': 'desc',
'outsource': 'not_exists',
}),
content_type='application/json'
)
self.assertContains(res, "Project for outsource does not exist", status_code=400)
res = self.client['registered'].post(
self.url_projects, simplejson.dumps({
'slug': 'api_project', 'name': 'Project from API',
'source_language_code': 'en', 'maintainers': 'not_exists',
'description': 'desc',
}),
content_type='application/json'
)
self.assertContains(res, "User", status_code=400)
res = self.client['registered'].post(
self.url_projects, simplejson.dumps({
'slug': 'api_project_maintainers',
'name': 'Project from API',
'source_language_code': 'en',
'maintainers': 'registered',
'none': 'none'
}),
content_type='application/json'
)
self.assertContains(res, "Field 'none'", status_code=400)
res = self.client['registered'].post(
self.url_projects, simplejson.dumps({
'slug': 'api_project_maintainers',
'name': 'Project from API',
'source_language_code': 'en',
'maintainers': 'registered',
'description': 'desc',
}),
content_type='application/json'
)
self.assertEquals(res.status_code, 201)
self.assertEquals(len(Project.objects.all()), 8)
res = self.client['registered'].post(
self.url_projects, simplejson.dumps({
'slug': 'api_project', 'name': 'Project from API',
'source_language_code': 'en_US', 'description': 'desc',
}),
content_type='application/json'
)
p = Project.objects.get(slug='api_project')
user = User.objects.get(username='registered')
self.assertTrue(user in p.maintainers.all())
self.assertEquals(res.status_code, 201)
self.assertEquals(len(Project.objects.all()), 9)
self.assertEquals(p.source_language, self.language_en)
# Check permissions
user = User.objects.get(username='registered')
user.groups = []
user.save()
res = self.client['registered'].post(
self.url_projects, simplejson.dumps({
'slug': 'api_project_2', 'name': 'Project from API - second',
'source_language_code': 'en_US', 'desctiption': 'desc',
}),
content_type='application/json'
)
self.assertEquals(res.status_code, 403)
0
Example 6
def handle(self, *args, **options):
if len(args) != 2:
raise CommandError(_("Expected two arguments"))
try:
contest = Contest.objects.get(id=args[0])
except Contest.DoesNotExist:
raise CommandError(_("Contest %s does not exist") % args[0])
arg = args[1]
if arg.startswith('http://') or arg.startswith('https://'):
self.stdout.write(_("Fetching %s...\n") % (arg,))
stream = urllib2.urlopen(arg)
else:
if not os.path.exists(arg):
raise CommandError(_("File not found: ") + arg)
stream = open(arg, 'r')
reader = csv.reader(stream)
header = reader.next()
if header != self.COLUMNS:
raise CommandError(_("Missing header or invalid columns: "
"%(header)s\nExpected: %(expected)s") % {
'header': ', '.join(header),
'expected': ', '.join(self.COLUMNS)})
with transaction.atomic():
BalloonsDisplay.objects.filter(contest=contest).delete()
ok = True
all_count = 0
for row in reader:
all_count += 1
for i, _column in enumerate(self.COLUMNS):
row[i] = row[i].decode('utf8')
try:
user = User.objects.get(username=row[0])
display = BalloonsDisplay(ip_addr=row[1], user=user,
contest=contest)
display.save()
except User.DoesNotExist:
self.stdout.write(_("Error for user=%(user)s: user does"
" not exist\n") % {'user': row[1]})
ok = False
except DatabaseError, e:
# This assumes that we'll get the message in this
# encoding. It is not perfect, but much better than
# ascii.
message = e.message.decode('utf-8')
self.stdout.write(_(
"DB Error for user=%(user)s: %(message)s\n")
% {'user': row[1], 'message': message})
ok = False
except ValidationError, e:
for k, v in e.message_dict.iteritems():
for message in v:
if k == '__all__':
self.stdout.write(_(
"Error for user=%(user)s: %s\n")
% (row[1], message))
else:
self.stdout.write(
_("Error for user=%(user)s, "
"field %(field)s: %(message)s\n")
% {'user': row[1], 'field': k,
'message': message})
ok = False
if ok:
self.stdout.write(_("Processed %d entries") % (all_count))
else:
raise CommandError(_("There were some errors. Database not "
"changed.\n"))
0
Example 7
Project: BingAds-Python-SDK Source File: views.py
def authorize_bing_ads_user(request, authentication, authentication_type, environment):
assert isinstance(request, HttpRequest)
global customer_service
bingadsuser = None
try:
Users = get_user_model()
user = User.objects.get(username=request.user.username)
except User.DoesNotExist:
user = User.objects.create_user(username=request.user.username, password=password)
try:
bingadsuser = user.bingadsuser
except BingAdsUser.DoesNotExist:
bingadsuser = BingAdsUser()
bingadsuser.user = user
pass
# If we have a refresh token let's refresh it
if(authentication_type == 'OAuthWebAuthCodeGrant' and bingadsuser != None and bingadsuser.refresh_token != ""):
authentication.request_oauth_tokens_by_refresh_token(bingadsuser.refresh_token)
bingadsuser.refresh_token = authentication.oauth_tokens.refresh_token
# If the current HTTP request is a callback from the Microsoft Account authorization server,
# use the current request url containing authorization code to request new access and refresh tokens
elif (authentication_type == 'OAuthWebAuthCodeGrant' and request.GET.get('code') != None):
authentication.request_oauth_tokens_by_response_uri(response_uri = request.get_full_path())
bingadsuser.refresh_token = authentication.oauth_tokens.refresh_token
# If there is no refresh token saved and no callback from the authorization server,
# then connect to the authorization server and request user consent.
elif (authentication_type == 'OAuthWebAuthCodeGrant' and bingadsuser.refresh_token == ""):
return redirect(authentication.get_authorization_endpoint())
set_session_data(request, authentication, authentication_type, environment)
user.save()
bingadsuser.save()
# At this point even if the user has a valid web application user account, we don't know whether they have access to Bing Ads.
# Let's test to see if they can call Bing Ads services, and only let Bing Ads users login to this application.
bing_ads_user = None
errors=[]
try:
bing_ads_user = get_user(None)
except WebFault as ex:
errors=get_webfault_errors(ex)
pass
form = BingAdsPasswordAuthenticationForm()
form.username = ""
form.password = ""
return render(
request,
'app/index.html',
context_instance = RequestContext(request,
{
'bingadsuser': bing_ads_user,
'errors': errors,
'form': form,
'year':datetime.now().year,
})
)
0
Example 8
def merge_users(self, request):
# takes one user and merges them into another by
# changing all their content objects' user ids to the new user's id.
context_instance = RequestContext(request)
opts = self.model._meta
admin_site = self.admin_site
merged_notice = None
merged_objects = []
preview_objects = None
preview_notice = None
if request.method == "POST":
if request.POST.get('merge'):
old_user = User.objects.get(id = request.POST.get('old_user'))
merge_user = User.objects.get(id = request.POST.get('merge_user'))
meta_objects = [rel.get_accessor_name() for rel in User._meta.get_all_related_objects()]
for meta in meta_objects:
try:
objects = getattr(old_user, meta).all()
if objects:
for object in objects:
# for some reason, printing the object here prevents
# Doesnotexist errors when i try to print the final list. need to fix.
print object
object.user = merge_user
object.save()
merged_objects.append(object)
except:
pass
blog_posts = old_user.get_profile().get_blog_posts()
if blog_posts:
for post in blog_posts:
post.authors.add(merge_user)
post.authors.remove(old_user)
merged_objects.append(post)
old_user.is_active = 0
old_user.save()
if merged_objects:
merged_notice = "%s objects merged" % len(merged_objects)
else:
merged_notice = "0 objects merged"
if request.POST.get('view_user_objects'):
preview_user = User.objects.get(id = request.POST.get('preview_user'))
preview_objects = []
if preview_user:
meta_objects = [rel.get_accessor_name() for rel in User._meta.get_all_related_objects()]
for meta in meta_objects:
try:
objects = getattr(preview_user, meta).all()
if objects:
for object in objects:
# for some reason, printing the object here prevents
# Doesnotexist errors when i try to print the final list. need to fix.
print object
preview_objects.append(object)
except:
pass
blog_posts = preview_user.get_profile().get_blog_posts()
if blog_posts:
for post in blog_posts:
preview_objects.append(post)
if preview_objects:
preview_notice = "USER'S OBJECTS:"
else:
preview_notice = "USER HAS NOT OBJECTS"
d = {'admin_site': admin_site.name,
'title': "Merge Users",
'opts': "Profiles",
'app_label': opts.app_label,
'merged_objects':merged_objects,
'merged_notice':merged_notice,
"preview_objects":preview_objects,
"preview_notice":preview_notice
}
return render_to_response('admin/accounts/rhizomeuser/merge_users.html', d, context_instance)
0
Example 9
Project: pari Source File: import_scrapy.py
def handle(self, *args, **options):
jsonfilename = options['filename']
with open(jsonfilename, 'r') as f:
for line in f:
jsoncontent = json.loads(line)
title = jsoncontent['title'][0].encode('utf-8').strip()
try:
new_article = Article.objects.get(title=title)
type_of_import = "Update"
except ObjectDoesNotExist:
new_article = Article()
new_article.title = title
type_of_import = "Import"
print "{0} {1}".format(type_of_import, title)
try:
author=Author.objects.get(title=jsoncontent['author'][0])
except ObjectDoesNotExist:
author = Author(title=jsoncontent['author'][0])
author.save()
new_article.author = author
new_article.user = User.objects.get(pk=1)
new_article.content = jsoncontent['content'] + "<p><em>This article was originally published on The Hindu at <a href=\"{0}\">{0}</a></em></p>".format(jsoncontent['link'][0])
try:
date = datetime.strptime(jsoncontent['date'], "%B %d, %Y").replace(tzinfo=utc)
new_article.publish_date = date
except:
new_article.publish_date = jsoncontent['date']
new_article.status = 1 # draft
new_article.save()
new_article.types.add(Type.objects.get(title='Photo'))
if hasattr(jsoncontent, 'location'):
location_name = jsoncontent['location'].strip(',\n')
try:
location = Location.objects.get(title__iexact=location_name)
new_article.locations.add(location)
except ObjectDoesNotExist:
pass
if hasattr(jsoncontent, 'keywords'):
for k in jsoncontent['keywords']:
try:
keyword = Keyword.objects.get(title__iexact=k)
except ObjectDoesNotExist:
keyword = Keyword(title=k)
keyword.save()
if not new_article.keywords.filter(keyword=keyword).exists():
new_article.keywords.add(AssignedKeyword(keyword=keyword))
0
Example 10
Project: volontulo Source File: __init__.py
@login_required
def logged_user_profile(request):
u"""View to display user profile page.
:param request: WSGIRequest instance
"""
def _init_edit_profile_form():
u"""Initialize EditProfileForm - helper method."""
return EditProfileForm(
initial={
'phone_no': request.user.userprofile.phone_no,
'first_name': request.user.first_name,
'last_name': request.user.last_name,
'user': request.user.id,
}
)
def _populate_participated_offers(request):
u"""Populate offers that current user participate."""
return Offer.objects.filter(volunteers=request.user)
def _populate_created_offers(request):
u"""Populate offers that current user create."""
return Offer.objects.filter(
organization__userprofiles__user=request.user
)
def _is_saving_user_avatar():
u"""."""
return request.POST.get('submit') == 'save_image' and request.FILES
def _is_saving_organization_image():
u"""."""
submit_value = request.POST.get('submit')
return submit_value == 'save_organization_image' and request.FILES
def _is_saving_profile():
u"""."""
return request.POST.get('submit') == 'save_profile'
def _save_userprofile():
u"""Save user profile"""
form = EditProfileForm(request.POST)
if form.is_valid():
user = User.objects.get(id=request.user.id)
if (
form.cleaned_data['current_password'] and
form.cleaned_data['new_password'] and
form.cleaned_data['confirm_new_password']
):
user.set_password(form.cleaned_data['new_password'])
user.userprofile.phone_no = form.cleaned_data['phone_no']
user.first_name = form.cleaned_data['first_name']
user.last_name = form.cleaned_data['last_name']
user.userprofile.save()
user.save()
messages.success(
request,
u"Zaktualizowano profil"
)
else:
errors = '<br />'.join(form.errors)
messages.error(
request,
u"Problem w trakcie zapisywania profilu: {}".format(errors)
)
return form
def _handle_user_avatar_upload():
u"""Handle image upload for user profile page."""
gallery_form = UserGalleryForm(request.POST, request.FILES)
if gallery_form.is_valid():
userprofile.clean_images()
gallery = gallery_form.save(commit=False)
gallery.userprofile = userprofile
# User can only change his avatar
gallery.is_avatar = True
gallery.save()
messages.success(request, u"Dodano grafikę")
else:
errors = '<br />'.join(gallery_form.errors)
messages.error(
request,
u"Problem w trakcie dodawania grafiki: {}".format(errors)
)
def _handle_organization_image_upload():
u"""Handle image upload for user profile page."""
def _is_main(form):
u"""Return True if is_main image was selected."""
return True if form.cleaned_data['is_main'] else False
gallery_form = OrganizationGalleryForm(
userprofile,
request.POST,
request.FILES
)
if gallery_form.is_valid():
gallery = gallery_form.save(commit=False)
gallery.published_by = userprofile
if _is_main(gallery_form):
gallery.set_as_main(gallery.organization)
gallery.save()
messages.success(request, u"Dodano zdjęcie do galerii.")
else:
errors = '<br />'.join(gallery_form.errors)
messages.error(
request,
u"Problem w trakcie dodawania grafiki: {}".format(errors)
)
profile_form = _init_edit_profile_form()
userprofile = UserProfile.objects.get(user=request.user)
galleries = OrganizationGallery.get_organizations_galleries(
userprofile
)
if request.method == 'POST':
if _is_saving_user_avatar():
_handle_user_avatar_upload()
elif _is_saving_organization_image():
_handle_organization_image_upload()
return redirect('logged_user_profile')
elif _is_saving_profile():
profile_form = _save_userprofile()
ctx = dict(
profile_form=profile_form,
user_avatar_form=UserGalleryForm(),
organization_image_form=OrganizationGalleryForm(userprofile),
galleries=galleries,
userprofile=userprofile,
MEDIA_URL=settings.MEDIA_URL
)
ctx['participated_offers'] = _populate_participated_offers(request)
ctx['created_offers'] = _populate_created_offers(request)
return render(request, 'users/user_profile.html', ctx)
0
Example 11
Project: django-api-tools Source File: tests.py
def test_dictify_helper(self):
user = User.objects.get(id=1)
foo = Foo.objects.get(id=1)
foo.set_user_auth(user)
# Test no dictified fields returned for empty fields to return
self.assertDictEqual(foo.dictify_helper(Foo.public_fields, [], False), {})
# Test no dictified fields returned for fields which aren't in the auth level
self.assertDictEqual(foo.dictify_helper(Foo.public_fields, ['bar1', 'bar2'], False), {})
# Test regular field is set in the dictionary
dictified_foo = foo.dictify_helper(Foo.public_fields, Foo.public_fields, False)
self.assertEqual(dictified_foo['id'], foo.id)
# Test invalid regular fields is set as None
non_existent_field = ('test', )
dictified_foo = foo.dictify_helper(non_existent_field, non_existent_field, False)
self.assertIsNone(dictified_foo[non_existent_field[0]])
# Test invalid related field is set as None
non_existent_rel_field = ('fk_short_test', )
dictified_foo = foo.dictify_helper(non_existent_rel_field, non_existent_rel_field, False)
self.assertIsNone(dictified_foo['test'])
# Test fk_short only returns the foreign model's ID
fk_short_field = ('fk_short_baz', )
bar = Bar.objects.get(id=1)
bar.set_user_auth(user)
dictified_bar = bar.dictify_helper(fk_short_field, fk_short_field, False)
self.assertEqual(len(dictified_bar), 1)
self.assertDictKeysEqual(dictified_bar['baz'], self.remove_foreign_key_fields(bar.baz.short_description_fields))
# Test fk_long returns the foreign model's dictify_long()
fk_long_field = ('fk_long_baz', )
dictified_bar = bar.dictify_helper(fk_long_field, fk_long_field, False)
self.assertEqual(len(dictified_bar), 1)
self.assertDictKeysEqual(dictified_bar['baz'], self.remove_foreign_key_fields(bar.baz.short_description_fields + bar.baz.long_description_fields))
# Test onetoone_short only returns the foreign model's ID
onetoone_short_field = ('onetoone_short_owner', )
dictified_foo = foo.dictify_helper(onetoone_short_field, onetoone_short_field, False)
self.assertEqual(len(dictified_foo), 1)
self.assertDictKeysEqual(dictified_foo['owner'], self.remove_foreign_key_fields(foo.owner.short_description_fields))
# Test onetoone_long returns the foreign model's dictify_long()
fk_long_field = ('onetoone_long_owner', )
qux = Qux.objects.get(id=1)
qux.set_user_auth(user)
dictified_qux = qux.dictify_helper(fk_long_field, fk_long_field, False)
self.assertEqual(len(dictified_qux), 1)
self.assertDictKeysEqual(dictified_qux['owner'], self.remove_foreign_key_fields(qux.owner.short_description_fields + qux.owner.long_description_fields))
# Test rel_short only returns the related models' ID's
rel_short_field = ('rel_short_bars', )
baz = Baz.objects.get(id=1)
baz.set_user_auth(user)
dictified_baz = baz.dictify_helper(rel_short_field, rel_short_field, False)
self.assertEqual(len(dictified_baz), 1)
self.assertEqual(len(dictified_baz['bars']), baz.bars.all().count())
self.assertDictKeysEqual(dictified_baz['bars'][0], self.remove_foreign_key_fields(baz.bars.all()[0].short_description_fields))
# Test rel_long returns the related models' dictify_long()
rel_long_field = ('rel_long_bars', )
dictified_baz = baz.dictify_helper(rel_long_field, rel_long_field, False)
self.assertEqual(len(dictified_baz), 1)
self.assertEqual(len(dictified_baz['bars']), baz.bars.all().count())
self.assertDictKeysEqual(dictified_baz['bars'][0], self.remove_foreign_key_fields(baz.bars.all()[0].short_description_fields + baz.bars.all()[0].long_description_fields))
# Test m2m_short only returns the related models' ID's
m2m_short_field = ('m2m_short_foos', )
qux = Qux.objects.get(id=1)
qux.set_user_auth(user)
qux.foos.add(foo)
dictified_qux = qux.dictify_helper(m2m_short_field, m2m_short_field, False)
self.assertEqual(len(dictified_qux), 1)
self.assertEqual(len(dictified_qux['foos']), qux.foos.all().count())
self.assertDictKeysEqual(dictified_qux['foos'][0], self.remove_foreign_key_fields(qux.foos.all()[0].short_description_fields))
# Test m2m_long returns the related models' dictify_long()
m2m_long_field = ('m2m_long_foos', )
dictified_qux = qux.dictify_helper(m2m_long_field, m2m_long_field, False)
self.assertEqual(len(dictified_qux), 1)
self.assertEqual(len(dictified_qux['foos']), qux.foos.all().count())
self.assertDictKeysEqual(dictified_qux['foos'][0], self.remove_foreign_key_fields(qux.foos.all()[0].short_description_fields + qux.foos.all()[0].long_description_fields))
0
Example 12
def test_hydrate(self):
note = Note()
bundle = Bundle(obj=note)
# With no value or nullable, we should get an ``ApiFieldError``.
field_1 = ToOneField(UserResource, 'author')
self.assertRaises(ApiFieldError, field_1.hydrate, bundle)
note = Note.objects.get(pk=1)
bundle = Bundle(obj=note)
# The nullable case.
field_2 = ToOneField(UserResource, 'author', null=True)
field_2.instance_name = 'fk'
bundle.data['fk'] = None
self.assertEqual(field_2.hydrate(bundle), None)
# Wrong resource URI.
field_3 = ToOneField(UserResource, 'author')
field_3.instance_name = 'fk'
bundle.data['fk'] = '/api/v1/users/abc/'
self.assertRaises(NotFound, field_3.hydrate, bundle)
# A real, live attribute!
field_4 = ToOneField(UserResource, 'author')
field_4.instance_name = 'fk'
bundle.data['fk'] = '/api/v1/users/1/'
fk_bundle = field_4.hydrate(bundle)
self.assertEqual(fk_bundle.data['username'], u'johndoe')
self.assertEqual(fk_bundle.data['email'], u'[email protected]')
self.assertEqual(fk_bundle.obj.username, u'johndoe')
self.assertEqual(fk_bundle.obj.email, u'[email protected]')
field_5 = ToOneField(UserResource, 'author')
field_5.instance_name = 'fk'
bundle.data['fk'] = {
'username': u'mistersmith',
'email': u'[email protected]',
'password': u'foobar',
}
fk_bundle = field_5.hydrate(bundle)
self.assertEqual(fk_bundle.data['username'], u'mistersmith')
self.assertEqual(fk_bundle.data['email'], u'[email protected]')
self.assertEqual(fk_bundle.obj.username, u'mistersmith')
self.assertEqual(fk_bundle.obj.email, u'[email protected]')
# Regression - Make sure Unicode keys get converted to regular strings
# so that we can **kwargs them.
field_6 = ToOneField(UserResource, 'author')
field_6.instance_name = 'fk'
bundle.data['fk'] = {
u'username': u'mistersmith',
u'email': u'[email protected]',
u'password': u'foobar',
}
fk_bundle = field_6.hydrate(bundle)
self.assertEqual(fk_bundle.data['username'], u'mistersmith')
self.assertEqual(fk_bundle.data['email'], u'[email protected]')
self.assertEqual(fk_bundle.obj.username, u'mistersmith')
self.assertEqual(fk_bundle.obj.email, u'[email protected]')
# Attribute & null regression test.
# First, simulate data missing from the bundle & ``null=True``.
# Use a Note with NO author, so that the lookup for the related
# author fails.
note = Note.objects.create(
title='Biplanes for all!',
slug='biplanes-for-all',
content='Somewhere, east of Manhattan, will lie the mythical land of planes with more one wing...'
)
bundle = Bundle(obj=note)
field_7 = ToOneField(UserResource, 'notinbundle', null=True)
field_7.instance_name = 'notinbundle'
self.assertEqual(field_7.hydrate(bundle), None)
# Then do something in the bundle also with ``null=True``.
field_8 = ToOneField(UserResource, 'author', null=True)
field_8.instance_name = 'author'
fk_bundle = field_8.hydrate(bundle)
self.assertEqual(field_8.hydrate(bundle), None)
# Then use an unsaved object in the bundle also with ``null=True``.
new_note = Note(
title='Biplanes for all!',
slug='biplanes-for-all',
content='Somewhere, east of Manhattan, will lie the mythical land of planes with more one wing...'
)
new_bundle = Bundle(obj=new_note)
field_9 = ToOneField(UserResource, 'author', null=True)
field_9.instance_name = 'author'
self.assertEqual(field_9.hydrate(bundle), None)
# The blank case.
field_10 = ToOneField(UserResource, 'fk', blank=True)
field_10.instance_name = 'fk'
self.assertEqual(field_10.hydrate(bundle), None)
bundle.data['author'] = '/api/v1/users/1/'
field_11 = ToOneField(UserResource, 'author', blank=True)
field_11.instance_name = 'author'
fk_bundle = field_11.hydrate(bundle)
self.assertEqual(fk_bundle.obj.username, 'johndoe')
# The readonly case.
field_12 = ToOneField(UserResource, 'author', readonly=True)
field_12.instance_name = 'author'
self.assertEqual(field_12.hydrate(bundle), None)
# A related object.
field_13 = ToOneField(UserResource, 'author')
field_13.instance_name = 'fk'
bundle.related_obj = User.objects.get(pk=1)
bundle.related_name = 'author'
fk_bundle = field_13.hydrate(bundle)
self.assertEqual(fk_bundle.obj.username, u'johndoe')
self.assertEqual(fk_bundle.obj.email, u'[email protected]')
0
Example 13
def authenticate(self, username=None, password=None):
"""Authenticate to the AD backends"""
if not '@' in username:
logger.warning("Domain not specified for %s\n" % username)
return None
_, domain = username.split('@')
dom = UserAddresses.objects.filter(address=domain, address_type=1)
if not dom:
logger.warning("AD auth not enabled for %s\n" % domain)
return None
hosts = MailAuthHost.objects.filter(useraddress=dom,
protocol=5,
enabled=True)
if not hosts:
logger.warning("No AD servers found for %s\n" % domain)
return None
adset = None
for host in hosts:
# process all hosts
# Query each host for configured AD settings:
try:
adset = MailADAuthHost.objects.get(ad_host=host)
aduser = ADUser(username, host.address, host.port, adset.ad_search_dn, adset.ad_admin_group, adset.ad_user_group, adset.ad_auth_domain)
except MailADAuthHost.DoesNotExist:
logger.warning("No MySQL MailADAuthHost; using setting.py AD config\n")
aduser = ADUser(username, host.address, host.port, adset, adset, adset, adset)
if not aduser.connect(password):
logger.warning("AD bind failed for %s\n" % username)
continue
user = None
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
logger.warning("User missing %s. creating\n" % username)
user = User(username=username,
is_staff = False,
is_superuser = False)
user.set_unusable_password()
if not aduser.get_data():
logger.warning("AD auth backend failed when reading data for"
" %s. No Group information available." % username)
user = None
continue
else:
do_update = False
for attr in ['first_name',
'last_name',
'email',
'is_superuser']:
if not getattr(user, attr) == getattr(aduser, attr):
setattr(user, attr, getattr(aduser, attr))
do_update = True
if do_update:
user.save()
if not user.is_superuser:
for mail1 in aduser.email_addresses:
try:
address = UserAddresses.objects.get(user=user,
address=mail1)
except UserAddresses.DoesNotExist:
address = UserAddresses(user=user,
address=mail1)
address.save()
logger.info("AD auth backend check passed for %s" % username)
if user:
try:
profile = user.get_profile()
except UserProfile.DoesNotExist:
account_type = 3
if user.is_superuser:
account_type = 1
profile = UserProfile(user=user,
account_type=account_type)
profile.save()
return user
return None
0
Example 14
Project: davvy Source File: wellknown.py
@csrf_exempt
def dispatch(self, request, *args, **kwargs):
user = None
if 'REMOTE_USER' in request.META:
user = User.objects.get(username=request.META['REMOTE_USER'])
elif 'HTTP_AUTHORIZATION' in request.META:
auth = request.META['HTTP_AUTHORIZATION'].split()
if len(auth) == 2:
if auth[0].lower() == "basic":
uname, passwd = base64.b64decode(auth[1]).split(':')
user = authenticate(username=uname, password=passwd)
if (user and user.is_active):
login(request, user)
request.user = user
# choose the correct current-user-principal handler (calendars/addressbooks)
if self.root == "calendars":
from davvy.calendar import prop_dav_calendar_home_set as prop_dav_resource_home_set
elif self.root == "addressbook001":
from davvy.addressbook import prop_dav_addressbook_home_set as prop_dav_resource_home_set
else:
from davvy.base import prop_dav_current_user_principal as prop_dav_resource_home_set
old_cup_prop = None
if prop_dav_resource_home_set:
# let's backup current-user-principal handler
cup = '{DAV:}current-user-principal'
old_cup_prop = davvy.retrieve_prop(
cup
)
# let's modify it
davvy.register_prop(
cup,
prop_dav_resource_home_set,
davvy.exceptions.Forbidden)
try:
response = super(WebDAV, self).dispatch(
request, user.username, "/", *args, **kwargs
)
dav_base = ['1']
dav_base += getattr(settings, 'DAVVY_EXTENSIONS', [])
response['Dav'] = ','.join(dav_base + self.dav_extensions)
except Exception as e:
logger.debug(e)
code, phrase = e.status.split(' ', 1)
response = HttpResponse(phrase, content_type='text/plain')
response.status_code = int(code)
response.reason_phrase = phrase
finally:
if old_cup_prop:
# restore current-user-principal
davvy.register_prop(
*old_cup_prop
)
else:
response = HttpResponse('Unathorized', content_type='text/plain')
response.status_code = 401
response['WWW-Authenticate'] = 'Basic realm="davvy"'
return response
0
Example 15
Project: reviewboard Source File: tests.py
@add_fixtures(['test_users'])
def test_show_archived(self):
"""Testing dashboard view with show-archived"""
visible = self.create_review_request(summary='Test 1', publish=True)
archived = self.create_review_request(summary='Test 2', publish=True)
muted = self.create_review_request(summary='Test 3', publish=True)
self.client.login(username='doc', password='doc')
user = User.objects.get(username='doc')
visible.target_people.add(user)
archived.target_people.add(user)
muted.target_people.add(user)
self.client.get(visible.get_absolute_url())
self.client.get(archived.get_absolute_url())
self.client.get(muted.get_absolute_url())
visit = ReviewRequestVisit.objects.get(user__username=user,
review_request=archived.id)
visit.visibility = ReviewRequestVisit.ARCHIVED
visit.save()
visit = ReviewRequestVisit.objects.get(user__username=user,
review_request=muted.id)
visit.visibility = ReviewRequestVisit.MUTED
visit.save()
response = self.client.get('/dashboard/', {'show-archived': '1'})
self.assertEqual(response.status_code, 200)
datagrid = self._get_context_var(response, 'datagrid')
self.assertTrue(datagrid)
self.assertEqual(len(datagrid.rows), 3)
self.assertEqual(datagrid.rows[0]['object'].summary, 'Test 3')
self.assertEqual(datagrid.rows[1]['object'].summary, 'Test 2')
self.assertEqual(datagrid.rows[2]['object'].summary, 'Test 1')
response = self.client.get('/dashboard/', {'show-archived': '0'})
self.assertEqual(response.status_code, 200)
datagrid = self._get_context_var(response, 'datagrid')
self.assertTrue(datagrid)
self.assertEqual(len(datagrid.rows), 1)
self.assertEqual(datagrid.rows[0]['object'].summary, 'Test 1')
self.client.logout()
self.client.login(username='grumpy', password='grumpy')
user = User.objects.get(username='grumpy')
visible.target_people.add(user)
archived.target_people.add(user)
muted.target_people.add(user)
self.client.get(visible.get_absolute_url())
self.client.get(archived.get_absolute_url())
self.client.get(muted.get_absolute_url())
response = self.client.get('/dashboard/', {'show-archived': '1'})
self.assertEqual(response.status_code, 200)
datagrid = self._get_context_var(response, 'datagrid')
self.assertTrue(datagrid)
self.assertEqual(len(datagrid.rows), 3)
self.assertEqual(datagrid.rows[0]['object'].summary, 'Test 3')
self.assertEqual(datagrid.rows[1]['object'].summary, 'Test 2')
self.assertEqual(datagrid.rows[2]['object'].summary, 'Test 1')
response = self.client.get('/dashboard/', {'show-archived': '0'})
self.assertEqual(response.status_code, 200)
datagrid = self._get_context_var(response, 'datagrid')
self.assertTrue(datagrid)
self.assertEqual(len(datagrid.rows), 3)
self.assertEqual(datagrid.rows[0]['object'].summary, 'Test 3')
self.assertEqual(datagrid.rows[1]['object'].summary, 'Test 2')
self.assertEqual(datagrid.rows[2]['object'].summary, 'Test 1')
0
Example 16
Project: foodnetwork Source File: engine.py
def send_all():
lock = FileLock("send_notices")
logging.debug("acquiring lock...")
try:
lock.acquire(LOCK_WAIT_TIMEOUT)
except AlreadyLocked:
logging.debug("lock already in place. quitting.")
return
except LockTimeout:
logging.debug("waiting for the lock timed out. quitting.")
return
logging.debug("acquired.")
batches, sent = 0, 0
start_time = time.time()
try:
# nesting the try statement to be Python 2.4
try:
for queued_batch in NoticeQueueBatch.objects.all():
notices = pickle.loads(str(queued_batch.pickled_data).decode("base64"))
for user, label, extra_context, on_site in notices:
user = User.objects.get(pk=user)
logging.info("emitting notice to %s" % user)
# call this once per user to be atomic and allow for logging to
# accurately show how long each takes.
notification.send_now([user], label, extra_context, on_site)
sent += 1
queued_batch.delete()
batches += 1
except:
# get the exception
exc_class, e, t = sys.exc_info()
# email people
current_site = Site.objects.get_current()
subject = "[%s emit_notices] %r" % (current_site.name, e)
message = "%s" % ("\n".join(traceback.format_exception(*sys.exc_info())),)
mail_admins(subject, message, fail_silently=True)
# log it as critical
logging.critical("an exception occurred: %r" % e)
finally:
logging.debug("releasing lock...")
lock.release()
logging.debug("released.")
logging.info("")
logging.info("%s batches, %s sent" % (batches, sent,))
logging.info("done in %.2f seconds" % (time.time() - start_time))
0
Example 17
def handle(self, *args, **options):
if len(args) != 2:
raise CommandError(_("Expected two arguments"))
try:
contest = Contest.objects.get(id=args[0])
except Contest.DoesNotExist:
raise CommandError(_("Contest %s does not exist") % args[0])
rcontroller = contest.controller.registration_controller()
print rcontroller
if not issubclass(getattr(rcontroller, 'participant_admin', None),
OnsiteRegistrationParticipantAdmin):
raise CommandError(_("Wrong type of contest"))
arg = args[1]
if arg.startswith('http://') or arg.startswith('https://'):
self.stdout.write(_("Fetching %s...\n") % (arg,))
stream = urllib2.urlopen(arg)
else:
if not os.path.exists(arg):
raise CommandError(_("File not found: ") + arg)
stream = open(arg, 'r')
reader = csv.reader(stream)
header = reader.next()
if header != self.COLUMNS:
raise CommandError(_("Missing header or invalid columns: "
"%(header)s\nExpected: %(expected)s") % {
'header': ', '.join(header),
'expected': ', '.join(self.COLUMNS)})
with transaction.atomic():
ok = True
all_count = 0
for row in reader:
all_count += 1
for i, _column in enumerate(self.COLUMNS):
row[i] = row[i].decode('utf8')
try:
user = User.objects.get(username=row[1])
region = Region.objects.get(short_name=row[2],
contest=contest)
participant, created = Participant.objects \
.get_or_create(contest=contest, user=user)
reg = OnsiteRegistration(participant=participant,
number=row[0], local_number=row[3], region=region)
reg.full_clean()
reg.save()
except User.DoesNotExist:
self.stdout.write(_("Error for user=%(user)s: user does"
" not exist\n") % {'user': row[1]})
ok = False
except Region.DoesNotExist:
self.stdout.write(_(
"Error for user=%(user)s: region %(region)s does"
" not exist\n") % {'user': row[1], 'region': row[2]})
ok = False
except DatabaseError, e:
# This assumes that we'll get the message in this
# encoding. It is not perfect, but much better than
# ascii.
message = e.message.decode('utf-8')
self.stdout.write(_(
"DB Error for user=%(user)s: %(message)s\n")
% {'user': row[1], 'message': message})
ok = False
except ValidationError, e:
for k, v in e.message_dict.iteritems():
for message in v:
if k == '__all__':
self.stdout.write(_(
"Error for user=%(user)s: %(message)s\n")
% {'user': row[1], 'message': message})
else:
self.stdout.write(
_("Error for user=%(user)s, "
"field %(field)s: %(message)s\n")
% {'user': row[1], 'field': k,
'message': message})
ok = False
if ok:
self.stdout.write(_("Processed %d entries") % (all_count))
else:
raise CommandError(_("There were some errors. Database not "
"changed.\n"))
0
Example 18
Project: btb Source File: import_test_data.py
def load_test_data():
data_file = os.path.join(settings.MEDIA_ROOT, "test", "test_data.yaml")
uploader = User.objects.get(username='uploader')
commenter = User.objects.create(username="commenter")
with open(data_file) as fh:
data = yaml.safe_load(fh)
orgs = {}
print "Setting site..."
site = Site.objects.get_current()
site.domain = data['site']['domain']
site.name = data['site']['name']
site.save()
print "Adding admins..."
for admin_data in data['admins']:
user, created = User.objects.get_or_create(
username=admin_data['username'],
is_superuser=True,
is_staff=True,
)
user.set_password(admin_data['password'])
user.save()
print "Adding orgs..."
for org_data in data['orgs']:
org, created = Organization.objects.get_or_create(
name=org_data['name'],
personal_contact=org_data['personal_contact'],
slug=slugify(org_data['name']),
public=org_data['public'],
mailing_address=org_data['mailing_address'],
about=org_data.get('about', ''),
footer=org_data.get('footer', ''),
)
orgs[org_data['name']] = org
for mod_data in org_data['moderators']:
u, created = User.objects.get_or_create(
username=mod_data['username']
)
u.set_password(mod_data['password'])
u.save()
org.moderators.add(u)
Group.objects.get(name='moderators').user_set.add(u)
for org_data in data['orgs']:
mail_handled_by = org_data.get('outgoing_mail_handled_by', None)
if mail_handled_by:
org = Organization.objects.get(name=org_data['name'])
mailer = Organization.objects.get(name=mail_handled_by)
org.outgoing_mail_handled_by = mailer
org.save()
print "Building pdfs and users..."
for user_data in data['users']:
user, created = User.objects.get_or_create(
username=slugify(user_data['name'])
)
if user_data.get('managed', False):
random_mailing_address = "\n".join([
# Prisoner number
"#%s" % "".join(random.choice(string.digits) for a in range(8)),
# Street
"%s Cherry Tree Lane" % "".join(
random.choice(string.digits) for a in range(3)),
# City, state, zip
"City Name, %s %s" % (
random.choice(US_STATES)[0],
"".join(random.choice(string.digits) for a in range(5)),
)
])
else:
random_mailing_address = ""
user.profile.display_name = user_data['name']
user.profile.mailing_address = random_mailing_address
user.profile.blogger = user_data.get('blogger', False)
user.profile.managed = user_data.get('managed', False)
user.profile.consent_form_received = user_data.get('consent_form_received', False)
user.profile.blog_name = user_data.get('blog_name', None) or ''
user.profile.save()
for org_name in user_data['orgs']:
orgs[org_name].members.add(user)
for corresp in user_data['correspondence']:
direction, content = corresp.items()[0]
if direction == "received":
# Build Scan
pdf = build_pdf(content['parts'], user.profile)
path = tasks.move_scan_file(filename=pdf)
scan = Scan.objects.create(
uploader=uploader,
org=orgs[org_name],
author=user,
pdf=os.path.relpath(path, settings.MEDIA_ROOT),
under_construction=True,
processing_complete=True,
created=content['date'])
# execute synchronously
tasks.split_scan(scan_id=scan.pk)
# Build Docuements
page_count = 1 # ignore envelope
for part in content['parts']:
page_count += part["pages"]
if part["type"] == "ignore":
continue
docuement = Docuement.objects.create(
scan=scan,
editor=uploader,
author=user,
type=part["type"],
date_written=content["date"],
created=content["date"],
title=part.get("title", None) or "",
)
for i, page_index in enumerate(
range(page_count - part["pages"], page_count)):
scanpage = scan.scanpage_set.get(order=page_index)
DocuementPage.objects.create(
docuement=docuement,
scan_page=scanpage,
order=i)
# execute synchronously
if part["type"] in ("profile", "post"):
docuement.status = "published"
else:
docuement.status = "unpublishable"
docuement.highlight_transform = '{"docuement_page_id": %s, "crop": [44.5, 58.66667175292969, 582.5, 288.6666717529297]}' % docuement.docuementpage_set.all()[0].pk
docuement.save()
tasks.update_docuement_images(docuement.pk)
for comment in part.get('comments', []):
Comment.objects.create(
user=commenter,
comment="Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus. Sed sit amet ipsum mauris. Maecenas congue ligula ac quam viverra nec consectetur ante hendrerit. Donec et mollis dolor. Praesent et diam eget libero egestas mattis sit amet vitae augue. Nam tincidunt congue enim, ut porta lorem lacinia consectetur. Donec ut libero sed arcu vehicula ultricies a non tortor. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean ut gravida lorem. Ut turpis felis, pulvinar a semper sed, adipiscing id dolor. Pellentesque auctor nisi id magna consequat sagittis.",
docuement=docuement,
created=comment['date'],
)
# Finish received scans before parsing letters, to ensure comments/etc
# are there yet.
for corresp in user_data['correspondence']:
direction, content = corresp.items()[0]
if direction == "sent":
letter = Letter(type=content['type'],
auto_generated=True,
sender=uploader,
created=content['date'],
sent=content['date'],
recipient=user,
org=Organization.objects.get(name=user_data['orgs'][0]))
if content['type'] == "comments":
letter.save()
comments = Comment.objects.unmailed().filter(
docuement__author=user,
created__lt=content['date']
)
for comment in comments:
letter.comments.add(comment)
elif content['type'] == "letter":
letter.body = content['body']
letter.save()
0
Example 19
Project: pycon Source File: tests.py
def test_reviewing(self):
guidos_proposal = ProposalBase.objects.all()[0]
with self.login("guido", "pythonisawesome"):
response = self.post("review_review", pk=guidos_proposal.pk, data={
"vote": "+1",
})
# It redirects, but...
self.assertEqual(response.status_code, 302)
# ... no vote recorded
self.assertEqual(guidos_proposal.reviews.count(), 0)
larry = User.objects.get(username="larryw")
# Larry is a trustworthy guy, he's a reviewer.
larry.groups.add(Group.objects.get(name="reviewers"))
with self.login("larryw", "linenoisehere"):
response = self.post("review_review", pk=guidos_proposal.pk, data={
"vote": "+0",
"text": "Looks like a decent proposal, and Guido is a smart guy",
})
self.assertEqual(response.status_code, 302)
self.assertEqual(guidos_proposal.reviews.count(), 1)
self.assertEqual(ReviewAssignment.objects.count(), 1)
assignment = ReviewAssignment.objects.get()
self.assertEqual(assignment.proposal, guidos_proposal)
self.assertEqual(assignment.origin, ReviewAssignment.OPT_IN)
self.assertEqual(guidos_proposal.comments.count(), 1)
comment = guidos_proposal.comments.get()
self.assertFalse(comment.public)
response = self.post("review_review", pk=guidos_proposal.pk, data={
"vote": "+1",
"text": "Actually Perl is dead, we really need a talk on the future",
})
self.assertEqual(guidos_proposal.reviews.count(), 2)
self.assertEqual(ReviewAssignment.objects.count(), 1)
assignment = ReviewAssignment.objects.get()
self.assertEqual(assignment.review, Review.objects.order_by("-id")[0])
self.assertEqual(guidos_proposal.comments.count(), 2)
# Larry's a big fan...
response = self.post("review_review", pk=guidos_proposal.pk, data={
"vote": "+20",
})
self.assertEqual(guidos_proposal.reviews.count(), 2)
0
Example 20
def save(self, request):
message = self.cleaned_data['message']
send_to = self.cleaned_data['send_to']
upload_to = []
calendar_owners = []
dest = []
ao = get_allowed_objects(request.user, Community, ['manage', 'member'])
if send_to:
send_to = send_to.split(',')
for item in send_to:
item = item.split('-')
if item[0] == 'u': # user
user = User.objects.get(pk=item[1])
# if user recipient member of any current user communities
ao_member_user = get_allowed_objects(
user, Community, ['member', 'manage'])
inter = [k for k in ao if k in ao_member_user]
if len(inter):
dest.append(user)
calendar_owners.append(user)
upload_to.append(u"U%s" % user.pk)
else:
community = Community.objects.get(pk=item[1])
if community.pk in ao:
dest.append(community)
calendar_owners.append(community)
upload_to.append(u"C%s" % community.pk)
users_emails = []
if len(dest):
m = MessageCommunity(message=message)
m.owner = m.modifier = request.user
m.save()
for k in dest:
if isinstance(k, User):
m.users.add(k)
users_emails.append(k.email)
else:
m.communities.add(k)
if k.email_notification:
users = list(chain(get_acl_by_object(
k, 'member'), get_acl_by_object(k, 'manage')))
users_emails.extend([u.email for u in users])
else:
return None
files = request.FILES.getlist("attachments")
if len(upload_to) and len(files):
try:
path_library = get_upload_library()
path = os.path.join(get_upload_communities(), "%s" % m.pk)
if not os.path.isdir(path):
os.makedirs(path)
for f in request.FILES.getlist("attachments"):
s = os.path.splitext(f.name)
fname = slugify(s[0])
fext = s[1]
destination = open(u"%s/%s" % (
path, u"%s%s" % (fname, fext)), 'wb+')
for chunk in f.chunks():
destination.write(chunk)
destination.close()
for d in upload_to:
destpath = os.path.join(path_library, "%s" % d)
if not os.path.isdir(destpath):
os.makedirs(destpath)
try:
libfile = ZornaFile(
owner=request.user, modifier=request.user)
libfile.save()
fsrc = u"%s/%s/%s,%s%s" % (
path_library, d, str(libfile.pk), fname, fext)
shutil.copy2(u"%s/%s" % (
path, u"%s%s" % (fname, fext)), fsrc)
except Exception as e:
print(e)
except Exception as e:
pass
# send email notification
if len(users_emails):
users_emails = list(set(users_emails))
if users_emails:
email = ZornaEmail()
url = request.build_absolute_uri(reverse(
'communities_home_page', args=[])) + '?all_msg=message&message_id=%s' % m.pk
ec = {"message": m, 'url': url, 'user': request.user}
body_text = render_to_string(
'communities/email_notification_text.html', ec)
body_html = render_to_string(
'communities/email_notification_html.html', ec)
subject = _(
u'A new message has been posted in communities')
step = getattr(settings, "ZORNA_MAIL_MAXPERPACKET", 25)
for n in range(0, len(users_emails) / step + 1):
email.append(subject, body_text, body_html, settings.DEFAULT_FROM_EMAIL, bcc=users_emails[
n * step:(n + 1) * step])
email.send()
return m
return None
0
Example 21
Project: classic.rhizome.org Source File: views.py
def orgsub_invite_welcome(request):
'''
users can be invited to join via email through the ManageMemberForm found
on the orgsub admin page in profiles. this view handles those coming from
the link provided in that email
'''
context = RequestContext(request)
user_email = request.GET.get("email")
registration_code = request.GET.get("registration_code")
breadcrumb = (("Welcome",None),)
notice = None
try:
orgsub_prospective_member = ProspectiveUser.objects.get(email=user_email)
except:
orgsub_prospective_member = False
if orgsub_prospective_member and registration_code == orgsub_prospective_member.registration_code:
orgsub_prospective_member.accepted = 1
try:
check_for_user = User.objects.get(email = user_email)
except User.DoesNotExist:
check_for_user = None
if check_for_user:
orgsub_prospective_member.user = check_for_user
orgsub_prospective_member.save()
#if user exists, check to see if user is member
if check_for_user:
try:
check_for_membership = RhizomeMembership.objects.get(user = check_for_user)
except RhizomeMembership.DoesNotExist:
check_for_membership = False
check_for_user.registration_code = orgsub_prospective_member.registration_code
check_for_user.is_active = 1
check_for_user.save()
# if user is member, update existing membership with org_sub that sent invitation
if check_for_membership:
check_for_membership.org_sub = orgsub_prospective_member.org_sub
check_for_membership.update_membership(None, check_for_membership.org_sub.expiration_date)
check_for_membership.save()
# if user is not member, create membership, add org_sub info, and update
else:
new_member_account = RhizomeMembership(user = check_for_user)
new_member_account.org_sub = orgsub_prospective_member.org_sub
org_sub_expire_date = orgsub_prospective_member.org_sub.expiration_date
new_member_account.update_membership(None,org_sub_expire_date)
new_member_account.save()
#if user doesn't exist, create both user account and membership
else:
username = user_email.split('@')[0]
try:
User.objects.get(username=username)
username = username + str(random.randint(0,1000000))
except User.DoesNotExist:
pass
password = User.objects.make_random_password(15)
new_user_account = RhizomeUser(username = username,
email = orgsub_prospective_member.email)
new_user_account.set_password(password)
new_user_account.registration_code = orgsub_prospective_member.registration_code
new_user_account.save()
welcome_email = EmailMessage()
welcome_email.subject = "Welcome to Rhizome!"
welcome_email.body = """
Welcome to Rhizome!
Here's your username and temporary password.
%s / %s
Go here to update your information: http://rhizome.org/profiles/edit/
Thanks,
--The Rhizome Team
""" % (new_user_account.username, password)
welcome_email.to = [user_email]
welcome_email.bcc = [admin[1] for admin in settings.ADMINS]
welcome_email.send(fail_silently=False)
new_member_account = RhizomeMembership(user = new_user_account)
new_member_account.org_sub = orgsub_prospective_member.org_sub
new_member_account.update_membership(None, new_member_account.org_sub.expiration_date)
new_member_account.save()
user_account = User.objects.get(email = user_email)
membership = RhizomeMembership.objects.get(user = user_account)
else:
user_account = None
membership = None
notice = "Either this account has already registered or your \
registration verification number is invalid."
d = {
"user_account":user_account,
"membership":membership,
"breadcrumb":breadcrumb,
"notice":notice
}
return render_to_response( "accounts/welcome_orgsub.html", d, context)
0
Example 22
def get_local_user(self, ldap_username, info):
username = ldap_username.lower()
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
# Make new one
user = User(username=username)
user.set_unusable_password()
# refresh memberships
members_of = []
for group in info.get('memberOf', []):
members_of.append(group.lower().split(","))
# Set first_name or last_name or email ..
for key, value in self.ldap_settings.USER_ATTR_MAP.items():
if value in info:
setattr(user, key, info[value][0])
def check_for_membership(members_of, required_groups_options):
""" Check for membership in given groups,
Parameter:
required_groups_options - can be string or list of strings. Each entry must
be comma-separeted groupnames """
if isinstance(required_groups_options, six.string_types):
required_groups_options = [required_groups_options]
for required_groups in required_groups_options:
required_groups = required_groups.lower().split(",")
# check for all members of groups
for member_of_group in members_of:
# check that all required groups are in this membership
requirement_fullfilled = all(
(required_group in member_of_group) for required_group in required_groups)
if requirement_fullfilled:
return True
return False
# set is_superuser etc
for wanted_property, requirements in self.ldap_settings.USER_FLAGS_BY_GROUP.items():
has_property = check_for_membership(members_of, requirements)
setattr(user, wanted_property, has_property)
# We need to do save before we can use the groups (for m2m binding)
user.save()
# user.groups.add( Group.objects.get(name = "ODAdmin"))
for wanted_group, requirements in self.ldap_settings.USER_GROUPS_BY_GROUP.items():
if check_for_membership(members_of, requirements):
user.groups.add(Group.objects.get(name=wanted_group))
else:
user.groups.remove(Group.objects.get(name=wanted_group))
user.save()
return user
0
Example 23
def browser(self):
self.driver.set_window_size(1024, 2000)
# view the homepage
self.fetch_page()
# go directly to our signup
self.fetch_page(reverse('orgs.org_signup'))
# create account
self.keys('email', '[email protected]')
self.keys('password', 'SuperSafe1')
self.keys('first_name', 'Joe')
self.keys('last_name', 'Blow')
self.click('#form-one-submit')
self.keys('name', 'Temba')
self.click('#form-two-submit')
# set up our channel for claiming
anon = User.objects.get(username=settings.ANONYMOUS_USER_NAME)
channel = Channel.create(None, anon, 'RW', 'A', name="Test Channel", address="0785551212",
claim_code='AAABBBCCC', secret="12345", gcm_id="123")
# and claim it
self.fetch_page(reverse('channels.channel_claim_android'))
self.keys('#id_claim_code', 'AAABBBCCC')
self.keys('#id_phone_number', '0785551212')
self.submit('.claim-form')
# get our freshly claimed channel
channel = Channel.objects.get(pk=channel.pk)
# now go to the contacts page
self.click('#menu-right .icon-contact')
self.click('#id_import_contacts')
# upload some contacts
directory = os.path.dirname(os.path.realpath(__file__))
self.keys('#csv_file', '%s/../media/test_imports/sample_contacts.xls' % directory)
self.submit('.smartmin-form')
# make sure they are there
self.click('#menu-right .icon-contact')
self.assertInElements('.value-phone', '+250788382382')
self.assertInElements('.value-text', 'Eric Newcomer')
self.assertInElements('.value-text', 'Sample Contacts')
0
Example 24
@catch_and_return(ObjectDoesNotExist, rc.NOT_HERE)
@catch_and_return(KeyError, rc.BAD_REQUEST)
@transaction.commit_on_success
def update(self, request, username):
def clean_date(date):
"""Set tzinfo=None because some DB engines do not accept
timezone-aware dates. As long as all dates in the database
are UTC, this is not a problem."""
return parser.parse(date).astimezone(pytz.utc).replace(tzinfo=None)
author = User.objects.get(username=username)
if request.user != author:
return rc.FORBIDDEN
update = json.loads(request.raw_post_data)
changes = update['note-changes']
current_sync_rev = author.get_profile().latest_sync_rev
new_sync_rev = current_sync_rev + 1
if update.has_key('latest-sync-revision'):
new_sync_rev = update['latest-sync-revision']
if new_sync_rev != current_sync_rev + 1:
# TODO: Return a more useful error response?
return rc.BAD_REQUEST
for c in changes:
note, created = Note.objects.get_or_create(author=author,
guid=c['guid'])
if c.has_key('command') and c['command'] == 'delete':
note.delete()
continue
if c.has_key('title'): note.title = c['title']
if c.has_key('note-content'): note.content = c['note-content']
if c.has_key('note-content-version'): note.content_version = c['note-content-version']
if c.has_key('last-change-date'): note.user_modified = clean_date(c['last-change-date'])
if c.has_key('last-metadata-change-date'):
note.modified = clean_date(c['last-metadata-change-date'])
else:
note.modified = datetime.utcnow()
if c.has_key('create-date'): note.created = clean_date(c['create-date'])
if c.has_key('open-on-startup'): note.open_on_startup = (c['open-on-startup'] == True)
if c.has_key('pinned'): note.pinned = (c['pinned'] == True)
if c.has_key('tags'):
note.tags.clear()
for tag_name in c['tags']:
tag, created = NoteTag.objects.get_or_create(author=author,
name=tag_name)
note.tags.add(tag)
note.last_sync_rev = new_sync_rev
note.save()
profile = author.get_profile()
if len(changes) > 0:
profile.latest_sync_rev = new_sync_rev
profile.save()
return {
'latest-sync-revision': profile.latest_sync_rev,
'notes': [simple_describe_note(n) for n in Note.objects.filter(author=author)]
}
0
Example 25
def add(request, form_class=DonationForm, template_name="donations/add.html"):
use_captcha = get_setting('site', 'global', 'captcha')
if request.method == "POST":
form = form_class(request.POST, user=request.user)
captcha_form = CaptchaForm(request.POST)
if not use_captcha:
del captcha_form.fields['captcha']
if form.is_valid() and captcha_form.is_valid():
donation = form.save(commit=False)
donation.payment_method = donation.payment_method.lower()
# we might need to create a user record if not exist
if request.user.is_authenticated():
user = request.user
else:
try:
user = User.objects.get(email=donation.email)
except:
user = request.user
if not user.is_anonymous():
donation.user = user
donation.creator = user
donation.creator_username = user.username
else:
# this is anonymous user donating and we didn't find their user record in the system,
# so add a new user
user = User()
user.first_name = donation.first_name
user.last_name = donation.last_name
user.email = donation.email
user.username = get_unique_username(user)
user.set_password(User.objects.make_random_password(length=8))
user.is_active = 0
user.save()
profile_kwarg = {'user':user,
'company':donation.company,
'address':donation.address,
'address2':donation.address2,
'city':donation.city,
'state':donation.state,
'zipcode':donation.zip_code,
'country':donation.country,
'phone':donation.phone}
if request.user.is_anonymous():
profile_kwarg['creator'] = user
profile_kwarg['creator_username'] = user.username
profile_kwarg['owner'] = user
profile_kwarg['owner_username'] = user.username
else:
profile_kwarg['creator'] = request.user
profile_kwarg['creator_username'] = request.user.username
profile_kwarg['owner'] = request.user
profile_kwarg['owner_username'] = request.user.username
profile = Profile.objects.create(**profile_kwarg)
profile.save()
donation.save(user)
# create invoice
invoice = donation_inv_add(user, donation)
# updated the invoice_id for mp, so save again
donation.save(user)
if request.user.profile.is_superuser:
if donation.payment_method in ['paid - check', 'paid - cc']:
# the admin accepted payment - mark the invoice paid
invoice.tender(request.user)
invoice.make_payment(request.user, donation.donation_amount)
# send notification to administrators
# get admin notice recipients
if not donation.payment_method.lower() in ['cc', 'credit card', 'paypal']:
# email to admin (if payment type is credit card email is not sent until payment confirmed)
recipients = get_notice_recipients('module', 'donations', 'donationsrecipients')
if recipients:
if notification:
extra_context = {
'donation': donation,
'invoice': invoice,
'request': request,
}
notification.send_emails(recipients,'donation_added', extra_context)
# email to user
email_receipt = form.cleaned_data['email_receipt']
if email_receipt:
donation_email_user(request, donation, invoice)
EventLog.objects.log(instance=donation)
# redirect to online payment or confirmation page
if donation.payment_method.lower() in ['cc', 'credit card', 'paypal']:
return HttpResponseRedirect(reverse('payment.pay_online', args=[invoice.id, invoice.guid]))
else:
return HttpResponseRedirect(reverse('donation.add_confirm', args=[donation.id]))
else:
form = form_class(user=request.user)
captcha_form = CaptchaForm()
currency_symbol = get_setting("site", "global", "currencysymbol")
if not currency_symbol: currency_symbol = "$"
return render_to_response(template_name, {
'form':form,
'captcha_form' : captcha_form,
'use_captcha' : use_captcha,
'currency_symbol': currency_symbol},
context_instance=RequestContext(request))
0
Example 26
def save(self, user):
"""
Writes and returns a Ticket() object
"""
q = Queue.objects.get(id=int(self.cleaned_data['queue']))
t = Ticket( title = self.cleaned_data['title'],
submitter_email = self.cleaned_data['submitter_email'],
created = timezone.now(),
status = Ticket.OPEN_STATUS,
queue = q,
description = self.cleaned_data['body'],
priority = self.cleaned_data['priority'],
due_date = self.cleaned_data['due_date'],
)
if self.cleaned_data['assigned_to']:
try:
u = User.objects.get(id=self.cleaned_data['assigned_to'])
t.assigned_to = u
except User.DoesNotExist:
t.assigned_to = None
t.save()
for field, value in self.cleaned_data.items():
if field.startswith('custom_'):
field_name = field.replace('custom_', '', 1)
customfield = CustomField.objects.get(name=field_name)
cfv = TicketCustomFieldValue(ticket=t,
field=customfield,
value=value)
cfv.save()
f = FollowUp( ticket = t,
title = _('Ticket Opened'),
date = timezone.now(),
public = True,
comment = self.cleaned_data['body'],
user = user,
)
if self.cleaned_data['assigned_to']:
f.title = _('Ticket Opened & Assigned to %(name)s') % {
'name': t.get_assigned_to
}
f.save()
files = []
if self.cleaned_data['attachment']:
import mimetypes
file = self.cleaned_data['attachment']
filename = file.name.replace(' ', '_')
a = Attachment(
followup=f,
filename=filename,
mime_type=mimetypes.guess_type(filename)[0] or 'application/octet-stream',
size=file.size,
)
a.file.save(file.name, file, save=False)
a.save()
if file.size < getattr(settings, 'MAX_EMAIL_ATTACHMENT_SIZE', 512000):
# Only files smaller than 512kb (or as defined in
# settings.MAX_EMAIL_ATTACHMENT_SIZE) are sent via email.
try:
files.append([a.filename, a.file])
except NotImplementedError:
pass
context = safe_template_context(t)
context['comment'] = f.comment
messages_sent_to = []
if t.submitter_email:
send_templated_mail(
'newticket_submitter',
context,
recipients=t.submitter_email,
sender=q.from_address,
fail_silently=True,
files=files,
)
messages_sent_to.append(t.submitter_email)
if t.assigned_to and t.assigned_to != user and t.assigned_to.usersettings.settings.get('email_on_ticket_assign', False) and t.assigned_to.email and t.assigned_to.email not in messages_sent_to:
send_templated_mail(
'assigned_owner',
context,
recipients=t.assigned_to.email,
sender=q.from_address,
fail_silently=True,
files=files,
)
messages_sent_to.append(t.assigned_to.email)
if q.new_ticket_cc and q.new_ticket_cc not in messages_sent_to:
send_templated_mail(
'newticket_cc',
context,
recipients=q.new_ticket_cc,
sender=q.from_address,
fail_silently=True,
files=files,
)
messages_sent_to.append(q.new_ticket_cc)
if q.updated_ticket_cc and q.updated_ticket_cc != q.new_ticket_cc and q.updated_ticket_cc not in messages_sent_to:
send_templated_mail(
'newticket_cc',
context,
recipients=q.updated_ticket_cc,
sender=q.from_address,
fail_silently=True,
files=files,
)
return t
0
Example 27
def import_comments(self, post_id, slug, *args, **options):
try:
mysite = Site.objects.get_current()
self.site_id = mysite.id
except Site.DoesNotExist:
print('site does not exist')
return
comments = self.get_posts_data(
self.url, post_id, get_comments=True)
imported_comments = []
for comment in comments:
try:
blog_post = BlogPage.objects.get(slug=slug)
blog_post_type = ContentType.objects.get_for_model(blog_post)
except BlogPage.DoesNotExist:
print('cannot find this blog post')
continue
comment_text = self.convert_html_entities(comment.get('content'))
date = datetime.strptime(comment.get('date'), '%Y-%m-%dT%H:%M:%S')
status = comment.get('status')
if status != 'approved':
continue
comment_author = comment.get('author')
new_comment = self.create_comment(
blog_post_type, blog_post.pk, comment_text, date)
new_comment.wordpress_id = comment.get('ID')
new_comment.parent_wordpress_id = comment.get('parent')
if type(comment_author) is int:
pass
else:
if 'username' in comment_author:
user_name = comment['author']['username']
user_url = comment['author']['URL']
try:
current_user = User.objects.get(username=user_name)
new_comment.user = current_user
except User.DoesNotExist:
pass
new_comment.user_name = user_name
new_comment.user_url = user_url
new_comment.save()
imported_comments.append(new_comment)
# Now assign parent comments
for comment in imported_comments:
if comment.parent_wordpress_id != "0":
for sub_comment in imported_comments:
if sub_comment.wordpress_id == comment.parent_wordpress_id:
comment.parent_id = sub_comment.id
try:
comment._calculate_thread_data()
comment.save()
except MaxThreadLevelExceededException:
print("Warning, max thread level exceeded on {}"
.format(comment.id))
break
0
Example 28
def login_user(self, userid):
"""
Login as specified user, does not depend on auth backend (hopefully)
This is based on Client.login() with a small hack that does not
require the call to authenticate()
"""
if not 'django.contrib.sessions' in settings.INSTALLED_APPS:
raise AssertionError("Unable to login without django.contrib.sessions in INSTALLED_APPS")
try:
user = User.objects.get(username=userid)
except User.DoesNotExist:
user = User(username=userid, password='')
user.save()
user.backend = "%s.%s" % ("django.contrib.auth.backends",
"ModelBackend")
engine = import_module(settings.SESSION_ENGINE)
# Create a fake request to store login details.
request = HttpRequest()
#if self.session:
# request.session = self.session
#else:
request.session = engine.SessionStore()
login(request, user)
# Set the cookie to represent the session.
session_cookie = settings.SESSION_COOKIE_NAME
self.cookies[session_cookie] = request.session.session_key
cookie_data = {
'max-age': None,
'path': '/',
'domain': settings.SESSION_COOKIE_DOMAIN,
'secure': settings.SESSION_COOKIE_SECURE or None,
'expires': None,
}
self.cookies[session_cookie].update(cookie_data)
# Save the session values.
request.session.save()
0
Example 29
def read(self, request, project_slug=None, resource_slug=None, release_slug=None,
username=None, language_code=None, api_version=2,):
try:
if request.GET.has_key('limit'):
limit = request.GET['limit']
else:
limit = None
if username:
user = User.objects.get(username=username)
if request.user == user:
feeds = LogEntry.objects.filter(user=user,
content_type=ContentType.objects.get(model='project'))
else:
feeds = LogEntry.objects.filter(user=user,
content_type=ContentType.objects.get(model='project'),
project__private=False)
elif not project_slug:
private_slugs = list(
Project.objects.filter(private=True).values_list('slug', flat=True)
)
feeds = LogEntry.objects.filter(
content_type=ContentType.objects.get(model='project')
).exclude(
project__slug__in=private_slugs
)
for slug in private_slugs:
feeds = feeds.exclude(message__contains='/projects/p/%s/'%slug)
else:
project = Project.objects.get(slug=project_slug)
if not self._has_perm(request.user, project):
return rc.FORBIDDEN
if resource_slug:
resource = Resource.objects.get(slug=resource_slug,
project=project)
feeds = LogEntry.objects.by_object(resource)
elif language_code:
team = Team.objects.get(language__code=language_code,
project=project)
feeds = LogEntry.objects.by_object(team)
elif release_slug:
release = Release.objects.get(slug=release_slug,
project=project)
feeds = LogEntry.objects.by_object(release)
elif project_slug and request.path == reverse('project_actionlogs', args=[project_slug]):
feeds = LogEntry.objects.by_object(project)
else:
if request.path.find('resources/actionlog/') > 0:
feeds = LogEntry.objects.by_object(project).filter(
action_type__label__startswith='project_resource')
elif request.path.find('teams/actionlog/') > 0:
feeds = LogEntry.objects.by_object(project).filter(
action_type__label__startswith='project_team')
elif request.path.find('releases/actionlog/') > 0:
feeds = LogEntry.objects.by_object(project).filter(
action_type__label__startswith='project_release')
feeds = feeds.values('action_time', 'message', 'user__username')
if limit:
feeds = feeds[:limit]
return feeds
except Project.DoesNotExist, e:
logger.warning(unicode(e))
return rc.NOT_FOUND
except Resource.DoesNotExist, e:
logger.warning(unicode(e))
return rc.NOT_FOUND
except Team.DoesNotExist, e:
logger.warning(unicode(e))
return rc.NOT_FOUND
except Release.DoesNotExist, e:
logger.warning(unicode(e))
return rc.NOT_FOUND
except User.DoesNotExist, e:
logger.warning(unicode(e))
return rc.NOT_FOUND
0
Example 30
def get_or_create_user(self, username, request, ldapo, userdn):
"""Get an existing user, or create one if it does not exist."""
username = re.sub(INVALID_USERNAME_CHAR_REGEX, '', username).lower()
try:
user = User.objects.get(username=username)
return user
except User.DoesNotExist:
try:
import ldap
# Perform a BASE search since we already know the DN of
# the user
search_result = ldapo.search_s(userdn,
ldap.SCOPE_BASE)
user_info = search_result[0][1]
given_name_attr = getattr(
settings, 'LDAP_GIVEN_NAME_ATTRIBUTE', 'givenName')
first_name = user_info.get(given_name_attr, [username])[0]
surname_attr = getattr(
settings, 'LDAP_SURNAME_ATTRIBUTE', 'sn')
last_name = user_info.get(surname_attr, [''])[0]
# If a single ldap attribute is used to hold the full name of
# a user, split it into two parts. Where to split was a coin
# toss and I went with a left split for the first name and
# dumped the remainder into the last name field. The system
# admin can handle the corner cases.
try:
if settings.LDAP_FULL_NAME_ATTRIBUTE:
full_name = \
user_info[settings.LDAP_FULL_NAME_ATTRIBUTE][0]
full_name = full_name.decode('utf-8')
first_name, last_name = full_name.split(' ', 1)
except AttributeError:
pass
if settings.LDAP_EMAIL_DOMAIN:
email = '%s@%s' % (username, settings.LDAP_EMAIL_DOMAIN)
elif settings.LDAP_EMAIL_ATTRIBUTE:
try:
email = user_info[settings.LDAP_EMAIL_ATTRIBUTE][0]
except KeyError:
logging.error('LDAP: could not get e-mail address for '
'user %s using attribute %s',
username, settings.LDAP_EMAIL_ATTRIBUTE)
email = ''
else:
logging.warning(
'LDAP: e-mail for user %s is not specified',
username)
email = ''
user = User(username=username,
password='',
first_name=first_name,
last_name=last_name,
email=email)
user.is_staff = False
user.is_superuser = False
user.set_unusable_password()
user.save()
return user
except ImportError:
pass
except ldap.INVALID_CREDENTIALS:
# FIXME I'd really like to warn the user that their
# ANON_BIND_UID and ANON_BIND_PASSWD are wrong, but I don't
# know how
pass
except ldap.NO_SUCH_OBJECT as e:
logging.warning("LDAP error: %s settings.LDAP_BASE_DN: %s "
"User DN: %s",
e, settings.LDAP_BASE_DN, userdn,
exc_info=1)
except ldap.LDAPError as e:
logging.warning("LDAP error: %s", e, exc_info=1)
return None
0
Example 31
def test_put(self):
res = self.client['anonymous'].put(
self.url_project, data=simplejson.dumps({}),
content_type='application/json'
)
self.assertEquals(res.status_code, 401)
res = self.client['registered'].put(self.url_project)
self.assertEquals(res.status_code, 400)
res = self.client['registered'].put(
self.url_project[:-1] + "1/",
simplejson.dumps({'name': 'name of project'}),
content_type="application/json"
)
self.assertEquals(res.status_code, 404)
res = self.client['maintainer'].post(
self.url_projects, simplejson.dumps({
'slug': 'foo', 'name': 'Foo Project',
'source_language_code': 'en', 'description': 'desc',
}),
content_type='application/json'
)
self.assertEquals(res.status_code, 201)
res = self.client['registered'].put(
self.url_project, data=simplejson.dumps({}),
content_type='application/json'
)
self.assertEquals(res.status_code, 403)
user = User.objects.get(username='registered')
user.user_permissions.add(
Permission.objects.get(codename="change_project")
)
res = self.client['registered'].put(
self.url_project,
data=simplejson.dumps({'foo': 'foo'}),
content_type='application/json'
)
self.assertContains(res, "Field 'foo'", status_code=400)
res = self.client['registered'].put(
self.url_project, data=simplejson.dumps({}),
content_type='application/json'
)
self.assertEquals(res.status_code, 200)
name = 'New name for foo'
res = self.client['registered'].put(
self.url_project,
data=simplejson.dumps({'name': name}),
content_type='application/json'
)
self.assertEquals(res.status_code, 200)
p_foo = Project.objects.get(slug="foo")
self.assertEquals(p_foo.name, name)
res = self.client['registered'].put(
self.url_project,
data=simplejson.dumps({'outsource': "foo"}),
content_type='application/json'
)
self.assertContains(res, "Original and outsource projects are the same", status_code=400)
res = self.client['registered'].put(
self.url_project,
data=simplejson.dumps({'outsource': "bar"}),
content_type='application/json'
)
self.assertContains(res, "Project for outsource does not exist", status_code=400)
res = self.client['registered'].put(
self.url_project,
data=simplejson.dumps({'maintainers': 'none, not'}),
content_type='application/json'
)
self.assertContains(res, "User", status_code=400)
0
Example 32
Project: baruwa Source File: views.py
def filemanager(request, user_id, domain_id=None):
"handle file access requests from jquery"
def unauthorized():
"return unauthorized"
body = anyjson.dumps(dict(success=False, error=_("Not authorized.")))
return HttpResponseForbidden(body, mimetype='application/json')
if request.user.is_authenticated():
user = User.objects.get(pk=user_id)
if user:
if not check_access(request, user):
unauthorized()
action = request.REQUEST.get('action', None)
if domain_id:
requesturl = reverse('domains-image-manager',
args=[domain_id, user_id])
else:
requesturl = reverse('accounts-image-manager',
args=[user_id])
if action and action == 'auth':
body = dict(success=True, data=dict(
move=dict(enabled=False, handler=requesturl),
rename=dict(enabled=False, handler=requesturl),
remove=dict(enabled=True, handler=requesturl),
mkdir=dict(enabled=False, handler=requesturl),
upload=dict(enabled=True, handler=requesturl + '?action=upload',
accept_ext=['gif', 'jpg', 'png']),
baseUrl='')
)
elif action and action == 'list':
imgquery = SignatureImg.objects.filter(owner=user)
imgs = {}
def builddict(img):
imgs[img.name] = reverse('img-view', args=[user_id, img.id])
[builddict(img) for img in imgquery]
body = dict(success=True, data=dict(
directories={},
files=imgs))
elif action and action == 'upload':
if request.method == 'POST':
handle = request.FILES['handle']
prevent = False
currentsigs = SignatureImg.objects.filter(owner=user).count()
profile = UserProfile.objects.filter(user=user)[0]
if user.is_superuser:
prevent = True
elif profile.account_type == 2:
domains = UserAddresses.objects.filter(address_type=1, user=user).count()
if currentsigs >= domains:
prevent = True
else:
if currentsigs:
prevent = True
if not prevent:
chunk = handle.read()
ext = imghdr.what('./xxx', chunk)
if ext in ['gif', 'jpg', 'png', 'jpeg']:
try:
name = request.REQUEST.get('newName') or 'image.%s' % ext
name = os.path.basename(name)
dbimg = SignatureImg(
name = name,
image = base64.encodestring(chunk),
content_type = handle.content_type,
owner = user,)
dbimg.save()
respond = _('File has been uploaded')
except DatabaseError:
respond = _('An error occured, try again later')
else:
respond = _('The uploaded file is not acceptable')
chunk = None
handle.close()
else:
respond = _('You already have a signature image, '
'delete the current image before '
'uploading a new one')
return HttpResponse(respond)
elif action and action == 'remove':
try:
fname = request.REQUEST.get('file', None)
SignatureImg.objects.filter(owner=user, name=fname).delete()
respond = _('The file has been deleted')
success = True
except DatabaseError:
respond = _('The file could not be deleted')
success = False
body = dict(success=success, data=respond)
else:
body = dict(success=False, error=_("Action not supported"),
errorno=255)
return HttpResponse(anyjson.dumps(body), mimetype='application/json')
else:
unauthorized()
0
Example 33
Project: django-rest-framework-fine-permissions Source File: fine_permissions_load.py
Function: handle
Function: handle
def handle(self, *args, **options):
"""
dump fields permissions for a user
"""
def get_user(username):
try:
return User.objects.get(username=username)
except ObjectDoesNotExist as e:
raise CommandError("This user doesn't exist in the database")
def add_permissions(user_field_permissions, content_type, name):
p = None
try:
p = FieldPermission.objects.get(content_type=content_type, name=name)
except ObjectDoesNotExist:
p = FieldPermission(content_type=content_type, name=name)
p.save()
finally:
user_field_permissions.permissions.add(p)
if len(args) !=1:
raise CommandError("Specifies a json file created by the fine_permissions_dump command")
else:
try:
with open(args[0], 'r') as json_file:
myjson = json.load(json_file)
user = get_user(options.get('user')) if options['user'] else get_user(myjson['username'])
fields_permissions = myjson['fields_permissions']
user_field_permissions = UserFieldPermissions(user=user)
user_field_permissions.save()
for f in fields_permissions:
content_type = ContentType.objects.get(app_label=f["app_label"], model=f["model"])
add_permissions(user_field_permissions, content_type, f['name'])
except Exception as e:
raise CommandError(e)
0
Example 34
def userupdate(request):
"""
Update a user's information.
This function will update the user's account based on the contents of
the form, much the same way the register function works.
Parameters:
request -- An HttpRequest with parameters for user information.
Returns:
JSON indicating success or failure.
"""
username = request.POST.get('newusername', None)
password1 = request.POST.get('newpassword1', None)
password2 = request.POST.get('newpassword2', None)
email = request.POST.get('email', None)
fname = request.POST.get('firstname', None)
lname = request.POST.get('lastname', None)
hint = request.POST.get('passwordhint', None)
org = request.POST.get('organization', None)
id = request.POST.get('userid', None)
status = { 'success':False, 'message':'Unspecified error.' }
if username == 'anonymous':
status['message'] = 'Cannot update anonymous account information.'
else:
try:
user = User.objects.get(id=id)
if user.username != username:
status['message'] = 'Cannot change username.'
elif password1 != password2:
status['message'] = 'Passwords do not match.'
else:
user.email = email
user.first_name = fname
user.last_name = lname
if not (password1 == '' or password1 is None):
user.set_password(password1)
user.save()
profile = user.get_profile()
profile.pass_hint = hint
profile.organization = org
profile.save()
status['success'] = True
status['message'] = 'Information updated.'
except:
status['message'] = 'No user for that account.'
return HttpResponse(json.dumps(status), mimetype='application/json')
0
Example 35
def handle(self, *args, **options):
if options['content_path']:
content_path = options['content_path']
elif settings.BOOTSTRAP_CONTENT_DIR:
content_path = settings.BOOTSTRAP_CONTENT_DIR
else:
raise CommandError("Pass --content <content dir>, where <content dir>/pages contain .yml files")
if options['owner']:
owner_user = User.objects.get(username=options['owner'])
else:
owner_user = None
#raise CommandError("Pass --owner <username>, where <username> will be the content owner")
dry_run = options['dry']
contents = load_content(os.path.join(content_path, 'pages'))
for site in Site.objects.all():
site.delete()
for page in Page.objects.filter(id__gt=1):
page.delete()
root = Page.get_first_root_node()
content_root = RootNode('/', page_properties={}, parent_page=root)
for page_attrs in contents:
new_node = SiteNode(full_path=page_attrs['path'], page_properties=page_attrs)
content_root.add_node(new_node)
page_property_defaults = get_page_defaults(content_path)
relation_mappings = get_relation_mappings(content_path)
content_root.instantiate_page(owner_user=owner_user,
page_property_defaults=page_property_defaults,
relation_mappings=relation_mappings,
dry_run=dry_run)
sites = []
for site in get_sites(content_path):
sites.append(Site.objects.create(hostname=site['hostname'],
port=int(site['port']),
root_page=page_for_path(site['root_page'])))
default_site = sites[0]
default_site.is_default_site = True
default_site.save()
if dry_run:
self.stdout.write("Dry run, exiting without making changes")
return
content_root.instantiate_deferred_models(owner_user=owner_user,
page_property_defaults=page_property_defaults,
relation_mappings=relation_mappings,
dry_run=dry_run)
0
Example 36
Project: oioioi Source File: tests.py
def test_schools_merging_unsuccessfull(self):
contest = Contest.objects.get()
contest.controller_name = \
'oioioi.oi.controllers.OIContestController'
contest.save()
user = User.objects.get(username='test_user')
url = reverse('participants_register',
kwargs={'contest_id': contest.id})
self.client.login(username='test_user')
response = self.client.get(url)
user.first_name = 'Sir Lancelot'
user.last_name = 'du Lac'
user.save()
reg_data = {
'address': 'The Castle',
'postal_code': '31-337',
'city': 'Camelot',
'phone': '000-000-000',
'birthday_month': '5',
'birthday_day': '25',
'birthday_year': '1975',
'birthplace': 'Lac',
't_shirt_size': 'L',
'school': '2',
'class_type': '1LO',
'terms_accepted': 'y',
}
response = self.client.post(url, reg_data)
self.assertEquals(302, response.status_code)
s1 = School.objects.get(pk=1)
s2 = School.objects.get(pk=2)
s2.is_approved = False
s2.save()
self.client.login(username='test_admin')
response = self._call_admin_merge_action((1))
self.assertContains(response, 'exactly one')
response = self._call_admin_merge_action((2))
self.assertContains(response, 'exactly one')
response = self._call_admin_merge_action((1, 3))
self.assertContains(response, 'exactly one')
response = self._call_admin_merge_action((1, 2, 3))
self.assertContains(response, 'exactly one')
s2reg = OIRegistration.objects.get(participant__user=user)
self.assertFalse(s2reg.school == s1)
self.assertTrue(s2reg.school == s2)
response = self._call_admin_merge_action((1, 2))
self.assertNotContains(response, 'exactly one')
s2reg = OIRegistration.objects.get(participant__user=user)
self.assertTrue(s2reg.school == s1)
self.assertFalse(s2reg.school == s2)
self.assertTrue(s2 not in School.objects.all())
0
Example 37
Project: wger Source File: test_calories_calculator.py
def test_automatic_weight_entry_bmr(self):
'''
Tests that weight entries are automatically created or updated
'''
self.user_login('test')
user = User.objects.get(username=self.current_user)
# Existing weight entry is old, a new one is created
entry1 = WeightEntry.objects.filter(user=user).latest()
response = self.client.post(reverse('nutrition:calories:bmr'),
{'age': 30,
'height': 180,
'gender': 1,
'weight': 80})
self.assertEqual(response.status_code, 200)
entry2 = WeightEntry.objects.filter(user=user).latest()
self.assertEqual(entry1.weight, 83)
self.assertEqual(entry2.weight, 80)
# Existing weight entry is from today, is updated
entry2.delete()
entry1.date = datetime.date.today()
entry1.save()
response = self.client.post(reverse('nutrition:calories:bmr'),
{'age': 30,
'height': 180,
'gender': 1,
'weight': 80})
self.assertEqual(response.status_code, 200)
entry2 = WeightEntry.objects.filter(user=user).latest()
self.assertEqual(entry1.pk, entry2.pk)
self.assertEqual(entry2.weight, 80)
# No existing entries
WeightEntry.objects.filter(user=user).delete()
response = self.client.post(reverse('nutrition:calories:bmr'),
{'age': 30,
'height': 180,
'gender': 1,
'weight': 80})
self.assertEqual(response.status_code, 200)
entry = WeightEntry.objects.filter(user=user).latest()
self.assertEqual(entry.weight, 80)
self.assertEqual(entry.date, datetime.date.today())
0
Example 38
Project: reviewboard Source File: testcase.py
def create_review_request(self, with_local_site=False, local_site=None,
summary='Test Summary',
description='Test Description',
testing_done='Testing',
submitter='doc',
branch='my-branch',
local_id=1001,
bugs_closed='', status='P', public=False,
publish=False, commit_id=None, changenum=None,
repository=None, id=None,
create_repository=False):
"""Create a ReviewRequest for testing.
The ReviewRequest may optionally be attached to a LocalSite. It's also
populated with default data that can be overridden by the caller.
If create_repository is True, a Repository will be created
automatically. If set, a custom repository cannot be provided.
The provided submitter may either be a username or a User object.
If publish is True, ReviewRequest.publish() will be called.
"""
if not local_site:
if with_local_site:
local_site = self.get_local_site(name=self.local_site_name)
else:
local_site = None
if not local_site:
local_id = None
if create_repository:
assert not repository
repository = \
self.create_repository(with_local_site=with_local_site)
if not isinstance(submitter, User):
submitter = User.objects.get(username=submitter)
review_request = ReviewRequest(
summary=summary,
description=description,
branch=branch,
testing_done=testing_done,
local_site=local_site,
local_id=local_id,
submitter=submitter,
diffset_history=DiffSetHistory.objects.create(),
repository=repository,
public=public,
commit_id=commit_id,
changenum=changenum,
bugs_closed=bugs_closed,
status=status)
# Set this separately to avoid issues with CounterField updates.
review_request.id = id
review_request.save()
if publish:
review_request.publish(review_request.submitter)
return review_request
0
Example 39
def handle(self, *args, **kwargs):
base_url = "https://www.mailboxforwarding.com/"
if (not hasattr(settings, "MAILBOX_FORWARDING") or
not "username" in settings.MAILBOX_FORWARDING or
not "password" in settings.MAILBOX_FORWARDING):
print "Requires MAILBOX_FORWARDING settings, e.g.:"
print 'MAILBOX_FORWARDING = {'
print ' "username": "[email protected]",'
print ' "password": "secret",'
print '}'
print "exit 1"
sys.exit(1)
sess = requests.Session()
res = sess.post(base_url + "manage/login.php", {
"action": "login",
"email": settings.MAILBOX_FORWARDING["username"],
"password": settings.MAILBOX_FORWARDING["password"],
"loginsubmit.x": "0",
"loginsubmit.y": "0"
})
# This is a slightly dirty hack -- we're matching a javascript data
# structure with a regex, converting the quotes to doubles so it resembles
# JSON, and then loading it as JSON. This may prove brittle.
match = re.search(r"Ext\.grid\.dummyData = (\[.*\]\]);", res.text, re.DOTALL)
if not match:
raise Exception("Can't find data. Are login creds correct?")
text = match.group(1)
text = text.replace('"', '\\"')
text = text.replace("'", '"')
data = json.loads(text)
scans = {}
packages = {}
for checkbox, date, envelope, type_status, dl in data:
details = {}
match = re.search("Type: <b>([^<]+)</b>.*Status: <b>([^<]+)</b>", type_status)
if not match:
raise Exception("Can't match type/status")
details['kind'] = match.group(1)
details['status'] = match.group(2)
if details['kind'] == "Letter" and details['status'] != "Scanned":
continue
match = re.search("pdfview.php\?id=(\d+)", dl)
if match:
id_ = match.group(1)
else:
# TODO: Handle packages correctly
continue
#raise Exception("Can't find ID")
match = re.search("src=\"([^\"]+)\"", envelope)
if not match:
raise Exception("Can't match envelope image")
details['envelope'] = match.group(1)
if details['status'] == "Scanned":
scans[id_] = details
elif details['kind'] != "Letter":
packages[id_] = details
uploader = User.objects.get(username="uploader")
org = Organization.objects.get(pk=1) #TODO: generalize this?
new_count = 0
for id_, details in scans.iteritems():
source_id = "mailboxforwarding.com-{}".format(id_)
if Scan.objects.filter(source_id=source_id).exists():
continue
new_count += 1
print "Downloading pdf", source_id
res = sess.get("{}manage/pdfview.php?id={}".format(base_url, id_))
in_pdf_fh = StringIO()
in_pdf_fh.write(res.content)
in_pdf_fh.seek(0)
reader = PdfFileReader(in_pdf_fh)
print "Downloading envelope", details['envelope']
res = sess.get(details['envelope'])
in_envelope_fh = StringIO()
in_envelope_fh.write(res.content)
in_envelope_fh.seek(0)
img = Image.open(in_envelope_fh)
out_envelope_fh = StringIO()
img.save(out_envelope_fh, "pdf")
envelope_reader = PdfFileReader(out_envelope_fh)
writer = PdfFileWriter()
writer.addPage(envelope_reader.getPage(0))
for page in range(reader.getNumPages()):
writer.addPage(reader.getPage(page))
with tempfile.NamedTemporaryFile(suffix=".pdf", delete=False) as fh:
writer.write(fh)
dest_pdf_name = fh.name
in_envelope_fh.close()
out_envelope_fh.close()
in_pdf_fh.close()
path = tasks.move_scan_file(filename=dest_pdf_name)
scan = Scan.objects.create(
uploader=uploader,
pdf=os.path.relpath(path, settings.MEDIA_ROOT),
under_construction=True,
org=org,
source_id=source_id
)
tasks.split_scan(scan=scan)
if packages:
print "Manual action needed on the following at " \
"https://www.mailboxforwarding.com/:"
for id_, details in packages.iteritems():
new_count += 1
print details
print "Examined {} letters, {} new.".format(len(data), new_count)
0
Example 40
Project: django-shibboleth Source File: views.py
def shib_register(request, RegisterForm=BaseRegisterForm,
register_template_name='shibboleth/register.html'):
attr, error = parse_attributes(request.META)
was_redirected = False
if "next" in request.REQUEST:
was_redirected = True
redirect_url = request.REQUEST.get('next', settings.LOGIN_REDIRECT_URL)
context = {'shib_attrs': attr,
'was_redirected': was_redirected}
if error:
return render_forbidden('shibboleth/attribute_error.html',
context,
context_instance=RequestContext(request))
try:
username = attr[settings.SHIB_USERNAME]
# TODO this should log a misconfiguration.
except:
return render_forbidden('shibboleth/attribute_error.html',
context,
context_instance=RequestContext(request))
if not attr[settings.SHIB_USERNAME] or attr[settings.SHIB_USERNAME] == '':
return render_forbidden('shibboleth/attribute_error.html',
context,
context_instance=RequestContext(request))
if request.method == 'POST':
form = RegisterForm(request.POST)
if form.is_valid():
user = form.save(attr)
try:
user = User.objects.get(username=attr[settings.SHIB_USERNAME])
except User.DoesNotExist:
form = RegisterForm()
context = {'form': form,
'next': redirect_url,
'shib_attrs': attr,
'was_redirected': was_redirected}
return render_to_response(register_template_name,
context,
context_instance=RequestContext(request))
user.set_unusable_password()
try:
user.first_name = attr[settings.SHIB_FIRST_NAME]
user.last_name = attr[settings.SHIB_LAST_NAME]
user.email = attr[settings.SHIB_EMAIL]
except:
pass
user.save()
user.backend = 'django.contrib.auth.backends.ModelBackend'
login(request, user)
shib_logon_done.send(sender=shib_register, user=user, shib_attrs=attr)
if not redirect_url or '//' in redirect_url or ' ' in redirect_url:
redirect_url = settings.LOGIN_REDIRECT_URL
return HttpResponseRedirect(redirect_url)
0
Example 41
Project: django-goflow Source File: models.py
def start(self, process_name, user, item, title=None, priority=0):
'''
Returns a workitem given the name of a preexisting enabled Process
instance, while passing in the id of the user, the contenttype
object and the title.
:type process_name: string
:param process_name: a name of a process. e.g. 'leave'
:type user: User
:param user: an instance of django.contrib.auth.models.User,
typically retrieved through a request object.
:type item: ContentType
:param item: a content_type object e.g. an instance of LeaveRequest
:type: title: string
:param title: title of new ProcessInstance instance (optional)
:type: priority: integer
:param priority: default priority (optional)
:rtype: WorkItem
:return: a newly configured workitem sent to auto_user,
a target_user, or ?? (roles).
usage::
wi = Process.objects.start(process_name='leave',
user=admin, item=leaverequest1)
'''
process = Process.objects.get(title=process_name, enabled=True)
if priority == 0: priority = process.priority
if not title or (title=='instance'):
title = '%s %s' % (process_name, str(item))
instance = ProcessInstance.objects.create(process=process, user=user, title=title, content_object=item)
# instance running
instance.set_status('running')
workitem = WorkItem.objects.create(instance=instance, user=user,
activity=process.begin, priority=priority)
log.event('created by ' + user.username, workitem)
log('process:', process_name, 'user:', user.username, 'item:', item)
if process.begin.kind == 'dummy':
log('routing activity', process.begin.title, 'workitem:', workitem)
auto_user = User.objects.get(username=settings.WF_USER_AUTO)
workitem.activate(actor=auto_user)
workitem.complete(actor=auto_user)
return workitem
if process.begin.autostart:
log('run auto activity', process.begin.title, 'workitem:', workitem)
auto_user = User.objects.get(username=settings.WF_USER_AUTO)
workitem.activate(actor=auto_user)
if workitem.exec_auto_application():
log('workitem.exec_auto_application:', workitem)
workitem.complete(actor=auto_user)
return workitem
if process.begin.push_application:
target_user = workitem.exec_push_application()
log('application pushed to user', target_user.username)
workitem.user = target_user
workitem.save()
log.event('assigned to '+target_user.username, workitem)
#notify_if_needed(user=target_user)
else:
# set pull roles; useful (in activity too)?
workitem.pull_roles = workitem.activity.roles.all()
workitem.save()
#notify_if_needed(roles=workitem.pull_roles)
return workitem
0
Example 42
def createsuperuser(username=None, email=None, password=None):
"""
Helper function for creating a superuser from the command line. All
arguments are optional and will be prompted-for if invalid or not given.
"""
try:
import pwd
except ImportError:
default_username = ''
else:
# Determine the current system user's username, to use as a default.
default_username = pwd.getpwuid(os.getuid())[0].replace(' ', '').lower()
# Determine whether the default username is taken, so we don't display
# it as an option.
if default_username:
try:
User.objects.get(username=default_username)
except User.DoesNotExist:
pass
else:
default_username = ''
try:
while 1:
if not username:
input_msg = 'Username'
if default_username:
input_msg += ' (Leave blank to use %r)' % default_username
username = raw_input(input_msg + ': ')
if default_username and username == '':
username = default_username
if not RE_VALID_USERNAME.match(username):
sys.stderr.write("Error: That username is invalid. Use only letters, digits and underscores.\n")
username = None
continue
try:
User.objects.get(username=username)
except User.DoesNotExist:
break
else:
sys.stderr.write("Error: That username is already taken.\n")
username = None
while 1:
if not email:
email = raw_input('E-mail address: ')
try:
validators.isValidEmail(email, None)
except validators.ValidationError:
sys.stderr.write("Error: That e-mail address is invalid.\n")
email = None
else:
break
while 1:
if not password:
password = getpass.getpass()
password2 = getpass.getpass('Password (again): ')
if password != password2:
sys.stderr.write("Error: Your passwords didn't match.\n")
password = None
continue
if password.strip() == '':
sys.stderr.write("Error: Blank passwords aren't allowed.\n")
password = None
continue
break
except KeyboardInterrupt:
sys.stderr.write("\nOperation cancelled.\n")
sys.exit(1)
u = User.objects.create_user(username, email, password)
u.is_staff = True
u.is_active = True
u.is_superuser = True
u.save()
print "Superuser created successfully."
0
Example 43
def initialize_context(request):
ret = {}
ret['all_msg'] = request.REQUEST.get("all_msg", 'all')
ret['community_id'] = request.REQUEST.get("community_id", 0)
ret['search_string'] = request.REQUEST.get("search_string", '')
ret['search_string'] = ret['search_string'].encode('utf8')
ret['member_id'] = request.REQUEST.get("member_id", 0)
ret['message_id'] = request.REQUEST.get("message_id", 0)
ret['contenttype_id'] = request.REQUEST.get("contenttype_id", 0)
ret['current_query_string'] = urllib.urlencode(ret)
# Next lines must be after previous line
ret['com_page'] = request.REQUEST.get("com_page", 0)
ret['from_id'] = request.REQUEST.get("from_id", 0)
if ret['from_id'] == '':
ret['from_id'] = 0
else:
ret['from_id'] = int(ret['from_id'])
ao = set([])
ao_member = get_allowed_objects(request.user, Community, 'member')
ao = ao.union(set(ao_member))
ao_manage = get_allowed_objects(request.user, Community, 'manage')
ao = ao.union(set(ao_manage))
ret['communities'] = Community.objects.filter(id__in=ao).order_by('name')
ret['user_manager'] = True if len(ao_manage) else False
ccom = int(ret['community_id'])
ret['current_community'] = None
for com in ret['communities']:
com.manager = True if com.pk in ao_manage else False
com.member = True if com.pk in ao_member else False
if ccom != 0 and ccom == com.pk:
ret['current_community'] = com
if int(ret['community_id']) != 0 and ret['current_community'] and ret['current_community'] in ret['communities']:
communities = [ret['current_community']]
else:
communities = ret['communities']
ret['community_id'] = 0
data = []
ret['members'] = set([])
for com in communities:
ret['members'] = ret['members'].union(
set(get_acl_by_object(com, 'member')))
ret['members'] = ret['members'].union(
set(get_acl_by_object(com, 'manage')))
data.append([com.name, "g-%s" % str(com.id)])
data.extend([("%s %s" % (x.last_name, x.first_name), ("u-%s" % str(x.id)))
for x in ret['members']])
ret['members_count'] = len(ret['members'])
if int(ret['community_id']):
contributors = MessageCommunity.objects.values('owner').filter(
Q(communities=int(ret['community_id'])) |
Q(reply__communities=int(ret['community_id']))
).annotate(total=Count('owner')
)
else:
contributors = MessageCommunity.objects.values(
'owner').annotate(total=Count('owner'))
contributors = contributors.order_by('-total')[0:10]
ret['users_avatars'] = {}
for avatar in UserAvatar.objects.select_related().filter(user__pk__in=[u.pk for u in ret['members']] + [c['owner'] for c in contributors]):
ret['users_avatars'][avatar.user_id] = avatar
for m in ret['members']:
if ret['users_avatars'].has_key(m.pk):
m.avatar = ret['users_avatars'][m.pk]
else:
m.avatar = None
for c in contributors:
if ret['users_avatars'].has_key(c['owner']):
c['avatar'] = ret['users_avatars'][c['owner']]
c['user'] = ret['users_avatars'][c['owner']].user
else:
c['avatar'] = None
c['user'] = User.objects.get(pk=c['owner'])
ret['contributors'] = contributors
ret['members_data'] = simplejson.dumps(data)
if ret['current_community']:
ret['community_title'] = ret['current_community'].name
elif ret['all_msg'] == 'followed':
ret['community_title'] = _(u"Followed posts")
elif ret['all_msg'] == 'last':
ret['community_title'] = _(u"Recent messages")
elif ret['all_msg'] == 'tome':
ret['community_title'] = _(u"Direct to me")
elif ret['all_msg'] == 'contributor':
member = User.objects.get(pk=ret['member_id'])
ret['community_title'] = member.get_full_name()
elif ret['all_msg'] == 'contenttype':
ret['community_title'] = _(u"Content type")
elif ret['all_msg'] == 'message':
ret['community_title'] = _(u"Message")
else:
ret['community_title'] = _(u"All")
if int(ret['from_id']) != 0:
ret['msg_sender'] = User.objects.get(pk=int(ret['from_id']))
return ret
0
Example 44
Project: volontulo Source File: test_auth.py
def test__post_login_by_anonymous_user(self):
u"""Post to login form by anonymous"""
# incorrect email or password
form_params = {
'email': '[email protected]',
'password': 'volunteer1',
}
response = self.client.post(
'/login',
form_params,
)
self.assertEqual(response.status_code, 200)
self.assertContains(response, u"Nieprawidłowy email lub hasło!")
form_params = {
'email': '[email protected]',
'password': 'xxx',
}
response = self.client.post(
'/login',
form_params,
)
self.assertEqual(response.status_code, 200)
self.assertContains(response, u"Nieprawidłowy email lub hasło!")
# email and password is correct but and user is not active
user = User.objects.get(email=u'[email protected]')
user.is_active = False
user.save()
form_params = {
'email': '[email protected]',
'password': 'volunteer1',
}
response = self.client.post(
'/login',
form_params,
)
self.assertEqual(response.status_code, 200)
self.assertContains(
response,
u"Konto jest nieaktywne, skontaktuj się z administratorem."
)
self.assertNotIn('_auth_user_id', self.client.session)
# email and password is correct and user is active
user.is_active = True
user.save()
form_params = {
'email': '[email protected]',
'password': 'volunteer1',
}
response = self.client.post(
'/login',
form_params,
follow=True
)
self.assertEqual(response.status_code, 200)
self.assertContains(response, u"Poprawnie zalogowano")
self.assertRedirects(
response,
'/',
302,
200,
)
self.assertEqual(len(response.redirect_chain), 1)
self.assertEqual(
response.redirect_chain[0],
('http://testserver/', 302),
)
0
Example 45
def add(request, form_class=MakePaymentForm, template_name="make_payments/add.html"):
if request.method == "POST":
form = form_class(request.user, request.POST)
if form.is_valid():
mp = form.save(commit=False)
# we might need to create a user record if not exist
if request.user.is_authenticated():
user = request.user
else:
try:
user = User.objects.get(email=mp.email)
except:
user = request.user
if not user.is_anonymous():
mp.user = user
mp.creator = user
mp.creator_username = user.username
mp.save(user)
# create invoice
invoice = make_payment_inv_add(user, mp)
EventLog.objects.log(instance=invoice)
# updated the invoice_id for mp, so save again
mp.save(user)
EventLog.objects.log(instance=mp)
# send notification to administrators
# get admin notice recipients
recipients = get_notice_recipients('module', 'payments', 'paymentrecipients')
if recipients:
if notification:
extra_context = {
'mp': mp,
'invoice': invoice,
'request': request,
}
notification.send_emails(recipients,'make_payment_added', extra_context)
# email to user
email_receipt = form.cleaned_data['email_receipt']
if email_receipt:
make_payment_email_user(request, mp, invoice)
# redirect to online payment or confirmation page
if mp.payment_method == 'cc' or mp.payment_method == 'credit card':
return HttpResponseRedirect(reverse('payment.pay_online', args=[invoice.id, invoice.guid]))
else:
return HttpResponseRedirect(reverse('make_payment.add_confirm', args=[mp.id]))
else:
form = form_class(request.user)
# check for initial payment_amount and clean up
payment_amount = request.GET.get('payment_amount', 0)
try:
payment_amount = float(payment_amount)
except:
payment_amount = 0
if payment_amount > 0:
form.fields['payment_amount'].initial = payment_amount
# check for initial comment and clean up
comments = request.GET.get('comments','')
if comments:
comments = strip_tags(comments)
comments = strip_entities(comments)
form.fields['comments'].initial = comments
currency_symbol = get_setting("site", "global", "currencysymbol")
if not currency_symbol: currency_symbol = "$"
return render_to_response(template_name, {'form':form, 'currency_symbol': currency_symbol},
context_instance=RequestContext(request))
0
Example 46
def staff_member_required(view_func):
"""
Decorator for views that checks that the user is logged in and is a staff
member, displaying the login page if necessary.
"""
def _checklogin(request, *args, **kwargs):
if request.user.is_authenticated() and request.user.is_staff:
# The user is valid. Continue to the admin page.
if 'post_data' in request.POST:
# User must have re-authenticated through a different window
# or tab.
request.POST = _decode_post_data(request.POST['post_data'])
return view_func(request, *args, **kwargs)
assert hasattr(request, 'session'), "The Django admin requires session middleware to be installed. Edit your MIDDLEWARE_CLASSES setting to insert 'django.contrib.sessions.middleware.SessionMiddleware'."
# If this isn't already the login page, display it.
if LOGIN_FORM_KEY not in request.POST:
if request.POST:
message = _("Please log in again, because your session has expired. Don't worry: Your submission has been saved.")
else:
message = ""
return _display_login_form(request, message)
# Check that the user accepts cookies.
if not request.session.test_cookie_worked():
message = _("Looks like your browser isn't configured to accept cookies. Please enable cookies, reload this page, and try again.")
return _display_login_form(request, message)
# Check the password.
username = request.POST.get('username', None)
password = request.POST.get('password', None)
user = authenticate(username=username, password=password)
if user is None:
message = ERROR_MESSAGE
if '@' in username:
# Mistakenly entered e-mail address instead of username? Look it up.
try:
user = User.objects.get(email=username)
except User.DoesNotExist:
message = _("Usernames cannot contain the '@' character.")
else:
message = _("Your e-mail address is not your username. Try '%s' instead.") % user.username
return _display_login_form(request, message)
# The user data is correct; log in the user in and continue.
else:
if user.is_active and user.is_staff:
login(request, user)
# TODO: set last_login with an event.
if 'post_data' in request.POST:
post_data = _decode_post_data(request.POST['post_data'])
if post_data and LOGIN_FORM_KEY not in post_data:
# overwrite request.POST with the saved post_data, and continue
request.POST = post_data
request.user = user
return view_func(request, *args, **kwargs)
else:
request.session.delete_test_cookie()
return http.HttpResponseRedirect(request.path)
else:
return _display_login_form(request, ERROR_MESSAGE)
return wraps(view_func)(_checklogin)
0
Example 47
Project: logtacts Source File: views.py
@csrf_exempt
def sms(request):
if request.method == 'GET':
return HttpResponseRedirect('/')
if request.method == 'POST':
overall_start = time.time()
cache_key = request.POST.get('From')
co_number = request.POST.get('To')
message = request.POST.get('Body').strip()
if not cache_key:
raise Http404()
flow_state = cache.get(cache_key)
if flow_state:
if message.lower() == 'done':
cache.delete(cache_key)
return help_message()
if flow_state == QUERY_ACCOUNT:
if message.lower() in ('yes', 'yep'):
cache.set(cache_key, GET_EMAIL, CACHE_TIMEOUT)
return create_message(
"Ok, what's the email address on your account?",
to=cache_key, sender=co_number,
)
else:
cache.delete(cache_key)
return create_message(
"Ok! Please go to https://www.contactotter.com to create an account.",
to=cache_key, sender=co_number,
)
if flow_state == GET_EMAIL:
try:
# TODO: Send a confirmation email for connecting phone
user = User.objects.get(email=message.lower())
profile, _ = Profile.objects.get_or_create(user=user)
profile.phone_number = cache_key
profile.save()
cache.delete(cache_key)
return create_message(
"Ok! Your phone is connected to your account.",
to=cache_key, sender=co_number,
)
except User.DoesNotExist:
cache.delete(cache_key)
return create_message(
"We couldn't find an account for that email. Please go to https://www.contactotter.com to create one",
to=cache_key, sender=co_number,
)
user, book = get_user_objects_from_message(request.POST)
if not user or not book:
cache.set(cache_key, QUERY_ACCOUNT, CACHE_TIMEOUT)
return create_message(
"Hmm... I can't find an account with this number. Do you have a ContactOtter account?",
to=cache_key, sender=co_number,
)
if flow_state:
if flow_state.startswith('log'):
name = ':'.join(flow_state.split(':')[1:])
contacts = SearchQuerySet().filter(book=book.id).filter(
SQ(name=AutoQuery(name)) | SQ(content=AutoQuery(name))
)
if len(message) == 1 and len(contacts) > 0:
index = ascii_lowercase.index(message.lower())
contact = contacts[index].object
cache.delete(cache_key)
return log_contact(contact, user)
cache.delete(cache_key)
return create_message(
"Sorry, I didn't understand that.",
to=cache_key, sender=co_number,
)
if flow_state.startswith('find'):
name = ':'.join(flow_state.split(':')[1:])
contacts = SearchQuerySet().filter(book=book.id).filter(
SQ(name=AutoQuery(name)) | SQ(content=AutoQuery(name))
)
if len(message) == 1 and len(contacts) > 0:
index = ascii_lowercase.index(message.lower())
contact = contacts[index].object
cache.delete(cache_key)
return create_message(
get_contact_string(contact), to=cache_key, sender=co_number,
)
cache.delete(cache_key)
return create_message(
"Sorry, I didn't understand that.",
to=cache_key, sender=co_number,
)
tokens = message.split(' ')
if len(tokens) < 2:
return help_message()
search_start = time.time()
if tokens[0].lower() in MET_PREFIXES:
if tokens[1].lower() == 'with':
del tokens[1]
name = ' '.join(tokens[1:])
contacts = SearchQuerySet().filter(book=book.id).filter(
SQ(name=AutoQuery(name)) | SQ(content=AutoQuery(name))
)
if len(contacts) > 1:
cache.set(cache_key, "log:{}".format(name), CACHE_TIMEOUT)
response_string = "Which {} did you mean?\n".format(name)
response_string += get_string_from_search_contacts(contacts)
response_string += "(DONE to exit)"
return create_message(
response_string, to=cache_key, sender=co_number,
)
if len(contacts) == 1:
contact = contacts[0].object
else:
contact = Contact.objects.create(
book=book,
name=name,
)
cache.delete(cache_key)
return log_contact(contact, user)
if tokens[0].lower() == 'find':
name = ' '.join(tokens[1:])
contacts = SearchQuerySet().filter(book=book.id).filter(
SQ(name=AutoQuery(name)) | SQ(content=AutoQuery(name))
)
if len(contacts) == 0:
return create_message(
"Hmm... I didn't find any contacts.",
to=cache_key, sender=co_number,
)
if len(contacts) == 1:
return create_message(
get_contact_string(contacts[0].object),
to=cache_key, sender=co_number,
)
response_string = get_string_from_search_contacts(contacts)
if len(contacts) > 3:
response_string += "More: https://{}/search/?q={}".format(
Site.objects.get_current().domain,
name,
)
cache.set(cache_key, "find:{}".format(name), CACHE_TIMEOUT)
return create_message(
"Here's what I found for {}:\n{}".format(name, response_string),
to=cache_key, sender=co_number,
)
return help_message()
0
Example 48
def login(request):
next = reverse(projects.list)
error_header = None
if request.method == 'POST':
if 'next' in request.POST:
next = request.POST['next']
login_form = LoginForm(request.POST, auto_id = "id_login_%s")
if login_form.is_valid():
try:
data = login_form.cleaned_data
# query for a user via email
try:
user = User.objects.get(email = data['email'])
except:
error_header = "{0} isn't registered.".format(data['email'])
raise LoginError(False)
# authenticate that user
user = auth.authenticate(username = user.username,
password = data['password'])
# if the password is incorrect, redireect to the login page
if user is None:
error_header = "Invalid password."
raise LoginError(True)
# otherwise, log the user in
auth.login(request, user)
return HttpResponseRedirect(next)
except LoginError as e:
pass
except:
raise
else:
login_form = LoginForm(auto_id = "id_login_%s")
return render_to_response('users/login.html', {
'next': next,
'error_header': error_header,
'login_form': login_form
}, context_instance = RequestContext(request))
0
Example 49
def __init__ (self, test_case, username, password, consumer):
self.SERVER_NAME = 'testserver'
self.consumer = consumer
self.test_case = test_case
# Much of this method comes straight from Piston's unit tests
# TODO: Fix copyright, then!
oaconsumer = oauth.OAuthConsumer(self.consumer.key,
self.consumer.secret)
# Callback URL
c_url = 'http://printer.example.com/request_token_ready'
# Get a request key...
url = 'http://' + self.SERVER_NAME + '/oauth/request_token/'
request = oauth.OAuthRequest.from_consumer_and_token(oaconsumer,
http_url=url,
parameters={"oauth_callback" : c_url})
request.sign_request(self.signature_method, oaconsumer, None)
response = test_case.client.get('/oauth/request_token/',
request.parameters)
oatoken = oauth.OAuthToken.from_string(response.content)
token = Token.objects.get(key=oatoken.key, token_type=Token.REQUEST)
test_case.assertEqual(token.secret, oatoken.secret)
# Simulate user authentication...
test_case.failUnless(test_case.client.login(username=username,
password=password))
url = 'http://' + self.SERVER_NAME + '/oauth/authenticate/'
request = oauth.OAuthRequest.from_token_and_callback(token=oatoken,
http_url=url)
request.sign_request(self.signature_method, oaconsumer, oatoken)
# Faking form submission seems to not work, so approve token manually
# This normally happens in piston.store.authorize_request_token
token.is_approved = True
token.verifier = generate_random(VERIFIER_SIZE)
token.user = User.objects.get(username=username)
token.save()
# Normally the oauth_verifier is transmitted with the callback to the
# consumer, which does not happen here. Get the verifier directly from
# the database instead.
oaverifier = token.verifier
# Obtain access token...
url = 'http://' + self.SERVER_NAME + '/oauth/access_token/'
request = oauth.OAuthRequest.from_consumer_and_token(oaconsumer,
token=oatoken,
verifier=oaverifier,
http_url=url)
request.sign_request(self.signature_method, oaconsumer, oatoken)
response = test_case.client.get('/oauth/access_token/',
request.parameters)
oa_atoken = oauth.OAuthToken.from_string(response.content)
atoken = Token.objects.get(key=oa_atoken.key, token_type=Token.ACCESS)
test_case.assertEqual(atoken.secret, oa_atoken.secret)
self.oa_atoken = oa_atoken
0
Example 50
def import_user(u):
print u['uid'], u['username']
username = u['username']
description = u['description']
roles = u['roles']
fullname = u['fullname'].strip()
biography = u['biography']
email = u['email']
portrait = u['portraitfile'].split('/')[-1]
psn_id = u['uid']
location = u['location']
if not user_exists(username, email):
user = create_user(username, email_address=email, password='password')
else:
user = User.objects.get(username=username)
user.set_password('password')
if description :
user.description = description
elif biography :
user.description = biography
if not user.homeplace :
if location :
p,flag = Location.objects.get_or_create(name=location)
user.homeplace = p
else :
user.homeplace = get_or_create_root_location()
if " " in fullname :
first, last = fullname.rsplit(' ',1)
elif "." in fullname :
first, last = fullname.rsplit('.',1)
else :
first = fullname
last = ''
user.first_name = first[:30]
user.last_name = last[:30]
user.psn_id = psn_id
c = 1
email2 = email
while (email_exists(email2)) :
print email2
email2 = '%s%s'%(c,email)
c=c+1
user.email = email2
user.save()
f = ImageFile(open('mhpss_export/user_images/%s'%portrait),'rb')
if f.size == 1357 :
return # image is plone default ... we don't want it
path = avatar_file_path(target=user, filename=portrait)
avatar = Avatar(
target = user.get_ref(),
primary = True,
avatar = path,
)
avatar.save()
new_file = avatar.avatar.storage.save(path, f)
avatar.save()