def register(self):
     if request.method == u'POST':
         client_key = self.generate_client_key()
         secret = self.generate_client_secret()
         # TODO: input sanitisation?
         name = request.form.get(u"name")
         description = request.form.get(u"description")
         callback = request.form.get(u"callback")
         pubkey = request.form.get(u"pubkey")
         # TODO: redirect?
         # TODO: pubkey upload
         # TODO: csrf
         info = {
             u"client_key": client_key,
             u"name": name,
             u"description": description,
             u"secret": secret,
             u"pubkey": pubkey
         }
         client = Client(**info)
         client['callbacks'].append(callback)
         client['resource_owner_id'] = g.user['_id']
         client_id = Client.insert(client)
         g.user.client_ids.append(client_id)
         User.get_collection().save(g.user)
         return render_template(u"client.html", **info)
     else:
         clients = Client.get_collection().find({'_id': {'$in': 
             [ObjectId(oid) for oid in g.user.client_ids]}})
         return render_template(u"register.html", clients=clients)

def authorize():
    if request.method == "GET":
        print "123445566"
        context_id = None
        # scopes requesting resource accesses
        resource_scopes = []
        for scope in request.args["scope"].split(" "):
            if scope.startswith("launch:"):
                _, context_id = scope.rsplit(":", 1)
            elif scope.startswith("patient/") or scope.startswith("user/"):
                resource_scopes.append(scope)
        if context_id is None:
            # create launch context for app launched outside of EHR env
            # TODO clean this up
            return redirect(
                "%s?%s" % (url_for("auth.create_context"), urlencode({"auth_req": json.dumps(request.args)}))
            )
        assert request.args["response_type"] == "code"
        # find app requested this authorization
        app = App.query.filter_by(
            client_id=request.args["client_id"], redirect_uri=request.args["redirect_uri"]
        ).first()
        assert app is not None
        client = Client(
            authorizer=request.session.user,
            app=app,
            state=request.args.get("state"),
            scope=request.args["scope"],
            context_id=context_id,
        )
        db.session.add(client)
        ctx = Context.query.get(context_id)
        # id of patient selected in launch time, could be none
        pid = json.loads(ctx.context).get("Patient")
        # parse requested scopes
        scopes = [OAuthScope(scp_str, pid) for scp_str in resource_scopes]
        readable_accesses = map(OAuthScope.to_readable, scopes)
        # we grant access despite user's reaction so that we don't have to keep tract of requested scope
        # security is being taken care of by marking the authorized client as un authorized
        for scope in scopes:
            scope.get_access_from_user(request.session.user, client)
        db.session.commit()
        return render_template(
            "authorization.html", appname=app.name, accesses=readable_accesses, auth_code=client.code
        )
    else:
        client = Client.query.filter_by(code=request.form["auth_code"]).first()
        assert client is not None
        app = App.query.filter_by(client_id=client.client_id).first()
        redirect_uri = app.redirect_uri
        if request.form["authorize"] == "yes":
            # authorize the client and redirect
            client.authorized = True
            db.session.commit()
            redirect_args = {"code": request.form["auth_code"]}
            if client.state is not None:
                redirect_args["state"] = client.state
        else:
            redirect_args = {"error": "Authorization declined"}
        return redirect("%s?%s" % (redirect_uri, urlencode(redirect_args)))

 def register(self):
     if request.method == u'POST':
         client_key = self.generate_client_key()
         secret = self.generate_client_secret()
         # TODO: input sanitisation?
         name = request.form.get(u"name")
         description = request.form.get(u"description")
         callback = request.form.get(u"callback")
         pubkey = request.form.get(u"pubkey")
         # TODO: redirect?
         # TODO: pubkey upload
         # TODO: csrf
         info = {
             u"client_key": client_key,
             u"name": name,
             u"description": description,
             u"secret": secret,
             u"pubkey": pubkey
         }
         client = Client(**info)
         client.callbacks.append(Callback(callback))
         client.resource_owner = g.user
         db_session.add(client)
         db_session.commit()
         return render_template(u"client.html", **info)
     else:
         clients = g.user.clients
         return render_template(u"register.html", clients=clients)

 def delete_client(self, cmd, anon_ch):
     valid, msg, owner = self.check_del_params(cmd)
     if not valid:
         anon_ch.put({'status': 'error',
                      'message': 'Invalid parameters sent: {}'.format(msg)})
         return None
     try:
         _, ag = self.get_agave(cmd['tenant'], owner)
     except ClientException as e:
         anon_ch.put({'status': 'error',
                      'message': 'Could not generate an Agave client: {}'.format(e)})
         return None
     # remove the client from APIM
     try:
         ag.clients.delete(clientName=cmd['worker_id'])
     except Exception as e:
         anon_ch.put({'status': 'error',
                     'message': 'Not able to delete client from APIM. Exception: {}'.format(e)})
         return None
     # remove the client from the abaco db
     try:
         Client.delete_client(tenant=cmd['tenant'], client_key=cmd['client_id'])
     except Exception as e:
         anon_ch.put({'status': 'error',
                     'message': 'Not able to delete client from abaco db. Exception: {}'.format(e)})
         return None
     anon_ch.put({'status': 'ok',
                  'message': 'Client deleted.'})

 def test_one_report(self):
   client = Client(product=ProductData.killerapp_obj, cookie='123')
   client.put()
   report = Report(product=ProductData.killerapp_obj, client=client, status=REPORT_NEW, remote_ip='127.0.0.1', data='[]')
   report.put()
 
   response = self.get('/status/')
   assert 'Queued Reports: 1' in str(response)

def management():
    """ This endpoint is for vieweing and adding users and clients. """
    if request.method == 'POST' and request.form['submit'] == 'Add User':
        User.save(request.form['username'], request.form['password'])
    if request.method == 'POST' and request.form['submit'] == 'Add Client':
        Client.generate()
    return render_template('management.html', users=User.all(),
                           clients=Client.all())

 def create(self, validated_data):
     client = Client(
         name=validated_data['name'],
         alias=validated_data['name'].lower(),
         active=validated_data['active']
     )
     client.save()
     return client

def authorize():
    if request.method == 'GET':
        context_id = None
        # scopes requesting resource accesses
        resource_scopes = [] 
        for scope in request.args['scope'].split(' '):
            if scope.startswith('launch:'):
                _, context_id = scope.rsplit(':', 1)
            elif scope.startswith('patient/') or scope.startswith('user/'):
                resource_scopes.append(scope)
        if context_id is None:
            # create launch context for app launched outside of EHR env
            # TODO clean this up
            return redirect('%s?%s'% (url_for('auth.create_context'), urlencode({'auth_req': json.dumps(request.args)})))
        assert request.args['response_type'] == 'code'
        # find app requested this authorization
        app = App.query.filter_by(
                client_id=request.args['client_id'],
                redirect_uri=request.args['redirect_uri']).first()
        assert app is not None
        client = Client(authorizer=request.session.user,
                        app=app,
                        state=request.args.get('state'),
                        scope=request.args['scope'],
                        context_id=context_id)
        db.session.add(client)
        ctx = Context.query.get(context_id)
        # id of patient selected in launch time, could be none
        pid = json.loads(ctx.context).get('Patient')
        # parse requested scopes
        scopes = [OAuthScope(scp_str, pid) for scp_str in resource_scopes]
        readable_accesses = map(OAuthScope.to_readable, scopes)  
        # we grant access despite user's reaction so that we don't have to keep tract of requested scope
        # security is being taken care of by marking the authorized client as un authorized
        for scope in scopes:
            scope.get_access_from_user(request.session.user, client)
        db.session.commit()
        return render_template('authorization.html',
                    appname=app.name,
                    accesses=readable_accesses,
                    auth_code=client.code)
    else:
        client = Client.query.filter_by(code=request.form['auth_code']).first()
        assert client is not None
        app = App.query.filter_by(client_id=client.client_id).first()
        redirect_uri = app.redirect_uri
        if request.form['authorize'] == 'yes':
            # authorize the client and redirect
            client.authorized = True 
            db.session.commit()
            redirect_args = {'code': request.form['auth_code']}
            if client.state is not None:
                redirect_args['state'] = client.state
        else:
            redirect_args = {'error': 'Authorization declined'}
        return redirect('%s?%s'% (redirect_uri, urlencode(redirect_args))) 

def client():
    item = Client(
            client_id=gen_salt(40),
            client_secret=gen_salt(50),
            _redirect_uris='/',
            is_confidential=True
    )
    db.session.add(item)
    db.session.commit()
    return make_response(json.dumps(item.dict()), 200)

    def test_parse_client(self):

        response = '''
            {"response":[{"id":"107111","name":"Ford","day_limit":170,"all_limit":3000}]}
            '''
        account = AccountFactory(remote_id=1)
        instance = Client(account=account, fetched=datetime.now())
        instance.parse(json.loads(response)['response'][0])
        instance.save(commit_remote=False)

        self.assertEqual(instance.account, account)
        self.assertEqual(instance.remote_id, 107111)
        self.assertEqual(instance.name, 'Ford')
        self.assertEqual(instance.day_limit, 170)
        self.assertEqual(instance.all_limit, 3000)

def clients_add(request):
    if request.method == "POST":
        add_form = ClientAddForm(request.POST)
        if add_form.is_valid():
            new_cl = Client(
                name=add_form.cleaned_data["name"],
                address=add_form.cleaned_data["address"],
                zip_code=add_form.cleaned_data["zip_code"],
                country=add_form.cleaned_data["country"],
            )
            new_cl.save()
            return HttpResponseRedirect("/clients/")
    else:
        add_form = ClientAddForm()
    return render_to_response("storage/clients_add.html", {"form": add_form}, context_instance=RequestContext(request))

 def get_rsa_key(self, client_key):
         client = Client.find_one({'client_key':client_key})
         
         if client:
             return client.get('pubkey')
         else:
             return None

 def get_client_secret(self, client_key):
         client = Client.find_one({'client_key':client_key})
         
         if client:
             return client.get('secret')
         else:
             return None

def announce(request):
    
    try:
        params = torUtils.getParams(request.get_full_path()) # <-- Add this to models
        ih = params[u'info_hash'][0]
        
        # Match params to grab a specific torrent
        t = Torrent.getTorrent(info_hash=ih)
        
        # Check whether this is a new or returning client
        c = t.getPeer(ip=request.META["REMOTE_ADDR"])
        if c.size == 0:
            c = Client.create(n = params['name'], i = request.META["REMOTE_ADDR"], p = params['port'], ih = params[u'info_hash'][0])
        else:
            # Parse old client
            c = c[0]
        c.update(params["event"])

    except Exception as e:
        print "Torrent not found; ", e
    #     return HttpResponse("Newp!")
    # Match client against list of known users
    # -- Seeding:
    # -- Leeching:
    # -- Loading:
    # -- Inactive:
    # If no announce, double-check peer connections, and send a new list
    return HttpResponse("Fixthis")

def createUser(request):
    _udid = request.GET['udid']
    _tokenId = request.GET['tokenId']
    _bundleId = request.GET['bundleId']
    userId = ""
    try : 
        user = Client.objects.get(udid =_udid)
        user.tokenId = _tokenId
        user.bundleId = _bundleId
        userId = user.id
        user.save()
    except :
        add_to_db = Client(udid=_udid,tokenId=_tokenId,bundleId=_bundleId)
        add_to_db.save()
        userId= add_to_db.id
    return JSONResponse({'userId':userId})

 def get_realm(self, client_key, request_token):
     client = Client.find_one({'client_key':client_key})
     
     if client:
         return RequestToken.find_one(
             {'token':request_token, 'client_id': client['_id']})['realm']
     else:
         return None

    def register(self):
        """Registers a new client (app)."""
        if request.method == u'POST':
            client_key = self.generate_client_key()
            secret = self.generate_client_secret()

            name = request.form.get(u"name")
            description = request.form.get(u"description")
            callback = request.form.get(u"callback")
            pubkey = request.form.get(u"pubkey")

            # Validoitaan syötteet:
            params = [name, description, callback, pubkey]
            if any(not param for param in params):
                flash("Please fill all fields.")
                return redirect(url_for("register"))

            for param in params:
                if len(param) < 5:
                    flash("Input too short: " + param)
                    return redirect(url_for("register"))
                if len(param) > 60:
                    flash("Input too long: ")
                    return redirect(url_for("register"))

            if not callback.startswith("http://"):
                flash("Invalid callback url: " + callback)
                return redirect(url_for("register"))

            info = {
                u"client_key": client_key,
                u"name": name,
                u"description": description,
                u"secret": secret,
                u"pubkey": pubkey
            }
            cb = Callback(callback=callback)
            cb_key = cb.put()
            client = Client(**info)
            client.callbacks.append(cb_key)
            client.resource_owner = g.user.key
            client.put()
            return render_template(u"client.html", **info)
        else:
            clients = Client.query(Client.resource_owner == g.user.key)
            return render_template(u"register.html", clients=clients)

 def start_oauth2_dance(self):
     login_hint = ''
     scope = ''
     client = Client.get_by_id(1)
     if not client:
         # If client does not exist then create an empty one
         client = Client(id=1)
         client.installer_user = users.get_current_user().email()
         client.put()
     # Get the login hint from configuration
     approval_prompt = 'auto' if client.refresh_token else 'force'
     scope = constants.OAUTH2_SCOPE
     redirect_uri = helpers.url_for('oauth.oauth_callback',
                                    _external=True)
     oauth_helper = OAuthDanceHelper(redirect_uri, approval_prompt, scope)
     url = oauth_helper.step1_get_authorize_url()
     #TODO: Add a random token to avoid forgery
     return redirect(url)

def date(request):
    if request.method == 'POST':
        if request.is_ajax():
            name = request.POST.get('name')
            phone = request.POST.get('phone')
            email = request.POST.get('email')
            d = request.POST.get('date')
            t = request.POST.get('time')
            dd = datetime.date.fromtimestamp(int(d)/1000.0)

            bookedHour = int(t[16:18])
            bookedMin = int(t[19:21])
            bookedTime = datetime.time(bookedHour, bookedMin)
            dateTime = Client(name = name, phone = phone, email = email, date = dd, time=bookedTime)
            dateTime.save()
            return render(request, 'date2.html')

    return render(request,'date2.html')

	def get(self, request):
		data = json.loads(list(request.GET)[0].replace('\'', ''))
		register_output = { 'code': -1 }
		u = authenticate(username=data['name_surname'], password=data['pass'])
		if u is not None:
		 	register_output['code'] = 1
			return JsonResponse(register_output)
		else:
			u = User()
			u.email = data['email']
			u.username = data['name_surname']
			u.set_password(data['pass'])
			register_output['code'] = 0 
			u.save()
			client = Client(client_id=data['client_id'])
			client.save()
			qccess_token = create_token(u, client)
			register_output.update({'token' : access_token.token})
			return JsonResponse(register_output)