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
0
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))
0
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'))
0
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))
0
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)
0
Example 105
@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))
0
Example 106
@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
}))
0
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))
0
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))
0
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))
0
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))
0
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))
0
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))
0
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
}
)
0
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))
0
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))
0
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))
0
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))
0
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))
0
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), )
0
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'))
0
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)
0
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))
0
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), )
0
Example 124
def _get_request_context(self):
return RequestContext(HttpRequest())
0
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
}))
0
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))
0
Example 127
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
0
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
0
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))
0
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))
0
Example 131
@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)
0
Example 132
@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
}))
0
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))
0
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), )
0
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))
0
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))
0
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))
0
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))
0
Example 139
def _render(tpl, ctx, req):
"""Renders to response loading request context"""
return render_to_response(tpl, ctx, RequestContext(req))
0
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
0
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'))
0
Example 142
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))
0
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'))
0
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())
0
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))
0
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)))
0
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), )
0
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))
0
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
)
0
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))