def register_page(request): if request.method == 'POST': form = FormularzRejestracji(request.POST) if form.is_valid(): user = User.objects.create_user( username=form.cleaned_data['username'], password=form.cleaned_data['password1'], ) user.save() acc = Account() acc.owner = user.username acc.balance = 0 acc.save() if form.cleaned_data['log_on']: user = authenticate(username=form.cleaned_data['username'],password=form.cleaned_data['password1']) login(request,user) return HttpResponseRedirect("/blog/") else: template = get_template("registration/register_success.html") variables = RequestContext(request,{'username':form.cleaned_data['username']}) output = template.render(variables) return HttpResponse(output) else: form = FormularzRejestracji() template = get_template("registration/register.html") variables = RequestContext(request,{'form':form}) output = template.render(variables) return HttpResponse(output)
def add_user(): mobile = request.form.get('mobile') username = request.form.get('username') password = request.form.get('password') u = User({'mobile': mobile, 'username': username, 'password': password}) u.upsert() i = 0 lnames = [] while True: login_name = request.form.get('accounts[{}][login_name]'.format(i)) login_password = request.form.get( 'accounts[{}][login_password]'.format(i)) if login_name and login_password: a = Account({'user_id': u._id, 'login_name': login_name, 'login_password': login_password}) a.upsert() lnames.append(login_name) i += 1 else: break Account.delete_many({'user_id': u._id, 'login_name': {'$nin': lnames}}) return jsonify(status=200)
def test_get_one_returns_entity(self): acc = Account(username=self.username, password=self.password, userid=self.userid) acc.put() result = Account.get_one() self.assertEqual(acc, result)
def test_model_liability(self): "Test liability model" contact_type = ContactType(name='test') contact_type.save() contact = Contact(name='test', contact_type=contact_type) contact.save() currency = Currency(code="GBP", name="Pounds", symbol="L", is_default=True) currency.save() account = Account( name='test', owner=contact, balance_currency=currency) account.save() obj = Liability(name='test', source=contact, target=contact, account=account, value=10, value_currency=currency) obj.save() self.assertEquals('test', obj.name) self.assertNotEquals(obj.id, None) obj.delete()
def process_tx_initial(tx_obj: Tx): found_relevant_address = False for out in tx_obj.txs_out: address = out.bitcoin_address() if address in all_addresses: found_relevant_address = True break if not found_relevant_address: logging.info('Found irrelevant tx %s' % hash_to_hex(tx_obj.hash())) return tx_hash = tx_obj.hash() txid = hash_to_hex(tx_hash).decode() if tx_hash in known_txs: return known_txs.add(tx_hash) txs[tx_hash] = tx_obj.as_hex() for out in tx_obj.txs_out: address = out.bitcoin_address() if address in all_addresses and address is not None: unprocessed_txs.add(tx_hash) uid = addr_to_uid[address] account = Account(uid) account.txs.add(tx_hash) account.unconf_minutes.incr(calc_node_minutes(satoshi_amount=out.coin_value, exchange_rate=exchange_rate.get())) account.add_msg('Found tx for %.08f, %s' % (out.coin_value / COIN, txid)) nodes_recently_updated.append(account.uid)
def cw_register(request): username = request.POST.get('username', '') password = request.POST.get('password', '') email = request.POST.get('email', '') first_name = request.POST.get('first_name', '') last_name = request.POST.get('last_name', '') zip_code = request.POST.get('zip', '') if User.objects.filter(email=email).exists(): return HttpResponseBadRequest(reason='An account exists for this email address.') if User.objects.filter(username=username).exists(): return HttpResponseBadRequest(reason='Sorry, this username is taken.') try: User.objects.create_user(username, email, password) user = authenticate(username=username, password=password) user.is_active = False user.save() except Exception as e: return HttpResponseServerError(reason=str(e)) try: account = Account(user=user, email=email, first_name=first_name, last_name=last_name, zip_code=zip_code) account.save() login(request, user) return HttpResponse() except Exception as e: user.delete() return HttpResponseServerError(reason=str(e))
def process_request(self, request): """ This function sets up the user object Depending on the value of require_login, it can return None as 'profile'. """ #Get Google user_id google_user = users.get_current_user() account = None is_admin = False logging.info(request.META['HTTP_USER_AGENT']) if google_user: #Check if the user already has a site profile user_id = google_user.user_id() is_admin = users.is_current_user_admin() q = Account.all() q.filter('google_user ='******'My Box') box.put() request.user = account Account.current_user_account = account request.user_is_admin = is_admin
def test_model_liability(self): "Test liability model" contact_type = ContactType(name='test') contact_type.save() contact = Contact(name='test', contact_type=contact_type) contact.save() currency = Currency(code="GBP", name="Pounds", symbol="L", is_default=True) currency.save() account = Account(name='test', owner=contact, balance_currency=currency) account.save() obj = Liability(name='test', source=contact, target=contact, account=account, value=10, value_currency=currency) obj.save() self.assertEquals('test', obj.name) self.assertNotEquals(obj.id, None) obj.delete()
def create_for_email(self, email, commit=False): if self.is_email_registered(email): raise EmailAlreadyInUse(email) account = Account(email=email) account.password = self.hasher.generate() db.session.add(account) if commit: db.session.commit() return account
def verify_mail(): """ """ account_obj = _get_account_by_email(g._db, request.form.get('email', '')) if account_obj: raise MainException.ACCOUNT_DUPLICATE email = request.form.get('email', '') password = request.form.get('password', '') password = generate_password_hash(password) code = random_ascii_string(40) account_id = Account.gen_id(g._db) send_verify_email(email, code, email_cb=url_for('account.register_valid', code='', _external=True)) Account.insert_verify_email(g._db, email, code, EmailUsageType.DEVELOPER_VERIFY, account_id) Account.create_account(g._db, account_id, email, password, 0, RoleType.DEVELOPER) if 'user' not in session: session['user'] = {} session['user']['id'] = account_id session['user']['email'] = email session['user']['email_checked'] = 0 session['user']['role'] = RoleType.DEVELOPER account = { "id":account_id, "email":email, "email_checked":0, "role":RoleType.DEVELOPER } return send_response(account)
def account_sync(request): """ API end point to sync the account that signed in via oauth. This API is called by [mankey] service. Logic: If account exists in database, fetch account + role and return if account does not exist, save the email into database as a visitor. sample request.data: { "name": "Tayler", "email": "*****@*****.**", "token":"AABBCC", } """ account = request.data email = account.get('email') name = account.get('name') log.debug( ' account_sync get request.data, receive account={0}, type={1}'.format( account, type(account))) user = {} # check account by email if account_exists(email): user = Account.objects.get(email=email) else: user = Account(name=name, email=email, status='v') user.save() serializer = AccountSerializer(user) return Response(serializer.data)
def dataset(setup_database): session = setup_database # Creates user john = User(username="******") mary = User(username="******") session.add(john) session.add(mary) session.commit() # Creates account john_account = Account(balance=10.0) mary_account = Account(balance=5.0) joint_account = Account(balance=20.0) john.accounts.append(john_account) mary.accounts.append(mary_account) john.accounts.append(joint_account) mary.accounts.append(joint_account) session.add(john_account) session.add(mary_account) session.add(joint_account) session.commit() yield session
def save(self, role=1): user = Account(**self.data) user.role = role user.save() stuusr = Student(stuid=user.username, grade="20" + user.username[0:2]) stuusr.save() return user
def saveProfile(self, request): """Update & return user profile.""" sandy = Account(username='******', userid=123, email='*****@*****.**') sandy_key = sandy.put() return self._doProfile(request)
def reset_mail(): """ """ email = request.form.get('email', '') if not email: raise MainException.ACCOUNT_NOT_FOUND account_obj = _get_account_by_email(g._db, email) if not account_obj: raise MainException.ACCOUNT_NOT_FOUND count = Account.get_verify_count(g._db, email) if count > 5: raise MainException.EMAIL_TOO_OFTEN code = random_ascii_string(40) send_reset_email( email, code, url_for('account.password_forget_check', mail=email, code='', _external=True)) Account.insert_verify_email(g._db, email, code, EmailUsageType.SELLER_RESET_PWD, account_obj['id']) return MainException.OK
def cw_register(request): username = request.POST.get('username', '') password = request.POST.get('password', '') email = request.POST.get('email', '') first_name = request.POST.get('first_name', '') last_name = request.POST.get('last_name', '') zip_code = request.POST.get('zip', '') if User.objects.filter(email=email).exists(): return HttpResponseBadRequest( reason='An account exists for this email address.') if User.objects.filter(username=username).exists(): return HttpResponseBadRequest(reason='Sorry, this username is taken.') try: User.objects.create_user(username, email, password) user = authenticate(username=username, password=password) user.is_active = False user.save() except Exception as e: return HttpResponseServerError(reason=str(e)) try: account = Account(user=user, email=email, first_name=first_name, last_name=last_name, zip_code=zip_code) account.save() login(request, user) return HttpResponse() except Exception as e: user.delete() return HttpResponseServerError(reason=str(e))
def get_or_init_account(user): account = Account.all().filter('user =', user).get() if account is None: account = Account(user=user) account.put() return account
def get_current_account(): """Retrieve the Account entity associated with the current user.""" user = endpoints.get_current_user() if user is None: return None email = user.email().lower() # Try latest recorded auth_email first accounts = Account.query(Account.auth_email == email).fetch(1) if len(accounts) > 0: return accounts[0] # Try the user's default email next accounts = Account.query(Account.email == email).fetch(1) if len(accounts) > 0: # Store auth email for next time accounts[0].auth_email = email accounts[0].put() return accounts[0] # Try via the user's Google ID user_id = _getUserId() accounts = Account.query(Account.gplus_id == user_id).fetch(1) if len(accounts) > 0: # Store auth email for next time accounts[0].auth_email = email accounts[0].put() return accounts[0] return None
def post(self): username = self.request.get('username') password = self.request.get('password') verify_password = self.request.get('verify') email = self.request.get('email') error = "" if username and password and verify_password: if password != verify_password: error = "Verify password is not matched" elif self.is_username_exist(username): error = "Username has already existed" else: hash_pw = encrypt.make_pw_hash(username, password) account = Account(username=username, password=hash_pw, email=email) account.put() account_id = account.key().id() cookie_account_id = encrypt.make_secure_cookie(account_id) # TODO: What is Path=/? self.response.headers.add_header( "Set-Cookie", "user_id={}; Path=/".format(cookie_account_id)) self.response.headers.add_header( "Set-Cookie", "username={}; Path=/".format(username)) self.redirect("/welcome") else: error = "Username, password and verify password is required!" self.render("sign_up.html", error=error, username=username, email=email)
def create_account(): body = request.get_json() first_name = body.get("first_name", None) last_name = body.get("last_name", None) init_balance = int(body.get("balance", None)) res_body = {} error = False if first_name is None or init_balance is None: error = True abort(400) else: try: new_account = Account(first_name=first_name, last_name=last_name, balance=init_balance) new_account.insert() res_body['created'] = new_account.id res_body['first_name'] = new_account.first_name res_body['last_name'] = new_account.last_name res_body['balance'] = new_account.balance res_body['success'] = True return jsonify(res_body) except: abort(422)
def configure_droplet(id, servers=None): # presumably id was just popped from droplets_to_configure if servers is None: servers = get_servers() account = Account(droplet_to_uid[id]) logging.info('Configuring %s for %s' % (id, account.uid)) droplet = servers[id] logging.info('Got server %s' % repr(droplet)) ip = droplet['main_ip'] password = droplet['default_password'] droplet_ips[id] = ip # ssh try: print('root', password, ip) _, stdout, stderr = ssh(ip, 'root', password, create_install_command(account.name.get(), account.client.get(), account.branch.get(), gen_loc(account.dcid.get()))) except Exception as e: print(e) logging.error('could not configure server %s due to %s' % (id, repr(e))) return print(stdout.read(), stderr.read()) account.add_msg('Started compilation script on server %s -- can take hours as it also bootstraps the blockchain.' % id) logging.info('Configuring server %s' % id) account.compile_ts.set(int(time.time())) droplets_to_configure.remove(id) currently_compiling.add(id)
def callback(request): oauth_token = request.GET.get('oauth_token') oauth_verifier = request.GET.get('oauth_verifier') oauth = OAuth1(settings.CONSUMER_KEY, client_secret=settings.CONSUMER_SECRET, resource_owner_key = request.session['key'], resource_owner_secret = request.session['secret'], verifier=oauth_verifier) r = requests.post(TWITTER_BASE + 'oauth/access_token', auth=oauth) credentials = parse_qs(r.content) oauth_token = credentials.get('oauth_token')[0] oauth_token_secret = credentials.get('oauth_token_secret')[0] user_id = credentials.get('user_id')[0] screen_name = credentials.get('screen_name')[0] account = Account( oauth_token=oauth_token, oauth_token_secret=oauth_token_secret, user_id=user_id, screen_name=screen_name) account.save() d = { 'oauth_token': oauth_token, 'oauth_token_secret': oauth_token_secret, 'user_id': user_id, 'screen_name': screen_name, } return render_to_response('callback.html', d)
def create_account(rp): # Account User account = Account(0, 0) account.referralProgram = rp db.session.add(account) #db.session.commit() return account
def create_account(): form = CreateAccountForm() if request.method == 'POST': ws_cust_id = request.form.get('ws_cust_id') ws_acct_type = request.form.get('ws_acct_type') ws_amt = request.form.get('ws_amt') customer = Customer.query.filter_by(ws_cust_id=ws_cust_id).first() if customer: account = Account(ws_cust_id=ws_cust_id, ws_acct_type=ws_acct_type) account.ws_acct_balance = ws_amt account.ws_acct_crdate = datetime.now() account.ws_acct_lasttrdate = datetime.now() #ws_acct_duration db.session.add(account) db.session.commit() # to update status temp_acc = Account.query.order_by(Account.ws_acc_id.desc()).first() if temp_acc: update_status_account(temp_acc.ws_acc_id, 'created') flash("Account creation initiated !", "success") return render_template("customer.html", title="Account created", create_account=True) else: flash("Customer Id does not exist !", "danger") return render_template("create_account.html", form=form, create_account=True, title='Create Account')
def get_alluser(db, arg): listObj = { "total": 0, "users": [], } start = arg["paras"].get("start") or 0 limit = arg["paras"].get("limit") or 100 cond = "WHERE 1=1 " ret = db.select(TB_ACCOUNT, cond=cond, limit=int(limit), offset=int(start)) if ret == -1: ERROR("get user list error") return (DB_ERR, None) for dur in db.cur: obj = dbmysql.row_to_dict(TB_ACCOUNT, dur) user = Account(db, dbObj=obj) user.loadFromObj() listObj["users"].append(user.toObj()) listObj["total"] = getAccountCount(db) return (OCT_SUCCESS, listObj)
def test_Account_initialization(self): try: Account().put() self.assertEqual(1,2) except BadValueError: pass try: Account(username='******').put() self.assertEqual(1,2) except BadValueError: pass try: Account(email='*****@*****.**').put() self.assertEqual(1,2) except BadValueError: pass # test contructor Account(username='******', email='*****@*****.**').put() self.assertEqual(1, len(Account.query().fetch(2))) # test add new user request = AccountRequest('First Mate', '*****@*****.**') Account.add_new_user(request) self.assertEqual(2, len(Account.query().fetch(3)))
def save(self, role=1): user = Account(**self.data) user.role=role user.save() stuusr=Student(stuid=user.username,grade="20"+user.username[0:2]) stuusr.save() return user
def register(): errors = [] if request.method == 'GET': if current_user.get_id(): return redirect(url_for('home')) else: return render_template('register.html') if db.session.query(Account).filter_by(account_name=request.form['account_name']).count() > 1: errors.append('Account name is already taken.') if not request.form['account_name']: errors.append('Please enter a account name.') if not request.form['password']: errors.append('Please enter a password.') if errors: return jsonify({"status": "error", 'errors': errors}), 400 account = Account( account_name=request.form['account_name'], active_user=True, ) account.set_password(request.form['password']) try: db.session.add(account) db.session.commit() except Exception: errors.append("Name is already taken") if errors: return jsonify({"status": "error", 'errors': errors}), 400 login_user(account, remember=True) success_message = "Your account has been created!" return jsonify({"status": "success", "value": success_message}), 200
def basicinfo(user, self): if user: url = users.create_logout_url(self.request.uri) url_linktext = 'Logout' nickname = user.nickname() accounts = Account.query(Account.guser == user).fetch() if len(accounts) == 0: # if no Account object exists for user new_account = Account( guser=user, modules_completed=[], projects_completed=[] ) new_account.put() else: url = users.create_login_url(self.request.uri) url_linktext = 'Login' nickname = None template_values = { 'title': config.SITE_NAME, 'url': url, 'url_linktext': url_linktext, 'nickname': nickname } return template_values
def save(self, user): cd = self.cleaned_data account = Account(number=cd['number'], bank=cd['bank'], balance=cd['balance'], nominal=cd['nominal'], user=user) account.save()
def setAccountInfo(info): e = Account.get_by_id(info['uid']) if e: pass else: account = Account(id = info['uid'], uid = info['uid'], name = info['display_name'], country = info['country'], link = info['referral_link'], quota_normal = info['quota_info']['normal'], quota_shared = info['quota_info']['shared'], quota_quota = info['quota_info']['quota']) account.put()
def new_user(type, custom_options={}): service = Service.query.filter(Service.type == type).one() account = Account() account.fill(service) db.session.add(account) db.session.commit() return custom_action("new_user", service, custom_options, account=account)
def find_existing(cls, email): hash = hashlib.md5(email).hexdigest() found = Account.all().filter('hash =', hash).get() if not found: found = Account.all().filter('hashes =', hash).get() if not found: found = Email.all().filter('email =', email).get() return found
def test_account_is_stored(self): acc = Account(username=self.username, password=self.password, userid=self.userid) key = acc.put() stored = key.get() self.assertEqual(stored.username, self.username) self.assertEqual(stored.password, self.password) self.assertEqual(stored.userid, self.userid)
def save_account(name, password, username, email): password, iv = crypt(password) account = Account(name=name, password=password, username=username, email=email, iv=iv) account.save()
def test_followings_timeline(self): account = Account() tweets = account.followings_timeline() myid = 43657148 self.assertTrue(myid in tweets) self.assertTrue(len(tweets[myid]) > 0) print tweets[myid][0][0] print tweets[myid][0][1]
def test_placeholder(self): user = users.User("*****@*****.**") account = Account(user=user) account.set_hash_and_key() account.put() self.assertTrue(account.user.email() == "*****@*****.**")
def find_existing(cls, email): hash = hashlib.md5(email).hexdigest() found = Account.all().filter("hash =", hash).get() if not found: found = Account.all().filter("hashes =", hash).get() if not found: found = Email.all().filter("email =", email).get() return found
def get_user(db, userId): user = Account(db, userId) if (user.init() != 0): ERROR("user %s not exist" % userId) return (USER_NOT_EXIST, None) return (OCT_SUCCESS, user.toObj())
def create_account(email, password): """No API endpoint calls this method - it's meant to be used via CLI""" AuthController.validate_email(email) try: account = Account(email, password) account.save() except Exception as e: logger.error(e) raise Error(FATAL)
def create_new_account_response(): new_account = Account(username=username) account_key = new_account.put() link_header = create_link_header( url_for("get_account", account_key=account_key.urlsafe()), 'account', 'Account created' ) return '', httplib.CREATED, {'Link': link_header}
def signup(username, password, email, facebook_id): user = Account(username=username ,signup_date=datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") ,email=email, facebook_id=facebook_id) user.hash_password(password) db.session.add(user) db.session.commit() send_mail('testing_android', [user.email], {}) return "Adding successful"
def register(request): """ 用户注册页面 需要用户填写 email,name,password POST请求后插入到数据库中,需要做校验 成功后跳转到登录首页 :param request: :return: """ if request.method == 'POST': email = request.POST.get('email', '') username = request.POST.get('username', '') password = request.POST.get('password', '') if not captch_http_check(request.POST.get('code', ''), request): return render_to_response( 'account/register.html', { 'error': u'验证码输入错误', 'email': email, 'name': username, 'password': password }) # email和name唯一,所以进行校验,如果email已经被注册,需要再次换一个email result = Account.objects.filter(Q(email=email) | Q(name=username)) #生成激活码 code = md5(username.encode('utf-8') + str(password)).hexdigest() if len(result) > 0: error = u'邮箱或用户名已经被注册,请换一个' return render_to_response( 'account/register.html', { 'error': error, 'email': email, 'name': username, 'password': password }) account = Account(email=email, name=username, password=md5(password).hexdigest(), is_active=False, active_code=code) account.save() #发送邮件 return_code = send_register_email(email, code) if return_code != 0: return render_to_response('account/register.html', {'done': 1}) else: return render_to_response( 'account/register.html', { 'error': u'发送激活邮件失败', 'email': email, 'name': username, 'password': password }) return render_to_response('account/register.html')
def create_account_menu(): print("Account creation") firstName = input('First Name : ') lastName = input('Last Name : ') pin = input('PIN : ') fullName = firstName + " " + lastName newUser = Account(fullName, 0, pin) #Default account number as 0 to indicate a real "new account" #Create the account in the database print("account created, your account number is: ", newUser.createAccount())
def checkUser(self, user): accounts = Account.all() user_ids = [] for acc in accounts: user_ids.append(acc.user_id) uid = user.nickname() if uid not in user_ids: account = Account(key_name=uid, user_id=uid) account.put()
def create_account(user): """ This function creates account for new user """ account = Account(user=user, newsletter=True) account.put() ig = ImageGroup(name="Custom Images", owner=account, priority=0) ig.save() notify_admins_about_new_user_signup(user) return account
def create_account(user): """ This function creates account for new user """ account = Account(user=user, newsletter=True) account.put() ig = ImageGroup(name='Custom Images', owner=account, priority=0) ig.save() notify_admins_about_new_user_signup(user) return account
def get(self, hash): if Account.all().filter('api_key =', self.request.get('api_key')).get(): if (Account.all().filter('hash =', hash.lower()).get()) or (Account.all().filter('hashes =', hash.lower()).get()): self.response.out.write("200 OK") else: self.error(404) self.response.out.write("404 User not found") else: self.error(403) self.response.out.write("403 Missing required parameters")
def save(self, user): cd = self.cleaned_data account = Account( number=cd['number'], bank=cd['bank'], balance=cd['balance'], nominal=cd['nominal'], user=user ) account.save()
def setUp(self): self.scott = Account.new('scott', 'tiger', '*****@*****.**') self.scott_page = Page.new(self.scott, 'Book List') self.scott_rev = self.scott_page.save_draft_rev( 'book list sample text', True) self.scott_page.publish_draft_rev() self.sally = Account.new('sally', 'secret', '*****@*****.**') self.sally_page = Page.new(self.sally, 'Dear Diary') self.sally_rev = self.sally_page.save_draft_rev('today i am sad', True) self.sally_page.publish_draft_rev()
def check_fail_cookie(cls): for i in Account.select(): cls(i.nick) users = Account.select( ) # .where(Account.valid == False)#, Account.apply == True) if users: msg = '、'.join([user.nick for user in users]) Smail('登陆失效提醒', '{users}已失效,请尽快重新登陆!'.format(users=msg)) return False return True
def post(self): json_req = self.jsonifyRequestBody() data = json_req print data print "Entering account handler!" service_ids = data["service_ids"] print service_ids for id_ in service_ids.keys(): # Checks if account exists at all.. # Means only there cannot be two accounts with the same service_id accountExists = self.validateAccount(id_) if accountExists: print "Account exists" continue print "Creating account for id " + id_ acc = Account() acc.email = data["email"] print "gotten email" acc.serviceID = id_ acc.alias = service_ids[id_] print "got service id" acc.config = default_config print "set default configs" acc.key = ndb.Key(Account, id_) print "creating key" acc.put() print "Account sucessfully created" logging.info("Account has been put into the datastore") #Better flesh out fail state. self.writeSucessfulResponse("Account sucessfully created")
def save(self): user = Account(**self.data) user.save() if self.role.data == 1: stuusr = Student(stuid=self.username.data) stuusr.save() if self.role.data == 3: teausr = Teacher(teaid=self.username.data) teausr.save() return self.username.data, self.role.data
def changeFollow(request): name=request.GET['username'] friend=Account.objects(username=name).first() user=Account.objects(username=request.user.username).first() if str(friend.id) in user.friends: user.friends.remove(str(friend.id)) else: user.friends=user.friends+[str(friend.id)] user.save() request.user=user return HttpResponse("add success")
def login_menu(): accountNum = input("Account number: ") pin = input("PIN: ") loginUser = Account("", accountNum, pin) testLogin = loginUser.login() if testLogin == False: print("!! Account Number/PIN # is invalid") else: loggedIn_menu(testLogin)