コード例 #1
0
def report_scheduled_job():
    consumer_key = settings.CONSUMER_KEY
    consumer_secret = settings.CONSUMER_SECRET
    access_token = settings.ACCESS_TOKEN
    access_secret = settings.ACCESS_SECRET
    max_tweets = settings.MAX_TWEETS

    auth = OAuthHandler(consumer_key, consumer_secret)
    auth.set_access_token(access_token, access_secret)
    api = tweepy.API(auth)

    non_bmp_map = dict.fromkeys(range(0x10000, sys.maxunicode + 1), 0xfffd)
    sources = Source.objects.filter(status='ACTIVE', type='TWITTER')

    for active_source in sources:
        keywords = active_source.keywords.all()
        for a_keyword in keywords:
            query = a_keyword.keyword
            searched_tweets = [
                status for status in tweepy.Cursor(api.search, q=query).items(
                    max_tweets)
            ]
            source = Reports_Source.objects.get(code='TWT')
            for status in searched_tweets:
                tweet_localcreatedtime = status.created_at + timedelta(hours=7)
                diff = datetime.now() - tweet_localcreatedtime
                diff_hours = diff.total_seconds() / 3600
                if diff_hours <= 1:
                    note = status.text.translate(non_bmp_map)
                    note = "[{}] {}".format(active_source.disaster,
                                            smart_str(note))
                    new_report = Report(note=note, source=source)
                    new_report.save()
コード例 #2
0
ファイル: views.py プロジェクト: vampure/reporting-system
def NewReport(request):
    if request.method == 'POST':
        com_name = request.POST.get("com_name")
        acronym = request.POST.get("acronym")
        wor_id = request.POST.get("wor_id")
        creator_id = int(request.POST.get("creator_name"))
        reviewer_id = int(request.POST.get("reviewer"))
        time = request.POST.get("start_date")
        print >> sys.stderr, 'End time: ' + str(time)
        end_time = request.POST.get("end_date")
        print >> sys.stderr, 'End time: ' + end_time
        wapt = bool(request.POST.get("f_wapt"))
        print >> sys.stderr, 'NewReport ' + str(wapt)
        new_report = Report(company_name=com_name, comp_acronym=acronym, 
                            wor_id=wor_id, creator_name_id=creator_id,
                            reviewer_name_id=reviewer_id,  pub_date=time,
                            end_date=end_time, report_wapt=wapt)
        #if request.POST.get("com_priority") is 'low':
            #new_report.report_status = False
        #print >> sys.stderr, 'NewReportx ' + str(new_report.report_status)
        new_report.save()
        return redirect("/reports/")
    else:
        new_report = 'new report here'
        reviewer = UserProfile.objects.all()
        print >> sys.stderr, str(reviewer)
        form = CveForm()
    
    return render(request, 'reports/new_report.html', { 'form' :form, 'reviewer': reviewer })
コード例 #3
0
ファイル: cron.py プロジェクト: geoenvo/opendims
def report_scheduled_job():
    consumer_key = settings.CONSUMER_KEY
    consumer_secret = settings.CONSUMER_SECRET
    access_token = settings.ACCESS_TOKEN
    access_secret = settings.ACCESS_SECRET
    max_tweets = settings.MAX_TWEETS

    auth = OAuthHandler(consumer_key, consumer_secret)
    auth.set_access_token(access_token, access_secret)
    api = tweepy.API(auth)

    non_bmp_map = dict.fromkeys(range(0x10000, sys.maxunicode + 1), 0xfffd)
    sources = Source.objects.filter(status='ACTIVE', type='TWITTER')

    for active_source in sources:
        keywords = active_source.keywords.all()
        for a_keyword in keywords:
            query = a_keyword.keyword
            searched_tweets = [status for status in tweepy.Cursor(api.search, q=query).items(max_tweets)]
            source = Reports_Source.objects.get(code='TWT')
            for status in searched_tweets:
                tweet_localcreatedtime = status.created_at + timedelta(hours=7)
                diff = datetime.now() - tweet_localcreatedtime
                diff_hours = diff.total_seconds() / 3600
                if diff_hours <= 1:
                    note = status.text.translate(non_bmp_map)
                    note = "[{}] {}".format(active_source.disaster, smart_str(note))
                    new_report = Report(
                        note=note,
                        source=source
                    )
                    new_report.save()
コード例 #4
0
ファイル: views.py プロジェクト: rauloojs/Tata-Server
def send(request):
    # make request
    # nombre doctor
    # fecha consulta
    # nombre paciente
    # edo paciente
    # observaciones
    # sugerencias
    doc_name = request.POST.get('nombre_dr', "")
    patient_name = request.POST.get('nombre_pac', "")
    consult_date = request.POST.get('fecha', "")
    patient_state = request.POST.get('estado_pac', "")
    observ = request.POST.get('comentarios', "")
    suggest = request.POST.get('sugerencias', "")

    rep = Report(doc_name=doc_name,
                 patient_name=patient_name,
                 consult_date=consult_date,
                 patient_state=patient_state,
                 observ=observ,
                 suggest=suggest)
    rep.save()

    url = 'https://android.googleapis.com/gcm/send'
    headers = {
        'Content-Type': 'application/json',
        'Authorization': 'key=AIzaSyCH7B7qMMbLnQdj6WG1yuvPp3SlsLHtBds'
    }
    payload = {
        "data": {
            "fecha": consult_date,
            "doctor": doc_name,
            "paciente": patient_name,
            "observaciones": observ,
            "sugerencias": suggest
        },
        "registration_ids": [
            "APA91bHDXfzISMoo6OfqhhODnU7TeNzqCxeE7lYZHhdI801wazh1e7vbITZVTqwKU5avNW0myInlZW3Aat3S8gzqawN9G5fQEkMVNvqkDHRRYt1IDsFrPuc"
        ]
    }

    try:
        r = requests.post(url, data=json.dumps(payload))
        #r = requests.post(url, headers=headers, data=json.dumps(payload))
    except requests.exceptions.ConnectionError:
        return render(request, 'reports/index.html', {
            'error_message':
            "No hay conexión a internet, intente más tarde",
        })
    else:
        print >> sys.stderr, "POST request response: ", r.status_code
        if r.status_code == 200:
            code = 0
        else:
            code = 1
        #print >>sys.stderr, consult_date
        return HttpResponseRedirect(
            reverse('reports:results', args=(rep.id, code)))
    finally:
        pass
コード例 #5
0
def attach_to_waste_deposit(report: Report) -> None:
    """
    Try to find an existing waste deposit in 5 meters from the new report location
    to attach report. If close waste deposit does not exist
    the new one with report`s coordinates will be created.
    """

    waste_deposits = WasteDeposit.objects.all()

    close_waste_deposit = None

    for waste_deposit in waste_deposits:
        distance = geodesic(report.location, waste_deposit.location).meters
        if distance <= settings.WASTE_DEPOSIT_DISTANCE_IN_METERS:
            settings.LOGGER.info(
                f'Attaching report {report.id} to the existing '
                f'waste deposit {waste_deposit.id} in {round(distance, ndigits=2)} '
                f'meters.'
            )
            close_waste_deposit = waste_deposit
            break

    if not close_waste_deposit:
        settings.LOGGER.info(
            f'Creating new waste deposit for the report {report.id}.'
        )
        close_waste_deposit = WasteDeposit.objects.create(
            lat=report.lat, long=report.long
        )

    report.waste_deposit_id = close_waste_deposit
    report.save()
コード例 #6
0
    def test_should_raise_404_if_no_tracker(self):
        report = Report()
        report.save()

        c = Client()
        response = c.get(self.STATS_PATH)

        self.assertEqual(response.status_code, 404)
コード例 #7
0
ファイル: views.py プロジェクト: rauloojs/Tata-Server
def send(request):
	# make request
	# nombre doctor
	# fecha consulta
	# nombre paciente
	# edo paciente
	# observaciones
	# sugerencias
	doc_name = request.POST.get('nombre_dr', "")
	patient_name = request.POST.get('nombre_pac', "")
	consult_date = request.POST.get('fecha', "")
	patient_state = request.POST.get('estado_pac', "")
	observ = request.POST.get('comentarios', "")
	suggest = request.POST.get('sugerencias', "")

	rep = Report(doc_name=doc_name, patient_name=patient_name, consult_date=consult_date, patient_state=patient_state, observ=observ, suggest=suggest)
	rep.save()

	url = 'https://android.googleapis.com/gcm/send'
	headers = {'Content-Type': 'application/json',
				'Authorization': 'key=AIzaSyCH7B7qMMbLnQdj6WG1yuvPp3SlsLHtBds'}
	payload = {
	          "data": {
	            "fecha": consult_date,
	            "doctor": doc_name,
	            "paciente": patient_name,
	            "observaciones": observ,
	            "sugerencias": suggest
	          },
	          "registration_ids": [
	            "APA91bHDXfzISMoo6OfqhhODnU7TeNzqCxeE7lYZHhdI801wazh1e7vbITZVTqwKU5avNW0myInlZW3Aat3S8gzqawN9G5fQEkMVNvqkDHRRYt1IDsFrPuc"
	          ]
	}

	try:
		r = requests.post(url, data=json.dumps(payload))
		#r = requests.post(url, headers=headers, data=json.dumps(payload))
	except requests.exceptions.ConnectionError:
		return render(request, 'reports/index.html', {
            'error_message': "No hay conexión a internet, intente más tarde",
        })
	else:
		print >>sys.stderr, "POST request response: ", r.status_code
		if r.status_code == 200:
			code = 0
		else:
			code = 1
		#print >>sys.stderr, consult_date
		return HttpResponseRedirect(reverse('reports:results', args=(rep.id, code)))
	finally:
		pass
コード例 #8
0
ファイル: logic.py プロジェクト: freedomd/WhiteBayReporting
def getReport():
    today = date.today()
    delta = datetime.timedelta(days=1)
    yesterday = today - delta

    trades = Trade.objects.filter(
        Q(tradeDate__year=today.year) & Q(tradeDate__month=today.month) & Q(tradeDate__day=today.day)
    )

    for trade in trades:
        try:
            new_report = Report.objects.get(
                Q(symbol=trade.symbol)
                & Q(reportDate__year=today.year)
                & Q(reportDate__month=today.month)
                & Q(reportDate__day=today.day)
            )

        except Report.DoesNotExist:  # today's new does not exist
            try:  # get yesterday's
                old_report = Report.objects.get(
                    Q(symbol=trade.symbol)
                    & Q(reportDate__year=yesterday.year)
                    & Q(reportDate__month=yesterday.month)
                    & Q(reportDate__day=yesterday.day)
                )
                old_report.pk = None
                old_report.save()  # clone a new one
                new_report = old_report
                new_report.SOD = new_report.EOD  # update SOD
            except Report.DoesNotExist:  # yesterday's old does not exist
                new_report = Report()
                new_report.symbol = trade.symbol

            new_report.reportDate = today

        # update report
        if trade.side == "B":
            total = new_report.buys * new_report.buyAve
            total += trade.quantity * trade.price  # new total
            new_report.buys += trade.quantity  # new buys
            new_report.buyAve = total / new_report.buys  # new buy ave
            new_report.EOD = new_report.EOD + trade.quantity

        elif trade.side == "S":
            total = new_report.sells * new_report.sellAve
            total += trade.quantity * trade.price  # new total
            new_report.sells += trade.quantity  # new sells
            new_report.sellAve = total / new_report.sells  # new sell ave
            new_report.EOD = new_report.EOD - trade.quantity

        new_report.save()  # save result

    getPNLs(today)  # calculate PNLS
    getTotal(today)  # get summary date
コード例 #9
0
ファイル: views.py プロジェクト: mas2tg/cs3240-f16-team07
def add_report(request): #the user is able to select multiple files
        if request.method == 'POST':
                form = ReportForm(request.POST, request.FILES)
                creator = request.user
                name = request.POST.get('name')
                keyword = request.POST.get('keyword')
                description = request.POST.get('description')
                
                encrypted = True if request.POST.get('encrypted') else False
                longDescription = request.POST.get('longDescription')
                private = True if request.POST.get('private') else False

                ip = get_client_ip(request)



                file = os.path.join(settings.GEOIP_PATH, 'GeoLiteCity.dat')

                
                gi = pygeoip.GeoIP(file)
                info=gi.record_by_addr(ip)
                
                
                
                area_code = None
                city = None
                country = None
                if info != None:
                    area_code = info['region_code']
                    city = info['city']
                    country = info['country_name']


                report = Report(creator_id=creator.id,region_code=area_code,city=city,country=country,keyword=keyword, encrypted=encrypted, name=name, description=description,longDescription=longDescription,private =private)

                #
                report.save()
                # file = File(report=report, path=paths) #pass variables to fields

                paths = request.FILES.getlist('path')
                #print(request.FILES)
                for path in paths:
                    File(report=report, path=path).save() #pass variables to fields


                return HttpResponseRedirect('/reports/$/')

        else:
                # This should never happen
                return HttpResponse('Improper arrival at add_report, see reports.views')
コード例 #10
0
ファイル: views_api.py プロジェクト: novirael/diabcontrol
    def post(self, request):
        serializer = MainReportSerializer(data=request.data)

        if serializer.is_valid():
            data_questions = serializer.data['questions']
            data_stats = serializer.data['stats']

            report = Report()
            report.patient = self.request.user
            report.has_headaches = data_questions['has_headaches']
            report.mood_level = data_questions['mood_level']
            report.other_diseases = data_questions['other_diseases']

            report.save()

            for group, group_data in data_stats.items():
                for data_type, type_data in group_data.items():
                    for data in type_data:
                        ReportData.objects.save_data(
                            self.request.user,
                            data_type,
                            data['timestamp'],
                            data['value'],
                            group,
                            report
                        )

            return Response(status=status.HTTP_201_CREATED)

        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
コード例 #11
0
    def test_should_return_stats_with_1_tracker_not_found(self):
        tracker = Tracker(name='Teemo')
        tracker.save()
        report = Report()
        report.save()

        c = Client()
        response = c.get(self.STATS_PATH)

        self.assertEqual(response.status_code, 200)
        self.assertContains(response, tracker.name, 1)
        self.assertEqual(response.context['trackers'][0].name, tracker.name)
        self.assertEqual(response.context['trackers'][0].count, 0)
        self.assertEqual(response.context['trackers'][0].score, 0)
コード例 #12
0
    def test_button_save_and_exit_redirects_to_correct_view(
            self, mock_update, mock_get):
        """
        Clicking on `Save and exit` button should update the draft barrier
        and redirect the user to the draft barrier details view
        """
        mock_update.return_value = Report(self.draft)
        mock_get.return_value = Report(self.draft)
        redirect_url = reverse('reports:draft_barrier_details_uuid',
                               kwargs={"barrier_id": self.draft["id"]})

        response = self.client.post(self.url, data={"action": "exit"})

        self.assertRedirects(response, redirect_url)
        assert mock_update.called is True
コード例 #13
0
ファイル: report_generator.py プロジェクト: AkaG/inz_retina
    def generate_report(self):
        self._create_directory()
        report = Report()
        report.save()

        report.report = self._get_report_file(report.id)
        report.neural_network = self.neural_network
        report.save()
コード例 #14
0
    def test_draft_barriers_returns_correct_html(self, mock_list):
        mock_list.return_value = (Report(self.draft_barrier(4)), Report(self.draft_barrier(5)),)
        expected_title = "<title>Market Access - Draft barriers</title>"
        my_draft_barriers_table = '<table class="standard-table my-draft-barriers">'
        draft_barrier_row = '<tr class="standard-table__row draft-barrier-item">'
        expected_row_count = 2

        response = self.client.get(self.url)
        html = response.content.decode('utf8')

        assert HTTPStatus.OK == response.status_code
        assert expected_title in html
        assert my_draft_barriers_table in html
        row_count = html.count(draft_barrier_row)
        assert expected_row_count == row_count,\
            f'Expected {expected_row_count} least one sector option, got: {row_count}'
コード例 #15
0
    def test_report_detail_view_loads_html__with_sections_not_started(self, mock_get):
        draft = self.draft_barrier(30)
        url = reverse(
            "reports:draft_barrier_details_uuid",
            kwargs={"barrier_id": draft["id"]}
        )
        mock_get.return_value = Report(draft)
        expected_title = "<title>Market Access - Add - Barrier details</title>"
        expected_callout_container = '<div class="callout callout--warn callout--with-button">'
        expected_callout_heading = '<h2 class="callout__heading">Unfinished barrier for</h2>'
        submit_button = '<input type="submit" value="Submit barrier" class="callout__button">'
        complete_class = "task-list__item__banner--complete"
        expected_complete_class_count = 3

        response = self.client.get(url)
        html = response.content.decode("utf8")

        assert HTTPStatus.OK == response.status_code
        assert expected_title in html
        assert expected_callout_container in html
        assert expected_callout_heading in html
        assert submit_button not in html
        completed_count = html.count(complete_class)
        assert expected_complete_class_count == completed_count,\
            f'Expected {expected_complete_class_count} admin areas, got: {completed_count}'
コード例 #16
0
ファイル: tests.py プロジェクト: anukat2015/Sylva
 def setUp(self):
     self.graph = Graph.objects.get(pk=1)
     self.template = ReportTemplate(name="test",
                                    start_date=datetime.now(),
                                    frequency="h",
                                    last_run=datetime.now(),
                                    layout={"hello": "world"},
                                    description="Some",
                                    graph=self.graph)
     self.template.save()
     self.template_id = self.template.id
     self.datetime = datetime.now()
     self.report = Report(date_run=self.datetime,
                          table={"hello": "again"},
                          template=self.template)
     self.report.save()
コード例 #17
0
    def handle(self, quiet=False, *files, **options):
        connection = connections[DEFAULT_DB_ALIAS]
        self.style = no_style()

        cursor = connection.cursor()

        # we do all messages in one transaction
        transaction.commit_unless_managed()
        transaction.enter_transaction_management()
        transaction.managed(True)

        # our current date/time in UTC
        utc_time = datetime.now(pytz.utc)

        try:
            # check our reports
            sent = Report.check_all(utc_time, quiet)
            if not quiet:
                print
                print "%d reports sent." % sent
        except Exception as e:
            traceback.print_exc(e)

        # one uber commit
        transaction.commit()
コード例 #18
0
ファイル: import_csv.py プロジェクト: danjac/sightings
    def parse_row_data(self, row):
        if len(row) != 9:
            return None
        print(row)

        (
            _,
            location,
            shape,
            duration,
            description,
            latitude,
            longitude,
            reported_at,
            occurred_at,
        ) = row

        return Report(
            occurred_at=self.parse_date(occurred_at),
            reported_at=self.parse_date(reported_at),
            location=location,
            shape=shape,
            duration=duration,
            description=description,
            latitude=self.parse_coord(latitude),
            longitude=self.parse_coord(longitude),
        )
コード例 #19
0
ファイル: report_populator.py プロジェクト: EQAR/eqar_backend
    def _report_upsert(self):
        """
        Create or update a Report record.
        """
        activity = self.submission.get('esg_activity', None)
        report_name = activity.activity + ' (by ' + self.agency.acronym_primary + ')'

        # Update report
        if self.report is not None:
            self.report.name = report_name
            self.report.agency = self.agency
            self.report.local_identifier = self.submission.get(
                'local_identifier', None)
            self.report.agency_esg_activity = activity
            self.report.status = self.submission.get('status', None)
            self.report.decision = self.submission.get('decision', None)
            self.report.valid_from = self.submission.get('valid_from', None)
            self.report.valid_to = self.submission.get('valid_to', None)
            self.report.updated_by = self.user
            self.report.updated_at = datetime.now()
            self.report.other_comment = self.submission.get(
                'other_comment', None)

            Report.contributing_agencies.through.objects.all().delete()

        # Create report
        else:
            self.report = Report(
                name=report_name,
                agency=self.agency,
                local_identifier=self.submission.get('local_identifier', None),
                agency_esg_activity=self.submission.get('esg_activity', None),
                status=self.submission.get('status', None),
                decision=self.submission.get('decision', None),
                valid_from=self.submission.get('valid_from', None),
                valid_to=self.submission.get('valid_to', None),
                created_by=self.user,
                other_comment=self.submission.get('other_comment', None))

        # Assign contributing agencies
        contributing_agencies = self.submission.get('contributing_agencies',
                                                    [])
        for contributing_agency in contributing_agencies:
            self.report.contributing_agencies.add(contributing_agency)

        self.report.save()
コード例 #20
0
ファイル: logic.py プロジェクト: freedomd/WhiteBayReporting
def getTotal(report_date):
    total = Report()
    total.symbol = "Total"
    report_list = Report.objects.filter(Q(reportDate=report_date))
    for report in report_list:
        total.SOD += report.SOD
        total.buys += report.buys
        total.sells += report.sells
        total.grossPNL += report.grossPNL
        total.unrealizedPNL += report.unrealizedPNL
        total.fees += report.fees
        total.netPNL += report.netPNL
        total.LMV += report.LMV
        total.SMV += report.SMV
        total.EOD += report.EOD
    total.reportDate = report_date
    total.save()
コード例 #21
0
ファイル: tests.py プロジェクト: CulturePlex/Sylva
 def test_report_delete(self):
     report = Report(date_run=datetime.now(), table={"hello": "again"}, template=self.template)
     report.save()
     rid = report.id
     try:
         r = Report.objects.get(pk=rid)
         exists = True
     except ReportTemplate.DoesNotExist:
         exists = False
     self.assertTrue(exists)
     r.delete()
     try:
         Report.objects.get(pk=rid)
         exists = True
     except Report.DoesNotExist:
         exists = False
     self.assertFalse(exists)
コード例 #22
0
ファイル: handlers.py プロジェクト: Astrabella/WalkGoodJA
class ReportHandler(PatternHandler):
    """ Handles the initialization of the reporting process. """
    pattern = r"^\s*R(eport)?\s*$"
    report = 0

    def help(self):
        # Create a new report in the DB
        self.report = Report(identity=self.msg.connection.identity, state=1)
        self.report.save()
        logger.debug("New report created")

        # Send initial response to user
        self.respond("Hello. Please text a number for the incident you are reporting..." +
                      "1-Verbal Abuse,  2-Physical Abuse,  3-Sexual Assault,  4-Robbery,  5-Rape")

    def handle(self, text):
        self.help()
コード例 #23
0
ファイル: mutation.py プロジェクト: Uttah/syn_app
    def mutate_and_get_payload(root, info, **kwargs):
        kwargs = check_kwargs(kwargs, info)
        projects = kwargs['projects']
        del kwargs['projects']
        report = Report()
        report.user_added = info.context.user

        # Если отчет добавляет ГИП, тогда отчет автоматически становится проверенным.
        if Project.objects.get(id=projects[0]).gip == info.context.user:
            report.checked_by = info.context.user
            report.time_checked = timezone.now()

        # Добавляем к полям модели полученные значения.
        # "keys" - это глобальный список внешних ключей (имен полей).
        [
            setattr(report, f + '_id' if f in keys else f, kwargs.get(f))
            for f in kwargs.keys()
        ]
        report.save()
        projects_states = Project.objects.filter(id__in=projects).values(
            'id', 'state_id')
        for ps in projects_states:
            ProjectState.objects.create(project_id=ps['id'],
                                        state_id=ps['state_id'],
                                        report_id=report.id)
        return CreateReport(report=report)
コード例 #24
0
ファイル: tests.py プロジェクト: TechnoServe/SMSBookkeeping
    def test_wetmill(self):
        self.season = self.rwanda_2010
        self.report = Report.get_for_wetmill_season(self.nasho, self.season,
                                                    self.viewer)
        self.scorecard = Scorecard.get_for_wetmill_season(
            self.nasho, self.season, self.viewer)

        # login with view report permission user
        self.login(self.viewer)
        response = self.client.get(
            reverse('public-wetmill', args=[self.nasho.id]))

        # nasho should be in the response
        self.assertContains(response, "Nasho")

        # check if the finalized report is inside the finalized list of report within the context
        # shouldn't be.
        self.assertFalse(self.report in response.context['finalized_reports'])
        self.assertFalse(
            self.report in response.context['finalized_scorecards'])

        # finalize on of this wetmills reports
        self.report.is_finalized = True
        self.report.save()

        # finalize the scorecard for this wetmill
        self.scorecard.is_finalized = True
        self.scorecard.save()

        response = self.client.get(
            reverse('public-wetmill', args=[self.nasho.id]))

        # nasho should be in the response
        self.assertContains(response, "Nasho")

        # check if the finalized report is inside the finalized list of report within the context
        self.assertTrue(self.report in response.context['finalized_reports'])
        self.assertTrue(
            self.scorecard in response.context['finalized_scorecards'])

        self.assertIsNone(response.context['last_scorecard'])
        self.assertIsNone(response.context['last_report'])

        # finalize the season
        self.season.is_finalized = True
        self.season.save()

        # get the page again
        response = self.client.get(
            reverse('public-wetmill', args=[self.nasho.id]))

        self.assertTrue(self.report in response.context['finalized_reports'])
        self.assertTrue(
            self.scorecard in response.context['finalized_scorecards'])

        self.assertEquals(self.scorecard, response.context['last_scorecard'])
        self.assertEquals(self.report, response.context['last_report'])
コード例 #25
0
    def test_report_detail_view_loads_correct_template(self, mock_get):
        draft = self.draft_barrier(1)
        mock_get.return_value = Report(draft)
        url = reverse('reports:draft_barrier_details_uuid', kwargs={"barrier_id": draft["id"]})

        response = self.client.get(url)

        assert HTTPStatus.OK == response.status_code
        self.assertTemplateUsed(response, "reports/report_detail.html")
コード例 #26
0
ファイル: handlers.py プロジェクト: Astrabella/WalkGoodJA
    def help(self):
        # Create a new report in the DB
        self.report = Report(identity=self.msg.connection.identity, state=1)
        self.report.save()
        logger.debug("New report created")

        # Send initial response to user
        self.respond("Hello. Please text a number for the incident you are reporting..." +
                      "1-Verbal Abuse,  2-Physical Abuse,  3-Sexual Assault,  4-Robbery,  5-Rape")
コード例 #27
0
    def test_delete_report_view_loads_correct_template(self, mock_delete, mock_get, _mock_list):
        mock_get.return_value = Report(self.draft)
        redirect_url = reverse("reports:draft_barriers")

        response = self.client.post(self.url, {})

        self.assertRedirects(response, redirect_url)
        assert mock_get.called is True
        assert mock_delete.called is True
コード例 #28
0
ファイル: tests.py プロジェクト: anukat2015/Sylva
class ReportTest(TestCase):

    fixtures = ["schemas.json", "graphs.json", "queries.json", "reports.json"]

    def setUp(self):
        self.graph = Graph.objects.get(pk=1)
        self.template = ReportTemplate(name="test",
                                       start_date=datetime.now(),
                                       frequency="h",
                                       last_run=datetime.now(),
                                       layout={"hello": "world"},
                                       description="Some",
                                       graph=self.graph)
        self.template.save()
        self.template_id = self.template.id
        self.datetime = datetime.now()
        self.report = Report(date_run=self.datetime,
                             table={"hello": "again"},
                             template=self.template)
        self.report.save()

    def test_report_creation(self):
        self.assertIsNotNone(self.report)
        self.assertEqual(self.report.date_run, self.datetime)

    def test_report_delete(self):
        report = Report(date_run=datetime.now(),
                        table={"hello": "again"},
                        template=self.template)
        report.save()
        rid = report.id
        try:
            r = Report.objects.get(pk=rid)
            exists = True
        except ReportTemplate.DoesNotExist:
            exists = False
        self.assertTrue(exists)
        r.delete()
        try:
            Report.objects.get(pk=rid)
            exists = True
        except Report.DoesNotExist:
            exists = False
        self.assertFalse(exists)
コード例 #29
0
ファイル: base.py プロジェクト: TechnoServe/SMSBookkeeping
 def setUp(self):
     super(PDFTestCase, self).setUp()
     self.report = Report.get_for_wetmill_season(self.nasho,
                                                 self.rwanda_2010,
                                                 self.admin)
     self.report.farmers = 100
     self.report.capacity = Decimal("10000")
     self.report.save()
     self.season = self.rwanda_2010
     self.nasho.set_csp_for_season(self.season, self.rtc)
コード例 #30
0
    def test_button_save_and_exit_redirects_to_correct_view(
            self, mock_create, mock_get):
        """
        Clicking on `Save and exit` button should create a draft barrier
        and redirect the user to the draft barrier details view
        """
        field_name = 'trade_direction'
        export = "1"
        draft_barrier = self.draft_barrier(2)
        mock_create.return_value = Report(draft_barrier)
        mock_get.return_value = Report(draft_barrier)
        redirect_url = reverse('reports:draft_barrier_details_uuid',
                               kwargs={"barrier_id": draft_barrier["id"]})

        payload = {field_name: export, "action": "exit"}
        response = self.client.post(self.url, data=payload)

        self.assertRedirects(response, redirect_url)
        assert mock_create.called is True
コード例 #31
0
ファイル: tests.py プロジェクト: anukat2015/Sylva
 def test_report_delete(self):
     report = Report(date_run=datetime.now(),
                     table={"hello": "again"},
                     template=self.template)
     report.save()
     rid = report.id
     try:
         r = Report.objects.get(pk=rid)
         exists = True
     except ReportTemplate.DoesNotExist:
         exists = False
     self.assertTrue(exists)
     r.delete()
     try:
         Report.objects.get(pk=rid)
         exists = True
     except Report.DoesNotExist:
         exists = False
     self.assertFalse(exists)
コード例 #32
0
ファイル: tests.py プロジェクト: CulturePlex/Sylva
class ReportTest(TestCase):

    fixtures = ["schemas.json", "graphs.json", "queries.json", "reports.json"]

    def setUp(self):
        self.graph = Graph.objects.get(pk=1)
        self.template = ReportTemplate(
            name="test",
            start_date=datetime.now(),
            frequency="h",
            last_run=datetime.now(),
            layout={"hello": "world"},
            description="Some",
            graph=self.graph,
        )
        self.template.save()
        self.template_id = self.template.id
        self.datetime = datetime.now()
        self.report = Report(date_run=self.datetime, table={"hello": "again"}, template=self.template)
        self.report.save()

    def test_report_creation(self):
        self.assertIsNotNone(self.report)
        self.assertEqual(self.report.date_run, self.datetime)

    def test_report_delete(self):
        report = Report(date_run=datetime.now(), table={"hello": "again"}, template=self.template)
        report.save()
        rid = report.id
        try:
            r = Report.objects.get(pk=rid)
            exists = True
        except ReportTemplate.DoesNotExist:
            exists = False
        self.assertTrue(exists)
        r.delete()
        try:
            Report.objects.get(pk=rid)
            exists = True
        except Report.DoesNotExist:
            exists = False
        self.assertFalse(exists)
コード例 #33
0
 def handle(self, *args, **options):
     report = Report(
         title='Test runner from CLI',
         description='Test runner from CLI',
         runner=options['runner'],
         frequency='on_demand')
     if 'attributes' in options:
         report.attributes = options['attributes']
     report.save()
     run = report.run()
     self.stdout.write(run.result)
     run.delete()
     report.delete()
コード例 #34
0
    def test_saving_location_redirects_to_correct_view(self, mock_create):
        draft_barrier = self.draft_barrier(2)
        mock_create.return_value = Report(draft_barrier)
        field_name = "location"
        fiji_uuid = "d9f682ac-5d95-e211-a939-e4115bead28a"
        redirect_url = reverse("reports:barrier_trade_direction")

        response = self.client.post(self.url, data={field_name: fiji_uuid})

        self.assertRedirects(response, redirect_url)
        assert mock_create.called is False
コード例 #35
0
    def test_trading_bloc_location_saved_in_session(self, mock_create):
        draft_barrier = self.draft_barrier(2)
        mock_create.return_value = Report(draft_barrier)
        session_key = "draft_barrier__location_form_data"
        expected_form_data = {"country": None, "trading_bloc": "TB00016"}

        response = self.client.post(self.url, data={"location": "TB00016"}, follow=True)
        saved_form_data = self.client.session.get(session_key)

        assert HTTPStatus.OK == response.status_code
        assert expected_form_data == saved_form_data
        assert mock_create.called is False
コード例 #36
0
    def test_button_continue_redirects_to_correct_view(self, mock_create):
        """
        Clicking on `Continue` button should proceed to trade directions without saving the barrier
        """
        draft_barrier = self.draft_barrier(2)
        mock_create.return_value = Report(draft_barrier)
        redirect_url = reverse("reports:barrier_trade_direction")

        response = self.client.post(self.url, data={})

        self.assertRedirects(response, redirect_url)
        assert mock_create.called is False
コード例 #37
0
    def test_saving_location_with_trading_bloc_redirects_to_correct_view(
            self, mock_create):
        draft_barrier = self.draft_barrier(2)
        mock_create.return_value = Report(draft_barrier)
        field_name = "location"
        france_uuid = "82756b9a-5d95-e211-a939-e4115bead28a"
        redirect_url = reverse("reports:barrier_caused_by_trading_bloc")

        response = self.client.post(self.url, data={field_name: france_uuid})

        self.assertRedirects(response, redirect_url)
        assert mock_create.called is False
コード例 #38
0
 def get_queryset(self, *args, **kwargs):
     """
     Only admins of the board can see the reports.
     """
     current_user = self.request.user
     boards_slug = self.request.GET.get('boards_slug', '')
     board = Board.objects.get(slug=boards_slug)
     if board:
         if current_user in board.admins.all():
             queryset_list = Report.get_reports(boards_slug)
             return queryset_list
     return []
コード例 #39
0
    def test_save_and_continue_redirects_to_correct_view(
            self, mock_update, mock_get, mock_submit):
        """
        Clicking on `Save and continue` button should update the draft barrier
        and redirect the user to the draft barrier details view
        """
        mock_update.return_value = Report(self.draft)
        mock_get.return_value = Report(self.draft)
        redirect_url = reverse("barriers:barrier_detail",
                               kwargs={"barrier_id": self.draft["id"]})
        data = {
            "summary": "wibble wobble",
            "is_summary_sensitive": "no",
            "next_steps_summary": "step 1 - wobble, step 2 - wibble",
        }

        response = self.client.post(self.url, data)

        self.assertRedirects(response, redirect_url)
        assert mock_update.called is True
        assert mock_submit.called is True
コード例 #40
0
ファイル: tests.py プロジェクト: kundeng/Sylva
 def setUp(self):
     self.graph = Graph.objects.get(pk=1)
     self.template = ReportTemplate(name="test", start_date=datetime.now(),
                                    frequency="h", last_run=datetime.now(),
                                    layout={"hello": "world"},
                                    description="Some", graph=self.graph)
     self.template.save()
     self.template_id = self.template.id
     self.datetime = datetime.now()
     self.report = Report(date_run=self.datetime, table={"hello": "again"},
                          template=self.template)
     self.report.save()
コード例 #41
0
    def test_save_and_continue_redirects_to_correct_view(self, mock_update):
        """
        Clicking on `Save and continue` should take the user to the .../problem/ page
        """
        mock_update.return_value = Report(self.draft)
        redirect_url = reverse('reports:barrier_about_uuid',
                               kwargs={"barrier_id": self.draft["id"]})

        response = self.client.post(self.url, data={})

        self.assertRedirects(response, redirect_url)
        assert mock_update.called is True
コード例 #42
0
ファイル: views.py プロジェクト: summerisgone/umc-kurator
    def form_valid(self, form):
        report_query = self.get_report_query(form)
        report_dict = self.get_report_dict(form)

        reports = Report.objects.filter(**report_query)

        if reports.filter(status=ReportStatus.Ready).exists():
            report = reports.filter(status=ReportStatus.Ready)[0]
            messages.add_message(self.request, messages.INFO, u'Отчёт уже построен')
            return HttpResponseRedirect(report.get_absolute_url())
        elif reports.filter(status=ReportStatus.Pending).exists():
            return self.render_to_response({
                'form': form,
                'pending': reports[0]
            })
        else:
            report = Report(**report_dict)
            report.save()
            try:
                report.process() #.delay(report)
            except ConnectionError:
                return self.render_to_response({
                    'form': form,
                    'error': u'Нет соединения с очередью задач'
                })
            return HttpResponseRedirect(report.get_absolute_url())
コード例 #43
0
ファイル: logic.py プロジェクト: freedomd/WhiteBayReporting
def newReport(account, symbol, today):
    
    try:
        mainAccount = account[:5]
        new_report = Report.objects.get(Q(account=mainAccount) & Q(symbol=symbol) & Q(reportDate=today))
            
    except Report.DoesNotExist: # today's new does not exist  
        new_report = Report()
        new_report.account = mainAccount
        new_report.symbol = symbol      
        new_report.reportDate = today
        new_report.save()
        #new_report = Report.objects.create(symbol=symbol, reportDate=today)
        
    return new_report
コード例 #44
0
def submit(request):

    if not request.GET.has_key("imei"):
        return HttpResponse("Expected additional parameters")

    imei = request.GET["imei"]
    nmea_str = request.GET["rmc"]
    nmea_list = nmea_str.split(",")

    # Sanav sentence is of type GPRMC with a couple extra attributes for voltage and report type
    # imei - first parameter before sentence, provides a unique id for the device
    # NMEA type - $GPRMC
    # UTC time - 095838.000 hhmmss.sss
    # Status - A
    # Lat - 2458.9733 ddmm.mmmm Degree Decimal Minute
    # Lat dir - N
    # Lon - 12125.6583 ddmm.mmmm Degree Decimal Minute
    # Lon dir - E
    # Speed knots - 0.41
    # Course - 79.21
    # UTC Date - 220905 ddmmyy
    # Mag. deviation - blank
    # Checksum - *30
    # Voltage - 3777mv
    # Report type - POLL

    rep_time = nmea_list[1]
    rep_lat = nmea_list[3]
    rep_lat_dir = nmea_list[4]
    rep_lon = nmea_list[5]
    rep_lon_dir = nmea_list[6]
    rep_date = nmea_list[9]

    r = Report()
    r.imei = imei
    r.nmea_type = nmea_list[0][1:]
    r.status = nmea_list[2]
    r.speed = nmea_list[7]
    r.course = nmea_list[8]
    r.voltage = nmea_list[12][0:-2]
    r.rep_type = nmea_list[13]
    r.nmea_sentence = nmea_str

    # parse and build location
    lon_dd = float(rep_lon[:-7]) + float(rep_lon[-7:]) / 60.0
    if rep_lon_dir == "W":
        lon_dd *= -1
    lat_dd = float(rep_lat[:-7]) + float(rep_lat[-7:]) / 60.0
    if rep_lat_dir == "S":
        lat_dd *= -1
    r.loc = Point(lon_dd, lat_dd)

    # parse and build timestamp
    year = int(rep_date[4:6])
    month = int(rep_date[2:4])
    day = int(rep_date[0:2])
    hour = int(rep_time[0:2])
    minute = int(rep_time[2:4])
    sec = int(rep_time[4:6])
    ms = int(rep_time[7:])
    r.timestamp = datetime.datetime(year, month, day, hour, minute, sec, ms)

    r.save()

    return HttpResponse("Report logged")
コード例 #45
0
ファイル: tasks.py プロジェクト: imclab/fda-aers
 def process_element(elem):
     report = Report()
     print elem.xpath('safetyreportid/text()')[0]
     try:
         report.safetyreportid = elem.xpath('safetyreportid/text()')[0]
     except:
         pass
     try:
         report.safetyreportversion = int_validator(elem.xpath('safetyreportversion/text()')[0])
     except:
         pass
     report.importedfilename = filename
     try:
         report.primarysourcecountry = str(elem.xpath('primarysourcecountry/text()')[0])
     except:
         pass
     try:
         report.occurcountry = str(elem.xpath('occurcountry/text()')[0])
     except:
         pass
     try:
         report.transmissiondateformat = str(elem.xpath('transmissiondateformat/text()')[0])
         report.transmissiondate = datetime_validator(str(elem.xpath('transmissiondateformat/text()')[0]), str(elem.xpath('transmissiondate/text()')[0]))
     except:
         pass
     try:
         report.reporttype = int_validator(elem.xpath('reporttype/text()')[0])
     except:
         pass
     try:
         report.serious = boolean_validator(str(elem.xpath('serious/text()')[0]))
     except:
         pass
     try:
         report.seriousnessdeath = boolean_validator(str(elem.xpath('seriousnessdeath/text()')[0]))
     except:
         pass
     try:
         report.seriousnesslifethreatening = boolean_validator(str(elem.xpath('seriousnesslifethreatening/text()')[0]))
     except:
         pass
     try:
         report.seriousnesshospitalization = boolean_validator(str(elem.xpath('seriousnesshospitalization/text()')[0]))
     except:
         pass
     try:
         report.seriousnessdisabling = boolean_validator(str(elem.xpath('seriousnessdisabling/text()')[0]))
     except:
         pass
     try:
         report.seriousnesscongenitalanomali = boolean_validator(str(elem.xpath('seriousnesscongenitalanomali/text()')[0]))
     except:
         pass
     try:
         report.seriousnessother = boolean_validator(str(elem.xpath('seriousnessother/text()')[0]))
     except:
         pass
     try:
         report.receivedateformat = str(elem.xpath('receivedateformat/text()')[0])
         report.receivedate = datetime_validator(str(elem.xpath('receivedateformat/text()')[0]), str(elem.xpath('receivedate/text()')[0]))
     except:
         pass
     try:
         report.recieptdateformat = str(elem.xpath('receiptdateformat/text()')[0])
         report.recieptdate = datetime_validator(str(elem.xpath('receiptdateformat/text()')[0]), str(elem.xpath('receiptdate/text()')[0]))
     except:
         pass
     try:
         report.fullfillexpeditecriteria = boolean_validator(str(elem.xpath('fulfillexpeditecriteria/text()')[0]))
     except:
         pass
     try:
         report.companynumb = str(elem.xpath('companynumb/text()')[0])
     except:
         pass
     try:
         report.reportercountry = str(elem.xpath('primarysource/reportercountry/text()')[0])
     except:
         pass
     try:
         report.duplicate = null_boolean_validator(str(elem.xpath('duplicate/text()')[0]))
     except:
         pass
     try:
         report.qualification = int_validator(elem.xpath('primarysource/qualification/text()')[0])
     except:
         pass
     try:
         report.sendertype = int_validator(elem.xpath('sender/sendertype/text()')[0])
     except:
         pass
     try:
         report.senderorganization = str(elem.xpath('sender/senderorganization/text()')[0])
     except:
         pass
     try:
         report.receivertype = int_validator(elem.xpath('receiver/receivertype/text()')[0])
     except:
         pass
     try:
         report.receiverorganization = str(elem.xpath('receiver/receiverorganization/text()')[0])
     except:
         pass
     try:
         report.patientonsetage = float(elem.xpath('patient/patientonsetage/text()')[0])
     except:
         pass
     try:
         report.patientonsetageunit = int_validator(elem.xpath('patient/patientonsetageunit/text()')[0])
     except:
         pass
     try:
         report.patientweight = float(elem.xpath('patient/patientweight/text()')[0])
     except:
         pass
     try:
         report.patientsex = int_validator(elem.xpath('patient/patientsex/text()')[0])
     except:
         pass
     report.save()
     
     
     reportduplicates = elem.xpath('reportduplicate')        
     # We delete any existing reportduplicates
     ReportDuplicate.objects.get(report=safetyreportid).delete()
     
     for item in reportduplicates:
         duplicate = ReportDuplicate()
         duplicate.report = Report.objects.get(safetyreportid=report.safetyreportid)
         try:
             duplicate.duplicatesource = str(item.xpath('duplicatesource/text()')[0])
         except:
             pass
         try:
             duplicate.duplicatenumb = str(item.xpath('duplicatenumb/text()')[0])
         except:
             pass
         duplicate.save()
                 
     reactions = elem.xpath('patient/reaction')
     # We delete any existing reactions
     Reaction.objects.get(report=safetyreportid).delete()
     
     for item in reactions:
         reaction = Reaction()
         reaction.report = Report.objects.get(safetyreportid=report.safetyreportid)
         try:
             reaction.reactionmeddrapt = str(item.xpath('reactionmeddrapt/text()')[0])
         except:
             pass
         try:
             reaction.reactionmeddraversionpt = str(item.xpath('reactionmeddraversionpt/text()')[0])
         except:
             pass
         try:
             reaction.reactionoutcome = int_validator(item.xpath('reactionoutcome/text()')[0])
         except:
             pass
         reaction.save()
       
     drugs = elem.xpath('patient/drug')
     # We delete any existing drugs
     Drug.objects.get(report=safetyreportid).delete()
     
     for item in drugs:
         drug = Drug()  
         drug.report = Report.objects.get(safetyreportid=report.safetyreportid)
         try:
             drug.drugcharacterization = int_validator(item.xpath('drugcharacterization/text()')[0])
         except:
             pass
         try:
             drug.medicinalproduct = str(item.xpath('medicinalproduct/text()')[0])
         except:
             pass
         try:
             drug.drugbatchnumb = str(item.xpath('drugbatchnumb/text()')[0])
         except:
             pass
         try:
             drug.drugauthorizationnumb = str(item.xpath('drugauthorizationnumb/text()')[0])
         except:
             pass
         try:
             drug.drugstructuredosagenumb = str(item.xpath('drugstructuredosagenumb/text()')[0])
         except:
             pass
         try:
             drug.drugstructureddosageunit = int_validator(item.xpath('drugstructureddosageunit/text()')[0])
         except:
             pass
         try:
             drug.drugseparatedosagenumb = float(item.xpath('drugseparatedosagenumb/text()')[0])
         except:
             pass
         try:
             drug.drugintervaldosageunitnumb = float(item.xpath('drugintervaldosageunitnumb/text()')[0])
         except:
             pass
         try:
             drug.drugintervaldosagedefinition = int_validator(item.xpath('drugintervaldosagedefinition/text()')[0])
         except:
             pass
         try:
             drug.drugcumulativedosagenumb = float(item.xpath('drugcumulativedosagenumb/text()')[0])
         except:
             pass
         try:
             drug.drugcumulativedosageunit = int_validator(item.xpath('drugcumulativedosageunit/text()')[0])
         except:
             pass
         try:
             drug.drugdosagetext = str(item.xpath('drugdosagetext/text()')[0])
         except:
             pass
         try:
             drug.drugdosageform = str(item.xpath('drugdosageform/text()')[0])
         except:
             pass
         try:
             drug.drugadministrationroute = int_validator(item.xpath('drugadministrationroute/text()')[0])
         except:
             pass
         try:
             drug.drugindication = str(item.xpath('drugindication/text()')[0])
         except:
             pass
         try:
             drug.drugstartdateformat = str(item.xpath('drugstartdateformat/text()')[0])
             drug.drugstartdate = datetime_validator(str(item.xpath('drugstartdateformat/text()')[0]), str(item.xpath('drugstartdate/text()')[0]))
         except:
             pass
         try:
             drug.drugenddateformat = str(item.xpath('drugenddateformat/text()')[0])
             drug.drugenddate = datetime_validator(str(item.xpath('drugenddateformat/text()')[0]), str(item.xpath('drugenddate/text()')[0]))
         except:
             pass
         try:
             drug.drugtreatmentduration = float(item.xpath('drugtreatmentduration/text()')[0])
         except:
             pass
         try:
             drug.drugtreatmentdurationunit = int_validator(item.xpath('drugtreatmentdurationunit/text()')[0])
         except:
             pass
         try:
             drug.actiondrug = int_validator(item.xpath('actiondrug/text()')[0])
         except:
             pass
         try:
             drug.drugrecurreadministration = null_boolean_validator(str(item.xpath('drugrecurreadministration/text()')[0]))
         except:
             pass
         try:
             drug.drugadditional = null_boolean_validator(str(item.xpath('drugadditional/text()')[0]))
         except:
             pass
         drug.save()
コード例 #46
0
ファイル: views.py プロジェクト: Mozta/tata_heroku
def send(request):

    # Obtenemos los campos comunes entre reportes
    report_type = request.POST.get("form_type", "")
    doc_name = request.POST.get("nombre_dr", "")
    patient_name = request.POST.get("nombre_pac", "")
    consult_date = request.POST.get("fecha", "")
    observ = request.POST.get("observaciones", "")

    # Variables comunes
    url = "https://android.googleapis.com/gcm/send"
    headers = {"Content-Type": "application/json", "Authorization": "key=AIzaSyCH7B7qMMbLnQdj6WG1yuvPp3SlsLHtBds"}

    # Creamos un objeto del tipo reporte del que heredará la info el reporte específico
    rep = Report(
        doc_name=doc_name, patient_name=patient_name, consult_date=consult_date, report_type=report_type, observ=observ
    )
    rep.save()

    if report_type == "psicologico":

        # Obtenemos campos únicos de reporte psicologico
        patient_state = request.POST.get("estado_pac", "")
        suggest = request.POST.get("sugerencias", "")

        psy = PsyReport(report=rep, patient_state=patient_state, suggest=suggest)
        psy.save()

        print >>sys.stderr, psy.report
        # Payload del reporte psicologico
        payload = {
            "data": {
                "id": psy.report.id,
                "tipo": report_type,
                "fecha": consult_date,
                "doctor": doc_name,
                "paciente": patient_name,
                "observaciones": observ,
                "sugerencias": suggest,
            },
            "registration_ids": [
                "APA91bHDXfzISMoo6OfqhhODnU7TeNzqCxeE7lYZHhdI801wazh1e7vbITZVTqwKU5avNW0myInlZW3Aat3S8gzqawN9G5fQEkMVNvqkDHRRYt1IDsFrPuc"
            ],
        }
    elif report_type == "nutricional":

        # Obtenemos campos únicos de reporte nutricional
        weight = request.POST.get("peso", "")
        height = request.POST.get("talla", "")
        pressure = request.POST.get("presion", "")
        risk_factors = request.POST.get("fac_riesgo", "")
        appetite = request.POST.get("est_apetito", "")
        diet = request.POST.get("dieta", "")

        nut = NutReport(
            report=rep,
            weight=weight,
            height=height,
            pressure=pressure,
            risk_factors=risk_factors,
            appetite=appetite,
            diet=diet,
        )
        nut.save()

        # Payload del reporte psicologico
        payload = {
            "data": {
                "id": nut.report.id,
                "tipo": report_type,
                "fecha": consult_date,
                "doctor": doc_name,
                "paciente": patient_name,
                "observaciones": observ,
                "peso": weight,
                "talla": height,
                "presion": pressure,
                "fac_riesgo": risk_factors,
                "est_apetito": appetite,
                "dieta": diet,
            },
            "registration_ids": [
                "APA91bHDXfzISMoo6OfqhhODnU7TeNzqCxeE7lYZHhdI801wazh1e7vbITZVTqwKU5avNW0myInlZW3Aat3S8gzqawN9G5fQEkMVNvqkDHRRYt1IDsFrPuc"
            ],
        }
        # El envío de la notificación es común para los reportes
    try:
        # r = requests.post(url, data=json.dumps(payload))
        r = requests.post(url, headers=headers, data=json.dumps(payload))
    except requests.exceptions.ConnectionError:
        if report_type == "psicologico":
            return render(
                request,
                "reports/psychological.html",
                {"error_message": "No hay conexión a internet, intente más tarde"},
            )
        elif report_type == "nutricional":
            return render(
                request, "reports/nutritional.html", {"error_message": "No hay conexión a internet, intente más tarde"}
            )
    else:
        print >>sys.stderr, "POST request response: ", r.status_code
        if r.status_code == 200:
            code = 0
        else:
            code = 1

        return HttpResponseRedirect(reverse("reports:results", args=(rep.id, code)))

        pass