def edit_user(id):
data = data_defaults['user']['edit']
data['action']['url'] = data['action']['url'] % id
if request.method == 'GET':
data['user'] = Users().get_user(id)
return render_template('user_form.html', data=data)
if request.method == 'POST':
_input = g.form.copy()
_input['id'] = id
_input['modified_by'] = g.current_user['id']
u = Users().get_user(id)
if 'password' in _input and _input['password']:
_input['password'] = Auth().password_hash(
_input['confirm_password'])
else:
_input['password'] = u['password']
ok, messages = fswww().validate_user_properties(_input)
if not ok:
for m in messages:
flash(m)
return render_template('user_form.html', data={'user': _input})
id = Users().update_user(_input)
if id is not False:
url = '/users/edit/%d' % id
flash('user updated')
return redirect(url)
flash('unable to update user')
return render_template('user_form.html', data={'role': _input})
def test_edit_first_user_name(app):
if app.users.count() == 0:
app.users.create(Users(firstname="testuser"))
old_users = app.users.get_users_list()
index = randrange(len(old_users))
user = Users(firstname="New user", lastname=None)
user.id = old_users[index].id
app.users.edit_user_by_index(index, user)
new_users = app.users.get_users_list()
assert len(old_users) == len(new_users)
old_users[index] = user
assert sorted(old_users, key=Users.id_or_max) != sorted(
new_users, key=Users.id_or_max)
def delete_user_from_group(app):
new_group = db.get_group_list()
group = random.choice(new_group)
if len(db.get_users_list()) == 0:
app.users.create(
Users(firstname="somebody",
lastname="someone",
email="*****@*****.**",
homephone=12345,
workphone=123456,
mobilephone=1234567,
address="somewhere"))
elif len(db.get_group_list()) == 0:
app.create(Group(name="New group for user"))
elif len(db.get_users_in_group(group)) == 0:
app.add_user_to_group()
else:
ui_list = db.get_users_in_group(group)
random_user = random.choice(ui_list)
app.users.delete_user_from_group()
db_list = db.get_users_in_group(group)
ui_list.remove(random_user)
assert sorted(ui_list,
key=Group.id_or_max) == sorted(db_list,
key=Group.id_or_max)
def test_add_user_to_group(app):
if len(db.get_users_list()) == 0:
app.users.create(
Users(firstname="somebody",
lastname="someone",
email="*****@*****.**",
homephone=12345,
workphone=123456,
mobilephone=1234567,
address="somewhere"))
elif len(db.get_group_list()) == 0:
app.group.create(Group(name="New group for user"))
else:
old_user = db.get_users_list()
old_group = db.get_group_list()
if old_group:
new_group = db.get_group_list()
group = random.choice(new_group)
group_id = group.id
if old_user:
new_user = db.get_users_not_in_group(group)
random_user = random.choice(new_user)
id = random_user.id
ui_list = db.get_users_in_group(group)
app.users.add_user_to_group(id, group_id)
db_list = db.get_users_in_group(group)
ui_list.append(random_user)
assert sorted(ui_list, key=Group.id_or_max) == sorted(
db_list, key=Group.id_or_max)
def validate_account(form, db):
email = form.email.data
tmp_password = form.password.data
username = form.username.data
# randomly generate an 8 character permalink it should be unique
# create a random sequence of length 16. A mix of letters and digits.
permalink = ""
for x in range(16):
if random.randint(0, 11) <= 5:
permalink = permalink + random.choice(string.ascii_letters)
else:
permalink = permalink + random.choice(string.digits)
# Add a check to see if permalink is in database and loop until we create a permalink that is not
# hash the password before storing it inside the database for security concerns
password = bcrypt.hashpw(tmp_password.encode('utf8'), salt=bcrypt_salt).decode('utf8')
my_user = Users(email=email, password=password, username=username, permalink=permalink)
# check if checkpw works
print(bcrypt.checkpw(tmp_password.encode('utf8'), password.encode('utf8')))
db.session.add(my_user)
try:
db.session.commit()
return True
except IntegrityError:
# cancel all changes
db.session.rollback()
return False
def login(self, form):
u, p = form.get('username'), form.get('password')
user = Users().get_by_username(u)
print repr(user)
if not user or not Auth().authorize_user(user, p):
return False
return user
def get_users_from_view_page(self, index):
wd = self.app.wd
self.open_users_view_by_index(index)
text = wd.find_element_by_id("content").text
homephone = re.search("H: (.*)", text).group(1)
workphone = re.search("W: (.*)", text).group(1)
mobilephone = re.search("M: (.*)", text).group(1)
secondaryphone = re.search("P: (.*)", text).group(1)
return Users(homephone=homephone, workphone=workphone, mobilephone=mobilephone, secondaryphone=secondaryphone)
def addContact():
'''
Add a contact
{
"sender_id": "4",
"displayName": "Mohit",
"phoneNum": "8427434777",
"countryPhoneCode":"91"
}
'''
auth_header = request.headers.get('Authorization')
sub = jwtUtil.parse_decode_auth_token(auth_header, SECRETKEY)
req_json = request.get_json()
returnStatus = {"status": "SUCCESS"}
session = Session()
try:
contactJson = req_json['contact']
sender_id = contactJson['sender_id']
sender_name = contactJson['sender_name']
con_displayName = contactJson['display_name']
con_phone_Num = contactJson['phone_number']
country_phone_code = contactJson['country_phone_code']
if (sender_name == sub):
contact = Users(display_name=con_displayName,
phone_number=con_phone_Num,
country_code=country_phone_code,
contact_id=sender_id)
session.add(contact)
session.commit()
session.refresh(contact)
# schema = UserSchema(many = True)
# contactList = schema.dump(contact)
returnStatus.update({
"user_id":
contact.user_id,
"display_name":
contact.display_name,
"phone_number":
contact.phone_number,
"country_phone_code":
contact.country_phone_code
})
print(contact.user_id)
else:
returnStatus = {"status": "FAILURE"}
except Exception as e:
print(e)
returnStatus = {
"status":
"Some problem while adding contact, please check for duplicity"
}
finally:
#returnStatus = "Contact {0} added success fully".format(contact.user_id)
session.close()
return json.dumps(returnStatus)
def test_delete_some_user(app, db, check_ui):
if len(db.get_users_list()) == 0:
app.users.create(Users(firstname="testuser"))
old_users = db.get_users_list()
user = random.choice(old_users)
app.users.delete_user_by_id(user.id)
new_users = db.get_users_list()
assert len(old_users) - 1 == len(new_users)
old_users.remove(user)
assert old_users == new_users
if check_ui:
assert sorted(new_users, key=Users.id_or_max) == sorted(
app.group.get_users_list(), key=Users.id_or_max)
def get_users_list(self):
list = []
cursor = self.connection.cursor()
try:
cursor.execute(
"select id, firstname, lastname from addressbook where deprecated='0000-00-00 00:00:00'"
)
for row in cursor:
(id, firstname, lastname) = row
list.append(
Users(id=str(id), firstname=firstname, lastname=lastname))
finally:
cursor.close()
return list
def get_users_info_from_edit_page(self, index):
wd = self.app.wd
self.open_users_to_edit_by_index(index)
firstname = wd.find_element_by_name("firstname").get_attribute("value")
lastname = wd.find_element_by_name("lastname").get_attribute("value")
id = wd.find_element_by_name("id").get_attribute("value")
homephone = wd.find_element_by_name("home").get_attribute("value")
workphone = wd.find_element_by_name("work").get_attribute("value")
mobilephone = wd.find_element_by_name("mobile").get_attribute("value")
secondaryphone = wd.find_element_by_name("phone2").get_attribute("value")
address = wd.find_element_by_name("address").text
email = wd.find_element_by_name("email").get_attribute("value")
email2 = wd.find_element_by_name("email2").get_attribute("value")
email3 = wd.find_element_by_name("email3").get_attribute("value")
return Users(firstname=firstname,lastname=lastname, id=id, homephone=homephone, workphone=workphone,address=address,
mobilephone=mobilephone, secondaryphone=secondaryphone, email=email, email2=email2, email3=email3)
def get_users_list(self):
if self.user_cache is None:
wd = self.app.wd
self.open_webpage()
self.user_cache = []
for row in wd.find_elements_by_name("entry"):
cells = row.find_elements_by_tag_name("td")
firstname = cells[2].text
lastname = cells[1].text
id = cells[0].find_element_by_tag_name("input").get_attribute("value")
address = cells[3].text
all_phones = cells[5].text
all_emails = cells[4].text
self.user_cache.append(Users(firstname=firstname, lastname=lastname, id=id, address=address,
all_phones_from_home_page=all_phones, all_emails_from_home_page=all_emails))
return list(self.user_cache)
def get_user_info_by_id(self, id):
wd = self.app.wd
self.app.open_home_page()
row = wd.find_element_by_xpath('//td/*[@id="' + id + '"]/../..')
cells = row.find_elements_by_tag_name("td")
id = cells[0].find_element_by_tag_name("input").get_attribute("value")
firstname = cells[2].text
lastname = cells[1].text
address = cells[3].text
all_emails = cells[4].text
all_phones = cells[5].text
return Users(id=id,
firstname=firstname,
lastname=lastname,
address=address,
all_emails_from_home_page=all_emails,
all_phones_from_home_page=all_phones)
def signup():
"""
curl -d '{"name":"greenbear", "id":"greenbear", "passwd": "greenbear"}' -H "Content-Type: application/json" -X POST http://localhost:5000/users/signup
- 만약, create_user가 있다면 singup으로 redirect => 신규 id 생성으로 요청
- 그렇지 않다면, user 생성 후, login 페이지로 redirect
:return:
"""
logger_info(f"[{request.remote_addr}] {request.method}")
if request.method == "POST":
logger_info(f"request.json: {request.json}")
logger_info(f"request.form: {request.form}")
if request.json:
if not request.json or not 'id' in request.json:
logger_info(f"400 error : {request}")
abort(400)
logger_info(f"request params: {request.json}")
with session_scope() as db_session:
if request.json:
user_id = request.json.get('id')
user_name = request.json.get('name')
user_pw = request.json.get('pw')
else:
user_id = request.form.get('id')
user_name = request.form.get('name')
user_pw = request.form.get('pw')
user = db_session.query(Users).filter_by(id=user_id).first()
if user:
# 만약 기존 user가 있다면, 신규 ID로 user를 생성할 수 있도록 다시 redirect
logger_info(
f"{user._asdict()} is already. try signup with new_user")
flash("user id already exists.")
return redirect(url_for('users.signup'))
user_pw = (bcrypt.hashpw(user_pw.encode('UTF-8'),
bcrypt.gensalt())).decode('utf-8')
cret_dt = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
new_user = Users(user_id, user_name, user_pw, cret_dt)
db_session.add(new_user)
logger_info(f"create new_user: {new_user.id}")
return redirect(url_for('users.login'))
elif request.method == "GET":
return render_template("signup_form.html")
def register():
'''
Add a User
{
"display_name": "Mohit",
"phone_number": "8427434777",
"country_phone_code":"91",
callback_url : "hdjkfhkdjsf",
telesign_customer_id : "ghdkjafhjd",
telesign_api_key : "jsdhfjkhsdfkj",
password : "******"
}
'''
req_json = request.get_json()
returnStatus = "status: User created successfully"
session = Session()
try:
userJson = req_json['contact']
user_displayName = userJson['display_name']
phone_Num = userJson['phone_number']
country_phone_code = userJson['country_phone_code']
callback_url = userJson['callback_url']
telesign_customer_id = userJson['telesign_customer_id']
telesign_api_key = userJson['telesign_api_key']
password = userJson['password']
newUser = Users(display_name=user_displayName,
phone_number=phone_Num,
country_code=country_phone_code,
callback_url=callback_url,
ts_cust_id=telesign_customer_id,
ts_api_key=telesign_api_key,
password=password)
session.add(newUser)
session.commit()
except Exception as e:
print(e)
returnStatus = "status: Some problem while registering user, please check for duplicity"
finally:
returnStatus = "status: Registration successfull"
#returnStatus = "Contact {0} added success fully".format(contact.user_id)
session.close()
return json.dumps(returnStatus)
def create_user():
data = data_defaults['user']['create']
if request.method == 'GET':
return render_template('user_form.html', data=data)
if request.method == 'POST':
_input = g.form.copy()
_input['modified_by'] = g.current_user['id']
ok, messages = fswww().validate_user_properties(_input)
if not ok:
for m in messages:
flash(m)
return render_template('user_form.html', data={'user': _input})
id = Users().create_user(_input)
if id is not False:
url = '/user/edit/%d' % id
flash('user created')
return redirect(url)
flash('unable to create user')
return render_template('user_form.html', data={'user': _input})
def test_delete_some_user(app, db, check_ui):
if len(db.get_users_list()) == 0:
app.users.create(
Users(firstname="somebody",
lastname="someone",
email="*****@*****.**",
homephone=12345,
workphone=123456,
mobilephone=1234567,
address="somewhere"))
old_users = db.get_users_list()
user = random.choice(old_users)
app.users.delete_user_by_id(user.id)
new_users = db.get_users_list()
assert len(old_users) - 1 == len(new_users)
old_users.remove(user)
assert old_users == new_users
if check_ui:
assert sorted(new_users, key=Users.id_or_max) == sorted(
app.group.get_users_list(), key=Users.id_or_max)
from controller.expense_controller import ExpenseController
from controller.user_controller import UserController
from model.expenses import Expenses
from model.users import Users
from view.login_window import *
from view.main_window import *
if __name__ == "__main__":
# Create databases
users = Users()
expenses = Expenses()
# Load database content from file
load_database_from_file(users, expenses)
# Create controller instances
user_controller = UserController(users)
expense_controller = ExpenseController(expenses)
# Create login windows, other windows are created from there
login_window = LoginWindow(user_controller, expense_controller)
login_window.execute()
def convert(user):
return Users(id=str(user.id), firstname=user.firstname, lastname=user.lastname, email=user.email)
[random.choice(symbols) for i in range(random.randrange(maxlen))])
def random_digits(prefix, maxlen):
digits = string.digits
return prefix + "".join(
[random.choice(digits) for i in range(random.randrange(maxlen))])
testdata = [
Users(firstname="",
lastname="",
homephone="",
workphone="",
mobilephone="",
secondaryphone="",
address="",
email="",
email2="",
email3="",
id=None)
] + [
Users(firstname=random_string("firstname", 10),
lastname=random_string("lastname", 20),
homephone=random_digits("home", 20),
workphone=random_digits("work", 20),
mobilephone=random_digits("mobile", 20),
secondaryphone=random_digits("phone2", 20),
address=random_string("address", 10),
email=random_string("email", 10),
email2=random_string("email2", 10),
from model.users import Users
testuserdata = [
Users(firstname="firstname1",
lastname="lastname1",
homephone="homephone1",
mobilephone="mobilephone1",
workphone="workphone1",
address="address1",
secondaryphone="secondaryphone1",
email="email1",
email2="email21",
email3="email31"),
Users(firstname="firstname2",
lastname="lastname2",
homephone="homephone2",
mobilephone="mobilephone2",
workphone="workphone2",
address="address2",
secondaryphone="secondaryphone2",
email="email2",
email2="email22",
email3="email32")
]
def test_new_user(app):
'''
Сценарий должен состоять из следующих частей:
1) регистрация новой учётной записи с достаточно уникальным адресом электронной почты
(чтобы не конфликтовало с ранее созданными пользователями, в том числе при предыдущих запусках того же самого сценария),
2) выход (logout), потому что после успешной регистрации автоматически происходит вход,
3) повторный вход в только что созданную учётную запись,
4) и ещё раз выход.
В качестве страны выбирайте United States, штат произвольный. При этом формат индекса -- пять цифр.
Можно оформить сценарий либо как тест, либо как отдельный исполняемый файл.
'''
# Цель - зарегистрировать нового пользователя
# открыть страницу магазина
app.session.open_home_page()
# открыть поле для новых пользователей.
app.driver.find_element_by_css_selector(
'#box-account-login tr:nth-child(5)').click()
# заполнить поля
email = ''
for index in range(0, 11):
email += str(randrange(0, 9))
phone = email
email += '@mail.ru'
app.users.fill_fields(
Users(
# company='1223',
firstname='123',
lastname='23',
address1='123',
postcode='12345',
city='123',
country_code='United States',
# zone_code="Colorado",
email=email,
phone=phone,
password=phone,
confirmed_password=phone))
# нажать на кнопку "создать аккаунт"
app.users.create_account()
# нажать логаут
app.driver.find_element_by_css_selector(
'.list-vertical li:nth-child(4) > a').click()
# залогиниться
app.driver.find_element_by_css_selector("input[name='email']").click()
app.driver.find_element_by_css_selector("input[name='email']").send_keys(
email)
app.driver.find_element_by_css_selector("input[name='password']").click()
app.driver.find_element_by_css_selector(
"input[name='password']").send_keys(phone)
app.driver.find_element_by_css_selector("button[name='login']").click()
# проверить, что открылась нужная страница
# Ещё раз выход
app.driver.find_element_by_css_selector(
'.list-vertical li:nth-child(4) > a').click()
from model.users import Users
testdata = [
Users(firstname="firstname1",
lastname="lastname1",
email="email1",
homephone="homephone1",
workphone="workphone1",
mobilephone="mobilephone1",
address="address1"),
Users(firstname="firstname2",
lastname="lastname2",
email="email2",
homephone="homephone2",
workphone="workphone2",
mobilephone="mobilephone2",
address="address2")
]
def list_users():
users = Users().get_all_users()
data = {'users': users}
return render_template('users.html', data=data)
import os
from blueprints.movies import movies
from blueprints.series import series
from blueprints.users import users
from blueprints.health import health
from model.movies import Movies
from model.series import Series
from model.users import Users
from model.health import Health
app = Flask(__name__)
app.secret_key = "asdas"
app.movies = Movies()
app.series = Series()
app.users = Users()
app.health = Health()
@app.route('/')
def hello_world():
return 'Hello continuous delivery!'
app.register_blueprint(movies, url_prefix='/movies')
app.register_blueprint(series, url_prefix='/series')
app.register_blueprint(users, url_prefix='/users')
app.register_blueprint(health, url_prefix='/health')
if __name__ == '__main__':
app.run(host='0.0.0.0', port=os.getenv('PORT', None))
app = Flask(__name__)
# helper functions
def error_message(message):
if type(message) != str:
message = "error"
code = 400
elif message == "invalid JSON":
code = 400
elif message == "id not found":
code = 404
return jsonify({"error_message": message}), code
users_db = Users()
manager = EncryptionManager()
# Flask endpoints
@app.route('/')
def home():
return 'Hello, World!'
@app.route('/healthcheck')
def health_check():
return jsonify({"alive": True})
@app.route('/users', methods=['POST', 'GET'])
n = 4
f = "data/users.json"
for o, a in opts:
if o =="-n":
n = int(a)
elif o == "-f":
f = a
def random_string(prefix, maxlen):
symbols = string.ascii_letters + string.digits + " "*10
return prefix + "".join([random.choice(symbols) for i in range(random.randrange(maxlen))])
testdata = [Users(firstname="", lastname="", email="", homephone="", workphone="",
mobilephone="", address="")] + [
Users(firstname=random_string("fname ", 7), lastname=random_string("lname ", 10),
email=random_string("email ", 12), homephone=random_string("home ", 6),
workphone=random_string("work ", 6), mobilephone=random_string("mobile ", 9),
address=random_string("", 8))
for i in range(n)
]
file = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", f)
with open(file, "w") as f_out:
jsonpickle.set_encoder_options("json", indent=2)
f_out.write(jsonpickle.encode(testdata))
