public JsonResult AddEmployee(EmployeeEntry Employee)
{
EmployeeController obj = new EmployeeController();
var response = obj.Post(Employee);
return(Json(((SchoolApi.EmployeeEntry)(((System.Net.Http.ObjectContent)(response.Content)).Value)).EEID, JsonRequestBehavior.AllowGet));
}
public async Task Put(int id, [FromBody] EmployeeEntry value)
{
var entry = await _db.Entries.FindAsync(id);
entry = value;
await _db.SaveChangesAsync();
}
public JsonResult UpdateEmployee(int Tid, EmployeeEntry Employee)
{
EmployeeController obj = new EmployeeController();
var response = obj.Put(Tid, Employee);
return(Json(response, JsonRequestBehavior.AllowGet));
}
private void SetUpMock()
{
List <EmployeeEntry> data = new List <EmployeeEntry>
{
new EmployeeEntry {
Email = "Email", EmployeeID = "EmployeeID1", FirstName = "FirstName1", Id = Guid.NewGuid(), LastName = "LastName", Phone = "Phone"
},
new EmployeeEntry {
Email = "Email", EmployeeID = "EmployeeID2", FirstName = "FirstName2", Id = Guid.NewGuid(), LastName = "LastName", Phone = "Phone"
},
new EmployeeEntry {
Email = "Email", EmployeeID = "EmployeeID3", FirstName = "FirstName3", Id = Guid.NewGuid(), LastName = "LastName", Phone = "Phone"
},
};
EmployeeEntry result = new EmployeeEntry {
Email = "Email", EmployeeID = "EmployeeID1", FirstName = "FirstName1", Id = Guid.NewGuid(), LastName = "LastName", Phone = "Phone"
};
mock.Setup(m => m.EmployeeRepository.AddEmployee(It.IsAny <EmployeeEntry>()));
mock.Setup(m => m.EmployeeRepository.DeleteEmployee(It.IsAny <Guid>()));
mock.Setup(m => m.EmployeeRepository.UpdateEmployee(It.IsAny <EmployeeEntry>()));
mock.Setup(m => m.EmployeeRepository.GetAllEmployee()).Returns(data);
mock.Setup(m => m.EmployeeRepository.GetEmployee(It.IsAny <Guid>())).Returns(result);
mock.Setup(m => m.Commit()).Returns(1);
}
public EmployeeModel(EmployeeEntry entry)
{
Email = entry.Email;
EmployeeID = entry.EmployeeID;
FirstName = entry.FirstName;
Id = entry.Id;
LastName = entry.LastName;
Phone = entry.Phone;
}
public async Task <string> Post([FromBody] EmployeeEntry value)
{
await _db.Entries.AddAsync(value);
await _db.SaveChangesAsync();
return(value.EmployeeId + " - " + value.Name + " : " + value.Surname);
}
public void UpdateEmployee(EmployeeEntry employee)
{
var empployee = _context.Employees.FirstOrDefault(t => t.Id == employee.Id);
empployee.Email = employee.Email;
empployee.EmployeeID = employee.EmployeeID;
empployee.FirstName = employee.FirstName;
empployee.LastName = employee.LastName;
empployee.Phone = employee.Phone;
_context.Entry(empployee).State = EntityState.Modified;
}
public ActionResult GetEmployees()
{
try
{
List <Employee> emplList = new EmployeeEntry().GetEmployees();
return(Ok(emplList));
}
catch (Exception ex)
{
Log.ErrorToFile(ex.Message);
return(BadRequest(ex.Message));
}
}
public ActionResult GetEmployees(int id)
{
try
{
Employee employee = new EmployeeEntry().GetEmployees().Where(X => X.Id == id).FirstOrDefault();
return(Ok(employee));
}
catch (Exception ex)
{
Log.ErrorToFile(ex.Message);
return(BadRequest(ex.Message));
}
}
public EmployeeEntryReply addEmployee(Employees empregd)
{
Console.WriteLine("In addEmployee");
EmployeeEntryReply empentryreply = new EmployeeEntryReply();
EmployeeEntry.getInstance().Add(empregd);
empentryreply.completeName = empregd.completeName;
empentryreply.companyName = empregd.companyName;
empentryreply.HireDate = empregd.HireDate;
empentryreply.employeeid = empregd.employeeid;
empentryreply.RegistrationStatus = "Successful";
return(empentryreply);
}
public static EmployeeEntry ToEntry(this EmployeeModel model)
{
EmployeeEntry entity = new EmployeeEntry()
{
Email = model.Email,
EmployeeID = model.EmployeeID,
FirstName = model.FirstName,
Id = model.Id,
LastName = model.LastName,
Phone = model.Phone,
};
return(entity);
}
public void AddEmployeeTest()
{
SetUpMock();
// Create some test data
var mockData = new EmployeeEntry {
Email = "Email", EmployeeID = "EmployeeID", FirstName = "FirstName1", Id = Guid.NewGuid(), LastName = "LastName", Phone = "Phone"
};
// Check the results
unitOfWork.EmployeeRepository.AddEmployee(mockData);
unitOfWork.Commit();
set.Verify(m => m.Add(It.IsAny <EmployeeEntity>()), Times.Once());
context.Verify(m => m.SaveChanges(), Times.Once());;
}
public void GetEmployeeTest()
{
EmployeeEntry mockData = new EmployeeEntry {
Email = "Email", EmployeeID = "EmployeeID", FirstName = "FirstName1", Id = Guid.Parse("{0F681332-D795-409A-85BB-B77678FB74EE}"), LastName = "LastName", Phone = "Phone"
};
_unitOfWork.Setup(m => m.EmployeeRepository.GetEmployee(Guid.Parse("{0F681332-D795-409A-85BB-B77678FB74EE}"))).Returns((mockData));
EmployeeMgr employeeMgr = new EmployeeMgr(_unitOfWork.Object);
EmployeeModel result = employeeMgr.GetEmployee(Guid.Parse("{0F681332-D795-409A-85BB-B77678FB74EE}"));
Assert.IsTrue(result.EmployeeID == mockData.EmployeeID &&
result.Email == mockData.Email &&
result.FirstName == mockData.FirstName &&
result.LastName == mockData.LastName &&
result.Phone == mockData.Phone);
}
public static EmployeeEntity ToEntity(this EmployeeEntry entry)
{
EmployeeEntity entity = new EmployeeEntity()
{
Email = entry.Email,
EmployeeID = entry.EmployeeID,
FirstName = entry.FirstName,
Gender = entry.Gender,
Id = entry.Id.Value,
LastName = entry.LastName,
Married = entry.Married,
Phone = entry.Phone,
Modified = entry.Modified,
Created = entry.Created
};
return(entity);
}
public void UpdateState(string login, Status status)
{
EmployeeEntry employeeEntry;
if (_employees.TryGetValue(login, out employeeEntry))
{
employeeEntry.Employee.Status = status;
_employees[login] = new EmployeeEntry(employeeEntry.Employee, new Timer(_employeeSettings.TimeOut));
}
else
{
var employee = _employeeRepository.GetEmployee(login);
employee.Status = status;
_employees[login] = new EmployeeEntry(employee, new Timer(_employeeSettings.TimeOut));
}
}
public HttpResponseMessage Post(EmployeeEntry Employee)
{
HttpRequestMessage Request = new HttpRequestMessage();
Request.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration());
if (ModelState.IsValid)
{
unitOfWork.EmployeeRepository.Insert(Employee);
unitOfWork.Save();
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.Created, Employee);
response.Headers.Location = new Uri(Url.Link("DefaultApi", new { EEID = Employee.EEID }));
return(response);
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
}
public EmployeeEntry Delete(int Tid)
{
EmployeeEntry Employee = unitOfWork.EmployeeRepository.GetById(Tid);
if (Employee == null)
{
return(Employee);
}
try
{
unitOfWork.EmployeeRepository.Delete(Tid);
unitOfWork.Save();
}
catch (DbUpdateConcurrencyException ex)
{
return(Employee);
}
return(Employee);
}
public void Display(EmployeeEntry employee)
{
empName = employee.empName;
Text text = gameObject.GetComponentInParent(typeof(Text)) as Text;
text.text = employee.empName;
description = employee.description;
level = employee.level;
sprintNum = employee.sprintNum;
salary = employee.salary;
motivation = employee.motivation;
talkative = employee.talkative;
mechanical = employee.mechanical;
debugging = employee.debugging;
documentation = employee.documentation;
test = employee.test;
estimate = employee.estimate;
friendliness = employee.friendliness;
helpfulness = employee.helpfulness;
quirk = employee.quirk.ToString();
}
public bool Put(int Tid, EmployeeEntry Employee)
{
if (!ModelState.IsValid)
{
return(false);
}
if (Tid != Employee.EEID)
{
return(false);
}
try
{
unitOfWork.EmployeeRepository.Update(Employee);
unitOfWork.Save();
}
catch (DbUpdateConcurrencyException ex)
{
return(false);
}
return(true);
}
public IActionResult Update(int id, [FromBody] EmployeeEntry employee)
{
return(entryRepository.Contains(id) ? (IActionResult)Ok(entryRepository.Update(id, employee)) : NotFound());
}
public String PutEmployeeRecord(Employees emp)
{
Console.WriteLine("In updateEmployeeRecord");
return(EmployeeEntry.getInstance().UpdateStudent(emp));
}
public String DeleteEmployeeRecord(String regID)
{
Console.WriteLine("In deleteEmployeeRecord");
return(EmployeeEntry.getInstance().Remove(regID));
}
public void AddEmployee(EmployeeEntry employee)
{
EmployeeEntity employeeEntity = employee.ToEntity();
employeeEntity = _context.Employees.Add(employeeEntity);
}
private void employeeEntryToolStripMenuItem_Click(object sender, EventArgs e)
{
EmployeeEntry obj = new EmployeeEntry();
obj.Show();
}
public IActionResult Create([FromBody] EmployeeEntry employeeEntry)
{
var CreatedEmployee = entryRepository.Create(employeeEntry);
return(CreatedAtRoute("CreatedRoute", new { id = CreatedEmployee.EmpId }, CreatedEmployee));
}
public List <Employees> GetAllStudents()
{
return(EmployeeEntry.getInstance().getallemployee());
}
