[Test] //ExSkip
public void CustomDataSourceRoot()
{
// Create a document with two mail merge regions named "Washington" and "Seattle".
string[] mailMergeRegions = { "Vancouver", "Seattle" };
Document doc = CreateSourceDocumentWithMailMergeRegions(mailMergeRegions);
// Create two data sources for the mail merge.
EmployeeList employeesWashingtonBranch = new EmployeeList();
employeesWashingtonBranch.Add(new Employee("John Doe", "Sales"));
employeesWashingtonBranch.Add(new Employee("Jane Doe", "Management"));
EmployeeList employeesSeattleBranch = new EmployeeList();
employeesSeattleBranch.Add(new Employee("John Cardholder", "Management"));
employeesSeattleBranch.Add(new Employee("Joe Bloggs", "Sales"));
// Register our data sources by name in a data source root.
// If we are about to use this data source root in a mail merge with regions,
// each source's registered name must match the name of an existing mail merge region in the mail merge source document.
DataSourceRoot sourceRoot = new DataSourceRoot();
sourceRoot.RegisterSource(mailMergeRegions[0], new EmployeeListMailMergeSource(employeesWashingtonBranch));
sourceRoot.RegisterSource(mailMergeRegions[1], new EmployeeListMailMergeSource(employeesSeattleBranch));
// Since we have consecutive mail merge regions, we would normally have to perform two mail merges.
// However, one mail merge source with a data root can fill in multiple regions
// if the root contains tables with corresponding names/column names.
doc.MailMerge.ExecuteWithRegions(sourceRoot);
doc.Save(ArtifactsDir + "MailMergeCustom.CustomDataSourceRoot.docx");
TestCustomDataSourceRoot(mailMergeRegions, sourceRoot, new Document(ArtifactsDir + "MailMergeCustom.CustomDataSourceRoot.docx")); //ExSkip
}
static void Main(string[] args)
{
var employees = new EmployeeList();
var employee = default(Employee);
employee = new Employee();
employee.Name = "Akira Sugiura";
employee.Id = employees.Count + 1;
employees.Add(employee);
employee = new Employee();
employee.Name = "Yusuke Fujiwara";
employee.Id = employees.Count + 1;
employees.Add(employee);
employee = new Employee();
employee.Name = "Takahiro Nagao";
employee.Id = employees.Count + 1;
employees.Add(employee);
foreach (IEmployee _employee in employees)
{
Console.WriteLine(string.Format("Employee{0:d2}: {1}", _employee.Id, _employee.Name));
}
Console.ReadLine();
}
static void Main(string[] args)
{
var employees = new EmployeeList();
var employee = default(Employee);
employee = new Employee();
employee.Name = "Akira Sugiura";
employee.Id = employees.Count + 1;
employees.Add(employee);
employee = new Employee();
employee.Name = "Yusuke Fujiwara";
employee.Id = employees.Count + 1;
employees.Add(employee);
employee = new Employee();
employee.Name = "Takahiro Nagao";
employee.Id = employees.Count + 1;
employees.Add(employee);
foreach (IEmployee _employee in employees)
{
Console.WriteLine(string.Format("Employee{0:d2}: {1}", _employee.Id, _employee.Name));
}
Console.ReadLine();
}
[Test] //ExSkip
public void MailMergeCustomDataSourceRoot()
{
// Create a document with two mail merge regions named "Washington" and "Seattle"
Document doc = CreateSourceDocumentWithMailMergeRegions(new string[] { "Washington", "Seattle" });
// Create two data sources
EmployeeList employeesWashingtonBranch = new EmployeeList();
employeesWashingtonBranch.Add(new Employee("John Doe", "Sales"));
employeesWashingtonBranch.Add(new Employee("Jane Doe", "Management"));
EmployeeList employeesSeattleBranch = new EmployeeList();
employeesSeattleBranch.Add(new Employee("John Cardholder", "Management"));
employeesSeattleBranch.Add(new Employee("Joe Bloggs", "Sales"));
// Register our data sources by name in a data source root
DataSourceRoot sourceRoot = new DataSourceRoot();
sourceRoot.RegisterSource("Washington", new EmployeeListMailMergeSource(employeesWashingtonBranch));
sourceRoot.RegisterSource("Seattle", new EmployeeListMailMergeSource(employeesSeattleBranch));
// Since we have consecutive mail merge regions, we would normally have to perform two mail merges
// However, one mail merge source data root call every relevant data source and merge automatically
doc.MailMerge.ExecuteWithRegions(sourceRoot);
doc.Save(ArtifactsDir + "MailMerge.MailMergeCustomDataSourceRoot.docx");
}
public Boolean addNewEmployee(string firstName, string lastName, string address, string phone, string email, string nextOfKinName, string nextOfKinPhone, decimal salery, string usertype)
{
try
{
int maxId = 0;
int maxUserID = 0;
//need some code to avoid dulicate usernames
//maybe add some logic (busiess rules) about password policy
//IUser user = new User(name, password, userType); // Construct a User Object
foreach (Employee employee in EmployeeList)
{
if (employee.EmployeeID > maxId && employee.UserID > maxUserID)
{
maxId = employee.EmployeeID;
}
maxUserID = employee.UserID;
}
IEmployee theEmployee = EmployeeFactory.GetEmployee(maxId + 1, maxUserID + 1, firstName, lastName, address, phone, email, nextOfKinName, nextOfKinPhone, salery, usertype); // Using a Factory to create the user entity object. ie seperating object creation from business logic
EmployeeList.Add(theEmployee); // Add a reference to the newly created object to the Models UserList
DataLayer.addNewEmployeeToDB(theEmployee); //Gets the DataLayer to add the new user to the DB.
return(true);
}
catch (System.Exception excep)
{
return(false);
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
if (Session["employeeToView"] != null)
{
//this must be an edit
//set formview as edit mode only
// display the account to be edited
Employee employeeToBeEdited = Session["employeeToView"] as Employee;
EmployeeList employeeList = new EmployeeList();
employeeList.Add(employeeToBeEdited);
fViewEmployee.ChangeMode(FormViewMode.Edit);
fViewEmployee.DataSource = employeeList;
fViewEmployee.DataBind();
//clear the session["accountToView"]
Session["employeeToView"] = null;
}
else
{
//create a new employee
}
}
}
/// <summary>
/// Retrieves list of Employee objects from SqlCommand, after database query
/// number of rows retrieved and returned depends upon the rows field value
/// </summary>
/// <param name="cmd">The command object to use for query</param>
/// <param name="rows">Number of rows to process</param>
/// <returns>A list of Employee objects</returns>
private EmployeeList GetList(SqlCommand cmd, long rows)
{
// Select multiple records
SqlDataReader reader;
long result = SelectRecords(cmd, out reader);
//Employee list
EmployeeList list = new EmployeeList();
using ( reader )
{
// Read rows until end of result or number of rows specified is reached
while (reader.Read() && rows-- != 0)
{
Employee employeeObject = new Employee();
FillObject(employeeObject, reader);
list.Add(employeeObject);
}
// Close the reader in order to receive output parameters
// Output parameters are not available until reader is closed.
reader.Close();
}
return(list);
}
public ActionResult One_Five()
{
using (var db = new NorthwindEntities())
{
var Q5Result = (from e in db.Employees
where e.Country.ToLower() == "uk"
select new { Fullname = e.TitleOfCourtesy + " " + e.FirstName + " " + e.LastName, e.City }).ToList();
List <(string Fullname, string City)> EmployeeList =
new List <(string Fullname, string City)>();
foreach (var item in Q5Result)
{
var Employee = (
item.Fullname,
item.City
);
EmployeeList.Add(Employee);
}
ViewBag.Q5 = EmployeeList;
}
return(View());
}
private async Task ExecuteLoadCommand()
{
try
{
IsBusy = true;
if (IsNetworkConnected)
{
EmployeeList.Clear();
var items = await ServiceHandler.ProcessRequestCollectionAsync <Employee>(Constants.Employee);
foreach (var item in items)
{
EmployeeList.Add(item);
} //Server Call
IsBusy = false;
}
else
{
_employeeList = App.DataBase.GetItems <Employee>(); //From Local DB
IsBusy = false;
}
}
catch (Exception ex)
{
Console.WriteLine("An Exception Occured During Save Record {0}", ex.Message);
}
}
public async void ExecuteLoadEmployeeCommand()
{
try
{
EmployeeList.Clear();
var employees = await DataStoreEmp.GetAllAsync();
foreach (var item in employees)
{
EmployeeList.Add(item);
}
int nb = EmployeeList.Count;
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
}
public bool AddNewEmployeeToDb(string title, string firstName, string middleName, string lastName,
string phoneNumber, string email, Address personalAddress,
int employeeNumber, DateTime dateOfBirth, string ppsn, double wage, int employeeCategory,
int employeeCardNumber, DateTime hireDate, string photo)
{
try
{
int maxId = 0;
// need some code to avoid dulicate usernames
// maybe add some logic (busiess rules) about password policy
// IUser user = new User(name, password, userType); // Construct a User Object
foreach (Employee employee in EmployeeList)
{
if (employee.employeeNumber > maxId)
{
maxId = employee.employeeNumber;
}
}
IEmployee theEmployee = EmployeeFactory.GetEmployee(title, firstName, middleName, lastName, phoneNumber,
email, personalAddress, employeeNumber, dateOfBirth, ppsn, wage, employeeCategory,
employeeCardNumber, hireDate, photo);
// Using a Factory to create the user entity object. ie seperating object creation from business logic
EmployeeList.Add(theEmployee); // Add a reference to the newly created object to the Models UserList
DataLayer.AddNewEmployeeToDb(theEmployee); //Gets the DataLayer to add the new user to the DB.
return(true);
}
catch (System.Exception excep)
{
return(false);
}
}
public static EmployeeList GetList()
{
EmployeeList eList = null;
MyDBConnection myConn = new MyDBConnection();
SqlConnection conn = new SqlConnection();
SqlDataReader dr;
SqlCommand cmd = null;
string sql = "Select * from AquaOne.dbo.Employee";
try
{
// Open the connection
conn = myConn.OpenDB();
cmd = new SqlCommand(sql, conn);
dr = cmd.ExecuteReader();
if (dr.HasRows)
{
eList = new EmployeeList();
while (dr.Read())
{
eList.Add(FillDataRecord(dr));
}
}
}
finally
{
cmd.Dispose();
myConn.CloseDB(conn);
}
return(eList);
}
public void CreateNewEmployee(OfficeDesk officeDesk, float happiness)
{
EmployeeController employeeController = employeeGenerator.InstantiateEmployeePrefab(GameMetaManager.Office.DoorPoint);
employeeController.OnHolidayTaked += officeDesk.HolidayDesk.ActivateHolidayCartel;
employeeController.Init(officeDesk, happiness);
EmployeeList.Add(employeeController);
}
private void DoRetreive()
{
EmployeeList.Clear();
foreach (var employee in Dal.GetEmployees())
{
EmployeeList.Add(employee);
}
}
public async void GetData()
{
EmployeeList.Clear();
var emplist = await DataStoreEmp.GetAllAsync();
foreach (Employee e in emplist)
{
EmployeeList.Add(e);
}
}
private async Task LoadEmployee(string departmentIDList)
{
await repoEmployeeRepository.GetAsync(departmentIDList);
EmployeeList.Clear();
foreach (var item in repoEmployeeRepository.Items)
{
EmployeeList.Add(item);
}
}
/// <summary>
/// Create a new employee
/// </summary>
/// <param name="id"></param>
/// <param name="name"></param>
/// <param name="sallary"></param>
/// <param name="employrate"></param>
/// <param name="vacancy"></param>
public Employee CreateEmployee(long id, string name, int sallary, int employrate, decimal vacancy)
{
Employee newEmployee = new Employee {
EmployeeID = id, EmployeeName = name, MonthSallary = sallary, EmployeementRate = employrate, VacancyDeduction = vacancy
};
EmployeeList.Add(newEmployee);
db.Employee.Add(newEmployee);
db.SaveChanges();
return(newEmployee);
}
public void AddEmployeeFromData(String employeeData)
{
try
{
String[] employeeInfoArray = employeeData.Split('|');
/*Employee Data
* Name, type, region, matchCount, averageRating, wins, losses, draws, moraleRank, moralePoints, failedQuiRolls, quitRollCeiling
*/
foreach (String employeeInfo in employeeInfoArray)
{
if (employeeInfo.Trim().Equals(""))
{
continue;
}
String[] employeeDetails = employeeInfo.Split(':');
Employee employee = new Employee();
employee.Name = employeeDetails[0];
employee.Type = CorrectEmployeeType(employeeDetails[1]);
employee.Region = employeeDetails[2];
employee.MatchCount = int.Parse(employeeDetails[3]);
employee.AverageRating = float.Parse(employeeDetails[4]);
employee.Wins = int.Parse(employeeDetails[5]);
employee.Losses = int.Parse(employeeDetails[6]);
employee.Draws = int.Parse(employeeDetails[7]);
//Ensure that the rank is in bounds
int rank = int.Parse(employeeDetails[8]);
if (rank > 5)
{
rank = 5;
}
else if (rank < 0)
{
rank = 0;
}
employee.MoraleRank = rank;
employee.MoralePoints = int.Parse(employeeDetails[9]);
employee.FailedQuitRolls = int.Parse(employeeDetails[10]);
employee.QuitRollCeiling = int.Parse(employeeDetails[11]);
EmployeeList.Add(employee);
}
}
catch (Exception e)
{
L.D("AddEmployeeFromData Exception for " + employeeData + " : " + e);
}
}
public void FillEmployeeList()
{
List <string[]> employeeData = DataLayer.GetTableData("employee");
foreach (String[] row in employeeData)
{
Guid uid = Guid.NewGuid();
GenericFactory <IEmployee> .Register(uid, () => new Employee(Convert.ToInt16(row[0]), row[1], row[2], row[3], Convert.ToInt16(row[4]), Convert.ToInt16(row[5])));
IEmployee emp = GenericFactory <IEmployee> .Create(uid);
EmployeeList.Add(emp);
}
}
protected void lnkEditPersonalInformation_OnCommand(object sender, CommandEventArgs e)
{
EmployeeList el = new EmployeeList();
el.Add(EmployeeManager.GetEmployeeByID(employeeSearched.EmployeeID));
JobPositionList jl = new JobPositionList();
jl.Add(JobPositionManager.GetPositionByID(employeeSearched.JobPositionID));
fview_EditPersonalInformation.DataSource = el;
fview_EditPersonalInformation.DataBind();
this.mPopupEdit_PersonalInformation.Show();
}
/// <summary>
/// Adds new Employee to Employees collection.
/// </summary>
/// <param name="newEmployee">Contains the Employee details to be added.</param>
/// <returns>Determinates whether the new Employee is added.</returns>
public override bool AddEmployeeDAL(Employee newEmployee)
{
bool employeeAdded = false;
try
{
newEmployee.EmployeeID = Guid.NewGuid();
newEmployee.CreationDateTime = DateTime.Now;
newEmployee.LastModifiedDateTime = DateTime.Now;
EmployeeList.Add(newEmployee);
employeeAdded = true;
}
catch (PecuniaException)
{
throw new EmployeeAddedException("Employee not added");
}
return(employeeAdded);
}
public void FillEmployeeGrid()
{
if (EmployeeList.Count() > 0)
{
EmployeeList.Clear();
}
using (var db = new DataSmartDBContext())
{
var emp = db.Employee.ToList();
if (emp != null)
{
foreach (var d in emp)
{
EmployeeList.Add(d);
}
}
}
}
/// <summary>
/// This method provides List of Employees available in Database.
/// </summary>
/// <param name="strWhere">Specifies condition for retrieving records.</param>
/// <returns>Collection of Employee Objects.</returns>
public static EmployeeList GetList(string strWhere)
{
EmployeeList objList = null;
string strSql = "SELECT A.*, B.DEPTNAME " +
" FROM EmpMast A, DEPTMAST B " +
" WHERE A.DEPT = B.DBID ";//(+)
if (strWhere != string.Empty)
{
strSql = strSql + " AND " + strWhere;
}
strSql += " ORDER BY DEPTNAME, INITIALS";
using (SqlConnection Conn = new SqlConnection(General.GetSQLConnectionString()))
{
using (SqlCommand objCmd = new SqlCommand())
{
objCmd.Connection = Conn;
objCmd.CommandType = CommandType.Text;
objCmd.CommandText = strSql;
if (Conn.State != ConnectionState.Open)
{
Conn.Open();
}
using (SqlDataReader oReader = objCmd.ExecuteReader())
{
if (oReader.HasRows)
{
objList = new EmployeeList();
while (oReader.Read())
{
objList.Add(FillDataRecord(oReader));
}
}
oReader.Close();
oReader.Dispose();
}
}
}
return(objList);
}
public async Task ExecuteLoadItemsCommand()
{
try
{
EmployeeList.Clear();
var employees = await DataStoreEmp.GetAllAsync();
foreach (var item in employees)
{
EmployeeList.Add(item);
}
int nb = EmployeeList.Count;
Console.WriteLine("Employee Number= " + nb);
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
finally
{
IsBusy = false;
}
}
public void AddEmployee(string name, double salary)
{
TotalSalary += salary;
EmployeeList.Add(new Employee(name, salary));
}
public void isEmployeeOf(Employee e)
{
EmployeeList.Add(e);
}
static void Program5()
{
EmployeeList list = new EmployeeList();
int i = 0;
string name = string.Empty;
int[] point = new int[3];
Console.WriteLine(" Sistema de Funcionários ");
Console.WriteLine("****************************************************************************");
while (i < 2)
{
Console.Write("Digite o nome: ");
name = Console.ReadLine();
Console.Write("Digite o mês de Novembro: ");
point[0] = int.Parse(Console.ReadLine());
Console.Write("Digite o mês de Dezembro: ");
point[1] = int.Parse(Console.ReadLine());
Console.Write("Digite o mês de Janeiro: ");
point[2] = int.Parse(Console.ReadLine());
Accumulate ac0 = new Accumulate("Novembro", point[0]);
Accumulate ac1 = new Accumulate("Dezembro", point[1]);
Accumulate ac2 = new Accumulate("Janeiro", point[2]);
Employee employee = new Employee(name, new List <Accumulate> {
ac0, ac1, ac2
});
list.Add(employee);
i++;
}
GlobalSummaryEmployee(list);
void GlobalSummaryEmployee(List <Employee> item)
{
Console.WriteLine("");
Console.WriteLine(" Soma Geral de Pontos ");
Console.WriteLine("****************************************************************************");
Console.WriteLine("Nome Completo Soma Média ");
Console.WriteLine("****************************************************************************");
item.ForEach(x => {
Console.WriteLine("{0} {1} {2:n}",
x.Name.PadRight(34, ' '),
x.Points.Sum(x => x.Point).ToString().PadRight(26, ' '),
x.Points.Average(x => x.Point)
);
});
Console.WriteLine("");
Console.WriteLine(" Pontuação por Mês / Funcionários ");
Console.WriteLine("****************************************************************************");
Console.WriteLine("Nome Completo Mês Valor ");
Console.WriteLine("****************************************************************************");
item.Select(x => new {
Name = x.Name,
Point = x.Points.Max(x => x.Point),
Month = x.Points.Where(b => b.Point == x.Points.Max(c => c.Point))
.Select(x => x.Month)
.FirstOrDefault()
})
.ToList()
.ForEach(x => {
Console.WriteLine("{0} {1} {2}",
x.Name.PadRight(34, ' '),
x.Month.ToString().PadRight(26, ' '),
x.Point
);
});
}
}
// Create a method that allows external code to add an employee
public void AddEmployee(Employee person)
{
EmployeeList.Add(person);
}
//Employee Methods
static public void GetAllEmployees(HairSpaContext context)
{
//Clear employee list, then add customer table records to the list.
EmployeeList.ToList().ForEach(emp => EmployeeList.Remove(emp));
context.Employees.ToList().ForEach(emp => EmployeeList.Add(emp));
}
static public void SearchEmployee(ComboBox box, TextBox search, HairSpaContext context)
{
IQueryable <Employee> list = null;
EmployeeList.Clear();
switch (box.SelectedItem)
{
case "Id":
list = context.Employees.Where(emp => emp.Id.ToString().Contains(search.Text));
break;
case "First Name":
list = context.Employees.Where(emp => emp.FirstName.Contains(search.Text));
break;
case "Last Name":
list = context.Employees.Where(emp => emp.LastName.Contains(search.Text));
break;
case "Address":
list = context.Employees.Where(emp => emp.Address.Contains(search.Text));
break;
case "City":
list = context.Employees.Where(emp => emp.City.Contains(search.Text));
break;
case "State":
list = context.Employees.Where(emp => emp.State.Contains(search.Text));
break;
case "Job Title":
list = context.Employees.Where(emp => emp.JobTitle.Contains(search.Text));
break;
case "Status Number":
list = context.Employees.Where(emp => emp.Status.ToString().Contains(search.Text));
break;
default:
break;
}
try
{
if (list.ToList().Count <= 0)
{
MessageBox.Show("No records were found", "No Results");
return;
}
else
{
list.ToList().ForEach(emp => EmployeeList.Add(emp));
}
}
catch (Exception)
{
MessageBox.Show("No records were found", "No Results");
return;
}
}
public void isEmployeeOf(Employee p)
{
EmployeeList.Add(p);
}
