django.contrib.auth.models.User.objects.get

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 7

Example 1

Project: madcow Source File: models.py
Function: add_link
    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

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())

Example 3

Project: movide Source File: tasks.py
Function: process_message
    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

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

Example 5

Project: transifex Source File: api.py
Function: test_post
    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)

Example 6

Project: oioioi Source File: import_balloons_displays.py
Function: handle
    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"))

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,
        })
    )

Example 8

Project: classic.rhizome.org Source File: admin.py
Function: merge_users
    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)

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))

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)

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))

Example 12

Project: piecrust Source File: fields.py
Function: test_hydrate
    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]')

Example 13

Project: baruwa Source File: ad.py
Function: authenticate
    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

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

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')

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))

Example 17

Project: oioioi Source File: import_onsite_participants.py
Function: handle
    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"))

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()

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)

Example 20

Project: zorna Source File: forms.py
Function: save
    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

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)

Example 22

Project: django-auth-ldap-ad Source File: backend.py
Function: get_local_user
    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

Example 23

Project: rapidpro Source File: tests.py
Function: browser
    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')

Example 24

Project: snowy Source File: handlers.py
Function: update
    @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)]
        }

Example 25

Project: tendenci Source File: views.py
Function: add
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))

Example 26

Project: tendenci Source File: forms.py
Function: save
    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

Example 27

Project: wagtail_blog Source File: wordpress_to_wagtail.py
Function: import_comments
    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

Example 28

Project: coursys Source File: testing.py
Function: log_in_user
    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()

Example 29

Project: transifex Source File: api.py
Function: read
    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

Example 30

Project: reviewboard Source File: backends.py
Function: get_or_create_user
    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

Example 31

Project: transifex Source File: api.py
Function: test_put
    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)

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()

Example 33

Project: django-rest-framework-fine-permissions Source File: fine_permissions_load.py
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)

Example 34

Project: DistrictBuilder Source File: views.py
Function: user_update
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')

Example 35

Project: wagtail-commons Source File: bootstrap_content.py
Function: handle
    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)

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())

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())

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

Example 39

Project: btb Source File: fetch_mailboxforwarding_mail.py
Function: handle
    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)

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)

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

Example 42

Project: talk.org Source File: create_superuser.py
Function: create_super_user
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."

Example 43

Project: zorna Source File: api.py
Function: initialize_context
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

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),
        )

Example 45

Project: tendenci Source File: views.py
Function: add
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))

Example 46

Project: talk.org Source File: decorators.py
Function: staff_member_required
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)

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()

Example 48

Project: Observatory Source File: users.py
Function: log_in
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))

Example 49

Project: snowy Source File: tests.py
Function: init
    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

Example 50

Project: hubplus Source File: users.py
Function: import_user
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()
See More Examples - Go to Next Page
Page 1 Selected Page 2 Page 3 Page 4