class TestUser(unittest.TestCase):
def setUp(self):
self.user = User()
def test_initial_user_creation(self):
expected_default = {
'site_version': INITIAL_SITE_VERSION,
'connections': []
}
for key, value in expected_default.viewitems():
assert getattr(self.user, key, None) == value
def test_user_id_generation(self):
user1 = User()
user2 = User()
assert user2.get_id() == user1.get_id() + 1
def test_update_site_version_on_user(self):
self.user.update_site_version(INFECTED_SITE_VERSION)
assert self.user.site_version == INFECTED_SITE_VERSION
def test_add_user_connection(self):
another_user = User()
self.user.add_connection(another_user)
assert another_user in self.user.connections
def test_add_users_to_a_graph(self):
graph = Graph()
user = User()
user_id = user.get_id()
graph.add_user(user)
assert user_id in graph.users and graph.users[user_id] == user
def construct_graph_of_count(count):
graph = Graph()
user1 = User()
graph.add_user(user1)
for i in range(0, count-1):
user = User()
graph.add_user(user)
graph.connect_users(user1.get_id(), user.get_id())
return graph
def login_user():
email = request.form['email']
password = request.form['password']
if User.login_valid(email, password):
User.login(email)
else:
session['email'] = None
return render_template("profile.html", email=session['email'])
class TeacherGuestFarmState(GuestFarmState):
def __init__(self, client, input, gui, user):
super().__init__(client, input, gui, user)
def init(self):
super().init()
self.farm = Farm()
self.owner = User(self.client, "")
# CONTROL WINDOW
self.ctrl_window = Window(sf.Vector2(260, 0), 256, 128, sf.Color(50, 50, 120, 255), self.input)
self.add_button = Button(sf.Vector2(16, 0), "button", self.input, "add")
self.set_button = Button(sf.Vector2(144, 0), "button", self.input, "set")
self.points_textbox = Textbox(sf.Vector2(0, 64), 256, "amount of points", self.input)
self.ctrl_window.add_child(self.add_button)
self.ctrl_window.add_child(self.set_button)
self.ctrl_window.add_child(self.points_textbox)
self.gui_manager.add(self.ctrl_window)
def handle_packet(self, packet):
packet_id = packet.read()
if packet_id == const.PacketTypes.LOAD_FARM: # when you first get into the state
self.owner.deserialize(packet)
self.farm.deserialize(packet)
self.textbox.default_text = self.owner.user_name
self.textbox.text.string = self.owner.user_name
def render(self, target):
super().render(target)
def update(self, dt):
super().update(dt)
def on_mouse_button_pressed(self, mouse_button, x, y):
super().on_mouse_button_pressed(mouse_button, x, y)
if mouse_button == sf.Mouse.LEFT:
if self.gui_manager.point_over_element(self.add_button, x, y) is True:
packet = net.Packet()
packet.write(const.PacketTypes.ADD_POINTS)
packet.write(self.owner.user_name) # name of person
packet.write(self.points_textbox.last_text)
self.client.send(packet)
elif self.gui_manager.point_over_element(self.set_button, x, y) is True:
packet = net.Packet()
packet.write(const.PacketTypes.SET_POINTS)
packet.write(self.owner.user_name) # name of person
packet.write(self.points_textbox.last_text)
self.client.send(packet)
class GuestFarmState(ClientState):
def __init__(self, client, input, gui, user):
super().__init__(client, input, gui, user)
def init(self):
super().init()
self.farm = Farm()
self.owner = User(self.client, "")
# CONTROL WINDOW
self.load_button = Button(sf.Vector2(16, 0), "button", self.input, "load")
self.home_button = Button(sf.Vector2(144, 0), "button", self.input, "home")
self.textbox = Textbox(sf.Vector2(0, 64), 256, self.owner.user_name, self.input)
self.window = Window(sf.Vector2(0, 0), 256, 128, sf.Color(50, 50, 120, 255), self.input)
self.window.add_child(self.load_button)
self.window.add_child(self.home_button)
self.window.add_child(self.textbox)
self.gui_manager.add(self.window)
def handle_packet(self, packet):
packet_id = packet.read()
if packet_id == const.PacketTypes.LOAD_FARM: # when you first get into the state
self.owner.deserialize(packet)
self.farm.deserialize(packet)
self.textbox.default_text = self.owner.user_name
self.textbox.text.string = self.owner.user_name
def render(self, target):
super().render(target)
self.farm.draw(target)
def update(self, dt):
super().update(dt)
def on_mouse_button_pressed(self, mouse_button, x, y):
if mouse_button == sf.Mouse.LEFT:
if self.gui_manager.point_over_element(self.home_button, x, y) is True:
self.user.switch_state(const.GameStates.HOME_FARM)
elif self.gui_manager.point_over_element(self.load_button, x, y) is True:
if self.textbox.last_text != self.user.user_name:
print(self.textbox.last_text, self.user.user_name)
packet = net.Packet()
packet.write(const.PacketTypes.SWITCH_FARM)
packet.write(self.textbox.last_text)
self.client.send(packet)
def check(self, data):
ajaxResponse = {}
error = False
#Check for empty fields and bind specific error message
if not data['nickName']:
ajaxResponse['error_notif_nick'] = True
ajaxResponse['error_nick_msg'] = "You must enter a nickname"
error = True
if not data['email'] or not data['is_email']:
ajaxResponse['error_notif_mail'] = True
ajaxResponse['error_mail_msg'] = "You must enter a valid e-mail address"
error = True
if not data['password']:
ajaxResponse['error_notif_pass'] = True
ajaxResponse['error_pass_msg'] = "You must enter a password"
error = True
if not data['passValidate']:
ajaxResponse['error_notif_pass_confirm'] = True
ajaxResponse['error_pass_confirm_msg'] = "You must validate your password"
error = True
elif data['passValidate'] != data['password']:
ajaxResponse['error_notif_pass_confirm'] = True
ajaxResponse['error_pass_confirm_msg'] = "Passwords are not the same"
error = True
# All fields required are non empty
else:
#Check for an already existant user by nickname
if User.by_name(data['nickName']):
ajaxResponse['error_notif_nick'] = True
ajaxResponse['error_nick_msg'] = "This nickname is already used."
error = True
#Check for an already existant user by mail
if User.by_email(data['email']):
ajaxResponse['error_notif_mail'] = True
ajaxResponse['error_mail_msg'] = "This email address is already used."
error = True
#Prepare the response to the ajax request
ajaxResponse['error'] = error
return ajaxResponse
def create_new_book():
if request.method == 'GET':
return render_template('new_book.html')
else:
book_name = request.form['book_name']
user = User.get_by_email(session['email'])
new_book = Book(user.email, book_name, user._id)
new_book.save_to_mongo()
return make_response(user_books(user._id))
def view(self, res):
server_show(
"Receives the client's request to view the current directory file...",
"msg")
name = res[1]
psd = res[2]
user = User(name, psd)
dirs, files = user.view_file()
dir = str(dirs)
file = str(files)
if len(dirs) == 0:
self.request.sendall("False".encode("utf-8"))
else:
self.request.sendall(bytes(dir, encoding="utf-8"))
self.request.sendall(bytes(file, encoding="utf-8"))
self.request.recv(1024)
dic = User.info_read(name)
storage = str(dic["storage"])
self.request.sendall(bytes(storage, encoding="utf-8"))
server_show("Current directory file view success...", "info")
def applicationsBy(cls, userEmail):
try:
objectManager = applicationDatabaseManager.DatabaseManager()
user = User.findUserByEmail(userEmail)
if user.get('role').get('S') == 'administrator':
return objectManager.allApplications()
else:
return objectManager.applicationsForUser(userEmail)
except Exception as e:
logger.error('Database error: ' + str(e))
raise DatabaseConnectionFailed("Connection with the database failed, please try again later")
def get(self, project_id):
logged_in_user_id = get_jwt_identity()
logged_in_user = User.find_by_id(logged_in_user_id)
project = Project.find_by_project_id(project_id)
if not project:
return {'msg': 'Project not found'}, 404
if not logged_in_user_id:
return {'msg': 'User not found'}, 404
if logged_in_user.has_project(project):
members = [member.basicDetails() for member in project.members]
return {'members': members}, 200
return {'msg': 'Project not found in your account'}, 404
def post(self):
logged_in_user_id = get_jwt_identity()
logged_in_user = User.find_by_id(logged_in_user_id)
# claims = get_jwt_claims()
# if not claims['manager']:
# return {'msg': 'Manager rights needed'}, 403
data = ProjectAllocate.parser.parse_args()
proj = Project.find_by_project_id(data['project_id'])
user = User.find_by_id(data['user_id'])
if not user:
return {'msg': 'User not found'}, 404
if not proj:
return {'msg': 'Project not found'}, 404
if logged_in_user.has_project(proj):
proj.members.append(user)
proj.create_project()
return {'msg': 'Members added to project'}, 200
# Project(id=None, **data, owner=user).create_project()
return {'msg': 'Project not found in your account'}, 404
def upload(self, res):
server_show(
"Receive the request from the client to upload the file....",
"msg")
name = res[1]
filename = res[3]
self.request.sendall(bytes("True", encoding="utf-8"))
res = int(self.request.recv(1024).decode())
if User.receive(filename, name, res, self.request):
self.request.sendall(bytes("True", encoding="utf-8"))
else:
self.request.sendall(bytes("False", encoding="utf-8"))
def create_new_review(book_id):
if request.method == 'GET':
return render_template('new_review.html', book_id=book_id)
else:
title = request.form['title']
content = request.form['content']
user = User.get_by_email(session['email'])
new_review = Review(book_id, title, content, user.email)
new_review.save_to_mongo()
return make_response(book_reviews(book_id))
def test_remove_product(self): #ok
user1 = User("amir", 12)
user1.identifier = 0
store1 = Store("mega", 0, "456456", None, None)
store1.store_number = 1
product1 = Product('chocholate', 'Food', ['Food', 'Sweet'], 10)
product1.catalog_number = 1
store1.add_new_product(product1)
Ecommerce.get_instance().stores = [store1]
user1.state = State.GUEST
self.assertFalse(user1.remove_product(1, 1).val, "need return False")
user1.state = State.STORE_OWNER
self.assertTrue(user1.remove_product(1, 1), "need return True")
self.assertFalse(user1.remove_product(1, 10).val, "need return False")
def main():
user_selector = UserSelector()
with open('customers.json', 'r') as customer_file:
for customer in customer_file.readlines():
try:
user = User.from_dict(json.loads(customer.rstrip()))
user_selector.append(user)
except:
print('{} could not be converted to a user'.format(customer))
lucky_users = user_selector.sort_by_user_id()
for user in lucky_users:
print(user)
def get_user_by_username(self, username: str) -> User:
"""
Get user by username.
:param username: username of the user to be fetched
:rtype: User
"""
UserRecord = namedtuple('UserRecord', 'username, password_salt, password')
query = f'''SELECT username, password_salt, password from passwords WHERE username = '******' '''
try:
self.cur.execute(query)
user = User()
for user_fetched in map(UserRecord._make, self.cur.fetchall()):
user.username = user_fetched.username
user.password_salt = user_fetched.password_salt
user.password_hash = user_fetched.password
self.con.commit()
except Exception as e:
raise self.con.DatabaseError(f'User does not exist: {str(e)}')
return user
def test_update_user_name(self):
self._repo.get.return_value = Users.jack
new_name = "Captain Jack Sparrow"
self._service.update_user_name(Users.jack.id, new_name)
expected_saved_user = User(Users.jack.id, new_name,
Users.jack.date_of_birth)
self._repo.save.assert_called_once()
# call_args[0][0] is the first positional argument of the call
updated_user = self._repo.save.call_args[0][0]
# note: dataclass generates __eq__ that checks all fields
self.assertEqual(updated_user, expected_saved_user)
def add_user(self, first_name, last_name, username, email_address,
password):
""" Add User to DB """
if self.find_user(username, email_address) is None:
user = User(first_name=first_name,
last_name=last_name,
user_name=username,
email_address=email_address,
password=password)
self.database.add_user(user)
else:
raise RuntimeError('User already exists')
def test_header_table_date(self, mocker, offer_date, expected_date):
user = mocker.create_autospec(User(), spec_set=True)
user.name = ""
user.mail = ""
user.gender_suffix = ""
user.phone = ""
offer = Offer(user)
offer.date = offer_date
header_table = offer.header_table()
expected = f"Z dnia: {expected_date}<br />"
assert_that(header_table, contains_string(expected))
def test_login(self): #ok
user1 = User("amir", 324)
user1.register("amirdimri", "123456789")
Ecommerce.get_instance().subscribers = [user1]
self.assertTrue(
user1.login("amirdimri", "123456789").val, "need return True")
self.assertFalse(
user1.login("amirdimri", "123456789").val, "need return False")
def test_inc_product_amount(self): #ok
user1 = User("amir", 13)
user1.identifier = 0
store1 = Store("ramiLevi", 0, "123123", None, None)
store1.store_number = 0
product1 = Product('Banana', 'Fruits', ['Food', 'Fruit', 'Apple'], 5)
product1.catalog_number = 0
store1.add_new_product(product1)
Ecommerce.get_instance().stores = [store1]
user1.state = State.GUEST
self.assertFalse(
user1.inc_product_amount(0, 0, 3).val, "need return False")
user1.state = State.STORE_OWNER
self.assertTrue(
user1.inc_product_amount(0, 0, 3).val, "need return True")
self.assertFalse(
user1.inc_product_amount(100, 0, 3).val, "need return False")
self.assertFalse(
user1.inc_product_amount(0, 10, 3).val, "need return False")
def on_click(*params):
uid = params[0].uid
peer = bot.users.get_user_peer_by_id(uid)
if uid not in users:
users[uid] = User(uid)
users[uid].last_key = "hello"
bot.messaging.send_message(peer, phrases["hello"])
return
user = users[uid]
which_button = params[0].value
if which_button == "Yes":
del_buttons(bot, peer)
files = create_card(user)
print(send_mail(user.e_mail, files))
print(send_to_chat(bot, peer, files[0]))
del_file(files)
bot.messaging.send_message(
peer,
"Письмо с визиткой отправлено на вашу почту {0}!\nЕсли хотите создать новую визитку, нажмите на кнопку."
.format(user.e_mail), new_form())
user.lock_msg = True
return
elif which_button == "No":
group = edit_data()
del_buttons(bot, peer)
bot.messaging.send_message(peer, "Что Вы хотели бы исправить?", group)
user.lock_msg = True
return
elif which_button == "all":
user.last_key = "second_name"
del_buttons(bot, peer)
bot.messaging.send_message(peer, phrases["second_name"])
else:
user.last_key = "to_check_" + which_button
del_buttons(bot, peer)
bot.messaging.send_message(peer, phrases[which_button])
user.lock_msg = False
def put(self):
parser = copy.deepcopy(TaskRes.parser)
parser.add_argument('id', type=str, required=True,
help='ID Required')
data = parser.parse_args()
logged_in_user_id = get_jwt_identity()
logged_in_user = User.find_by_id(logged_in_user_id)
assigned_user = User.find_by_id(data['user_id'])
tsk = Task.find_by_taskID(data['id'])
proj = tsk.project if tsk else None
if proj and tsk:
if (not assigned_user or (assigned_user not in proj.members)):
return {'msg': 'Not a member of this project'}, 403
if logged_in_user.has_project(tsk.project):
tsk.subject = data['subject']
tsk.description = data['description']
tsk.status = Task.validateStatus(data['status'])
tsk.user_id = data['user_id']
tsk.save_to_db()
if (data['ref_image']):
data['ref_image'].save(f"assets/Projects/{tsk.id}" + data['ref_image'].filename)
return {'msg': 'Task updated successfully'}, 200
return {'msg': 'No such task found in this project'}, 404
def add_client(self, usr_obj: User):
if len(self._clients) < self._max_clients:
self._clients.append(usr_obj)
self.send_msg(
"server",
self._join_msg.replace("<nick>", usr_obj.get_nickname()))
else:
usr_obj.sock.send("FULL")
self.send_msg(
"server",
f"{usr_obj.get_nickname()} tried to join, but the room is full!"
)
def login():
"""Login page"""
if request.method == 'GET':
return render_template('login.jinja')
else:
result = actions.validate_account(request.form)
if result['success']:
user = User(request.form['username'], request.form['password'])
login_user(user)
return redirect(url_for('site_views.logged'))
else:
return render_template('login.jinja',
msg=result['message'],
succes=result['success'])
def test_header_table_symbol(self, mocker, symbol):
user = mocker.create_autospec(User(), spec_set=True)
user.name = ""
user.mail = ""
user.gender_suffix = ""
user.phone = ""
offer = Offer(user)
offer.date = date(2020, 12, 15)
offer.symbol = symbol
header_table = offer.header_table()
expected = f"Oferta nr: <b>{symbol}</b><br />"
assert_that(header_table, contains_string(expected))
def test_connect_users_in_a_graph(self):
graph = Graph()
user1 = User()
user2 = User()
graph.add_user(user1)
graph.add_user(user2)
graph.connect_users(user1.get_id(), user2.get_id())
assert user2 in user1.get_connections() and user1 in user2.get_connections()
def handle_route_request():
user_preferences = request.POST.get('userPreferences')
user_preferences = json.loads(user_preferences)
print(user_preferences['startLocation'])
print(user_preferences['distance'])
user = User(user_preferences)
reply = {}
reply["STATUS"] = "SUCCESS"
coordinates = user.process_user_setting()
print("coordinates", str(coordinates))
#reply["WAYPOINTS"] = [{"latitude": 43.733, "longitude": -73.26}, {"latitude": 43.133, "longitude": -73.96}]
return_mesg = []
for i in range(len(coordinates[0])):
waypoint_dict = {}
waypoint_dict['latitude'] = coordinates[0][i]
waypoint_dict['longitude'] = coordinates[1][i]
return_mesg.append(waypoint_dict)
print("return_mesg", return_mesg)
reply["WAYPOINTS"] = return_mesg
print(reply["WAYPOINTS"])
return json.dumps(reply)
def on_click(*params):
uid = params[0].uid
peer = bot.users.get_user_peer_by_id(uid)
if uid not in users:
users[uid] = User(uid)
users[uid].last_key = "hello"
bot.messaging.send_message(peer, phrases["hello"])
return
user = users[uid]
which_button = params[0].value
if which_button == "Yes":
f = open('text.txt', 'w')
for index in user.org:
f.write(user.org + '\n')
bot.messaging.send_message(
peer,
"Новые отзывы от {0} получены!\nЕсли хотите сделать это позже, то напишите мне снова."
.format(user.org))
user.lock_msg = True
return
elif which_button == "No":
group = edit_data()
del_buttons(bot, peer)
bot.messaging.send_message(peer, "Что Вы хотели бы исправить?", group)
user.lock_msg = True
return
elif which_button == "all":
user.last_key = "second_name"
del_buttons(bot, peer)
bot.messaging.send_message(peer, phrases["second_name"])
else:
user.last_key = "to_check_" + which_button
del_buttons(bot, peer)
bot.messaging.send_message(peer, phrases[which_button])
user.lock_msg = False
def get_user():
user = None
try:
response = requests.get('http://randomuser.me/api/')
if response.status_code == 404:
raise HttpNotFound()
result = response.json()
# prettyprinter.cpprint(result)
record = result['results'][0]
return User(record['name']['title'], record['name']['last'],
record['name']['first'], record['login']['username'],
record['email'])
except requests.exceptions.ConnectionError:
raise APIUnreachableException()
def load_config(path: Path) -> tuple:
parser = configparser.ConfigParser()
parser.read(path)
server_conf = parser['Server']
wallet_conf = parser['Wallet']
users = {}
for section in parser.sections():
type_ = section.split(':')[0]
if type_ == 'User':
section = parser[section]
users[section.name.split(':')[1]] = User.from_section(section)
return server_conf, wallet_conf, users
def init(self):
super().init()
self.farm = Farm()
self.owner = User(self.client, "")
# CONTROL WINDOW
self.ctrl_window = Window(sf.Vector2(260, 0), 256, 128, sf.Color(50, 50, 120, 255), self.input)
self.add_button = Button(sf.Vector2(16, 0), "button", self.input, "add")
self.set_button = Button(sf.Vector2(144, 0), "button", self.input, "set")
self.points_textbox = Textbox(sf.Vector2(0, 64), 256, "amount of points", self.input)
self.ctrl_window.add_child(self.add_button)
self.ctrl_window.add_child(self.set_button)
self.ctrl_window.add_child(self.points_textbox)
self.gui_manager.add(self.ctrl_window)
def login():
if request.method == 'POST':
userName = request.values.get('userName')
password = request.values.get('password')
#Validate user against password
if api.validateUser(userName, password):
#User is valid
userId = api.getUserId(userName)
flask_login.login_user(User(userId), remember=True)
return redirect(url_for('index'))
else:
#User isn't valid, return to login page GET
error = "User name and password combination invalid"
return redirect(url_for('login', error=error))
elif request.method == 'GET':
return render_template('login.html')
def main():
logging.info("pyOffer version %s started at %s", version, datetime.now())
locale_set = locale.setlocale(locale.LC_ALL, '')
logging.info("System locale: %s", locale_set)
app = QApplication(sys.argv)
app.setOrganizationName("KonserwSoft")
app.setApplicationName("pyOffer")
lang = QLocale.system().name()[0:2]
logging.info("Loading translation for: %s", lang)
translator = QTranslator()
if translator.load(f"translations/{lang}"):
app.installTranslator(translator)
logging.info("Loaded translations from: %s", f"translations/{lang}")
else:
logging.warning("Failed to load translations from: %s",
f"translations/{lang}")
settings = QSettings()
settings.beginGroup("database")
host_name = settings.value("host_name", "127.0.0.1")
port = int(settings.value("port", "5432"))
database_name = settings.value("database_name", "koferta_test")
user_name = settings.value("user_name", "postgres")
password = settings.value("password", "docker")
settings.endGroup()
try:
logging.info("DB host name: %s", host_name)
logging.info("DB port: %s", port)
logging.info("DB database name: %s", database_name)
logging.info("DB user name: %s", user_name)
database.connect(host_name, database_name, user_name, password, port)
except RuntimeError as e:
QMessageBox.critical(
None, app.tr("Database connection failed"),
app.tr(f"Driver error: {e.args[1]}\nDatabase error: {e.args[2]}"))
return str(e)
user_dialog = UserSelectionDialog.make()
if user_dialog.exec_() == QDialog.Accepted:
logging.debug("User dialog accepted")
user = User.from_sql_record(user_dialog.chosen_user_record)
logging.info("Chosen user: %s", user)
main_window = MainWindow(user)
main_window.show()
return app.exec_()
logging.info("User hasn't been chosen - exiting")
return 0
def init(self):
super().init()
self.farm = Farm()
self.owner = User(self.client, "")
# CONTROL WINDOW
self.load_button = Button(sf.Vector2(16, 0), "button", self.input, "load")
self.home_button = Button(sf.Vector2(144, 0), "button", self.input, "home")
self.textbox = Textbox(sf.Vector2(0, 64), 256, self.owner.user_name, self.input)
self.window = Window(sf.Vector2(0, 0), 256, 128, sf.Color(50, 50, 120, 255), self.input)
self.window.add_child(self.load_button)
self.window.add_child(self.home_button)
self.window.add_child(self.textbox)
self.gui_manager.add(self.window)
def run(cls):
user = User(input("Enter username: "******"3":
cls.display_board()
print("Choose from the following options: ")
print("1. Enter new order")
print("2. Delete an order")
print("3. Exit application")
selection = input("Enter a number and hit enter: ")
if selection == "1":
cls.entry_form(user.object_id)
elif selection == "2":
cls.delete_form()
def get(self):
parser = reqparse.RequestParser()
parser.add_argument('project_id', type=int, required=True,
help='Project ID Required')
data = parser.parse_args()
logged_in_user_id = get_jwt_identity()
logged_in_user = User.find_by_id(logged_in_user_id)
proj = Project.find_by_project_id(data['project_id'])
shared_filter = {'project_id': data['project_id']}
if logged_in_user.has_project(proj):
resp = {}
tsks = []
for task in Task.query.filter_by(status=TaskStatus.BLOCKED,
**shared_filter):
tsks.append(
task.json()
)
resp['blocked'] = tsks
tsks = []
for task in Task.query.filter_by(status=TaskStatus.TODO,
**shared_filter):
tsks.append(
task.json()
)
resp['to_do'] = tsks
tsks = []
for task in Task.query.filter_by(status=TaskStatus.INPROGRESS,
**shared_filter):
tsks.append(
task.json()
)
resp['in_progress'] = tsks
tsks = []
for task in Task.query.filter_by(status=TaskStatus.DONE,
**shared_filter):
tsks.append(
task.json()
)
resp['done'] = tsks
return resp, 200
return {'msg': 'No such project found in your account'}, 404
def setUp(self):
juan = User(name='Juan')
juan.gender = 'male'
juan.comments = [
{'text': 'Hola mundo', 'sentiment': 'pos'},
]
fatima = User(name='Fatima')
fatima.gender = 'female'
fatima.comments = [
{'text': 'Hola mundo', 'sentiment': 'pos'},
]
pedro = User(name='Pedro')
pedro.gender = 'male'
pedro.comments = [
{'text': 'Hola mundo', 'sentiment': 'neg'},
]
self.users = {
'1234': juan,
'1010': fatima,
'2222': pedro,
}
def test_header_table_author_no_phone(self, mocker, company, name, mail):
user = mocker.create_autospec(User(), spec_set=True)
user.name = name
user.mail = mail
user.phone = None
offer = Offer(user)
offer.company_address = company
offer.date = date(2020, 12, 15)
header_table = offer.header_table()
expected = f"""
<td width=315>
{company}<br />
<b>{name}</b><br />
{mail}<br />
"""
assert_that(header_table, contains_string(expected))
assert_that(header_table, not_(contains_string("Tel")))
def editMembers(self, members: List):
original_users = self.members
updated_users = []
if not members:
return
for mem in members:
uname = mem['username']
mem = User.find_by_username(uname)
if mem:
updated_users.append(mem)
if self.owner not in updated_users:
updated_users.append(self.owner)
# Above line is to prevent owner to to lose ownership
deleted_members = set(original_users) - set(updated_users)
new_members = set(updated_users) - set(original_users)
for member in deleted_members:
self.members.remove(member)
for member in new_members:
self.members.append(member)
def register_students(self):
filename = "content/users/all_registered_users.txt"
file = open(filename, 'r')
for line in file:
user = User(None, "")
values = line.split() # each word(value) in txt file
# create new student, add him to users list
user.user_type = values[0]
user.first_name = values[1]
user.last_name = values[2]
user.user_name = values[3]
user.password = values[4]
# get user data (points, inventory, farm)
self.load_user_data(user)
self.load_farm(user)
self.users[user.user_name] = user
from src.states.farm_state import GuestFarmState
from src.states.farm_state import TeacherGuestFarmState
from src.states.shop_state import ShopState
from src.states.statistics_state import StatisticsState
from src.user import User
# create the main window
window = sf.RenderWindow(sf.VideoMode(const.WINDOW_WIDTH, const.WINDOW_HEIGHT), "Koa Reforestation Client")
# Connect to server
client = net.Client("localhost", const.PORT)
input_sys = InputSystem(window)
gui = GUIManager()
user = User(client, "")
# make all the states
login = LoginState(client, input_sys, gui, user)
home = HomeFarmState(client, input_sys, gui, user)
guest = GuestFarmState(client, input_sys, gui, user)
teacher = TeacherGuestFarmState(client, input_sys, gui, user)
shop = ShopState(client, input_sys, gui, user)
stats = StatisticsState(client, input_sys, gui, user)
user.states = [login, home, guest, teacher, shop, stats]
user.state = const.GameStates.LOGIN
user.states[user.state].init()
clock = sf.Clock()
def setUp(self):
self.user = User()
def test_user_id_generation(self):
user1 = User()
user2 = User()
assert user2.get_id() == user1.get_id() + 1
