def test_close_conn(self, mock_cursor):
# act
db = ConnectDb()
db.close_conn()
# assert
mock_cursor().cursor().close.assert_called_once()
mock_cursor().close.assert_called_once()
def test_db_script(self, mock_cursor):
db = ConnectDb()
db.db_script()
mock_cursor().cursor().executescript.assert_called_once()
mock_cursor().commit.assert_called_once()
mock_cursor().cursor().close.assert_called_once()
mock_cursor().close.assert_called_once()
def test_db_script_fail(self, mock_cursor, mock_sys, mock_connect):
db = ConnectDb()
db.db_script()
mock_sys.exit.assert_called_once()
mock_cursor().cursor().close.assert_called_once()
mock_cursor().rollback.assert_called_once()
mock_cursor().close.assert_called_once()
def test_get_requests(self, mock_cursor):
# arrange
receiver_id = '1234'
# act
db = ConnectDb()
db.get_requests(receiver_id)
# assert
mock_cursor().cursor().execute.assert_called_once_with(
mock.ANY, [receiver_id])
def test_get_subordinate_details(self, mock_cursor):
# arrange
subordinate_id = '1234'
# act
db = ConnectDb()
db.get_subordinate_details(subordinate_id)
# assert
mock_cursor().cursor().execute.assert_called_once_with(
mock.ANY, [subordinate_id])
def test_remove_project_all_members(self, mock_cursor):
# arrange
project_id = '2345'
# act
db = ConnectDb()
db.remove_project_all_members(project_id)
# assert
mock_cursor().cursor().execute.assert_called_once_with(
mock.ANY, [project_id])
def test_get_gpm_projects_details(self, mock_cursor):
# arrange
gpm_id = 'sample-id'
# act
db = ConnectDb()
result = db.get_gpm_projects_details(gpm_id)
# assert
mock_cursor().cursor().execute.assert_called_once_with(
mock.ANY, [gpm_id])
def test_get_bdo_project_details(self, mock_cursor):
# arrange
bdo_id = '1234'
# act
db = ConnectDb()
db.get_bdo_project_details(bdo_id)
# assert
mock_cursor().cursor().execute.assert_called_once_with(
mock.ANY, [bdo_id])
def __init__(self):
"""
initializing BDO class .
"""
self.conn = ConnectDb()
self.bdo_id = ''
self.project_id = ' '
self.gpm_id = ' '
self.member_id = ''
def test_update_member_gpm(self, mock_cursor):
# arrange
gpm_id = '1234'
old_gmp_id = '4467'
# act
db = ConnectDb()
db.update_member_gpm(gpm_id, old_gmp_id)
# assert
mock_cursor().cursor().execute.assert_called_once_with(
mock.ANY, [gpm_id, old_gmp_id])
def test_resolve_request(self, mock_cursor):
# arrange
status = 'True'
request_id = '1234'
# act
db = ConnectDb()
db.resolve_request(status, request_id)
# assert
mock_cursor().cursor().execute.assert_called_once_with(
mock.ANY, [mock.ANY, request_id])
def test_assign_project_members(self, mock_cursor):
# arrange
project_id = '1234'
member_id = '2345'
# act
db = ConnectDb()
db.assign_project_members(project_id, member_id)
# assert
mock_cursor().cursor().execute.assert_called_once_with(
mock.ANY, [project_id, member_id, mock.ANY])
def test_update_personal_details(self, mock_cursor):
# arrange
member_id = '1234'
field = 'sample-field'
user_input = 'sample-input'
# act
db = ConnectDb()
db.update_personal_details(field, member_id, user_input)
# assert
mock_cursor().cursor().execute.assert_called_once_with(
mock.ANY, [user_input, member_id])
def test_update_project(self, mock_cursor):
# arrange
field = 'field_name'
user_input = 'user_input'
project_id = '1234'
# act
db = ConnectDb()
db.update_project(field, user_input, project_id)
# assert
mock_cursor().cursor().execute.assert_called_once_with(
mock.ANY, [user_input, project_id])
def test_get_project_members_list(self, mock_cursor):
# arrange
project_id = '1234'
mock_cursor.cursor().execute().fetchall.return_value = [['dummy']]
# act
db = ConnectDb()
result = db.get_project_members_list(project_id)
# assert
mock_cursor().cursor().execute.assert_called_once_with(
mock.ANY, [project_id])
mock_cursor().cursor().execute().fetchall.assert_called_once()
assert result, ['dummy']
def test_get_gpm_project_names(self, mock_cursor):
# arrange
gpm_id = '1234'
mock_cursor.cursor().execute().fetchone.return_value = ['dummy']
# act
db = ConnectDb()
result = db.get_gpm_project_names(gpm_id)
# assert
mock_cursor().cursor().execute.assert_called_once_with(
mock.ANY, [gpm_id])
mock_cursor().cursor().execute().fetchall.assert_called_once()
assert result, ['dummy']
def test_get_members_assigned_project(self, mock_cursor):
# arrange
member_id = '1234'
mock_cursor.cursor().execute().fetchone.return_value = ['dummy']
# act
db = ConnectDb()
result = db.get_members_assigned_project(member_id)
# assert
mock_cursor().cursor().execute.assert_called_once_with(
mock.ANY, [member_id])
mock_cursor().cursor().execute().fetchone.assert_called_once()
assert result, ['dummy']
def test_find_project_is_assigned(self, mock_cursor):
# arrange
project_id = '2345'
mock_cursor.cursor().execute().fetchone.return_value = ['dummy']
# act
db = ConnectDb()
result = db.find_project_is_assigned(project_id)
# assert
mock_cursor().cursor().execute.assert_called_once_with(
mock.ANY, [project_id])
mock_cursor().cursor().execute().fetchall.assert_called_once()
assert result, ['dummy']
def test_get_bdo_approvals_list(self, mock_cursor):
# arrange
bdo_id = '2345'
mock_cursor.cursor().execute().fetchone.return_value = ['dummy']
# act
db = ConnectDb()
result = db.get_bdo_approvals_list(bdo_id)
# assert
mock_cursor().cursor().execute.assert_called_once_with(
mock.ANY, [bdo_id])
mock_cursor().cursor().execute().fetchall.assert_called_once()
assert result, ['dummy']
def test_get_bdo_gpm_for_member(self, mock_cursor):
# arrange
member_id = 'member-id'
mock_cursor.cursor().execute().fetchone.return_value = 'dummy'
# act
db = ConnectDb()
result = db.get_bdo_gpm_for_member(member_id)
# assert
mock_cursor().cursor().execute.assert_called_once_with(
mock.ANY, [member_id])
mock_cursor().cursor().execute().fetchone.assert_called_once()
assert result, 'dummy'
def test_get_project_start_date(self, mock_cursor):
# arrange
project_id = '1234'
mock_cursor.cursor().execute().fetchone.return_value = 'dummy'
# act
db = ConnectDb()
result = db.get_project_start_date(project_id)
# assert
mock_cursor().cursor().execute.assert_called_once_with(
mock.ANY, [project_id])
mock_cursor().cursor().execute().fetchone.assert_called_once()
assert result, 'dummy'
def test_get_user_with_role(self, mock_cursor):
# arrange
name = 'sample_name'
role = 1
mock_cursor.cursor().execute().fetchone.return_value = 'dummy'
# act
db = ConnectDb()
result = db.get_user_with_role(name, role)
# assert
mock_cursor().cursor().execute.assert_called_once_with(
mock.ANY, (name, role))
mock_cursor().cursor().execute().fetchone.assert_called_once()
assert result, 'dummy'
def main():
"""
this method is used to call main menu for login
"""
conn = ConnectDb()
try:
os.system('clear')
# select role for login
print("login as:\n")
menu = Menu()
roles = [x.name for x in Role]
roles.extend([str(BackButton.EXIT.name)])
role = menu.draw_menu(roles)
role_id = Role[role].value
input()
# get user name and password for login
user_name = input("enter user name: ")
password = getpass()
# check user authentication
result = conn.get_user_with_role(user_name, role_id)
flag = True
if result is not None:
os.system('clear')
actual_pass = decrypt_pass(result[1])
if str(actual_pass.decode("utf-8")) == password:
flag = False
if role_id == int(Role.BDO.value):
bdo = BDO()
bdo.bdo_id = result[0]
bdo.bdo_features()
elif role_id == int(Role.GPM.value):
gpm = GPM()
gpm.gpm_id = result[0]
gpm.gpm_features()
elif role_id == int(Role.Member.value):
member = Member()
member.member_id = result[0]
member.member_features()
if result is None or flag:
print(Color.F_Red + 'wrong credentials' + Base.END)
input()
main()
except Exception as e:
print(e)
sys.exit()
finally:
conn.close_conn()
def test_register_project_completion(self, mock_cursor):
# arrange
project_id = '1234'
member_id = '2345'
assigned_date = '2020-01-02'
total_days = 20
wage = 2000
# act
db = ConnectDb()
db.register_project_completion(project_id, member_id, assigned_date,
total_days, wage)
# assert
mock_cursor().cursor().execute.assert_called_once_with(
mock.ANY, [project_id, member_id, assigned_date, total_days, wage])
def test_register_complain(self, mock_cursor, mock_uuid):
# arrange
issue = 'sample-issue'
sender_id = 'sample_id'
request_msg = 'msg'
recipient_id = 'recipient-id'
request_id = '1234'
mock_uuid.uuid4.return_value = request_id
# act
db = ConnectDb()
db.register_complain(issue, sender_id, request_msg, recipient_id)
# assert
mock_cursor().cursor().execute.assert_called_once_with(
mock.ANY, [
issue, sender_id, request_msg, mock.ANY, recipient_id,
request_id
])
def test_add_personal_details(self, mock_cursor):
# arrange
user_id = '1234'
state = 'state'
district = 'distrcit'
pincode = '123456'
age = 21
gender = 'male'
created_by = '2020-02-02'
# act
db = ConnectDb()
db.add_personal_details(user_id, state, district, pincode, age, gender,
created_by)
# assert
mock_cursor().cursor().execute.assert_called_once_with(
mock.ANY,
[user_id, state, district, pincode, age, gender, created_by])
def test_add_user(self, mock_cursor):
# arrange
user_id = '1234'
encrypted_pass = '******'
user_name = 'username'
role_id = 2
created_at = '2020-01-01'
updated_at = '2020-02-02'
name = 'name'
is_deleted = 'False'
# act
db = ConnectDb()
db.add_user(user_id, encrypted_pass, user_name, role_id, created_at,
updated_at, name, is_deleted)
# assert
mock_cursor().cursor().execute.assert_called_once_with(
mock.ANY, [
user_id, encrypted_pass, user_name, role_id, created_at,
updated_at, name, is_deleted
])
def test_create_project(self, mock_cursor):
# arrange
project_id = '1233'
project_name = 'name'
labours = 23
cost = 23
area = 234
start_date = '2020-01-02'
end_date = '2020-02-20'
gpm_id = '1234'
created_by = '4353'
project_type = 'type'
is_deleted = 'False'
# act
db = ConnectDb()
db.create_project(project_id, project_name, labours, cost, area,
start_date, end_date, gpm_id, created_by,
project_type, is_deleted)
# assert
mock_cursor().cursor().execute.assert_called_once_with(
mock.ANY, [
project_id, project_name, labours, cost, area, start_date,
end_date, gpm_id, created_by, project_type, is_deleted
])
class BDO:
"""this is a class for BDO related operations.
Attributes:
conn (sqlite connection): connection object.
bdo_id (string): bdo id.
project_id (string): project id.
gpm_id (string): gpm id.
member_id (string): member id.
"""
def __init__(self):
"""
initializing BDO class .
"""
self.conn = ConnectDb()
self.bdo_id = ''
self.project_id = ' '
self.gpm_id = ' '
self.member_id = ''
def __del__(self):
"""
closing database connection.
"""
self.conn.close_conn()
def bdo_features(self):
"""
this method is used to print all bdo features on console.
"""
try:
while True:
print("choose feature :\n")
menu = Menu()
features = [x.name for x in BdoFeatures]
features.extend([str(BackButton.EXIT.name)])
feature = menu.draw_menu(features)
input()
required_feature = getattr(self, feature.lower())
required_feature()
# again calling gpm menu
input()
os.system('clear')
self.bdo_features()
except Exception as e:
print(e)
sys.exit()
def show_gpm(self):
"""
this method is used to print all gpm of current bdo.
"""
print("GPM's list:\n")
result = self.conn.get_subordinate_details(self.bdo_id)
data = result.fetchall()
if len(data) == 0:
print(Color.F_Green + "you don't have any GPM under you" +
Base.END)
return
# converting list of tuples into list of list
list_data = [list(elem) for elem in data]
for gpm in list_data:
gpm[2] = decrypt_pass(gpm[2])
raw_data_to_table(list_data, result)
def show_members(self):
"""
this method is used to print members and gpm of current bdo.
"""
print("members List:\n")
gpm_list = self.conn.get_user_names(self.bdo_id)
if len(gpm_list) == 0:
print(Color.F_Green +
"you don't have any GPM and members under you" + Base.END)
return
for gpm_detail in gpm_list:
print('GPM name ' + gpm_detail[0])
gpm = GPM()
gpm.gpm_id = gpm_detail[1]
gpm.show_members()
def create_gpm(self):
"""
this method is used to create gpm for current bdo.
"""
try:
name = input("enter gpm name ")
id = str(uuid.uuid4())
password = input("enter password for gpm ")
user_name = input("enter user name for gpm ")
role_id = int(Role.GPM.value)
created_at = datetime.datetime.now().date()
updated_at = datetime.datetime.now().date()
is_deleted = 'False'
state = input("enter state ")
district = input("enter district ")
pincode = input("enter pincode ")
if not Validation.pincode(pincode):
print("pin code is not valid")
input()
sys.exit()
age = input("enter age ")
if not Validation.is_int(age):
print("age is not valid")
input()
sys.exit()
gender = input("enter gender ")
if not Validation.gender(gender):
print("gender is not valid")
input()
sys.exit()
created_by = self.bdo_id
encrypted_pass = encrypt_pass(password)
self.conn.add_user(id, encrypted_pass, user_name, role_id,
created_at, updated_at, name, is_deleted)
self.conn.add_personal_details(id, state, district, pincode, age,
gender, created_by)
self.conn.commit_data()
print("\n" + Color.F_Green + "record inserted" + Base.END)
except Exception as e:
print(e)
self.conn.rollback_data()
def delete_gpm(self):
"""
this method is used to delete gpm for current bdo.
"""
try:
print("choose gmp to delete:\n")
gpm_list = self.get_gpm_list()
menu = Menu()
gpm_names = [x for x in gpm_list.keys()]
gpm_names.extend(
[str(BackButton.EXIT.name),
str(BackButton.BACK.name)])
gpm_name = menu.draw_menu(gpm_names)
input()
if gpm_name == str(BackButton.BACK.name):
return
self.gpm_id = gpm_list.pop(gpm_name)
os.system('clear')
print('choose another gpm to assign current gpm members:\n')
menu2 = Menu()
if len(gpm_list.keys()) == 0:
print(
Color.F_Red +
"Can't delete GPM because you don't have any alternative GPM "
+ Base.END)
return
alternative_gpm_names = [x for x in gpm_list.keys()]
alternative_gpm_names.extend(
[str(BackButton.EXIT.name),
str(BackButton.BACK.name)])
alternative_gpm_name = menu2.draw_menu(alternative_gpm_names)
input()
if alternative_gpm_name == str(BackButton.BACK.name):
return
# assigning new gpm to members
self.conn.update_member_gpm(gpm_list[alternative_gpm_name],
self.gpm_id)
# completing all gpm projects
project_ids = self.conn.get_gpm_projects(self.gpm_id)
for project_id in project_ids:
self.project_id = project_id
member_ids = self.conn.get_project_members(self.project_id)
for member_id in member_ids:
self.member_id = member_id[0]
self.delete_project_members()
self.conn.update_user('is_deleted', self.gpm_id, 'True')
self.conn.commit_data()
except Exception as e:
print(e)
self.conn.rollback_data()
def update_gpm(self):
"""
this method is used to update gpm for current bdo.
"""
try:
gpm_list = self.get_gpm_list()
menu = Menu()
gpm_names = [x for x in gpm_list.keys()]
gpm_names.extend(
[str(BackButton.EXIT.name),
str(BackButton.BACK.name)])
gpm_name = menu.draw_menu(gpm_names)
input()
if str(BackButton.BACK.name) == gpm_name:
return
gpm_id = gpm_list[gpm_name]
print("select the field to update: \n")
menu = Menu()
details = [x.name for x in GpmUpdateFields]
details.extend([str(BackButton.EXIT.name)])
field = menu.draw_menu(details)
input()
user_input = input("enter new value for " + str(field) + " ")
user_table_fields = [1, 2, 3]
# validating field
if field == str(GpmUpdateFields.AGE.name):
if not Validation.is_int(user_input):
print("age is not valid")
input()
sys.exit()
if field == str(GpmUpdateFields.PINCODE.name):
if not Validation.pincode(user_input):
print("pincode is not valid")
input()
sys.exit()
if field == str(GpmUpdateFields.GENDER.name):
if not Validation.gender(user_input):
print("gender is not valid")
input()
sys.exit()
query = ""
# if field belong to user table
if user_table_fields.count(GpmUpdateFields[field].value) == 1:
self.conn.update_user(str(field), gpm_id, user_input)
else:
self.conn.update_personal_details(str(field), gpm_id,
user_input)
self.conn.commit_data()
print("\n" + Color.F_Green + "record updated" + Base.END)
except Exception as e:
print(e)
self.conn.rollback_data()
def get_gpm_list(self):
"""
this method is used to get gpm for current bdo.
:return: dict, gpm name and id dictionary.
"""
result = self.conn.get_user_names(self.bdo_id)
gpm_dict = {}
for data in result:
gpm_dict[data[0]] = data[1]
return gpm_dict
def create_project(self):
"""
this method is used to create project for current bdo.
"""
try:
print("choose gpm for project\n")
gpm_list = self.get_gpm_list()
menu = Menu()
gpm_names = [x for x in gpm_list.keys()]
gpm_names.extend([str(BackButton.EXIT.name)])
gpm_name = menu.draw_menu(gpm_names)
input()
gpm_id = gpm_list[gpm_name]
print("choose project type:\n")
menu2 = Menu()
project_types = [x.name for x in ProjectType]
project_types.extend([str(BackButton.EXIT.name)])
project_type = menu2.draw_menu(project_types)
input()
project_id = str(uuid.uuid4())
project_name = input("enter project name: ")
labours = input("enter expected labours: ")
if not Validation.is_int(labours):
print("labours count is not valid")
input()
sys.exit()
cost = input("enter estimated project cost: ")
if not Validation.is_int(cost):
print("cost is not valid")
input()
sys.exit()
area = input("enter estimated project area: ")
if not Validation.is_int(area):
print("area is not valid")
input()
sys.exit()
start_date = input("enter estimated start date: ")
if not Validation.is_date(start_date):
print("start date is not valid")
input()
sys.exit()
end_date = input("enter estimated end date: ")
if not Validation.is_date(end_date):
print("end date is not valid")
input()
sys.exit()
is_deleted = 'False'
created_by = self.bdo_id
self.conn.create_project(project_id, project_name, labours, cost,
area, start_date, end_date, gpm_id,
created_by, project_type, is_deleted)
self.conn.commit_data()
print("\n" + Color.F_Green + "project created" + Base.END)
except Exception as e:
print(e)
self.conn.rollback_data()
def update_project(self):
"""
this method is used to update project for current bdo.
"""
print("choose project")
project_list = self.get_project_list()
menu = Menu()
project_names = [x for x in project_list.keys()]
project_names.extend(
[str(BackButton.EXIT.name),
str(BackButton.BACK.name)])
project_name = menu.draw_menu(project_names)
input()
if str(BackButton.BACK.name) == project_name:
return
project_id = project_list[project_name]
print("select the field to update: \n")
menu2 = Menu()
details = [x.name for x in ProjectsUpdateFields]
details.extend([str(BackButton.EXIT.name)])
field = menu2.draw_menu(details)
input()
user_input = ""
if ProjectsUpdateFields[
field].value == ProjectsUpdateFields.PROJECT_TYPE.value:
print("choose project type: \n")
menu3 = Menu()
project_types = [x.name for x in ProjectType]
project_types.extend([str(BackButton.EXIT.name)])
user_input = menu3.draw_menu(project_types)
input()
else:
user_input = input("enter new value for " + str(field) + " ")
# validations
if field == str(ProjectsUpdateFields.AREA_OF_PROJECT.name):
if not Validation.is_int(user_input):
print("area is not valid")
input()
sys.exit()
if field == str(ProjectsUpdateFields.TOTAL_LABOUR_REQUIRED.name):
if not Validation.is_int(user_input):
print("labour required is not valid")
input()
sys.exit()
if field == str(ProjectsUpdateFields.ESTIMATED_START_DATE.name):
if not Validation.is_date(user_input):
print("start date is not valid")
input()
sys.exit()
if field == str(ProjectsUpdateFields.ESTIMATED_END_DATE.name):
if not Validation.is_date(user_input):
print("end date is not valid")
input()
sys.exit()
if field == str(ProjectsUpdateFields.ESTIMATED_COST.name):
if not Validation.is_int(user_input):
print("cost is not valid")
input()
sys.exit()
self.conn.update_project(field, user_input, project_id)
self.conn.commit_data()
print("\n" + Color.F_Green + "record updated" + Base.END)
def delete_project(self):
"""
this method is used to delete project for current bdo.
"""
print("choose project")
project_list = self.get_project_list()
menu = Menu()
project_names = [x for x in project_list.keys()]
project_names.extend(
[str(BackButton.EXIT.name),
str(BackButton.BACK.name)])
project_name = menu.draw_menu(project_names)
input()
if project_name == str(BackButton.BACK.name):
return
project_id = project_list[project_name]
self.project_id = project_id
self.project_deletion()
print(Color.F_Green + "project deleted successfully " + Base.END)
def show_projects(self):
"""
this method is used to print projects for current bdo.
"""
result = self.conn.get_bdo_project_details(self.bdo_id)
raw_data_to_table(result.fetchall(), result)
def get_project_list(self):
"""
this method is used to get projects list for current bdo.
:return: dict, project name and id dictionary.
"""
result = self.conn.get_bdo_project_names(self.bdo_id)
gpm_dict = {}
for data in result:
gpm_dict[data[0]] = data[1]
return gpm_dict
def show_requests(self):
"""
this method is used to show and resolve all requests for current bdo.
"""
try:
projects = self.conn.get_requests(self.bdo_id)
# adding index column to given result
projects_fields = (('index'), ) + projects.description
result = projects.fetchall()
counter = 0
# request is empty then returning early with a message
if len(result) == 0:
print(Color.F_Red + "there is no pending request" + Base.END)
return
print("write index of request to manage:\n")
temp = result
# converting list of tuples into list of list
temp = [list(elem) for elem in temp]
for request in temp:
if str(RequestType.APPROVAL.name) == str(request[0]):
temp2 = str(request[2]).split('|')
request[2] = temp2[0] + " request for " + temp2[
4] + " project for " + temp2[1] + " member"
# inserting data for index column
request.insert(0, counter)
counter += 1
table = PrettyTable()
# assigning field names to pretty table object and removing request id column
table.field_names = [column[0] for column in projects_fields[:-1]]
for row in temp:
# removing request id from temp list and adding to table row
table.add_row(row[:-1])
print(table)
row_number = input("enter index number: ")
if not Validation.is_int(row_number):
print("index number is not valid")
input()
sys.exit()
menu = Menu()
result_names = [x.name for x in RequestResult]
result_names.extend([str(BackButton.EXIT.name)])
result_name = menu.draw_menu(result_names)
input()
status = "NULL"
if str(RequestType.APPROVAL.name) == str(
result[int(row_number)][0]):
temp = str(result[int(row_number)][2]).split('|')
req_type = str(temp[0])
self.project_id = str(temp[3])
self.member_id = str(temp[2])
if req_type == str(
ApprovalType.WAGE.name) and str(result_name) == str(
RequestResult.APPROVED.name):
self.delete_project_members()
status = "'True'"
elif req_type == str(
ApprovalType.MEMBER.name) and str(result_name) == str(
RequestResult.APPROVED.name):
project_members_id = self.conn.get_project_members(
self.project_id)
members_required = self.conn.get_project_members_required(
self.project_id)
# checking if total number of members in given project are less then actual project requirement
if members_required[0] <= len(project_members_id):
print(
Color.F_Red +
"project members limit exceeded can't accept request"
+ Base.END)
return
self.conn.assign_project_members(self.project_id,
self.member_id)
status = "'True'"
elif str(result_name) == str(RequestResult.REJECTED.name):
status = "'False'"
else:
if str(result_name) == str(RequestResult.APPROVED.name):
status = "'True'"
elif str(result_name) == str(RequestResult.REJECTED.name):
status = "'False'"
self.conn.resolve_request(status, result[int(row_number)][4])
self.conn.commit_data()
print(Color.F_Green + "Request completed successfully" + Base.END)
except Exception as e:
print(e)
self.conn.rollback_data()
def delete_project_members(self):
"""
this method is used to delete project members for current bdo.
"""
result = self.conn.get_member_project(self.member_id)
if result is None:
return
# removing member from project
duration = datetime.datetime.now() - datetime.datetime.strptime(
str(result[2]), '%Y-%m-%d')
wage = duration.days * 100
self.conn.register_project_completion(result[0], self.member_id,
result[2],
datetime.datetime.now().date(),
wage)
self.conn.remove_project_member(self.member_id)
# checking if other members are assigned to this project
result2 = self.conn.find_project_is_assigned(result[0])
# deleting whole project
if len(result2) == 0:
self.conn.update_project('is_deleted', 'True', result[0])
def project_deletion(self):
"""
this method is used to delete project for current bdo.
"""
try:
result = self.conn.get_project_members_list(self.project_id)
if len(result) != 0:
for project_member in result:
duration = datetime.datetime.now(
) - datetime.datetime.strptime(str(project_member[2]),
'%Y-%m-%d')
wage = duration.days * 100
self.conn.register_project_completion(
project_member[0], project_member[1],
project_member[2],
datetime.datetime.now().date(), wage)
self.conn.remove_project_all_members(self.project_id)
self.conn.update_project('is_deleted', 'True', self.project_id)
# removing project pending requests
pending_requests = self.conn.get_bdo_approvals_list(self.bdo_id)
pending_requests_ids = []
for request in pending_requests:
temp = str(request[1]).split('|')
if str(temp[3]) == str(self.project_id):
pending_requests_ids.append(request[0])
for pending_requests_id in pending_requests_ids:
self.conn.resolve_request("'True'", pending_requests_id)
self.conn.commit_data()
except Exception as e:
print(e)
self.conn.rollback_data()
class Supervisor:
"""this is a class for supervisor related operations."""
def __init__(self):
"""
initializing supervisor class.
"""
self.conn = ConnectDb()
self.supervisor_id = ''
def __del__(self):
"""
closing database connection.
"""
self.conn.close_conn()
def supervisor_features(self):
"""
this method is used to print all supervisor features on console.
"""
try:
while True:
print("choose feature :\n")
menu = Menu()
features = [x.name for x in SupervisorFeatures]
features.extend([str(BackButton.EXIT.name)])
feature = menu.draw_menu(features)
input()
required_feature = getattr(self, feature.lower())
required_feature()
# again calling supervisor menu
input()
os.system('clear')
self.supervisor_features()
except Exception as e:
print(e)
sys.exit()
def show_accident_complain(self):
"""
this method is used to show supervisor accident complain.
"""
cursor = self.conn.show_supervisor_accidents(self.supervisor_id)
admin = Admin()
temp_dict = dict()
print('choose accident to send report')
temp_dict['accident_id'] = admin.show_table_menu(cursor)
if temp_dict['accident_id'] is None:
return
cursor = self.conn.show_members()
print('choose eye witness')
temp_dict['eye_witness'] = admin.show_table_menu(cursor)
print('choose victims')
victims = admin.choose_multiple_employee()
print('choose culprit')
temp_dict['victims'] = ''
temp_dict['culprit'] = ''
culprit = admin.choose_multiple_employee()
if culprit != [] and culprit != None:
temp_dict['culprit'] = ','.join(culprit)
if victims != [] and victims != None:
temp_dict['victims'] = ','.join(victims)
temp_dict['submitted_by'] = self.supervisor_id
temp_dict['reason'] = input('enter reason ')
temp_dict['timing'] = input('enter accident timing ')
temp_dict['submission_time'] = d.datetime.now()
temp_dict['location'] = input('enter location of accident ')
temp_dict['action_to_resolve'] = input('enter action to resolve ' )
try:
self.conn.register_supervisor_report(temp_dict)
self.conn.commit_data()
print('report submitted successfully.')
except Exception as e:
print('some error occured')
print(e)
self.conn.rollback_data()
