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 mailer_add_view(request):
if request.user.is_superuser:
template = "mailer_add.html"
data=dict()
if request.method == 'POST':
mailer_form = MailerForm(request.POST)
filter_form = FilterForm(request.POST)
if mailer_form.is_valid() and filter_form.is_valid():
filt = filter_form.save()
mailer = mailer_form.save(commit=False)
mailer.filters = filt
mailer.save()
return HttpResponseRedirect(reverse('mailer_all'))
else:
data['mailer_form'] = MailerForm(request.POST)
data['filter_form'] = FilterForm(request.POST)
t = loader.get_template(template)
c = RequestContext(request, data, processors=[custom_proc])
return HttpResponse(t.render(c))
else:
data['mailer_form'] = MailerForm()
data['filter_form'] = FilterForm()
t = loader.get_template(template)
c = RequestContext(request, data, processors=[custom_proc])
return HttpResponse(t.render(c))
else:
raise Http404
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 formulario(request):
if request.method == 'POST':
form = FilterForm(request.POST)
if form.is_valid():
lista_modelos = [] #ojala fueran chavalas y no tablas :-(
for key in model_dict.keys():
if form.cleaned_data[key] == 'on':
lista_modelos.append(key)
request.session['lista_modelos'] = lista_modelos
#validar aca!
#aburriiiiiiiiiido
for coso in ('semillas', 'materia_procesada', 'buenas_practicas',
'arboles', 'cultivos', 'animales',
'tipo_organizacion', 'certificacion', 'area_trabajo'):
request.session[coso] = form.cleaned_data[coso]
#TODO:hacer un flash al estilo rails redigirir a mapita
request.session['activo'] = True
return HttpResponseRedirect('/mapeo/mapa')
else:
form = FilterForm()
return render_to_response('mapeo/formulario.html',
{'form': form},
context_instance=RequestContext(request))
def save_filter(request, filter_name=None):
if request.method == "POST":
OutFormSet = formset_factory(OutForm)
outformset = OutFormSet(request.POST)
filterform = FilterForm(request.POST)
if not outformset.is_valid() or not filterform.is_valid():
return HttpResponse("invalid form")
filter_name=filterform.cleaned_data["name"]
form_li = [i.cleaned_data for i in outformset.forms]
if len(form_li) > 0:
form_li[-1]["logical_operation"] = "none"
dname = {"name" : filter_name}
if filterform.cleaned_data.get("comment") is "":
dname["comment"] = filterform.cleaned_data["comment"]
_filter = make_filter_with_forms(form_li, dname)
s = make_dbdb_session()
ret = s.query(Filter).filter_by(name=filter_name).scalar()
if ret is not None:
s.delete(ret)
s.commit()
s.add(_filter)
s.commit()
s.close()
return HttpResponse("%(name)s has been saved<br>======it looks like======<br> %(expr)s" % {'name' : filter_name, 'expr': _filter.expression})
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 filter_edit_form(filter_id):
form = FilterForm()
filter_result = None
if filter_id is not None:
filter = models.Filter.query.get_or_404(filter_id)
filter_result = get_filter_result(filter_id, 'all')
else:
filter = models.Filter(name='')
if form.validate_on_submit():
filter.name = form.name.data
filter.icon = form.icon.data.upper()
filter.filter_string = form.filter_string.data
db.session.add(filter)
db.session.commit()
db.session.refresh(filter)
return redirect('/Filter/'+ str(filter.id))
elif filter.icon is not None:
form.icon.data = filter.icon
return render_template('filter_edit.html',
title='Filter ' + str(filter.name),
filter=filter,
filter_result=filter_result,
form=form)
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 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 hello_world():
form = FilterForm()
data = {}
if form.validate_on_submit():
for field in form.data.items():
item = field[1]
data[field[0]] = item
return render_template('index.html', title="Home", form=form,
restaurants=data["restaurants"],
cafes=data["cafes"],
apparel=data["apparel"],
lifestyle=data["lifestyle"],
specialty_goods=data["specialty_goods"]
)
return render_template('index.html', title="Home", form=form, restaurants=True, cafes=True, apparel=True, lifestyle=True, specialty_goods=True)
def filter_issues(request):
filter_form = FilterForm(request.GET)
context = {'filter_form': filter_form}
key_filters = ('project',
'service_type',
'status',
'priority',
'region',
'source',
'assignee',
'creator',
'component',
)
date_filters = ('opened_start', 'opened_end', 'control_start', 'control_end')
m2m_filters = ('contracts',)
context['filtered'] = False
if 'search' in request.GET:
if filter_form.is_valid():
context['queries'] = get_queries(request)
context['filtered'] = True
filtered_issues = Issue.objects.all()
date_filters_dict = {}
params = [v for v in request.GET.keys() if request.GET.get(v) != '' and v != 'page']
for p in params:
if p in key_filters:
qs_str = p + '__in'
filtered_issues = filtered_issues.filter(**{qs_str: request.GET.getlist(p)})
elif p in m2m_filters:
qs_str = p + '__in'
filtered_issues = filtered_issues.filter(**{qs_str: request.GET.getlist(p)}).distinct()
elif p in date_filters:
date_filters_dict[p] = filter_form.cleaned_data.get(p)
filtered_issues = issues_dates_filter(filtered_issues, **date_filters_dict)
if 'export' in request.GET:
return export_issues(request, request.GET.get('export'), filtered_issues)
context['issues'] = pagination(request, filtered_issues)
context.update(get_pagination_range(list_for_pagination=context['issues']))
context['title'] = _('Found issues')
if 'view' in request.GET:
context['extended_view'] = True
return render(request, 'helpdesk/filter.html', context)
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 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 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 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 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_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 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 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 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 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 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 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(request):
if request.method == 'POST':
form = FilterForm(request.POST)
if form.is_valid():
raw_tags = form.cleaned_data['tags'].rstrip(' ').lstrip(' ')
try:
after_date = int(time.mktime(form.cleaned_data['after'].timetuple()))
except:
after_date = None
try:
before_date = int(time.mktime(form.cleaned_data['before'].timetuple()))
except:
before_date = None
if len(raw_tags):
tagsa = raw_tags.split(',')
posts = Post.objects.filter(tags__in=Tag.objects.filter(text__in=tagsa).all()).all()
if before_date:
posts = posts.filter(date__lt=before_date)
if after_date:
posts = posts.filter(date__gt=after_date)
else:
posts = Post.objects.all()
if before_date:
posts = posts.filter(date__lt=before_date)
if after_date:
posts = posts.filter(date__gt=after_date)
else:
posts = Post.objects.all()
elif request.method == 'GET':
if 'tags' in request.GET:
tagsa = request.GET['tags'].split(',')
posts = Post.objects.filter(tags__in=Tag.objects.filter(text__in=tagsa).all()).all()
else:
posts = Post.objects.all()
form = FilterForm()
tags = Tag.objects.all()
return render(request, "index.html", {'posts': posts, 'tags': tags, 'form': form})
def index(request):
context = {}
output = Program.objects.all()
if request.method == 'POST':
form = FilterForm(request.POST)
if form.is_valid():
form_output = {"evaluation" : request.POST['evaluation'], "target_audience" : request.POST['target_audience'], "type_of_exercise" : request.POST['type_of_exercise']}
evaluation, target_audience, type_of_exercise = request.POST['evaluation'], request.POST['target_audience'], request.POST['type_of_exercise']
if type_of_exercise == "Any Activity" and target_audience == "Any" and evaluation == "Any":
context = { 'output' : output, 'form' : form, 'form_output' : form_output }
else:
result = []
for item in output:
# if (evaluation == item["evaluation"] or evaluation == 'Any') and (target_audience == item['target'] or target_audience == 'Any') and (type_of_exercise in item['type'] or type_of_exercise == 'Any Activity'):
if (evaluation == item.evaluation or evaluation == 'Any') and (target_audience == item.target_audience or target_audience == 'Any') and (type_of_exercise in item.type_of_exercise or type_of_exercise == 'Any Activity'):
result.append(item)
if result:
context = { 'output' : result, 'form' : form, 'form_output' : form_output }
else:
context = { 'output' : output, 'form' : form, 'form_output' : form_output }
else:
form = FilterForm()
context = { 'output' : output, 'form' : form }
return render(request, 'programs/index.html', context)
def ajax_report(request, report_id):
start_time = datetime.datetime.now()
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.")},
)
output_type = request.GET.get("output_type", "chart")
params = {}
special_params = {}
if report.filtersets.all():
filtersets = report.filtersets
if request.method == "GET":
filter_form = FilterForm(filtersets, request.user, request.GET)
else:
filter_form = FilterForm(filtersets, request.user)
valid_form = filter_form.is_valid()
for set in filtersets.all():
for filter in set.filters.all():
if filter_form.is_valid():
value = filter_form.cleaned_data[filter.name]
if not value:
filter.execute_function()
value = filter.default
else:
filter.execute_function()
value = filter.default
if filter.type == FILTER_TYPE_DATE:
params[filter.name] = value.strftime("%Y%m%d")
elif filter.type == FILTER_TYPE_COMBO:
special_params[filter.name] = "(" + (("".join(["%s"] * len(value)) % tuple(value))) + ")"
else:
params[filter.name] = value
series_results = []
labels = []
for s in report.serietype_set.all():
query = s.serie.query
if re.compile("[^%]%[^%(]").search(query):
return render_to_response(
"messagebox-error.html",
{
"title": _(u"Query error"),
"message": _(
u"Single '%' found, replace with double '%%' to properly escape the SQL wildcard caracter '%'."
),
},
)
cursor = connection_source.cursor()
if special_params:
for sp in special_params.keys():
query = re.compile("%\(" + sp + "\)s").sub(special_params[sp], query)
try:
serie_start_time = datetime.datetime.now()
cursor.execute(query, params)
except:
import sys
(exc_type, exc_info, tb) = sys.exc_info()
return render_to_response("messagebox-error.html", {"title": exc_type, "message": exc_info})
else:
cursor.execute(query, params)
serie_start_time = datetime.datetime.now()
labels.append(re.compile("aS\s(\S*)", re.IGNORECASE).findall(query))
if output_type == "chart":
series_results.append(data_to_js_chart(cursor.fetchall(), s.serie.tick_format, report.orientation))
elif output_type == "grid":
series_results.append(data_to_js_grid(cursor.fetchall(), s.serie.tick_format))
s.serie.last_execution_time = (datetime.datetime.now() - serie_start_time).seconds
s.serie.avg_execution_time = (s.serie.avg_execution_time or 0 + s.serie.last_execution_time) / 2
s.serie.save()
try:
serie_statistics = SeriesStatistic()
serie_statistics.serie = s.serie
serie_statistics.user = request.user
serie_statistics.execution_time = (datetime.datetime.now() - serie_start_time).seconds
serie_statistics.params = ", ".join(["%s = %s" % (k, v) for k, v in filter_form.cleaned_data.items()])
serie_statistics.save()
except:
pass
try:
report_statistics = ReportStatistic()
report_statistics.report = report
report_statistics.user = request.user
report_statistics.execution_time = (datetime.datetime.now() - start_time).seconds
report_statistics.params = "%s" % (", ".join(["%s = %s" % (k, v) for k, v in filter_form.cleaned_data.items()]))
report_statistics.save()
except:
pass
if report.orientation == "v":
h_axis = "x"
v_axis = "y"
else:
h_axis = "y"
v_axis = "x"
data = {
"chart_data": ",".join(series_results),
"series_results": series_results,
"chart_series": report.serietype_set.all(),
"chart": report,
"h_axis": h_axis,
"v_axis": v_axis,
"ajax": True,
"query": query,
"params": params,
"series_labels": labels,
"time_delta": datetime.datetime.now() - start_time,
}
if output_type == "chart":
return render_to_response("single_chart.html", data, context_instance=RequestContext(request))
elif output_type == "grid":
return render_to_response("single_grid.html", data, context_instance=RequestContext(request))
else:
return render_to_response(
"messagebox-error.html", {"title": _(u"Error"), "message": _(u"Unknown output type (chart, table, etc).")}
)
def ajax_report(request, report_id):
start_time = datetime.datetime.now()
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.")})
output_type = request.GET.get('output_type', 'chart')
params = {}
special_params = {}
if report.filtersets.all():
filtersets = report.filtersets
if request.method == 'GET':
filter_form = FilterForm(filtersets, request.user, request.GET)
else:
filter_form = FilterForm(filtersets, request.user)
for set in filtersets.all():
for filter in set.filters.all():
if filter_form.is_valid():
value = filter_form.cleaned_data[filter.name]
if not value:
filter.execute_function()
value = filter.default
else:
filter.execute_function()
value = filter.default
if filter.type == FILTER_TYPE_DATE:
params[filter.name] = value.strftime("%Y%m%d")
elif filter.type == FILTER_TYPE_COMBO:
special_params[filter.name] = '(' + ((''.join(['%s'] * len(value)) % tuple(value))) + ')'
else:
params[filter.name] = value
series_results = []
labels = []
for s in report.serietype_set.all():
query = s.serie.query
if re.compile("[^%]%[^%(]").search(query):
return render_to_response('messagebox-error.html', {'title': _(u'Query error'), 'message': _(u"Single '%' found, replace with double '%%' to properly escape the SQL wildcard caracter '%'.")})
cursor = connections['data_source'].cursor()
if special_params:
for sp in special_params.keys():
query = re.compile('%\(' + sp + '\)s').sub(special_params[sp], query)
try:
serie_start_time = datetime.datetime.now()
cursor.execute(query, params)
except:
import sys
(exc_type, exc_info, tb) = sys.exc_info()
return render_to_response('messagebox-error.html', {'title': exc_type, 'message': exc_info})
else:
cursor.execute(query, params)
serie_start_time = datetime.datetime.now()
labels.append(re.compile('aS\s(\S*)', re.IGNORECASE).findall(query))
if output_type == 'chart':
series_results.append(data_to_js_chart(cursor.fetchall(), s.serie.tick_format, report.orientation))
elif output_type == 'grid':
series_results.append(data_to_js_grid(cursor.fetchall(), s.serie.tick_format))
s.serie.last_execution_time = (datetime.datetime.now() - serie_start_time).seconds
s.serie.avg_execution_time = (s.serie.avg_execution_time or 0 + s.serie.last_execution_time) / 2
s.serie.save()
try:
serie_statistics = SeriesStatistic()
serie_statistics.serie = s.serie
serie_statistics.user = request.user
serie_statistics.execution_time = (datetime.datetime.now() - serie_start_time).seconds
serie_statistics.params = ', '.join(["%s = %s" % (k, v) for k, v in filter_form.cleaned_data.items()])
serie_statistics.save()
except:
pass
try:
report_statistics = ReportStatistic()
report_statistics.report = report
report_statistics.user = request.user
report_statistics.execution_time = (datetime.datetime.now() - start_time).seconds
report_statistics.params = "%s" % (', '.join(["%s = %s" % (k, v) for k, v in filter_form.cleaned_data.items()]))
report_statistics.save()
except:
pass
if report.orientation == 'v':
h_axis = "x"
v_axis = "y"
else:
h_axis = "y"
v_axis = "x"
data = {
'chart_data': ','.join(series_results),
'series_results': series_results,
'chart_series': report.serietype_set.all(),
'chart': report,
'h_axis': h_axis,
'v_axis': v_axis,
'ajax': True,
'query': query,
'params': params,
'series_labels': labels,
'time_delta': datetime.datetime.now() - start_time,
}
if output_type == 'chart':
return render_to_response('single_chart.html', data,
context_instance=RequestContext(request))
elif output_type == 'grid':
return render_to_response('single_grid.html', data,
context_instance=RequestContext(request))
else:
return render_to_response('messagebox-error.html', {'title': _(u'Error'), 'message': _(u"Unknown output type (chart, table, etc).")})
def tiered_stocks(request):
tiered_stocks = []
for t in Ticker.objects.all():
if t.tier:
tiered_stocks.append(t)
else:
print 'newp'
services_to_filter_by = None
service_filter_description = None
tickers_to_filter_by = None
ticker_filter_description = None
service_options = Service.objects.all()
tiers_to_filter_by = None
tier_filter_description = None
if request.POST:
tiered_filter_form = FilterForm(request.POST)
if tiered_filter_form.is_valid():
if 'services' in tiered_filter_form.cleaned_data:
if len(tiered_filter_form.cleaned_data['services']) > 0:
services_to_filter_by = tiered_filter_form.cleaned_data['services']
if 'tier_status' in tiered_filter_form.cleaned_data:
tiers_user_input = tiered_filter_form.cleaned_data['tier_status']
if len(tiers_user_input) > 0:
tickers_to_filter_by = _get_ticker_objects_for_tier_status(tiers_user_input)
ticker_note_name_prefix = 'ticker_notes_'
keys_of_ticker_note_data = [key_in_post_dict for key_in_post_dict in request.POST.keys() if key_in_post_dict.startswith(ticker_note_name_prefix)]
for key_of_ticker_note_data in keys_of_ticker_note_data:
ticker_id = key_of_ticker_note_data[len(ticker_note_name_prefix):]
print ticker_id
ticker_to_update = Ticker.objects.get(ticker_symbol=ticker_id)
ticker_to_update.notes = request.POST[key_of_ticker_note_data]
ticker_to_update.save()
print 'updated Ticker %s (id: %s). notes value: %s' % (ticker_to_update.ticker_symbol, ticker_id, ticker_to_update.notes)
elif request.GET:
initial_form_values = {}
if 'tickers' in request.GET:
tickers_user_input = request.GET.get('tickers')
tickers_to_filter_by = _get_ticker_objects_for_ticker_symbols(tickers_user_input)
initial_form_values['tickers'] = tickers_user_input
if 'service_ids' in request.GET:
services_to_filter_by = _get_service_objects_for_service_ids(request.GET.get('service_ids'))
initial_form_values['services'] = services_to_filter_by
if 'tier_status' in request.GET:
tiers_user_input = request.GET.get('tier_status')
tiers_to_filter_by = _get_ticker_objects_for_tier_status(tiers_user_input)
initial_form_values['tier_status'] = tiers_to_filter_by
print tiers_user_input
tiered_filter_form = FilterForm(initial=initial_form_values)
else:
tiered_filter_form = FilterForm()
if services_to_filter_by:
pretty_names_of_services_we_matched = [s.pretty_name for s in services_to_filter_by]
pretty_names_of_services_we_matched.sort()
service_filter_description = ', '.join(pretty_names_of_services_we_matched)
if tickers_to_filter_by:
tier_status_names = [t.tier_status for t in tickers_to_filter_by]
tier_status_names.sort()
tier_status_names = set(tier_status_names)
tier_filter_description = ', '.join(tier_status_names)
else:
pass
if tickers_to_filter_by is not None and services_to_filter_by is not None:
tiered_stocks = []
for t in tickers_to_filter_by:
for service in services_to_filter_by:
if service.pretty_name in t.services_for_ticker and t.tier is not 0:
tiered_stocks.append(t)
break
elif services_to_filter_by is not None:
tiered_stocks = []
for t in Ticker.objects.all():
if t.services_for_ticker is None:
continue
for service in services_to_filter_by:
if service.pretty_name in t.services_for_ticker and t.tier is not 0:
tiered_stocks.append(t)
break
elif tickers_to_filter_by is not None:
tiered_stocks = tickers_to_filter_by
else:
tiered_stocks = []
for t in Ticker.objects.all():
if t.tier_status:
tiered_stocks.append(t)
dictionary_of_values = {
'tiered_stocks': tiered_stocks,
'tiered_filter_form': FilterForm,
'ticker_filter_description': ticker_filter_description,
'service_filter_description': service_filter_description,
'tier_filter_description': tier_filter_description,
}
return render(request, 'satellite/tiered_stocks.html', dictionary_of_values)
def List(request):
try:
if CheckAccess(request,'5') != 'OK':
return render_to_response("notaccess.html")
except:
return HttpResponseRedirect('/')
### --- Получение номера страницы ---
try:
page = int(request.GET.get('page',1))
request.session['page'] = page
except:
pass
try:
page = int(request.session['page'])
except:
page = 1
if request.method == 'POST':
form = FilterForm(request.POST)
if form.is_valid():
search = form.cleaned_data['search']
status = form.cleaned_data['status']
request.session['search'] = search
request.session['status'] = status
else:
form = FilterForm()
try:
search = request.session['search']
status = request.session['status']
except:
search = ''
status = 'ACTIVE'
form.fields['search'].initial = search
if search !='' :
form.fields['status'].initial = 'ALL'
# form.fields['status'].widget.attrs['disabled'] = True
else:
form.fields['status'].initial = status
data = GetDList(search,status)
paginator = Paginator(data,50)
try:
data_page = paginator.page(page)
except (EmptyPage, InvalidPage):
data_page = paginator.page(paginator.num_pages)
c = RequestContext(request,{'data':data_page,'form':form})
c.update(csrf(request))
return render_to_response("contract/list.html",c)
def articles_index(request):
tickers_to_filter_by = None
services_to_filter_by = None
ticker_filter_description = None
service_filter_description = None
page_num = 1
if request.POST:
if 'page_number' in request.POST:
page_num = int(request.POST['page_number'])
article_filter_form = FilterForm(request.POST)
if article_filter_form.is_valid():
if 'tickers' in article_filter_form.cleaned_data:
tickers_user_input = article_filter_form.cleaned_data['tickers'].strip()
if tickers_user_input != '':
tickers_to_filter_by = _get_ticker_objects_for_ticker_symbols(tickers_user_input)
if 'services' in article_filter_form.cleaned_data:
if len(article_filter_form.cleaned_data['services']) > 0:
services_to_filter_by = article_filter_form.cleaned_data['services']
elif request.GET:
initial_form_values = {}
if 'tickers' in request.GET:
tickers_user_input = request.GET.get('tickers')
tickers_to_filter_by = _get_ticker_objects_for_ticker_symbols(tickers_user_input)
initial_form_values['tickers'] = tickers_user_input
if 'service_ids' in request.GET:
services_to_filter_by = _get_service_objects_for_service_ids(request.GET.get('service_ids'))
initial_form_values['services'] = services_to_filter_by
article_filter_form = FilterForm(initial=initial_form_values)
else:
article_filter_form = FilterForm()
if tickers_to_filter_by:
ticker_filter_description = ', '.join([t.strip() for t in tickers_user_input.split(",")])
if services_to_filter_by:
pretty_names_of_services_we_matched = [s.pretty_name for s in services_to_filter_by]
pretty_names_of_services_we_matched.sort()
service_filter_description = ', '.join(pretty_names_of_services_we_matched)
if tickers_to_filter_by is not None and services_to_filter_by is not None:
articles = Article.objects.filter(ticker__in=tickers_to_filter_by, service__in=services_to_filter_by).order_by('-date_pub')
elif tickers_to_filter_by is not None:
articles = Article.objects.filter(ticker__in=tickers_to_filter_by).order_by('-date_pub')
elif services_to_filter_by is not None:
articles = Article.objects.filter(service__in=services_to_filter_by).order_by('-date_pub')
else:
articles = Article.objects.all().order_by('-date_pub')
paginator = Paginator(articles, 100)
try:
articles_subset = paginator.page(page_num)
except PageNotAnInteger:
# page is not an integer; let's show the first page of results
articles_subset = paginator.page(1)
except EmptyPage:
# the user asked for a page way beyond what we have available;
# let's show the last page of articles, which we can calculate
# with paginator.num_pages
articles_subset = paginator.page(paginator.num_pages)
if len(articles):
article_most_recent_date = articles[0].date_pub
article_oldest_date = articles[len(articles)-1].date_pub
else:
article_most_recent_date = "n/a"
article_oldest_date = "n/a"
authors = [art.author for art in articles]
authors_set = set(authors)
num_authors = len(authors_set)
num_articles = len(articles)
article_defns = []
for article in articles_subset:
byline_meta_data = ''
byline_match = BylineMetaData.objects.filter(byline=article.author)
if byline_match:
byline_meta_data = byline_match[0].services
article_defns.append({
'article':article,
'author_service_associations': byline_meta_data,
})
dictionary_of_values = {
'form': article_filter_form,
'articles': articles_subset,
'article_defns': article_defns,
'pub_date_newest': article_most_recent_date,
'pub_date_oldest': article_oldest_date,
'num_authors' : num_authors,
'num_articles' : num_articles,
'service_filter_description': service_filter_description,
'ticker_filter_description': ticker_filter_description
}
return render(request, 'satellite/articles_index.html', dictionary_of_values)
def grid(request, mode=''):
# This code will create 'shelve.db' if it absent. You need uncoment code and
# reload page. So 'shelve.db' will be created
# d = shelve.open('shelve.db')
# d['IMPORT_MODE'] = False
# d.close()
d = shelve.open('shelve.db')
import_mode = d['IMPORT_MODE']
d.close()
context = RequestContext(request)
myquery = Q()
# Фильтр по умолчанию - за последние n дней.
n = 60
start = datetime.datetime.now() - datetime.timedelta(days=n)
end = datetime.datetime.now()
defaultfilter = Q(datetime__range=(start, end))
# Если не указано иное, то по умолчанию используется темплайт grid
shablon = 'grid.html'
if request.method == 'GET':
# В эту ветку мы можем попасть, если нажато Filter или Print или Clear
form = FilterForm(request.GET)
if form.is_valid():
"""
DEPRECATED
# Логика по датам: первый if - введены обе даты, elif - если введена только начальная дата -
# с нее по сегодня, иначе - за последние n дней.
if form.cleaned_data['from_date'] and form.cleaned_data['to_date']:
start = form.cleaned_data['from_date']
end = form.cleaned_data['to_date'] + datetime.timedelta(days=1)
myquery &= Q(datetime__range=(start, end))
elif form.cleaned_data['from_date']:
start = form.cleaned_data['from_date']
end = datetime.datetime.now() + datetime.timedelta(days=1)
myquery &= Q(datetime__range=(start, end))
else:
myquery &= defaultfilter
if form.cleaned_data['contractor']:
myquery &= Q(contractor__exact=form.cleaned_data['contractor'])
if form.cleaned_data['machine']:
myquery &= Q(machine__exact=form.cleaned_data['machine'])
if form.cleaned_data['filename']:
if form.cleaned_data['filename'][0] == '-':
myquery &= ~Q(pdfname__icontains=form.cleaned_data['filename'][1:])
else:
myquery &= Q(pdfname__icontains=form.cleaned_data['filename'])
"""
#### НОЫВАЯ ЛОГИКА ####
# Если пользователь задал хотя бы один фильтр, то применяем только явно заданные фильтры. Иначе применяем фильтр "за последние два месяца".
if form.cleaned_data['from_date'] or form.cleaned_data['to_date'] or form.cleaned_data['contractor'] or form.cleaned_data['machine'] or form.cleaned_data['filename']:
# Если заданы обе даты, то делаем выборку между ними, иначе проверяем, задана ли начальная дата, и делаем выборку от нее по today
if form.cleaned_data['from_date'] and form.cleaned_data['to_date']:
start = form.cleaned_data['from_date']
end = form.cleaned_data['to_date'] + datetime.timedelta(days=1)
myquery &= Q(datetime__range=(start, end))
elif form.cleaned_data['from_date']:
start = form.cleaned_data['from_date']
end = datetime.datetime.now() + datetime.timedelta(days=1)
myquery &= Q(datetime__range=(start, end))
if form.cleaned_data['contractor']:
myquery &= Q(contractor__exact=form.cleaned_data['contractor'])
if form.cleaned_data['machine']:
myquery &= Q(machine__exact=form.cleaned_data['machine'])
# Если предварить фильтр по имени файла дефисом, то это исключит имена, вместо добавления
if form.cleaned_data['filename']:
if form.cleaned_data['filename'][0] == '-':
myquery &= ~Q(pdfname__icontains=form.cleaned_data['filename'][1:])
else:
myquery &= Q(pdfname__icontains=form.cleaned_data['filename'])
else:
myquery &= defaultfilter
if mode == 'clear':
myquery = defaultfilter
form = FilterForm()
table = Grid.objects.filter(myquery).order_by('datetime').reverse()
if mode == 'printing':
table = table.reverse()
shablon = 'printing.html'
if mode == 'filter':
pass
else:
# В эту ветку попадаем, если пользователем перед этим не был применен фильтр.
# Например, после Delete или первый заход на страницу
table = Grid.objects.filter(defaultfilter).order_by('datetime').reverse()
form = FilterForm()
sum_plates = {}
for m in PrintingPress.objects.all():
total = table.filter(machine__name=m.name).aggregate(Sum('total_plates'))
if total['total_plates__sum']:
sum_plates[m.name] = total['total_plates__sum']
return render_to_response(shablon, {'table': table, 'form': form, 'sum_plate': sum_plates, 'import_mode': import_mode}, context)
def coverage_detail(request, ticker_symbol):
try:
ticker = Ticker.objects.get(ticker_symbol=ticker_symbol)
except:
# if the ticker isn't found, redirect to the listing of all tickers
return redirect('coverage_index')
services_to_filter_by = None
service_filter_description = None
tickers_to_filter_by = None
single_authors = get_authors_from_article_set()
audit_filter_form = None
if request.POST:
if 'coverage' in request.POST:
audit_filter_form = FilterForm(request.POST)
# delete records that are already there
coverage_type_objects = CoverageType.objects.filter(ticker=ticker)
print 'deleting existing CoverageType records for %s (%d)' % (ticker.ticker_symbol, len(coverage_type_objects))
coverage_type_objects.delete()
# replace them with the records passed along in POST
# we expect the keys per selection to have this format: "cid_x__sid_y", where x is a content choice integer value, y is a service id
selected_keys = [k for k in request.POST if k.startswith('author_')]
for k in selected_keys:
k = k.replace('author_','')
print k, '----pants----'
choice_id, service_id = k.replace("cid_","").replace("sid_","").split('__')
ct = CoverageType()
ct.coverage_type = int(choice_id)
ct.ticker = ticker
ct.service = Service.objects.get(id=service_id)
author_key = 'author_'+k
print author_key
if author_key in request.POST:
ct.author = request.POST[author_key]
ct.save()
print 'added CoverageType record: %s %s %d %s' % (ct.service.pretty_name, ct.ticker.ticker_symbol, ct.coverage_type, ct.author)
else:
audit_filter_form = FilterForm(request.POST)
if audit_filter_form.is_valid():
if 'services' in audit_filter_form.cleaned_data:
if len(audit_filter_form.cleaned_data['services']) > 0:
services_to_filter_by = audit_filter_form.cleaned_data['services']
elif request.GET:
initial_form_values = {}
if 'tickers' in request.GET:
initial_form_values['tickers'] = ticker
if 'service_ids' in request.GET:
services_to_filter_by = _get_service_objects_for_service_ids(request.GET.get('service_ids'))
initial_form_values['services'] = services_to_filter_by
audit_filter_form = FilterForm(initial=initial_form_values)
else:
audit_filter_form = FilterForm()
if services_to_filter_by:
pretty_names_of_services_we_matched = [s.pretty_name for s in services_to_filter_by]
pretty_names_of_services_we_matched.sort()
service_filter_description = ', '.join(pretty_names_of_services_we_matched)
else:
pass
services = Service.objects.all()
today = datetime.now()
date_today = today.date()
ninety_days_ago = (date_today - timedelta(days=90))
articles = [a for a in Article.objects.filter(ticker=ticker).exclude(tags=None).exclude(tags='') if a.date_pub is not None and a.date_pub.date() >= ninety_days_ago]
relevant_articles = set()
ten_percent_promises = set()
everlasting = set()
analysis = set()
featured = set()
earnings = set()
mission_log = set()
buy_recommendations = set()
five_and_three = set()
best_buys_now = set()
two_minute_drills = set()
commentary = set()
news = set()
for a in articles:
if '10 promise' in a.tags:
ten_percent_promises.add(a)
if 'everlasting' in a.tags:
everlasting.add(a)
if 'analysis' in a.tags:
analysis.add(a)
if 'featured' in a.tags:
featured.add(a)
if 'earnings' in a.tags:
earnings.add(a)
if 'mission_log' in a.tags:
mission_log.add(a)
if 'buy recommendation' in a.tags:
buy_recommendations.add(a)
if '5 and 3' in a.tags:
five_and_three.add(a)
if 'best buys now' in a.tags:
best_buys_now.add(a)
if '2 minute drill' in a.tags:
two_minute_drills.add(a)
if 'commentary' in a.tags:
commentary.add(a)
if 'news' in a.tags:
news.add(a)
print request.POST
dictionary_of_values = {
'ticker': ticker,
'form': audit_filter_form,
'service_filter_description': service_filter_description,
'coverage_type_choices': COVERAGE_CHOICES,
'services': services,
'single_authors': single_authors,
'title_value': '%s (%s)' % (ticker.company_name, ticker.ticker_symbol),
'relevant_articles': relevant_articles,
'ten_percent_promises': ten_percent_promises,
'everlasting': everlasting,
'featured': featured,
'earnings': earnings,
'mission_log': mission_log,
'buy_recommendations': buy_recommendations,
'five_and_three': five_and_three,
'best_buys_now': best_buys_now,
'two_minute_drills': two_minute_drills,
'commentary': commentary,
'news': news,
}
return render(request, 'satellite/coverage_detail.html', dictionary_of_values)
