public static bool Delete(string employeeId)
{
if (string.IsNullOrWhiteSpace(employeeId))
{
throw new ArgumentNullException("employeeId");
}
IBaseEmployee factory = BaseEmployeeFactory.GetFactory();
IEmployeePlate platefactory = EmployeePlateFactory.GetFactory();
using (DbOperator dbOperator = ConnectionManager.CreateConnection())
{
try
{
dbOperator.BeginTransaction();
//删除车牌
bool result = platefactory.DeleteByEmployeeId(employeeId, dbOperator);
if (!result)
{
throw new MyException("删除车牌失败");
}
//删授权表
result = factory.Delete(employeeId, dbOperator);
if (!result)
{
throw new MyException("删除人员信息失败");
}
dbOperator.CommitTransaction();
return(result);
}
catch {
dbOperator.RollbackTransaction();
throw;
}
}
}
public static IDeviceFactory GetDevice(IBaseEmployee employee)
{
return(employee.RequestedDeviceType switch
{
DeviceType.Laptop => DellLaptopFactory.GetDevice(employee),
DeviceType.Desktop => DellDesktopFactory.GetDevice(employee),
_ => DellDesktopFactory.GetDevice(employee)
});
public static IDeviceFactory Create(IBaseEmployee employee)
{
return(employee.EmployeeType switch
{
EmployeeType.Permanent => AppleFactory.GetDevice(employee),
EmployeeType.Contract => DellFactory.GetDevice(employee),
EmployeeType.Visiting => HewlettPackardFactory.GetDevice(employee),
_ => HewlettPackardFactory.GetDevice(employee)
});
public static BaseEmployeeFactory GetFactory(IBaseEmployee employee)
{
return(employee.EmployeeType switch
{
EmployeeType.Contract => new ContractEmployeeFactory(employee),
EmployeeType.Permanent => new PermanentEmployeeFactory(employee),
EmployeeType.Visiting => new VisitingEmployeeFactory(employee),
_ => null
});
public static IEmployeeManager GetEmployeeManager(IBaseEmployee employee)
{
return(employee.EmployeeType switch
{
EmployeeType.Permanent => new PermanentEmployeeManager(employee),
EmployeeType.Contract => new ContractEmployeeManager(employee),
EmployeeType.Visiting => new VisitingEmployeeManager(employee),
_ => null
});
public static IBaseEmployee GetFactory()
{
if (factory == null)
{
Type type = Type.GetType("Common." + SystemDefaultConfig.DatabaseProvider + "Repository.BaseEmployeeDAL,Common." + SystemDefaultConfig.DatabaseProvider + "Repository", true);
factory = (IBaseEmployee)Activator.CreateInstance(type);
}
return(factory);
}
public static BaseEmployee QueryByEmployeeId(string employeeId)
{
if (string.IsNullOrWhiteSpace(employeeId))
{
throw new ArgumentNullException("employeeId");
}
IBaseEmployee factory = BaseEmployeeFactory.GetFactory();
return(factory.QueryByEmployeeId(employeeId));
}
public static List <BaseEmployee> QueryEmployeeByVillageId(string villageId)
{
if (string.IsNullOrWhiteSpace(villageId))
{
throw new ArgumentNullException("villageId");
}
IBaseEmployee factory = BaseEmployeeFactory.GetFactory();
return(factory.QueryEmployeeByVillageId(villageId));
}
public static bool Add(BaseEmployee model)
{
if (model == null)
{
throw new ArgumentNullException("model");
}
IBaseEmployee factory = BaseEmployeeFactory.GetFactory();
model.EmployeeID = GuidGenerator.GetGuidString();
return(factory.Add(model));
}
internal static bool AddOrUpdateBaseEmployee(BaseEmployee employee, DbOperator dbOperator)
{
IBaseEmployee employeeFactory = BaseEmployeeFactory.GetFactory();
BaseEmployee oldEmployee = BaseEmployeeServices.QueryByEmployeeId(employee.EmployeeID);
if (oldEmployee != null)
{
return(employeeFactory.Update(employee, dbOperator));
}
else
{
return(employeeFactory.Add(employee, dbOperator));
}
}
public static List <BaseEmployee> QueryEmployeePage(EmployeeCondition condition, int pagesize, int pageindex, out int total)
{
if (condition == null)
{
throw new ArgumentNullException("condition");
}
if (string.IsNullOrWhiteSpace(condition.VillageId))
{
throw new ArgumentNullException("VillageId");
}
IBaseEmployee factory = BaseEmployeeFactory.GetFactory();
return(factory.QueryEmployeePage(condition, pagesize, pageindex, out total));
}
public static BaseEmployee QueryBaseEmployeeByVillageIdAndMobile(string villageId, string mobile)
{
if (string.IsNullOrWhiteSpace(villageId))
{
throw new ArgumentNullException("villageId");
}
if (string.IsNullOrWhiteSpace(mobile))
{
throw new ArgumentNullException("mobile");
}
IBaseEmployee factory = BaseEmployeeFactory.GetFactory();
return(factory.QueryBaseEmployeeByVillageIdAndMobile(villageId, mobile));
}
public static bool Update(BaseEmployee model)
{
if (model == null)
{
throw new ArgumentNullException("model");
}
if (string.IsNullOrWhiteSpace(model.EmployeeID))
{
throw new ArgumentNullException("EmployeeID");
}
IBaseEmployee factory = BaseEmployeeFactory.GetFactory();
return(factory.Update(model));
}
public ContractEmployeeFactory(IBaseEmployee employee) : base(employee)
{
}
public PermanentEmployeeFactory(IBaseEmployee employee) : base(employee)
{
}
public ContractEmployeeManager(IBaseEmployee employee)
{
_employee = employee;
}
public virtual void AssignManager(IBaseEmployee manager)
{
Manager = manager;
}
public PermanentEmployeeManager(IBaseEmployee employee)
{
_employee = employee;
}
protected BaseEmployeeFactory(IBaseEmployee employee)
{
Employee = employee;
}
public VisitingEmployeeManager(IBaseEmployee employee)
{
_employee = employee;
}
} // Employee Age
/// <summary>
/// Prints details of the employee file
/// </summary>
/// <param name="employee">The employee to which the file will be printed</param>
public void PrintFile(IBaseEmployee employee)
{
Console.WriteLine($"{employee.GetType().Name} File : \nID:{employee.ID}\nName:{employee.Name}\nAge:{employee.Age}");
}
/// <summary>
/// Adds an employee to the employee list
/// </summary>
/// <param name="employee">The employee to be added</param>
public void AddBaseEmployee(IBaseEmployee employee)
{
_employee_list.Add(employee);
}
/// <summary>
/// Calculates the salary of an employee based on the type
/// passed
/// </summary>
/// <param name="employee">The employee to calculate the salary for</param>
public void CalcSalary(IBaseEmployee employee)
{
@switch[employee.GetType()].Invoke();
Console.WriteLine($"The salary is : {this.salary}");
}
public VisitingEmployeeFactory(IBaseEmployee employee) : base(employee)
{
}
