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 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 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 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 create_account(email: str,
password: str,
first_name: str,
last_name: str,
fsuid: str,
course_list: list = []):
"""
Creates an account for a single user.
:email: Required, the email address of the user.
:password: Required, user's chosen password.
:first_name: Required, user's first name.
:last_name: Required, user's last name.
:fsuid: Optional, user's FSUID.
:course_list: Optional, courses being taken by user
:return: Account object.
"""
account = Account(email=email,
first_name=first_name,
last_name=last_name,
fsuid=fsuid,
is_admin=False)
# Set user's extra credit courses
course_util.set_courses(account, course_list)
account.set_password(password)
account.save()
return account
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 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 generate_accounts():
Account.query.delete()
account_numbers = []
count = 0
for x in range(0, 10):
for name in names:
account_number, balance, date = account_values()
while account_number in account_numbers:
account_number, balance, date = account_values()
account_numbers.append(account_number)
custodian = random.choice(custodians)
payment_source = random.choice(payment_sources)
household, billing_group, fee_structure = sample_household_billing_group_fees(
)
account = Account(name=name,
account_number=account_number,
custodian=custodian,
opening_date=date,
balance=balance,
payment_source=payment_source,
household=household,
billing_group=billing_group,
fee_structure=fee_structure)
db.session.add(account)
def users(db):
"""
Create user fixtures. They reset per test
:param db: Pytest fixture
:return: SQLAlchemy database session
"""
db.session.query(Account).delete()
users = [
{
"first_name": "Admin",
"last_name": "Dummy",
"username": "******",
"password": encrypt_password("password"),
},
{
"first_name": "Disabled",
"last_name": "Dummy",
"username": "******",
"password": encrypt_password("password"),
"active": False,
},
]
for user in users:
db.session.add(Account(**user))
db.session.commit()
return db
def db(app):
"""
Setup our database, this only gets executed once per session
:param app: Pytest fixture
:return: SQLAlchemy database session
"""
_db.drop_all()
_db.create_all()
# Create a single user because a lot of tests do not mutate this user.
# It will result in faster tests.
params = {
"first_name": "Admin",
"last_name": "Dummy",
"username": "******",
"password": encrypt_password("password"),
}
admin = Account(**params)
_db.session.add(admin)
_db.session.commit()
return _db
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 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 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 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 register_user(request):
msg = None
success = False
if request.method == "POST":
form = SignUpForm(request.POST)
if form.is_valid():
form.save()
username = form.cleaned_data.get("username")
raw_password = form.cleaned_data.get("password1")
user = authenticate(username=username, password=raw_password)
account = Account(user_id=str(form.cleaned_data['username']))
account.save(force_insert=True)
account.full_clean()
msg = 'User created.'
success = True
#return redirect("/login/")
else:
msg = 'Form is not valid'
else:
form = SignUpForm()
return render(request, "accounts/register.html", {"form": form, "msg" : msg, "success" : success })
def create_user():
"""
Creates and adds a new user
:return: dict
"""
data = request.get_json()
username = data.get("username")
if Account.find(username):
return {"error": "User already exists"}, 403
# print("================================")
# print(request.data)
# print("================================")
# print(request.get_json())
encrypted_password = encrypt_password(data["password"])
user = Account(
extl_ref_id=data.get("extl_ref_id"),
first_name=data.get("first_name"),
last_name=data.get("last_name"),
username=data.get("username"),
password=encrypted_password,
)
user.save()
login_user(user, remember=True)
return {
"status": "success",
"user": user.get_dict(),
"token": user.serialize_token(),
}
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 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 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 chat_list():
user = Account(session['user'])
if not user:
flash('Please, fill in information about yourself', 'info')
return redirect(url_for('settings'))
chats = Chat.get_chats(session['user'])
print(chats)
return render_template('chat-list.html', cur_user=user, chats=chats)
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 register_process(request):
account = Account()
account.name = request.POST['name']
account.id_number = request.POST['id_number']
account.save()
return redirect("/")
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 index():
if 'user' in session:
user = Account(session['user'])
if not user:
flash('Please, fill in information about yourself', 'info')
return redirect(url_for('settings'))
else:
user = None
return render_template('index.html', cur_user=user)
def register():
form = RegistrationForm()
if form.validate_on_submit():
user = Account()
form.populate_obj(user)
db.session.add(user)
db.session.commit()
login_user(user)
return redirect(url_for('tracking.index'))
return render_template('register.html', form=form)
def post(self, args):
account = Account(**args)
db.session.add(account)
try:
db.session.commit()
except Exception as e:
return error({}, 422, errors={'email': [str(e)]})
result = account_schema.dump(account)
return result.data, 201
def register():
form = RegistrationForm()
if form.validate_on_submit():
user = Account(username=form.username.data,
password=form.password.data)
db.session.add(user)
db.session.commit()
flash('Вы успешно зарегистрированы')
return redirect(url_for('login'))
return render_template('register.html', title='Register', form=form)
def chat_page(user_id):
try:
recipient = Account(user_id)
except AssertionError:
flash('No user with this id!', 'danger')
return redirect(url_for('index'))
cur_user = Account(session["user"])
if not cur_user:
flash('Please, fill in information about yourself', 'info')
return redirect(url_for('settings'))
if user_id not in cur_user.liked or cur_user.id not in recipient.liked:
flash("You should like each other before chatting", 'danger')
return redirect(url_for('profile', user_id=recipient.id))
chat = Chat(cur_user.id, recipient.id)
return render_template('chat.html',
cur_user=cur_user,
user=recipient,
chat=chat)
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 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('/')
