internal static List <Employee> Map(this List <EmployeeResponse> items)
{
List <Employee> response = new List <Employee>();
foreach (var item in items)
{
Employee employee;
if (Enum.TryParse(item.ContractTypeName, out ContractType type))
{
employee = EmployeeFactory.Build(type);
employee.Id = item.Id;
employee.Name = item.Name;
employee.ContractTypeName = item.ContractTypeName;
employee.RoleId = item.RoleId;
employee.RoleName = item.RoleName;
employee.RoleDescription = item.RoleDescription;
employee.HourlySalary = item.HourlySalary;
employee.MonthlySalary = item.MonthlySalary;
employee.Total = employee.CalculateSalary();
response.Add(employee);
}
}
return(response);
}
private void submitBtn_Click(object sender, RoutedEventArgs e)
{
string name = nameTxt.Text;
string password = passwordTxt.Password;
string salaryStr = salaryTxt.Text;
string department = (string)((ComboBoxItem)deptComboBox.SelectedValue).Content;
DateTime?dob = dobDate.SelectedDate;
int salary;
bool flag = int.TryParse(salaryStr, out salary);
if (!flag)
{
errorLbl.Text = "Salary must be a number!";
}
else if (name == "" || password == "" || !dob.HasValue || deptComboBox.SelectedItem == null)
{
errorLbl.Text = "Please fill all field!";
}
else
{
EmployeeMediator mediator = new EmployeeMediator();
EmployeeFactory factory = new EmployeeFactory();
Employee employee = mediator.addEmployee(factory.createNewEmployee(name, password, salary, dob, department));
if (employee != null)
{
MessageBox.Show("Employee " + employee.name + " has been Added!");
}
else
{
MessageBox.Show("Add employee failed!");
}
this.Close();
}
}
public async Task <IActionResult> PutEmployee([FromBody] PersonAPI person)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (!(await EmployeeExists(person.Ssn)))
{
return(BadRequest());
}
try
{
Employee employee = EmployeeFactory.Get(person, EmployeeEnum.AssistentLibrarian);
await _repository.UpdateAsync(employee);
}
catch (DbUpdateConcurrencyException)
{
if (!(await EmployeeExists(person.Ssn)))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
private void OnSave(object obj)
{
Employee employee = null;
EmployeeFactory factory = new EmployeeFactory();
switch (Position)
{
case "Employee":
employee = factory.GeneralEmployee(Name, Rate, EmoploymentDate);
break;
case "Manager":
employee = factory.Manager(Name, Rate, EmoploymentDate);
break;
case "Salesman":
employee = factory.Salesman(Name, Rate, EmoploymentDate);
break;
default:
throw new ArgumentException("Unhandled position of employee");
}
if (employee != null)
{
db.AddEmployee(employee);
}
OnCancel(obj);
}
public async Task WhenRequestingEmployeesByUnitId_SubUnits_ThenItShouldBeReturned()
{
var unitId = 5;
var subUnit1 = 10;
var subUnit2 = 12;
var dummyUnitId = 1337;
// Arrange
var emps = EmployeeFactory.GetFactory().Generate(5);
emps[0].UnitId = unitId;
emps[1].UnitId = subUnit1;
emps[2].UnitId = subUnit2;
emps[3].UnitId = subUnit2;
emps[4].UnitId = dummyUnitId;
await AddToPersonalDb(emps);
// Act
var url = $"{_customerId}/employees/?take=500&UnitIds={unitId}&UnitIds={subUnit1}&UnitIds={subUnit2}";
var employees = await _client.GetAsyncAndDeserialize <List <contract.Employee> >(url);
// Asserts
Assert.IsNotNull(employees);
Assert.AreEqual(4, employees.Count);
Assert.IsTrue(employees.Any(x => x.UnitId == unitId));
Assert.IsTrue(employees.Any(x => x.UnitId == subUnit1));
Assert.AreEqual(2, employees.Count(x => x.UnitId == subUnit2));
Assert.IsFalse(employees.Any(x => x.UnitId == dummyUnitId));
}
private void fillInformation(int EmpID)
{
List <Employee> emp = EmployeeFactory.RetrieveEmployeesByID(EmpID);
txtEmployeeID.Text = emp[0].EmpID.ToString();
txtFirstName.Text = emp[0].FirstName;
txtMiddleInitial.Text = emp[0].MiddleInitial;
txtLastName.Text = emp[0].LastName;
dtpDateOfBirth.Value = emp[0].DateOfBirth;
dtpSeniorityDate.Value = emp[0].HireDate;
var today = DateTime.Today;
var yearsOfWork = today.Year - emp[0].HireDate.Year;
if (emp[0].HireDate > today.AddYears(-yearsOfWork))
{
yearsOfWork--;
}
if (yearsOfWork < 5)
{
grpboxPension.Visible = false;
grpBoxPensions.Visible = false;
grpBoxWoops.Visible = true;
}
else
{
grpboxPension.Visible = true;
grpBoxPensions.Visible = true;
grpBoxWoops.Visible = false;
fillEmployeePensions(emp[0]);
}
}
public async Task <ActionResult <EmployeeDto> > Pagination([FromQuery] PaginationFilter filter, CancellationToken cancellationToken)
{
var route = Request.Path.Value;
var validFilter = new PaginationFilter(filter.PageNumber, filter.PageSize, filter.SearchQuery);
var dbResultSet = EmployeeFactory.Create();
var AsQueryableResult = dbResultSet.AsQueryable()
.Skip((filter.PageNumber - 1) * filter.PageSize)
.Take(filter.PageSize).ToList();
if (!string.IsNullOrEmpty(filter.SearchQuery))
{
// trim & ignore casing
var searchQueryForWhereClause = filter.SearchQuery
.Trim().ToLowerInvariant();
AsQueryableResult.Where(o => o.FirstName.ToLowerInvariant().Contains(searchQueryForWhereClause) ||
o.LastName.ToLowerInvariant().Contains(searchQueryForWhereClause)).ToList();
}
AsQueryableResult.ToList();
var totalRecords = dbResultSet.Count();
var pagedData = AsQueryableResult;
var pagedReponse = PaginationHelper.CreatePagedReponse <EmployeeDto>(
pagedData, validFilter, totalRecords, _uriService, route
);
return(Ok(pagedReponse));
}
public void Employee_Salary_ShouldReturnErrorIfSalaryLessAllowed()
{
// Arrange, Act and Assert
var exception = Assert.Throws <Exception>(() => EmployeeFactory.Create("Thiago", 230.45));
Assert.Equal("Salary less than allowed", exception.Message);
}
private void btnPending_Click(object sender, EventArgs e)
{
try
{
int gridItemIndex = dgvItems.SelectedRows[0].Index;
Item listItem = ItemList[gridItemIndex];
if (listItem.Status.Equals("Pending"))
{
MessageBox.Show("Item status is already set to Pending.");
}
else if (listItem.Description.Equals("No longer needed"))
{
MessageBox.Show("Item has been marked as no longer needed by the employee. Unable to process.");
}
else
{
listItem.Status = "Pending";
int itemIndex = ItemList.IndexOf(listItem);
ItemList[itemIndex] = listItem;
string[] names = Settings.Default.EmployeeName.ToString().Split(' ');
string firstName = names[0];
string lastName = names[1];
Employee CurrentEmployee = EmployeeFactory.RetrieveByName(firstName, lastName);
bool result = ItemFactory.PendingItem(listItem, CurrentEmployee.Id);
if (result == true)
{
MessageBox.Show("Item status has been successfully updated to Pending.");
dgvItems.Rows[itemIndex].Cells["Status"].Value = listItem.Status;
dgvItems.Rows[itemIndex].DefaultCellStyle.BackColor = Color.White;
int itemCount = 0;
foreach (Item item in ItemList)
{
if (item.Status.Equals("Pending"))
{
itemCount += 1;
}
}
if (itemCount == ItemList.Count)
{
Order.Status = "Pending";
dgvOrders.Rows[selectedOrderIndex].Cells["Status"].Value = Order.Status;
dgvOrders.Rows[selectedOrderIndex].DefaultCellStyle.BackColor = Color.White;
MessageBox.Show("All items have a Pending status. Purchase order status has been set back to Pending.");
}
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "An error has occurred");
}
}
private void btnSave_Click(object sender, RoutedEventArgs e)
{
ForceValidation();
if (Validation.GetHasError(txtName) || Validation.GetHasError(txtPhone) ||
Validation.GetHasError(txtDesg) || Validation.GetHasError(txtSalary) ||
Validation.GetHasError(txtAddress))
{
MessageBox.Show("Error Some Data is Missing", "ERROR");
return;
}
Employee_Table obj = new Employee_Table();
obj.E_Name = txtName.Text.Trim();
int ph = Convert.ToInt32(txtPhone.Text);
obj.E_Phone = ph;
obj.E_Desg = txtDesg.Text.Trim();
obj.E_Address = txtAddress.Text.Trim();
obj.E_Salary = decimal.Parse(txtSalary.Text);
EmployeeFactory iobj = new EmployeeFactory();
if (iobj.insert(obj))
{
MessageBox.Show("Data Saved Successfully", "Saved");
txtName.Text = null;
txtDesg.Text = null;
txtAddress.Text = null;
txtPhone.Text = null;
txtSalary.Text = null;
}
else
{
MessageBox.Show("Error in Data ", "Error");
}
}
public IViewComponentResult Invoke(int AgeAbove)
{
var emps = EmployeeFactory.GetEmployees();
var elderEmployees = emps.Where(emp => emp.DOB.Year <= DateTime.Now.AddYears(-AgeAbove).Year);
return(View(elderEmployees.ToList()));
}
/// <summary>
/// Sets the Employee for the UI
/// </summary>
/// <param name="_empData">EmployeeData of the Emp</param>
/// <param name="buttonAction">The Action to be performed when the Button is clicked</param>
public virtual void SetEmp(EmployeeData _empData, UnityAction buttonAction)
{
this.employeeData = _empData;
factory = new EmployeeFactory();
GenerateSkillGui();
if (employeeData.generatedData != null)
{
empImage.material = factory.GenerateMaterialForEmployee(employeeData.generatedData, true);
empName.text = employeeData.generatedData.name;
}
else
{
empName.text = employeeData.EmployeeDefinition.EmployeeName;
}
foreach (var special in employeeData.GetSpecials())
{
addSpecial(special);
}
button.onClick.AddListener(buttonAction);
//EmployeeName, specials and Salary are not going to change, so they can be set once.
salaryTime.text = "a Week";
salary.text = $"{employeeData.Salary} $";
specialsChangedAction = onSpecialsChanged;
_empData.SpecialsChanged.AddListener(specialsChangedAction);
}
private void sendEmail()
{
try
{
var date = DateTime.Now.ToShortDateString();
List <Employee> emp = EmployeeFactory.RetrieveEmployeesByID(po.EmpId);
MailMessage message = new MailMessage();
message.To.Add(emp[0].EmailAddress);
message.From = new MailAddress("*****@*****.**");
message.Subject = "Pruchase Order Closed";
message.IsBodyHtml = true;
message.Body += "<h2>" + date + "</h2>";
message.Body += "<h3>Pruchase Order #" + po.OrderNumber + " has been processed!</h3><br />";
foreach (Item item in po.Items)
{
message.Body += "<p>" + item.ItemName + " - " + item.ItemStatus + "</p>";
}
message.Body += "<p>Total Order Cost - $" + po.Total + "</p>";
SmtpClient smtpClient = new SmtpClient("localhost");
smtpClient.Send(message);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public void DepartmentWithNestedManagerTotalExpenses_Equals_TotalEmployeeExpenses()
{
Department marketing = new Department
{
Name = "Markteting"
};
IEmployee qaTester1 = EmployeeFactory.Create(EmployeeType.Employee, _qatester.Item1, _qatester.Item2);
IEmployee developer1 = EmployeeFactory.Create(EmployeeType.Employee, _developer.Item1, _developer.Item2);
Manager manager1 = (Manager)EmployeeFactory.Create(EmployeeType.Manager, _manager.Item1, _manager.Item2);
manager1.Employees.Add(qaTester1);
manager1.Employees.Add(developer1);
decimal manager1Expenses = testHelper.GetTotalExpenses();
IEmployee qaTester2 = EmployeeFactory.Create(EmployeeType.Employee, _qatester.Item1, _qatester.Item2);
IEmployee developer2 = EmployeeFactory.Create(EmployeeType.Employee, _developer.Item1, _developer.Item2);
Manager manager2 = (Manager)EmployeeFactory.Create(EmployeeType.Manager, _manager.Item1, _manager.Item2);
manager2.Employees.Add(qaTester2);
manager2.Employees.Add(developer2);
decimal manager2Expenses = testHelper.GetTotalExpenses();
manager2.Employees.Add(manager1);
marketing.Employees.Add(manager2);
Assert.AreEqual(marketing.GetTotalExpenses(), manager1Expenses + manager2Expenses);
}
private void sendPayrollEmails()
{
try
{
var date = DateTime.Now.ToShortDateString();
List <Employee> employees = EmployeeFactory.RetrieveEmployeesByEmailNotification();
foreach (Employee emp in employees)
{
String empPayStub = createPayStub(emp);
StringReader sr = new StringReader(empPayStub);
Document pdfDoc = new Document(PageSize.A4, 10f, 10f, 10f, 0f);
HTMLWorker htmlparser = new HTMLWorker(pdfDoc);
using (MemoryStream memoryStream = new MemoryStream())
{
PdfWriter writer = PdfWriter.GetInstance(pdfDoc, memoryStream);
pdfDoc.Open();
htmlparser.Parse(sr);
pdfDoc.Close();
byte[] bytes = memoryStream.ToArray();
memoryStream.Close();
MailMessage message = new MailMessage();
message.To.Add(emp.EmailAddress);
message.From = new MailAddress("*****@*****.**");
message.Subject = "Pay Stub for " + date;
message.IsBodyHtml = true;
message.Body = "<h3>Please find attached PayStub.</h3>";
message.Attachments.Add(new Attachment(new MemoryStream(bytes), "Paystub.pdf"));
SmtpClient smtpClient = new SmtpClient("localhost");
smtpClient.Send(message);
}
//MailMessage mm = new MailMessage("*****@*****.**", emp.EmailAddress);
//mm.Subject = "Pay Stub for " + date;
//mm.IsBodyHtml = true;
//mm.Body = "<h3>Please find attached PayStub.</h3>";
//mm.Attachments.Add(new Attachment(new MemoryStream(bytes), "iTextSharpPDF.pdf"));
//mm.IsBodyHtml = true;
//SmtpClient smtp = new SmtpClient("local");
//smtp.Host = "smtp.gmail.com";
//smtp.EnableSsl = true;
//NetworkCredential NetworkCred = new NetworkCredential();
//NetworkCred.UserName = "******";
//NetworkCred.Password = "******";
//smtp.UseDefaultCredentials = true;
//smtp.Credentials = NetworkCred;
//smtp.Port = 587;
//smtp.Send(mm);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public GraphDataMutation(IEmployeeRepository employeeRepository,
IPaycheckCalculatorService paycheckCalculatorService,
EmployeeFactory employeeFactory,
DependentFactory dependentFactory)
{
_employeeRepository = employeeRepository;
_paycheckCalculatorService = paycheckCalculatorService;
_employeeFactory = employeeFactory;
_dependentFactory = dependentFactory;
Name = "Mutation";
Field <EmployeeType>(
"saveEmployee",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <EmployeeInputType> > {
Name = "employee"
}
),
resolve: context =>
{
var data = context.GetArgument <Employee>("employee");
return(ProcessSave(data));
}
);
}
public static void Main()
{
var jobCollection = new JobCollection();
EmployeeFactory employeeFactory = new EmployeeFactory();
IDictionary <string, IEmployee> employeesByName = new Dictionary <string, IEmployee>();
string command = Console.ReadLine();
while (command != "End")
{
string[] commandArgs = command.Split();
string commandName = commandArgs[0];
switch (commandName)
{
case "Job":
CreateJob(employeesByName, commandArgs, jobCollection);
break;
case "Pass":
PassWeek(jobCollection);
break;
case "Status":
PrintJobsStatus(jobCollection);
break;
default:
CreateEmployee(employeeFactory, employeesByName, commandArgs);
break;
}
command = Console.ReadLine();
}
}
private void RefillHiringPool()
{
if (EmployeesForHire.Count < _minimumForHire)
{
EmployeesForHire.Add(EmployeeFactory.Create());
}
}
private void RetrieveItems(int orderNumber)
{
try
{
ItemList.Clear();
ItemList = ItemFactory.RetrieveByOrderNumber(orderNumber);
Employee tmpEmployee = EmployeeFactory.RetrieveByOrderNumber(orderNumber);
tmpDepartment = DepartmentFactory.RetrieveByEmployeeId(tmpEmployee.Id);
txtEmployee.Text = tmpEmployee.FirstName + " " + tmpEmployee.LastName;
txtDepartment.Text = tmpDepartment.Title;
txtSupervisor.Text = tmpDepartment.SupervisorName;
Order = PurchaseOrderFactory.RetrieveByNumber(orderNumber, tmpEmployee.Id);
grdItems.DataSource = ItemList;
grdItems.DataBind();
txtPONumber.Text = Order.OrderNumber.ToString();
txtCreationDate.Text = Order.OrderDate.ToShortDateString();
txtStatus.Text = Order.Status;
txtSubtotal.Text = String.Format("{0:C}", Order.Subtotal);
txtTaxes.Text = String.Format("{0:C}", Order.Taxes);
txtTotal.Text = String.Format("{0:C}", Order.Total);
orderDetails.Attributes.Add("style", "display:block");
confirmation.Attributes.Add("style", "display:none");
lblMessage.Text = "";
}
catch (Exception ex)
{
confirmation.Attributes.Add("style", "display:block");
lblMessage.Text = ex.Message + " " + ex.GetType().ToString();
}
}
public static List <EmployeeViewModel> GetEmployeesInformation()
{
try
{
string data = ApiConnection.GetEmployeesFromApi();
if (string.IsNullOrEmpty(data))
{
return(employeesViewModel);
}
List <EmployeeProperties> employeesProperties = JsonConvert.DeserializeObject <List <EmployeeProperties> >(data);
employeesViewModel = new List <EmployeeViewModel>();
foreach (var item in employeesProperties)
{
EmployeeDTO employeeDTO = employeeDTO = EmployeeFactory.FactoryMethod(item.ContractTypeName);
employeeDTO.EmployeeProperties = item;
EmployeeViewModel e = new EmployeeViewModel(employeeDTO.EmployeeProperties)
{
AnualSalary = employeeDTO.CalculatedAnualSalary()
};
employeesViewModel.Add(e);
}
return(employeesViewModel);
}
catch (Exception ex)
{
throw ex;
}
}
public async Task CreateEmployee_ReturnsNewEmployee_WithCalculatedVariable()
{
var employeeFactory = new EmployeeFactory();
var employee = await employeeFactory.Create(1);
Assert.AreEqual(employee.GenerateEmployeeString(), employee.EmployeeString);
}
public async Task <IEnumerable <EmployeeDto> > GetInfoEmployees(int id)
{
var employees = await _employeeRepo.GetAllAsync();
var result = new List <EmployeeDto>();
EmployeeFactory factory = null;
foreach (var employee in employees)
{
switch (employee.ContractTypeName.ToLower())
{
case "hourlysalaryemployee":
factory = new HourlyFactory(employee.Id, employee.Name, employee.RoleName, employee.HourlySalary);
break;
case "monthlysalaryemployee":
factory = new MonthlyFactory(employee.Id, employee.Name, employee.RoleName, employee.MonthlySalary);
break;
default:
break;
}
result.Add(factory.GetEmployee());
}
if (id != 0)
{
result = result.FindAll(x => x.Id == id);
}
return(result);
}
public async Task CreateEmployee_ReturnsNewEmployee()
{
var employeeFactory = new EmployeeFactory();
var employee = await employeeFactory.Create(1);
Assert.NotNull(employee);
}
public void SeedDB()
{
using (var db = new LiteDatabase(Constants.DB_NAME))
{
//clean up
IEnumerable <string> collectionNames = db.GetCollectionNames().ToList();
foreach (string collectionName in collectionNames)
{
db.DropCollection(collectionName);
}
}
//setup test data
Employee nextMgr = new Employee()
{
Id = Guid.Empty
};
for (int i = 0; i < 99; i++)
{
FakeName fname = GetAName();
DateTime onboardDate = DateTime.Now.AddMonths(random.Next(-100, -12));
DateTime recentPerfReviewDate = new DateTime(DateTime.Now.Year - 1, onboardDate.Month, 1);
Employee theNextMgr = EmployeeFactory.CreateEmployee(fname.FirstName, fname.LastName, (Gender)GetValue(genders), fname.Email, nextMgr, (Title)GetValue(titles), (Level)GetValue(levels), random.Next(50000, 200000), random.Next(0, 10000), onboardDate);
HistoryFactory.CreateHistory(theNextMgr, nextMgr, (Title)GetValue(titles), (Level)GetValue(levels), random.Next(50000, 200000), random.Next(0, 10000), ActionType.ANNUAL_PERFORMANCE_REVIEW, recentPerfReviewDate);
nextMgr = theNextMgr;
}
}
public Executioner(JobFactory jobFactory,
EmployeeFactory employeeFactory, IWriter writer)
{
this.jobFactory = jobFactory;
this.employeeFactory = employeeFactory;
this.writer = writer;
}
public EmployeeFactory GetEmployee(int id, string name, string contractTypeName, int roleId, string roleName, string roleDescription, decimal hourlySalary, decimal monthlySalary)
{
EmployeeFactory employeeFactory = null;
switch (contractTypeName.ToLower())
{
case "hourlysalaryemployee":
employeeFactory = new EmployeeHourlySalary(id,
name,
contractTypeName,
roleId,
roleName,
roleDescription,
hourlySalary,
monthlySalary);
break;
case "monthlysalaryemployee":
employeeFactory = new EmployeeMonthlySalary(id,
name,
contractTypeName,
roleId,
roleName,
roleDescription,
hourlySalary,
monthlySalary);
break;
}
return(employeeFactory);
}
public IngStockTransferController()
{
_factory = new StockTransferFactory();
_InventoryFactory = new InventoryFactory();
_UOMFactory = new UnitOfMeasureFactory();
_EmployeeFactory = new EmployeeFactory();
//lstStoreReceiving = GetListStoreForTransfer();
//lstStoreIssue.AddRange(lstStoreReceiving);
//if (base.CurrentUser != null)
//{
// lstStoreIssue = lstStoreIssue.Where(ww => CurrentUser.ListStoreID.Contains(ww.Value)).ToList();
//}
//ViewBag.ListStore = lstStoreIssue;
//ViewBag.ListStoreReceived = lstStoreReceiving;
lstStoreReceiving = GetListStoreForTransfer();
ViewBag.ListStoreReceived = new SelectList(lstStoreReceiving, "Id", "Name", "CompanyName", 1);
//==========
//lstStore = ViewBag.ListStore;
if (lstStoreReceiving != null && lstStoreReceiving.Any())
{
listStoreReceiveId = lstStoreReceiving.Select(x => x.Id).ToList();
listStoreIssueId.AddRange(listStoreReceiveId);
if (CurrentUser != null)
{
listStoreIssueId = listStoreIssueId.Where(ww => CurrentUser.ListStoreID.Contains(ww)).ToList();
}
}
}
/// <summary>
///
/// </summary>
/// <param name="request"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task <EmployeeDto> Handle(CreateEmployeeCommand request, CancellationToken cancellationToken)
{
//make db call rather
var result = EmployeeFactory.Create();
return(result.FirstOrDefault());
}
private List <Employee> GetEmployeeList(SQLQueryResult sQLQueryResult)
{
List <Employee> employees = new List <Employee>();
for (int i = 0; i < sQLQueryResult.dataTable.Rows.Count; i++)
{
int employeeID;
string name;
bool active = true;
int titleID;
Title title;
string titleName;
employeeID = (int)sQLQueryResult.dataTable.Rows[i]["EmployeeID"];
name = (string)sQLQueryResult.dataTable.Rows[i]["Employeename"];
titleID = (int)sQLQueryResult.dataTable.Rows[i]["TitleID"];
titleName = (string)sQLQueryResult.dataTable.Rows[i]["TitleName"];
Title newtitle = TitleFactory.Instance().CreateTitle(titleName, titleID);
title = newtitle;
employees.Add(EmployeeFactory.Instance().CreateEmployee(employeeID, name, active, title));
}
return(employees);
}
void Worker_DoWork(object sender, DoWorkEventArgs e)
{
List <Contact> contactlist = new ContactFactory().SelectAll();
// 3 = 'Project Manager'
List <Employee> emplist = new EmployeeFactory().SelectByDesignation(5);
List <OrderStatus> orderStatuslist = new OrderStatusFactory().SelectAll();
this.Dispatcher.Invoke(() =>
{
CustomerComboBox.ItemsSource = contactlist;
CustomerComboBox.DisplayMemberPath = "CompanyName";
CustomerComboBox.SelectedValuePath = "ID";
PanelComboBox.ItemsSource = panelList;
PanelComboBox.DisplayMemberPath = "SerialNo";
PanelComboBox.SelectedValuePath = "ID";
AssignedEmployeeComboBox.ItemsSource = emplist;
AssignedEmployeeComboBox.DisplayMemberPath = "FirstName";
AssignedEmployeeComboBox.SelectedValuePath = "ID";
OrderStatusComboBox.ItemsSource = orderStatuslist;
OrderStatusComboBox.DisplayMemberPath = "Name";
OrderStatusComboBox.SelectedValuePath = "ID";
});
}
public static IEmployee GetNewEmployee() {
EmployeeFactory employeeFactory = new EmployeeFactory();
return employeeFactory.CreateNewEmployee();
}
