def status_view(request, status_id, response_format='html'):
"Status view"
status = get_object_or_404(ChangeSetStatus, pk=status_id)
if not request.user.profile.has_permission(status) \
and not request.user.profile.is_admin('anaf.changes'):
return user_denied(request,
"You don't have access to this Change Set Status.",
response_format=response_format)
query = Q(
object__in=Object.filter_by_request(request, Object.objects)) & Q(
status=status)
if request.GET:
query = query & _get_filter_query(request.GET)
filters = FilterForm(request.user.profile, 'status', request.GET)
else:
filters = FilterForm(request.user.profile, 'status')
changesets = ChangeSet.objects.filter(query)
context = _get_default_context(request)
context.update({
'status': status,
'changesets': changesets,
'filters': filters
})
return render_to_response('changes/status_view',
context,
context_instance=RequestContext(request),
response_format=response_format)
def inject_filter():
"""
Ensures that the there is a filterform on each page.
"""
if current_user.is_authenticated:
return dict(search_filter=FilterForm(obj=current_user.filters))
else:
return dict(search_filter=FilterForm())
def projects(request):
form = FilterForm()
if request.method == 'POST':
form = FilterForm(request.POST)
# DOESNT WORK without print statement?????
print form
search = form.clean().get("search")
if search == 'Open Projects':
projects = Projects.objects.filter(status="Open")
search_title = "Available Projects"
elif search == 'Closed Projects':
projects = Projects.objects.filter(status="Closed")
search_title = "Closed Projects"
elif search == 'My Projects':
projects = Projects.objects.filter(owner=request.user.username)
search_title = "My Projects"
elif search == "All Projects":
projects = Projects.objects.all()
search_title = "All Projects"
else:
projects = Projects.objects.filter(status="Open")
search_title = "Available Projects"
pages = {}
pages["page_limit"] = 5
pages["page_links"] = []
if request.method == 'POST':
pages["form"] = PagesForm(request.POST)
pages["page_limit"] = int(request.POST.get("page"))
for x in range(len(projects) / pages["page_limit"]):
pages["page_links"].append(str(x))
pages["page_links"] = "".join(pages["page_links"])
if len(projects
) % pages["page_limit"] != 0 and pages["page_links"] != "":
pages["page_links"] = pages["page_links"] + str(
int(pages["page_links"][-1]) + 1)
else:
pages["form"] = PagesForm()
return render(
request, 'BuildPythonPleaseGUI/projects.html', {
"search_title": search_title,
"projects": projects,
"form": form,
'notifications': notifications(request),
"pages": pages
})
def display_map(request):
errorMessage = None
geodata = {}
geodata = json.dumps(geodata)
if request.method == 'POST':
form1 = DocumentForm(request.POST, request.FILES)
form = FilterForm(request.POST)
bndryform = BndryCondsForm(request.POST, request.FILES)
if form1.is_valid() and bndryform.is_valid():
form1.save()
bndryform.save()
meshpath = request.FILES['document']
bcpath = request.FILES['bndryfile']
kwargs = {}
kwargs["proj"] = request.POST['projection']
cwd = os.getcwd()
meshpath = cwd + '/documents/' + str(meshpath)
bcpath = cwd + '/documents/' + str(bcpath)
kwargs["bcfile"] = bcpath
mymesh = MESHOBJECT(meshpath, **kwargs)
if not mymesh.fileExists:
IOError('%s does not exist. Check file name and path' %
self.meshfile)
errorMessage = ('%s does not exist. Check file name and path' %
self.meshfile)
else:
meshgeojson = mymesh.mesh2GEOJSON()
geodata = json.dumps(meshgeojson)
meshcentre = mymesh.meshCentre()
bndrysgeojson = mymesh.bndry2GEOJSON()
request.session['my_data'] = geodata
meshcentrestr = str(meshcentre[0]) + "," + str(meshcentre[1])
request.session['centre'] = meshcentrestr
request.session['bndrysgeojson'] = bndrysgeojson
request.session['meshfile'] = meshpath
request.session['bcfile'] = bcpath
return HttpResponseRedirect(reverse('model_parameters'))
else:
form1 = DocumentForm()
bndryform = BndryCondsForm()
form = FilterForm()
return render(
request, 'runtide/fileuploadv2.html', {
'form': form,
'form1': form1,
'geodata': geodata,
'errorMessage': errorMessage,
'bndryform': bndryform,
})
def add_filter(request, list_filters):
filters = []
filter_dict = dict([(f['name'], f) for f in list_filters])
if request.method == 'GET':
filter_form = FilterForm(list_filters, request.GET)
if filter_form.is_valid():
for name, data in filter_form.cleaned_data.items():
if data:
filters.append(Q(**{filter_dict[name]['destination']:data}))
else:
filter_form = FilterForm(list_filters)
return filter_form, filters
def get_context_data(self, *args, **kwargs):
context = super(InterventionList,
self).get_context_data(*args, **kwargs)
context['form'] = FilterForm(
initial={'filter': InterventionList.query})
context['interventionsfilter'] = self.interventionsfilter
return context
def index(request, response_format='html'):
"All available tickets"
if request.GET:
if 'status' in request.GET and request.GET['status']:
query = _get_filter_query(request.GET)
else:
query = Q(status__hidden=False) & _get_filter_query(request.GET)
tickets = Object.filter_by_request(request,
Ticket.objects.filter(query))
else:
tickets = Object.filter_by_request(
request, Ticket.objects.filter(status__hidden=False))
filters = FilterForm(request.user.profile, '', request.GET)
context = _get_default_context(request)
context.update({
'tickets': tickets,
'filters': filters,
})
return render_to_response('services/index',
context,
context_instance=RequestContext(request),
response_format=response_format)
def queue_view(request, queue_id, response_format='html'):
"Queue view"
queue = get_object_or_404(TicketQueue, pk=queue_id)
if not request.user.profile.has_permission(queue):
return user_denied(request,
message="You don't have access to this Queue")
query = Q(queue=queue)
if request.GET:
if 'status' in request.GET and request.GET['status']:
query = query & _get_filter_query(request.GET)
else:
query = query & Q(status__hidden=False) & _get_filter_query(
request.GET)
else:
query = query & Q(status__hidden=False)
tickets = Object.filter_by_request(request, Ticket.objects.filter(query))
filters = FilterForm(request.user.profile, 'queue', request.GET)
subqueues = Object.filter_by_request(
request, TicketQueue.objects.filter(parent=queue))
context = _get_default_context(request)
context.update({
'queue': queue,
'subqueues': subqueues,
'filters': filters,
'tickets': tickets
})
return render_to_response('services/queue_view',
context,
context_instance=RequestContext(request),
response_format=response_format)
def index_owned(request, response_format='html'):
"Tickets owned by current user"
context = _get_default_context(request)
query = Q(caller__related_user=request.user.profile)
if request.GET:
if 'status' in request.GET and request.GET['status']:
query = query & _get_filter_query(request.GET)
else:
query = query & Q(status__hidden=False) & _get_filter_query(
request.GET)
else:
query = query & Q(status__hidden=False)
tickets = Object.filter_by_request(request, Ticket.objects.filter(query))
filters = FilterForm(request.user.profile, 'caller', request.GET)
context.update({'tickets': tickets, 'filters': filters})
return render_to_response('services/index_owned',
context,
context_instance=RequestContext(request),
response_format=response_format)
def index_assigned(request, response_format='html'):
"Tickets assigned to current user"
context = _get_default_context(request)
agent = context['agent']
if agent:
query = Q(assigned=agent)
if request.GET:
if 'status' in request.GET and request.GET['status']:
query = query & _get_filter_query(request.GET)
else:
query = query & Q(status__hidden=False) & _get_filter_query(
request.GET)
else:
query = query & Q(status__hidden=False)
tickets = Object.filter_by_request(request,
Ticket.objects.filter(query))
else:
return user_denied(request,
"You are not a Service Support Agent.",
response_format=response_format)
filters = FilterForm(request.user.profile, 'assigned', request.GET)
context.update({'tickets': tickets, 'filters': filters})
return render_to_response('services/index_assigned',
context,
context_instance=RequestContext(request),
response_format=response_format)
def input():
form = FilterForm()
if form.is_submitted():
result = request.form
return render_template('confirmation_page.html', result=result)
return render_template('input_page.html', form=form)
def settings():
info_form = UserInfoForm(obj=current_user)
filter_form = FilterForm(obj=current_user.filters)
# Modifying User Info
# if info_form.validate_on_submit():
# current_user.username = info_form.username.data
# current_user.description = info_form.description.data
# current_user.avatar = info_form.avatar.data
# current_user.email = info_form.email.data
# db.session.commit()
# return redirect(url_for('users.settings'))
# Modifying User Filter
if filter_form.validate_on_submit():
current_user.filters.price_min = filter_form.price_min.data
current_user.filters.price_max = filter_form.price_max.data
current_user.filters.calorie_min = filter_form.calorie_min.data
current_user.filters.calorie_max = filter_form.calorie_max.data
current_user.filters.meal_type = filter_form.meal_type.data
current_user.filters.meal_style = filter_form.meal_style.data
current_user.filters.dietary_preferences = filter_form.dietary_preferences.data
current_user.filters.cooking_time_min = filter_form.cooking_time_min.data
current_user.filters.cooking_time_max = filter_form.cooking_time_max.data
db.session.commit()
return redirect(url_for('users.settings'))
return render_template('settings.html',
user_info=current_user,
info_form=info_form,
filter_form=filter_form)
def myservices(request):
services = request.user.service_provider.services.all()
durations = set(service.duration for service in services)
# discounts = set(service.get_discount().discount for service in services if service.get_discount())
discounts = set(
discount.discount
for discount in Discount.objects.filter(service__in=services))
filter_form = FilterForm(request.GET,
durations=sorted(list(durations)),
discounts=discounts)
if filter_form.is_valid():
if filter_form.cleaned_data['duration'] != 'all':
services = services.filter(
duration=filter_form.cleaned_data['duration'])
if filter_form.cleaned_data['discount'] != 'all':
services = services.filter(discounts__discount=filter_form.
cleaned_data['discount']).distinct()
if filter_form.cleaned_data['active'] == 'active':
services = [service for service in services if service.is_active()]
elif filter_form.cleaned_data['active'] == 'inactive':
services = [
service for service in services if not service.is_active()
]
# locals() returns a dictionary of variables in the local scope (request and services in this case)
return render_to_response('service/myservices.html',
locals(),
context_instance=RequestContext(request))
def index(request, response_format='html'):
"Index page: displays all Items"
query = Q(status__hidden=False)
if request.GET:
if 'status' in request.GET and request.GET['status']:
query = _get_filter_query(request.GET)
else:
query = query & _get_filter_query(request.GET)
if request.GET:
query = query & _get_filter_query(request.GET)
items = Object.filter_by_request(
request,
Item.objects.filter(query).order_by('name'))
filters = FilterForm(request.user.profile, '', request.GET)
context = _get_default_context(request)
context.update({'items': items, 'filters': filters})
return render_to_response('infrastructure/index',
context,
context_instance=RequestContext(request),
response_format=response_format)
def main_page():
form = FilterForm()
cars = Car.query.all()
if form.validate_on_submit()==True:
cars = Car.query.all().first()
return render_template('main.html', cars=cars, user = request.args['user'])
return render_template('main.html', cars=cars, user = request.args['user'])
def reportIssue():
service = build("calendar", "v3", http=Http())
booking = Booking.query.filter_by(
booking_id=request.args['booking_id']).first()
if (date.today() > booking.start_date):
booking.end_date = date.today()
booking.number_of_days = (booking.end_date -
booking.start_date).days + 1
booking.cost = car.cost_per_hour * booking.number_of_days
booking.end_location = "melbourne"
else:
booking.end_date = booking.start_date
booking.cost = 0
booking.number_of_days = 0
booking.end_location = booking.start_location
booking.status = False
booking.removeFromCalendar(service)
bdb.session.commit()
car = Car.query.filter_by(carnumber=booking.carnumber).first()
car.isAvailable = True
car.maintenance = 1
car.location = booking.end_location
cdb.session.commit()
bdb.session.commit()
cars = Car.query.all()
form = FilterForm()
return render_template('main.html',
form=form,
cars=cars,
user=request.args['user'])
def status_view(request, status_id, response_format='html'):
"ItemStatus view"
item_status = get_object_or_404(ItemStatus, pk=status_id)
if not request.user.profile.has_permission(item_status):
return user_denied(request,
message="You don't have access to this Item Status",
response_format=response_format)
query = Q(status=item_status)
if request.GET:
query = query & _get_filter_query(request.GET)
items = Object.filter_by_request(
request,
Item.objects.filter(query).order_by('name'))
filters = FilterForm(request.user.profile, ['status'], request.GET)
context = _get_default_context(request)
context.update({
'items': items,
'filters': filters,
'item_status': item_status
})
return render_to_response('infrastructure/item_status_view',
context,
context_instance=RequestContext(request),
response_format=response_format)
def post(self, request, *args, **kwargs):
group_membership = request.user.groups.values_list('name', flat=True)
# if this user is not in the Enablement group, throw a permission denied error
if 'Enablement' not in group_membership:
raise PermissionDenied
filter_form = FilterForm(request.POST)
# save values from form fields into a dictionary
filter_form.full_clean()
cd = filter_form.cleaned_data
if cd['assigned_engineer'] == '':
cd['assigned_engineer'] = None
# show pre-filled forms with criteria from the form that triggered the POST
filter_form = FilterForm(initial=cd)
#
objects = EnablementRequest.objects.filter(
customer_name__contains=cd['customer_name'],
short_term_revenue__gte=cd['short_term_revenue'],
current_state__contains=cd['current_state'],
assigned_engineer=cd['assigned_engineer'],
config_details__os_type__contains=cd['os_type'],
config_details__os_version__contains=cd['os_version'],
config_details__storage_adapter_vendor__contains=cd[
'storage_adapter_vendor'],
config_details__storage_adapter_model__contains=cd[
'storage_adapter_model'],
config_details__storage_adapter_driver__contains=cd[
'storage_adapter_driver'],
config_details__storage_adapter_firmware__contains=cd[
'storage_adapter_firmware'],
config_details__data_ontap_version__contains=cd[
'data_ontap_version'],
).order_by('-identifier')
context = {
'objects': objects,
'filter_form': filter_form,
'request': request,
'group_membership': group_membership,
'navbar_options_template': 'enablement_navbar_options.html',
}
return render(request, self.template_name, context)
def answers_list():
filter_form = FilterForm()
if request.method == 'POST' and filter_form.validate_on_submit():
answered_by_filter = filter_form.creator.data if filter_form.creator.data else None
question_text_filter = filter_form.text.data if filter_form.text.data else None
answers = get_answers_list(questions_owner=current_user.username, answered_by=answered_by_filter,
question_text=question_text_filter, status='Active')
else:
answers = get_answers_list(questions_owner=current_user.username, status='Active')
return render_template('answers.html', answers=answers, filter_form=filter_form, is_my_answers=False)
def ajax_filter_form(request, report_id):
#TODO: access control
if request.method == 'GET':
query = request.GET
report = get_object_or_404(Report, pk=report_id)
if report not in _get_allowed_object_for_user(request.user)['reports']:
return render_to_response('messagebox-error.html',
{'title': _(u'Permission error'),
'message': _(u"Insufficient permissions to access this area.")})
if query:
filter_form = FilterForm(report.filtersets.all(), request.user, query)
else:
filter_form = FilterForm(report.filtersets.all(), request.user)
return render_to_response('filter_form_subtemplate.html', {'filter_form': filter_form},
context_instance=RequestContext(request))
def questions():
filter_form = FilterForm()
creator = request.args.get('creator', None)
text = None
if request.method == 'POST' and filter_form.validate_on_submit():
creator = filter_form.creator.data if filter_form.creator.data else None
text = filter_form.text.data if filter_form.text.data else None
return render_template('questions.html', questions=get_questions_list(creator, text, status='Active'),
form=AnswerForm(), current_user=current_user.username, filter_form=filter_form)
def index(request, response_format='html'):
"Change Control index page"
query = Q(object__in=Object.filter_by_request(request, Object.objects))
if request.GET:
query = query & _get_filter_query(request.GET)
filters = FilterForm(request.user.profile, [], request.GET)
else:
query = query & Q(status__hidden=False)
filters = FilterForm(request.user.profile)
changesets = ChangeSet.objects.filter(query)
context = _get_default_context(request)
context.update({'changesets': changesets, 'filters': filters})
return render_to_response('changes/index',
context,
context_instance=RequestContext(request),
response_format=response_format)
def report_filter(request, report_id, field_name, response_format='html'):
"View to Filter over a given field for a Report"
report = get_object_or_404(Report, pk=report_id)
if not request.user.profile.has_permission(report, mode='w'):
return user_denied(request, message="You don't have access to this Report")
if request.POST:
FilterForm(request.user.profile, request.POST,
report=report, field_name=field_name).save()
return HttpResponseRedirect(reverse('reports_report_edit', args=[report.id]))
else:
form = FilterForm(
request.user.profile, report=report, field_name=field_name)
return render_to_response('reports/report_filter',
{'form': form,
'field_name': field_name},
context_instance=RequestContext(request), response_format=response_format)
def index_resolved(request, response_format='html'):
"Change Control resolved by me page"
query = Q(
object__in=Object.filter_by_request(request, Object.objects)) & Q(
resolved_by=request.user.profile)
if request.GET:
query = query & _get_filter_query(request.GET)
filters = FilterForm(request.user.profile, 'resolved_by', request.GET)
else:
filters = FilterForm(request.user.profile, 'resolved_by')
changesets = ChangeSet.objects.filter(query)
context = _get_default_context(request)
context.update({'filters': filters, 'changesets': changesets})
return render_to_response('changes/index_resolved',
context,
context_instance=RequestContext(request),
response_format=response_format)
def get(self, request):
if not request.user.is_authenticated():
return render(request, 'unauthorised.html')
q_set = Challenge.objects.filter(to=request.user.username,
resolved=False).order_by('-time')
return render(request, 'show_challenge.html', {
'form': FilterForm(),
'results': q_set
})
def index(request, response_format='html'):
"Index page: display all events"
if request.GET:
filters = FilterForm(request.GET)
if filters.is_valid():
query = _get_filter_query(request.GET)
else:
query = Q()
else:
query = Q()
filters = FilterForm()
events = Object.filter_by_request(request, Event.objects.filter(query))
context = _get_default_context(request)
context.update({'events': events, 'filters': filters})
return render_to_response('events/index',
context,
context_instance=RequestContext(request),
response_format=response_format)
def main_page():
form = FilterForm()
cars = Car.query.all()
if request.method == 'POST':
if (form.search.data == None or form.search.data == ''
or form.search.data == []):
cars1 = Car.query.all()
else:
cars1 = Car.query.filter(
or_(Car.carnumber == form.search.data,
Car.model == form.search.data))
if (form.available.data == "available cars only"):
cars2 = Car.query.filter(
and_(Car.isAvailable == True, Car.maintenance == False))
elif (form.available.data == "all cars"):
cars2 = Car.query.all()
else:
cars2 = Car.query.all()
if (form.cost_below.data == None or form.cost_below.data == ''
or form.cost_below.data == []):
cars3 = Car.query.all()
else:
cars3 = Car.query.filter(Car.cost_per_hour <= form.cost_below.data)
if (form.body.data == None or form.body.data == ''
or form.body.data == []):
cars4 = Car.query.all()
else:
if (form.body.data == "SUV"):
cars4 = Car.query.filter(Car.body_type == "suv")
elif (form.body.data == "sedan"):
cars4 = Car.query.filter(Car.body_type == "sedan")
else:
cars4 = Car.query.filter(Car.body_type == "hatch")
print(list(set(cars1) & set(cars2) & set(cars3) & set(cars4)))
cars = list(set(cars1) & set(cars2) & set(cars3) & set(cars4))
if (cars is None or cars == None or len(cars) == 0):
flash('No results found, please re-edit filters!', 'danger')
cars = Car.query.all()
return render_template('main.html',
form=form,
cars=cars,
user=request.args['user'])
return render_template('main.html',
form=form,
cars=cars,
user=request.args['user'])
def view_all():
# Load all items from DB, then pass to browse.html file to display
#use the global variable filter_item
form = FilterForm()
# connect to db
db = get_db()
cur = db.cursor()
#multiple if statements for different cases of filtration. ex. 2 categories together, only filter by category etc.
#depending on what case of filtration is needed, we will execute a different query on the database.
if request.method == 'POST' and form.validate_on_submit():
if (form.category.data != 'none' and form.city.data != 'none'
and form.maxPrice.data != 'none'):
cur.execute(
"SELECT * FROM ITEM, USER WHERE USER.Email = ITEM.Owner_email AND Category_name=? AND Daily_rate<=? AND USER.City =?",
(form.category.data, form.maxPrice.data, form.city.data))
elif (form.category.data != 'none' and form.city.data != 'none'):
cur.execute(
"SELECT * FROM ITEM, USER WHERE Category_name=? AND USER.Email = ITEM.Owner_email AND USER.City =?",
(form.category.data, form.city.data))
elif (form.category.data != 'none' and form.maxPrice.data != 'none'):
cur.execute(
"SELECT * FROM ITEM WHERE Category_name=? AND Daily_rate<=?",
(form.category.data, form.maxPrice.data))
elif (form.maxPrice.data != 'none' and form.city.data != 'none'):
cur.execute(
"SELECT * FROM ITEM, USER WHERE Daily_rate<=? AND USER.Email = ITEM.Owner_email AND USER.City =?",
(form.maxPrice.data, form.city.data))
elif (form.category.data != 'none'):
cur.execute("SELECT * FROM ITEM WHERE Category_name=?",
(form.category.data, ))
elif (form.city.data != 'none'):
cur.execute(
"SELECT * FROM ITEM, USER WHERE USER.Email = ITEM.Owner_email AND USER.City =?",
(form.city.data, ))
elif (form.maxPrice.data != 'none'):
cur.execute("SELECT * FROM ITEM WHERE Daily_rate<=?",
(form.maxPrice.data, ))
else:
cur.execute("SELECT * FROM ITEM")
else:
cur.execute("SELECT * FROM ITEM")
data = cur.fetchall() #an array of all items fetched from DB
return render_template('browse.html', data=data,
form=form) #show the data in the html
def edit_filter():
form = FilterForm(request.form)
settings = Settings.query.limit(1).first()
if request.method == 'GET':
form.regex.data = settings.regex_filter
return render_template("filter.html", form=form)
else:
try:
re.compile(form.regex.data)
settings.regex_filter = form.regex.data
db.session.commit()
return redirect(url_for('dashboard'))
except re.error:
return render_template("filter.html", form=form, issue=True)
def get(self, request, *args, **kwargs):
group_membership = request.user.groups.values_list('name', flat=True)
# if this user is not in the Enablement group, throw a permission denied error
if 'Enablement' not in group_membership:
raise PermissionDenied
filter_form = FilterForm()
context = {
'filter_form': filter_form,
'request': request,
'group_membership': group_membership,
'navbar_options_template': 'enablement_navbar_options.html',
}
return render(request, self.template_name, context)
