public async Task <PagedResult <Employee> > Handle(GetEmployees request, CancellationToken cancellationToken)
{
var result = await _repository.GetAll();
var employees = result.ToList();
return(new PagedResult <Employee>(1, employees.Count, employees));
}
public async Task <IActionResult> Employees()
{
var request = new GetEmployees();
var result = await mediator.Send(request);
return(Ok(result));
}
public IHttpActionResult EmployeesgetbyId(int id)
{
IGetEmployees getemployees = new GetEmployees();
var empDetails = getemployees.getEmployeeById(id);
if (empDetails.Count == 0)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
return(Ok(empDetails));
}
public Task<List<EmployeeListItem>> Handle(GetEmployees query, CancellationToken cancellationToken = default(CancellationToken))
{
return Employees
.Select(employee => new EmployeeListItem
{
Id= employee.Id,
ChristianName= employee.Name.ChristianName,
Surname=employee.Name.Surname
})
.ToListAsync(cancellationToken);
}
public async Task ShouldGet_EmployeeListItems_UsingGetEmployeesQueryParameters()
{
var getEmployees = new GetEmployees {
Page = 1, PageSize = 20
};
var result = await _employeeQrySvc.Query(getEmployees);
int resultCount = result.ReadModels.ToList().Count;
Assert.True(resultCount > 0);
}
public WindowController(MainWindow mainWindow, GetEmployees employees)
{
if (mainWindow == null)
throw new ArgumentNullException(nameof(mainWindow));
if (employees == null)
throw new ArgumentNullException(nameof(employees));
_mainWindow = mainWindow;
//View And model
_collectionView = CollectionViewSource.GetDefaultView(employees);
}
public async Task <IActionResult> GetEmployees([FromQuery] GetEmployees getEmployeesParams)
{
try
{
var retValue = await _employeeQryReqHdler.Handle <GetEmployees>(getEmployeesParams, HttpContext, Response);
return(retValue);
}
catch (Exception ex)
{
_logger.LogError($"An exception has been thrown: {ex}");
return(BadRequest(ex.Message));
}
}
public void ReturnEmployeesTest_output_NotEmptyCollection()
{
// Arrange
var employees = new GetEmployees();
var repo = new Mock <EmployeeRepository>();
repo.Setup(arg => arg.GetList()).Returns(new List <Employee>());
employees.employeeRepository = repo.Object;
// Act
var resultCollection = employees.ReturnEmployees();
// Assert
Assert.IsNotNull(resultCollection);
}
private static int RunGetCommandAndReturnExitCode(GetEmployees opts)
{
var client = new RestClient(opts.BaseUrl)
{
RemoteCertificateValidationCallback = (sender, certificate, chain, sslPolicyErrors) => true,
};
var request = new RestRequest(_path + "employees", Method.GET);
request.AddQueryParameter("limit", opts.Limit.ToString());
request.AddQueryParameter("offset", opts.Offset.ToString());
var response = client.Execute <List <Employee> >(request);
response.Data.ForEach(Console.WriteLine);
return(0);
}
public static BaseHelper GetEmployeesList(Model.GetEmployeesList data)
{
var retVal = new BaseHelper();
var objJSONPage = new Output.GetEmployeesList();
try
{
var entityPage = GetEmployees.GetEmployeesList(data, objJSONPage);
if (objJSONPage.ResultCode == 1)
{
retVal.SQLElapsed += entityPage.SQLElapsed;
retVal.SQLInfo($"sp : {entityPage.SQLDetail}, elapsed : {entityPage.SQLElapsed}");
retVal.IsError = (entityPage.ResultCode == 1) ? false : true;
}
else
{
objJSONPage.ResultCode = objJSONPage.ResultCode;
objJSONPage.ErrorMessage = objJSONPage.ErrorMessage;
}
}
catch (Exception ex)
{
retVal.Exception = ex;
if (ex is System.Data.SqlClient.SqlException sqlEx)
{
retVal.SQLInfo($"sp:{sqlEx.Procedure}, line:{sqlEx.LineNumber}, detail:{data.SqlDetail}");
retVal.SQLException = true;
objJSONPage.ResultCode = 69998;
objJSONPage.ErrorMessage = "SQL Exception";
}
else
{
objJSONPage.ResultCode = 69999;
objJSONPage.ErrorMessage = "Unknown Error";
}
}
finally
{
retVal.SerializeObject <Output.GetEmployeesList>(objJSONPage);
}
return(retVal);
}
public async Task ShouldGet_EmployeeListItems_UsingGetEmployeesFilteredByName()
{
var getEmployees = new GetEmployees
{
Page = 1,
PageSize = 10,
EmployeeLastName = "B",
SupervisorLastName = null,
SortField = "LastName",
SortOrder = "DESC"
};
var result = await _employeeQrySvc.Query(getEmployees);
int resultCount = result.ReadModels.ToList().Count;
Assert.True(resultCount > 0);
}
public override int GetHashCode()
{
int hash = 1;
if (getAccounts_ != null)
{
hash ^= GetAccounts.GetHashCode();
}
if (saveAccounts_ != null)
{
hash ^= SaveAccounts.GetHashCode();
}
if (deleteAccounts_ != null)
{
hash ^= DeleteAccounts.GetHashCode();
}
if (getEmployees_ != null)
{
hash ^= GetEmployees.GetHashCode();
}
if (saveEmployees_ != null)
{
hash ^= SaveEmployees.GetHashCode();
}
if (deleteEmployees_ != null)
{
hash ^= DeleteEmployees.GetHashCode();
}
if (getJobs_ != null)
{
hash ^= GetJobs.GetHashCode();
}
if (saveJobs_ != null)
{
hash ^= SaveJobs.GetHashCode();
}
if (deleteJobs_ != null)
{
hash ^= DeleteJobs.GetHashCode();
}
return(hash);
}
public List <Employee> searchEmp(string searchBy, string searchValue)
{
DataTable table = new DataTable();
table = new GetEmployees().SearchEmployees(searchBy, searchValue);
List <Employee> emp = new List <Employee>();
foreach (DataRow item in table.Rows)
{
emp.Add(new Employee()
{
EmpId = int.Parse(item["EmpId"].ToString()),
EmpName = item["EmpName"].ToString(),
City = item["City"].ToString(),
Salary = decimal.Parse(item["Salary"].ToString()),
DeptId = int.Parse(item["DeptId"].ToString())
});
}
return(emp);
}
public async Task <IEnumerable <Employee> > Handle(GetEmployees request, CancellationToken token)
{
return(await database.Employees
.Select(o => o)
.ToListAsync(token));
}
public static void Initial(AppDBContext context)
{
if (!context.Position.Any())
{
context.Position.AddRange(GetPositions.Select(p => p.Value));
}
if (!context.Employee.Any())
{
context.Employee.AddRange(GetEmployees.Select(e => e.Value));
}
if (!context.BusinessTrip.Any())
{
context.AddRange(
new BusinessTrip
{
city = "Москва",
departureDate = DateTime.Today,
arrivalDate = DateTime.Today.Add(new TimeSpan(12, 0, 0, 0)),
Employee = GetEmployees["Соловьёв"]
},
new BusinessTrip
{
city = "Казань",
departureDate = DateTime.Today,
arrivalDate = DateTime.Today.Add(new TimeSpan(18, 0, 0, 0)),
Employee = GetEmployees["Соловьёв"]
},
new BusinessTrip
{
city = "Екатеринбург",
departureDate = DateTime.Today,
arrivalDate = DateTime.Today.Add(new TimeSpan(14, 0, 0, 0)),
Employee = GetEmployees["Зыков"]
},
new BusinessTrip
{
city = "Новосибирск",
departureDate = DateTime.Today,
arrivalDate = DateTime.Today.Add(new TimeSpan(63, 0, 0, 0)),
Employee = GetEmployees["Зыков"]
},
new BusinessTrip
{
city = "Анапа",
departureDate = DateTime.Today,
arrivalDate = DateTime.Today.Add(new TimeSpan(25, 0, 0, 0)),
Employee = GetEmployees["Соловьёв"]
},
new BusinessTrip
{
city = "Уфа",
departureDate = DateTime.Today,
arrivalDate = DateTime.Today.Add(new TimeSpan(2, 0, 0, 0)),
Employee = GetEmployees["Зыков"]
}
);
}
context.SaveChanges();
}
public void MergeFrom(MainController other)
{
if (other == null)
{
return;
}
if (other.getAccounts_ != null)
{
if (getAccounts_ == null)
{
getAccounts_ = new global::Com.Revolutionlandscaping.Businessmanager.CommonAction();
}
GetAccounts.MergeFrom(other.GetAccounts);
}
if (other.saveAccounts_ != null)
{
if (saveAccounts_ == null)
{
saveAccounts_ = new global::Com.Revolutionlandscaping.Businessmanager.CommonAction();
}
SaveAccounts.MergeFrom(other.SaveAccounts);
}
if (other.deleteAccounts_ != null)
{
if (deleteAccounts_ == null)
{
deleteAccounts_ = new global::Com.Revolutionlandscaping.Businessmanager.CommonAction();
}
DeleteAccounts.MergeFrom(other.DeleteAccounts);
}
if (other.getEmployees_ != null)
{
if (getEmployees_ == null)
{
getEmployees_ = new global::Com.Revolutionlandscaping.Businessmanager.CommonAction();
}
GetEmployees.MergeFrom(other.GetEmployees);
}
if (other.saveEmployees_ != null)
{
if (saveEmployees_ == null)
{
saveEmployees_ = new global::Com.Revolutionlandscaping.Businessmanager.CommonAction();
}
SaveEmployees.MergeFrom(other.SaveEmployees);
}
if (other.deleteEmployees_ != null)
{
if (deleteEmployees_ == null)
{
deleteEmployees_ = new global::Com.Revolutionlandscaping.Businessmanager.CommonAction();
}
DeleteEmployees.MergeFrom(other.DeleteEmployees);
}
if (other.getJobs_ != null)
{
if (getJobs_ == null)
{
getJobs_ = new global::Com.Revolutionlandscaping.Businessmanager.CommonAction();
}
GetJobs.MergeFrom(other.GetJobs);
}
if (other.saveJobs_ != null)
{
if (saveJobs_ == null)
{
saveJobs_ = new global::Com.Revolutionlandscaping.Businessmanager.CommonAction();
}
SaveJobs.MergeFrom(other.SaveJobs);
}
if (other.deleteJobs_ != null)
{
if (deleteJobs_ == null)
{
deleteJobs_ = new global::Com.Revolutionlandscaping.Businessmanager.CommonAction();
}
DeleteJobs.MergeFrom(other.DeleteJobs);
}
}
public async Task <IActionResult> GetAll(GetEmployees request)
{
var result = await _mediator.Send(request);
return(Ok(result));
}
public Task <IReadOnlyCollection <EmployeeRM> > Run(GetEmployees criteria, IContext context) => Task.FromResult(Run(context));
public ApiResponse <List <Employee> > GetEmployees(GetEmployees req)
{
var result = null as List <Employee>;
using (var connection = new SqlConnection(_connectionString.HotelManagement))
{
var cmd = new SqlCommand(p_Employees_Get, connection)
{
CommandType = CommandType.StoredProcedure
};
cmd.Parameters.AddWithValue("@UserID", _requestInfo.UserId);
cmd.Parameters.Add("@RetVal", SqlDbType.Int).Direction = ParameterDirection.Output;
cmd.Parameters.Add("@RetMsg", SqlDbType.VarChar, 500).Direction = ParameterDirection.Output;
cmd.Parameters.AddWithValue("@EmployeeID", req.EmployeeId);
cmd.Parameters.AddWithValue("@UserName", req.UserName);
cmd.Parameters.AddWithValue("@FirstName", req.FirstName);
cmd.Parameters.AddWithValue("@MidName", req.MidName);
cmd.Parameters.AddWithValue("@LastName1", req.LastName1);
cmd.Parameters.AddWithValue("@LastName2", req.LastName2);
cmd.Parameters.AddWithValue("@Locked", req.Locked);
cmd.Parameters.AddWithValue("@LockedDateTime", req.LockedDateTime);
cmd.Parameters.AddWithValue("@RequiresReset", req.RequiresReset);
cmd.Parameters.AddWithValue("@EmployeeTypeID", req.EmployeeTypeId);
cmd.Parameters.AddWithValue("@StartDateTime", req.StartDateTime);
cmd.Parameters.AddWithValue("@LastLoginDateTime", req.LastLoginDateTime);
cmd.Parameters.AddWithValue("@IncludeTerminated", req.IncludeTerminated);
cmd.Parameters.AddWithValue("@TerminatedDateTime", req.TerminatedDateTime);
connection.Open();
using (var dr = cmd.ExecuteReader())
{
result = new List <Employee>();
while (dr.Read())
{
result.Add(new Employee
{
EmployeeId = dr["EmployeeID"].ToSafeInt32(),
UserName = dr["UserName"].ToSafeString(),
FirstName = dr["FirstName"].ToSafeString(),
MidName = dr["MidName"].ToSafeString(),
LastName1 = dr["LastName1"].ToSafeString(),
LastName2 = dr["LastName2"].ToSafeString(),
Locked = dr["Locked"].ToSafeBool(),
LockedDateTime = dr["LockedDateTime"].ToSafeDateTime(),
RequiresReset = dr["RequiresReset"].ToSafeBool(),
EmployeeTypeId = dr["EmployeeTypeID"].ToSafeInt32(),
StartDateTime = dr["StartDateTime"].ToSafeDateTime(),
LastLoginDateTime = dr["LastLoginDateTime"].ToSafeDateTime(),
Terminated = dr["IncludeTerminated"].ToSafeBool(),
TerminatedDateTime = dr["TerminatedDateTime"].ToSafeDateTime(),
CreatedId = dr["CreatedID"].ToSafeInt32(),
CreatedBy = dr["CreatedBy"].ToSafeString(),
CreatedDateTime = dr["CreatedDateTime"].ToSafeDateTime(),
ModifiedId = dr["ModifiedID"].ToSafeInt32(),
ModifiedBy = dr["ModifiedBy"].ToSafeString(),
ModifiedDateTime = dr["ModifiedDateTime"].ToSafeDateTime()
});
}
}
return(new ApiResponse <List <Employee> >
{
Content = result,
Status = new ReturnStatus(cmd.Parameters["@RetVal"].Value.ToSafeInt32(),
cmd.Parameters["@RetMsg"].Value.ToSafeString())
});
}
}
public HumanResourcesController(GetEmployees getEmployees)
{
_getEmployees = getEmployees;
}
public List <Employee> GetEmployees(GetEmployees req)
{
return(null);
}
public ShowEmployee()
{
InitializeComponent();
getEmployees = new GetEmployees();
list.ItemsSource = getEmployees.ReturnEmployees().ToList();
}
