django.template.context.RequestContext

Here are the examples of the python api django.template.context.RequestContext taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

154 Examples 7

Example 101

Project: newfies-dialer Source File: views.py
@login_required
def contact_import(request):
    """Import CSV file of Contacts for the logged in user

    **Attributes**:

        * ``form`` - Contact_fileImport
        * ``template`` - dialer_contact/contact/import_contact.html

    **Logic Description**:

        * Before adding contacts, check dialer setting limit if applicable
          to the user.
        * Add new contacts which will belong to the logged in user
          via csv file & get the result (upload success and failure
          statistics)

    **Important variable**:

        * total_rows - Total no. of records in the CSV file
        * retail_record_count - No. of records imported from the CSV file
    """
    # Check dialer setting limit
    if request.user and request.method == 'POST':
        # check  Max Number of contacts
        if check_dialer_setting(request, check_for="contact"):
            request.session['msg'] = _("you have too many contacts. you are allowed a maximum of %(limit)s") % \
                {'limit': dialer_setting_limit(request, limit_for="contact")}

            # contact limit reached
            frontend_send_notification(request, NOTIFICATION_NAME.contact_limit_reached)
            return HttpResponseRedirect(redirect_url_to_contact_list)

    form = Contact_fileImport(request.user, request.POST or None, request.FILES or None)
    csv_data = ''
    msg = ''
    error_msg = ''
    success_import_list = []
    type_error_import_list = []
    contact_cnt = 0
    bulk_record = []

    if form.is_valid():
        # col_no - field name
        #  0     - contact
        #  1     - last_name
        #  2     - first_name
        #  3     - email
        #  4     - description
        #  5     - status
        #  6     - address
        #  7     - city
        #  8     - country
        #  9     - country
        # 10     - unit_number
        # 11     - additional_vars
        # To count total rows of CSV file
        records = csv.reader(request.FILES['csv_file'], delimiter='|', quotechar='"')
        total_rows = len(list(records))
        BULK_SIZE = 1000
        csv_data = csv.reader(request.FILES['csv_file'], delimiter='|', quotechar='"')
        # Get Phonebook Obj
        phonebook = get_object_or_404(Phonebook, pk=request.POST['phonebook'], user=request.user)
        # Read each Row
        for row in csv_data:
            row = striplist(row)
            if not row or str(row[0]) == 0:
                continue

            # Check field type
            if not int(row[5]):
                error_msg = _("invalid value for import! please check the import samples or phonebook is not valid")
                type_error_import_list.append(row)
                break

            if len(row[9]) > 2:
                error_msg = _("invalid value for country code, it needs to be a valid ISO 3166-1 alpha-2 codes")
                type_error_import_list.append(row)
                break

            row_11 = ''
            if row[11]:
                try:
                    row_11 = json.loads(row[11])
                except:
                    row_11 = ''

            bulk_record.append(
                Contact(
                    phonebook=phonebook,
                    contact=row[0],
                    last_name=row[1],
                    first_name=row[2],
                    email=row[3],
                    description=row[4],
                    status=int(row[5]),
                    address=row[6],
                    city=row[7],
                    state=row[8],
                    country=row[9],  # Note: country needs to be a country code (CA, ES)
                    unit_number=row[10],
                    additional_vars=row_11)
            )

            contact_cnt = contact_cnt + 1

            if contact_cnt < 100:
                # We want to display only 100 lines of the success import
                success_import_list.append(row)

            if contact_cnt % BULK_SIZE == 0:
                # Bulk insert
                Contact.objects.bulk_create(bulk_record)
                bulk_record = []

        # remaining record
        Contact.objects.bulk_create(bulk_record)
        bulk_record = []

    # check if there is contact imported
    if contact_cnt > 0:
        msg = _('%(contact_cnt)s contact(s) have been uploaded successfully out of %(total_rows)s row(s)!') \
            % {'contact_cnt': contact_cnt, 'total_rows': total_rows}

    data = {
        'form': form,
        'csv_data': csv_data,
        'msg': msg,
        'error_msg': error_msg,
        'success_import_list': success_import_list,
        'type_error_import_list': type_error_import_list,
    }
    return render_to_response('dialer_contact/contact/import_contact.html',
                              data, context_instance=RequestContext(request))

Example 102

Project: repowatcher Source File: authed.py
@login_required
def authed_owned(request):
    repo_link_type, _ = LinkType.objects.get_or_create(name = "owned")
    repositories_by_language = defaultdict(list)
    github_repositories_by_language = defaultdict(list)
    bitbucket_repositories_by_language = defaultdict(list)
    bitbucket_authed = True
    github_authed = True
    owned = True
    api_only = True
    user = request.user
    github_username = None
    bitbucket_username = None
    try:
        github_username = user.social_auth.get(provider='github').extra_data['username']
        github_provider = GithubProvider(user)
        github_repositories_by_language, github_repository_user = github_provider.retrieve_repositories_dict(github_username, "owned")
        if len(github_repositories_by_language) == 0:
            owned_repos = github_provider.get_repositories(github_username, "owned")

            count = 0
            for repo in owned_repos:
                update = False
                try:
                    repository = github_provider.retrieve_repository_details(repo['owner'], repo['name'])
                except ObjectDoesNotExist:
                    update = True
                    repository = Repository()
                if update or (datetime.now() - repository.last_modified) > timedelta(days = 1):
                    repository = github_provider.create_or_update_repository_details(repo, repository)
                    if not repository.private:
                        repository.save()
                if not repository.private:
                    count += 1
                    RepositoryUserRepositoryLink.objects.get_or_create(user = github_repository_user, repository = repository, link_type = repo_link_type)

                github_repositories_by_language[repository.language.lower()].append(repository)
            for category in github_repositories_by_language.keys():
                RepositoryCategory.objects.get_or_create(name=category)
                repositories_by_language[category].extend(github_repositories_by_language[category])
            for category in repositories_by_language.keys():
                repositories_by_language[category].sort(key=lambda x: x.watchers, reverse = True)
        else:
            for category in github_repositories_by_language.keys():
                repositories_by_language[category].extend(github_repositories_by_language[category])
    except ObjectDoesNotExist:
        github_authed = False
    try:
        bitbucket_username = user.social_auth.get(provider='bitbucket').extra_data['username']
        bitbucket_provider = BitbucketProvider(user)
        bitbucket_repositories_by_language, bitbucket_repository_user = bitbucket_provider.retrieve_owned_repositories_dict(bitbucket_username)
        if len(bitbucket_repositories_by_language)==0:
            owned_repos = bitbucket_provider.get_owned_repositories(bitbucket_username)
            for repo in owned_repos:
                update = False
                try:
                    repository = bitbucket_provider.retrieve_repository_details(repo['owner'], repo['name'])
                except ObjectDoesNotExist:
                    update = True
                    repository = Repository()
                if update or (datetime.now() - repository.last_modified) > timedelta(days = 1):
                    repository = bitbucket_provider.create_or_update_repository_details(repo, repository)
                    if not repository.private:
                        repository.save()
                bitbucket_repositories_by_language[repository.language].append(repository)
            for category in bitbucket_repositories_by_language.keys():
                RepositoryCategory.objects.get_or_create(name=category)
                repositories_by_language[category].extend(bitbucket_repositories_by_language[category])
            for category in repositories_by_language.keys():
                repositories_by_language[category].sort(key=lambda x: x.watchers, reverse = True)
        else:
            for category in bitbucket_repositories_by_language.keys():
                repositories_by_language[category].extend(bitbucket_repositories_by_language[category])
    except ObjectDoesNotExist:
        bitbucket_authed = False
    if bitbucket_authed or github_authed:
        return render_to_response('username_watched.html', {'github_username': github_username,'github_authed': github_authed,'bitbucket_username':bitbucket_username, 'bitbucket_authed':bitbucket_authed,'repositories_by_language':sorted(dict(repositories_by_language).iteritems(),key=lambda (k, v): len(v),reverse = True),'owned':owned},context_instance=RequestContext(request))
    else:
        return HttpResponseRedirect(reverse('repowatcher.main.views.authed'))

Example 103

Project: django-authority Source File: views.py
@login_required
def add_permission(request, app_label, module_name, pk, approved=False,
                   template_name='authority/permission_form.html',
                   extra_context=None, form_class=UserPermissionForm):
    codename = request.POST.get('codename', None)
    model = get_model(app_label, module_name)
    if model is None:
        return permission_denied(request)
    obj = get_object_or_404(model, pk=pk)
    next = get_next(request, obj)
    if approved:
        if not request.user.has_perm('authority.add_permission'):
            return HttpResponseRedirect(
                url_for_obj('authority-add-permission-request', obj))
        view_name = 'authority-add-permission'
    else:
        view_name = 'authority-add-permission-request'
    if request.method == 'POST':
        if codename is None:
            return HttpResponseForbidden(next)
        form = form_class(data=request.POST, obj=obj, approved=approved,
                          perm=codename, initial=dict(codename=codename))
        if not approved:
            # Limit permission request to current user
            form.data['user'] = request.user
        if form.is_valid():
            form.save(request)
            request.user.message_set.create(
                message=_('You added a permission request.'))
            return HttpResponseRedirect(next)
    else:
        form = form_class(obj=obj, approved=approved, perm=codename,
                          initial=dict(codename=codename))
    context = {
        'form': form,
        'form_url': url_for_obj(view_name, obj),
        'next': next,
        'perm': codename,
        'approved': approved,
    }
    if extra_context:
        context.update(extra_context)
    return render_to_response(template_name, context,
                              context_instance=RequestContext(request))

Example 104

Project: wikicoding Source File: decorators.py
def get_article(func=None, can_read=True, can_write=False, 
                 deleted_contents=False, not_locked=False,
                 can_delete=False, can_moderate=False,
                 can_create=False):
    """View decorator for processing standard url keyword args: Intercepts the 
    keyword args path or article_id and looks up an article, calling the decorated 
    func with this ID.
    
    Will accept a func(request, article, *args, **kwargs)
    
    NB! This function will redirect if an article does not exist, permissions
    are missing or the article is deleted.
    
    Arguments:
    
    can_read=True and/or can_write=True: Check that the current request.user
    has correct permissions.
    
    can_delete and can_moderate: Verifies with wiki.core.permissions
    
    can_create: Same as can_write but adds an extra global setting for anonymous access (ANONYMOUS_CREATE)

    deleted_contents=True: Do not redirect if the article has been deleted.
    
    not_locked=True: Return permission denied if the article is locked
    
    Also see: wiki.views.mixins.ArticleMixin 
    """
    
    def wrapper(request, *args, **kwargs):
        from . import models

        path = kwargs.pop('path', None)
        article_id = kwargs.pop('article_id', None)
        language = kwargs.pop('language', '_')
                
        urlpath = None
        
        # fetch by urlpath.path
        if not path is None:
            try:
                urlpath = models.URLPath.get_by_path(path=path, language=language, select_related=True)
            except NoRootURL:
                return redirect('wiki:root_create')
            except models.URLPath.DoesNotExist:
                try:
                    pathlist = list(filter(lambda x: x!="", path.split("/"),))
                    path = "/".join(pathlist[:-1])
                    parent = models.URLPath.get_by_path(path=path, language=language)
                    return HttpResponseRedirect(reverse("wiki:create", kwargs={'language': language, 'path': parent.path}) + "?slug=%s" % pathlist[-1])
                except models.URLPath.DoesNotExist:
                    c = RequestContext(request, {'error_type' : 'ancestors_missing'})
                    return HttpResponseNotFound(render_to_string("wiki/error.html", context_instance=c))
            if urlpath.article:
                # urlpath is already smart about prefetching items on article (like current_revision), so we don't have to
                article = urlpath.article
            else:
                # Be robust: Somehow article is gone but urlpath exists... clean up
                return_url = reverse('wiki:get', kwargs={'path': urlpath.parent.path})
                urlpath.delete()
                return HttpResponseRedirect(return_url)
        
        
        # fetch by article.id
        elif article_id:
            #TODO We should try to grab the article form URLPath so the caching is good, and fall back to grabbing it from Article.objects if not
            articles = models.Article.objects
            
            article = get_object_or_404(articles, id=article_id)
            try:
                urlpath = models.URLPath.objects.get(articles__article=article)
            except models.URLPath.DoesNotExist as noarticle:
                models.URLPath.MultipleObjectsReturned = noarticle
                urlpath = None
        
        
        else:
            raise TypeError('You should specify either article_id or path')
        
        if not deleted_contents:    
            # If the article has been deleted, show a special page.        
            if urlpath:
                if urlpath.is_deleted(): # This also checks all ancestors
                    return redirect('wiki:deleted', path=urlpath.path)
            else:
                if article.current_revision and article.current_revision.deleted:
                    return redirect('wiki:deleted', article_id=article.id)
        
        
        if article.current_revision.locked and not_locked:
            return response_forbidden(request, article, urlpath)

        if can_read and not article.can_read(request.user):
            return response_forbidden(request, article, urlpath)
        
        if (can_write or can_create) and not article.can_write(request.user):
            return response_forbidden(request, article, urlpath)

        if can_create and not (request.user.is_authenticated() or settings.ANONYMOUS_CREATE):
            return response_forbidden(request, article, urlpath)
        
        if can_delete and not article.can_delete(request.user):
            return response_forbidden(request, article, urlpath)
            
        if can_moderate and not article.can_moderate(request.user):
            return response_forbidden(request, article, urlpath)
        
        kwargs['urlpath'] = urlpath
        
        return func(request, article, *args, **kwargs)
    
    if func:
        return wrapper
    else:
        return lambda func: get_article(func, can_read=can_read, can_write=can_write, 
                                        deleted_contents=deleted_contents,
                                        not_locked=not_locked,can_delete=can_delete,
                                        can_moderate=can_moderate, can_create=can_create)

Example 105

Project: julython.org Source File: views.py
Function: edit_profile
@login_required
def edit_profile(request, username, template_name='people/edit.html'):
    from forms import EditUserForm
    user = request.user

    if user.username != request.user.username:
        http403 = HttpResponse("This ain't you!")
        http403.status = 403
        return http403

    form = EditUserForm(request.POST or None, user=request.user)

    if form.is_valid():
        for key, value in form.cleaned_data.iteritems():
            if key in ['gittip']:
                continue
            if key in ['email']:
                # send verification email
                domain = get_current_site(request).domain
                if value is not None:
                    send_verify_email(value, user.pk, domain)
                # Don't actually add email to user model.
                continue
            if key == 'team':
                # slugify the team to allow easy lookups
                setattr(user, 'team_slug', slugify(value))
            setattr(user, key, value)
        user.save()

        return HttpResponseRedirect(
            reverse('member-profile', kwargs={'username': user.username}))

    ctx = {
        'form': form,
        'profile': user,
        'active': 'edit',
    }
    return render(request, template_name,
                  ctx, context_instance=RequestContext(request))

Example 106

Project: django-addressbook Source File: views.py
Function: edit_contact
@login_required
def edit_contact(request, pk):
    contact = Contact.objects.get(pk=pk)
    if contact.group.user != request.user:
        return HttpResponse(contact.group.user.username + request.user.username)
        #raise Http404
    if request.method == "POST":
        contact_form = ContactForm(request.POST, instance = contact, user = request.user)
        phone_formset = PhoneEditFormSet(request.POST, instance = contact, prefix="phone")
        address_formset = AddressEditFormSet(request.POST, instance = contact, prefix="address")
        email_formset = EmailEditFormSet(request.POST, instance = contact, prefix="email")
        website_formset = WebsiteEditFormSet(request.POST, instance = contact, prefix="website")
        if (contact_form.is_valid() and email_formset.is_valid() and
                address_formset.is_valid() and phone_formset.is_valid() and
                website_formset.is_valid()):
            contact_form.save()
            email_formset.save()
            address_formset.save()
            phone_formset.save()
            website_formset.save()
            return HttpResponseRedirect(reverse('addressbook_index'))
    else:
        contact_form = ContactForm(instance=contact, user=request.user)
        phone_formset = PhoneEditFormSet(instance = contact, prefix="phone")
        address_formset = AddressEditFormSet(instance = contact, prefix="address")
        email_formset = EmailEditFormSet(instance = contact, prefix="email")
        website_formset = WebsiteEditFormSet(instance = contact, prefix="website")
    return render(request, 'addressbook/edit_contact.html',
            RequestContext(request, {
                'email_formset':email_formset, 'phone_formset':phone_formset,
                'address_formset':address_formset, 'contact_form':contact_form,
                'website_formset':website_formset, 'contact':contact
            }))

Example 107

Project: newfies-dialer Source File: views.py
@permission_required('survey.view_survey_report', login_url='/')
@login_required
def survey_report(request):
    """
    Survey detail report for the logged in user

    **Attributes**:

        * ``template`` - survey/survey_report.html
        * ``form`` - SurveyDetailReportForm

    **Logic Description**:

        * List all survey_report which belong to the logged in user.
    """
    tday = datetime.today()
    from_date = tday.strftime("%Y-%m-%d")
    to_date = tday.strftime("%Y-%m-%d")

    form = SurveyDetailReportForm(request.user, request.POST or None,
                                  initial={'from_date': from_date,
                                           'to_date': to_date})
    survey_result = ''

    survey_cdr_daily_data = {
        'total_data': '',
        'total_duration': '',
        'total_calls': '',
        'total_avg_duration': '',
        'max_duration': '',
    }

    sort_col_field_list = ['starting_date', 'phone_number', 'duration', 'disposition', 'id']
    pag_vars = get_pagination_vars(request, sort_col_field_list, default_sort_field='starting_date')

    survey_id = ''
    action = 'tabs-1'
    campaign_obj = ''
    rows = []
    survey_id = ''
    post_var_with_page = 0
    if form.is_valid():
        post_var_with_page = 1
        # set session var value
        request.session['session_surveycalls_kwargs'] = {}
        request.session['session_survey_cdr_daily_data'] = {}
        # set session var value
        field_list = ['from_date', 'to_date', 'survey_id']
        unset_session_var(request, field_list)

        from_date = getvar(request, 'from_date')
        to_date = getvar(request, 'to_date')
        start_date = ceil_strdate(str(from_date), 'start')
        end_date = ceil_strdate(str(to_date), 'end')

        converted_start_date = start_date.strftime('%Y-%m-%d')
        converted_end_date = end_date.strftime('%Y-%m-%d')
        request.session['session_start_date'] = converted_start_date
        request.session['session_end_date'] = converted_end_date

        survey_id = getvar(request, 'survey_id', setsession=True)

    if request.GET.get('page') or request.GET.get('sort_by'):
        post_var_with_page = 1
        start_date = request.session.get('session_start_date')
        end_date = request.session.get('session_end_date')
        start_date = ceil_strdate(start_date, 'start')
        end_date = ceil_strdate(end_date, 'end')
        survey_id = request.session.get('session_survey_id')

        form = SurveyDetailReportForm(request.user, initial={'from_date': start_date.strftime('%Y-%m-%d'),
                                                             'to_date': end_date.strftime('%Y-%m-%d'),
                                                             'survey_id': survey_id})
    if post_var_with_page == 0:
        # default
        # unset session var
        tday = datetime.utcnow().replace(tzinfo=utc)
        from_date = tday.strftime('%Y-%m-01')
        last_day = ((datetime(tday.year, tday.month, 1, 23, 59, 59, 999999).replace(tzinfo=utc) +
                     relativedelta(months=1)) -
                    relativedelta(days=1)).strftime('%d')
        to_date = tday.strftime('%Y-%m-' + last_day)
        start_date = ceil_strdate(from_date, 'start')
        end_date = ceil_strdate(to_date, 'end')

        # unset session var value
        request.session['session_from_date'] = from_date
        request.session['session_to_date'] = to_date
        request.session['session_survey_id'] = ''
        request.session['session_surveycalls_kwargs'] = ''

    kwargs = {}
    if not request.user.is_superuser:
        kwargs['user'] = request.user
    kwargs['disposition__exact'] = CALL_DISPOSITION.ANSWER

    survey_result_kwargs = {}

    if start_date and end_date:
        kwargs['starting_date__range'] = (start_date, end_date)
        survey_result_kwargs['created_date__range'] = (start_date, end_date)
    if start_date and end_date == '':
        kwargs['starting_date__gte'] = start_date
        survey_result_kwargs['created_date__gte'] = start_date
    if start_date == '' and end_date:
        kwargs['starting_date__lte'] = end_date
        survey_result_kwargs['created_date__lte'] = end_date

    all_call_list = []
    try:
        survey_result_kwargs['survey_id'] = survey_id
        survey_result = get_survey_result(survey_result_kwargs)

        campaign_obj = Survey.objects.get(id=int(survey_id)).campaign
        kwargs['callrequest__campaign'] = campaign_obj

        # List of Survey VoIP call report
        voipcall_list = VoIPCall.objects.filter(**kwargs)
        request.session['session_surveycalls_kwargs'] = kwargs
        all_call_list = voipcall_list.values_list('id', flat=True)

        # Get daily report from session while using pagination & sorting
        if request.GET.get('page') or request.GET.get('sort_by'):
            survey_cdr_daily_data = request.session['session_survey_cdr_daily_data']
            action = 'tabs-2'
        else:
            survey_cdr_daily_data = survey_cdr_daily_report(voipcall_list)
            request.session['session_survey_cdr_daily_data'] = survey_cdr_daily_data

        rows = voipcall_list.order_by(pag_vars['sort_order'])[pag_vars['start_page']:pag_vars['end_page']]
    except:
        rows = []
        if request.method == 'POST':
            request.session["err_msg"] = _('no campaign attached with survey.')

    data = {
        'rows': rows,
        'all_call_list': all_call_list,
        'call_count': all_call_list.count() if all_call_list else 0,
        'SURVEY_CALL_RESULT_NAME': SURVEY_CALL_RESULT_NAME,
        'col_name_with_order': pag_vars['col_name_with_order'],
        'total_data': survey_cdr_daily_data['total_data'],
        'total_duration': survey_cdr_daily_data['total_duration'],
        'total_calls': survey_cdr_daily_data['total_calls'],
        'total_avg_duration': survey_cdr_daily_data['total_avg_duration'],
        'max_duration': survey_cdr_daily_data['max_duration'],
        'msg': request.session.get('msg'),
        'err_msg': request.session.get('err_msg'),
        'form': form,
        'survey_result': survey_result,
        'action': action,
        'start_date': start_date,
        'end_date': end_date,
        'campaign_obj': campaign_obj,
    }
    request.session['msg'] = ''
    request.session['err_msg'] = ''
    return render_to_response('survey/survey_report.html', data, context_instance=RequestContext(request))

Example 108

Project: aemanager Source File: views.py
@settings_required
@subscription_required
def index(request):
    if settings.DEMO:
        messages.warning(request, _("You're currently using the demo version. Data are reset every %i hours. Stroke links are disabled features.") % (settings.DEMO_RESET_DELAY))

    user = request.user
    profile = user.get_profile()

    if not Proposal.objects.filter(owner=user).count():
        messages.info(request, _('How-to : create a customer, a project, a proposal and finally an invoice'))

    last_subscription = profile.get_last_subscription()
    delay_before_end_of_subscription = last_subscription.expiration_date - datetime.date.today()
    if delay_before_end_of_subscription.days <= 30:
        subscription_message = ''
        subscription_state = last_subscription.state
        if subscription_state == SUBSCRIPTION_STATE_TRIAL:
            subscription_message = _("Your trial ends in %(days)d days, if you want to keep using %(site_name)s don't forget to subscribe") % {'days': delay_before_end_of_subscription.days,
                                                                                                                                                     'site_name': Site.objects.get_current().name}
        elif subscription_state == SUBSCRIPTION_STATE_PAID:
            subscription_message = _("Your subscription ends in %(days)d days, if you want to keep using %(site_name)s don't forget to renew it") % {'days': delay_before_end_of_subscription.days,
                                                                                                                                                     'site_name': Site.objects.get_current().name}
        if subscription_message:
            messages.warning(request, subscription_message)

    today = datetime.date.today()
    one_year_back = datetime.date(today.year - 1, today.month, today.day)
    first_year = True
    if one_year_back.year >= profile.creation_date.year:
        first_year = False

    service_paid = 0
    service_waiting = 0
    service_to_be_invoiced = 0
    service_limit = 0
    service_paid_previous_year = 0
    service_limit_previous_year = 0
    service_remaining = 0

    paid = Invoice.objects.get_paid_sales(owner=user)

    if not first_year:
        paid_previous_year = Invoice.objects.get_paid_sales(owner=user,
                                                            reference_date=datetime.date(one_year_back.year, 12, 31))
    waiting = Invoice.objects.get_waiting_payments(owner=user)
    to_be_invoiced = Invoice.objects.get_to_be_invoiced(owner=user)
    limit = profile.get_sales_limit()
    remaining = limit - paid - waiting - to_be_invoiced
    sales_limit = profile.get_sales_limit()
    sales_limit2 = profile.get_sales_limit2()

    if user.get_profile().activity == AUTOENTREPRENEUR_ACTIVITY_PRODUCT_SALE_BIC:
        service_waiting = Invoice.objects.get_waiting_service_payments(owner=user)
        service_to_be_invoiced = Invoice.objects.get_service_to_be_invoiced(owner=user)
        service_limit = profile.get_service_sales_limit()
        service_paid = Invoice.objects.get_paid_service_sales(owner=user)
        service_remaining = service_limit - service_paid - service_waiting - service_to_be_invoiced
    if not first_year:
        limit_previous_year = profile.get_sales_limit(year=one_year_back.year)
        if user.get_profile().activity == AUTOENTREPRENEUR_ACTIVITY_PRODUCT_SALE_BIC:
            service_limit_previous_year = profile.get_service_sales_limit(year=one_year_back.year)
            service_paid_previous_year = Invoice.objects.get_paid_service_sales(owner=user, year=one_year_back.year)

    if not first_year and paid_previous_year > limit_previous_year:
        messages.warning(request, _('You will leave the Auto-entrepreneur status at the end of the current year.'))
        if profile.creation_help:
            messages.warning(request, _('You lose tax rates associated with creation help for overrunning sales.'))
        if profile.freeing_tax_payment:
            messages.warning(request, _('You lose freeing tax payment.'))
    else:
        if paid > sales_limit:
            if paid > sales_limit2:
                messages.warning(request, _('You will leave the Auto-entrepreneur status at the end of the current year.'))
            else:
                messages.warning(request, _('You will leave the Auto-entrepreneur status at the end of the next year.'))
            if profile.creation_help:
                messages.warning(request, _('You lose tax rates associated with creation help for overrunning sales.'))
            if profile.freeing_tax_payment:
                messages.warning(request, _('You lose freeing tax payment.'))
        elif remaining < 0:
            if remaining < (sales_limit - sales_limit2):
                messages.warning(request, _('Attention, you will leave the Auto-entrepreneur status at the end of the current year if all your proposals and invoices are paid before the end of the year.'))
            else:
                messages.warning(request, _('Attention, you will leave the Auto-entrepreneur status at the end of the next year if all your proposals and invoices are paid before the end of the year.'))
            if profile.creation_help:
                messages.warning(request, _('Attention, you will lose tax rates associated with creation help for overrunning sales if all your proposals and invoices are paid before the end of the year.'))
            if profile.freeing_tax_payment:
                messages.warning(request, _('Attention, you will lose freeing tax payment if all your proposals and invoices are paid before the end of the year.'))

    if remaining < (sales_limit - sales_limit2):
        messages.warning(request, _('You have to declare VAT from the first month of overrun.'))

    late_invoices = Invoice.objects.get_late_invoices(owner=user)
    invoices_to_send = Invoice.objects.get_invoices_to_send(owner=user)
    potential = Proposal.objects.get_potential_sales(owner=user)
    duration = Proposal.objects.get_potential_duration(owner=user)
    proposals_to_send = Proposal.objects.get_proposals_to_send(owner=user)

    min_date = Invoice.objects.get_first_invoice_paid_date(owner=user)
    if not min_date:
        chart_begin_date = today
    elif min_date < one_year_back:
        chart_begin_date = one_year_back
    else:
        chart_begin_date = min_date
    invoices = Invoice.objects.get_paid_invoices(user, begin_date=chart_begin_date)
    sales_progression = []
    last = 0.0
    for invoice in invoices:
        amount = last + float(invoice.amount)
        sales_progression.append([int(time.mktime(invoice.paid_date.timetuple())*1000), last])
        sales_progression.append([int(time.mktime(invoice.paid_date.timetuple())*1000), amount])
        last = amount

    sales_progression.append([int(time.mktime(today.timetuple())*1000), last])

    waiting_progression = []
    waiting_progression.append([int(time.mktime(today.timetuple())*1000), last])
    waiting_invoices = Invoice.objects.get_waiting_invoices(owner=user)
    for invoice in waiting_invoices:
        amount = last + float(invoice.amount)
        payment_date = invoice.payment_date
        if payment_date < today:
            payment_date = today
        waiting_progression.append([int(time.mktime(payment_date.timetuple())*1000), last])
        waiting_progression.append([int(time.mktime(payment_date.timetuple())*1000), amount])
        last = amount

    # adding ten days to see last waiting invoice
    if waiting_progression:
        waiting_progression.append([int((waiting_progression[-1][0] + 86400 * 10 * 1000)), waiting_progression[-1][1]])

    expenses_progression = []
    last = 0.0
    for expense in Expense.objects.filter(date__gte=chart_begin_date,
                                          owner=user).order_by(('date')):
        amount = last + float(expense.amount)
        expenses_progression.append([int(time.mktime(expense.date.timetuple())*1000), last])
        expenses_progression.append([int(time.mktime(expense.date.timetuple())*1000), amount])
        last = amount

    expenses_progression.append([int(time.mktime(today.timetuple())*1000), last])

    profit_progression = []
    if len(sales_progression) and len(expenses_progression):
        invoice_counter = 0
        expense_counter = 0
        current_invoice = None
        current_expense = None
        invoice_amount = 0.0
        expense_amount = 0.0
        while invoice_counter < len(sales_progression) and expense_counter < len(expenses_progression):
            current_invoice = sales_progression[invoice_counter]
            current_expense = expenses_progression[expense_counter]
            if current_invoice[0] < current_expense[0]:
                invoice_amount = current_invoice[1]
                if profit_progression:
                    profit_progression.append([current_invoice[0], profit_progression[-1][1]])
                profit_progression.append([current_invoice[0], invoice_amount - expense_amount])
                invoice_counter = invoice_counter + 1
            else:
                expense_amount = current_expense[1]
                if profit_progression:
                    profit_progression.append([current_expense[0], profit_progression[-1][1]])
                profit_progression.append([current_expense[0], invoice_amount - expense_amount])
                expense_counter = expense_counter + 1

    sales = {'paid': paid,
             'service_paid': service_paid,
             'waiting': waiting,
             'service_waiting': service_waiting,
             'to_be_invoiced': to_be_invoiced,
             'service_to_be_invoiced': service_to_be_invoiced,
             'total': paid + waiting + to_be_invoiced,
             'service_total': service_paid + service_waiting + service_to_be_invoiced,
             'limit': limit,
             'service_limit': service_limit,
             'remaining': remaining,
             'service_remaining': service_remaining}

    sales_previous_year = None
    if not first_year:
        sales_previous_year = {'paid': paid_previous_year,
                               'service_paid': service_paid_previous_year,
                               'limit': limit_previous_year,
                               'service_limit': service_limit_previous_year,
                               'remaining': limit_previous_year - paid_previous_year,
                               'service_remaining': service_limit_previous_year - service_paid_previous_year}

    invoices = {'late': late_invoices,
                'to_send': invoices_to_send}

    percentage_of_remaining = 0
    if sales['remaining']:
        percentage_of_remaining = potential * 100 / sales['remaining']

    average_unit_price = 0
    if duration:
        average_unit_price = potential / duration

    prospects = {'potential_sales': potential,
                 'percentage_of_remaining': percentage_of_remaining,
                 'duration': duration,
                 'average_unit_price': average_unit_price,
                 'proposals_to_send': proposals_to_send}

    taxes = profile.get_tax_data(today)
    if taxes['period_begin'] == profile.creation_date:
        previous_taxes = None
    else:
        previous_taxes = profile.get_tax_data(taxes['period_begin'] - datetime.timedelta(1))
    next_taxes = profile.get_tax_data(taxes['tax_due_date'] + datetime.timedelta(1))

    charts = {'sales_progression':simplejson.dumps(sales_progression),
              'waiting_progression':simplejson.dumps(waiting_progression),
              'expenses_progression':simplejson.dumps(expenses_progression),
              'profit_progression':simplejson.dumps(profit_progression)}

    announcements = Announcement.objects.filter(enabled=True, important=False)
    important_announcements = Announcement.objects.filter(enabled=True, important=True)
    for important_announcement in important_announcements:
        messages.warning(request, important_announcement.content)

    return render_to_response('core/index.html',
                              {'active': 'dashboard',
                               'title': _('Dashboard'),
                               'announcements': announcements,
                               'sales': sales,
                               'sales_previous_year': sales_previous_year,
                               'years': [today.year, today.year - 1],
                               'invoices': invoices,
                               'prospects': prospects,
                               'taxes': taxes,
                               'previous_taxes': previous_taxes,
                               'next_taxes': next_taxes,
                               'charts': charts},
                              context_instance=RequestContext(request))

Example 109

Project: repowatcher Source File: general.py
@cache_control(max_age=60 * 60 * 24)
def search(request):
    user = request.user
    query = request.GET['query']
    repositories_by_language = defaultdict(list)
    if query != '':
        github_provider = GithubProvider(user)
        if user.is_authenticated():
            try:
                tokens = user.social_auth.get(provider='bitbucket').tokens
                oauth_hook = OAuthHook(tokens['oauth_token'], tokens['oauth_token_secret'], header_auth=False)
                client = requests.session(hooks={'pre_request': oauth_hook})
            except ObjectDoesNotExist:
                client = requests.session()
        else:
            client = requests.session()
        if '/' in query:
            user_query = query.split('/')[0]
            repo_query = query.split('/')[1]
            github_repositories = github_provider.search_repository(repo_query)
            users = github_provider.search_user(user_query)
            try:
                response = client.get('https://api.bitbucket.org/1.0/repositories/',params={'name':repo_query,'limit':100})
                bitbucket_repositories = json.loads(response.text)['repositories'][:100]
            except Exception:
                bitbucket_repositories = []
        else:
            github_repositories = github_provider.search_repository(query)
            users = github_provider.search_user(query)
            try:
                response = client.get('https://api.bitbucket.org/1.0/repositories/',params={'name':query,'limit':100})
                bitbucket_repositories = json.loads(response.text)['repositories'][:100]
            except Exception:
                bitbucket_repositories = []
        for repo in github_repositories:
            update = False
            repo['owner'] = repo['owner'].lower().replace("/", "")
            repo['name'] = repo['name'].lower().replace("/", "")
            try:
                repository = Repository.objects.get(slug= repo['owner'].lower() + '/' + repo['name'], host ='github')
            except ObjectDoesNotExist:
                update = True
                repository = Repository()
            if update or (datetime.now() - repository.last_modified) > timedelta(days = 1):
                repository = github_provider.create_or_update_repository_details(repo, repository)
                if not repository.private:
                    repository.save()
            repositories_by_language[repository.language].append(repository)
        for repo in bitbucket_repositories:
            update = False
            repo['owner'] = repo['owner'].lower().replace("/", "")
            repo['name'] = repo['name'].lower().replace("/", "")
            try:
                repository = Repository.objects.get(slug= repo['owner'] + '/' + repo['name'], host='bitbucket')
            except ObjectDoesNotExist:
                update = True
                repository = Repository()
            if update or (datetime.now() - repository.last_modified) > timedelta(days = 1):
                extra_data = {}
                key_map={'owner':'owner','name':'name', 'website':'homepage','language':'language','description':'description','created_on':'created_at','last_updated':'pushed_at','scm':'scm','is_private':'private'}
                for key,value in repo.iteritems():
                    if key in ['owner','name', 'website','language','description','created_on','last_updated','scm','is_private']:
                        setattr(repository,key_map[key],value)
                    else:
                        extra_data[key] = value
                repository.extra_data = json.dumps(extra_data)
                if repository.language == "" or repository.language == None:
                    repository.language = "other"
                repository.host ='bitbucket'
                if not repository.private:
                    repository.save()
            for category in repositories_by_language.keys():
                RepositoryCategory.objects.get_or_create(name = category)
            repositories_by_language[repository.language].append(repository)
        return render_to_response('search.html', {'repositories_by_language':sorted(dict(repositories_by_language).iteritems(),key=lambda (k, v): len(v),reverse = True), 'users':users},context_instance=RequestContext(request))
    else:
        return render_to_response('search.html', {'repositories_by_language':{}, 'users':[]},context_instance=RequestContext(request))

Example 110

Project: aemanager Source File: views.py
@settings_required
@subscription_required
@commit_on_success
def proposal_create_or_edit(request, id=None, project_id=None):
    user = request.user
    if id:
        title = _('Edit a proposal')
        proposal = get_object_or_404(Proposal, pk=id, owner=request.user)
        old_file = proposal.contract_file
        project = proposal.project
    else:
        title = _('Add a proposal')
        proposal = None
        old_file = None
        project = get_object_or_404(Project, pk=project_id, owner=request.user)

    ProposalRowFormSet = inlineformset_factory(Proposal,
                                               ProposalRow,
                                               form=ProposalRowForm,
                                               fk_name="proposal",
                                               extra=1)

    proposals = Proposal.objects.filter(owner=request.user).exclude(contract_content='')

    if request.method == 'POST':
        proposalForm = ProposalForm(request.POST, request.FILES, instance=proposal, prefix="proposal")
        proposalForm.fields['contract_model'].queryset = proposals
        proposalrowformset = ProposalRowFormSet(request.POST, instance=proposal)
        if proposalForm.is_valid() and proposalrowformset.is_valid():
            if request.FILES:
                try:
                    if old_file:
                        if os.path.exists(old_file.path):
                            os.remove(old_file.path)
                except:
                    pass
            try:
                proposal = proposalForm.save(commit=False)
                proposal.project = project
                proposal.update_date = datetime.datetime.now()
                proposal.save(user=user)

                proposalForm.save_m2m()
                for proposalrowform in proposalrowformset.forms:
                    if proposalrowform not in proposalrowformset.deleted_forms and proposalrowform.cleaned_data:
                        proposalrow = proposalrowform.save(commit=False)
                        proposalrow.proposal = proposal
                        proposalrow.save(user=user)

                for deleted_proposalrowform in proposalrowformset.deleted_forms:
                    deleted_proposalrowform.instance.delete()

                proposal.update_amount()

                messages.success(request, _('The proposal has been saved successfully'))
                if proposal.begin_date and proposal.end_date and proposal.begin_date > proposal.end_date:
                    messages.warning(request, _("Begin date is greater than end date, is this normal ?"))
                if proposal.expiration_date and proposal.expiration_date < datetime.date.today() and proposal.state < PROPOSAL_STATE_SENT:
                    messages.warning(request, _("Expiration date is in the past while the proposal is not yet sent, is this normal ?"))
                return redirect(reverse('proposal_detail', kwargs={'id': proposal.id}))
            except ProposalAmountError:
                rollback()
                messages.error(request, _("Proposal amount can't be less than sum of invoices"))
        else:
            messages.error(request, _('Data provided are invalid'))
    else:
        proposalForm = ProposalForm(instance=proposal, prefix="proposal")
        proposalForm.fields['contract_model'].queryset = proposals
        proposalrowformset = ProposalRowFormSet(instance=proposal)

    substitution_map = Proposal.get_substitution_map()
    substitution_keys = substitution_map.keys()
    keys = ''
    if len(substitution_keys):
        keys = "{{ " + " }}, {{ ".join(substitution_keys) + " }}"

    return render_to_response('proposal/edit.html',
                              {'active': 'business',
                               'title': title,
                               'proposalForm': proposalForm,
                               'proposalrowformset': proposalrowformset,
                               'substitution_keys': keys},
                               context_instance=RequestContext(request))

Example 111

Project: django-frontend-notification Source File: views.py
@login_required
def notification_list(request):
    """User Detail change on Customer UI

    **Attributes**:

        * ``form`` - UserChangeDetailForm, UserChangeDetailExtendForm,
                        PasswordChangeForm, CheckPhoneNumberForm
        * ``template`` - 'frontend/frontend_notification/user_notification.html'

    **Logic Description**:

        * User is able to change his/her detail.
    """
    sort_col_field_list = ['description', 'verb', 'level', 'timestamp']
    coltitle = {
        'description': _("Description"),
        'verb': _("Verb"),
        'level': _("Level"),
        'timestamp': _("Date"),
    }
    pag_vars = get_pagination_vars(request, sort_col_field_list, default_sort_field='id')
    form = NotificationForm(request.POST or None, initial={'notification_list': NOTICE_TYPE.ALL})

    # TODO: rename notification_list to type_filter
    notification_list = NOTICE_TYPE.ALL
    post_var_with_page = 0
    if form.is_valid():
        request.session['session_notification_list'] = ''
        post_var_with_page = 1

        if request.POST.get('notification_list'):
            notification_list = request.POST.get('notification_list')
            request.session['session_notification_list'] = notification_list

    if request.GET.get('page') or request.GET.get('sort_by'):
        post_var_with_page = 1
        notification_list = request.session.get('session_notification_list')
        form = NotificationForm(initial={'notification_list': notification_list})

    notification_list = int(notification_list)

    if post_var_with_page == 0:
        # unset session var
        request.session['session_notification_list'] = ''

    kwargs = {}
    # kwargs['sender'] = request.user
    if notification_list == NOTICE_TYPE.UNREAD:
        kwargs['unread'] = True

    if notification_list == NOTICE_TYPE.READ:
        kwargs['unread'] = False

    user_notification = Notification.objects.filter(recipient=request.user)
    if kwargs:
        user_notification = user_notification.filter(**kwargs)

    all_user_notification = user_notification.order_by(pag_vars['sort_order'])
    user_notification = all_user_notification[pag_vars['start_page']:pag_vars['end_page']]
    user_notification_count = all_user_notification.count()

    msg_note = ''
    if request.GET.get('msg_note') == 'true':
        msg_note = request.session['msg_note']

    # Mark all notification as read
    if request.GET.get('notification') == 'mark_read_all':
        notification_list = Notification.objects.filter(unread=True, recipient=request.user)
        notification_list.update(unread=False)
        msg_note = _('all notifications are marked as read.')

    data = {
        'coltitle': coltitle,
        'form': form,
        'msg_note': msg_note,
        'all_user_notification': all_user_notification,
        'user_notification': user_notification,
        'user_notification_count': user_notification_count,
        'col_name_with_order': pag_vars['col_name_with_order'],
    }
    return render_to_response(
        'frontend/frontend_notification/user_notification.html', data, context_instance=RequestContext(request))

Example 112

Project: django-hvad Source File: admin.py
    @csrf_protect_m
    @transaction.atomic
    def delete_translation(self, request, object_id, language_code):
        "The 'delete translation' admin view for this model."
        opts = self.model._meta
        app_label = opts.app_label
        translations_model = opts.translations_model
        
        try:
            obj = translations_model.objects.select_related('master').get(
                                                master__pk=unquote(object_id),
                                                language_code=language_code)
        except translations_model.DoesNotExist:
            raise Http404

        if not self.has_delete_permission(request, obj):
            raise PermissionDenied
        
        if len(self.get_available_languages(obj.master)) <= 1:
            return self.deletion_not_allowed(request, obj, language_code)

        using = router.db_for_write(translations_model)

        # Populate deleted_objects, a data structure of all related objects that
        # will also be deleted.
        
        protected = False
        if django.VERSION >= (1, 8):
            deleted_objects, model_count, perms_needed, protected = get_deleted_objects(
                [obj], translations_model._meta, request.user, self.admin_site, using)
        else:
            deleted_objects, perms_needed, protected = get_deleted_objects(
                [obj], translations_model._meta, request.user, self.admin_site, using)
        
        lang = get_language_name(language_code) 
            

        if request.POST: # The user has already confirmed the deletion.
            if perms_needed:
                raise PermissionDenied
            obj_display = u'%s translation of %s' % (force_text(lang), force_text(obj.master))
            self.log_deletion(request, obj, obj_display)
            self.delete_model_translation(request, obj)

            self.message_user(request,
                _(u'The %(name)s "%(obj)s" was deleted successfully.') % {
                    'name': force_text(opts.verbose_name),
                    'obj': force_text(obj_display)
                }
            )

            if not self.has_change_permission(request, None):
                return HttpResponseRedirect(self.reverse('admin:index'))
            return HttpResponseRedirect(self.reverse('admin:%s_%s_changelist' % (opts.app_label, opts.model_name)))

        object_name = _(u'%s Translation') % force_text(opts.verbose_name)

        if perms_needed or protected:
            title = _(u"Cannot delete %(name)s") % {"name": object_name}
        else:
            title = _(u"Are you sure?")

        context = {
            "title": title,
            "object_name": object_name,
            "object": obj,
            "deleted_objects": deleted_objects,
            "perms_lacking": perms_needed,
            "protected": protected,
            "opts": opts,
            "app_label": app_label,
        }

        return render_to_response(self.delete_confirmation_template or [
            "admin/%s/%s/delete_confirmation.html" % (app_label, opts.object_name.lower()),
            "admin/%s/delete_confirmation.html" % app_label,
            "admin/delete_confirmation.html"
        ], context, RequestContext(request))

Example 113

Project: ganetimgr Source File: __init__.py
@csrf_exempt
@login_required
def tagInstance(request, instance):
    '''
    Set a new instance tag, or delete a tag.
    '''
    try:
        # get instance
        instance = Instance.objects.get(name=instance)
    except ObjectDoesNotExist:
        raise Http404()

    # get cluster
    cluster = instance.cluster

    # get cache key
    cache_key = "cluster:%s:instance:%s:user:%s" % (
        cluster.slug, instance.name,
        request.user.username
    )
    # check if the object has been cached
    res = cache.get(cache_key)
    if res is None:
        # if not, we must see if the user requested
        # the change, has permissions to do so.
        res = False
        if (
            request.user.is_superuser or
            request.user in instance.users or
            set.intersection(
                set(request.user.groups.all()),
                set(instance.groups)
            )
        ):
            res = True
        cache.set(cache_key, res, 90)
        if not res:
            t = get_template("403.html")
            return HttpResponseForbidden(content=t.render(RequestContext(request)))

    if request.method == 'POST':
        users = []
        for user in instance.users:
            users.append("u_%s" % user.pk)
        groups = []
        for group in instance.groups:
            groups.append("g_%s" % group.pk)
        existingugtags = users + groups
        form = tagsForm(request.POST)
        if form.is_valid():
            newtags = form.cleaned_data['tags']
            newtags = newtags.split(',')
            common = list(set(existingugtags).intersection(set(newtags)))
            deltags = list(set(existingugtags) - set(common))

            if len(deltags) > 0:
                # we have tags to delete
                oldtodelete = prepare_tags(deltags)
                jobid = instance.cluster.untag_instance(instance.name, oldtodelete)
                if not jobid:
                    return HttpResponse(
                        json.dumps(
                            {
                                'result': 'failure',
                                'reason': jobid
                            }
                        ),
                        mimetype='application/json'
                    )
            newtagstoapply = prepare_tags(newtags)

            if len(newtagstoapply) > 0:
                instance.cluster.tag_instance(instance.name, newtagstoapply)

            res = {'result': 'success'}
            return HttpResponse(json.dumps(res), mimetype='application/json')
        else:
            return render(
                request,
                'tagging/itags.html',
                {
                    'form': form,
                    'users': users,
                    'instance': instance
                }
            )
    elif request.method == 'GET':
        form = tagsForm()
        users = []
        for user in instance.users:
            userd = {}
            userd['text'] = user.username
            userd['id'] = "u_%s" % user.pk
            userd['type'] = "user"
            users.append(userd)
        for group in instance.groups:
            groupd = {}
            groupd['text'] = group.name
            groupd['id'] = "g_%s" % group.pk
            groupd['type'] = "group"
            users.append(groupd)
        return render(
            request,
            'tagging/itags.html',
            {
                'form': form,
                'users': users,
                'instance': instance
            }
        )

Example 114

Project: newfies-dialer Source File: views.py
@permission_required('dialer_campaign.view_subscriber', login_url='/')
@login_required
def subscriber_list(request):
    """
    Subscriber list for the logged in user

    **Attributes**:

        * ``template`` - dialer_campaign/subscriber/list.html
        * ``form`` - SubscriberSearchForm

    **Logic Description**:

        * List all subscribers belonging to the logged in user & their campaign
    """
    sort_col_field_list = ['contact', 'updated_date', 'count_attempt', 'completion_count_attempt',
                           'status', 'disposition', 'collected_data', 'agent']
    pag_vars = get_pagination_vars(request, sort_col_field_list, default_sort_field='id')
    form = SubscriberSearchForm(request.user, request.POST or None)
    campaign_id = ''
    agent_id = ''
    status = 'all'
    start_date = end_date = None
    post_var_with_page = 0
    if form.is_valid():
        post_var_with_page = 1
        field_list = ['start_date', 'end_date', 'status', 'campaign_id', 'agent_id']
        unset_session_var(request, field_list)
        campaign_id = getvar(request, 'campaign_id', setsession=True)
        agent_id = getvar(request, 'agent_id', setsession=True)

        from_date = getvar(request, 'from_date')
        to_date = getvar(request, 'to_date')
        start_date = ceil_strdate(str(from_date), 'start')
        end_date = ceil_strdate(str(to_date), 'end')

        converted_start_date = start_date.strftime('%Y-%m-%d')
        converted_end_date = end_date.strftime('%Y-%m-%d')
        request.session['session_start_date'] = converted_start_date
        request.session['session_end_date'] = converted_end_date

        status = getvar(request, 'status', setsession=True)

    if request.GET.get('page') or request.GET.get('sort_by'):
        post_var_with_page = 1
        start_date = request.session.get('session_start_date')
        end_date = request.session.get('session_end_date')

        start_date = ceil_strdate(str(start_date), 'start')
        end_date = ceil_strdate(str(end_date), 'end')

        campaign_id = request.session.get('session_campaign_id')
        agent_id = request.session.get('session_agent_id')
        status = request.session.get('session_status')
        form = SubscriberSearchForm(
            request.user,
            initial={'from_date': start_date.strftime('%Y-%m-%d'),
                     'to_date': end_date.strftime('%Y-%m-%d'),
                     'campaign_id': campaign_id,
                     'agent_id': agent_id,
                     'status': status})

    if post_var_with_page == 0:
        # default
        tday = datetime.utcnow().replace(tzinfo=utc)
        from_date = tday.strftime('%Y-%m-%d')
        to_date = tday.strftime('%Y-%m-%d')
        start_date = datetime(tday.year, tday.month, tday.day, 0, 0, 0, 0).replace(tzinfo=utc)
        end_date = datetime(tday.year, tday.month, tday.day, 23, 59, 59, 999999).replace(tzinfo=utc)

        form = SubscriberSearchForm(request.user, initial={'from_date': from_date, 'to_date': to_date})
        # unset session var
        request.session['session_start_date'] = start_date
        request.session['session_end_date'] = end_date
        request.session['session_status'] = ''
        request.session['session_campaign_id'] = ''
        request.session['session_agent_id'] = ''

    kwargs = {}
    # updated_date might be replaced with last_attempt
    if start_date and end_date:
        kwargs['updated_date__range'] = (start_date, end_date)
    if start_date and end_date == '':
        kwargs['updated_date__gte'] = start_date
    if start_date == '' and end_date:
        kwargs['updated_date__lte'] = end_date

    if campaign_id and campaign_id != '0':
        kwargs['campaign_id'] = campaign_id

    # if agent_id and agent_id != '0':
    #    kwargs['agent_id'] = agent_id

    if status and status != 'all':
        kwargs['status'] = status

    subscriber_list = []
    all_subscriber_list = []
    subscriber_count = 0

    if request.user.is_superuser:
        subscriber_list = Subscriber.objects.all()
    else:
        subscriber_list = Subscriber.objects.filter(campaign__user=request.user)

    if kwargs:
        subscriber_list = subscriber_list.filter(**kwargs)
        request.session['subscriber_list_kwargs'] = kwargs

    all_subscriber_list = subscriber_list.order_by(pag_vars['sort_order'])
    subscriber_list = all_subscriber_list[pag_vars['start_page']:pag_vars['end_page']]
    subscriber_count = all_subscriber_list.count()

    data = {
        'subscriber_list': subscriber_list,
        'all_subscriber_list': all_subscriber_list,
        'total_subscribers': subscriber_count,
        'SUBSCRIBER_COLUMN_NAME': SUBSCRIBER_COLUMN_NAME,
        'col_name_with_order': pag_vars['col_name_with_order'],
        'msg': request.session.get('msg'),
        'error_msg': request.session.get('error_msg'),
        'form': form,
    }
    request.session['msg'] = ''
    request.session['error_msg'] = ''
    return render_to_response('dialer_campaign/subscriber/list.html', data, context_instance=RequestContext(request))

Example 115

Project: aemanager Source File: views.py
@settings_required
@commit_on_success
def backup(request):
    subscription = request.user.get_profile().get_last_subscription()

    backup_request = None
    restore_request = None
    old_file = None
    action_pending = False
    try:
        backup_request = request.user.backuprequest
    except:
        pass

    try:
        restore_request = request.user.restorerequest
        old_file = restore_request.backup_file
    except:
        pass

    if (backup_request and backup_request.state <= BACKUP_RESTORE_STATE_IN_PROGRESS) \
    or (restore_request and restore_request.state <= BACKUP_RESTORE_STATE_IN_PROGRESS):
        action_pending = True

    backup_form = BackupForm(instance=backup_request)
    restore_form = RestoreForm(instance=restore_request)
    csv_form = CSVForm()

    if request.method == 'POST':
        if request.POST.get('backup_or_restore') == 'backup':
            backup_form = BackupForm(request.POST, instance=backup_request)
            if backup_form.is_valid():
                if action_pending:
                    messages.error(request, _("A backup or restore is already scheduled"))
                else:
                    backup_request = backup_form.save(commit=False)
                    backup_request.user = request.user
                    backup_request.state = BACKUP_RESTORE_STATE_PENDING
                    backup_request.creation_datetime = datetime.datetime.now()
                    backup_request.last_state_datetime = backup_request.creation_datetime
                    backup_request.save()
                    position = BackupRequest.objects.filter(state__lte=BACKUP_RESTORE_STATE_IN_PROGRESS).count()
                    messages.info(request, _("Your backup has been scheduled successfully. There are %i other backups before yours.") % (position - 1))
                    return redirect(reverse('backup'))
        elif request.POST.get('backup_or_restore') == 'restore':
            if subscription.state == SUBSCRIPTION_STATE_TRIAL:
                messages.error(request, _("You have to subscribe to restore your backups"))
            else:
                restore_form = RestoreForm(request.POST, request.FILES, instance=restore_request)
                if restore_form.is_valid():
                    if request.FILES:
                        try:
                            if old_file:
                                if os.path.exists(old_file.path):
                                    os.remove(old_file.path)
                        except:
                            pass

                    if action_pending:
                        messages.error(request, _("A backup or restore is already scheduled"))
                    else:
                        restore_request = restore_form.save(commit=False)
                        restore_request.user = request.user
                        restore_request.state = BACKUP_RESTORE_STATE_PENDING
                        restore_request.creation_datetime = datetime.datetime.now()
                        restore_request.last_state_datetime = restore_request.creation_datetime
                        restore_request.save()
                        position = RestoreRequest.objects.filter(state__lte=BACKUP_RESTORE_STATE_IN_PROGRESS).count()
                        messages.info(request, _("Your restore has been scheduled successfully. There are %i other restores before yours.") % (position - 1))
                        return redirect(reverse('backup'))
        else:
            messages.error(request, _("Form data have been tempered"))

    context = {
               'title': _('Backup'),
               'backup_request': backup_request,
               'restore_request': restore_request,
               'backup_form': backup_form,
               'restore_form': restore_form,
               'csv_form': csv_form,
               'action_pending': action_pending,
               'cant_restore': subscription.state == SUBSCRIPTION_STATE_TRIAL
               }
    return render_to_response('backup/index.html',
                              context,
                              context_instance=RequestContext(request))

Example 116

Project: newfies-dialer Source File: views.py
@permission_required('mod_sms.view_sms_dashboard', login_url='/')
@login_required
def sms_dashboard(request, on_index=None):
    """SMS dashboard gives the following information

        * No of SMSCampaigns for logged in user
        * Total phonebook contacts
        * Total SMSCampaigns contacts
        * Amount of contact reached today
        * Disposition of sms via pie chart
        * SMS count shown on graph by days/hours

    **Attributes**:

        * ``template`` - mod_sms/sms_dashboard.html
        * ``form`` - SMSDashboardForm
    """
    # All sms_campaign for logged in User
    sms_campaign_id_list = SMSCampaign.objects.values_list('id', flat=True).filter(user=request.user).order_by('id')

    # Contacts count which are active and belong to those phonebook(s) which is
    # associated with all sms campaign
    pb_active_contact_count = Contact.objects.filter(
        phonebook__smscampaign__in=sms_campaign_id_list,
        status=CONTACT_STATUS.ACTIVE).count()

    form = SMSDashboardForm(request.user, request.POST or None)

    total_record = dict()
    total_sms_count = 0
    total_unsent = 0
    total_sent = 0
    total_delivered = 0
    total_failed = 0
    total_no_route = 0
    total_unauthorized = 0

    select_graph_for = 'sms count'  # default
    search_type = SEARCH_TYPE.D_Last_24_hours  # default Last 24 hours
    selected_sms_campaign = ''

    if sms_campaign_id_list:
        selected_sms_campaign = sms_campaign_id_list[0]  # default sms campaign id

    # selected_sms_campaign should not be empty
    if selected_sms_campaign:

        if form.is_valid():
            selected_sms_campaign = request.POST['smscampaign']
            search_type = request.POST['search_type']

        end_date = datetime.utcnow().replace(tzinfo=utc)
        start_date = calculate_date(search_type)

        # date_length is used to do group by starting_date
        if int(search_type) >= SEARCH_TYPE.B_Last_7_days:  # all options except 30 days
            date_length = 13
            if int(search_type) == SEARCH_TYPE.C_Yesterday:  # yesterday
                now = datetime.utcnow().replace(tzinfo=utc)
                start_date = datetime(now.year, now.month, now.day, 0, 0, 0, 0).replace(tzinfo=utc) \
                    - relativedelta(days=1)
                end_date = datetime(now.year, now.month, now.day, 23, 59, 59, 999999).replace(tzinfo=utc) \
                    - relativedelta(days=1)
            if int(search_type) >= SEARCH_TYPE.E_Last_12_hours:
                date_length = 16
        else:
            date_length = 10  # Last 30 days option

        select_data = {
            "send_date": "SUBSTR(CAST(send_date as CHAR(30)),1," + str(date_length) + ")"}

        # This calls list is used by pie chart
        list_sms = SMSMessage.objects.filter(
            sender=request.user,
            sms_campaign_id=selected_sms_campaign,
            send_date__range=(start_date, end_date))\
            .extra(select=select_data)\
            .values('send_date', 'status')\
            .annotate(Count('send_date'))\
            .order_by('send_date')

        for i in list_sms:
            # convert unicode date string into date
            if i['status'] == 'Unsent':
                total_unsent += i['send_date__count']
            elif i['status'] == 'Sent':
                total_sent += i['send_date__count']
            elif i['status'] == 'Delivered':
                total_delivered += i['send_date__count']
            elif i['status'] == 'Failed':
                total_failed += i['send_date__count']
            elif i['status'] == 'No_Route':
                total_no_route += i['send_date__count']
            else:
                total_unauthorized += i['send_date__count']  # Unauthorized

            total_sms_count += i['send_date__count']

        list_sms = SMSMessage.objects.filter(
            sender=request.user,
            sms_campaign_id=selected_sms_campaign,
            send_date__range=(start_date, end_date))\
            .extra(select=select_data).values('send_date')\
            .annotate(Count('send_date')).order_by('send_date')

        mintime = start_date
        maxtime = end_date
        sms_dict = {}
        sms_dict_with_min = {}

        for data in list_sms:
            if int(search_type) >= SEARCH_TYPE.B_Last_7_days:
                ctime = datetime(int(data['send_date'][0:4]),
                                 int(data['send_date'][5:7]),
                                 int(data['send_date'][8:10]),
                                 int(data['send_date'][11:13]),
                                 0, 0, 0).replace(tzinfo=utc)
                if int(search_type) >= SEARCH_TYPE.E_Last_12_hours:
                    ctime = datetime(int(data['send_date'][0:4]),
                                     int(data['send_date'][5:7]),
                                     int(data['send_date'][8:10]),
                                     int(data['send_date'][11:13]),
                                     int(data['send_date'][14:16]),
                                     0, 0).replace(tzinfo=utc)
            else:
                ctime = datetime(int(data['send_date'][0:4]),
                                 int(data['send_date'][5:7]),
                                 int(data['send_date'][8:10]),
                                 0, 0, 0, 0).replace(tzinfo=utc)
            if ctime > maxtime:
                maxtime = ctime
            elif ctime < mintime:
                mintime = ctime

            # all options except 30 days
            if int(search_type) >= SEARCH_TYPE.B_Last_7_days:
                sms_dict[int(ctime.strftime("%Y%m%d%H"))] = {
                    'sms_count': data['send_date__count']
                }
                sms_dict_with_min[int(ctime.strftime("%Y%m%d%H%M"))] = {
                    'sms_count': data['send_date__count']
                }
            else:
                # Last 30 days option
                sms_dict[int(ctime.strftime("%Y%m%d"))] = {
                    'sms_count': data['send_date__count']
                }

        dateList = date_range(mintime, maxtime, q=search_type)

        i = 0
        total_record = {}
        for date in dateList:
            inttime = int(date.strftime("%Y%m%d"))
            # last 7 days | yesterday | last 24 hrs
            if (int(search_type) == SEARCH_TYPE.B_Last_7_days
                    or int(search_type) == SEARCH_TYPE.C_Yesterday
                    or int(search_type) == SEARCH_TYPE.D_Last_24_hours):

                for option in range(0, 24):
                    day_time = int(str(inttime) + str(option).zfill(2))

                    graph_day = datetime(int(date.strftime("%Y")),
                                         int(date.strftime("%m")),
                                         int(date.strftime("%d")),
                                         int(str(option).zfill(2))).replace(tzinfo=utc)

                    dt = int(1000 * time.mktime(graph_day.timetuple()))
                    total_record[dt] = {'sms_count': 0}

                    if day_time in sms_dict.keys():
                        total_record[dt]['sms_count'] += sms_dict[day_time]['sms_count']

            # last 12 hrs | last 6 hrs | last 1 hrs
            elif (int(search_type) == SEARCH_TYPE.E_Last_12_hours
                  or int(search_type) == SEARCH_TYPE.F_Last_6_hours
                  or int(search_type) == SEARCH_TYPE.G_Last_hour):

                for hour in range(0, 24):
                    for minute in range(0, 60):
                        hr_time = int(str(inttime) + str(hour).zfill(2) + str(minute).zfill(2))

                        graph_day = datetime(int(date.strftime("%Y")),
                                             int(date.strftime("%m")),
                                             int(date.strftime("%d")),
                                             int(str(hour).zfill(2)),
                                             int(str(minute).zfill(2))).replace(tzinfo=utc)

                        dt = int(1000 * time.mktime(graph_day.timetuple()))
                        total_record[dt] = {'sms_count': 0}

                        if hr_time in sms_dict_with_min.keys():
                            total_record[dt]['sms_count'] += sms_dict_with_min[hr_time]['sms_count']

            else:
                # Last 30 days option
                graph_day = datetime(int(date.strftime("%Y")),
                                     int(date.strftime("%m")),
                                     int(date.strftime("%d"))).replace(tzinfo=utc)
                dt = int(1000 * time.mktime(graph_day.timetuple()))
                total_record[dt] = {'sms_count': 0}
                if inttime in sms_dict.keys():
                    total_record[dt]['sms_count'] += sms_dict[inttime]['sms_count']

    # sorting on date col
    total_record = total_record.items()
    total_record = sorted(total_record, key=lambda k: k[0])

    # lineWithFocusChart
    final_charttype = "lineWithFocusChart"
    xdata = []
    ydata = []
    for i in total_record:
        xdata.append(i[0])
        ydata.append(i[1]['sms_count'])

    tooltip_date = "%d %b %y %H:%M %p"
    extra_serie1 = {
        "tooltip": {"y_start": "", "y_end": " SMS"},
        "date_format": tooltip_date
    }

    final_chartdata = {
        'x': xdata,
        'name1': 'SMS', 'y1': ydata, 'extra1': extra_serie1,
    }

    # Contacts which are successfully messaged for running sms campaign
    reached_contact = 0
    if sms_campaign_id_list:
        now = datetime.utcnow().replace(tzinfo=utc)
        start_date = datetime(now.year, now.month, now.day, 0, 0, 0, 0).replace(tzinfo=utc)
        end_date = datetime(now.year, now.month, now.day, 23, 59, 59, 999999).replace(tzinfo=utc)
        sms_campaign_subscriber = SMSCampaignSubscriber.objects.filter(
            sms_campaign_id__in=sms_campaign_id_list,
            status=SMS_SUBSCRIBER_STATUS.COMPLETE,
            updated_date__range=(start_date, end_date)).count()
        reached_contact += sms_campaign_subscriber

    # PieChart
    sms_analytic_charttype = "pieChart"
    xdata = []
    ydata = []
    sms_analytic_chartdata = {'x': xdata, 'y1': ydata}

    if total_sms_count != 0:
        for i in SMS_MESSAGE_STATUS:
            xdata.append(i[0].upper())

        # Y-axis order depend upon SMS_MESSAGE_STATUS
        # 'UNSENT', 'SENT', 'DELIVERED', 'FAILED', 'NO_ROUTE', 'UNAUTHORIZED'
        ydata = [
            percentage(total_unsent, total_sms_count),
            percentage(total_sent, total_sms_count),
            percentage(total_delivered, total_sms_count),
            percentage(total_failed, total_sms_count),
            percentage(total_no_route, total_sms_count),
            percentage(total_unauthorized, total_sms_count),
        ]

        color_list = [
            COLOR_SMS_DISPOSITION['UNSENT'],
            COLOR_SMS_DISPOSITION['SENT'],
            COLOR_SMS_DISPOSITION['DELIVERED'],
            COLOR_SMS_DISPOSITION['FAILED'],
            COLOR_SMS_DISPOSITION['NO_ROUTE'],
            COLOR_SMS_DISPOSITION['UNAUTHORIZED'],
        ]
        extra_serie = {
            "tooltip": {"y_start": "", "y_end": " %"},
            "color_list": color_list
        }
        kwargs1 = {}
        kwargs1['resize'] = True
        sms_analytic_chartdata = {
            'x': xdata, 'y1': ydata, 'extra1': extra_serie,
            'kwargs1': kwargs1,
        }

    data = {
        'form': form,
        'SEARCH_TYPE': SEARCH_TYPE,
        'pb_active_contact_count': pb_active_contact_count,
        'reached_contact': reached_contact,
        'total_record': total_record,
        'select_graph_for': select_graph_for,
        'total_sms_count': total_sms_count,
        'total_unsent': total_unsent,
        'total_sent': total_sent,
        'total_delivered': total_delivered,
        'total_failed': total_failed,
        'total_no_route': total_no_route,
        'total_unauthorized': total_unauthorized,
        'unsent_color': COLOR_SMS_DISPOSITION['UNSENT'],
        'sent_color': COLOR_SMS_DISPOSITION['SENT'],
        'delivered_color': COLOR_SMS_DISPOSITION['DELIVERED'],
        'failed_color': COLOR_SMS_DISPOSITION['FAILED'],
        'no_route_color': COLOR_SMS_DISPOSITION['NO_ROUTE'],
        'unauthorized_color': COLOR_SMS_DISPOSITION['UNAUTHORIZED'],
        'final_chartcontainer': 'lineplusbarwithfocuschart_container',
        'final_chartdata': final_chartdata,
        'final_charttype': final_charttype,
        'final_extra': {
            'x_is_date': True,
            'x_axis_format': '%d %b %Y',
            'tag_script_js': True,
            'jquery_on_ready': False,
        },
        'sms_analytic_chartcontainer': 'piechart_container',
        'sms_analytic_charttype': sms_analytic_charttype,
        'sms_analytic_chartdata': sms_analytic_chartdata,
        'sms_analytic_extra': {
            'x_is_date': False,
            'x_axis_format': '',
            'tag_script_js': True,
            'jquery_on_ready': False,
        },
    }
    if on_index == 'yes':
        return data
    return render_to_response('mod_sms/sms_dashboard.html', data, context_instance=RequestContext(request))

Example 117

Project: imaginationforpeople Source File: views.py
def project_sheet_edit_field(request, field, slug=None, topic_slug=None):
    """
    Edit a translatable field of a project (such as baseline)

    FIXME This view is used for both project creation and
    editing. Should be splitted.
    """
    language_code = translation.get_language()

    if topic_slug:
        topic = get_object_or_404(Topic,
                                  slug=topic_slug)
    else:
        get_object_or_404(I4pProjectTranslation,
                          slug=slug,
                          language_code=language_code)

    
    FieldForm = modelform_factory(I4pProjectTranslation, fields=(field,))
    context = {}

    project_translation = None
    if request.method == 'POST':
        try:
            project_translation = get_project_translation_by_slug(slug, language_code)
        except I4pProjectTranslation.DoesNotExist:
            # Create parent project, then translation
            parent_project = create_parent_project(topic_slug)
            project_translation = get_or_create_project_translation_by_slug(slug,
                                                                            parent_project=parent_project,
                                                                            language_code=language_code)
        
        form = FieldForm(request.POST, request.FILES, instance=project_translation)
        if form.is_valid():
            form.save()
            return HttpResponseRedirect(reverse('project_sheet-show', args=[project_translation.slug]))
    else:
        try:
            project_translation = get_project_translation_by_slug(slug, language_code)

            form = FieldForm(instance=project_translation)
            context["project_translation"] = project_translation
        except I4pProjectTranslation.DoesNotExist:
            form = FieldForm()

    if project_translation:
        # context['project_objectives_form'] = I4pProjectObjectivesForm(instance=project_translation.project, prefix="objectives-form")
        context['project_member_form'] = ProjectMemberAddForm()
        context['answer_form'] = AnswerForm()
        context['project_tab'] = True
        context['project'] = project_translation.master
    elif topic_slug:
        context['topic'] = topic

    context["%s_form" % field] = form
    return render_to_response(template_name="project_sheet/page/project_sheet.html",
                              dictionary=context,
                              context_instance=RequestContext(request))

Example 118

Project: repowatcher Source File: authed.py
@login_required
def authed(request):
    user = request.user
    bitbucket_authed = True
    github_authed = True
    bitbucket_user_events = []
    github_user_events = []
    github_repository_user = None
    bitbucket_repository_user = None
    try:
        github_username = user.social_auth.get(provider='github').extra_data['username']
        github_provider = GithubProvider(user)
        update = False

        # Get user information
        try:
            github_repository_user = github_provider.retrieve_user_details(github_username)
        except ObjectDoesNotExist:
            update = True
            github_repository_user = RepositoryUser()
        if update or (datetime.now() - github_repository_user.last_modified) > timedelta(days = 1):
            github_user_dict = github_provider.get_user_details(github_username)
            github_repository_user = github_provider.create_or_update_user_details(github_user_dict, github_repository_user)
            github_repository_user.save()
        github_user_events = github_provider.get_user_events(github_username)
        for github_user_event in github_user_events:
            github_user_event['host'] = 'github'
            github_user_event['created_on'] = dateutil.parser.parse(github_user_event['created_at'])

        # Get repository information
        repositories, _ = github_provider.retrieve_starred_repositories_list(github_username)

        if len(repositories) == 0:
            repo_link_type, _ = LinkType.objects.get_or_create(name = "starred")
            if not github_repository_user:
                github_repository_user,_ = RepositoryUser.objects.get_or_create(login=github_username,host='github')
            watched = github_provider.get_starred_repositories(github_username)
            for repo in watched:
                update = False
                try:
                    repository = Repository.objects.get(host_slug= 'github/'+repo['owner'].lower() + '/' + repo['name'].lower())
                except ObjectDoesNotExist:
                    update = True
                    repository = Repository()
                if update or (datetime.now() - repository.last_modified) > timedelta(days = 1):
                    repository = github_provider.create_or_update_repository_details(repo, repository)
                    if not repository.private:
                        repository.save()
                    RepositoryCategory.objects.get_or_create(name = repository.language)
                if not repository.private:
                    RepositoryUserRepositoryLink.objects.get_or_create(user = github_repository_user, repository = repository, link_type = repo_link_type)

                repositories.append(repository)
        github_repository_user.starred = len(repositories)
        github_repository_user.save()

        # Get repository information
        repositories, _ = github_provider.retrieve_watched_repositories_list(github_username)

        if len(repositories) == 0:
            repo_link_type, _ = LinkType.objects.get_or_create(name = "watched")
            if not github_repository_user:
                github_repository_user,_ = RepositoryUser.objects.get_or_create(login=github_username,host='github')
            watched = github_provider.get_watched_repositories(github_username)
            for repo in watched:
                update = False
                try:
                    repository = Repository.objects.get(host_slug= 'github/'+repo['owner'].lower() + '/' + repo['name'].lower())
                except ObjectDoesNotExist:
                    update = True
                    repository = Repository()
                if update or (datetime.now() - repository.last_modified) > timedelta(days = 1):
                    repository = github_provider.create_or_update_repository_details(repo, repository)
                    if not repository.private:
                        repository.save()
                    RepositoryCategory.objects.get_or_create(name = repository.language)
                if not repository.private:
                    RepositoryUserRepositoryLink.objects.get_or_create(user = github_repository_user, repository = repository, link_type = repo_link_type)

                repositories.append(repository)
        github_repository_user.watched = len(repositories)
        github_repository_user.save()
    except ObjectDoesNotExist:
        github_authed = False

    try:
        bitbucket_username = user.social_auth.get(provider='bitbucket').extra_data['username']
        bitbucket_provider = BitbucketProvider(user)
        # Get user information
        update = False
        try:
            bitbucket_repository_user = bitbucket_provider.retrieve_user_details(bitbucket_username)
        except ObjectDoesNotExist:
            update = True
            bitbucket_repository_user = RepositoryUser()
        if update or (datetime.now() - bitbucket_repository_user.last_modified) > timedelta(days = 1):
            user_dict = bitbucket_provider.get_user_details(bitbucket_username)
            bitbucket_repository_user = bitbucket_provider.create_or_update_user_details(user_dict, bitbucket_repository_user)
            bitbucket_repository_user.save()
        bitbucket_user_events = bitbucket_provider.get_user_events(bitbucket_username)
        for bitbucket_user_event in bitbucket_user_events:
            bitbucket_user_event['host'] = 'bitbucket'
            bitbucket_user_event['created_on'] = dateutil.parser.parse(bitbucket_user_event['utc_created_on'])
        # Get repository information
        owned_repositories, _ = bitbucket_provider.retrieve_owned_repositories_list(bitbucket_username)
        watched_repositories, _ = bitbucket_provider.retrieve_watched_repositories_list(bitbucket_username)

        if len(owned_repositories) == 0:
            owned = bitbucket_provider.get_owned_repositories(bitbucket_username)
            for repo in owned:
                update = False
                try:
                    repository = bitbucket_provider.retrieve_repository_details(repo['owner'], repo['name'])
                except ObjectDoesNotExist:
                    update = True
                    repository = Repository()
                if update or (datetime.now() - repository.last_modified) > timedelta(days = 1):
                    repository = bitbucket_provider.create_or_update_repository_details(repo, repository)
                    if not repository.private:
                        repository.save()
                    RepositoryCategory.objects.get_or_create(name=repository.language)
                if not repository.private:
                    RepositoryUserRepositoryLink.objects.get_or_create(user=bitbucket_repository_user, repository = repository, owned = True)
                owned_repositories.append(repository)
            bitbucket_repository_user.public_repos = len(owned_repositories)
            bitbucket_repository_user.save()

        if len(watched_repositories) == 0:
            watched = bitbucket_provider.get_watched_repositories(bitbucket_username)
            for repo in watched:
                update = False
                try:
                    repository = bitbucket_provider.retrieve_repository_details(repo['owner'], repo['name'])
                except ObjectDoesNotExist:
                    update = True
                    repository = Repository()
                if update or (datetime.now() - repository.last_modified) > timedelta(days = 1):
                    repository = bitbucket_provider.create_or_update_repository_details(repo, repository)
                    if not repository.private:
                        repository.save()
                watched_repositories.append(repository)
            bitbucket_repository_user.starred = len(watched_repositories)
    except ObjectDoesNotExist:
        bitbucket_authed = False

    user_events = sorted(github_user_events + bitbucket_user_events,key=itemgetter('created_on'), reverse = True)[:30]

    return render_to_response('authed.html', {'user_events':user_events,'github_repository_user':github_repository_user,'bitbucket_repository_user':bitbucket_repository_user,'github_authed':github_authed,'bitbucket_authed':bitbucket_authed}, context_instance=RequestContext(request))

Example 119

Project: dndtools Source File: views.py
@menu_item(MenuItem.MAGIC)
@submenu_item(MenuItem.Magic.DOMAINS)
def spell_domain_detail(request, spell_domain_slug, rulebook_slug=None, rulebook_id=None):
    # fetch the class
    spell_domain = get_object_or_404(Domain.objects.select_related(
        'domain_variant', 'domain_variant__rulebook'), slug=spell_domain_slug)

    # fetch primary variant, this is independent of rulebook selected
    try:
        primary_variant = DomainVariant.objects.select_related(
            'rulebook', 'rulebook__dnd_edition',
        ).filter(
            domain=spell_domain,
        ).order_by('-rulebook__dnd_edition__core', '-rulebook__published')[0]
    except Exception:
        primary_variant = None

    # if rulebook is supplied, select find this variant
    if rulebook_slug and rulebook_id:
        # use canonical link in head as this is more or less duplicated content
        use_canonical_link = True
        selected_variant = get_object_or_404(
            DomainVariant.objects.select_related(
                'domain', 'rulebook', 'rulebook__dnd_edition'),
            domain__slug=spell_domain_slug,
            rulebook__pk=rulebook_id)

        # possible malformed/changed slug
        if rulebook_slug != selected_variant.rulebook.slug:
            return permanent_redirect_object(request, selected_variant)

        # selected variant is primary! Redirect to canonical url
        if selected_variant == primary_variant:
            return permanent_redirect_view(
                request, spell_domain_detail, kwargs={
                    'spell_domain_slug': spell_domain_slug}
            )
    else:
        # this is canonical, no need to specify it
        use_canonical_link = False
        selected_variant = primary_variant

    other_variants = [
        variant
        for variant
        in spell_domain.domainvariant_set.select_related(
            'rulebook', 'rulebook__dnd_edition', 'spell_domain').all()
        if variant != selected_variant
    ]

    if selected_variant:
        display_3e_warning = is_3e_edition(selected_variant.rulebook.dnd_edition)
    else:
        display_3e_warning = False

    spell_list = spell_domain.spell_set.select_related(
        'rulebook', 'rulebook__dnd_edition', 'school').all()

    paginator = DndPaginator(spell_list, request)

    return render_to_response('dnd/spells/spell_domain_detail.html',
                              {
                                  'spell_domain': spell_domain,
                                  'spell_list': paginator.items(),
                                  'paginator': paginator,
                                  'request': request,
                                  'i_like_it_url': request.build_absolute_uri(),
                                  'inaccurate_url': request.build_absolute_uri(),
                                  'selected_variant': selected_variant,
                                  'other_variants': other_variants,
                                  'use_canonical_link': use_canonical_link,
                                  'display_3e_warning': display_3e_warning, },
                              context_instance=RequestContext(request), )

Example 120

Project: repowatcher Source File: authed.py
@login_required
def authed_category_owned(request,category):
    """has all github repos and the latest 30 events for a username with a specific category"""
    repo_link_type, _ = LinkType.objects.get_or_create(name = "owned")
    owned = True
    category = urllib.unquote(category).lower()
    github_repo_events = []
    bitbucket_repo_events = []
    github_watched_filtered = []
    bitbucket_watched_filtered = []
    user = request.user
    repository_user = None
    github_username = None
    bitbucket_username = None
    bitbucket_authed = True
    github_authed = True
    watched_filtered = []
    try:
        github_username = user.social_auth.get(provider='github').extra_data['username']
        github_provider = GithubProvider(user)
        github_watched_filtered, github_repository_user = github_provider.retrieve_category_repositories(github_username, category, "owned")
        watched_filtered.extend(github_watched_filtered)
        github_repository_user.save()
        if len(github_watched_filtered) == 0:
            watched = github_provider.get_repositories(github_username, "owned")
            category_lower = category.lower()
            for repo in watched:
                update = False
                try:
                    repository = Repository.objects.get(host_slug= 'github/'+repo['owner'].lower() + '/' + repo['name'].lower())
                except ObjectDoesNotExist:
                    update = True
                    repository = Repository()
                if update or (datetime.now() - repository.last_modified) > timedelta(days = 1):
                    repository = github_provider.create_or_update_repository_details(repo, repository)
                    if not repository.private:
                        repository.save()
                if repository.language == category_lower:
                    github_watched_filtered.append(repository)
                if not repository.private:
                    RepositoryUserRepositoryLink.objects.get_or_create(user = github_repository_user, repository = repository, link_type = repo_link_type)
            watched_filtered.extend(github_watched_filtered)
            watched_filtered.sort(key=lambda x: x.watchers, reverse = True)
            RepositoryCategory.objects.get_or_create(name = category.lower())
            github_repository_user.save()


        # Get repository events

        github_repo_events = github_provider.get_repositories_events(github_watched_filtered)
        for github_repo_event in github_repo_events:
            github_repo_event['host'] = 'github'
            github_repo_event['created_on'] = dateutil.parser.parse(github_repo_event['created_at'])
    except ObjectDoesNotExist:
        github_authed = False
    user = request.user
    try:
        bitbucket_username = user.social_auth.get(provider='bitbucket').extra_data['username']
        profile = user.get_profile()
        bitbucket_provider = BitbucketProvider(user)
        bitbucket_watched_filtered, bitbucket_repository_user = bitbucket_provider.retrieve_owned_category_repositories(bitbucket_username, category)
        watched_filtered.extend(bitbucket_watched_filtered)
        if len(bitbucket_watched_filtered) == 0:
            owned = bitbucket_provider.get_owned_repositories(bitbucket_username)
            for repo in owned:
                update = False
                try:
                    repository = Repository.objects.get(host_slug= 'bitbucket/'+repo['owner'].lower() + '/' + repo['name'].lower())
                except ObjectDoesNotExist:
                    update = True
                    repository = Repository()
                if update or (datetime.now() - repository.last_modified) > timedelta(days = 1):
                    repository = bitbucket_provider.create_or_update_repository_details(repo, repository)
                    if not repository.private:
                        repository.save()


                if repository.language == category_lower:
                    bitbucket_watched_filtered.append(repository)
            watched_filtered.extend(bitbucket_watched_filtered)
            watched_filtered.sort(key=lambda x: x.watchers, reverse = True)
            RepositoryCategory.objects.get_or_create(name = category.lower())
        bitbucket_repo_events = bitbucket_provider.get_repositories_events(bitbucket_watched_filtered)
        for bitbucket_repo_event in bitbucket_repo_events:
                bitbucket_repo_event['host'] = 'bitbucket'
                bitbucket_repo_event['created_on'] = dateutil.parser.parse(bitbucket_repo_event['utc_created_on'])
    except ObjectDoesNotExist:
        bitbucket_authed = False
    repo_events = sorted(github_repo_events + bitbucket_repo_events,key=itemgetter('created_on'), reverse = True)[:30]
    if bitbucket_authed or github_authed:
        return render_to_response('username_category_watched.html', {'github_username': github_username,'github_authed': github_authed,'bitbucket_username':bitbucket_username, 'bitbucket_authed':bitbucket_authed, 'watched':watched_filtered, 'category':category, 'repo_events':repo_events,'owned':owned},context_instance=RequestContext(request))
    else:
        return HttpResponseRedirect(reverse('repowatcher.main.views.authed'))

Example 121

Project: private-readthedocs.org Source File: views.py
@login_required
def editor_file(request, project_slug, filename):
    """
    Edits a file in a project
    """
    project = get_object_or_404(Project, slug=project_slug)
    if not filename:
        filename = "index.html"
    filename = filename.rstrip('/')
    repo_file = _replace_ext(_get_rel_filepath(project, filename), project.suffix)
    if not project.contribution_backend:
        return _project_404(request, project)
    branch = Branch.objects.get_branch(request.user, project)
    current_data = project.contribution_backend.get_branch_file(branch, repo_file)
    if not current_data:
        return _project_404(request, project)
    if request.method == 'POST':
        form = FileForm(request.POST)
        if form.is_valid():
            body = form.cleaned_data['body']
            comment = form.cleaned_data['comment']
            with project.repo_lock(5):
                project.contribution_backend.set_branch_file(
                    branch, repo_file, body, comment
                )
            url = reverse(editor_pick, args=(project.slug,))
            return HttpResponseRedirect(url)
    else:
        initial = {
            'body': current_data
        }
        form = FileForm(initial=initial)
    ctx = RequestContext(request)
    ctx['form'] = form
    ctx['filename'] = repo_file
    ctx['project'] = project
    return render_to_response('editor/editor_file.html', ctx)

Example 122

Project: django-popup-forms Source File: popup_form.py
    def render(self, context):

        # Resolve variables
        popup_id = self.popup_id.resolve(context)
        form_class = self.form_class.resolve(context)
        form_action = self.form_action.resolve(context)
        template_name = self.template_name.resolve(context)

        # Resolve kwargs
        kwargs = {}
        for key, value in self.kwargs.iteritems():
            kwargs[key] = value.resolve(context)

        # Django tries to call callables, so we extract
        # form class from the form instance
        if not isinstance(form_class, type):
            form_class = form_class.__class__
        form_instance = form_class(**kwargs)

        # Try to get popup_form from session
        # (emulate response to POST request for popup form)
        hide_form = True  # Hide form by default, unless form is in session
        request = context['request']
        if 'popup_form' in request.session:
            action, data, errors = request.session['popup_form']

            # A page could have many popup forms,
            # with different actions
            if action == form_action:
                del request.session['popup_form']

                # Instantiate the form
                args = []
                if data is not None:
                    args.append(data)
                form_instance = form_class(*args, **kwargs)

                # If there are errors, show them
                if errors:
                    form_instance._errors = errors

                # Mark the form as non-hidden
                hide_form = False

        # Render popup form, using template
        tpl = template.loader.get_template(template_name)
        context_vars = {'POPUP_FORM_id': popup_id,
                        'POPUP_FORM_form': form_instance,
                        'POPUP_FORM_action': form_action,
                        'POPUP_FORM_hide': hide_form}
        context = copy(context)
        context.update(context_vars)
        return tpl.render(RequestContext(request, context))

Example 123

Project: dndtools Source File: views.py
def inaccurate_content(request):
    if request.method == 'POST':
        form = InaccurateContentForm(request.POST, initial={
            'captcha': request.META['REMOTE_ADDR']})
        if form.is_valid():
            if form.cleaned_data['sender']:
                headers = {
                    'Reply-To': form.cleaned_data['sender']}
            else:
                headers = {}

            email = EmailMessage(
                subject='Problem in url %s' % form.cleaned_data['url'],
                body="Message: %s\n\nUrl: %s\n\nBetter desc:%s\nFrom: %s" % (
                    form.cleaned_data['message'], form.cleaned_data['url'],
                    form.cleaned_data['better_description'],
                    form.cleaned_data['sender']),
                from_email='[email protected]',
                to=('[email protected]', '[email protected]'),
                headers=headers,
            )

            email.send()

            # Trello email

            email = EmailMessage(
                subject='#2 BUGFIXES: %s' % form.cleaned_data['url'],
                body="Message: %s\n\nUrl: %s\n\nBetter desc:%s\nFrom: %s" % (
                    form.cleaned_data['message'], form.cleaned_data['url'],
                    form.cleaned_data['better_description'],
                    form.cleaned_data['sender']),
                from_email='[email protected]',
                to=('[email protected]', ),
                headers=headers,
            )

            email.send()

            # Redirect after POST
            return HttpResponseRedirect(reverse('inaccurate_content_sent'))

    else:
        form = InaccurateContentForm(
            initial={
                'url': request.GET.get('url', ''),
            })

    return render_to_response('dnd/inaccurate_content.html',
                              {
                                  'request': request,
                                  'form': form, }, context_instance=RequestContext(request), )

Example 124

Project: django-coffeescript Source File: tests.py
Function: get_request_context
    def _get_request_context(self):
        return RequestContext(HttpRequest())

Example 125

Project: geonode Source File: views.py
def forgot_username(request):
    """ Look up a username based on an email address, and send an email
    containing the username if found"""

    username_form = ForgotUsernameForm()

    message = ''

    site = Site.objects.get_current()

    email_subject = _("Your username for " + site.name)

    if request.method == 'POST':
        username_form = ForgotUsernameForm(request.POST)
        if username_form.is_valid():

            users = get_user_model().objects.filter(
                email=username_form.cleaned_data['email'])

            if users:
                username = users[0].username
                email_message = email_subject + " : " + username
                send_email.delay(email_subject, email_message, settings.DEFAULT_FROM_EMAIL,
                                 [username_form.cleaned_data['email']], fail_silently=False)
                message = _("Your username has been emailed to you.")
            else:
                message = _("No user could be found with that email address.")

    return render_to_response('people/forgot_username_form.html',
                              RequestContext(request, {
                                  'message': message,
                                  'form': username_form
                              }))

Example 126

Project: META-SHARE Source File: admin.py
    def remove_user_from_editor_group(self, request, queryset):
        form = None
        if request.user.is_superuser:
            if 'cancel' in request.POST:
                self.message_user(request, _('Cancelled removing users from the editor group.'))
                return
            elif 'remove_user_profile_from_editor_group' in request.POST:
                objs_up = UserProfile.objects.filter(user__is_active=True)
                form = self.UserProfileinEditorGroupForm(objs_up, request.POST)
                if form.is_valid():
                    userprofiles = form.cleaned_data['users']
                    for userprofile in userprofiles:
                        for obj in queryset:
                            userprofile.user.groups.remove(obj)
                    self.message_user(request, _('Successfully removed users from editor group.'))
                    return HttpResponseRedirect(request.get_full_path())
    
            if not form:
                userprofiles = UserProfile.objects.filter(user__is_active=True)
                form = self.UserProfileinEditorGroupForm(choices=userprofiles,
                    initial={'_selected_action': request.POST.getlist(admin.ACTION_CHECKBOX_NAME)})
        
            dictionary = {'title': _('Remove Users from Editor Group'),
                          'selected_editorgroups': queryset,
                          'form': form,
                          'path': request.get_full_path()
                         }
            dictionary.update(create_breadcrumb_template_params(self.model, _('Remove user')))
        
            return render_to_response('accounts/remove_user_profile_from_editor_group.html',
                                      dictionary,
                                      context_instance=RequestContext(request))

Example 127

Project: django-plus Source File: decorators.py
Function: page
def page(template=None, context=None, **decorator_args):
    """This decorator was made by Yuri Baburov at its first version and Marinho just improved it"""
    def _wrapper(fn):
        def _innerWrapper(*args, **kw):
            # Supports independent function views
            if isinstance(args[0], HttpRequest):
                request = args[0]

            # Supports ModelAdmin method views
            elif isinstance(args[0], ModelAdmin):
                model_admin = args[0]
                request = args[1]

            context_dict = decorator_args.copy()
            template = kw.pop("template", _innerWrapper.template)
            g = fn(*args, **kw)
            if issubclass(type(g), HttpResponse): 
                return g
            if not hasattr(g, 'next'):  #Is this a generator?  Otherwise make it a tuple!
                g = (g,)
            for i in g:
                if issubclass(type(i), HttpResponse):
                    return i
                if type(i) == type(()):
                    context_dict[i[0]] = i[1]
                else:
                    context_dict.update(i)
            template_name = context_dict.get("template", template)
            context_instance = context_dict.get("context", context)
            if not context_instance:
                context_instance = RequestContext(request, context_dict)
            return render_to_response(template_name, context_dict, context_instance)

        _innerWrapper.template = template
        return _innerWrapper
    return _wrapper

Example 128

Project: ganetimgr Source File: __init__.py
def check_instance_readonly(view_fn):
    def check_auth(request, *args, **kwargs):
        try:
            cluster_slug = kwargs["cluster_slug"]
            instance_name = kwargs["instance"]
        except KeyError:
            cluster_slug = args[0]
            instance_name = args[1]

        cache_key = "cluster:%s:instance:%s:user:%s" % (
            cluster_slug,
            instance_name,
            request.user.username
        )
        res = cache.get(cache_key)
        if res is None:
            cluster = get_object_or_404(Cluster, slug=cluster_slug)
            instance = cluster.get_instance_or_404(instance_name)
            res = False

            if (
                request.user.is_superuser or
                request.user in instance.users or
                request.user.has_perm('ganeti.view_instances') or
                set.intersection(
                    set(request.user.groups.all()), set(instance.groups)
                )
            ):
                res = True

            cache.set(cache_key, res, 60)

        if not res:
            t = get_template("403.html")
            return HttpResponseForbidden(
                content=t.render(RequestContext(request))
            )
        else:
            return view_fn(request, *args, **kwargs)
    return check_auth

Example 129

Project: kitsune Source File: views.py
@login_required
def add_permission(request, app_label, module_name, pk, approved=False,
                   template_name='authority/permission_form.html',
                   extra_context=None, form_class=UserPermissionForm):
    codename = request.POST.get('codename', None)
    model = get_model(app_label, module_name)
    if model is None:
        return permission_denied(request)
    obj = get_object_or_404(model, pk=pk)
    next = get_next(request, obj)
    if approved:
        if not request.user.has_perm('authority.add_permission'):
            return HttpResponseRedirect(
                url_for_obj('authority-add-permission-request', obj))
        view_name = 'authority-add-permission'
    else:
        view_name = 'authority-add-permission-request'
    if request.method == 'POST':
        if codename is None:
            return HttpResponseForbidden(next)
        form = form_class(data=request.POST, obj=obj, approved=approved,
                          perm=codename, initial=dict(codename=codename))
        if not approved:
            # Limit permission request to current user
            form.data['user'] = request.user
        if form.is_valid():
            request.user.message_set.create(
                message=_('You added a permission request.'))
            return HttpResponseRedirect(next)
    else:
        form = form_class(obj=obj, approved=approved, perm=codename,
                          initial=dict(codename=codename))
    context = {
        'form': form,
        'form_url': url_for_obj(view_name, obj),
        'next': next,
        'perm': codename,
        'approved': approved,
    }
    if extra_context:
        context.update(extra_context)
    return render_to_response(template_name, context,
                              context_instance=RequestContext(request))

Example 130

Project: aemanager Source File: views.py
@settings_required
@subscription_required
@commit_on_success
def invoice_create_or_edit(request, id=None, customer_id=None, proposal_id=None):
    if id:
        title = _('Edit an invoice')
        invoice = get_object_or_404(Invoice, pk=id, owner=request.user)
        customer = invoice.customer
    else:
        title = _('Draw up an invoice')
        invoice = None
        """
        in case of invoice creation, if a customer_id is not provided by url
        we look for it in the autocomplete field (case of direct invoice draw up
        without proposal)
        """
        if request.method == 'POST':
            autocompleted_customer_id = request.POST.get('contact-customer_id')
            if not customer_id:
                customer_id = autocompleted_customer_id
        if customer_id:
            customer = get_object_or_404(Contact, pk=customer_id, owner=request.user)
        else:
            customer = None

    address = None
    original_customer_name = None
    if customer:
        address = customer.address
        original_customer_name = customer.name

    proposal = None
    if proposal_id:
        proposal = get_object_or_404(Proposal,
                                     pk=proposal_id,
                                     project__customer=customer,
                                     owner=request.user,
                                     state__in=[PROPOSAL_STATE_ACCEPTED])

    InvoiceRowFormSet = inlineformset_factory(Invoice,
                                              InvoiceRow,
                                              form=InvoiceRowForm,
                                              fk_name="invoice",
                                              extra=1)

    proposals = Proposal.objects.get_proposals_for_invoice(customer, request.user, invoice)

    if request.method == 'POST':
        contactForm = ContactQuickCreateForm(request.POST,
                                             instance=customer,
                                             prefix="contact")
        if customer:
            contactForm.setToEditMode()

        addressForm = AddressForm(request.POST,
                                  instance=address,
                                  prefix="address")
        invoiceForm = InvoiceForm(request.POST,
                                  instance=invoice,
                                  prefix="invoice")
        invoicerowformset = InvoiceRowFormSet(request.POST,
                                              instance=invoice)
        for invoicerowform in invoicerowformset.forms:
            invoicerowform.fields['proposal'].queryset = proposals

        if contactForm.is_valid() and addressForm.is_valid() and \
           invoiceForm.is_valid() and invoicerowformset.is_valid():
            try:
                user = request.user

                address = addressForm.save(commit=False)
                address.save(user=user)

                customer = contactForm.save(commit=False)
                if not customer.contact_type:
                    customer.contact_type = CONTACT_TYPE_COMPANY
                # restore original name since it shouldn't be changed in invoice
                if original_customer_name:
                    customer.name = original_customer_name
                customer.address_id = address.id
                customer.save(user=user)

                invoice = invoiceForm.save(commit=False)
                invoice.customer = customer
                if invoice.paid_date:
                    invoice.state = INVOICE_STATE_PAID
                invoice.save(user=user)
                invoiceForm.save_m2m()
                for invoicerowform in invoicerowformset.forms:
                    if invoicerowform not in invoicerowformset.deleted_forms and invoicerowform.cleaned_data:
                        invoicerow = invoicerowform.save(commit=False)
                        invoicerow.invoice = invoice
                        invoicerow.save(user=user)

                        if invoicerow.proposal and invoicerow.balance_payments and invoice.paid_date:
                            invoicerow.proposal.state = PROPOSAL_STATE_BALANCED
                            invoicerow.proposal.save()

                for deleted_invoicerowform in invoicerowformset.deleted_forms:
                    deleted_invoicerowform.instance.delete()

                invoice.check_amounts()

                messages.success(request, _('The invoice has been saved successfully'))
                if invoice.paid_date and invoice.paid_date > datetime.date.today():
                    messages.warning(request, _("Paid date is in the future, is this normal ?"))
                if invoice.execution_begin_date and invoice.execution_end_date and invoice.execution_begin_date > invoice.execution_end_date:
                    messages.warning(request, _("Execution begin date is greater than execution end date, is this normal ?"))
                if invoice.penalty_date and invoice.penalty_date < invoice.payment_date:
                    messages.warning(request, _("Payment date is greater than penalty date, is this normal ?"))
                return redirect(reverse('invoice_detail', kwargs={'id': invoice.id}))
            except InvoiceRowAmountError:
                transaction.rollback()
                messages.error(request, _("Amounts invoiced can't be greater than proposals remaining amounts"))
            except InvoiceIdNotUniqueError:
                transaction.rollback()
                invoiceForm._errors["invoice_id"] = invoiceForm.error_class([_("Invoice id must be unique")])
        else:
            messages.error(request, _('Data provided are invalid'))
    else:
        next_invoice_id = Invoice.objects.get_next_invoice_id(request.user)
        initial_data = None
        if not invoice:
            initial_data = {'invoice_id': next_invoice_id,
                            'edition_date': datetime.datetime.now()}
            if proposal:
                initial_data['execution_begin_date'] = proposal.begin_date
                initial_data['execution_end_date'] = proposal.end_date

        contactForm = ContactQuickCreateForm(instance=customer,
                                             prefix="contact")
        if customer:
            contactForm.setToEditMode()
        addressForm = AddressForm(instance=address,
                                  prefix="address")

        invoiceForm = InvoiceForm(instance=invoice,
                                  prefix="invoice",
                                  initial=initial_data)

        initial_row_data = None
        if proposal:
            initial_row_data = []
            for proposal_row in proposal.proposal_rows.all():
                initial_row_data.append({'label': proposal_row.label,
                                         'proposal': proposal,
                                         'balance_payments': True,
                                         'category': proposal_row.category,
                                         'quantity': proposal_row.quantity,
                                         'detail': proposal_row.detail,
                                         'unit_price': proposal_row.unit_price})
            InvoiceRowFormSet.extra = len(initial_row_data) + 1

        invoicerowformset = InvoiceRowFormSet(instance=invoice)
        i = 0
        for invoicerowform in invoicerowformset.forms:
            invoicerowform.fields['proposal'].queryset = proposals
            # for all rows except last
            if i < InvoiceRowFormSet.extra - 1:
                invoicerowform.initial = initial_row_data[i]
                i = i + 1


    return render_to_response('invoice/edit.html',
                              {'active': 'accounts',
                               'title': title,
                               'from_proposal': proposal,
                               'contactForm': contactForm,
                               'addressForm': addressForm,
                               'invoiceForm': invoiceForm,
                               'invoicerowformset': invoicerowformset},
                               context_instance=RequestContext(request))

Example 131

Project: wikicoding Source File: article.py
Function: merge
@get_article(can_write=True)
def merge(request, article, revision_id, urlpath=None, template_file="wiki/preview_inline.html", preview=False):

    revision = get_object_or_404(models.ArticleRevision, article=article, id=revision_id)

    current_text = article.current_revision.content if article.current_revision else ""
    new_text = revision.content

    content = simple_merge(current_text, new_text)

    # Save new revision
    if not preview:
        old_revision = article.current_revision

        if revision.deleted:
            c = RequestContext(request, {'error_msg': _('You cannot merge with a deleted revision'),
                                         'article': article,
                                         'urlpath': urlpath})
            return render_to_response("wiki/error.html", context_instance=c)

        new_revision = models.ArticleRevision()
        new_revision.inherit_predecessor(article)
        new_revision.deleted = False
        new_revision.locked = False
        new_revision.title=article.current_revision.title
        new_revision.content=content
        new_revision.automatic_log = (_('Merge between revision #%(r1)d and revision #%(r2)d') %
                                      {'r1': revision.revision_number,
                                       'r2': old_revision.revision_number})
        article.add_revision(new_revision, save=True)

        old_revision.simpleplugin_set.all().update(article_revision=new_revision)
        revision.simpleplugin_set.all().update(article_revision=new_revision)

        messages.success(request, _('A new revision was created: Merge between revision #%(r1)d and revision #%(r2)d') %
                         {'r1': revision.revision_number,
                          'r2': old_revision.revision_number})
        if urlpath:
            return redirect('wiki:edit', path=urlpath.path, language=urlpath.language)
        else:
            return redirect('wiki:edit', article_id=article.id)


    c = RequestContext(request, {'article': article,
                                 'title': article.current_revision.title,
                                 'revision': None,
                                 'merge1': revision,
                                 'merge2': article.current_revision,
                                 'merge': True,
                                 'content': content})
    return render_to_response(template_file, context_instance=c)

Example 132

Project: django-addressbook Source File: views.py
Function: add_contact
@login_required
def add_contact(request):
    if request.method == 'POST': # If the form has been submitted...
        contact_form = ContactForm(request.POST, user=request.user) # A form bound to the POST data
        # Create a formset from the submitted data
        email_formset = EmailFormSet(request.POST, prefix="email")
        phone_formset = PhoneFormSet(request.POST, prefix="phone")
        address_formset = AddressFormSet(request.POST, prefix="address")
        website_formset = WebsiteFormSet(request.POST, prefix="website")
        if (contact_form.is_valid() and email_formset.is_valid() and
                phone_formset.is_valid() and address_formset.is_valid() and
                website_formset.is_valid()):
            contact = contact_form.save()
            for form in email_formset.forms:
                email = form.save(commit=False)
                email.contact = contact
                email.save()
            for form in phone_formset.forms:
                phone = form.save(commit=False)
                phone.contact = contact
                phone.save()
            for form in address_formset.forms:
                address = form.save(commit=False)
                address.contact = contact
                address.save()
            for form in website_formset.forms:
                website = form.save(commit=False)
                website.contact = contact
                website.save()
#            request.user.message_set.create(message = 'Successfully saved contact.')
            return HttpResponseRedirect(reverse('addressbook_index')) # Redirect to a 'success' page
    else:
        groups = ContactGroup.objects.filter(user=request.user)
        if not groups:
            return HttpResponseRedirect(reverse('addressbook_add_group'))
        contact_form = ContactForm(user=request.user)
        email_formset = EmailFormSet(prefix="email")
        phone_formset = PhoneFormSet(prefix="phone")
        address_formset = AddressFormSet(prefix="address")
        website_formset = WebsiteFormSet(prefix="website")
    return render(request, 'addressbook/add_contact.html',
            RequestContext(request, {
                'phone_formset': phone_formset,
                'contact_form': contact_form,
                'email_formset': email_formset,
                'address_formset': address_formset,
                'website_formset': website_formset
            }))

Example 133

Project: newfies-dialer Source File: views.py
@permission_required('dialer_cdr.view_call_detail_report', login_url='/')
@login_required
def voipcall_report(request):
    """VoIP Call Report

    **Attributes**:

        * ``form`` - VoipSearchForm
        * ``template`` - dialer_cdr/voipcall_report.html

    **Logic Description**:

        * Get VoIP call list according to search parameters for loggedin user

    **Important variable**:

        * ``request.session['voipcall_record_kwargs']`` - stores voipcall kwargs
    """
    sort_col_field_list = ['starting_date', 'leg_type', 'disposition', 'used_gateway', 'callerid',
                           'callid', 'phone_number', 'duration', 'billsec', 'amd_status']
    pag_vars = get_pagination_vars(request, sort_col_field_list, default_sort_field='starting_date')
    action = 'tabs-1'
    form = VoipSearchForm(request.user, request.POST or None)
    if form.is_valid():
        # Valid form
        field_list = ['start_date', 'end_date', 'disposition', 'campaign_id', 'leg_type']
        unset_session_var(request, field_list)

        from_date = getvar(request, 'from_date')
        to_date = getvar(request, 'to_date')
        start_date = ceil_strdate(str(from_date), 'start')
        end_date = ceil_strdate(str(to_date), 'end')

        converted_start_date = start_date.strftime('%Y-%m-%d')
        converted_end_date = end_date.strftime('%Y-%m-%d')
        request.session['session_start_date'] = converted_start_date
        request.session['session_end_date'] = converted_end_date

        disposition = getvar(request, 'disposition', setsession=True)
        campaign_id = getvar(request, 'campaign_id', setsession=True)
        leg_type = getvar(request, 'leg_type', setsession=True)
        form = VoipSearchForm(request.user, initial={'from_date': start_date.strftime('%Y-%m-%d'),
                                                     'to_date': end_date.strftime('%Y-%m-%d'),
                                                     'disposition': disposition,
                                                     'campaign_id': campaign_id,
                                                     'leg_type': leg_type})

    elif request.GET.get('page') or request.GET.get('sort_by'):
        # Pagination / Sort
        start_date = request.session.get('session_start_date')
        end_date = request.session.get('session_end_date')
        start_date = ceil_strdate(str(start_date), 'start')
        end_date = ceil_strdate(str(end_date), 'end')

        disposition = request.session.get('session_disposition')
        campaign_id = request.session.get('session_campaign_id')
        leg_type = request.session.get('session_leg_type')
        form = VoipSearchForm(request.user, initial={'from_date': start_date.strftime('%Y-%m-%d'),
                                                     'to_date': end_date.strftime('%Y-%m-%d'),
                                                     'disposition': disposition,
                                                     'campaign_id': campaign_id,
                                                     'leg_type': leg_type})
    else:
        # Default
        tday = datetime.utcnow().replace(tzinfo=utc)
        from_date = tday.strftime('%Y-%m-%d')
        to_date = tday.strftime('%Y-%m-%d')
        start_date = datetime(tday.year, tday.month, tday.day, 0, 0, 0, 0).replace(tzinfo=utc)
        end_date = datetime(tday.year, tday.month, tday.day, 23, 59, 59, 999999).replace(tzinfo=utc)
        disposition = 'all'
        campaign_id = 0
        leg_type = ''
        form = VoipSearchForm(request.user, initial={'from_date': from_date,
                                                     'to_date': to_date,
                                                     'disposition': disposition,
                                                     'campaign_id': campaign_id,
                                                     'leg_type': leg_type})
        # unset session var
        request.session['session_start_date'] = start_date
        request.session['session_end_date'] = end_date
        request.session['session_disposition'] = disposition
        request.session['session_campaign_id'] = ''
        request.session['session_leg_type'] = ''

    kwargs = {}
    if start_date and end_date:
        kwargs['starting_date__range'] = (start_date, end_date)
    if start_date and end_date == '':
        kwargs['starting_date__gte'] = start_date
    if start_date == '' and end_date:
        kwargs['starting_date__lte'] = end_date

    if disposition and disposition != 'all':
        kwargs['disposition__exact'] = disposition

    if campaign_id and int(campaign_id) != 0:
        kwargs['callrequest__campaign_id'] = campaign_id

    if leg_type and leg_type != '':
        kwargs['leg_type__exact'] = leg_type

    if not request.user.is_superuser:
        kwargs['user_id'] = request.user.id

    voipcall_list = VoIPCall.objects.filter(**kwargs)
    all_voipcall_list = voipcall_list.values_list('id', flat=True)

    # Session variable is used to get record set with searched option
    # into export file
    request.session['voipcall_record_kwargs'] = kwargs

    if request.GET.get('page') or request.GET.get('sort_by'):
        daily_data = request.session['voipcall_daily_data']
    else:
        if not voipcall_list:
            request.session['voipcall_daily_data'] = ''
        daily_data = get_voipcall_daily_data(voipcall_list)
        request.session['voipcall_daily_data'] = daily_data

    voipcall_list = voipcall_list.order_by(pag_vars['sort_order'])[pag_vars['start_page']:pag_vars['end_page']]

    data = {
        'form': form,
        'total_data': daily_data['total_data'],
        'total_duration': daily_data['total_duration'],
        'total_calls': daily_data['total_calls'],
        'total_avg_duration': daily_data['total_avg_duration'],
        'max_duration': daily_data['max_duration'],
        'all_voipcall_list': all_voipcall_list,
        'voipcall_list': voipcall_list,
        'CDR_REPORT_COLUMN_NAME': CDR_REPORT_COLUMN_NAME,
        'col_name_with_order': pag_vars['col_name_with_order'],
        'start_date': start_date,
        'end_date': end_date,
        'action': action,
    }
    request.session['msg'] = ''
    request.session['error_msg'] = ''
    return render_to_response('dialer_cdr/voipcall_report.html', data, context_instance=RequestContext(request))

Example 134

Project: dndtools Source File: views.py
@menu_item(MenuItem.CHARACTER_OPTIONS)
@submenu_item(MenuItem.CharacterOptions.SKILLS)
def skill_detail(request, skill_slug, rulebook_slug=None,
                 rulebook_id=None):
    # fetch the class
    skill = get_object_or_404(Skill.objects.select_related(
        'skill_variant', 'skill_variant__rulebook'), slug=skill_slug)

    # fetch primary variant, this is independent of rulebook selected
    try:
        primary_variant = SkillVariant.objects.select_related(
            'rulebook', 'rulebook__dnd_edition',
        ).filter(
            skill=skill,
        ).order_by('-rulebook__dnd_edition__core', '-rulebook__published')[0]
    except Exception:
        primary_variant = None

    # if rulebook is supplied, select find this variant
    if rulebook_slug and rulebook_id:
        # use canonical link in head as this is more or less duplicated content
        use_canonical_link = True
        selected_variant = get_object_or_404(
            SkillVariant.objects.select_related(
                'rulebook', 'skill', 'rulebook__dnd_edition'),
            skill__slug=skill_slug,
            rulebook__pk=rulebook_id)

        # possible malformed/changed slug
        if rulebook_slug != selected_variant.rulebook.slug:
            return permanent_redirect_object(request, selected_variant)

        # selected variant is primary! Redirect to canonical url
        if selected_variant == primary_variant:
            return permanent_redirect_view(
                request, skill_detail, kwargs={
                    'skill_slug': skill_slug}
            )
    else:
        # this is canonical, no need to specify it
        use_canonical_link = False
        selected_variant = primary_variant

    other_variants = [
        variant
        for variant
        in skill.skillvariant_set.select_related(
            'rulebook', 'rulebook__dnd_edition', 'skill').all()
        if variant != selected_variant
    ]

    if selected_variant:
        display_3e_warning = is_3e_edition(selected_variant.rulebook.dnd_edition)
    else:
        display_3e_warning = False

    feat_list = skill.required_by_feats.select_related('rulebook').all()
    feat_paginator = DndPaginator(feat_list, request)

    return render_to_response('dnd/skills/skill_detail.html',
                              {
                                  'skill': skill,
                                  'feat_list': feat_paginator.items(),
                                  'feat_paginator': feat_paginator,
                                  'request': request,
                                  'i_like_it_url': request.build_absolute_uri(),
                                  'inaccurate_url': request.build_absolute_uri(),
                                  'selected_variant': selected_variant,
                                  'other_variants': other_variants,
                                  'use_canonical_link': use_canonical_link,
                                  'display_3e_warning': display_3e_warning,
                              }, context_instance=RequestContext(request), )

Example 135

Project: newfies-dialer Source File: views.py
@permission_required('dialer_campaign.view_dashboard', login_url='/')
@login_required
def customer_dashboard(request, on_index=None):
    """Customer dashboard gives the following information

        * Total Campaigns contacts
        * Amount of contact reached today
        * Disposition of calls via pie chart
        * Call records & Duration of calls are shown on graph by days/hours

    **Attributes**:

        * ``template`` - frontend/dashboard.html
        * ``form`` - DashboardForm
    """
    logging.debug('Start Dashboard')
    # All campaign for logged in User
    campaign_id_list = Campaign.objects.values_list('id', flat=True).filter(user=request.user).order_by('id')

    # Contacts count which are active and belong to those phonebook(s) which is
    # associated with all campaign
    pb_active_contact_count = Contact.objects\
        .filter(phonebook__campaign__in=campaign_id_list, status=CONTACT_STATUS.ACTIVE).count()

    form = DashboardForm(request.user, request.POST or None)
    logging.debug('Got Campaign list')

    total_record = dict()
    total_duration_sum = 0
    total_billsec_sum = 0
    total_call_count = 0
    total_answered = 0
    total_not_answered = 0
    total_busy = 0
    total_cancel = 0
    total_congestion = 0
    total_failed = 0
    search_type = SEARCH_TYPE.D_Last_24_hours  # default Last 24 hours
    selected_campaign = ''

    if campaign_id_list:
        selected_campaign = campaign_id_list[0]  # default campaign id

    # selected_campaign should not be empty
    if selected_campaign:
        if form.is_valid():
            selected_campaign = request.POST['campaign']
            search_type = request.POST['search_type']

        end_date = datetime.utcnow().replace(tzinfo=utc)
        start_date = calculate_date(search_type)

        # date_length is used to do group by starting_date
        if int(search_type) >= SEARCH_TYPE.B_Last_7_days:  # all options except 30 days
            date_length = 13
            if int(search_type) == SEARCH_TYPE.C_Yesterday:  # yesterday
                tday = datetime.utcnow().replace(tzinfo=utc)
                start_date = datetime(tday.year, tday.month, tday.day, 0, 0, 0, 0)\
                    .replace(tzinfo=utc) - relativedelta(days=1)
                end_date = datetime(tday.year, tday.month, tday.day, 23, 59, 59, 999999)\
                    .replace(tzinfo=utc) - relativedelta(days=1)
            if int(search_type) >= SEARCH_TYPE.E_Last_12_hours:
                date_length = 16
        else:
            date_length = 10  # Last 30 days option

        select_data = {
            "starting_date": "SUBSTR(CAST(starting_date as CHAR(30)),1,%s)" % str(date_length)
        }

        # This calls list is used by pie chart
        calls = VoIPCall.objects\
            .filter(callrequest__campaign=selected_campaign,
                    duration__isnull=False,
                    user=request.user,
                    starting_date__range=(start_date, end_date))\
            .extra(select=select_data)\
            .values('starting_date', 'disposition')\
            .annotate(Count('starting_date'))\
            .order_by('starting_date')

        logging.debug('Aggregate VoIPCall')

        for i in calls:
            total_call_count += i['starting_date__count']
            if i['disposition'] == CALL_DISPOSITION.ANSWER or i['disposition'] == 'NORMAL_CLEARING':
                total_answered += i['starting_date__count']
            elif i['disposition'] == CALL_DISPOSITION.BUSY or i['disposition'] == 'USER_BUSY':
                total_busy += i['starting_date__count']
            elif i['disposition'] == CALL_DISPOSITION.NOANSWER or i['disposition'] == 'NO_ANSWER':
                total_not_answered += i['starting_date__count']
            elif i['disposition'] == CALL_DISPOSITION.CANCEL or i['disposition'] == 'ORIGINATOR_CANCEL':
                total_cancel += i['starting_date__count']
            elif i['disposition'] == CALL_DISPOSITION.CONGESTION or i['disposition'] == 'NORMAL_CIRCUIT_CONGESTION':
                total_congestion += i['starting_date__count']
            else:
                # VOIP CALL FAILED
                total_failed += i['starting_date__count']

        # following calls list is without disposition & group by call date
        calls = VoIPCall.objects\
            .filter(callrequest__campaign=selected_campaign,
                    duration__isnull=False,
                    user=request.user,
                    starting_date__range=(start_date, end_date))\
            .extra(select=select_data)\
            .values('starting_date')\
            .annotate(Sum('duration'))\
            .annotate(Sum('billsec'))\
            .annotate(Avg('duration'))\
            .annotate(Count('starting_date'))\
            .order_by('starting_date')

        logging.debug('Aggregate VoIPCall (2)')

        mintime = start_date
        maxtime = end_date
        calls_dict = {}
        calls_dict_with_min = {}

        for call in calls:
            total_duration_sum += call['duration__sum']
            total_billsec_sum += call['billsec__sum']
            if int(search_type) >= SEARCH_TYPE.B_Last_7_days:
                ctime = datetime(int(call['starting_date'][0:4]),
                                 int(call['starting_date'][5:7]),
                                 int(call['starting_date'][8:10]),
                                 int(call['starting_date'][11:13]),
                                 0,
                                 0,
                                 0).replace(tzinfo=utc)
                if int(search_type) >= SEARCH_TYPE.E_Last_12_hours:
                    ctime = datetime(int(call['starting_date'][0:4]),
                                     int(call['starting_date'][5:7]),
                                     int(call['starting_date'][8:10]),
                                     int(call['starting_date'][11:13]),
                                     int(call['starting_date'][14:16]),
                                     0,
                                     0).replace(tzinfo=utc)
            else:
                ctime = datetime(int(call['starting_date'][0:4]),
                                 int(call['starting_date'][5:7]),
                                 int(call['starting_date'][8:10]),
                                 0,
                                 0,
                                 0,
                                 0).replace(tzinfo=utc)
            if ctime > maxtime:
                maxtime = ctime
            elif ctime < mintime:
                mintime = ctime

            # all options except 30 days
            if int(search_type) >= SEARCH_TYPE.B_Last_7_days:
                calls_dict[int(ctime.strftime("%Y%m%d%H"))] =\
                    {
                        'call_count': call['starting_date__count'],
                        'duration_sum': call['duration__sum'],
                        'duration_avg': float(call['duration__avg']),
                }

                calls_dict_with_min[int(ctime.strftime("%Y%m%d%H%M"))] =\
                    {
                        'call_count': call['starting_date__count'],
                        'duration_sum': call['duration__sum'],
                        'duration_avg': float(call['duration__avg']),
                }
            else:
                # Last 30 days option
                calls_dict[int(ctime.strftime("%Y%m%d"))] =\
                    {
                        'call_count': call['starting_date__count'],
                        'duration_sum': call['duration__sum'],
                        'duration_avg': float(call['duration__avg']),
                }

        logging.debug('After Call Loops')

        dateList = date_range(mintime, maxtime, q=search_type)

        for date in dateList:
            inttime = int(date.strftime("%Y%m%d"))

            # last 7 days | yesterday | last 24 hrs
            if int(search_type) == SEARCH_TYPE.B_Last_7_days \
                or int(search_type) == SEARCH_TYPE.C_Yesterday \
                    or int(search_type) == SEARCH_TYPE.D_Last_24_hours:

                for option in range(0, 24):
                    day_time = int(str(inttime) + str(option).zfill(2))

                    graph_day = datetime(int(date.strftime("%Y")),
                                         int(date.strftime("%m")),
                                         int(date.strftime("%d")),
                                         int(str(option).zfill(2))).replace(tzinfo=utc)

                    dt = int(1000 * time.mktime(graph_day.timetuple()))
                    total_record[dt] = {
                        'call_count': 0,
                        'duration_sum': 0,
                        'duration_avg': 0.0,
                    }

                    if day_time in calls_dict.keys():
                        total_record[dt]['call_count'] += calls_dict[day_time]['call_count']
                        total_record[dt]['duration_sum'] += calls_dict[day_time]['duration_sum']
                        total_record[dt]['duration_avg'] += float(calls_dict[day_time]['duration_avg'])

            # last 12 hrs | last 6 hrs | last 1 hr
            elif (int(search_type) == SEARCH_TYPE.E_Last_12_hours
                  or int(search_type) == SEARCH_TYPE.F_Last_6_hours
                  or int(search_type) == SEARCH_TYPE.G_Last_hour):

                for hour in range(0, 24):
                    for minute in range(0, 60):
                        hr_time = int(str(inttime) + str(hour).zfill(2) + str(minute).zfill(2))

                        graph_day = datetime(int(date.strftime("%Y")),
                                             int(date.strftime("%m")),
                                             int(date.strftime("%d")),
                                             int(str(hour).zfill(2)),
                                             int(str(minute).zfill(2))).replace(tzinfo=utc)

                        dt = int(1000 * time.mktime(graph_day.timetuple()))
                        total_record[dt] = {
                            'call_count': 0,
                            'duration_sum': 0,
                            'duration_avg': 0.0,
                        }

                        if hr_time in calls_dict_with_min.keys():
                            total_record[dt]['call_count'] += calls_dict_with_min[hr_time]['call_count']
                            total_record[dt]['duration_sum'] += calls_dict_with_min[hr_time]['duration_sum']
                            total_record[dt]['duration_avg'] += float(calls_dict_with_min[hr_time]['duration_avg'])
            else:
                # Default: Last 30 days option
                graph_day = datetime(int(date.strftime("%Y")),
                                     int(date.strftime("%m")),
                                     int(date.strftime("%d"))).replace(tzinfo=utc)
                dt = int(1000 * time.mktime(graph_day.timetuple()))
                total_record[dt] = {
                    'call_count': 0,
                    'duration_sum': 0,
                    'duration_avg': 0,
                }
                if inttime in calls_dict.keys():
                    total_record[dt]['call_count'] += calls_dict[inttime]['call_count']
                    total_record[dt]['duration_sum'] += calls_dict[inttime]['duration_sum']
                    total_record[dt]['duration_avg'] += float(calls_dict[inttime]['duration_avg'])

    logging.debug('After dateList Loops')

    # sorting on date col
    total_record = total_record.items()
    total_record = sorted(total_record, key=lambda k: k[0])

    # lineplusbarwithfocuschart
    final_charttype = "linePlusBarChart"
    xdata = []
    ydata = []
    ydata2 = []
    for i in total_record:
        xdata.append(i[0])
        ydata.append(i[1]['call_count'])
        ydata2.append(i[1]['duration_sum'])

    tooltip_date = "%d %b %y %H:%M %p"
    kwargs1 = {}
    kwargs1['bar'] = True
    extra_serie1 = {"tooltip": {"y_start": "", "y_end": " calls"}, "date_format": tooltip_date}
    extra_serie2 = {"tooltip": {"y_start": "", "y_end": " sec"}, "date_format": tooltip_date}

    final_chartdata = {
        'x': xdata,
        'name1': 'Calls', 'y1': ydata, 'extra1': extra_serie1, 'kwargs1': kwargs1,
        'name2': 'Duration', 'y2': ydata2, 'extra2': extra_serie2,
    }

    # Contacts which are successfully called for running campaign
    reached_contact = 0
    if campaign_id_list:
        tday = datetime.utcnow().replace(tzinfo=utc)
        start_date = datetime(tday.year, tday.month, tday.day, 0, 0, 0, 0).replace(tzinfo=utc)
        end_date = datetime(tday.year, tday.month, tday.day, 23, 59, 59, 999999).replace(tzinfo=utc)
        reached_contact = Subscriber.objects\
            .filter(campaign_id__in=campaign_id_list,  # status=5,
                    updated_date__range=(start_date, end_date))\
            .count()

    # PieChart
    hangup_analytic_charttype = "pieChart"
    xdata = []
    ydata = []
    hangup_analytic_chartdata = {'x': xdata, 'y1': ydata}
    if total_call_count != 0:
        for i in CALL_DISPOSITION:
            xdata.append(i[0])

        # Y-axis order depend upon CALL_DISPOSITION
        # 'ANSWER', 'BUSY', 'CANCEL', 'CONGESTION', 'FAILED', 'NOANSWER'
        ydata = [percentage(total_answered, total_call_count),
                 percentage(total_busy, total_call_count),
                 percentage(total_cancel, total_call_count),
                 percentage(total_congestion, total_call_count),
                 percentage(total_failed, total_call_count),
                 percentage(total_not_answered, total_call_count)]

        color_list = [
            COLOR_DISPOSITION['ANSWER'],
            COLOR_DISPOSITION['BUSY'],
            COLOR_DISPOSITION['CANCEL'],
            COLOR_DISPOSITION['CONGESTION'],
            COLOR_DISPOSITION['FAILED'],
            COLOR_DISPOSITION['NOANSWER'],
        ]

        extra_serie = {"tooltip": {"y_start": "", "y_end": " %"},
                       "color_list": color_list}
        hangup_analytic_chartdata = {'x': xdata, 'y1': ydata, 'extra1': extra_serie}

    data = {
        'form': form,
        'campaign_phonebook_active_contact_count': pb_active_contact_count,
        'reached_contact': reached_contact,
        'total_duration_sum': total_duration_sum,
        'total_billsec_sum': total_billsec_sum,
        'total_call_count': total_call_count,
        'total_answered': total_answered,
        'total_not_answered': total_not_answered,
        'total_busy': total_busy,
        'total_cancel': total_cancel,
        'total_congestion': total_congestion,
        'total_failed': total_failed,
        'answered_color': COLOR_DISPOSITION['ANSWER'],
        'busy_color': COLOR_DISPOSITION['BUSY'],
        'not_answered_color': COLOR_DISPOSITION['NOANSWER'],
        'cancel_color': COLOR_DISPOSITION['CANCEL'],
        'congestion_color': COLOR_DISPOSITION['CONGESTION'],
        'failed_color': COLOR_DISPOSITION['FAILED'],
        'CALL_DISPOSITION': CALL_DISPOSITION,
        'hangup_analytic_chartdata': hangup_analytic_chartdata,
        'hangup_analytic_charttype': hangup_analytic_charttype,
        'hangup_chartcontainer': 'piechart_container',
        'hangup_extra': {
            'x_is_date': False,
            'x_axis_format': '',
            'tag_script_js': True,
            'jquery_on_ready': True,
        },
        'final_chartdata': final_chartdata,
        'final_charttype': final_charttype,
        'final_chartcontainer': 'lineplusbarwithfocuschart_container',
        'final_extra': {
            'x_is_date': True,
            'x_axis_format': '%d %b %Y',
            'tag_script_js': True,
            'jquery_on_ready': True,
            'resize': True,
            'focus_enable': True,
        }
    }
    if on_index == 'yes':
        return data
    return render_to_response('frontend/dashboard.html', data, context_instance=RequestContext(request))

Example 136

Project: imaginationforpeople Source File: views.py
def project_sheet_edit_question(request, slug, question_id):
    """
    Edit a question for a given project sheet translation 

    FIXME: Not sure if this is secure. Question may be assigned to
    projects that doesn't link to them.
    """
    language_code = translation.get_language()

    # Get project
    try:
        project_translation = get_project_translation_by_slug(slug, language_code)
    except I4pProjectTranslation.DoesNotExist:
        raise Http404

    # Get question
    question = get_object_or_404(Question, id=question_id)

    # Lookup the answer. If does not exist, create it.
    try:
        untrans_answer = Answer.objects.untranslated().get(project=project_translation.master,
                                                           question=question)
        if not language_code in untrans_answer.get_available_languages():
            untrans_answer.translate(language_code)
            untrans_answer.save()
    except Answer.DoesNotExist:
        answer = Answer.objects.create(project=project_translation.master, question=question)

    answer = Answer.objects.get(project=project_translation.master,
                                question=question)

    answer_form = AnswerForm(request.POST or None, instance=answer)

    if request.method == 'POST':
        if answer_form.is_valid():
            answer = answer_form.save()
            return redirect(project_translation)

    context = {}
    context['answer_form'] = answer_form
    context['question_id'] = question_id
    context['project_slug'] = slug

    return render_to_response(template_name="project_sheet/page/project_sheet_edit_question.html",
                              dictionary=context,
                              context_instance=RequestContext(request))

Example 137

Project: newfies-dialer Source File: views.py
@login_required
@permission_required('mod_sms.view_sms_report', login_url='/')
def sms_report(request):
    """SMS Report

    **Attributes**:

        * ``form`` - SMSSearchForm
        * ``template`` - mod_sms/sms_report.html

    **Logic Description**:

        * Get SMS list according to search parameters for logged-in user

    **Important variable**:

        * ``request.session['sms_record_kwargs']`` - stores sms kwargs
    """
    sort_col_field_list = ['send_date', 'recipient_number', 'uuid', 'status', 'status_message', 'gateway']
    pag_vars = get_pagination_vars(request, sort_col_field_list, default_sort_field='send_date')

    from_date = ''
    to_date = ''
    status = 'all'
    smscampaign = ''

    form = SMSSearchForm(request.user, request.POST or None)
    action = 'tabs-1'
    kwargs = {}
    post_var_with_page = 0
    if form.is_valid():
        post_var_with_page = 1
        field_list = ['start_date', 'end_date', 'status', 'smscampaign']
        unset_session_var(request, field_list)

        from_date = getvar(request, 'from_date')
        to_date = getvar(request, 'to_date')
        start_date = ceil_strdate(str(from_date), 'start')
        end_date = ceil_strdate(str(to_date), 'end')

        converted_start_date = start_date.strftime('%Y-%m-%d')
        converted_end_date = end_date.strftime('%Y-%m-%d')
        request.session['session_start_date'] = converted_start_date
        request.session['session_end_date'] = converted_end_date

        status = getvar(request, 'status', setsession=True)
        smscampaign = getvar(request, 'smscampaign', setsession=True)

    if request.GET.get('page') or request.GET.get('sort_by'):
        post_var_with_page = 1
        start_date = request.session.get('session_start_date')
        end_date = request.session.get('session_end_date')
        start_date = ceil_strdate(start_date, 'start')
        end_date = ceil_strdate(end_date, 'end')
        status = request.session.get('session_status')
        smscampaign = request.session.get('session_smscampaign')

        form = SMSSearchForm(request.user,
                             initial={'from_date': start_date.strftime('%Y-%m-%d'),
                                      'to_date': end_date.strftime('%Y-%m-%d'),
                                      'status': status,
                                      'smscampaign': smscampaign})

    if post_var_with_page == 0:
        # default
        tday = datetime.utcnow().replace(tzinfo=utc)
        from_date = tday.strftime('%Y-%m-%d')
        to_date = tday.strftime('%Y-%m-%d')
        start_date = datetime(tday.year, tday.month, tday.day, 0, 0, 0, 0).replace(tzinfo=utc)
        end_date = datetime(tday.year, tday.month, tday.day, 23, 59, 59, 999999).replace(tzinfo=utc)
        status = 'all'
        smscampaign = ''
        form = SMSSearchForm(request.user, initial={'from_date': from_date, 'to_date': to_date,
                                                    'status': status, 'smscampaign': smscampaign})
        # unset session var
        request.session['session_start_date'] = start_date
        request.session['session_end_date'] = end_date
        request.session['session_status'] = status
        request.session['session_smscampaign'] = smscampaign

    kwargs['sender'] = request.user

    if start_date and end_date:
        kwargs['send_date__range'] = (start_date, end_date)
    if start_date and end_date == '':
        kwargs['send_date__gte'] = start_date
    if start_date == '' and end_date:
        kwargs['send_date__lte'] = end_date

    if status and status != 'all':
        kwargs['status__exact'] = status

    if smscampaign and smscampaign != '0':
        kwargs['sms_campaign_id'] = smscampaign

    smslist = SMSMessage.objects.filter(**kwargs)
    all_sms_list = smslist.values_list('id', flat=True)
    sms_list = smslist.order_by(pag_vars['sort_order'])[pag_vars['start_page']:pag_vars['end_page']]

    # Session variable is used to get record set with searched option
    # into export file
    request.session['sms_record_kwargs'] = kwargs

    select_data = {"send_date": "SUBSTR(CAST(send_date as CHAR(30)),1,10)"}
    # Get Total Rrecords from SMSMessage Report table for Daily SMS Report
    total_data = all_sms_list.extra(select=select_data).values('send_date')\
        .annotate(Count('send_date')).order_by('-send_date')

    # Following code will count total sms
    if total_data.count() != 0:
        total_sms = sum([x['send_date__count'] for x in total_data])
    else:
        total_sms = 0

    data = {
        'form': form,
        'from_date': from_date,
        'all_sms_list': all_sms_list,
        'sms_list': sms_list,
        'sms_count': all_sms_list.count() if all_sms_list else 0,
        'SMS_REPORT_COLUMN_NAME': SMS_REPORT_COLUMN_NAME,
        'col_name_with_order': pag_vars['col_name_with_order'],
        'start_date': start_date,
        'end_date': end_date,
        'to_date': to_date,
        'action': action,
        'status': status,
        'total_data': total_data.reverse(),
        'total_sms': total_sms,
    }

    return render_to_response('mod_sms/sms_report.html', data, context_instance=RequestContext(request))

Example 138

Project: aemanager Source File: views.py
@disabled_for_demo
@settings_required
@commit_on_success
def comment_create_or_edit(request, id=None, issue_id=None):
    if id:
        title = _('Edit a comment')
        comment = get_object_or_404(Comment,
                                    pk=id,
                                    owner=request.user,
                                    issue__category__in=[ISSUE_CATEGORY_BUG, ISSUE_CATEGORY_FEATURE])
        issue = comment.issue
        mail_subject = _('A comment has been updated')
    else:
        title = _('Send a comment')
        comment = None
        issue = get_object_or_404(Issue,
                                  pk=issue_id,
                                  category__in=[ISSUE_CATEGORY_BUG, ISSUE_CATEGORY_FEATURE])
        mail_subject = _('A comment has been added')

    if request.method == 'POST':
        form = CommentForm(request.POST, instance=comment)
        if form.is_valid():
            comment = form.save(commit=False)
            comment.issue = issue
            comment.update_date = datetime.datetime.now()
            comment.owner = request.user
            comment.save()

            domain = Site.objects.get_current().domain
            # notify admin
            mail_message = _('%(issue_subject)s : %(issue_url)s') % {'issue_subject': issue.subject,
                                                                     'issue_url': 'https://%s%s' % (domain, reverse('issue_detail', kwargs={'id': issue.id}))}
            mail_admins(mail_subject, mail_message, fail_silently=(not settings.DEBUG))
            # notify users who have commented except owner of this comment
            emails_to_notify = issue.emails_to_notify()
            emails_to_notify.remove(comment.owner.email)
            notification_subject = _('A new comment has been added on issue #%(id)d') % {'id': issue.id}
            notification_message = _("%(user)s wrote:") % {'user': display_name(comment.owner)}
            notification_message = "%s\n\n%s\n\n%s" % ('https://%s%s' % (domain,
                                                                         reverse('issue_detail',
                                                                                 kwargs={'id': issue.id})),
                                                       notification_message,
                                                       comment.message)
            notification_messages = []
            for email in emails_to_notify:
                notification_messages.append((notification_subject,
                                              notification_message,
                                              settings.DEFAULT_FROM_EMAIL,
                                              [email]))
            send_mass_mail(notification_messages, fail_silently=(not settings.DEBUG))

            messages.success(request, _('Your comment has been saved successfully'))
            return redirect(reverse('issue_detail', kwargs={'id': issue.id}))
    else:
        form = CommentForm(instance=comment)

    return render_to_response('comment/edit.html',
                              {'active': 'settings',
                               'title': title,
                               'form': form},
                              context_instance=RequestContext(request))

Example 139

Project: django-tcms Source File: views.py
Function: render
def _render(tpl, ctx, req):
    """Renders to response loading request context"""
    return render_to_response(tpl, ctx, RequestContext(req))

Example 140

Project: django-wkhtmltopdf Source File: utils.py
def render_to_temporary_file(template, context, request=None, mode='w+b',
                             bufsize=-1, suffix='.html', prefix='tmp',
                             dir=None, delete=True):
    if django.VERSION < (1, 8):
        # If using a version of Django prior to 1.8, ensure ``context`` is an
        # instance of ``Context``
        if not isinstance(context, Context):
            if request:
                context = RequestContext(request, context)
            else:
                context = Context(context)
        content = template.render(context)
    else:
        content = template.render(context, request)

    content = smart_text(content)
    content = make_absolute_paths(content)

    try:
        # Python3 has 'buffering' arg instead of 'bufsize'
        tempfile = NamedTemporaryFile(mode=mode, buffering=bufsize,
                                      suffix=suffix, prefix=prefix,
                                      dir=dir, delete=delete)
    except TypeError:
        tempfile = NamedTemporaryFile(mode=mode, bufsize=bufsize,
                                      suffix=suffix, prefix=prefix,
                                      dir=dir, delete=delete)

    try:
        tempfile.write(content.encode('utf-8'))
        tempfile.flush()
        return tempfile
    except:
        # Clean-up tempfile if an Exception is raised.
        tempfile.close()
        raise

Example 141

Project: repowatcher Source File: authed.py
@login_required
def authed_watched(request):
    repo_link_type, _ = LinkType.objects.get_or_create(name = "starred")
    repositories_by_language = defaultdict(list)
    github_repositories_by_language = defaultdict(list)
    bitbucket_repositories_by_language = defaultdict(list)
    bitbucket_authed = True
    github_authed = True
    owned = False
    user = request.user
    github_username = None
    bitbucket_username = None
    try:
        github_username = user.social_auth.get(provider='github').extra_data['username']
        github_provider = GithubProvider(user)
        github_repositories_by_language, github_repository_user = github_provider.retrieve_repositories_dict(github_username,"starred")
        if len(github_repositories_by_language) == 0:
            watched = github_provider.get_repositories(github_username, "starred")
            count = 0
            for repo in watched:
                update = False
                try:
                    repository = Repository.objects.get(host_slug= 'github/'+repo['owner'].lower() + '/' + repo['name'].lower())
                except ObjectDoesNotExist:
                    update = True
                    repository = Repository()
                if update or (datetime.now() - repository.last_modified) > timedelta(days = 1):
                    repository = github_provider.create_or_update_repository_details(repo, repository)
                    if not repository.private:
                        repository.save()
                if not repository.private:
                    count += 1
                    RepositoryUserRepositoryLink.objects.get_or_create(user = github_repository_user, repository = repository, link_type = repo_link_type)

                github_repositories_by_language[repository.language].append(repository)
            for category in github_repositories_by_language.keys():
                RepositoryCategory.objects.get_or_create(name=category)
                repositories_by_language[category].extend(github_repositories_by_language[category])
            for category in repositories_by_language.keys():
                repositories_by_language[category].sort(key=lambda x: x.watchers, reverse = True)
            github_repository_user.starred = count
            github_repository_user.save()
        else:
            for category in github_repositories_by_language.keys():
                repositories_by_language[category].extend(github_repositories_by_language[category])
    except ObjectDoesNotExist:
        github_authed = False
    try:
        bitbucket_username = user.social_auth.get(provider='bitbucket').extra_data['username']
        bitbucket_provider = BitbucketProvider(user)
        bitbucket_repositories_by_language, bitbucket_repository_user = bitbucket_provider.retrieve_watched_repositories_dict(bitbucket_username)
        if len(bitbucket_repositories_by_language) == 0:
            watched = bitbucket_provider.get_watched_repositories(bitbucket_username)
            count = 0
            for repo in watched:
                update = False
                try:
                    repository = bitbucket_provider.retrieve_repository_details(repo['owner'], repo['name'])
                except ObjectDoesNotExist:
                    update = True
                    repository = Repository()
                if update or (datetime.now() - repository.last_modified) > timedelta(days = 1):
                    repository = bitbucket_provider.create_or_update_repository_details(repo, repository)
                    if not repository.private:
                        count += 1
                        repository.save()
                bitbucket_repositories_by_language[repository.language].append(repository)
            for category in bitbucket_repositories_by_language.keys():
                RepositoryCategory.objects.get_or_create(name=category)
                repositories_by_language[category].extend(bitbucket_repositories_by_language[category])
            for category in repositories_by_language.keys():
                repositories_by_language[category].sort(key=lambda x: x.watchers, reverse = True)
            bitbucket_repository_user.starred = count
        else:
            for category in bitbucket_repositories_by_language.keys():
                repositories_by_language[category].extend(bitbucket_repositories_by_language[category])
    except ObjectDoesNotExist:
        bitbucket_authed = False
    if bitbucket_authed or github_authed:
        return render_to_response('username_watched.html', {'github_username': github_username,'github_authed': github_authed,'bitbucket_username':bitbucket_username, 'bitbucket_authed':bitbucket_authed, 'repositories_by_language':sorted(dict(repositories_by_language).iteritems(),key=lambda (k, v): len(v),reverse = True),'owned':owned},context_instance=RequestContext(request))
    else:
        return HttpResponseRedirect(reverse('repowatcher.main.views.authed'))

Example 142

Project: django-datagrid Source File: grids.py
Function: render_to_response
    def render_to_response(self, template_name, extra_context={}):
        """
        Renders a template containing this datagrid as a context variable.
        """
        self.handle_search()
        self.handle_filter()
        self.load_state()


        # If the caller is requesting just this particular grid, return it.
        if self.request.GET.get('gridonly', False) and \
           self.request.GET.get('datagrid-id', None) == self.id:
            return self.render_listview_to_response()

        context = {
            'datagrid': self
        }
        context.update(extra_context)
        context.update(self.extra_context)
        if self.request.GET.get('is_pdf', None):
            import ho.pisa as pisa
            file_data = render_to_string('datagrid/as_pdf.pdf', context)
            myfile = StringIO.StringIO()
            pisa.CreatePDF(file_data, myfile)
            myfile.seek(0)
            response =  HttpResponse(myfile, mimetype='application/pdf')
            response['Content-Disposition'] = 'attachment; filename=data.pdf'
            return response
        elif self.request.GET.get('is_csv', None):
            file_data = render_to_string('datagrid/as_csv.csv', context)
            response =  HttpResponse(file_data, mimetype='text.csv')
            response['Content-Disposition'] = 'attachment; filename=data.csv'
            return response


        return render_to_response(template_name, RequestContext(self.request,
                                                                context))

Example 143

Project: repowatcher Source File: authed.py
@login_required
def authed_category_watched(request,category):
    """has all github repos and the latest 30 events for a username with a specific category"""
    repo_link_type, _ = LinkType.objects.get_or_create(name = "starred")
    owned = False
    category = urllib.unquote(category).lower()
    github_watched_filtered = []
    bitbucket_watched_filtered = []
    github_repo_events = []
    bitbucket_repo_events = []
    user = request.user
    repository_user = None
    github_username = None
    bitbucket_username = None
    bitbucket_authed = True
    github_authed = True
    watched_filtered = []
    try:
        github_username = user.social_auth.get(provider='github').extra_data['username']
        github_provider = GithubProvider(user)
        github_watched_filtered, github_repository_user = github_provider.retrieve_category_repositories(github_username, category, "starred")
        watched_filtered.extend(github_watched_filtered)
        github_repository_user.save()
        if len(github_watched_filtered) == 0:
            watched = github_provider.get_repositories(github_username, "starred")

            count = 0
            for repo in watched:
                update = False
                try:
                    repository = Repository.objects.get(host_slug= 'github/'+repo['owner'].lower() + '/' + repo['name'].lower())
                except ObjectDoesNotExist:
                    update = True
                    repository = Repository()
                if update or (datetime.now() - repository.last_modified) > timedelta(days = 1):
                    repository = github_provider.create_or_update_repository_details(repo, repository)
                    if not repository.private:
                        repository.save()
                if repository.language == category:
                    github_watched_filtered.append(repository)
                    if not repository.private:
                        count += 1
                if not repository.private:
                    RepositoryUserRepositoryLink.objects.get_or_create(user = repository_user, repository = repository, link_type = repo_link_type)
            watched_filtered.extend(github_watched_filtered)
            watched_filtered.sort(key=lambda x: x.watchers, reverse = True)
            RepositoryCategory.objects.get_or_create(name = category.lower())
            github_repository_user.starred = count
            github_repository_user.save()


        # Get repository events
        github_repo_events = github_provider.get_repositories_events(github_watched_filtered)
        for github_repo_event in github_repo_events:
            github_repo_event['host'] = 'github'
            github_repo_event['created_on'] = dateutil.parser.parse(github_repo_event['created_at'])
    except ObjectDoesNotExist:
        github_authed = False

    user = request.user
    try:
        bitbucket_username = user.social_auth.get(provider='bitbucket').extra_data['username']
        bitbucket_provider = BitbucketProvider(user)
        bitbucket_watched_filtered, bitbucket_repository_user = bitbucket_provider.retrieve_watched_category_repositories(bitbucket_username, category)
        watched_filtered.extend(bitbucket_watched_filtered)
        bitbucket_repository_user.save()
        if len(bitbucket_watched_filtered) == 0:
            watched = bitbucket_provider.get_watched_repositories(bitbucket_username)
            for repo in watched:
                update = False
                try:
                    repository = Repository.objects.get(host_slug= 'bitbucket/'+repo['owner'].lower() + '/' + repo['name'].lower())
                except ObjectDoesNotExist:
                    update = True
                    repository = Repository()
                if update or (datetime.now() - repository.last_modified) > timedelta(days = 1):
                    bitbucket_provider.create_or_update_repository_details(repo, repository)
                    if not repository.private:
                        repository.save()
                if repository.language == category:
                    bitbucket_watched_filtered.append(repository)
            RepositoryCategory.objects.get_or_create(name = category)
            watched_filtered.extend(bitbucket_watched_filtered)
            watched_filtered.sort(key=lambda x: x.watchers, reverse = True)
        bitbucket_repo_events = bitbucket_provider.get_repositories_events(bitbucket_watched_filtered)
        for bitbucket_repo_event in bitbucket_repo_events:
            bitbucket_repo_event['host'] = 'bitbucket'
            bitbucket_repo_event['created_on'] = dateutil.parser.parse(bitbucket_repo_event['utc_created_on'])
    except ObjectDoesNotExist:
        bitbucket_authed = False
    repo_events = sorted(github_repo_events + bitbucket_repo_events,key=itemgetter('created_on'), reverse = True)[:30]
    if bitbucket_authed or github_authed:
        return render_to_response('username_category_watched.html', {'github_username': github_username,'github_authed': github_authed,'bitbucket_username':bitbucket_username, 'bitbucket_authed':bitbucket_authed, 'watched':watched_filtered, 'category':category, 'repo_events':repo_events,'owned':owned},context_instance=RequestContext(request))
    else:
        return HttpResponseRedirect(reverse('repowatcher.main.views.authed'))

Example 144

Project: django-embed-video Source File: tests_embed_video_tags.py
    def assertRenderedTemplate(self, template_string, output, context=None):
        response = RequestContext(HttpRequest(), context)
        rendered_output = Template(template_string).render(response)
        self.assertEqual(rendered_output.strip(), output.strip())

Example 145

Project: aemanager Source File: views.py
@csrf_exempt
@commit_on_success
def paypal_ipn(request):
    # send back the response to paypal
    data = dict(request.POST.items())
    args = {'cmd': '_notify-validate'}
    args.update(data)
    params = urllib.urlencode(dict([k, v.encode('utf-8')] for k, v in args.items()))
    paypal_response = urllib2.urlopen(settings.PAYPAL_URL + '/cgi-bin/webscr', params).read()

    # process the payment
    receiver_id = data['receiver_id']
    transaction_id = data['txn_id']
    payment_status = data['payment_status']
    payment_amount = data['mc_gross']
    payment_currency = data['mc_currency']
    fee = data['mc_fee']
    item_name = data['item_name']
    user_id = data['custom']
    user = get_object_or_404(User, pk=user_id)
    profile = user.get_profile()
    last_subscription = profile.get_last_subscription()

    subscription, created = Subscription.objects.get_or_create(transaction_id=transaction_id,
                                                               defaults={'owner': user,
                                                                         'state': SUBSCRIPTION_STATE_NOT_PAID,
                                                                         'expiration_date': profile.get_next_expiration_date(),
                                                                         'transaction_id': transaction_id,
                                                                         'error_message': ugettext('Not verified')})

    if paypal_response == 'VERIFIED':
        if receiver_id <> settings.PAYPAL_RECEIVER_ID:
            subscription.error_message = ugettext('Receiver is not as defined in settings. Spoofing ?')
        elif payment_status <> 'Completed':
            subscription.error_message = ugettext('Payment not completed')
        elif payment_amount <> settings.PAYPAL_APP_SUBSCRIPTION_AMOUNT:
            subscription.error_message = ugettext('Amount altered. Bad guy ?')
        elif payment_currency <> settings.PAYPAL_APP_SUBSCRIPTION_CURRENCY:
            subscription.error_message = ugettext('Amount altered. Bad guy ?')
        else:
            subscription.error_message = ugettext('Paid')
            subscription.state = SUBSCRIPTION_STATE_PAID

            # create an invoice for this payment
            # first, get the provider user
            provider = User.objects.get(email=settings.SERVICE_PROVIDER_EMAIL)
            if provider.get_profile().vat_number:
                payment_amount = Decimal(payment_amount) / Decimal('1.196')

            # look for a customer corresponding to user
            address, created = Address.objects.get_or_create(contact__email=user.email,
                                                             owner=provider,
                                                             defaults={'street': profile.address.street,
                                                                       'zipcode': profile.address.zipcode,
                                                                       'city': profile.address.city,
                                                                       'country': profile.address.country,
                                                                       'owner': provider})
            customer, created = Contact.objects.get_or_create(email=user.email,
                                                              defaults={'contact_type': CONTACT_TYPE_COMPANY,
                                                                        'name': '%s %s' % (user.first_name, user.last_name),
                                                                        'company_id': profile.company_id,
                                                                        'legal_form': 'Auto-entrepreneur',
                                                                        'email': user.email,
                                                                        'address': address,
                                                                        'owner': provider})
            # create a related project if needed
            # set it to finished to clear daily business
            project, created = Project.objects.get_or_create(state=PROJECT_STATE_FINISHED,
                                                             customer=customer,
                                                             name='Subscription %s - %s %s' % (Site.objects.get_current().name, user.first_name, user.last_name),
                                                             defaults={'state': PROJECT_STATE_FINISHED,
                                                                       'customer': customer,
                                                                       'name': 'Subscription %s - %s %s' % (Site.objects.get_current().name, user.first_name, user.last_name),
                                                                       'owner': provider})

            # create proposal for this subscription
            begin_date = datetime.date.today()
            if begin_date < last_subscription.expiration_date:
                begin_date = last_subscription.expiration_date

            proposal = Proposal.objects.create(project=project,
                                               reference='subscription%i%i%i' % (subscription.expiration_date.year,
                                                                                  subscription.expiration_date.month,
                                                                                  subscription.expiration_date.day),
                                               state=PROPOSAL_STATE_BALANCED,
                                               begin_date=begin_date,
                                               end_date=subscription.expiration_date,
                                               contract_content='',
                                               update_date=datetime.date.today(),
                                               expiration_date=None,
                                               owner=provider)

            unit_price = Decimal(settings.PAYPAL_APP_SUBSCRIPTION_AMOUNT)
            if provider.get_profile().vat_number:
                unit_price = Decimal(unit_price) / Decimal('1.196')

            proposal_row = ProposalRow.objects.create(proposal=proposal,
                                                      label=item_name,
                                                      category=ROW_CATEGORY_SERVICE,
                                                      quantity=1,
                                                      unit_price='%s' % unit_price,
                                                      owner=provider)

            # finally create invoice
            invoice = Invoice.objects.create(customer=customer,
                                             invoice_id=Invoice.objects.get_next_invoice_id(provider),
                                             state=INVOICE_STATE_PAID,
                                             amount=payment_amount,
                                             edition_date=datetime.date.today(),
                                             payment_date=datetime.date.today(),
                                             paid_date=datetime.date.today(),
                                             payment_type=PAYMENT_TYPE_BANK_CARD,
                                             execution_begin_date=begin_date,
                                             execution_end_date=subscription.expiration_date,
                                             penalty_date=None,
                                             penalty_rate=None,
                                             discount_conditions=None,
                                             owner=provider)

            invoice_row = InvoiceRow.objects.create(proposal=proposal,
                                                    invoice=invoice,
                                                    label=item_name,
                                                    category=ROW_CATEGORY_SERVICE,
                                                    quantity=1,
                                                    unit_price=payment_amount,
                                                    balance_payments=True,
                                                    vat_rate=VAT_RATES_19_6,
                                                    owner=provider)
            # create expense for paypal fee
            expense = Expense.objects.create(date=datetime.date.today(),
                                             reference=transaction_id,
                                             supplier='Paypal',
                                             amount=fee,
                                             payment_type=PAYMENT_TYPE_BANK_CARD,
                                             description='Commission paypal',
                                             owner=provider)

            # generate invoice in pdf
            response = HttpResponse(mimetype='application/pdf')
            invoice.to_pdf(provider, response)

            subject_template = loader.get_template('core/subscription_paid_email_subject.html')
            subject_context = {'site_name': Site.objects.get_current().name}
            subject = subject_template.render(Context(subject_context))
            body_template = loader.get_template('core/subscription_paid_email.html')
            body_context = {'site_name': Site.objects.get_current().name,
                            'expiration_date': subscription.expiration_date}
            body = body_template.render(Context(body_context))
            email = EmailMessage(subject=subject,
                                 body=body,
                                 to=[user.email])
            email.attach('facture_%i.pdf' % (invoice.invoice_id), response.content, 'application/pdf')
            email.send(fail_silently=(not settings.DEBUG))

        subscription.save()

    return render_to_response('core/paypal_ipn.html',
                              {'active': 'account',
                               'title': _('Subscribe')},
                              context_instance=RequestContext(request))

Example 146

Project: django-datagrid Source File: grids.py
    def render_listview(self):
        """
        Renders the standard list view of the grid.

        This can be called from templates.
        """
        self.handle_search()
        self.handle_filter()
        self.load_state()
        context = {
            'datagrid': self,
            'request': self.request,
            'is_paginated': self.page.has_other_pages(),
            'results_per_page': self.paginate_by,
            'has_next': self.page.has_next(),
            'has_previous': self.page.has_previous(),
            'page': self.page.number,
            'next': self.page.next_page_number(),
            'previous': self.page.previous_page_number(),
            'last_on_page': self.page.end_index(),
            'first_on_page': self.page.start_index(),
            'pages': self.paginator.num_pages,
            'hits': self.paginator.count,
            'page_range': self.paginator.page_range,
            'pagination_control_widget': self.pagination_control_widget,
            'get_pdf_link': self.get_pdf_link,
            'get_csv_link': self.get_csv_link,
            'filter_fields': self.filter_fields,
            'search_fields': self.search_fields,
            'filtering_options': self.filtering_options.items(),
        }


        context.update(self.extra_context)

        return mark_safe(render_to_string(self.listview_template,
            RequestContext(self.request, context)))

Example 147

Project: dndtools Source File: views.py
@menu_item(MenuItem.CHARACTER_OPTIONS)
@submenu_item(MenuItem.CharacterOptions.CLASSES)
def character_class_detail(request, character_class_slug, rulebook_slug=None,
                           rulebook_id=None):
    # fetch the class
    character_class = get_object_or_404(
        CharacterClass.objects.select_related('character_class_variant', 'character_class_variant__rulebook'),
        slug=character_class_slug)

    assert isinstance(character_class, CharacterClass)

    # fetch primary variant, this is independent of rulebook selected
    try:
        primary_variant = CharacterClassVariant.objects.select_related(
            'rulebook', 'rulebook__dnd_edition',
        ).filter(
            character_class=character_class,
        ).order_by('-rulebook__dnd_edition__core', '-rulebook__published')[0]
    except Exception:
        primary_variant = None

    # if rulebook is supplied, select find this variant
    if rulebook_slug and rulebook_id:
        # use canonical link in head as this is more or less duplicated content
        use_canonical_link = True
        selected_variant = get_object_or_404(
            CharacterClassVariant.objects.select_related(
                'rulebook', 'character_class', 'rulebook__dnd_edition'),
            character_class__slug=character_class_slug,
            rulebook__pk=rulebook_id)

        # possible malformed/changed slug
        if rulebook_slug != selected_variant.rulebook.slug:
            return permanent_redirect_object(request, selected_variant)

        # selected variant is primary! Redirect to canonical url
        if selected_variant == primary_variant:
            return permanent_redirect_view(
                request, character_class_detail, kwargs={
                    'character_class_slug': character_class_slug}
            )
    else:
        # this is canonical, no need to specify it
        use_canonical_link = False
        selected_variant = primary_variant

    other_variants = [
        variant
        for variant
        in character_class.characterclassvariant_set.select_related(
            'rulebook', 'rulebook__dnd_edition', 'character_class').all()
        if variant != selected_variant
    ]

    if selected_variant:
        required_races = selected_variant.required_races.select_related('race', 'race__rulebook').all()
        required_skills = selected_variant.required_skills.select_related('skill').all()
        required_feats = selected_variant.required_feats.select_related('feat', 'feat__rulebook').all()
        display_3e_warning = is_3e_edition(selected_variant.rulebook.dnd_edition)
    else:
        required_races = ()
        required_skills = ()
        required_feats = ()
        display_3e_warning = False

    return render_to_response('dnd/character_classes/character_class_detail.html',
                              {
                                  'character_class': character_class,
                                  'request': request,
                                  'i_like_it_url': request.build_absolute_uri(),
                                  'inaccurate_url': request.build_absolute_uri(),
                                  'selected_variant': selected_variant,
                                  'required_races': required_races,
                                  'required_skills': required_skills,
                                  'required_feats': required_feats,
                                  'other_variants': other_variants,
                                  'use_canonical_link': use_canonical_link,
                                  'display_3e_warning': display_3e_warning,
                              }, context_instance=RequestContext(request), )

Example 148

Project: feincms Source File: modeladmins.py
def assign_category(modeladmin, request, queryset):
    class AddCategoryForm(forms.Form):
        _selected_action = forms.CharField(widget=forms.MultipleHiddenInput)
        category = forms.ModelChoiceField(Category.objects.all())

    form = None
    if 'apply' in request.POST:
        form = AddCategoryForm(request.POST)
        if form.is_valid():
            category = form.cleaned_data['category']

            count = 0
            for mediafile in queryset:
                category.mediafile_set.add(mediafile)
                count += 1

            message = ungettext(
                'Successfully added %(count)d media file to %(category)s.',
                'Successfully added %(count)d media files to %(category)s.',
                count) % {'count': count, 'category': category}
            modeladmin.message_user(request, message)
            return HttpResponseRedirect(request.get_full_path())
    if 'cancel' in request.POST:
        return HttpResponseRedirect(request.get_full_path())

    if not form:
        form = AddCategoryForm(initial={
            '_selected_action': request.POST.getlist(
                admin.ACTION_CHECKBOX_NAME),
        })

    return render_to_response('admin/medialibrary/add_to_category.html', {
        'mediafiles': queryset,
        'category_form': form,
        'opts': modeladmin.model._meta,
    }, context_instance=RequestContext(request))

Example 149

Project: ganetimgr Source File: views.py
def activate_account(request, activation_key):
    # Normalize before trying anything with it.
    activation_key = activation_key.lower()
    account = CustomRegistrationProfile.objects.admin_activate_user(
        activation_key)
    context = RequestContext(request)

    if account:
        # the user must be emailed, not the admin
        email = render_to_string(
            "registration/activation_complete.txt",
            {
                "site": Site.objects.get_current(),
                "user": account
            }
        )
        send_mail(
            _("%s User account activated") % settings.EMAIL_SUBJECT_PREFIX,
            email,
            settings.SERVER_EMAIL,
            [account.email]
        )
    else:
        return render_to_response("registration/activate.html")

    return render_to_response(
        "registration/activate.html",
        {
            'account': account,
            'expiration_days': settings.ACCOUNT_ACTIVATION_DAYS
        },
        context_instance=context
    )

Example 150

Project: META-SHARE Source File: admin.py
    def add_user_to_editor_group(self, request, queryset):
        form = None
        if 'cancel' in request.POST:
            self.message_user(request, _('Cancelled adding users to the editor group.'))
            return
        elif 'add_user_profile_to_editor_group' in request.POST:
            objs_up = UserProfile.objects.filter(user__is_active=True)
            form = self.UserProfileinEditorGroupForm(objs_up, request.POST)
            if form.is_valid():
                userprofiles = form.cleaned_data['users']
                for userprofile in userprofiles:
                    for obj in queryset:
                        if UserProfile.objects.filter(user=request.user)[0].has_manager_permission(obj):
                            userprofile.user.groups.add(obj)
                        else:
                            self.message_user(request,
                                _('You need to be group manager to add a user to this editor group.'))
                            return HttpResponseRedirect(request.get_full_path())
                self.message_user(request, _('Successfully added users to editor group.'))
                return HttpResponseRedirect(request.get_full_path())

        if not form:
            userprofiles = UserProfile.objects.filter(user__is_active=True)
            form = self.UserProfileinEditorGroupForm(choices=userprofiles,
                initial={'_selected_action': request.POST.getlist(admin.ACTION_CHECKBOX_NAME)})
        
        dictionary = {'title': _('Add Users to Editor Group'),
                      'selected_editorgroups': queryset,
                      'form': form,
                      'path': request.get_full_path()
                     }
        dictionary.update(create_breadcrumb_template_params(self.model, _('Add user')))
        
        return render_to_response('accounts/add_user_profile_to_editor_group.html',
                                  dictionary,
                                  context_instance=RequestContext(request))
See More Examples - Go to Next Page
Page 1 Page 2 Page 3 Selected Page 4