def feed_list(request):
tags = Tag.objects.all()
return render_to_response('feeds/list.html', {'tags': tags},
context_instance=RequestContext(request))
def form_invalid(self, form):
html = loader.render_to_string(self.template_name,
dictionary=self.get_context_data(form=form),
context_instance=RequestContext(self.request))
json = simplejson.dumps({'success': False, 'data': html})
return HttpResponse(json)
def profile_saved(request):
form = account.forms.LoginUsernameForm
return render_to_response('home.html', {'login_form': form, },
context_instance=RequestContext(request))
def changePassword(request):
if request.method == "POST":
old_password = request.POST.get('old_password', None)
new_password1 = request.POST.get('new_password1', None)
new_password2 = request.POST.get('new_password2', None)
if new_password1 != new_password2:
messages.error(request,"The new passwords donot match")
return HttpResponseRedirect('')
user = Person.objects.get(user=request.user).user
if user.check_password(old_password):
user.set_password(new_password1)
user.save()
messages.success(request, "Password Changed Successfully.")
else:
messages.error(request, "Please enter your password correctly")
return HttpResponseRedirect('')
else:
return render_to_response("person/changePassword.html",{'image':False},context_instance=RequestContext(request))
def profile(request):
person = request.user.person
return render_to_response("person/profile.html",{'person': person},context_instance=RequestContext(request))
def add(request, form_class=DirectoryForm, template_name="directories/add.html"):
can_add_active = has_perm(request.user,'directories.add_directory')
if not any([request.user.profile.is_superuser,
can_add_active,
get_setting('module', 'directories', 'usercanadd'),
(request.user.profile.is_member and get_setting('module', 'directories', 'directoriesrequiresmembership'))
]):
raise Http403
pricings = DirectoryPricing.objects.filter(status=True)
if not pricings and has_perm(request.user, 'directories.add_directorypricing'):
messages.add_message(request, messages.WARNING, 'You need to add a %s Pricing before you can add %s.' % (get_setting('module', 'directories', 'label_plural'),get_setting('module', 'directories', 'label')))
return HttpResponseRedirect(reverse('directory_pricing.add'))
require_payment = get_setting('module', 'directories', 'directoriesrequirespayment')
form = form_class(request.POST or None, request.FILES or None, user=request.user)
if not require_payment:
del form.fields['payment_method']
del form.fields['list_type']
if request.method == "POST":
if require_payment:
is_free = is_free_listing(request.user,
request.POST.get('pricing', 0),
request.POST.get('list_type'))
if is_free:
del form.fields['payment_method']
if form.is_valid():
directory = form.save(commit=False)
pricing = form.cleaned_data['pricing']
if require_payment and is_free:
directory.payment_method = 'paid - cc'
if directory.payment_method:
directory.payment_method = directory.payment_method.lower()
if not directory.requested_duration:
directory.requested_duration = 30
if not directory.list_type:
directory.list_type = 'regular'
if not directory.slug:
directory.slug = '%s-%s' % (slugify(directory.headline), Directory.objects.count())
if not can_add_active:
directory.status = True
directory.status_detail = 'pending'
else:
directory.activation_dt = datetime.now()
# set the expiration date
directory.expiration_dt = directory.activation_dt + timedelta(days=directory.requested_duration)
# We set the logo to None temporarily because we need
# the PK when we save to get the filepath of the file
logo = directory.logo
directory.logo = None
directory = update_perms_and_save(request, form, directory)
# directory now has a pk, so we can reassign the logo
# and resave
directory.logo = logo
if directory.logo:
directory.logo.file.seek(0)
directory.save(log=False)
if settings.USE_S3_STORAGE:
resize_s3_image(directory.logo.name)
else:
try:
logo = Image.open(directory.logo.path)
logo.thumbnail((200,200),Image.ANTIALIAS)
logo.save(directory.logo.path)
except:
pass
# create invoice
directory_set_inv_payment(request.user, directory, pricing)
messages.add_message(request, messages.SUCCESS, 'Successfully added %s' % directory)
# send notification to administrators
# get admin notice recipients
recipients = get_notice_recipients('module', 'directories', 'directoryrecipients')
if recipients:
if notification:
extra_context = {
'object': directory,
'request': request,
}
notification.send_emails(recipients,'directory_added', extra_context)
if directory.payment_method.lower() in ['credit card', 'cc']:
if directory.invoice and directory.invoice.balance > 0:
return HttpResponseRedirect(reverse('payment.pay_online', args=[directory.invoice.id, directory.invoice.guid]))
if can_add_active:
return HttpResponseRedirect(reverse('directory', args=[directory.slug]))
else:
return HttpResponseRedirect(reverse('directory.thank_you'))
return render_to_response(template_name,
{'form': form,
'require_payment': require_payment},
context_instance=RequestContext(request))
def thank_you(request, template_name="directories/thank-you.html"):
return render_to_response(template_name, {}, context_instance=RequestContext(request))
def web(request):
template = loader.get_template('clientes/indexWeb.html')
return HttpResponse(template.render(RequestContext(request)))
def pin_detail(request, pinId):
context = getPinContext(request, pinId)
return render_to_string('pins/templatetags/pin_detail.html',
context,
context_instance=RequestContext(request))
def _carers(request, db=None, ctx={}):
t = loader.get_template('carers.html')
ctx['carers'] = Member.carers()
return HttpResponse(t.render(RequestContext(request, ctx)))
def login_form(request, ctx):
ctx['authenticationform'] = forms.AuthenticationForm()
t = loader.get_template('login.html')
return HttpResponse(t.render(RequestContext(request, ctx)))
def console(request):
"""
Our web console, lets you see recent messages as well as send out new ones for
processing.
"""
form = SendForm()
reply_form = ReplyForm()
search_form = SearchForm()
queryset = Message.objects.all()
if request.method == 'POST' and 'this_is_the_login_form' not in request.POST:
if request.POST['action'] == 'test':
form = SendForm(request.POST)
if form.is_valid():
backend = "console"
message = get_router().handle_incoming(
backend, form.cleaned_data['sender'],
form.cleaned_data['text'])
reply_form = ReplyForm()
elif request.POST['action'] == 'reply':
reply_form = ReplyForm(request.POST)
if reply_form.is_valid():
if Connection.objects.filter(
identity=reply_form.cleaned_data['recipient']).count():
text = reply_form.cleaned_data['message']
conn = Connection.objects.filter(
identity=reply_form.cleaned_data['recipient'])[0]
outgoing = OutgoingMessage(conn, text)
get_router().handle_outgoing(outgoing)
else:
reply_form.errors.setdefault('short_description',
forms.ErrorList())
reply_form.errors['recipient'].append(
"This number isn't in the system")
elif request.POST['action'] == 'search':
# split on spaces
search_form = SearchForm(request.POST)
if search_form.is_valid():
terms = search_form.cleaned_data['search'].split()
if terms:
term = terms[0]
query = (Q(text__icontains=term)
| Q(in_response_to__text__icontains=term)
| Q(connection__identity__icontains=term))
for term in terms[1:]:
query &= (Q(text__icontains=term)
| Q(in_response_to__text__icontains=term)
| Q(connection__identity__icontains=term))
queryset = queryset.filter(query)
paginator = Paginator(queryset.order_by('-id'), 20)
page = request.GET.get('page')
try:
messages = paginator.page(page)
except EmptyPage:
# If page is out of range (e.g. 9999), deliver last page of results.
messages = paginator.page(paginator.num_pages)
except:
# None or not an integer, default to first page
messages = paginator.page(1)
return render_to_response(
"router/index.html", {
"messages_table": MessageTable(queryset, request=request),
"form": form,
"reply_form": reply_form,
"search_form": search_form,
"messages": messages
},
context_instance=RequestContext(request))
def translate(request, project, subproject, lang):
'''
Generic entry point for translating, suggesting and searching.
'''
translation = get_translation(request, project, subproject, lang)
# Check locks
project_locked, user_locked, own_lock = translation.is_locked(
request, True
)
locked = project_locked or user_locked
# Search results
search_result = search(translation, request)
# Handle redirects
if isinstance(search_result, HttpResponse):
return search_result
# Get numer of results
num_results = len(search_result['ids'])
# Search offset
try:
offset = int(request.GET.get('offset', search_result.get('offset', 0)))
except ValueError:
offset = 0
# Check boundaries
if offset < 0 or offset >= num_results:
messages.info(request, _('You have reached end of translating.'))
# Delete search
del request.session['search_%s' % search_result['search_id']]
# Redirect to translation
return redirect(translation)
# Some URLs we will most likely use
base_unit_url = '%s?sid=%s&offset=' % (
translation.get_translate_url(),
search_result['search_id'],
)
this_unit_url = base_unit_url + str(offset)
next_unit_url = base_unit_url + str(offset + 1)
response = None
# Any form submitted?
if request.method == 'POST' and not project_locked:
# Handle accepting/deleting suggestions
if ('accept' not in request.POST
and 'delete' not in request.POST
and 'upvote' not in request.POST
and 'downvote' not in request.POST):
response = handle_translate(
translation, request, user_locked,
this_unit_url, next_unit_url
)
elif not locked:
response = handle_suggestions(
translation, request, this_unit_url
)
# Handle translation merging
elif 'merge' in request.GET and not locked:
response = handle_merge(
translation, request, next_unit_url
)
# Handle reverting
elif 'revert' in request.GET and not locked:
response = handle_revert(
translation, request, this_unit_url
)
# Pass possible redirect further
if response is not None:
return response
# Grab actual unit
try:
unit = translation.unit_set.get(pk=search_result['ids'][offset])
except Unit.DoesNotExist:
# Can happen when using SID for other translation
messages.error(request, _('Invalid search string!'))
return redirect(translation)
# Show secondary languages for logged in users
if request.user.is_authenticated():
secondary = request.user.profile.get_secondary_units(unit)
else:
secondary = None
# Spam protection
antispam = AntispamForm()
# Prepare form
form = TranslationForm(translation, unit)
return render_to_response(
'translate.html',
RequestContext(
request,
{
'this_unit_url': this_unit_url,
'first_unit_url': base_unit_url + '0',
'last_unit_url': base_unit_url + str(num_results - 1),
'next_unit_url': next_unit_url,
'prev_unit_url': base_unit_url + str(offset - 1),
'object': translation,
'unit': unit,
'total': translation.unit_set.all().count(),
'search_id': search_result['search_id'],
'search_query': search_result['query'],
'offset': offset,
'filter_name': search_result['name'],
'filter_count': num_results,
'filter_pos': offset + 1,
'form': form,
'antispam': antispam,
'comment_form': CommentForm(),
'search_form': SearchForm(),
'update_lock': own_lock,
'secondary': secondary,
'locked': locked,
'user_locked': user_locked,
'project_locked': project_locked,
},
)
)
def thanks(request):
return render_to_response('thanks.html',
context_instance=RequestContext(request))
def cityinit(request):
trie.initialize()
return render_to_response('index.html',{},context_instance = RequestContext(request))
def activate(request,
backend,
template_name='registration/activate.html',
success_url=None,
extra_context=None,
**kwargs):
"""
Activate a user's account.
The actual activation of the account will be delegated to the
backend specified by the ``backend`` keyword argument (see below);
the backend's ``activate()`` method will be called, passing any
keyword arguments captured from the URL, and will be assumed to
return a ``User`` if activation was successful, or a value which
evaluates to ``False`` in boolean context if not.
Upon successful activation, the backend's
``post_activation_redirect()`` method will be called, passing the
``HttpRequest`` and the activated ``User`` to determine the URL to
redirect the user to. To override this, pass the argument
``success_url`` (see below).
On unsuccessful activation, will render the template
``registration/activate.html`` to display an error message; to
override thise, pass the argument ``template_name`` (see below).
**Arguments**
``backend``
The dotted Python import path to the backend class to
use. Required.
``extra_context``
A dictionary of variables to add to the template context. Any
callable object in this dictionary will be called to produce
the end result which appears in the context. Optional.
``success_url``
The name of a URL pattern to redirect to on successful
acivation. This is optional; if not specified, this will be
obtained by calling the backend's
``post_activation_redirect()`` method.
``template_name``
A custom template to use. This is optional; if not specified,
this will default to ``registration/activate.html``.
``\*\*kwargs``
Any keyword arguments captured from the URL, such as an
activation key, which will be passed to the backend's
``activate()`` method.
**Context:**
The context will be populated from the keyword arguments captured
in the URL, and any extra variables supplied in the
``extra_context`` argument (see above).
**Template:**
registration/activate.html or ``template_name`` keyword argument.
"""
backend = get_backend(backend)
account = backend.activate(request, **kwargs)
if account:
if success_url is None:
to, args, kwargs = backend.post_activation_redirect(
request, account)
return redirect(to, *args, **kwargs)
else:
return redirect(success_url)
if extra_context is None:
extra_context = {}
context = RequestContext(request)
for key, value in extra_context.items():
context[key] = callable(value) and value() or value
return render_to_response(template_name, kwargs, context_instance=context)
def _setup_required(self, request):
if settings.EMBEDDED:
return HttpResponseServerError('Site is not set up.', content_type='text/plain')
return SimpleTemplateResponse('setup_wizard/setup_required.html',
context=RequestContext(request), status=403)
def register(request,
backend,
success_url=None,
form_class=None,
disallowed_url='registration_disallowed',
template_name='registration/registration_form.html',
extra_context=None):
"""
Allow a new user to register an account.
The actual registration of the account will be delegated to the
backend specified by the ``backend`` keyword argument (see below);
it will be used as follows:
1. The backend's ``registration_allowed()`` method will be called,
passing the ``HttpRequest``, to determine whether registration
of an account is to be allowed; if not, a redirect is issued to
the view corresponding to the named URL pattern
``registration_disallowed``. To override this, see the list of
optional arguments for this view (below).
2. The form to use for account registration will be obtained by
calling the backend's ``get_form_class()`` method, passing the
``HttpRequest``. To override this, see the list of optional
arguments for this view (below).
3. If valid, the form's ``cleaned_data`` will be passed (as
keyword arguments, and along with the ``HttpRequest``) to the
backend's ``register()`` method, which should return the new
``User`` object.
4. Upon successful registration, the backend's
``post_registration_redirect()`` method will be called, passing
the ``HttpRequest`` and the new ``User``, to determine the URL
to redirect the user to. To override this, see the list of
optional arguments for this view (below).
**Required arguments**
None.
**Optional arguments**
``backend``
The dotted Python import path to the backend class to use.
``disallowed_url``
URL to redirect to if registration is not permitted for the
current ``HttpRequest``. Must be a value which can legally be
passed to ``django.shortcuts.redirect``. If not supplied, this
will be whatever URL corresponds to the named URL pattern
``registration_disallowed``.
``form_class``
The form class to use for registration. If not supplied, this
will be retrieved from the registration backend.
``extra_context``
A dictionary of variables to add to the template context. Any
callable object in this dictionary will be called to produce
the end result which appears in the context.
``success_url``
URL to redirect to after successful registration. Must be a
value which can legally be passed to
``django.shortcuts.redirect``. If not supplied, this will be
retrieved from the registration backend.
``template_name``
A custom template to use. If not supplied, this will default
to ``registration/registration_form.html``.
**Context:**
``form``
The registration form.
Any extra variables supplied in the ``extra_context`` argument
(see above).
**Template:**
registration/registration_form.html or ``template_name`` keyword
argument.
"""
backend = get_backend(backend)
if not backend.registration_allowed(request):
return redirect(disallowed_url)
if form_class is None:
form_class = backend.get_form_class(request)
if request.method == 'POST':
form = form_class(data=request.POST, files=request.FILES)
if form.is_valid():
new_user = backend.register(request, **form.cleaned_data)
if success_url is None:
to, args, kwargs = backend.post_registration_redirect(
request, new_user)
return redirect(to, *args, **kwargs)
else:
return redirect(success_url)
else:
form = form_class()
if extra_context is None:
extra_context = {}
context = RequestContext(request)
for key, value in extra_context.items():
context[key] = callable(value) and value() or value
return render_to_response(template_name, {'form': form},
context_instance=context)
def pricing_search(request, template_name="directories/pricing-search.html"):
directory_pricing = DirectoryPricing.objects.filter(status=True).order_by('duration')
EventLog.objects.log()
return render_to_response(template_name, {'directory_pricings':directory_pricing},
context_instance=RequestContext(request))
def home(request):
registered_users = User.objects.all()
return render_to_response('chat_app/home.html',
{'user': request.user, 'registered_users': registered_users}, context_instance=RequestContext(request))
def renew(request, id, form_class=DirectoryRenewForm, template_name="directories/renew.html"):
can_add_active = has_perm(request.user,'directories.add_directory')
require_approval = get_setting('module', 'directories', 'renewalrequiresapproval')
directory = get_object_or_404(Directory, pk=id)
if not has_perm(request.user,'directories.change_directory', directory) or not request.user == directory.creator:
raise Http403
# pop payment fields if not required
require_payment = get_setting('module', 'directories', 'directoriesrequirespayment')
form = form_class(request.POST or None, request.FILES or None, instance=directory, user=request.user)
if not require_payment:
del form.fields['payment_method']
del form.fields['list_type']
if request.method == "POST":
if form.is_valid():
directory = form.save(commit=False)
pricing = form.cleaned_data['pricing']
if directory.payment_method:
directory.payment_method = directory.payment_method.lower()
if not directory.requested_duration:
directory.requested_duration = 30
if not directory.list_type:
directory.list_type = 'regular'
if not directory.slug:
directory.slug = '%s-%s' % (slugify(directory.headline), Directory.objects.count())
if not can_add_active and require_approval:
directory.status = True
directory.status_detail = 'pending'
else:
directory.activation_dt = datetime.now()
# set the expiration date
directory.expiration_dt = directory.activation_dt + timedelta(days=directory.requested_duration)
# mark renewal as not sent for new exp date
directory.renewal_notice_sent = False
# update all permissions and save the model
directory = update_perms_and_save(request, form, directory)
# create invoice
directory_set_inv_payment(request.user, directory, pricing)
messages.add_message(request, messages.SUCCESS, 'Successfully renewed %s' % directory)
# send notification to administrators
# get admin notice recipients
recipients = get_notice_recipients('module', 'directories', 'directoryrecipients')
if recipients:
if notification:
extra_context = {
'object': directory,
'request': request,
}
notification.send_emails(recipients,'directory_renewed', extra_context)
if directory.payment_method.lower() in ['credit card', 'cc']:
if directory.invoice and directory.invoice.balance > 0:
return HttpResponseRedirect(reverse('payments.views.pay_online', args=[directory.invoice.id, directory.invoice.guid]))
if can_add_active:
return HttpResponseRedirect(reverse('directory', args=[directory.slug]))
else:
return HttpResponseRedirect(reverse('directory.thank_you'))
return render_to_response(template_name, {'directory':directory, 'form':form},
context_instance=RequestContext(request))
def index(request):
events_list = Event.objects.all()
collections = GalleryCollection.objects.all()
rahmaninov.apps.gallery.views.update_collections(collections)
return render_to_response('index.html', RequestContext(request, locals()))
def info(request):
if request.method == "POST":
return HttpResponseRedirect("/person/home/")
else:
return render_to_response("person/person_info.html",{'image':image,'degrees':degrees,'branches':branches,'jobs':jobs,'industries':industries,'languages':languages,'poli':poli,'hobbies':hobbies},context_instance=RequestContext(request))
def mainMobile(request):
return render_to_response('mainMobile.html',{},context_instance = RequestContext(request))
def loginRequest(request):
errors = []
success = []
if request.user.is_authenticated():
return HttpResponseRedirect('/person/home/')
if request.method=="POST":
username=request.POST.get('username', None)
password=request.POST.get('password', None)
user=authenticate(username=username,password=password)
if user is not None and user.is_active:
login(request,user)
if not request.POST.get('remember_me', None):
request.session.set_expiry(0)
return HttpResponseRedirect("/person/home/")
messages.error(request, "Please enter valid details. Login Failed.")
return render_to_response("person/login.html",{'errors':errors,'success':success},context_instance=RequestContext(request))
def planningMobile(request):
return render_to_response('planningMobile.html',{},context_instance = RequestContext(request))
def calendar(request):
context = {}
return render_to_response('calendar.html', context,\
context_instance=RequestContext(request))
def traininit(request):
startup.loadtraindata()
return render_to_response('index.html',{},context_instance = RequestContext(request))
def manage_featured_inline(
request, as_string=False, template_name="manage/marketing/featured_inline.html"):
"""
"""
featured = FeaturedProduct.objects.all()
featured_ids = [f.product.id for f in featured]
r = request.REQUEST
s = request.session
# If we get the parameter ``keep-filters`` or ``page`` we take the
# filters out of the request resp. session. The request takes precedence.
# The page parameter is given if the user clicks on the next/previous page
# links. The ``keep-filters`` parameters is given is the users adds/removes
# products. In this way we keeps the current filters when we needed to. If
# the whole page is reloaded there is no ``keep-filters`` or ``page`` and
# all filters are reset as they should.
if r.get("keep-filters") or r.get("page"):
page = r.get("page", s.get("featured_products_page", 1))
filter_ = r.get("filter", s.get("filter"))
category_filter = r.get("featured_category_filter",
s.get("featured_category_filter"))
else:
page = r.get("page", 1)
filter_ = r.get("filter")
category_filter = r.get("featured_category_filter")
# The current filters are saved in any case for later use.
s["featured_products_page"] = page
s["filter"] = filter_
s["featured_category_filter"] = category_filter
try:
s["featured-amount"] = int(r.get("featured-amount", s.get("featured-amount")))
except TypeError:
s["featured-amount"] = 25
filters = Q()
if filter_:
filters &= Q(name__icontains=filter_)
filters |= Q(sku__icontains=filter_)
filters |= (Q(sub_type=VARIANT) & Q(active_sku=False) & Q(parent__sku__icontains=filter_))
filters |= (Q(sub_type=VARIANT) & Q(active_name=False) & Q(parent__name__icontains=filter_))
if category_filter:
if category_filter == "None":
filters &= Q(categories=None)
elif category_filter == "All":
pass
else:
# First we collect all sub categories and using the `in` operator
category = lfs_get_object_or_404(Category, pk=category_filter)
categories = [category]
categories.extend(category.get_all_children())
filters &= Q(categories__in=categories)
products = Product.objects.filter(filters).exclude(pk__in=featured_ids)
paginator = Paginator(products, s["featured-amount"])
total = products.count()
try:
page = paginator.page(page)
except EmptyPage:
page = 0
result = render_to_string(template_name, RequestContext(request, {
"featured": featured,
"total": total,
"page": page,
"paginator": paginator,
"filter": filter_
}))
if as_string:
return result
else:
return HttpResponse(
simplejson.dumps({
"html": [["#featured-inline", result]],
}), mimetype='application/json')
def resource_details(request, resource_id, slug=""):
resource = get_object_or_404(Resource, pk=resource_id)
return render_to_response('details.html', {'resource': resource},
context_instance=RequestContext(request))
