public void GetUserDetailsCreatedBeforeToday()
{
List <EmployeeModel> employeeList = new List <EmployeeModel>();
Function function = new Function();
QueryBuilderRequest employeeRequest = new QueryBuilderRequest
{
CompanyId = 6,
UserId = 111,
Payload = new QueryBuilderRequest
{
ColumnList = DefaultColumnsList,
Fields = employeeList,
EntityName = "Employee",
AppType = Constants.QUERY_BUILDER
}
};
EmployeeModel employeeModel1 = new EmployeeModel
{
Name = Constants.USER_CREATED_DATE,
Value = "04/22/2019",
Operator = "<"
};
employeeList.Add(employeeModel1);
EmployeeResponse usersResponse = function.GetEmployeesQueryBuilder(employeeRequest, null);
List <EmployeeQueryModel> userResponse = usersResponse.Employees;
Assert.AreNotEqual(0, userResponse.Count);
}
public void GetUsersWithSpecificRole()
{
List <EmployeeModel> employeeList = new List <EmployeeModel>();
Function function = new Function();
QueryBuilderRequest employeeRequest = new QueryBuilderRequest
{
CompanyId = 6,
UserId = 111,
Payload = new QueryBuilderRequest
{
ColumnList = DefaultColumnsList,
Fields = employeeList,
EntityName = "Employee",
AppType = Constants.QUERY_BUILDER
}
};
EmployeeModel employeeModel1 = new EmployeeModel
{
Name = Constants.ROLE,
Value = Constants.SUPERVISOR,
Operator = "="
};
employeeList.Add(employeeModel1);
EmployeeResponse usersResponse = function.GetEmployeesQueryBuilder(employeeRequest, null);
List <EmployeeQueryModel> userResponse = usersResponse.Employees;
Assert.AreNotEqual(0, userResponse.Count);
Assert.IsTrue(userResponse[0].Role.ToUpper() == Constants.SUPERVISOR);
}
public void RetrieveEmployeeMetricsFail()
{
var testEmail = "*****@*****.**";
var empService = new Mock <IEmployeeService>();
EmployeeResponse mockRes = null; // Return a null response from service call
empService.Setup(serv => serv.RetrieveEmployeeMetrics(It.IsAny <string>())).Returns(mockRes);
var user = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, "test"),
new Claim(ClaimTypes.NameIdentifier, "1"),
new Claim("email", testEmail),
}, "mock"));
var controller = new EmployeeController(empService.Object);
controller.ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = user
}
};
var result = controller.GetEmployeeMetrics().Result;
var notFoundResult = result as NotFoundResult;
Assert.NotNull(notFoundResult);
Assert.Equal(404, notFoundResult.StatusCode);
empService.Verify(x => x.RetrieveEmployeeMetrics(It.IsAny <string>()), Times.Once);
}
//[HttpGet]
public async Task <IEnumerable <EmployeeResponse> > Gettblemployee()
{
List <EmployeeResponse> EmployeeResponseList = new List <EmployeeResponse>();
List <Employee> list = new List <Employee>();
var o = _context.tblemployee;
list = _context.tblemployee.ToList <Employee>();
for (int i = 0; i < list.Count; i++)
{
try
{
var document = await _context.document.FirstOrDefaultAsync(x => x.IDEmployee == list[i].ID);
EmployeeResponse obj = new EmployeeResponse();
obj.employee = list[i];
obj.fileToUpload = document;
EmployeeResponseList.Add(obj);
}
catch (Exception ex)
{
System.Console.WriteLine(ex.ToString());
}
}
return(EmployeeResponseList);
}
public async Task <bool> UpdateEmployeeAsync(EmployeeResponse employeeViewModel,
CancellationToken ct = default)
{
var employee = await _employeeRepository.GetByIdAsync(employeeViewModel.EmployeeId, ct);
if (employee == null)
{
return(false);
}
employee.EmployeeId = employeeViewModel.EmployeeId;
employee.LastName = employeeViewModel.LastName;
employee.FirstName = employeeViewModel.FirstName;
employee.Title = employeeViewModel.Title;
employee.ReportsTo = employeeViewModel.ReportsTo;
employee.BirthDate = employeeViewModel.BirthDate;
employee.HireDate = employeeViewModel.HireDate;
employee.Address = employeeViewModel.Address;
employee.City = employeeViewModel.City;
employee.State = employeeViewModel.State;
employee.Country = employeeViewModel.Country;
employee.PostalCode = employeeViewModel.PostalCode;
employee.Phone = employeeViewModel.Phone;
employee.Fax = employeeViewModel.Fax;
employee.Email = employeeViewModel.Email;
return(await _employeeRepository.UpdateAsync(employee, ct));
}
public async Task <EmployeeResponse> AddEmployeeAsync(EmployeeResponse newEmployeeViewModel,
CancellationToken ct = default)
{
var employee = new Employee
{
LastName = newEmployeeViewModel.LastName,
FirstName = newEmployeeViewModel.FirstName,
Title = newEmployeeViewModel.Title,
ReportsTo = newEmployeeViewModel.ReportsTo,
BirthDate = newEmployeeViewModel.BirthDate,
HireDate = newEmployeeViewModel.HireDate,
Address = newEmployeeViewModel.Address,
City = newEmployeeViewModel.City,
State = newEmployeeViewModel.State,
Country = newEmployeeViewModel.Country,
PostalCode = newEmployeeViewModel.PostalCode,
Phone = newEmployeeViewModel.Phone,
Fax = newEmployeeViewModel.Fax,
Email = newEmployeeViewModel.Email
};
employee = await _employeeRepository.AddAsync(employee, ct);
newEmployeeViewModel.EmployeeId = employee.EmployeeId;
return(newEmployeeViewModel);
}
public async Task <ActionResult <EmployeeResponse> > Put(int id, [FromBody] EmployeeResponse input,
CancellationToken ct = default)
{
try
{
if (input == null)
{
return(BadRequest());
}
if (await _chinookSupervisor.GetEmployeeByIdAsync(id, ct) == null)
{
return(NotFound());
}
var errors = JsonConvert.SerializeObject(ModelState.Values
.SelectMany(state => state.Errors)
.Select(error => error.ErrorMessage));
Debug.WriteLine(errors);
if (await _chinookSupervisor.UpdateEmployeeAsync(input, ct))
{
return(Ok(input));
}
return(StatusCode(500));
}
catch (Exception ex)
{
return(StatusCode(500, ex));
}
}
public void SmartParamCombinationTest()
{
List <EmployeeModel> employeeList = new List <EmployeeModel>();
Function function = new Function();
QueryBuilderRequest employeeRequest = new QueryBuilderRequest
{
CompanyId = 6,
UserId = 111,
Payload = new QueryBuilderRequest
{
ColumnList = DefaultColumnsList,
Fields = employeeList,
EntityName = "Employee",
AppType = Constants.QUERY_BUILDER
}
};
EmployeeModel employeeModel1 = new EmployeeModel
{
Name = Constants.DEPARTMENT,
Value = Constants.YES,
Operator = "="
};
employeeList.Add(employeeModel1);
EmployeeResponse usersResponse = function.GetEmployeesQueryBuilder(employeeRequest, null);
List <EmployeeQueryModel> userResponse = usersResponse.Employees;
Assert.AreNotEqual(0, userResponse.Count);
}
public void RetrieveEmployeeMetricsSuccess()
{
System.DateTime dt = new System.DateTime();
List <EmployeeMetrics> dbRetVal = new List <EmployeeMetrics>()
{
new EmployeeMetrics("lol1", "lol2", "lol3", 1.0, 2.0, 3.0, 4.0, 5.0, dt),
new EmployeeMetrics("lul", "lul", "lul", 2.0, 2.0, 2.0, 2.0, 2.0, dt)
};
MockServiceProvider serviceProvider = new MockServiceProvider()
.AddMockDBConnection();
serviceProvider.MockDBConnection
.Setup(_ => _.ExecuteQuery <EmployeeMetrics>(QueryGenerator.GetEmployeeMetricsHeader() + QueryGenerator.WhereEmail("*****@*****.**")))
.Returns(dbRetVal);
EmployeeService employeeService = new EmployeeService(serviceProvider.Build());
EmployeeResponse response = employeeService.RetrieveEmployeeMetrics("*****@*****.**");
Assert.Equal("lol1", response.EmployeeId);
Assert.Equal(3.0, response.Billable.CurrentHours);
Assert.Equal(2.0, response.Billable.CurrentTarget);
Assert.Equal(1.0, response.Billable.TotalTarget);
Assert.Equal(-1.0, response.Growth.HoursRemaining);
Assert.Equal(5.0, response.Growth.HoursUsed);
Assert.Equal(4.0, response.Growth.TotalGrowth);
}
public override async Task <EmployeeResponse> Save(EmployeeRequest request, ServerCallContext context)
{
try
{
var metadata = context.RequestHeaders;
foreach (var pair in metadata)
{
_logger.LogInformation($"{pair.Key}: {pair.Value}");
}
InMemoryData.Employees.Add(request.Employee);
var response = new EmployeeResponse
{
Employee = InMemoryData.Employees.SingleOrDefault(x => x.No == request.Employee.No)
};
Console.WriteLine("Employees:");
foreach (var employee in InMemoryData.Employees)
{
Console.WriteLine(employee);
}
return(await Task.FromResult(response));
}
catch (RpcException re)
{
throw;
}
catch (Exception e)
{
_logger.LogError(e.Message);
throw new RpcException(Status.DefaultCancelled, e.Message);
}
}
public IEnumerable <EmployeeResponse> GetEmployees(
int departmentId, bool includeDepartment) =>
this
.repository
.GetEmployees(departmentId, includeDepartment)
.Select(x => EmployeeResponse.FromEmployee(x, includeDepartment))
.ToArray();
/// <summary>
/// [QueryBuilder] Function to get list of employee(s) filtered with some condition(s)
/// </summary>
/// <param name="queryBuilderRequest"></param>
/// <param name="context"></param>
/// <returns>EmployeeResponse</returns>
public EmployeeResponse GetEmployeesQueryBuilder(QueryBuilderRequest queryBuilderRequest, ILambdaContext context = null)
{
EmployeeRepository employeeRepository = new EmployeeRepository();
EmployeeResponse employeeResponse = new EmployeeResponse();
Authorizer authorizer = new Authorizer();
try
{
//Validating the student details
string studentDetails = queryBuilderRequest.Payload.Fields.Where(x => x.Name.ToUpper() == Constants.STUDENT_DETAILS).Select(x => x.Value).FirstOrDefault();
if (authorizer.ValidateUser(queryBuilderRequest.UserId, queryBuilderRequest.CompanyId, queryBuilderRequest.Payload.AppType, studentDetails))
{
return(employeeRepository.GetEmployeeDetails(queryBuilderRequest));
}
else
{
employeeResponse.Error = ResponseBuilder.Forbidden();
return(employeeResponse);
}
}
catch (Exception getEmployeesException)
{
LambdaLogger.Log(getEmployeesException.ToString());
employeeResponse.Error = ResponseBuilder.InternalError();
return(employeeResponse);
}
}
public async Task <ActionResult <EmployeeResponse> > GetEmployeeByIdAsync(Guid id)
{
var employee = await _employeeRepository.GetByIdAsync(id);
if (employee == null)
{
return(NotFound());
}
var employeeModel = new EmployeeResponse()
{
Id = employee.Id,
Email = employee.Email,
Role = new RoleItemResponse()
{
Id = employee.Id,
Name = employee.Role.Name,
Description = employee.Role.Description
},
FullName = employee.FullName,
AppliedPromocodesCount = employee.AppliedPromocodesCount
};
return(employeeModel);
}
/// <summary>
/// 一元操作演示 —— 根据id获取员工数据
/// </summary>
/// <param name="request"></param>
/// <param name="context"></param>
/// <returns></returns>
public override async Task <EmployeeResponse> GetEmployeeById(GetEmployeeByIdRequest request,
ServerCallContext context)
{
//读取请求头中的元数据(应用层自定义的 key-value 对)
var metaDataIdHeaders = context.RequestHeaders;
foreach (var data in metaDataIdHeaders)
{
Console.WriteLine($"{data.Key} => {data.Value}");
}
//根据请求的Id找到员工信息
var employee = EmployeeRepository.Emloyees.SingleOrDefault(emp => emp.Id == request.Id);
if (employee == null)
{
throw new RpcException(Status.DefaultSuccess
, $"Employee of {request.Id} is not found");
}
var response = new EmployeeResponse {
Employee = employee
};
return(await Task.FromResult(response));
}
public void RequestWithoutColumnsList()
{
List <EmployeeModel> employeeList = new List <EmployeeModel>();
Function function = new Function();
QueryBuilderRequest employeeRequest = new QueryBuilderRequest
{
CompanyId = 6,
UserId = 6,
Payload = new QueryBuilderRequest
{
Fields = employeeList,
EntityName = "Employee",
AppType = Constants.QUERY_BUILDER
}
};
EmployeeModel employeeModel1 = new EmployeeModel
{
Name = Constants.USERID,
Value = "7",
Operator = ">="
};
employeeList.Add(employeeModel1);
EmployeeResponse usersResponse = function.GetEmployeesQueryBuilder(employeeRequest, null);
ErrorResponse userResponse = usersResponse.Error;
Assert.AreEqual(500, userResponse.Status);
Assert.AreEqual(33, userResponse.Code);
StringAssert.Contains(userResponse.Message, TestConstants.SYSTEM_ERROR);
}
public EmployeeResponse Create(EmployeeAttachmentViewModel attachment)
{
EmployeeResponse response = new EmployeeResponse();
using (SqliteConnection db = new SqliteConnection("Filename=SirmiumERPGFC.db"))
{
db.Open();
SqliteCommand insertCommand = db.CreateCommand();
insertCommand.CommandText = SqlCommandInsertPart;
try
{
insertCommand = AddCreateParameters(insertCommand, attachment);
insertCommand.ExecuteNonQuery();
}
catch (SqliteException error)
{
MainWindow.ErrorMessage = error.Message;
response.Success = false;
response.Message = error.Message;
return(response);
}
db.Close();
response.Success = true;
return(response);
}
}
internal void InsertEmployeeTest()
{
RestClient restClient = new RestClient("http://localhost:14547/api/");
EmployeeRequest employeeRequest = new EmployeeRequest()
{
EmployeeDto = new EmployeeDto()
{
EmployeeId = 0,
LastName = "Engin",
FirstName = "Türenç",
Title = "Türenç Engin",
TitleOfCourtesy = "TE",
BirthDate = new DateTime(1986, 07, 14),
HireDate = new DateTime(2018, 01, 15),
Address = "Sanayi Mahallesi, Teknopark Bulvarı 1/3C Kurtköy - Pendik",
City = "İstanbul",
Region = "Anadolu",
PostalCode = "34906",
Country = "Türkiye",
HomePhone = "+90 216 664 20 00",
Extension = "",
Photo = null,
Notes = "Developer",
ReportsTo = null,
PhotoPath = ""
}
};
EmployeeResponse employeeResponse = restClient.Consume <EmployeeResponse>("Employee/InsertEmpoloyee", employeeRequest);;
Console.WriteLine($"EmployeeId: {employeeResponse.EmployeeId}");
}
public ActionResult Create(EmployeeModel model)
{
try
{
if (ModelState.IsValid)
{
EmployeeResponse employeeResponse = _empClient.AddEditRecord(model);
return(RedirectToAction("Index"));
}
var deptList = _DptClient.GetDepartmentList(new DepartmentRequest());
List <SelectListItem> ObjList = new List <SelectListItem>();
foreach (var item in deptList.Items)
{
var value = new SelectListItem {
Text = item.Name, Value = item.Id.ToString()
};
ObjList.Add(value);
}
;
ViewBag.DepartmentList = ObjList;
return(View(model));
}
catch
{
return(View(model));
}
}
public async Task <object> Get(EmployeeRequest req)
{
try
{
var result = new EmployeeResponse()
{
Id = Guid.Empty.ToString()
};
var employee = await _employeeRepository.GetEmployee(req.Id);
if (employee != null)
{
result = new EmployeeResponse()
{
Id = employee.Record.Id,
Name = employee.Record.Name,
Department = employee.Record.Department,
Address = employee.Record.Address,
City = employee.Record.City,
Country = employee.Record.Country
};
}
return(result);
}
catch (Exception ex)
{
return(this.ErrorResult(new string[] { ex.Message }));
}
}
public async Task <IActionResult> Create([FromBody] CreateEmployeeRequest createEmployeeRequest)
{
var employee = new Employee
{
FirstName = createEmployeeRequest.FirstName,
LastName = createEmployeeRequest.LastName,
PersonalIdentity = createEmployeeRequest.PersonalIdentity,
ManagerId = createEmployeeRequest.ManagerId
};
var createdEmployee = await _repo.CreateEmployeeAsync(employee);
if (!createdEmployee)
{
return(BadRequest(new { Error = "There was an error creating a new Employee" }));
}
var response = new EmployeeResponse
{
Id = employee.Id,
FirstName = employee.FirstName,
LastName = employee.LastName,
PersonalIdentity = employee.PersonalIdentity,
ManagerId = employee.ManagerId
};
return(Created("", response));
}
public async Task <IActionResult> Create([FromBody] CreateEmployeeRequest request)
{
List <Employee> allEmployees = await _employeeService.GetAllEmployeesAsync();
for (int i = 0; i < allEmployees.Count; i++)
{
if (allEmployees[i].Email == request.Email)
{
return(StatusCode(StatusCodes.Status406NotAcceptable, "This Email is already in use, please choose a different Email!"));
}
}
Employee employee = new Employee {
FirstName = request.FirstName, LastName = request.LastName, Email = request.Email
};
await _employeeService.CreateEmployeeAsync(employee);
string baseUrl = HttpContext.Request.Scheme + "//" + HttpContext.Request.Host.ToUriComponent();
string locationUri = baseUrl + "/" + ApiRoutes.Employees.Get.Replace("{employeeId}", employee.Id.ToString());
EmployeeResponse response = new EmployeeResponse {
Id = employee.Id
};
return(Created(locationUri, response));
}
public async Task <IActionResult> Get(int id)
{
var response = new EmployeeResponse()
{
Result = null
};
try
{
var result = await _employeeService.GetEmployeesById(id);
if (result == null)
{
response.Messages = ResponseMessages.NotFound();
return(NotFound(response));
}
response.Messages = ResponseMessages.Success();
response.Result = result;
return(Ok(response));
}
catch (Exception exception)
{
response.Messages = ResponseMessages.InternalServerError(exception.ToString());
return(StatusCode(500, response));
}
}
public override Task <EmployeeResponse> GetEmployeeByEmpID(EmployeeRequest request, ServerCallContext context)
{
var response = new EmployeeResponse {
StatusCode = EmployeeResponse.Types.Status.Notfound, Message = EnumStatus.NotFound.ToString()
};
if (request.EmployeeID > 0)
{
var result = Task.FromResult(new EmployeeResponse()
{
StatusCode = EmployeeResponse.Types.Status.Success,
Message = "Data found",
}).Result;
result.Data.Add(new EmployeeDTO
{
EmployeeID = 1,
NIK = "10000000",
Name = "Farid Permana",
Occupation = "Sofware Enginer",
Address = "South Jakarta City, Indonesia"
});
}
return(Task.FromResult(response));
}
public override Task <EmployeeResponse> GetEmployee(EmployeeRequest request, ServerCallContext context)
{
var response = new EmployeeResponse {
StatusCode = EmployeeResponse.Types.Status.Notfound, Message = EnumStatus.NotFound.ToString()
};
if (request.MemberID > 0)
{
var result = new EmployeeResponse()
{
StatusCode = EmployeeResponse.Types.Status.Success,
Message = "Data found",
};
var manager = new EmployeeManager();
var query = (from emp in manager.Reader.Value.GetEmployees()
select new EmployeeDTO
{
EmployeeID = emp.EmployeeId,
NIK = emp.Nik,
Name = emp.Name,
Address = emp.Address,
Occupation = emp.Occupation
}).AsQueryable();
result.Data.AddRange(query.ToArray());
return(Task.FromResult(result));
}
return(Task.FromResult(response));
}
public ActionResult CreateOrEditEmployee()
{
EmployeeResponse _response = new EmployeeResponse();
if (Request.QueryString["id"] != null)
{
var request = new EmployeeRequest
{
Data = new EmployeeModel
{
Id = long.Parse(Request.QueryString["id"].ToString())
}
};
EmployeeResponse resp = new EmployeeHandler(_unitOfWork).GetDetail(request);
EmployeeModel _model = resp.Entity;
ViewBag.Response = _response;
ViewBag.EmpTypes = BindDropDownEmployementType();
ViewBag.EmplStatus = BindDropDownEmployeeStatus();
ViewBag.EmpActive = BindDropDownEmployeeReff();
ViewBag.ActionType = ClinicEnums.Action.Edit;
return(View(_model));
}
else
{
ViewBag.ActionType = ClinicEnums.Action.Add;
ViewBag.Response = _response;
ViewBag.EmpTypes = BindDropDownEmployementType();
ViewBag.EmplStatus = BindDropDownEmployeeStatus();
ViewBag.EmpActive = BindDropDownEmployeeReff();
return(View());
}
}
public async Task <EmployeeResponse> DeleteAsync(int id, CancellationToken token)
{
var response = new EmployeeResponse("Init");
if (id > 0)
{
var dbEmp = await _context.Employees
.Where(w => w.Id == id)
.FirstOrDefaultAsync(cancellationToken: token)
.ConfigureAwait(true);
if (dbEmp == null)
{
response = new EmployeeResponse("Employee Not Found");
}
else
{
_context.Employees.Remove(dbEmp);
await _context.SaveChangesAsync(token)
.ConfigureAwait(true);
return(new EmployeeResponse(new EmployeeModel()));
}
}
else
{
return(new EmployeeResponse("Invalid Employee Id for delete"));
}
return(response);
}
/// <summary>
/// Búsqueda de empleado
/// </summary>
/// <param name="numberEmployee">Número de empleado</param>
/// <param name="name">Nombre del empleado</param>
/// <param name="codigoTienda">Codigo de tienda</param>
/// <returns>Lista de empleados</returns>
public EmployeeResponse[] SearchEmployee(int numberEmployee, string name, int codigoTienda)
{
List <EmployeeResponse> list = new List <EmployeeResponse>();
var parameters = new Dictionary <string, object>();
parameters.Add("@CodigoEmpleado", numberEmployee);
parameters.Add("@Nombre", name);
parameters.Add("@CodigoTienda", codigoTienda);
foreach (var r in data.GetDataReader("sp_vanti_EmpleadosBusqueda", parameters))
{
EmployeeResponse employee = new EmployeeResponse();
employee.Code = Convert.ToInt32(r.GetValue(0));
employee.UserName = r.GetValue(1).ToString();
employee.Paternal = r.GetValue(2).ToString();
employee.Maternal = r.GetValue(3).ToString();
employee.Name = r.GetValue(4).ToString();
employee.Position = r.GetValue(5).ToString();
employee.RoleCode = Convert.ToInt32(r.GetValue(6));
employee.InitialDate = Convert.ToDateTime(r.GetValue(7)).ToShortDateString();
employee.Sex = r.GetValue(8).ToString();
employee.Status = r.GetValue(9).ToString();
employee.Store = Convert.ToInt32(r.GetValue(10));
list.Add(employee);
}
return(list.ToArray());
}
// Mappers
// Note: doesn't expose behavior
public static PetResponse FromPetDTO(PetDTO item) =>
new PetResponse()
{
Id = item.Id,
Animal = AnimalResponse.FromAnimalDTO(item.Animal),
Name = item.Name,
Owner = EmployeeResponse.FromEmployeeDTO(item.Employee)
};
private EmployeeResponse InitializeResponse(EmployeeRequest req)
{
EmployeeResponse res = new EmployeeResponse();
res.RequestId = req.RequestId;
return(res);
}
public EmployeeResponse SaveEmployee(EmployeeRequest employeeRequest)
{
EmployeeResponse employeeResponse = new EmployeeResponse();
#region Database activity
#endregion
return(employeeResponse);
}
