public MoveDepartmentMenu(IDepartmentDTO d, List <IDepartmentDTO> deptList)
{
InitializeComponent();
IdDisplay.Text = $"{d.DeptID}";
DeptNameDisplay.Text = d.DeptName;
DeparmmentEntryBox.ItemsSource = deptList;
}
public OperationResult <IDepartmentDTO> GetDepartment(int departmentId)
{
OperationResult <IDepartmentDTO> getDepartmentRetVal = null;
try
{
IDepartmentDAC departmentDAC = (IDepartmentDAC)DACFactory.Instance.Create(DACType.DepartmentDAC);
IDepartmentDTO returnedDepartmentDTO = departmentDAC.GetDepartment(departmentId);
if (returnedDepartmentDTO != null)
{
getDepartmentRetVal = OperationResult <IDepartmentDTO> .CreateSuccessResult(returnedDepartmentDTO, " successfully");
}
else
{
getDepartmentRetVal = OperationResult <IDepartmentDTO> .CreateFailureResult("failed!");
}
}
catch (DACException dacEx)
{
getDepartmentRetVal = OperationResult <IDepartmentDTO> .CreateErrorResult(dacEx.Message, dacEx.StackTrace);
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex);
getDepartmentRetVal = OperationResult <IDepartmentDTO> .CreateErrorResult(ex.Message, ex.StackTrace);
}
return(getDepartmentRetVal);
}
/// <summary>
/// Creates TreeViewItem node for the department
/// </summary>
/// <param name="d">Department</param>
/// <returns></returns>
private TreeViewItem CreateTVINode(IDepartmentDTO d)
{
var item = new TreeViewItem()
{
// Set the header
Header = d.DeptName,
// Add reference to the node content
Tag = d
};
// Add a dummy item if the item being expanded has subitems
// We do this in order to show "expand" arrow next to a tree node name
// If a node cannot be expanded, arrow does not appear
if ((item.Tag as IDepartmentDTO).NumberOfSubDepts != 0)
{
item.Items.Add(null);
}
// Listen out for item being selected. This method is already added in XAML
//item.Selected += Department_Selected;
// Listen out for item being expanded. This method is already added in XAML
//item.Expanded += Department_Expanded;
return(item);
}
/// <summary>
/// Moves worker to the department with specified ID
/// </summary>
/// <param name="worker">Worker to move</param>
/// <param name="destDept">Destination department</param>
/// <returns>
/// 0 if moved successfully
/// -1 if worker with such ID does not exist
/// -2 if department with such ID does not exist
/// -3 if destination department is current worker's department
/// </returns>
public int MoveWorker(IWorker worker, IDepartmentDTO destDept)
{
var w = RemoveWorker(worker);
// Worker can be moved to another department only either as Employee or Intern
if (w.Position != Positions.Employee &&
w.Position != Positions.Intern)
{
w.Position = Positions.Employee;
w.PositionTitle = "Employee";
}
// Move worker to destination department
w.DeptID = destDept.DeptID;
if (w is Director)
{
// Using explicit type cast operator from Director to Employee
// defined in Employee class
Employee e = (Employee)(w as Director);
AddWorker(e);
}
else
{
AddWorker(w);
}
return(0);
}
/// <summary>
/// Removes department with specified ID from the list of departments
/// provided that this is not root department.
/// Adds sub departments to the parent department.
/// Adds all department workers to the parent department.
/// </summary>
/// <param name="d">Department to delete</param>
/// <returns>
/// Deleted department
/// null if such department does not exist or we are trying to delete root department
/// </returns>
public IDepartmentDTO SelfExcludeOfDepartment(IDepartmentDTO d)
{
var parentDept = Department(d.ParentDeptID) as BaseDepartment;
var dir = Director(d);
if (dir != null)
{
MoveWorker(dir, parentDept);
}
// update department ID of each worker to destinationDept ID
foreach (var w in OneDepartmentWorkersList(d))
{
w.DeptID = parentDept.DeptID;
// Make all vice bosses as Employees
if (w.Position != Positions.Employee ||
w.Position != Positions.Intern)
{
w.Position = Positions.Employee;
w.PositionTitle = "Employee";
}
}
d.NumberOfEmployees = 0;
foreach (var dept in SubDepartments(d))
{
MoveDepartment(dept, parentDept);
}
UpdateSalaries(parentDept);
return(DeleteEmptyDepartment(d));
}
/// <summary>
/// Searches through UI Tree for specific node
/// </summary>
/// <param name="entryNode"></param>
/// <param name="d"></param>
/// <returns>UI TreeViewItem corresponding to department</returns>
private TreeViewItem FindNode(TreeViewItem entryNode, IDepartmentDTO d)
{
var currDept = entryNode.Tag as IDepartmentDTO;
if (currDept.DeptID == d.DeptID)
{
return(entryNode);
}
TreeViewItem foundNode = null;
foreach (var subNode in entryNode.Items)
{
// We need this check because our TreeViewItem.Items has null item at Items[0]
// in shown but not expanded yet items.
if (subNode == null)
{
continue;
}
foundNode = FindNode(subNode as TreeViewItem, d);
if (foundNode != null)
{
break;
}
}
return(foundNode);
}
/// <summary>
/// Used wherever a specific department is required.
/// </summary>
/// <param name="departmentId"></param>
/// <returns></returns>
public IDepartmentDTO GetADepartment(int departmentId)
{
IDepartmentDTO departmentDTO = null;
using (EmployeePortal2017Entities portal = new EmployeePortal2017Entities())
{
try
{
var department = portal.Departments.Where(d => d.DepartmentId == departmentId)
.SingleOrDefault <Department>();
departmentDTO = (IDepartmentDTO)DTOFactory.Instance.Create(DTOType.DepartmentDTO);;
if (department != null)
{
EntityConverter.FillDTOFromEntity(department, departmentDTO);
}
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex);
throw new DACException(ex.Message);
}
}
return(departmentDTO);
}
/// <summary>
/// Creates new worker of specified type and adds him to the organization
/// </summary>
/// <param name="fn">First name</param>
/// <param name="ln">Last name</param>
/// <param name="dob">Date of birth</param>
/// <param name="d">Department interface</param>
/// <param name="pos">Position</param>
/// <returns>
/// 0 if worker was added successfully,
/// -1 if worker is director and department already has a director
/// </returns>
public int AddWorker(string fn, string ln, DateTime dob, IDepartmentDTO d, Positions pos)
{
// Check if we are not adding a director to the department which already has a director
if ((pos == Positions.President ||
pos == Positions.DivisionHead ||
pos == Positions.DeptDirector) &&
Director(d) != null)
{
return(-1);
}
Worker newWorker = null;
switch (pos)
{
case Positions.President:
newWorker = new Director(fn, ln, dob, DateTime.Now, d.DeptID, "President", pos);
break;
case Positions.VicePresident:
newWorker = new Employee(fn, ln, dob, DateTime.Now, d.DeptID, "VicePresident", pos);
break;
case Positions.DivisionHead:
newWorker = new Director(fn, ln, dob, DateTime.Now, d.DeptID,
"Head of the " + d.DeptName, pos);
break;
case Positions.ViceDivisionHead:
newWorker = new Employee(fn, ln, dob, DateTime.Now, d.DeptID,
"Deputy Head of the " + d.DeptName, pos);
break;
case Positions.DeptDirector:
newWorker = new Director(fn, ln, dob, DateTime.Now, d.DeptID,
"Director" + d.DeptName.Substring(10), pos);
break;
case Positions.ViceDeptDirector:
newWorker = new Employee(fn, ln, dob, DateTime.Now, d.DeptID,
"Vice Director" + d.DeptName.Substring(10), pos);
break;
case Positions.Employee:
newWorker = new Employee(fn, ln, dob, DateTime.Now, d.DeptID, "Employee", pos);
break;
case Positions.Intern:
newWorker = new Intern(fn, ln, dob, DateTime.Now, d.DeptID, "Intern");
break;
default:
break;
}
return(AddWorker(newWorker as IWorker));
}
/// <summary>
/// Deletes department including all sub departments with all employees
/// </summary>
/// <param name="d">Department to delete</param>
public void DeleteCompletely(IDepartmentDTO d)
{
int i = 0;
while (i < Workers.Count)
{
// We should NOT increment i after taking out a worker
// because next worker has the same index as just deleted one
if (Workers[i].DeptID == d.DeptID)
{
Workers.RemoveAt(i);
}
else
{
i++;
}
}
// Check if d has sub departments
if ((d as BaseDepartment).SubDepts.Count > 0)
{
// Delete all subdepartments from Departments list
// Let's check deptID of each department if it belongs to SubDepts list
// If DeptID is in SubDept list - delete department and ID from the SubDept list
// When there is no SubDepts remain stop scanning Departments
for (i = 0; i < Departments.Count; i++)
{
if ((d as BaseDepartment).SubDepts.Count > 0)
{
int j = 0;
while (j < (d as BaseDepartment).SubDepts.Count)
{
if (Departments[i].DeptID == (d as BaseDepartment).SubDepts[j])
{
DeleteCompletely(Departments[i]);
(d as BaseDepartment).SubDepts.RemoveAt(j);
// After deleting subdepartment i will reman the same
// but Department[i] will be different
// because there will be shift of all list items to position i
}
else
{
j++;
}
}
}
else
{
break; // if no mor subdepartments in
}
}
}
// if no, or all were deleted, delete department
Departments.Remove(d as BaseDepartment);
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
// Get root department
IDepartmentDTO d = UI.Get.RootDepartment();
var item = CreateTVINode(d);
// Add it the main tree-view
AppleTree.Items.Add(item);
AppleTreeRoot = item;
}
/// <summary>
/// Deletes department which has no employees and sub departments
/// </summary>
/// <param name="d">Department to delete</param>
/// <returns>
/// Deleted department
/// null if such department does not exist or we are trying to delete root department
/// </returns>
public IDepartmentDTO DeleteEmptyDepartment(IDepartmentDTO d)
{
bool result = Departments.Remove(d as BaseDepartment);
if (result)
{
BaseDepartment parent = Department(d.ParentDeptID) as BaseDepartment;
parent.SubDepts.Remove(d.DeptID);
return(d);
}
return(null);
}
private void btnOk_MoveDepartment_Click(object sender, RoutedEventArgs e)
{
// If destination department was not selected don't do anything
if (DeparmmentEntryBox.SelectedItem == null)
{
this.DialogResult = false;
}
else
{
destDept = DeparmmentEntryBox.SelectedItem as IDepartmentDTO;
this.DialogResult = true;
}
}
/// <summary>
/// Collects list of sub-departments of the specified department
/// </summary>
/// <param name="d">Department</param>
/// <returns>
/// Collection of sub departments of department d, or
/// null if there are no sub departments
/// </returns>
public List <IDepartmentDTO> SubDepartments(IDepartmentDTO d)
{
List <IDepartmentDTO> dl = new List <IDepartmentDTO>();
foreach (BaseDepartment dept in Departments)
{
if (dept.ParentDeptID == d.DeptID)
{
dl.Add(dept);
}
}
return(dl);
}
/// <summary>
/// Finds all workers, including director, who work in the department d
/// and puts them in the collection List
/// </summary>
/// <param name="d">Department</param>
/// <returns>Collection of workers of IWorker type who works in the department d</returns>
public List <IWorker> OneDepartmentWorkersList(IDepartmentDTO d)
{
List <IWorker> wl = new List <IWorker>();
foreach (Worker w in Workers)
{
if (w.DeptID == d.DeptID)
{
wl.Add(w as IWorker);
}
}
return(wl);
}
/// <summary>
/// Returns a list of departments where we can move current department because
/// department cannot be moved to any its direct or distant subdepartments
/// </summary>
/// <param name="d">Department to be moved</param>
/// <returns>List of available departments to move specified one</returns>
public List <IDepartmentDTO> AvailableDestinationDepartmentsList(IDepartmentDTO d)
{
_availDestDeptList = DepartmentsList();
TakeOutSubDeptsAndDept(d);
_availDestDeptList.Remove(Department(d.ParentDeptID));
return(_availDestDeptList);
void TakeOutSubDeptsAndDept(IDepartmentDTO dd)
{
foreach (var sd in SubDepartments(dd))
{
TakeOutSubDeptsAndDept(sd);
}
_availDestDeptList.Remove(dd);
}
}
/// <summary>
/// Moves department to destination department
/// </summary>
/// <param name="d">Department to move</param>
/// <param name="destinationDept">Destination department to nest in as subdepartment</param>
/// <returns>Moved department with updated parent dept ID</returns>
public IDepartmentDTO MoveDepartment(IDepartmentDTO d, IDepartmentDTO destinationDept)
{
var cloneDept = d as BaseDepartment;
var oldParent = Department(d.ParentDeptID) as BaseDepartment;
// Take out being moved department from parent's subdepartments
oldParent.SubDepts.Remove(d.DeptID);
// If current department level is Division, it means we are going down to Department level
// and need to change class of department
if (d is Division)
{
cloneDept = new Department(d as BaseDepartment);
}
// If we are moving up to Division level,
// need to change class from Department to Division
if (destinationDept.ParentDeptID == 0)
{
cloneDept = new Division(d as BaseDepartment);
cloneDept.DeptName = "Division_" + UniqueID.Name();
}
else if (SubDepartments(destinationDept).
Find(sameName => sameName.DeptName == cloneDept.DeptName) != null)
{
cloneDept.DeptName += "_" + UniqueID.Name();
}
// Set new parent for being moved department
cloneDept.ParentDeptID = destinationDept.DeptID;
// Add new child to destination subdepartment
(destinationDept as BaseDepartment).SubDepts.Add(cloneDept.DeptID);
// If class of department changed, need to update Departments table
int di = Departments.FindIndex(dept => dept.DeptID == d.DeptID);
Departments[di] = cloneDept;
UpdateSalaries(oldParent);
UpdateSalaries(destinationDept as BaseDepartment);
return(cloneDept);
}
/// <summary>
/// Adds newly created child department to parent department
/// </summary>
/// <param name="parentDept">Parent department</param>
/// <param name="childDept">Departmet to add</param>
/// <returns>
/// 0 if child was added successfully,
/// </returns>
public int AddDepartment(IDepartmentDTO pd, IDepartmentDTO cd)
{
BaseDepartment parentDept = pd as BaseDepartment;
BaseDepartment childDept = cd as BaseDepartment;
// Creation of root department
// it means childDept is root department
if (parentDept == null && childDept.ParentDeptID == 0)
{
Departments.Add(childDept);
return(0);
}
// Adding child department to parent dept
Departments.Add(childDept);
parentDept.SubDepts.Add(childDept.DeptID);
childDept.ParentDeptID = parentDept.DeptID;
return(0);
}
public IDepartmentDTO GetDepartment(int departmentId)
{
IDepartmentDTO retVal = null;
try
{
using (EmployeePortalEntities context = new EmployeePortalEntities())
{
IDepartmentDTO departmentDTO = (IDepartmentDTO)DTOFactory.Instance.Create(DTOType.DepartmentDTO);
EntityConverter.FillDTOFromEntity(context.Departments.First(item => item.DepartmentId == departmentId), departmentDTO);
retVal = departmentDTO;
}
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex);
throw new DACException(ex.Message);
}
return(retVal);
}
/// <summary>
/// Adds newly created child department to parent department
/// </summary>
/// <param name="pd">Parent department</param>
/// <param name="childDeptName">Name of the department to be created</param>
/// <param name="childDeptCreationDate">Child department creation date</param>
public IDepartmentDTO CreateDepartment(IDepartmentDTO pd, string childDeptName, DateTime childDeptCreationDate)
{
BaseDepartment parentDept = pd as BaseDepartment;
BaseDepartment childDept;
// Creation of root department
// it means childDept is root department
if (parentDept == null)
{
childDept = new HQ(childDeptName);
childDept.CreatedOn = childDeptCreationDate;
Departments.Add(childDept);
return(childDept as IDepartmentDTO);
}
// Create Division level department
uint rootDeptID = RootDepartment().DeptID;
if (parentDept.DeptID == rootDeptID)
{
childDept = new Division(childDeptName, rootDeptID)
{
CreatedOn = childDeptCreationDate
};
Departments.Add(childDept);
parentDept.SubDepts.Add(childDept.DeptID);
childDept.ParentDeptID = parentDept.DeptID;
return(childDept as IDepartmentDTO);
}
// Create Department level department
childDept = new Department(childDeptName, parentDept.DeptID)
{
CreatedOn = childDeptCreationDate
};
Departments.Add(childDept);
parentDept.SubDepts.Add(childDept.DeptID);
childDept.ParentDeptID = parentDept.DeptID;
return(childDept as IDepartmentDTO);
}
public IList <IDepartmentDTO> GetAll()
{
List <IDepartmentDTO> departments = new List <IDepartmentDTO>();
try
{
using (EmployeePortalEntities context = new EmployeePortalEntities())
{
foreach (var departmentName in context.Departments)
{
IDepartmentDTO departmentDTO = (IDepartmentDTO)DTOFactory.Instance.Create(DTOType.DepartmentDTO);
EntityConverter.FillDTOFromEntity(departmentName, departmentDTO);
departments.Add(departmentDTO);
}
}
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex);
throw new DACException(ex.Message);
}
return(departments);
}
public EditWorkerMenu(IWorker w,
IDepartmentDTO d,
bool hasDirector,
List <IPositionTuple> posList,
DateTime orgCreationDate)
{
InitializeComponent();
wCopy = new EditWorkerValidation(w, d, hasDirector, orgCreationDate);
EditWorkerGrid.DataContext = wCopy;
DateOfBirthPicker.SelectedDate = wCopy.DateOfBirth;
EmployedOnDatePicker.SelectedDate = wCopy.EmployedOn;;
DeptNameDisplay.Text = d.DeptName;
PositionEntryBox.ItemsSource = posList;
PositionEntryBox.SelectedItem = posList.Find(p => p.Pos == w.Position);
DirectorSalary.Visibility = Visibility.Collapsed;
EmployeeSalary.Visibility = Visibility.Collapsed;
InternSalary.Visibility = Visibility.Collapsed;
if (w is IDirector)
{
DirectorSalary.Visibility = Visibility.Visible;
}
if (w is IEmployee)
{
EmployeeSalary.Visibility = Visibility.Visible;
}
if (w is IIntern)
{
InternSalary.Visibility = Visibility.Visible;
}
}
public DeleteDepartmentMenu(IDepartmentDTO d)
{
InitializeComponent();
deptnameid.Text = $"ID: {d.DeptID}, {d.DeptName}";
}
/// <summary>
/// Finds director (president,head) of department
/// </summary>
/// <param name="d">Department</param>
/// <returns>
/// Worker of the Director class or
/// null if a director of deptID department is not found
/// </returns>
public IWorker Director(IDepartmentDTO d)
{
Director dir = Workers.Find(w => w.DeptID == d.DeptID && w is Director) as Director;
return(dir);
}
/// <summary>
/// Updates name and creation date of the department
/// </summary>
/// <param name="deptToEdit">Department to edit</param>
/// <param name="newName">New department name</param>
/// <param name="newCreationDate">New creation date</param>
/// <returns>
/// 0 if department was updated successfully
/// </returns>
public int EditDepartment(IDepartmentDTO deptToEdit, string newName, DateTime newCreationDate)
{
deptToEdit.DeptName = newName;
deptToEdit.CreatedOn = newCreationDate;
return(0);
}
