To create an advanced Python Employment Management application with an SQL database, we’ll structure our code using classes for employees, managers, salaries, and departments. Additionally, we’ll integrate SQLite3 as the database backend. Let’s start by creating the necessary classes.
1. Employee Class
import sqlite3
class Employee:
"""
The Employee class represents individual employees in the organization.
"""
def __init__(self, id, name, salary):
"""
Constructor to initialize employee attributes.
"""
self.id = id
self.name = name
self.salary = salary
def update_employee(self, name, salary):
"""
Method to update employee details in the database.
"""
conn = sqlite3.connect('employees.db')
cursor = conn.cursor()
cursor.execute('UPDATE employees SET name=?, salary=? WHERE id=?', (name, salary, self.id))
conn.commit()
conn.close()
def delete_employee(self):
"""
Method to delete employee from the database.
"""
conn = sqlite3.connect('employees.db')
cursor = conn.cursor()
cursor.execute('DELETE FROM employees WHERE id=?', (self.id,))
conn.commit()
conn.close()
Explanation:
- The
Employeeclass represents individual employees in the organization. - It contains attributes
id,name, andsalaryto store employee information. - The
update_employeemethod updates employee details in the SQLite database. - The
delete_employeemethod deletes the employee from the SQLite database.
2. Manager Class
class Manager(Employee):
"""
The Manager class represents managers in the organization.
Inherits from the Employee class.
"""
def __init__(self, id, name, salary, department):
"""
Constructor to initialize manager attributes.
"""
super().__init__(id, name, salary)
self.department = department
Explanation:
- The
Managerclass represents managers in the organization and inherits from theEmployeeclass. - It adds an additional attribute
departmentto store the department managed by the manager.
3. Salary Class
class Salary:
"""
The Salary class represents salary information for employees.
"""
def __init__(self, employee_id, amount):
"""
Constructor to initialize salary attributes.
"""
self.employee_id = employee_id
self.amount = amount
Explanation:
- The
Salaryclass represents salary information for employees. - It contains attributes
employee_idandamountto store the employee’s ID and salary amount.
4. Department Class
class Department:
"""
The Department class represents departments in the organization.
"""
def __init__(self, id, name):
"""
Constructor to initialize department attributes.
"""
self.id = id
self.name = name
self.employees = []
def add_employee(self, employee):
"""
Method to add an employee to the department.
"""
self.employees.append(employee)
def remove_employee(self, employee):
"""
Method to remove an employee from the department.
"""
self.employees.remove(employee)
Explanation:
- The
Departmentclass represents departments in the organization. - It contains attributes
id,name, andemployeesto store department information and a list of employees in the department. - The
add_employeemethod adds an employee to the department. - The
remove_employeemethod removes an employee from the department.
Database Integration:
We’ll use SQLite3 as the database backend. Below is a simple example of connecting to an SQLite database:
import sqlite3
# Create connection and cursor
conn = sqlite3.connect('employees.db')
cursor = conn.cursor()
# Create employees table if not exists
cursor.execute('''CREATE TABLE IF NOT EXISTS employees (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
salary REAL NOT NULL
)''')
# Commit changes and close connection
conn.commit()
conn.close()
Explanation:
- This code establishes a connection to an SQLite database named
employees.db. - It creates a table named
employeesif it does not already exist, with columns forid,name, andsalary. - After executing SQL commands, changes are committed and the connection is closed.
View and Controller:
For the view and controller components, you can use frameworks like Flask or Django to create a web interface for the application. The controller will handle user actions and invoke appropriate methods in the model to perform operations on the data. With these components in place, users can view, edit, and delete employee details through the web interface.
