コード例 #1
0
ファイル: app.py プロジェクト: unokun/flask
def delete_employee(id):
    errors = []

    employee = Employee.find_by_id(id)
    Employee.delete(id)
    success = "データベースから社員(" + employee.name + ")を削除しました。"

    return render_template('result.html', success=success, errors=errors)
コード例 #2
0
 def __init__(self, db, user):
     """
     Initialising database and User
     :param db:
     :param user:
     """
     self.db = db
     self.user = user
     self.employee = Employee(db, user)
コード例 #3
0
 def print_body_for_user(self, authenticated_user):
     db_session = DB_Session_Factory.get_db_session()
     employee = db_session.query(Employee).get(authenticated_user.email)
     if employee is None:
         employee = Employee(authenticated_user.email)
     reimbursements = []
     for reimbursement in db_session.query(Reimbursement).all():
         reimbursements.append(reimbursement.dict_representation())
     final_output_dict = {"employee": employee.dict_representation(), "reimbursement_policy": reimbursements}
     print json.dumps(final_output_dict)
コード例 #4
0
ファイル: app.py プロジェクト: unokun/flask
def download_employee():
    f = StringIO()
    writer = csv.writer(f,
                        quotechar='"',
                        quoting=csv.QUOTE_ALL,
                        lineterminator="\n")

    writer.writerow([
        'id', '名前', '年齢', '性別', '郵便番号', '都道府県', '住所', '部署名', '入社日', '退社日',
        '作成日時', '更新日時'
    ])
    employees = Employee.find_all_in_details()
    for emp in employees:
        writer.writerow([
            emp.id, emp.name, emp.age, emp.gender, emp.zip_cd, emp.pref_name,
            emp.address, emp.div_name, emp.hired_date, emp.retired_date,
            emp.created_at, emp.updated_at
        ])

    res = make_response()
    res.data = f.getvalue()
    res.headers['Content-Type'] = 'text/csv'
    res.headers[
        'Content-Disposition'] = 'attachment; filename=employee_list.csv'
    return res
コード例 #5
0
    def register_employee(self, employee_type, username, hash_password, cpf, name, birthday, photo_location, role, condominium_id):
        try:
            birthday = datetime.datetime.strptime(birthday, '%Y-%m-%d')
            employee = Employee(type=employee_type, cpf=cpf, name=name, birthday=birthday, photo_location=photo_location, role=role, condominium_id=condominium_id)
            employee_user = EmployeeUser(password=hash_password)
            employee_user._username = Username(username=username)
            employee.user = employee_user

            db.session.add(employee)
            db.session.commit()

            return employee

        except exc.IntegrityError as e:
            db.session.rollback()
            return None
コード例 #6
0
def save_employee(position, save, obj=None):
    employee = Employee(password=request.form['password'],
                        first_name=request.form['first_name'],
                        last_name=request.form['last_name'],
                        position=position,
                        telephone=request.form.get('phone_number', ''),
                        mail=request.form.get('mail', ''),
                        salary=request.form.get('salary', ''))
    if save == 'add':
        employee.add_employee()
    elif save == 'edit':
        obj.edit_employee(password=request.form['password'],
                          first_name=request.form['first_name'],
                          last_name=request.form['last_name'],
                          telephone=request.form.get('phone_number', ''),
                          mail=request.form.get('mail', ''),
                          salary=request.form.get('salary', ''))
コード例 #7
0
ファイル: app.py プロジェクト: unokun/flask
def edit_employee(id):
    employee = Employee.find_by_id(id)
    divisions = Division.find_all()
    prefectures = Prefecture.find_all()
    return render_template('edit_employee.html',
                           employee=employee,
                           divisions=divisions,
                           prefectures=prefectures)
コード例 #8
0
ファイル: company.py プロジェクト: rapid-snail/soap-test
 def update_from_soap(self, obj):
     self.id = str(obj.Id)
     self.created_at = obj.CreatedAt
     self.updated_at = obj.UpdatedAt
     self.name = obj.Name
     if hasattr(obj, "employees"):
         self.employees = [Employee().update_from_soap(x) for x in obj.employees]
     return self
コード例 #9
0
def delete_assistant(employee_id):
    """
    Remove assistant from list(data base)
    :param employee_id: int
    GET return list of assistants without removed assistant
    """
    assistant = Employee.get_by_id(employee_id, 'assistant')
    assistant.delete_employee()
    flash('Assistant was deleted')
    return redirect(url_for('employee_controller.list_assistants'))
コード例 #10
0
    def show_add_emp_dialog(self):
        dialog = loadUi("../view/add_emp.ui")
        dialog.de_hire_date.setDate(datetime.today())
        jobs = {str(e.job_id) for e in self.emps}
        dialog.cb_jobs.addItems(jobs)
        depts = [d.dept_name for d in self.depts]
        dialog.cb_depts.addItems(depts)
        choice = dialog.exec()

        if choice == 1:
            idx = dialog.cb_depts.currentIndex()
            e = Employee(dialog.le_emp_id.text(), dialog.le_emp_name.text(),
                         dialog.le_email.text(),
                         dialog.de_hire_date.date().toString("yyyy-MM-dd"),
                         dialog.cb_jobs.currentText(), dialog.le_salary.text(),
                         self.depts[idx - 1].dept_id)
            self.emps.append(e)
            self.load_emps()
            e.save_to_db()
コード例 #11
0
ファイル: soap.py プロジェクト: rapid-snail/soap-test
    def update_employee(self, id, first_name, last_name, middle_name):
        client = Client(self.url, faults=True)

        try:
            response = client.service.UpdateEmployee(id, first_name, last_name, middle_name)
        except WebFault as e:
            return (False, None, e.fault)

        employee = Employee().update_from_soap(response)
        return (True, employee, None)
コード例 #12
0
def list_assistants():
    """
    GET to generate a list of assistants
    """
    assistants_list = Employee.list_employee('assistant')
    add = 'employee_controller.add_assistant'
    edit = 'employee_controller.edit_assistant'
    delete = 'employee_controller.delete_assistant'
    return render_template('viewemployee.html', user=user_session(session['user'], session['type']),
                           employee_list=assistants_list, employee='Assistant',
                           add=add, edit=edit, delete=delete)
コード例 #13
0
ファイル: app.py プロジェクト: unokun/flask
def create_employee():
    errors = []
    if not request.form['name']:
        errors.append('名前は必須です。')

    cmd_type = request.form['cmd-type']
    if cmd_type == 'cancel':
        return render_template('new_division.html')

    success = ''
    age = 0
    pref_cd = 0
    photo_img = None
    mimetype = ''
    div_id = None
    hired_date = None
    retired_date = None
    if not errors:
        name = request.form['name']
        if len(request.form['age']) > 0:
            age = request.form['age']
        gender = request.form['gender']
        zip_cd = request.form['zip-cd']
        if len(request.form['pref-cd']) > 0:
            pref_cd = request.form['pref-cd']
        address = request.form['address']
        if len(request.form['div-id']) > 0:
            div_id = request.form['div-id']
        if len(request.form['hired-date']) > 0:
            hired_date = request.form['hired-date']
        if len(request.form['retired-date']) > 0:
            retired_date = request.form['retired-date']
        if request.files['image-file']:
            f = request.files['image-file']
            photo_img = f.read()
            mimetype = f.mimetype
        Employee.insert(name, age, gender, zip_cd, pref_cd, address, div_id,
                        hired_date, retired_date, photo_img, mimetype)
        success = "社員の登録に成功しました。"

    return render_template('result.html', success=success, errors=errors)
コード例 #14
0
    def get_employee_by_id(self, employee_id):
        sql = "SELECT * FROM employee where id = %s"
        cursor = connection.cursor()
        cursor.execute(sql, [employee_id])
        record = cursor.fetchone()
        cursor.close()

        if record:
            return Employee(record[0], record[1], record[2], record[3],
                            float(record[4]), record[5])
        else:
            raise ResourceNotFound(
                f"Employee record could not be verified with input data.")
コード例 #15
0
    def employee_authentication(self, employee):
        sql = "SELECT * FROM employee where employee_name = %s AND title = %s"
        cursor = connection.cursor()
        cursor.execute(sql, (employee.name, employee.title))
        record = cursor.fetchone()
        cursor.close()

        if record:
            return Employee(record[0], record[1], record[2], record[3],
                            float(record[4]), record[5])
        else:
            raise ResourceNotFound(
                f"Employee record could not be verified with input data.")
コード例 #16
0
def edit_assistant(employee_id):
    """
    Edit assistant formula to edit assistant details
    :param employee_id: int
    GET return edit assistants formula
    POST return list of assistants with edited assistant changes saved
    """
    assistant = Employee.get_by_id(employee_id, 'assistant')
    if request.method == 'POST':
        save_employee('assistant', 'edit', assistant)
        flash('Assistant was edited')
        return redirect(url_for('employee_controller.list_assistants'))
    return render_template('editemployee.html', user=user_session(session['user'], session['type']), employee=assistant,
                           list='employee_controller.list_assistants')
コード例 #17
0
 def print_body_for_user(self, authenticated_user):
     db_session = DB_Session_Factory.get_db_session()
     employee = db_session.query(Employee).get(authenticated_user.email)
     if employee is None:
         employee = Employee(authenticated_user.email)
         db_session.add(employee)
         sys.stderr.write(employee.email)
     max_amounts = {}
     for reimbursement in db_session.query(Reimbursement).all():
         max_amounts[reimbursement.id] = reimbursement.max_amount
     error = None
     if self.requested_gym_reimbursement > max_amounts['gym'] or self.requested_mobile_reimbursement > max_amounts['mobile']:
         error = "You are asking too much."
     else:
         employee.gym = self.requested_gym_reimbursement
         employee.mobile = self.requested_mobile_reimbursement
     db_session.commit()
     final_output_dict = {}
     if error is not None:
         final_output_dict['error'] = error
     else:
         final_output_dict['status'] = 'ok';
     print json.dumps(final_output_dict)
コード例 #18
0
 def main_dashboard(self, db, user):
     """
     Main Dashboard
     :param db:
     :param user:
     :return:
     """
     print(
         'Welcome to Cab Booking Service!!\nLogin as :\n1 : Admin\n2 : Employee\n3 : Exit'
     )
     while True:
         try:
             n = int(input('Enter your choice : '))
             break
         except:
             print('\n***Only numbers is allowed***\n')
     if n == 1:
         admin = Admin(db, user)
         admin.login()
     elif n == 2:
         employee = Employee(db, user)
         employee.login()
     else:
         sys.exit(1)
コード例 #19
0
 def post_authentication_employee():
     try:
         print("here")
         employee = Employee.json_parse(request.json)
         print(f"name: {employee.name} title: {employee.title}")
         employee = EmployeeService.employee_authentication(employee)
         # before returning any data after an employee is verified
         # need to check if any pending process have taken too long
         # I decided each manager gets five day to approve or deny
         # if it is day five and the requester still needs to add info
         # The claim could be auto-rejected and if the manager requests
         # addition information on the fifth day I could add one day
         return jsonify(employee.json()), 202  # accepted
     except ResourceNotFound as r:
         return r.message, 404
コード例 #20
0
ファイル: app.py プロジェクト: unokun/flask
def find_employees():
    div_id = 0
    id_from = 0
    id_to = 0
    if len(request.form['div-id']) > 0:
        div_id = int(request.form['div-id'])
    if len(request.form['id-from']) > 0:
        id_from = int(request.form['id-from'])
    if len(request.form['id-to']) > 0:
        id_to = int(request.form['id-to'])
    kw = request.form['kw']

    # TODO: 社員ID範囲チェック
    employees = Employee.find_by(div_id, id_from, id_to, kw)
    return render_template('employee_list.html', employees=employees)
コード例 #21
0
def user_session(id, class_name):
    """Return object with given class name in class_name and id"""
    if class_name == "Student":

        return Student.get_by_id(id)
    elif class_name == "Mentor":

        return Mentor.get_by_id(id)
    elif class_name == "Employee":

        return Employee.get_by_id(id, 'assistant')
    elif class_name == "Manager":

        return Manager.get_by_id(id)
    return None
コード例 #22
0
    def __init__(self):
        QWidget.__init__(self)
        self.setupUi(self)

        self.depts = Department.get_all_deps()
        self.load_depts()

        self.emps = Employee.get_all_emps()
        self.load_emps()

        self.cb_depts.currentIndexChanged.connect(self.filter_emps_by_dept)
        self.le_search.textChanged.connect(self.filter_emps_by_name)
        self.bt_add_dept.clicked.connect(self.show_add_dialog)
        self.bt_del_dept.clicked.connect(self.delete_dept)
        self.bt_add_emp.clicked.connect(self.show_add_emp_dialog)
        self.bt_del_emp.clicked.connect(self.delete_emp)
        self.bt_export.clicked.connect(self.export_data)
コード例 #23
0
    def __init__(self):
        super().__init__()
        self.setupUi(self)

        self.depts = Department.get_all_depts()
        self.load_depts()

        self.emps = Employee.get_all_emps()
        self.load_emps()

        self.sb_depts.currentIndexChanged.connect(self.filter_emps_by_dept)
        self.le_search.textChanged.connect(self.filter_emps_by_name)

        self.bt_add_dept.clicked.connect(self.show_add_dept_dialog)

        self.bt_exit.clicked.connect(app.exit)
        self.bt_del_dept.clicked.connect(self.delete_dept)
        self.bt_add_emp.clicked.connect(self.show_add_emp_dialog)
        self.bt_del_emp.clicked.connect(self.delete_emp)
        self.pushButton_5.clicked.connect(self.export_data)

        print()
コード例 #24
0
def init_db():
    """
    Initializes the database with some starter data.
    """
    from model.department import Department
    from model.employee import Employee
    Base.metadata.drop_all(bind=engine)
    Base.metadata.create_all(bind=engine)

    # Create the fixtures
    engineering = Department(name='Engineering')
    hr = Department(name='Human Resources')
    marketing = Department(name='Marketing')

    db_session.add_all([engineering, hr, marketing])
    db_session.add(Employee(name='Peter', salary=50000,
                            department=engineering))
    db_session.add(Employee(name='Roy', salary=75000, department=engineering))
    db_session.add(Employee(name='Tracy', salary=25000, department=hr))

    # Arbitrarily produce data
    for i in range(50):
        if i % 3 == 0:
            db_session.add(
                Employee(name='George #' + str(i),
                         salary=25000 + i,
                         department=hr))
        elif i % 2 == 0:
            db_session.add(
                Employee(name='Samuel #' + str(i),
                         salary=60000 - i,
                         department=marketing))
        else:
            db_session.add(
                Employee(name='Albert #' + str(i),
                         salary=12000 - i,
                         department=engineering))

    db_session.commit()
コード例 #25
0
 def add_new_employee(self):
     name, password = self.ui.login_inputs()
     surname, birth, earnings = self.ui.new_employee_inputs()
     customer = Employee(self.user, earnings, name, surname, birth)
     self.dao.save_password_new_person(name, password)
コード例 #26
0
    "no_error": ""
}


def gen_str(symbols, max_len):
    return "".join(
        [random.choice(symbols) for _ in range(random.randrange(max_len))])


def random_string(prefix, max_len):
    symbols = string.ascii_letters + " "
    return prefix + gen_str(symbols, max_len)


test_data = [(Employee(first_name=random_string("fn_", 50),
                       last_name=random_string("ln_", 50),
                       middle_name=random_string("mn_",
                                                 50)), err_map['no_error']),
             (Employee(first_name=random_string("fn_", 50),
                       last_name=random_string("ln_", 50),
                       middle_name=""), err_map['no_error']),
             (Employee(first_name=random_string("fn_", 50),
                       last_name=random_string("ln_", 50),
                       middle_name=None), err_map['no_error'])]


@pytest.mark.parametrize("data", test_data)
def test_add_employee(soap, data):
    (employee, err_msg) = data
    (found, response, fault) = soap.add_employee(employee.first_name,
                                                 employee.last_name,
                                                 employee.middle_name)
コード例 #27
0
def update_employee(*, id, code, name):
    emp = Employee(code, name)
    emp.id = id
    Database.update_employee(emp)
コード例 #28
0
def save_employee(*, code, name):
    emp = Employee(code, name)
    Database.save_employee(emp)
コード例 #29
0
class Admin:
    def __init__(self, db, user):
        """
        Initialising database and User
        :param db:
        :param user:
        """
        self.db = db
        self.user = user
        self.employee = Employee(db, user)

    def login(self):
        """
        Login validation and homescreen for Admin
        :return:
        """
        username = input("Enter username: "******"Enter password: "******"Admin")
        if not access:
            print("Username/Password not matched")
            return
        name = self.db.get_name(dict, "Admin")
        print(f"\nWelcome {name}\n")
        while True:
            n = input(
                '\n1: Check total booking\n2: Check booking of an employee\n'
                '3: Add a cab\n4: Update cab details\n5: Add/Update/Delete Employee\n'
                '6: Logout\nEnter your choice : ')
            if n == '1':
                self.check_total_booking()
            elif n == '2':
                self.check_employee_booking()
            elif n == '3':
                self.add_cab()
            elif n == '4':
                self.update_cab_details()
            elif n == '5':
                self.crud_employee()
            elif n == '6':
                break
            else:
                print('\nWrong Choice!! Try again\n')
        print("\nLogging out!!\n")
        time.sleep(.5)

    def check_total_booking(self):
        """
        Showing total booking record based on date, week, month
        :return:
        """
        date = input('\nEnter the date in DD-MM-YYYY format: ')
        while True:
            try:
                n = int(
                    input(
                        '\n1: See booking records date-wise\n2: See booking records week-wise'
                        '\n3: See booking records month-wise\nEnter your choice: '
                    ))
                break
            except:
                print("\n***Only numbers are allowed***\n")
        if n == 1:
            record = self.db.get_record_datewise(date)
        elif n == 2:
            week_dict = {
                1: ('01', '02', '03', '04', '05', '06', '07'),
                2: ('08', '09', '10', '11', '12', '13', '14'),
                3: ('15', '16', '17', '18', '19', '20', '21'),
                4: ('22', '23', '24', '25', '27', '28', '29'),
                5: ('30', '31')
            }
            week_number = int(int(date[:2]) / 7) + 1
            week_list = week_dict[week_number]
            record = self.db.get_record_weekwise(date[3:], week_list)
        elif n == 3:
            record = self.db.get_record_monthwise(date[3:])

        if record == []:
            print('\nNo Travel History Found\n')
            return
        print('\n' +
              tabulate(record,
                       headers=[
                           'Employee ID', 'Cab Number', 'Trip Date', 'Time',
                           'Source Location', 'Destination', 'Status'
                       ],
                       tablefmt='orgtbl') + '\n')

    def check_employee_booking(self):
        """
        Check total booking record of a employee
        :return:
        """
        while True:
            try:
                employee_id = int(input('\nEnter the employee ID: '))
                break
            except:
                print("\n***Only numbers are allowed***\n")
        if not self.db.validate_record_existence(employee_id,
                                                 'employee_details'):
            print(f'\nNo employee found from id -> {employee_id}\n')
            return
        travel_history = self.db.get_travel_history(employee_id)
        if travel_history == []:
            print('\nNo Travel History Found\n')
            return
        print('\n' + tabulate(travel_history,
                              headers=[
                                  'Cab Number', 'Trip Date', 'Time',
                                  'Source Location', 'Destination', 'Status'
                              ],
                              tablefmt='orgtbl') + '\n')

    def add_cab(self):
        """
        Adding a new cab
        :return:
        """
        cab_detail_dict = self.input_cab_details()
        self.db.insert_cab_details(cab_detail_dict)
        print('\nNew cab details entered successfully\n')

    def update_cab_details(self):
        """
        Updating a cab details
        :return:
        """
        while True:
            try:
                cab_id = int(
                    input(
                        'Enter the cab ID of the cab you want to update details: '
                    ))
                break
            except:
                print("\n***Only numbers are allowed***\n")
        if not self.db.validate_record_existence(cab_id, 'cab_details'):
            print(f'No cab found from id -> {cab_id}')
            return
        cab_detail_dict = self.input_cab_details()
        self.db.update_details(cab_id, cab_detail_dict, 'cab_details')
        print('\nCab details updated successfully\n')

    def input_cab_details(self):
        """
        Common function for getting the cab details from user
        :return:
        """
        cab_number = input('Enter cab number: ')
        while True:
            try:
                seat_capacity = int(input('Enter the seats capacity: '))
                break
            except:
                print("\n***Only numbers are allowed***\n")
        locations = {
            1: "Koramangala",
            2: "HSR",
            3: "Bellandur",
            4: "Electronic City",
            5: "Sarjapur"
        }
        for item, value in locations.items():
            print(f"{item} : {value}")
        n = 0
        while True:
            try:
                n = int(
                    input(
                        'Enter the routes as in the number specified by them: '
                    ))
                break
            except:
                print('\n*Only numbers is alllowed*\n')
        route_num_list = [int(d) for d in str(n)]
        route = ""
        for item in route_num_list:
            route += ":" + locations[item]
        print(route[1:])
        time = input(
            'Enter the running time(24hrs, HH:mm format) of the cab comma(,) seperated: '
        )
        time_list = time.split(',')
        timing = ""
        for item in time_list:
            timing += "-" + item
        print(timing[1:])
        return {
            'cab_number': cab_number,
            'seat_capacity': seat_capacity,
            'seat_available': seat_capacity,
            'route': route[1:],
            'timing': timing[1:]
        }

    def crud_employee(self):
        """
        CRUD operations on employee
        :return:
        """
        while True:
            user_choice = input(
                '\n1: Create Employee\n2: Update Employee\n3: Delete Employee\n'
                'Any Other key to Exit\nEnter your choice: ')
            if user_choice == '1':
                self.employee.create_member()
            elif user_choice == '2':
                self.employee.update_member()
            elif user_choice == '3':
                self.employee.delete_member()
            else:
                print('')
                break
コード例 #30
0
ファイル: controller.py プロジェクト: Rayree/PythonClass
def add_employee(*, code, name):
    employee = Employee(code, name)
    Database.save_employee(employee)
コード例 #31
0
    "not_fount": "is not found",
    "no_error": ""
}


def gen_str(symbols, max_len):
    return "".join([random.choice(symbols) for _ in range(random.randrange(max_len))])


def random_string(prefix, max_len):
    symbols = string.ascii_letters + " "
    return prefix + gen_str(symbols, max_len)


test_data = [
    (Employee(id="5f17fe2949faca0001b68212", first_name=random_string("fn_", 50), last_name=random_string("ln_", 50),
              middle_name=random_string("mn_", 50)), err_map['no_error']),
    (Employee(id="5f17fe2949faca0001b68212", first_name=random_string("fn_", 50), last_name=random_string("ln_", 50), middle_name=""), err_map['no_error']),
    (Employee(id="5f17fe2949faca0001b68212", first_name=random_string("fn_", 50), last_name=random_string("ln_", 50), middle_name=None), err_map['no_error']),
    (Employee(id="5f17fe2949faca0001b68213", first_name=random_string("fn_", 50), last_name=random_string("ln_", 50), middle_name=""), err_map['not_fount'])
]


@pytest.mark.parametrize("data", test_data)
def test_update_employee(soap, data):
    (employee, err_msg) = data
    (found, response, fault) = soap.update_employee(employee.id, employee.first_name, employee.last_name, employee.middle_name)
    if found:
        print("%s" % response)
        assert response.last_name == employee.last_name
        assert err_msg == err_map['no_error']
        assert response.created_at != response.updated_at
コード例 #32
0
import json
from model.person import Person
from model.employee import Employee

p1 = Person("shajal", 27)
p2 = Person("Simon", 27)
p3 = Person("Iftekhar", 27)
plist = [p1, p2, p3]

with open("person_list.json", "w", encoding='utf-8') as f:
    for p in plist:
        f.write(p.to_json() + "\n")

e1 = Employee("Shajal", 27, 10, 'cse')
print(e1.name)