def test_upd_member_profile(self, keep_member=False):
"""Positive test: Update a new Member"""
# create a member
new_id = self.test_add_new_member(keep_member=True)
member = Member(id=new_id)
current_avatarUrl = member["avatar_url"]
current_username = member["username"]
# call update API
url = "{}/member/openid/{}".format(self.base_url, member["openid"])
print("Path:", url)
patch = {
"op": "update",
"data": {
"avatarUrl": "https://new/link/to_avatar.html",
'nickName': "new_nickName",
'tags': 5
}
}
response = requests.patch(url, json=patch)
self.assertEqual(200, response.status_code)
result = response.json()
self.print_JSON(result, title="test_upd_member_profile:")
# fetch record again
member = Member(id=new_id)
upd_avatarUrl = member["avatar_url"]
upd_username = member["username"]
self.assertNotEqual(current_avatarUrl, upd_avatarUrl)
self.assertNotEqual(current_username, upd_username)
self.assertEqual("new_nickName", upd_username)
if not keep_member: self.delete_member(new_id)
def test_add_payment(self, keep_member=False):
"""Positive test: add a payment to a new Member"""
# create a member
new_id = self.test_add_new_member(keep_member=True)
member = Member(id=new_id, db_access="../../Private/db_access.data")
# call update API
url = "{}/member/openid/{}".format(self.base_url, member["openid"])
print("Path:", url)
patch = {
"op": "add",
"data": {
'paidTime':
datetime.now().strftime('%Y%m%d%H%M'), # '201803121929',
'payIndex': 'this_is_craaaazy_____',
'CNYAmount': 123.45,
'payType': 'DONATION'
}
}
response = requests.patch(url, json=patch)
self.assertEqual(200, response.status_code)
result = response.json()
self.print_JSON(result, title="test_add_payment:")
# fetch record again
member = Member(id=new_id, db_access="../../Private/db_access.data")
print(member.transactions)
if not keep_member: self.delete_member(new_id)
def test_send_back(self):
librarian = Librarian()
librarian.add_book("xxxx", "b")
member1 = Member()
member2 = Member()
# can send back a book
book = member1.borrow("xxxx")
self.assertEqual(book.is_borrowed, True)
self.assertEqual(member1.number_book_borrowed, 1)
member1.send_back("xxxx")
self.assertEqual(book.is_borrowed, False)
self.assertEqual(member1.number_book_borrowed, 0)
# can't send back a book that is not yours
book = member1.borrow("xxxx")
self.assertEqual(book.is_borrowed, True)
member2.send_back("xxxx")
self.assertEqual(book.is_borrowed, True)
member1.send_back("xxxx")
self.assertEqual(book.is_borrowed, False)
# can't send back a book not borrowed
book = member1.send_back("xxxx")
self.assertIsNone(book)
def test_choose_member(self):
m1 = Member("foo")
m2 = Member("Bar")
m3 = Member("Baz")
members = [m1, m2, m3]
member = choose_member_from(members)
assert_that([member.display_name
for member in members]).contains(member.display_name)
def login_menu(self):
""" Display Login options for users to choose.
:return: True
"""
print("\n**** LOGIN MENU ****")
print(
"1. Login as BDO \n2. Login as GPM \n3. Login as Member\n4. Exit")
choice = input("Choose: ")
if choice == '1':
BlockDevelopmentOfficer(self.conn).login_bdo()
elif choice == '2':
GramPanchayatMember(self.conn).login_gpm()
elif choice == '3':
Member(self.conn).login_member()
elif choice == '4':
print("\nExiting...")
self.conn.close()
else:
print("\nWrong Input! Try again.")
if choice != '4':
self.login_menu()
return True
def handle_server_notification(self, socket):
message = socket.recv(4096)
if message:
# debug message to print the message sent by tracker
# print 'Tracker [' + str(socket.getpeername()) + '] sent notification "' + str(message) + '"'
notification = message.split("\t")
operation = notification[0]
group_name = notification[1]
group = self.group_list[group_name]
member_info = notification[2].split(',')
# add the new member to client's group view in order to be
# able to send him messages
if operation == 'add':
new_member = Member(member_info[0], member_info[1],
member_info[2], member_info[3],
member_info[4])
group.add_member(new_member)
# remove the member from client's group view
elif operation == 'remove':
member_name = member_info[1]
group.remove_member_by_name(member_name)
else:
print '[handle_server_notification] Operation not supported'
sys.exit(2)
def test_d_has_many_activities_returns_true_with_more_than_one_activity(
self):
member = Member('id', 'first_name', 'last_name', 'birth_date')
member.add_activity('activity1', 'location1', 'start_date1', 'cost1')
member.add_activity('activity2', 'location2', 'start_date2', 'cost2')
returned = member.has_many_activities()
assert returned == True
def test_login_member_failure_sql_error(self, inputs):
""" Test login member method."""
inputs.side_effect = ['id', 'pswd']
with mock.patch('member.sqlite3.connect') as mocksql:
mocksql.execute.side_effect = sqlite3.Error
assert Member(mocksql).login_member() == False
def option_four(self, coop):
try:
name = input("Enter name:")
except ValueError:
print("Error in input name")
return 0
try:
contact = int(input("Enter contact:"))
except ValueError:
print("Error in input contact")
return 0
date = self.correct_date('day of birth')
try:
money = input("Enter monthly income to nearest whole number or <Enter> if not disclosing: ")
if money == '':
money = None
else:
money = int(money)
except ValueError:
print("Error in input monthly income")
return 0
try:
coop.addMember(Member(name, contact, date, money))
print(coop.membersStr())
print("Add member operation successful")
except UnboundLocalError:
print("Operation is not successful")
def get_member(id):
"""Display the form in R/O mode for a member"""
member = Member(id)
qr_file = "images/XCJ_{}.png".format(id)
if member['status'] == "OK":
try:
last_modif_time = stat(qr_file).st_mtime
make_qr_code = datetime.fromtimestamp(
last_modif_time) < datetime.now().replace(
minute=0, hour=0, second=0, microsecond=0)
except (FileNotFoundError, AttributeError) as err:
make_qr_code = True
if make_qr_code:
qrcode_text = member.encode_qrcode()
img = make_qrcode(qrcode_text)
img.save(qr_file)
member.qrcode_is_valid = True
else:
member.qrcode_is_valid = False
copy2("images/emoji-not-happy.jpg",
qr_file) # overwrite any previous QR code .png
return template("member",
member=member,
read_only=True,
session=session_manager.get_session())
def _collect_sys_members (self, dtype, hparam, default, has_bulkice):
''' collect all set members for a specific data type
and a specific discrete parameter
:param hparam (str): name of the discrete systematics
:param dtype (str): name of the given member
:param default (dict): keys:default values of discrete systematics
:param has_bulkice (bool): If True, include bulk ice off axis points
:return members (`Map`): dictionary with all `Members` objects
'''
set_members = Map ({})
sets = get_sets (dtype, hparam, has_bulkice=has_bulkice)
for s in sets:
setid, setvalues = self._get_setvalues (s, dtype,
hparam, default)
isdef = self._check_setid (setid, default)
## don't waste time if it is the default set and already stored
if setid in set_members:
if not defid == setid:
message = 'Library:' + fname + \
' : WARNING : setid (' + setid + \
') already exist in the dictionary !'
print ('{0}'.format (message))
continue
set_members [setid] = Member (dtype, self.ppath,
ranges=self._ranges,
baseline=False,
isdragon=self.isdragon,
sysvalues=setvalues)
return set_members
def fillMembersArray(self):
self.loadDataPath()
try:
with open(self.current_selected_path + '/members.json',
'r') as file:
data = file.read()
members_dict = json.loads(data)
except:
print('No path')
members_dict = []
for member in members_dict:
if "shortname" in member:
shortname = member['shortname']
else:
shortname = "404"
tmp_member = Member([
member['firstname'], member['middlename'], member['lastname'],
shortname
], member['birthday'], member['statements'],
self.current_selected_path)
self.members.append(tmp_member)
def test_add_new_member(self, keep_member=False):
"""POST new member profile"""
url = "{}/member/new".format(self.base_url)
print("Path:", url)
openid = datetime.now().strftime('%Y%m%d%H%M%S.%f')
minimum_data = {
"openid": openid,
"avatarUrl":
"https://wx.qlogo.cn/mmopen/vi_32/GPm0HkJtcIsWkZmVNaxJP19ibl1g2YJTEibglP0UibOZstaRN1lbuMavu1a1Y795p6J1vHz0bM27icibCiat9ERricyng/0",
'basicInfo': {
'nickName': "test_" + openid,
'country': "China",
'gender': 1,
'language': "zh_CN",
},
'memberInfo': {
'tags': 'Master'
}
}
response = requests.post(url, json=minimum_data)
self.assertEqual(200, response.status_code)
result = response.json()
self.print_JSON(result, title="test_add_new_member:")
self.assertEqual('1000', result['errno'])
new_id = result['data']['new_id']
member = Member(new_id, db_access="../../Private/db_access.data")
print("Created as [role:", member['role'], "] with status:",
member["status"])
self.assertEqual('NOT_OK', member["status"])
if not keep_member: self.delete_member(new_id)
return new_id
def delete_member(self, id):
m = Member(id)
for t in m.transactions:
trec = Transaction(t['id'])
trec.delete()
m.delete()
print("deleted row", id)
def test_upd_unknown_field_member(self, keep_member=False):
"""
Positive Test: try to update an unknown field for a given Member
The fields not declared in Member_Api.API_MAPPING_TO_DB are ignored
"""
# create a member
new_id = self.test_add_new_member(keep_member=True)
member = Member(id=new_id)
# call update API
url = "{}/member/openid/{}".format(self.base_url, member["openid"])
print("Path:", url)
patch = {
"op": "update",
"data": {
"avatarUrl": "https://new/link/to_avatar.html",
'nickName': "new_nickName",
"unknow_field___": "incorrect field"
}
}
response = requests.patch(url, json=patch)
self.assertEqual(200, response.status_code)
result = response.json()
self.print_JSON(result, title="test_upd_unknown_field_member:")
self.assertEqual(1000, int(result['errno']))
# self.assertEqual(new_id, result['data']['id'])
if not keep_member: self.delete_member(new_id)
def Start(self):
while True:
try:
self.pods = self.kube.GetPods()
exists = self.CheckForPrimaryMongo()
if exists == True:
print(
'Watcher.CheckForPrimaryMongo: PRIMARY ALREADY IN REPLICASET'
)
self.primary = False
elif exists == False:
member = Member(_id=None, IP='127.0.0.1', priority=None)
alive = member.CheckIfAlive()
if alive == True:
primary = member.CheckIfPodIsPrimary()
if primary == True:
self.primary = True
print(
'Watcher.CheckForPrimaryMongo: POD IS PRIMARY')
elif primary == False:
print(
'Watcher.CheckForPrimaryMongo: NO PRIMARY IN REPLICASET'
)
self.mongo.HoldElection(self)
if self.primary == True:
self.CheckCurrentMongoPods()
time.sleep(5)
except Exception as error:
print('Watcher.Start: ERROR - {}'.format(error))
time.sleep(5)
def load_members(names):
"""
Load the game owners as members in database.
:param names: the list of the game owner names
:return:
"""
for name in names:
# Ignore empty names
if not name.strip():
continue
member = MemberRepo.get_member_by_name(name)
if member is None:
# Get the number of the last registered member
last_num = 0
last_member = MemberRepo.get_last_member()
if last_member is not None:
last_num = last_member.number
num = str(int(last_num) + 1)
now = datetime.datetime.today().strftime('%Y-%m-%d')
member = Member(num, name, now)
# Insert new member
logging.debug('Insert member ' + member.to_string())
MemberRepo.insert_member(member)
else:
logging.debug('Update member ' + member.to_string())
MemberRepo.update_member(member)
def upd_form_member(id):
"""update a member database record - Display current data for input modification"""
member = Member(id)
return template("member",
member=member,
read_only=False,
session=session_manager.get_session())
def test_show_member_complaints_without_data(self, mocksql):
""" Test show member complaints method."""
sqlite_execute_mock = mock.Mock()
mocksql.execute.return_value = sqlite_execute_mock
sqlite_execute_mock.fetchall.return_value = {}
assert Member(mocksql).show_member_complaints() == True
def get_daypass():
"""Present a calendar to choose the daypass pariod (from/to) - default is today"""
session = session_manager.get_session()
if request.method == "POST":
from_date = request.forms['from_date']
until_date = request.forms.get(
'until_date', from_date) # one day pass only --> no until_date
_from_date = datetime.strptime(from_date, "%Y-%m-%d")
_until_date = datetime.strptime(until_date, "%Y-%m-%d")
if (_until_date - _from_date).days <= 7:
admin = Member(id=1)
qr_code = admin.encode_qrcode(version=3,
from_date=_from_date,
until_date=_until_date)
img_qrcode = make_qrcode(qr_code)
qr_code_file = "images/XCJ_{}.png".format(from_date)
img_qrcode.save(qr_code_file)
# print("QR code:", qr_code_file)
if request.forms.get('email'):
admin.email_qrcode(
qr_code_file,
"from {} until {}".format(from_date, until_date),
request.forms['email'])
else:
qr_code_file = "images/emoji-not-happy.jpg"
else: # GET
qr_code_file = None
from_date, until_date = date.today(), date.today()
# only admin can set 'until date'
period = (from_date, until_date if session['user'].is_admin else "")
return template("daypass",
qr_code=qr_code_file,
period=period,
session=session)
def test_member_details_true_without_data(self, mocksql):
""" Test member details method."""
sqlite_execute_mock = mock.Mock()
mocksql.execute.return_value = sqlite_execute_mock
sqlite_execute_mock.fetchone.return_value = []
assert Member(mocksql).member_details() == True
def do_login():
"""
Fetch the login/password from the form and check this couple against the tb_user table
"""
username = request.forms.get('username').lower()
password = request.forms.get('password')
if not username or not password:
return template('login.tpl',
error='Please specify username and password',
session=session_manager.get_session())
session = session_manager.get_session()
new_user = Member()
new_user_id = new_user.select('users',
columns='id',
username=username,
passwd=password)
if new_user_id:
new_user.get_from_db(id=new_user_id['id'])
session['valid'] = True
session['user'] = new_user
session_manager.save(session)
else:
session['valid'] = False
session['user'] = {}
session_manager.save(session)
return template('login.tpl',
error='Username or password is invalid',
session=session_manager.get_session())
# redirect(request.get_cookie('validuserloginredirect', '/member/{}'.format(new_user['id'])))
redirect('/member/{}'.format(new_user['id']))
def __init__(self, ip, udp_port, mode='FIFO'):
self.member = Member(None, None, ip, udp_port,
self.generate_random_port())
self.udp_socket = None
self.tcp_socket = None
self.tracker_ip = None
self.tracker_port = None
self.input_fd = None
if (mode != 'FIFO') and (mode != 'TOTAL_ORDER'):
print 'Unsupported message ordering mode'
sys.exit(3)
else:
self.mode = mode
# dictionary of all groups this client belongs to
self.group_list = {}
# the group client has selected to send messages
self.current_group = None
# serial number of message sent by client
self.message_num = 0
# lamport vector implementation for FIFO ordering implemented as a dictionary
# with key = <(username, group_name)> and value = <message-serial-no>
self.lamport_dict = {}
# buffer storing messages waiting to be delivered
self.messages_buffer = []
# lamport timestamp to support total ordering operation mode
self.lamport_timestamp = 0
# performance metrics
self.metrics = Metrics()
def profile_email_toggle(event):
m = Member(session['username'])
if m.get_email_prefs()[event]:
m.set_email_pref(event, 0)
else:
m.set_email_pref(event, 1)
return redirect('/hub/profile/emails')
def ticket():
# Validate inputs
required = ['first-name', 'sure-name', 'email', 'promise']
if not request.form:
return redirect("http://*****:*****@]+@[^@]+\.[^@]+", request.form['email']):
return redirect("http://localhost:1313/podlesi-fest/#tickets&err",
code=302)
#Insert data and send message
member = Member(request.form['first-name'], request.form['sure-name'],
request.form['email'], request.form['promise'],
request.form['tel'])
if member.sendMail()[0]:
return redirect("http://localhost:1313/podlesi-fest/#tickets&ok",
code=302)
else:
return redirect("http://localhost:1313/podlesi-fest/#tickets&err",
code=302)
def createMember(self, member_json):
"""
Create a Member object from JSON object
"""
return Member(trello_client=self,
member_id=member_json['id'].encode('utf-8'),
name=member_json['fullName'].encode('utf-8'))
def createMember(self):
name = input("\nIngrese Nombre: ")
surname = input("Ingrese Apellido: ")
age = int(input("Ingrese Edad: "))
celular = int(input("Ingrese Celular: "))
member = Member(name, surname, age, celular)
return member
def admin_payment():
member = Member(request.form['username'])
if 'month' in request.form.keys():
try:
month = int(request.form['month'])
if not (1 <= month <= 12):
return render_template('message.html',
title='Fail',
message='That is an unacceptable month')
year = int(request.form['year'])
delta_yr = datetime.date.today().year - year
if not (-1 <= delta_yr <= 1):
return render_template('message.html',
title='Fail',
message='That is an unacceptable year')
member.add_payment(month, year, session['username'])
return redirect('/hub/admin')
except Exception as e:
return render_template('message.html',
title='Fail',
message=str(e))
else:
now = datetime.datetime.now()
member.add_payment(now.month, now.year, session['username'])
return redirect('/hub/admin')
async def handleRoomCreation(ws, initObj, setRoom):
if "name" in initObj and initObj["name"].strip() != "":
gm = GameManager(initObj["packs"], initObj["questions"],
initObj["answers"])
while gm.joinCode in games:
gm.regenJoinCode()
m = Member(ws, initObj["name"])
gm.addMember(m)
games[gm.joinCode] = gm
setRoom(gm.joinCode)
await send_object(
ws, {
"action": "roomMade",
"joinCode": gm.joinCode,
"setName": initObj["name"]
})
nextObj = await recv_object(ws)
if "action" in nextObj:
if nextObj["action"] == "startGame":
await asyncio.wait(
[games[gm.joinCode].startGame(),
m.runGameLoop()],
return_when=asyncio.FIRST_COMPLETED)
else:
await send_object(ws, {
"action": "error",
"content": "Please make sure to set a name."
})
def test_add_new_member_with_payment(self, keep_member=False):
"""POST new member profile with a new payment record"""
url = "{}/member/new".format(self.base_url)
print("Path:", url)
openid = datetime.now().strftime('%Y%m%d%H%M%S.%f')
minimum_data = {
"openid": openid,
"avatarUrl":
"https://wx.qlogo.cn/mmopen/vi_32/GPm0HkJtcIsWkZmVNaxJP19ibl1g2YJTEibglP0UibOZstaRN1lbuMavu1a1Y795p6J1vHz0bM27icibCiat9ERricyng/0",
'basicInfo': {
'nickName': "test_" + openid,
},
'paymentInfo': {
'paidTime': '{0:%Y%m%d%H%M}'.format(datetime.today()),
'payIndex': 'membership 1 month',
'CNYAmount': 3200.00,
}
}
response = requests.post(url, json=minimum_data)
self.assertEqual(200, response.status_code)
result = response.json()
self.print_JSON(result, title="test_add_new_member_with_payment:")
self.assertEqual('1000', result['errno'])
new_id = result['data']['new_id']
member = Member(new_id, db_access="../../Private/db_access.data")
print("Created as [role:", member['role'], "] with status:",
member["status"])
self.assertEqual('OK', member["status"])
print("Transaction:", member.transactions)
if not keep_member: self.delete_member(new_id)
return new_id
