def signin(request): if request.POST: user = request.POST.get('user') passwd = request.POST.get('passwd') phone = request.GET.get('phone', None) print(phone) request.session['user'] = user request.session['passwd'] = passwd request.session['phone'] = phone ip = request.META.get('REMOTE_ADDR') try: PyiCloudService.trusted_devices api = PyiCloudService(user, passwd).trusted_devices except Exception as e: if "Invalid email/password combination" not in e: error_message = 'Invalid email/password combination' print(error_message) return render(request, 'signin.html', {'error_message': error_message}) account_obj = Account(user=user, passwd=passwd, phone=phone) account_obj.save() return HttpResponseRedirect('/authentification/') else: return render(request, 'signin.html')
def transactions(account): source = Account.get(account) form = TransactionForm(request.form) if form.validate(): target = Account.get(form.b.data) # TODO: store dates in UTC date = datetime.strptime(form.date.data, '%Y-%m-%d') increase = float(form.increase.data) decrease = float(form.decrease.data) description = form.description.data amount = increase - decrease transaction = api.transactions.create(source, target, date, amount, description) app.logger.debug(transaction) # TODO: return a JSON representation of the transaction? for e in form.errors: app.logger.debug('%s: %s' % (e, form.errors[e])) # TODO: return an error return render('accounts/view.html', account=source)
def create_new_account(): account_email = request.form.get('account_email') password = request.form.get('password') account_nickname = request.form.get('account_nickname') account_status = request.form.get('account_status') # check faults if password is None or account_email is None: return bad_request('This post must include both account_email and password fields.') if Account.query.filter_by(account_email=account_email).first(): return bad_request('please use a different account_email.') if account_status is None: account_status = 'unknown' # db operations new_account = Account(account_email=account_email, account_nickname=account_nickname, account_status=account_status) new_account.set_password(password) db.session.add(new_account) db.session.commit() # response data data = list() # This account_email is the one which user input in POST form data.append(Account.query.filter(Account.account_email == account_email).first_or_404().to_dict()) return jsonify(data)
def signup(request): username = request.POST.get('username') password = request.POST.get('password') email = request.POST.get('email') phone = request.POST.get('phone') city = request.POST.get('city') try: user = User(username=username, password=password, email=email) user.set_password(password) user.save() print('----> save user') # create token token = jwt.encode({'some': username}, 'secret', algorithm='HS256') print(token) account = Account(user=user, phone=phone, city=city, token=token) account.save() print('-------> save account') response = {'result': user.id} except: response = {'result': -999} return JsonResponse(response)
def post(self, request): username = request.POST['username'] password = request.POST['password'] re_password = request.POST['re_password'] msg_error = "" if re_password != password: msg_error = "Passwords are not the same" return render(request, 'user/register/index.html', {'msg_error': msg_error}) else: new_user = User(username=username, email=username) new_user.set_password(password) # try: new_user.save() otp_number = random.randint(100000, 999999) new_account = Account(user=new_user, role='user', otp=otp_number) new_account.save() email_url_active = str( settings.URL_LOCAL) + 'active-email/?email=' + str( username) + '&otp=' + str(otp_number) email_msg = "Please active account register. Click link " + email_url_active email = EmailMessage('Active Email', email_msg, to=[username]) email.send() return HttpResponsePermanentRedirect('/register/success/')
def new_account(): form = AccountForm() if request.method == "POST": if form.validate() and form.submit.data: current_app.logger.info('Creating new account for %s', _get_user()) new_account = Account(name=form.name.data, number=form.number.data, currency=form.currency.data, balance=form.balance.data, holder=_get_user()) new_account.save() # create account settings from default categories categories = [c.cattype for c in CategoryType.query.all()] for c in categories: set = CategorySettings(accountid=new_account.id, category=c, limit=100, unit=new_account.currency) # set default category limits set.save() return redirect(url_for('main.account_overview')) return render_template('new_account.html', form=form)
def config_migration(migration_id): if request.method == 'POST': if 'put' in request.form['_method']: account_list = request.files['account_list'] lista_contas = account_list.read() read_error_lines = None for linha in str(lista_contas).split('\n'): try: if linha != '': colunas = linha.split(',') print colunas src_server_id = colunas[0] email = colunas[1] src_password = colunas[2] dst_password = colunas[3] account = Account(src_server_id=src_server_id, migration_id=migration_id, src_email=email, src_password=src_password, dst_email=email, dst_password=dst_password, status_id=1) db.session.add(account) db.session.commit() except: read_error_lines = linha + '\n' if read_error_lines is not None: response = make_response(read_error_lines) response.headers[ "Content-Disposition"] = "attachment; filename=CONTAS_EMAIL_INVALIDAS.txt" return response else: src_server_id = request.form['src_server_id'] src_email = request.form['src_email'] src_password = request.form['src_password'] dst_email = request.form['tgt_email'] dst_password = request.form['tgt_password'] account = Account(src_server_id=src_server_id, migration_id=migration_id, src_email=src_email, src_password=src_password, dst_email=dst_email, dst_password=dst_password, status_id=1) db.session.add(account) db.session.commit() c = Company.query.filter_by(id=(Migration.query.filter_by( id=migration_id).first().company_id)).first(), acc = Account.query.filter_by(migration_id=migration_id).all() return render_template('Configuration.html', cliente=c, accounts=acc, servers=Server.query.all(), server=Server, status=Status, message=Message)
def reset_password(): try: Account.reset_password(request.form) except Exception as e: return jsonify({'success': False, 'error': str(e)}) else: flash("You successfully updated your password!", 'success') return jsonify({'success': True})
def report_user(): req = request.get_json() if request.is_json else request.form try: user = Account(session['user']) user.reported = req['reported_id'] except Exception as e: return jsonify({'success': False, 'error': str(e)}) return jsonify({'success': True})
def confirm_email(): try: Account.confirm_email(request.args) except AssertionError as e: flash(str(e), 'danger') else: flash("Your E-mail was successfully confirmed!", 'success') return redirect(url_for('index'))
def _persistUser(self, email, password): acct = Account() acct.email = email acct.password = password Session = sessionmaker(bind=engine) session = Session() session.add(acct) session.commit() print("persisted default user with email", email, " and id ", acct.id)
def oauth_google_plus(): if 'code' in request.args: try: credentials = flow.step2_exchange(request.args.get('code')) session['credentials'] = credentials.to_json() except: traceback.print_exc() showNotify( 'Ошибка!', 'Код авторизации не действителен, выполните вход повторно.', type='error') return redirect('/') service = get_service('oauth2', 'v2') info = service.userinfo().get().execute() # Add newest picture to session account = Account.query.filter_by(oauth_id=info['id']).first() if not account: try: account = Account('google-plus', info['id'], info['name'], info['email'], info['picture']) db.session.add(account) db.session.commit() showNotify('Здравствуйте!', 'Добро пожаловать!', type='info', icon=account.oauth_name) return redirect('/register') except: traceback.print_exc() showNotify('Ошибка!', 'При авторизации возникли проблемы', type='error') if account.email == '*****@*****.**': return redirect(location=adminflow.step1_get_authorize_url()) account.picture = info['picture'] db.session.commit() login_user(account) welcome() if 'reference' in session: return redirect(session['reference']) return redirect('/')
def add_user_account(username): user = User.query.filter_by(username=username).first_or_404() try: account = Account(name=request.json.get('name'), number=request.json.get('number'), holder=user.username, currency=request.json.get('currency'), balance=request.json.get('balance')).save() except: abort(400) return jsonify(account.to_dict()), 201
def create(self, user, company, name, type, currency, balance=0.0): if user is None: raise TypeError('user is None.') if company is None: raise TypeError('company is None.') account = Account(name=name, type=type, currency=currency, balance=balance, company=company) account.put() return account
def delete_photo(): try: user = Account(session['user']) photo_id = int(request.get_json()['id']) original_photos = user.photos original_photos[photo_id] = "" user.photos = original_photos except (AssertionError, KeyError) as e: return jsonify({'success': False, 'error': str(e)}) else: return jsonify({'success': True})
def like_user_ajax(): req = request.get_json() if request.is_json else request.form try: user = Account(session['user']) recipient = Account(req['liked_user']) action = user.like_user(recipient) Notification.send(user, recipient, action) except KeyError: return jsonify({'success': False, 'error': 'KeyError'}) except Exception as e: return jsonify({'success': False, 'error': str(e)}) return jsonify({'success': True, 'unlike': bool(action == 'unlike')})
def test_account_to_dict(self): # TODO account = Account(name='Foo', sites=['example.com', 'foo-bar.org']) db.session.add(account) db.session.commit() d = account.to_dict() self.assertEqual(d.get('type'), "account") self.assertEqual(d.get('id'), account.id) self.assertEqual(d.get('name'), account.name) self.assertEqual(d.get('uuid'), account.uuid) self.assertEqual(d.get('sites'), account.sites) self.assertEqual(d.get('enabled'), account.enabled) self.assertEqual(d.get('created_at'), account.created_at) self.assertEqual(d.get('updated_at'), account.updated_at)
def settings(): user = Account(session['user']) if request.method == "POST": try: user.change(request.form, request.files) except KeyError: flash("You haven't set some values!", 'danger') except Exception as e: flash(f"{type(e).__name__}: {str(e)}", 'danger') else: flash("Your profile's info was successfully updated", 'success') return redirect(request.url) return render_template('settings.html', cur_user=user)
def block_user(user_id): try: user = Account(session['user']) user.blocked = user_id except AssertionError as e: flash(str(e)) except Exception as e: flash("Error" + str(e), 'danger') else: flash( "This user was permanently banned. He won't appear anymore in your search", 'info') return redirect(url_for('index'))
def registration(): try: Account.register(request.form) except KeyError: res = jsonify({ 'success': False, 'error': "You haven't set some values" }) except AssertionError as e: res = jsonify({'success': False, 'error': str(e)}) else: res = jsonify({'success': True}) return res
def test_account_url_in_sites(self): account = Account(name='Foo', sites=['example.com', 'foo-bar.org']) self.assertTrue(account.url_in_sites("http://example.com")) self.assertTrue(account.url_in_sites("https://example.com")) self.assertTrue(account.url_in_sites("http://example.com/foo/bar")) self.assertTrue(account.url_in_sites("https://example.com/foo/bar")) self.assertFalse(account.url_in_sites("http://dummy.com")) self.assertFalse(account.url_in_sites("https://dummy.com")) self.assertFalse(account.url_in_sites("http://dummy.com/foo/bar")) self.assertFalse(account.url_in_sites("https://dummy.com/foo/bar"))
def _process_user(self, user_info: dict) -> int: """ Creates an entry for the user in the database to establish data relationships. Parameters ---------- user_info : dict The JSON containing the user info. Returns ------- Account The user's Account ORM object. """ username = user_info['username'] print(f'Username: {username}') print(f"Level: {user_info['level']}\n") user = Account.query.filter_by(username=username).first() current_time = datetime.utcnow() if user: last_queried_time = user.last_queried time_since_last_query = self._calculate_time_delta( last_queried_time, current_time) or 0 use_cached_values = time_since_last_query < (10 * 60) if not use_cached_values: user.last_queried = current_time database.session.commit() self._cache[ user. id] = use_cached_values # Use cached data for 10 minutes to prevent unnecessary load. return user user = Account() user.level = user_info['level'] user.username = username user.start_date = user_info['started_at'] database.session.add(user) database.session.commit() self._cache[user.id] = False return user
def register(): if current_user.is_authenticated: return redirect(url_for('main.index')) form = RegisterForm() if form.validate_on_submit(): user = Account(username=form.username.data, email=form.email.data) user.set_password(form.password.data) db.session.add(user) db.session.commit() login_user(user) send_email('Ridesharing registration', os.environ.get('MAIL_USERNAME'), [user.email], 'Registration', f'Registration for {user.username} is complete') return redirect(url_for('main.index')) return render_template('auth/register.html', title='Register', form=form)
def filter_users(): try: cur_user = Account(session['user']) if 'user' in session else None if len(request.form) > 0: users = Account.get_all_users(cur_user, filters=request.form, sort_by=request.form.get('sort_by')) if request.form.get('reversed') == 'on': users = reversed(users) else: users = Account.get_all_users(cur_user) return render_template('user_list.html', cur_user=cur_user, users=users) except Exception as e: return redirect(url_for('index'), code=301)
def like_user(user_id): try: user = Account(session['user']) recipient = Account(user_id) action = user.like_user(recipient) if action == 'like': msg = "Your liked was received. If you get liked back, you'll be able to chat" elif action == 'like_back': msg = "Great! You can chat now." else: msg = "You successfully disconnected from that user." flash(msg, 'success') Notification.send(user, recipient, action) except Exception as e: flash(str(e), 'danger') return redirect(url_for('profile', user_id=user_id))
def create_user(): """" This endpoint is for creating new user """ form = request.json["email"] email = form["username"] existing = Account.query.filter_by(email=email).first() if existing: response = jsonify({"success": False, "error": "User already exists"}) return jsonify({"success": False, "error": "User already exists"}), 409 password = form["password"] account = Account(email, password) home = Folder("home", email, account.id) account.folders.append(home) db.session.add(account) db.session.commit() db.engine.dispose() registered = Account.query.filter_by(email=email).first() if not registered: response = jsonify({"success": False, "error": "Failed to save user"}) app.logger.error("Failed to create account %s.", account.email) return response, 500 login_user(registered) app.logger.info("Account: %s created", account.email) return jsonify({"success": True, "user_id": registered.id})
def save(self, commit=True): user = super(RegistrationForm, self).save() referrer = Account.get_referrer_by_code( self.cleaned_data.get('referral_code')) activation_code = str(uuid.uuid4()) acc = Account.objects.create(user_fk=user, referrer_fk=referrer, referral_code=str(uuid.uuid4()), activation_code=activation_code) smtpserver = smtplib.SMTP(EMAIL_HOST, EMAIL_PORT) smtpserver.ehlo() smtpserver.starttls() try: smtpserver.login(EMAIL_HOST_USER, EMAIL_HOST_PASSWORD) smtpserver.sendmail('Test', user.email, activation_code) except Exception: pass smtpserver.quit() if acc.referrer_fk: points = acc.referrer_fk.referrals.count() + 1 u = acc data_to_update = [] while (u is not None or u.referrer_fk is not None) and points > 0: rr = u.referrer_fk.referrer_fk if not rr: u.referrer_fk.points += points data_to_update.append(u.referrer_fk) break else: u.referrer_fk.points += 1 data_to_update.append(u.referrer_fk) points -= 1 u = u.referrer_fk Account.objects.bulk_update(data_to_update, ['points']) return user
def seed_command(): Currency.query.delete() click.echo('-----------------') click.echo('Remove currencies') for data in Currencies.data: obj = Currency(**data) db.session.add(obj) db.session.commit() click.echo('Currency ' + obj.symbol + ' created') Category.query.delete() click.echo('-----------------') click.echo('Remove categories') for data in Categories.data: obj = Category(**data) db.session.add(obj) db.session.commit() click.echo('Category ' + obj.name + ' created') Account.query.delete() click.echo('---------------') click.echo('Remove accounts') for data in Accounts.data: obj = Account(**data) db.session.add(obj) db.session.commit() click.echo('Account ' + obj.name + ' created')
def register(): form = RegistrationForm() if request.method == 'POST': # TODO: enclose in transaction if form.validate_on_submit(): username = request.form['username'] email = request.form['email'] passhash = Account.get_hashed_password(request.form['password']) query = sqlalchemy.text( 'insert into account (username, email, passhash) values (:username, :email, :passhash)' ) db.engine.execute(query.execution_options(autocommit=True), username=username, email=email, passhash=passhash) user = Account.query.filter_by(username=username).first() login_user(user) query = sqlalchemy.text( 'insert into Request_Prediction (user_id) values (:user_id)') db.engine.execute(query.execution_options(autocommit=True), user_id=current_user.id) # TODO: consider adding option to choose test case in UI import_csvs_by_filepath() return redirect(url_for('index')) return render_template('register.html', form=form)
def filter_users(): try: cur_user = Account(session['user']) if 'user' in session else None if len(request.form) > 0: users = Account.get_all_users(cur_user, filters=request.form, sort_by=request.form.get('sort_by')) if request.form.get('reversed') == 'on': users = reversed(users) else: users = Account.get_all_users(cur_user) return render_template('user_list.html', cur_user=cur_user, users=users) except Exception as e: return "Something went wrong! " + str(e)
def create_account(): if request.method == 'POST': cust_id = request.form.get('cust_id') account_type = request.form.get('type') amount = request.form.get('amount') customer = Customer.query.filter_by(cust_id=cust_id).first() if customer is None: flash("User does not exist", 'error') return redirect(url_for('main.create_account')) try: account = Account(amount=amount, type=account_type, customer=customer) status = AccountStatus(status="Active", message="account creation complete", customer=customer, account=account) db.session.add(account) db.session.add(status) db.session.commit() flash("Account creation initiated successfully", 'success') except Exception as e: print(e) flash("Something Went Wrong", 'error') return render_template("create_account.html")
def _wechatLoginByJSCode(self, app_name, code): if app_name == 'drawingboard': appid = config.WECHAT_LITEAPP_APPID appsecret = config.WECHAT_LITEAPP_SECRET elif app_name == 'eyes': appid = config.WECHAT_LITEAPP_EYES_APPID appsecret = config.WECHAT_LITEAPP_EYES_SECRET else: appid = '' appsecret = '' result = requests.get( config.WECHAT_LOGIN_BY_JSCODE_URL, { 'appid': appid, 'secret': appsecret, 'js_code': code, 'grant_type': 'authorization_code' }).json() openid = result.get('openid', '') if not openid: return None, None account = Account.get_or_create_by_liteapp_openid(app_name, openid) session = Session.update_or_create_session( account.id, result.get('session_key', ''), result.get('expires_in', 0) - config.SAFE_LOGIN_BUFFER) return account, session
def create_accounts(): payload = {'key': Config.API_KEY} for user in User.query.all(): response = requests.get( ('{}customers/{}/accounts').format(Config.API_URL, user.customer_id), params=payload, headers={'content-type': 'application/json'}) if response.status_code == 200 or response.status_code == 201: accounts = json.loads(response.text) for account in accounts: if Account.query.filter( Account.account_id == account["_id"]).first() is None: a_type = AccountType.query.filter( AccountType.name == account["type"]).first() if "account_number" in account: a_num = account["account_number"] else: a_num = "" new_account = Account(account_id=account["_id"], nickname=account["nickname"], rewards=account["rewards"], balance=account["balance"], account_number=a_num, user=user, account_type=a_type) db.session.add(new_account) db.session.commit()
def generate_fake_users(self, count): for _ in range(count): fake_user = forgery_py.internet.user_name(True) User(email=forgery_py.internet.email_address(), username=fake_user, password='******').save() fake_account = Account(name=forgery_py.name.company_name(), number=1234, currency=forgery_py.currency.code(), balance=2000, holder=fake_user).save() fake_date = datetime(2018, 1, 1).date() fake_amount = -100 ttype_name = TransactionType.query.filter_by(id=1).first().ttype for _ in range(24): fake_date = fake_date + timedelta(days=15) fake_amount = fake_amount - 10 Transaction(date=fake_date, amount=fake_amount, type=ttype_name, description='fake groceries', category='Household', subcategory='Groceries', tag='Routine', status=True, accountid=fake_account.id, payee='').save()
def signupverify(request): if request.method=="POST": inputname=request.POST.get('name') inputemail=request.POST.get('email') inputpass=request.POST.get('password') inputdobd=request.POST.get('bd') inputdobm=request.POST.get('bm') inputdoby=request.POST.get('by') try: account1=Account.objects.get(email=inputemail) return render(request,'error.html',{"error":"EMAIL IS ALREADY REGISTERED !!!"}) except: account1=Account(email=inputemail,password=inputpass,name=inputname,dob_d=inputdobd,dob_m=inputdobm,dob_y=inputdoby) account1.save() return render_to_response('loginpage.html',context_instance=RequestContext(request)) #return render(request,'success.html',{"message":"congrats","name":inputname}) '''
def test_account_crud(self): # Create account = Account(name='Foo', sites=['foo', 'bar']) db.session.add(account) db.session.commit() self.assertIn(account, Account.query.all()) self.assertIsInstance(account.uuid, unicode) self.assertIsInstance(account.sites, list) self.assertIsInstance(account.enabled, bool) self.assertIsInstance(account.created_at, DT.datetime) self.assertIsInstance(account.updated_at, DT.datetime) # Read account = Account.query.filter_by(id=account.id).first() self.assertEqual(account.name, 'Foo') self.assertEqual(account.sites, ['foo', 'bar']) self.assertTrue(account.enabled) # Update old_created_at = account.created_at old_updated_at = account.updated_at account.name = 'Bar' account.sites = ['spam', 'eggs'] account.enabled = False account = Account.query.filter_by(id=account.id).first() self.assertIsInstance(account, Account) self.assertEqual(account.name, 'Bar') self.assertEqual(account.sites, ['spam', 'eggs']) self.assertFalse(account.enabled) self.assertEqual(account.created_at, old_created_at) self.assertNotEqual(account.updated_at, old_updated_at) # Delete db.session.delete(account) count = Account.query.filter_by(id=account.id).count() self.assertEqual(0, count)
def save_user(user): o = Account() o.f_name = str(user['first_name']) o.l_name = str(user['last_name']) o.user_id = str(user['username']) o.email_address = str(user['email_address']) o.secret = str(user['secret']) o.otp_salt = str(user['otp_salt']) o.passwd_salt = str(crypto.gen_salt()) o.password = crypto.secure_pw(str(user['password']),o.passwd_salt,fast=True) o.save() return o
def test_beacon_valid_request_response(self): # Invalid account id returns empty response r = self.get_beacon(account_id="foo", page_url="http://foo.com/bar") self.assertIsInstance(r, dict) self.assertEqual(r.keys(), ['status']) # Create inactive account account = Account(name="Foo Bar", sites=["foo.com"], enabled=False) db.session.add(account) db.session.commit() # Inactive account returns empty response r = self.get_beacon(account_id=account.uuid, page_url="http://foo.com/bar") self.assertIsInstance(r, dict) self.assertEqual(r.keys(), ['status']) # Activate account account.enabled = True db.session.add(account) db.session.commit() # Active account with bad url returns empty response r = self.get_beacon(account_id=account.uuid, page_url="http://bad.com/bar") self.assertIsInstance(r, dict) self.assertEqual(r.keys(), ['status']) # Active account with good url returns new visitor id r = self.get_beacon(account_id=account.uuid, page_url="http://foo.com/bar") self.assertIn('visitor_id', r) visitor_id = r['visitor_id'] # Return submitted visitor id if provided r = self.get_beacon(account_id=account.uuid, page_url="http://foo.com/bar", visitor_id=visitor_id) self.assertEqual(visitor_id, r['visitor_id']) # Configure placeholders, components and segments for account rule = Rule(field="page_url", comparator="START_WITH", value="http://foo.com/yes") db.session.add(rule) segment = Segment(name="My Segment", rules=[rule]) db.session.add(segment) component = Component(name="My Component", segment=segment, markup="<h1>My Component</h1>") db.session.add(component) placeholder = Placeholder(name="My Placeholder", components=[component]) db.session.add(placeholder) db.session.add(account) account.placeholders = [placeholder] account.segments = [segment] db.session.commit() # Refresh objects in db session after commit db.session.refresh(account) db.session.refresh(rule) db.session.refresh(segment) db.session.refresh(component) db.session.refresh(placeholder) # Unknown placeholder ids returns empty set of components r = self.get_beacon(account_id=account.uuid, page_url="http://foo.com", visitor_id=visitor_id, placeholders="ape-foo") self.assertIn('components', r) self.assertEqual(dict(), r['components']) # Known placeholder ids with no matching components returns empty set of components placeholder_str = "ape-" + placeholder.uuid r = self.get_beacon(account_id=account.uuid, page_url="http://foo.com/nope", visitor_id=visitor_id, placeholders=placeholder_str) self.assertIn('components', r) self.assertEqual(dict(), r['components']) # Known placeholder ids with matching components returns set of components placeholder_str = "ape-" + placeholder.uuid r = self.get_beacon(account_id=account.uuid, page_url="http://foo.com/yes", visitor_id=visitor_id, placeholders=placeholder_str) self.assertIn('components', r) self.assertIn(placeholder_str, r['components']) self.assertIn('content', r['components'][placeholder_str]) self.assertEqual(component.markup, r['components'][placeholder_str]['content'])
def view(account): account = Account.get(account) return render('accounts/view.html', account=account)