def edit_entry(self, name, update=None, field=None):
if name in self.directory:
entry = self.directory[name].split("/")
temp_employee = Employee(name, entry[0], entry[1], entry[2],
entry[3], entry[4])
if field is None:
field = input(
"Which field would you like to change? " +
"Fields are 'email', 'phone', 'department', 'title', and 'education': "
)
field = field.lower()
fields = ['email', 'phone', 'department', 'title', 'education']
if field in fields:
if update is None:
update = input("Enter new {} information: ".format(field))
exec("temp_employee.set_{}('{}')".format(field, update))
self.directory[name] = temp_employee.stringify_attrs()
print("Entry updated")
else:
print("Invalid field entered")
else:
entry_dne()
def getSummary(self):
summary = "Name: {}\n".format(Employee.getName(self))
summary += "Age: {} years old\n".format(Employee.getAge(self))
summary += "Monthly Salary: $ {}\n".format(self.getFormattedSalary())
return summary
def addEmployee(self):
'''
Interface to add an employee and configure him/her
'''
self.printTitle("Add Employee")
#Added check to prevent duplicate employee names
while True:
name = self.getInputOfType("Enter a name for new employee: ", "str", range(1,20)) #20 chars max
if name not in self.employeeNames:
break
print("Name '%s' already taken!"%name)
if name != "cancel":
priority = self.getInputOfType("Enter employee priority: ", "int", range(0,1000)) #priority must be non negative
if priority != "cancel":
new_emp = Employee(name, priority)
self.scheduler.addEmployee(new_emp)
self.employeeNames[new_emp.getName()] = new_emp
print("...")
print("Successfuly created employee %s"%new_emp.getName())
cont = self.getInputOfType("Would you like to configure employee now? (y/n): ", "bool")
if cont:
self.configEmployee(new_emp)
else:
self.toMainScreen()
#returns to main screen
else:
self.toMainScreen()
else:
self.toMainScreen()
class EmployeeTests(unittest.TestCase):
def setUp(self):
self.e1 = Employee(40000, "Maxi", 20, 1.03)
self.e2 = Employee(70000, "Timo", 28, 1.05)
def test_check_email(self):
self.assertEqual(self.e1.email, "*****@*****.**", "Invalid Email Output!")
def test_salary(self):
self.assertEqual(self.e1.salary, 40000, "Invalid Salary value!")
def test_salary_increase(self):
self.e1.increase_salary()
self.e2.increase_salary()
self.assertEqual(self.e1.salary, 40000 * 1.03, "Invalid Salary increase!")
self.assertEqual(self.e2.salary, 70000 * 1.05, "Invalid Salary increase!")
def test_age(self):
self.assertEqual(self.e1.age, 20)
self.assertEqual(self.e2.age, 28)
def get(self):
# check for correct cookie
name = self.request.cookies.get("name")
admins = Employee.query(Employee.username == name,
Employee.isAdmin == True).fetch()
# if cookie is correct, render page
if len(admins) != 0:
employees = Employee.query().order(Employee.username).fetch()
# pulls current year to put into footer for copyrights
dateTimeNow = datetime.datetime.now()
curYear = dateTimeNow.year
values = {
"username": name,
"employee": employees,
"reset": 0,
"curYear": curYear
}
template = JINJA_ENVIRONMENT.get_template(
'HTML/AdminManageEmployees.html')
self.response.write(template.render(values))
else:
self.redirect('/')
return
def __init__(self):
self.user = User()
self.account = Account()
self.employee = Employee()
self.service = Service()
self.utilities = Utilities()
self.initAmt = 0
def __init__(self, first_name, last_name, ssn, salary, title,
amt_bonus_indollars):
"""
sets firstName, lastName, ssn and salary, title and bonus amount of the object to respective values passed by the client as parameters.
"""
Employee.__init__(self, first_name, last_name, ssn, salary)
self.title = title
self.amt_bonus_indollars = amt_bonus_indollars
def displayEmployee(self, a, b):
self.name = a
self.salary = b
self.empCount += 1
if self.empCount == 1:
Employee.displayEmployee(self, self.name, self.salary)
else:
print "Calling Child class method displayEmployee()", "\n", "Name: ", self.name, ", salary: ", self.salary
def __init__(self, name, ID, shift, payRate, initHours):
# Call constructor of base class
Employee.__init__(self, name, ID)
# Initialize class variables
self._shiftNumber = shift
self._payRate = payRate
self._hoursWorked = initHours
def load(self, f, info=False):
"""
Loads scheduler, shiftcal, & employees from filename
@params f: an open file pointer in "rb" mode
@params info: T/F whether to print detailed loading info
@return: True if no errors occurred, False otherwise
"""
try:
print("Loading Scheduler data...")
self.year = pickle.load(f)
if info:
print(" Read year: %d" % self.year)
self.month = pickle.load(f)
if info:
print(" Read month: %d" % self.month)
self.numDays = pickle.load(f)
if info:
print(" Read number of days: %d" % self.numDays)
self.firstDay = pickle.load(f)
if info:
print(" Read first day: %d" % self.firstDay)
print(" Loaded scheduler attributes")
if info:
print(" Checking employee data")
numEmps = pickle.load(f)
if info:
print(" Read num employees: %d" % numEmps)
self.employeeList = []
emp_dict = {}
print("")
if numEmps == 0:
print("No Employee data to load...")
else:
print("Loading Employees...")
print(" %d employees to load\n" % numEmps)
for i in range(0, numEmps):
emp = Employee("dummy", 1) # dummy employee who will be overwritten by loaded emp
if emp.load(f, info):
self.employeeList.append(emp)
emp_dict[emp.getName()] = emp
else:
return False
print("")
print("")
self.cal = ShiftCalendar(1, 1970) # dummy shiftCal
if self.cal.load(f, emp_dict, info):
return True
else:
print("Error occured loading calendar...")
return False
except FileNotFoundError:
print("Couldnt find scheduler data file...")
return False
class Employee_Test(unittest.TestCase):
"""This is a test to ensure weather Employee.py is working correctly"""
def setUp(self):
self.main = Employee('Harsh','Powar',50000)
def test_give_default_raise(self):
self.main.give_rise()
self.assertEqual(self.main.salary, 55000)
def test_give_custom_raise(self):
self.main.give_rise(10000)
self.assertEqual(self.main.salary, 60000)
def __init__(self, employeeID, firstName, lastName, birthYear, birthMonth,
birthDay, startingDate, yearlyPay):
# call superclass constructor
Employee.__init__(self, employeeID, firstName, lastName, birthYear, birthMonth,
birthDay, startingDate)
# new variable yearlyPay
self.yearlyPay = yearlyPay
# calculate weekly pay and weekly tax based on yearlyPay
self.calcWeeklyPay()
self.calcWeeklyTax(self.weeklyPay)
def __init__(self,
n=None,
a=None,
ID=None,
add=None,
s=0,
p='unknown'): #constructor method
Employee.__init__(self, n, a, ID, add) #initializing objects
self.salaray = s
self.employee_personal = p #this variable is for storing individual employee data that has been salaried
def test_fulName(self):
print('test_fulName')
self.emp1 = Employee('Tanvi','Satheesh',5000)
self.emp2 = Employee('Divya','Satheesh',10000)
self.assertEqual(self.emp1.fulname,'Tanvi Satheesh')
self.assertEqual(self.emp2.fulname,'Divya Satheesh')
self.emp1.first = 'Manasvi'
self.emp2.last = 'Srirangapatna'
self.assertEqual(self.emp1.fulname,'Manasvi Satheesh')
self.assertEqual(self.emp2.fulname,'Divya Srirangapatna')
def get(self):
# check if any employee is in the system, if not, create an administrator
users = Employee.query().fetch()
if len(users) == 0:
swaiss = Employee(username="******",
password="******",
email="*****@*****.**",
isAdmin=True,
isActive=True)
swaiss.put()
dummy = Employee(username="******",
password="******",
email="*****@*****.**",
isAdmin=False,
isActive=True)
dummy.put()
# pulls current year to put into footer for copyrights
dateTimeNow = datetime.datetime.now()
curYear = dateTimeNow.year
values = {"curYear": curYear}
template = JINJA_ENVIRONMENT.get_template('HTML/Login.html')
self.response.write(template.render(values))
def test_getters(self):
e = Employee("Joe Namath", "*****@*****.**", "392 493 4939",
"Marketing", "Marketing Manager", "U of Minnesota")
assert e.get_name() == "Joe Namath"
assert getattr(e, "name") == "Joe Namath"
assert getattr(e, "email") == "*****@*****.**"
assert getattr(e, "phone") == "392 493 4939"
assert getattr(e, "department") == "Marketing"
assert getattr(e, "title") == "Marketing Manager"
assert getattr(e, "education") == "U of Minnesota"
class EmployeeTestCase(unittest.TestCase):
def setUp(self):
self.employee = Employee('Yushun', 'Xu', 10000)
def test_give_default_raise(self):
self.employee.give_raise()
self.assertEqual(self.employee.salary, 15000)
def test_give_custom_raise(self):
self.employee.give_raise(10000)
self.assertEqual(self.employee.salary, 20000)
class TestEmployee(unittest.TestCase):
def setUp(self):
self.my_money = Employee('lee', 'tom', 1000)
def test_give_default_raise(self):
infor = self.my_money.give_raise()
self.assertEqual(infor, 6000)
def test_give_custom_raise(self):
infor1 = self.my_money.give_raise(2000)
self.assertEqual(infor1, 3000)
class GiveRaiseTestCase(unittest.TestCase):
def setUp(self):
self.e1 = Employee("venkat", "jalaneela", 5000)
def test_default_raise(self):
self.e1.give_raise()
self.assertEqual(10000, self.e1.annualsalary)
def test_give_custom_raise(self):
self.e1.give_raise(7000)
self.assertEqual(12000, self.e1.annualsalary)
def __init__(self, employeeID, firstName, lastName, birthYear, birthMonth,
birthDay, startingDate, hoursWorked, rateOfPay):
# call superclass constructor
Employee.__init__(self, employeeID, firstName, lastName, birthYear, birthMonth,
birthDay, startingDate)
# new variables hoursWorked and rateOfPay
self.hoursWorked = hoursWorked
self.rateOfPay = rateOfPay
# calculate weekly pay and weekly tax based on hoursWorked and rateOfPay
self.calcWeeklyPay()
self.calcWeeklyTax(self.weeklyPay)
class SalaryIncrementTest(unittest.TestCase):
def setUp(self):
self.my_employee = Employee("Elon", "Musk", 100000)
def test_give_default_(self):
self.my_employee.give_raise()
self.assertEqual(self.my_employee.salary, 105000)
def test_give_custom_raise(self):
self.my_employee.give_raise(100)
self.assertEqual(self.my_employee.salary, 100100)
class test_Employee(unittest.TestCase):
def setUp(self):
self.employee = Employee("xp", "liao", 100000)
def test_give_default_raise(self):
self.employee.give_raise()
self.assertEqual(105000, self.employee.annualSalary)
def test_give_custom_raise(self):
self.employee.give_raise(7000)
self.assertEqual(107000, self.employee.annualSalary)
def main():
name=input("Enter the Emplyoee name:\n")
design=input("Enter the designation:\n")
salary=eval(input("Enter the salary\n"))
DA=eval(input("Enter the DA\n"))
HRA=eval(input("Enter HRA\n"))
#create an object
emp=Employee(name,design,salary,DA,HRA)
print("The gross salary is",emp.grosssalary())
class TestEmployee(unittest.TestCase):
def setUp(self):
self.bob = Employee("Bob", "Barker", 90000)
def test_give_default_raise(self):
self.bob.give_raise()
self.assertEqual(95000, self.bob.salary)
def test_give_custom_raise(self):
self.bob.give_raise(10000)
self.assertEqual(100000, self.bob.salary)
class TestEmployee(unittest.TestCase):
def setUp(self):
self.test_one = Employee('lazada', 'Hola', 25000)
def test_give_default_raise(self):
self.test_one.give_raise()
self.assertEqual(self.test_one.an_salary, 30000)
def test_tive_custom_raise(self):
self.test_one.give_raise(1000)
self.assertEqual(self.test_one.an_salary, 26000)
def addNormalEmployee(self, employeeUserName, employeePassword, reporting):
enUserType = "Employee"
employee = Employee()
employee.setEnUserType(enUserType)
employee.setsUserid(employeeUserName)
employee.setsPassword(employeePassword)
employee.SetRA(reporting)
return employee
class TestEmployee(unittest.TestCase):
'''针对Employee类的测试'''
def setUp(self):
self.employee = Employee('x', 'rr', 4500)
def test_give_default_raise(self):
self.employee.give_raise()
self.assertEqual(self.employee.salary, 9500)
def test_give_custom_raise(self):
self.employee.give_raise(10000)
self.assertEqual(self.employee.salary, 14500)
class TestEmployee(unittest.TestCase):
def setUp(self):
first_name = 'John'
last_name = 'Bunyan'
ssn = '123-45-6789'
phone_num = '252-989-5555'
status = True
date = '2020-10-01'
self.new_employee = Employee(
date,
first_name,
last_name,
ssn,
phone_num,
status,
)
# def tearDown(self):
# self.new_employee.dispose()
def test_employee_constructor(self):
first_name = 'John'
last_name = 'Bunyan'
ssn = '123-45-6789'
phone_num = '252-989-5555'
status = True
date = '2020-10-01'
self.assertEqual(self.new_employee.first_name, first_name)
self.assertEqual(self.new_employee.last_name, last_name)
self.assertEqual(self.new_employee.social_security_number, ssn)
self.assertEqual(self.new_employee.phone_number, phone_num)
self.assertTrue(self.new_employee.status)
self.assertEqual(self.new_employee.hire_date, date)
def test_set_hire_date(self):
date = '2020-11-01'
self.new_employee.set_hire_date(date)
self.assertEqual(self.new_employee.hire_date, date)
def test_set_hire_date_invalid_inputs(self):
with self.assertRaises(ValueError):
date = '2020-11-0'
self.new_employee.set_hire_date(date)
with self.assertRaises(TypeError):
date = 20201101
self.new_employee.set_hire_date(date)
def test_get_hire_date(self):
date = '2020-10-01'
self.assertEqual(self.new_employee.get_hire_date(), date)
def test_change_status(self):
self.new_employee.change_status()
self.assertFalse(self.new_employee.status)
def userInfo(employee_id):
if request.method=='POST':
req = request.form.get('offDay')
Employee(int(employee_id)).setOffDay(int(req))
penalty = request.form.get('penalty')
if penalty != "None":
Employee(int(employee_id)).addPenalty(int(penalty))
print(penalty)
employee_id = int(employee_id)
data = emp.Employee(employee_id)
penaltyList = list(collection.find({"emp_id":employee_id}))
attendances = list(data.viewAttendance())[0]['attendance']
return render_template('userinfo.html', emp_id=employee_id, data=data, attendances=attendances, calendar=calendar,penaltyList=penaltyList)
class employeeTestCase(unittest.TestCase):
""" Create a test for the Empoyee class. """
def setUp(self):
self.my_employee = Employee("Mohammad", "Boustta")
self.annual_salary = 10000
def test_give_default_raise(self):
self.assertEqual(self.my_employee.annual_salary, 0)
def test_give_custom_raise(self):
self.my_employee.give_raise()
self.my_employee.give_raise(100000)
self.assertTrue(self.my_employee.annual_salary, 100000)
class EmployeeTset(unittest.TestCase):
def setUp(self):
self.my_enter = Employee('Liu', 'Jin', 145000)
def test_give_default_raise(self):
'''测试默认的年薪增加值'''
self.my_enter.give_raise()
self.assertEqual(self.my_enter.payment, 150000)
def test_give_custom_raise(self):
'''测试传递一个实参'''
self.my_enter.give_raise(9000)
self.assertEqual(self.my_enter.payment, 154000)
class test(unittest.TestCase):
def setUp(self):
self.employee = Employee('Josiah', 'Carlson', 2000)
def test_give_default_raise(self):
self.employee.give_raise()
raises = self.employee.raises
self.assertEqual(raises, 7000)
def test_give_custom_raise(self):
self.employee.give_raise(3000)
raises = self.employee.raises
self.assertEqual(raises, 5000)
class Testemplyee(unittest.TestCase):
@classmethod
def setUpClass(cls):
print('setUpClass')
@classmethod
def tearDownClass(cls):
print('tearDownClass')
def setUp(self):
print('setup')
self.emp1 = Employee('Tanvi','Satheesh',5000)
self.emp2 = Employee('Divya','Satheesh',10000)
def tearDown(self):
print('tearDown\n')
def test_email(self):
print('test_email')
self.assertEqual(self.emp1.email,'*****@*****.**')
self.assertEqual(self.emp2.email,'*****@*****.**')
self.emp1.first = 'Manasvi'
self.emp2.last = 'Srirangapatna'
self.assertEqual(self.emp1.email,'*****@*****.**')
self.assertEqual(self.emp2.email,'*****@*****.**')
def test_fulName(self):
print('test_fulName')
self.emp1 = Employee('Tanvi','Satheesh',5000)
self.emp2 = Employee('Divya','Satheesh',10000)
self.assertEqual(self.emp1.fulname,'Tanvi Satheesh')
self.assertEqual(self.emp2.fulname,'Divya Satheesh')
self.emp1.first = 'Manasvi'
self.emp2.last = 'Srirangapatna'
self.assertEqual(self.emp1.fulname,'Manasvi Satheesh')
self.assertEqual(self.emp2.fulname,'Divya Srirangapatna')
def test_apply_riase(self):
print('test_apply_raise')
self.emp1.pay = 6000
self.emp2.pay = 11000
self.assertEqual(self.emp1.apply_riase(),60000)
self.assertEqual(self.emp2.apply_riase(),110000)
def test_monthly_schedule(self):
with patch('Employee.requests.get') as mocked_get:
mocked_get.retun_value.ok = True
mocked_get.retun_value.text = 'Success'
schedule = self.emp1.monthly_schedule('May')
mocked_get.assert_called_with('http://company.com/Satheesh/May')
self.assertEqual(schedule, 'Success')
class TestEmployee(unittest.TestCase):
def setUp(self):
self.kkk = Employee('Tom', 'Smith', 10000)
def test_give_default_raise(self):
salary = self.kkk.salary
self.kkk.give_raise()
self.assertEqual(salary + 5000, self.kkk.salary)
def test_give_custom_raise(self):
salary = self.kkk.salary
_give = 6000
self.kkk.give_raise(_give)
self.assertEqual(salary + _give, self.kkk.salary)
class TestEmployee(unittest.TestCase):
"""docstring for TestEmployee"""
#setup函数建立默认实例化内容，避免重复实例化浪费资源。
def setUp(self):
self.employeea = Employee('slade', 5000)
def test_give_default_raise(self):
salary1 = self.employeea.give_default_raise()
self.assertEqual(salary1, 10000)
def test_give_custom_raise(self):
salary2 = self.employeea.give_custom_raise(1000)
self.assertEqual(salary2, 6000)
class TestEmployee(unittest.TestCase):
def setUp(self):
self.name = 'Pawat'
self.last = 'Biggy'
self.a_salary = 5000
self.custom = 7000
self.my_employee = Employee(self.name, self.last, self.a_salary)
def test_give_default_raise(self):
self.my_employee.give_raise()
self.assertEqual(10000, self.my_employee.annual_salary)
def test_give_custom_raise(self):
self.my_employee.give_raise(adds=self.custom)
self.assertEqual(12000, self.my_employee.annual_salary)
def editEmp():
id = request.args.get('id', '')
print(request.json)
if not request.json:
abort(400)
DataBase.editEmp(id,Employee(0,request.json['Login'],request.json['Name'],Employee.hashPassword(request.json['Password']),request.json['Salary']))
return jsonify({'status':'good'})
def login():
print(request.json)
if not request.json:
abort(400)
data = DataBase.isUser(request.json['Login'],Employee.hashPassword(request.json['Password']))
if not data:
return jsonify({'status':"Invalide user name or password"})
else:
return jsonify({'status':'good','data':data})
def staff_parser(text):
parts = text.split(',')
employee = Employee(parts[0])
shift_max_pairs = map(lambda x: x.split('='), parts[1].split('|'))
shifts_max = {}
for shift, limit in shift_max_pairs:
shifts_max[shift] = int(limit)
employee.set_max_shifts(shifts_max)
employee.max_total_minutes = int(parts[2])
employee.min_total_minutes = int(parts[3])
employee.max_consecutive_shifts = int(parts[4])
employee.min_consecutive_shifts = int(parts[5])
employee.min_consecutive_days_off = int(parts[6])
employee.max_weekends = int(parts[7])
return employee
class TestEmployee(unittest.TestCase):
def setUp(self):
self.emp1 = Employee("Vesa", "Kuoppala", 10.0)
def tearDown(self):
None
def test_too_many_hours_raises_an_error(self):
with self.assertRaises(ValueError):
self.emp1.payment(200)
def test_double_time_hours_give_proper_payment(self):
self.assertEqual(1500.00, self.emp1.payment(100))
def test_time_and_half_hours_give_proper_payment(self):
self.assertEqual(550.00, self.emp1.payment(50))
def test_regular_time_hours_give_proper_payment(self):
self.assertEqual(200.00, self.emp1.payment(20))
def test_negative_hours_raises_an_error(self):
with self.assertRaises(ValueError):
self.emp1.payment(-10)
def setUp(self):
self.emp1 = Employee("Vesa", "Kuoppala", 10.0)
phoneName = {x[0]:x[1] for x in Threatphone}
#Creating all of our employee objects
emp=[]
idnum = 0
name = ''
ntid = ''
temp = 0
for i in range(1,1001):
idnum = int(employee_info.cell(i,0).value) #Finding Employee ID Number and storing it in idnum
name = employee_info.cell(i,7).value + ',' + employee_info.cell(i,5).value #Finding Employee Name and storing it in name
for j in range(1,job_hx.nrows):
if (int(job_hx.cell(j,0).value) == idnum):
ntid = job_hx.cell(j,19).value #Finding NTID and storing it in ntid
break
Temp = Employee(idnum, name, ntid)
try:
temp = phoneName[name]
Temp.threat = temp
except KeyError:
pass #Creating a Employee object
emp.append(Temp) #Storing the object in a list of the employee objects
print 'id,name,ntid,threat,state,department'
for i in range(0,len(emp)):
Threatphone = emp[i].threat
Threatair = airThreat(emp[i], air_travel)
Threataccess = access_log(emp[i], access_logs)
Threatjobhx,state,dept = job_history_score(emp[i], job_hx)
def test_get_name(self):
employee = Employee("Maik")
self.assertEqual("Maik", employee.get_name())
def createEmp():
if not request.json:
abort(400)
DataBase.createEmp(Employee(0,request.json['Login'],request.json['Name'],Employee.hashPassword(request.json['Password']),request.json['Salary']))
return jsonify({'status':'good'})
def employeeObjectTests():
emp1 = Employee("Zara", "Zara", 27, 'F', 2000)
emp2 = Employee("Clara", "Clara", 31, 'M', 10000)
emp1.displayCount()
emp1.displayEmployee()
emp2.displayCount()
emp2.displayEmployee()
attrManipulation(emp2)
emp1.displayEmployeeMetaInfo()
def test_employee_title(self):
emp5 = Employee("Ethan", title = "CEO", salary = 100000, rank = 1)
emp6 = Employee("Frank", title = "Program Manager", salary = 5000, rank = 4)
self.assertEqual(emp5.getTitle(), "CEO")
#!/usr/bin/python
import sys
## change this path to where Date.py is defined.
load_path = '/home/vladimir/programming/py/oop/'
if __name__ == '__main__':
if not load_path in sys.path:
sys.path.append(load_path)
from Employee import Employee
from Date import Date
hire_date = Date()
hire_date.setMonth(10)
hire_date.setDay(10)
hire_date.setYear(2010)
emp = Employee()
emp.setFirstName('John')
emp.setLastName('Nicholson')
emp.setHireDate(hire_date)
print 'First Name: ' + emp.getFirstName()
print 'Last Name: ' + emp.getLastName()
print 'Hire Date: ' + emp.getHireDate().toMDYString()
def setUp(self):
self.name = 'Pawat'
self.last = 'Biggy'
self.a_salary = 5000
self.custom = 7000
self.my_employee = Employee(self.name, self.last, self.a_salary)
from Employee import Employee
emp1 = Employee("Zara", 2000)
"This would create second object of Employee class"
emp2 = Employee("Manni", 5000)
emp1 = Employee("Zara", 2000)
"This would create second object of Employee class"
emp2 = Employee("Manni", 5000)
emp1.displayEmployee()
emp2.displayEmployee()
return
def Fire():
fireEmployee = input("Enter employees full name to terminate: ")
info.Fire(fileIn, fireEmployee)
return
try:
fileIn = open('employees.txt','r')
for line in fileIn:
employeeName = fileIn.readline()
employeeTitle = fileIn.readline()
employeePay = fileIn.readline()
info = Employee(employeeName, employeeTitle, employeePay)
info.printEmployee()
fileIn.close()
except IOError:
print("An error has occured while reading in the file")
while True:
print("\n Press 'H' - Hire employee")
print("\n Press 'F' - Fire employee")
print("\n Press 'E' - Exit")
userInput = input("Please enter a valid value: ")
if userInput == 'H':
Hire()
def testEmployee(self):
employeeTest = Employee("12345","Richard","Barney","1990","03","25","2015-11-02")
employeeString = "12345\t\tRichard Barney\t\t1990-03-25\t2015-11-02"
self.assertEqual(employeeString, employeeTest.__str__())
def test_employee_salary(self):
emp1 = Employee("Alice", title = "Software Engineer", salary = 2000, rank = 5)
emp2 = Employee("Bob", title = "Program Manager", salary = 5000, rank = 4)
self.assertTrue(emp1.getSalary() < emp2.getSalary())
def __init__(self,name,salary):
self.name=name
self.salary=salary
Employee.__init__(self,"name","Manager",salary)
def __init__(self,name,salary):
self.name=name
self.salary=salary
Employee.__init__(self,name,"Developer",salary)
while (True):
user_input = raw_input("Enter the number: \n1: To add the Employee detail \n2: To search Employee \n3: To delete Employee \n4: To Exit Program\n")
if user_input == '0':
break
elif user_input == '1':
print("Enter the following details of employee")
name = raw_input("Name: ")
number = raw_input("Employee Number: ")
department = raw_input("Department Name: ")
dob = raw_input("Date of birth: ")
join_date = raw_input("Joined Date: ")
salary = raw_input("Employee Salary: ")
emp = Employee(name, number, department, dob, join_date, salary)
print(type(emp.__str__()))
print (type("Shankar"))
file = open("employee_record.txt", 'a')
file.write("%s%s" % (emp.__str__(),"\n"))
file.close()
elif user_input == '2':
print ("Enter the Employee name to search")
name = raw_input("Name: ")
with open('employee_record.txt') as f:
for line in f:
employee_name = line.split("|", 5)
# print employee_name[0]
def test_employee_rank(self):
emp3 = Employee("Charlie", title = "CTO", salary = 3000, rank = 2)
emp4 = Employee("Deborah", title = "CFO", salary = 4000, rank = 3)
self.assertTrue(emp3.getRank() < emp4.getRank())
def test_employee_extension(self):
emp7 = Employee("Gilbery", title = "Secretary", salary = 1500, rank = 5)
emp8 = Employee("Henry", title = "Program Manager", salary = 5000, rank = 4)
self.assertTrue(not emp7.getTitle() is emp8.getTitle())
