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 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)