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)
