Python models.Record类代码示例

def new_record(id):
    user = User.query.get_or_404(id)
    record = Record(user=user)
    record.import_data(request.json)
    db.session.add(record)
    db.session.commit()
    return jsonify({}), 201, {'Location': record.get_url()}

    def save(self,record=None):
        if record:
            links = []
            if self.validated_data['gwc']:
                links.append(
                    json.loads(Record.generate_ows_link(self.validated_data['gwc_endpoint'],'WMS',None,record))
                )
            if self.validated_data['wms']:
                links.append(
                    json.loads(Record.generate_ows_link(self.validated_data['wms_endpoint'],'WMS',self.validated_data['wms_version'],record))
                )
            if self.validated_data['wfs']:
                links.append(
                    json.loads(Record.generate_ows_link(self.validated_data['wfs_endpoint'],'WFS',self.validated_data['wfs_version'],record))
                )
                
            if record.service_type == "WMS":
                record.service_type_version = self.validated_data['wms_version']
            elif record.service_type == "WFS":
                record.service_type_version = self.validated_data['wfs_version']
            else:
                record.service_type_version = ""

            style_resources = record.style_resources
            resources = links + style_resources

            Record.update_links(resources,record)

def gong(request):
    user = "@%s" % request.POST.get("user_name", "somebody")
    reason = request.POST.get("text", "Gonged stuff!")

    slack_message('slack/gonged.slack', {
        'user': user,
        'reason': reason
    })

    attachments = [
        {
            'author_name': user,
            'title': reason,
            'image_url': 'https://curriculum.code.org/images/gong.gif',
            'color': '#00adbc'
        }
    ]
    payload = {
        "response_type": "in_channel",
        "attachments": attachments,
    }

    record = Record(user=user, reason=reason)
    record.save()

    return Response(payload, content_type='application/json')

def rest(request):
	admins_email = ['[email protected]']
	content_to_sender = u"Dear %s,\n\nWe have received your application.Please do NOT reply this email directly.\n\nThanks,\nTech Team"
	content_to_admin = u"Received an application from %s %s at %s"
	receive_time_str = strftime("%H:%M:%S %Y-%m-%d", localtime())
	if request.META.has_key('CONTENT_TYPE'):
		info = request.META['CONTENT_TYPE'] 
		if info == 'application/json' and request.method == 'POST':
			data = json.loads(request.body) 
			form = RecordForm(data)

			if form.is_valid():
				r = Record(email = form.cleaned_data['email'],
							first_name = form.cleaned_data['first_name'],
							last_name = form.cleaned_data['last_name'],
							contact_number = form.cleaned_data['contact_number'],
							title = form.cleaned_data['title'],
							content = form.cleaned_data['content'],
							link = form.cleaned_data['link'])
				r.save()

				send_mail(u'Thanks for your application',
							content_to_sender % data['last_name'],
							'[email protected]',
							[data['email']])
				send_mail(u'Application Received from %s' % data['email'],
							content_to_admin % (data['last_name'],data['first_name'],receive_time_str),
							'[email protected]',
							admins_email)
				return HttpResponse('save successful')
		return HttpResponse('data invalid')	
	else:
		return HttpResponse('Please verify Header info')

def add_record(release):
    from models import Record, Artist, Track
    release_discogs_id = release.id
    try:
        # Check if we already have this album
        existing = Record.objects.get(discogs_id=release_discogs_id)
        return existing
    except Record.DoesNotExist:
        # Process record
        record_title = release.title
        if (len(record_title.split('- '))>1):
            record_title = record_title.split('- ')[1]
        record = Record(discogs_id = release_discogs_id, title = record_title, year = release.year, thumb = release.thumb, notes = release.notes)
        record.save()

        # Process artists
        for release_artist in release.artists:
            artist = Artist(discogs_id=release_artist.id, name=release_artist.name)
            artist.save()
            record.artists.add(artist)

        # Process tracklist
        for release_track in release.tracklist:
            track = Track()
            track.position = release_track.position
            track.title = release_track.title
            track.duration = release_track.duration
            track.save()
            record.tracklist.add(track)

        record.save()
        return record

    def save(self, record=None):
        if record:
            links = []
            if self.validated_data['gwc']:
                gwc_endpoints = [endpoint.strip() for endpoint in self.validated_data['gwc_endpoint'].split("^") if endpoint.strip()]
                for endpoint in gwc_endpoints:
                    links.append(
                        record.generate_ows_link(endpoint, 'GWC', self.validated_data['wms_version'])
                    )
            elif self.validated_data['wms']:
                links.append(
                    record.generate_ows_link(self.validated_data['wms_endpoint'], 'WMS', self.validated_data['wms_version'])
                )
            if self.validated_data['wfs']:
                links.append(
                    record.generate_ows_link(self.validated_data['wfs_endpoint'], 'WFS', self.validated_data['wfs_version'])
                )
            if record.service_type == "WMS":
                record.service_type_version = self.validated_data['wms_version']
            elif record.service_type == "WFS":
                record.service_type_version = self.validated_data['wfs_version']
            else:
                record.service_type_version = ""

            style_links = record.style_links
            resources = links + style_links

            Record.update_links(resources, record)

def delete(instance, obj_id):
    obj = Record().give_child(instance)
    obj = obj.get_by_id_or_new(obj_id)
    obj.delete()
    if not request.is_xhr:
        return redirect('index/'+repr(obj))
    else:
        return "it ok"

 def get_user_rankings(self, request):
     """Get user rankings"""
     if isinstance(request.number_of_results, int):
         _number_of_results = request.number_of_results
         records = Record.query().order(Record.wins).fetch(limit=_number_of_results)
         return RecordForms(items=[record.to_form() for record in records])
     else:
         records = Record.query().order(Record.wins)
         return RecordForms(items=[record.to_form() for record in records])

def record_user(request,user):
	user = User.objects.get(id=user)
	summary = Record.summary_by_user(user)
	records = Record.list_by_user(user)

	context = {'records':records,
		'summary':summary,}
	
	return render_to_response('user.html', context,context_instance=RequestContext(request))

    def testExpressionParsing(self):
        from models import Record
        r = Record()
        x = 5
        y = -2
        z = 3.5
        r.setColumnValue("x", x)
        r.setColumnValue("y", y)
        r.setColumnValue("z", z)
        volley = [
            ["1 + 1", (1 + 1) ],
            ["1 + 1 + 5", (1 + 1 + 5) ],
            ["2 * 8 + 3", (2*8) + 3 ],
            ["4 + 5 * 2", 4 + (5*2)],
            ["2^3", (pow(2,3)) ],
            ["(8/2)*3 + 9", ((8/2)*3 + 9) ],
            ["[x]^2", (pow(x,2))],
            ["SQRT([x]^2 + [y]^2)", ( math.sqrt(pow(x,2)+pow(y,2)) )],
            ["5 > 2", True],
            ["5 > 6", False],
            ["(3*5) < 20", True],
            ["[x] > 100", False],
            ["(3*5) < 20 AND [x] > 100", False],
            ["(3*5) < 20 AND [x] > 0 AND [x] > 1", True],
            ["1==1 OR 1==3 AND 2==0", True],
            ["(1==1 OR 1==3) AND 2==2", True],
            ["(1==2 AND 1==3) OR 2==2", True],
            ["(1==1 OR 1==1) AND 1==0", False],
            ["1==1 OR 1==1 AND 1==0", True], # And first
            ["1==1 OR (1==1 AND 1==0)", True],
            ["1 == 2 OR [x] > 100 OR [x] > 1", True],
            ["1==2 OR 1==1 OR 1==4 OR 1==5", True],
            ["SQRT([x]^2 + [y]^2)", ( math.sqrt(pow(x,2)+pow(y,2)) )],
            ["SQRT([x]^2 + [y]^2 + 8^2)", ( math.sqrt(pow(x,2)+pow(y,2)+pow(8,2))) ],
            ["SQRT([x]^2 + [y]^2 + [z]^2)", ( math.sqrt(pow(x,2)+pow(y,2)+pow(z,2))) ]
        ]

        for v in volley:
            expr = v[0]
            target = v[1]
            tick = datetime.now()
            ep = ExpressionParser(expr, verbose=True)
            result = ep.run(r)
            tock = datetime.now()
            diff = tock - tick
            ms = diff.microseconds/1000
            logmessage = "%s took %d ms" % (expr, ms)
            if ms > 100:
                logmessage += " <<<<<<<<<<<<<<<<<<<<<<<<<<< SLOW OP!"
            print logmessage
            self.assertEqual(result, target)

def instantiate_and_form(request, instance, obj_id=None):
    """
    Abstracts common operations from actions add/<instance>, edit/<instance>.
    Instantiates blank model object obj by it's string name (i. e.
    instance=book will produce obj=Book()). Instantiates corresponding
    WTForm model_form object form. If obj_id provided, tries to populate
    obj with database data.
    Populates form with request.from data (if any). Than tries to modify
    obj with data in form. Returns ready to use obj, form to caller.
    """
    obj = Record().give_child(instance)
    form = obj.give_form()
    obj = obj.get_by_id_or_new(obj_id)
    form = form(request.form, obj=obj)
    obj.populate_with(form)
    return obj, form

    def get(self):
        """Handles GET."""

        height = self.request.GET.get('height', 600)
        width = self.request.GET.get('width', 1000)
        num = int(self.request.GET.get('num', 100))
        if num > 1000:
            num = 1000

        records = Record.all().order('-num_iter').order('-date').fetch(num)

        values = [r.estimated_pi for r in records]

        num_rows = len(values)

        rows = []

        for i in range(num_rows):
            rows.append("%i, 0, %i" % (i, i+1))
            rows.append("%i, 1, %f" % (i, values[i]))

        if values:
            pi = sum(values)/num_rows
        else:
            pi = 'unknown'

        self.response.out.write(template.render('chart.html', locals()))

def render_review_page():
  """
  Render the review page.
  """
  title = 'Review'
  pending = Record.get_all_pending_records()
  return render_template('review.html', page_title=title, pending=pending)

def update(POST):
    player_one = Player.objects.get(pk=int(POST['player_one']))
    player_one_score = int(POST['player_one_score'])
    player_two = Player.objects.get(pk=int(POST['player_two']))
    player_two_score = int(POST['player_two_score'])

    record = Record(date=datetime.datetime.now(), player_one_id=player_one.id, player_one_score=player_one_score, player_two_id=player_two.id, player_two_score=player_two_score)
    record.save()

    if player_one.ELO > player_two.ELO:
        expected_one = get_Expected(player_one.ELO, player_two.ELO)
    else:
        expected_one = 1 - get_Expected(player_two.ELO, player_one.ELO)

    update_player(player_one, player_one_score, player_two, player_two_score, expected_one)
    update_player(player_two, player_two_score, player_one, player_one_score, 1-expected_one)

def record_user_road(request,user,road):
	user = User.objects.get(id=user)
	records = Record.objects.filter(user=user,road=road)
	summary = Record.summary_by_user_road(user,road)
	context = {'user':user,
		'records':records,
		'summary':summary,}
	return render_to_response('record-user-road.html', context,context_instance=RequestContext(request))