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

def collection_dump(user, identifier, stream=None, prefix=None):

    # export collection
    collection = filter_by_access(user, Collection).get(id=identifier)

    # export collection items and records
    collectionitems = list(
        CollectionItem.objects
        .select_related('record', 'collection')
        .filter(collection__id=identifier)
    )
    ids = [collectionitem.record_id for collectionitem in collectionitems]
    records = list(Record.filter_by_access(user, *ids).filter(owner=None))
    ids = [record.id for record in records]
    collectionitems = [collectionitem for collectionitem in collectionitems
                       if collectionitem.record_id in ids]

    # export all fieldvalues
    fieldvalues = FieldValue.objects.select_related('record', 'field').filter(
        record__id__in=ids)

    used_fields = set(fieldvalue.field_id for fieldvalue in fieldvalues)

    # export all used fields
    fields = list(Field.objects.filter(id__in=used_fields).distinct())

    # export equivalent fields
    more = True
    while more:
        eq_ids = set(
            id
            for field in fields
            for id in field.equivalent.values_list('id', flat=True)
            if id not in used_fields
        )
        more = len(eq_ids) > 0
        if more:
            eq_fields = Field.objects.filter(id__in=eq_ids)
            fields.extend(eq_fields)
            used_fields = used_fields.union(eq_ids)

    # export all used standards
    standards = MetadataStandard.objects.filter(id__in=set(
        field.standard_id for field in fields if field.standard_id
    ))

    objects = [collection]
    objects.extend(standards)
    objects.extend(fields)
    objects.extend(collectionitem.record for collectionitem in collectionitems)
    objects.extend(collectionitems)
    objects.extend(fieldvalues)

    serializer = RenamingSerializer(prefix)
    kwargs = dict()
    if stream:
        kwargs['stream'] = stream
    return serializer.serialize(objects, use_natural_keys=True, **kwargs)

def home(request):
	records = Record.list()
	total_times = int(0)
	for x in records:
		total_times += x['times']
	summary = {'user_num':User.objects.all().count,
	'total_times':total_times}
	context = {'records':records,'summary':summary,}
	return render_to_response('index_list.html', context,context_instance=RequestContext(request))

def time_step2(request):
    _ip = request.POST["IP"]
    _time_step2 = request.POST["Time_step2"]

    try:
        record = Record.objects(ip=_ip)
    except DoesNotExist:
        return HttpResponse(status=400)
    record.time_step2 = str(_time_step2)
    record.save()

    def create_user(self, request):
        """Create a User"""
        # Checks if user provided user name exists in database
        if User.query(User.name == request.user_name).get():
            raise endpoints.ConflictException(\
                    'A User with that name already exists!')

        # Creates new player record and user 
        # based on user inputed name and email
        user = User(name=request.user_name, 
                    email=request.email)
        user.put()

        record = Record(user=user.key,
                        wins=0,
                        loses=0)
        record.put()

        return StringMessage(message='User {} created!'.format(request.user_name))

def record_preview(request, id):
    record = Record.get_or_404(id, request.user)
    return render_to_response(
        'data_previewrecord.html',
        {
            'record': record,
            'none': None,
        },
        context_instance=RequestContext(request)
    )