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 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 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 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 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 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 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: 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(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, 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 post(self, request):
if not request.user.is_authenticated():
return render(request, 'unauthorised.html')
form = FilterForm(request.POST)
if not form.is_valid():
return render(request, 'show_challenge.html', {
'form': form,
'error': 'Invalid Form Data'
})
this = form.cleaned_data
q_set = Challenge.objects.filter(
to=request.user.username,
resolved=this.get('resolved')).order_by('-time')
if this.get('frm') != '':
q_set = q_set.filter(frm=this.get('frm'))
if this.get('contest') != '':
q_set = q_set.filter(contest=this.get('contest'))
if len(q_set):
return render(request, 'show_challenge.html', {
'form': form,
'results': q_set
})
else:
return render(
request, 'show_challenge.html', {
'form': form,
'error':
'No search items found matching the required filters'
})
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)
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 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 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 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 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)
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 user_map(request):
#os.chdir(os.path.dirname(__file__))
#pageMessage = None
pageMessage = None
if request.method == 'POST':
#arr = json.loads(request.body)
form = FilterForm(request.POST)
form1 = CoordForm(request.POST)
print("Hello")
if form.is_valid() or form1.is_valid():
rend = request.POST['myRender']
coords = request.POST['myCoords']
print(rend)
print(coords)
x1 = float(coords.split(",")[0])
print(str(x1))
y1 = float(coords.split(",")[1])
#arr = json.loads(request.body)
#for key in request.POST:
# print(key)
# value = request.POST[key]
# print(value)
#test = request.POST['csrfmiddlewaretoken']
#print("This - " + test)
#rend = request.POST['myRender']
#print("Attay[0] - " + str(arr[0]))
#print(rend)
#arr = [1,2,3,4]
x1, y1 = transform(inProj, outProj, x1, y1)
#print(str(x1) + ", " + str(y1))
#temporary test are for 3d model
#threshold is 10 km
thold = 10000.
data_av = False
lakes_xo = 322173.0
lakes_yo = 515831.0
walton_xo = 620000.0
walton_yo = 220000.0
#test if it is near the lakes model
dist = ((x1 - lakes_xo)**2 + (y1 - lakes_yo)**2)**0.5
if dist <= thold:
data_av = True
#test if it is near the lakes model
dist = ((x1 - walton_xo)**2 + (y1 - walton_yo)**2)**0.5
if dist <= thold:
data_av = True
if data_av:
pageMessage = "3D Terrain model available"
return render(request, 'terrainviewer/north_lakes_render.html')
else:
pageMessage = "No 3D Terrain model available"
print(pageMessage)
#return HttpResponseRedirect("http://127.0.0.1:8000/terrainviewer/tester")
else:
form = FilterForm()
form1 = CoordForm()
return render(request, 'terrainviewer/selectionMessage.html', {
'form1': form1,
'form': form,
'pageMessage': pageMessage,
})
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)
