public async Task <List <EmployeeViewModel> > GetAllEmployeeAsync(
CancellationToken ct = default(CancellationToken))
{
var employees = EmployeeConverter.ConvertList(await _employeeRepository.GetAllAsync(ct));
return(employees);
}
/// <summary>
/// Method returns filtered Employees from databse
/// </summary>
/// <param name="filter">Name or Surname or PersonalIdentityNumber of Employee</param>
/// <returns>Collection of Employees from Database</returns>
public async Task <ObservableCollection <DtoEmployee> > GetEmployees(string filter = null)
{
var ret = new ObservableCollection <DtoEmployee>();
using (var data = Context)
if (!string.IsNullOrWhiteSpace(filter))
{
foreach (var item in await(from item in data.Employee
where
item.name.Contains(filter) || item.surname.Contains(filter) ||
item.personalIdentityNumber.Contains(filter)
select item).ToListAsync())
{
ret.Add(EmployeeConverter.DataAccsessToDto(item));
}
}
else
{
foreach (var item in await(from item in data.Employee select item).ToListAsync())
{
ret.Add(EmployeeConverter.DataAccsessToDto(item));
}
}
return(ret);
}
public async Task <EmployeeViewModel> GetEmployeeReportsToAsync(int id,
CancellationToken ct = default(CancellationToken))
{
var employee = await _employeeRepository.GetReportsToAsync(id, ct);
return(EmployeeConverter.Convert(employee));
}
public async Task <List <EmployeeViewModel> > GetDirectReportsAsync(int id,
CancellationToken ct = default(CancellationToken))
{
var employees = await _employeeRepository.GetDirectReportsAsync(id, ct);
return(EmployeeConverter.ConvertList(employees).ToList());
}
public RhController(ILogger <RhController> logger, IHttpClientService service, EmployeeConverter converter, IOptions <AppSettings> appSettings)
{
_logger = logger;
_service = service;
_converter = converter;
_appSetings = appSettings.Value;
}
public void Convert()
{
string input = @"""Mattias Asplund"" 46 35000.00 070-6186120";
var sut = new EmployeeConverter();
string actual = sut.Convert(input);
Assert.AreEqual("Asplund, Mattias (Lön: 35000,00 SEK) Telefon:070-6186120 Födelseår:1971", actual);
}
public void RegexTest()
{
string input = @"""Mattias Asplund"" 46 35000.00 070-6186120 ";
EmployeeConverter sut = new EmployeeConverter();
var results = sut.Convert(input);
}
public EmployeeRepositoryRpc(EmployeeConverter employeeConverter)
{
var channel = new Channel("localhost:8080", ChannelCredentials.Insecure);
_employeeServiceClient = new ProtocolBuffers.EmployeeService.EmployeeServiceClient(channel);
_employeeConverter = employeeConverter;
}
public void Execute(EmployeeModel employeeModel)
{
var employee = EmployeeConverter
.CreateEmployee(employeeModel);
_databaseService.Employees.Add(employee);
_databaseService.Save();
}
public async Task <ObservableCollection <Employee> > GetEmployees(string filter)
{
var ret = new ObservableCollection <Employee>();
foreach (var e in await Post <string, ObservableCollection <DtoEmployee> >("GetEmployees", filter))
{
ret.Add(EmployeeConverter.DtoToViewModel(e));
}
return(ret);
}
public EmployeeDTO getEmployeeById(string accountId)
{
ApplicationUser user = employeeRepository.GetByID(accountId);
if (user == null)
{
throw new InvalidOperationException("No Employee found with that Id");
}
return(EmployeeConverter.toDto(user));
}
public int UpdateEmployees(IEnumerable <employee> items)
{
using (IOPContext db = new IOPContext())
{
EmployeeConverter converter = new EmployeeConverter(db);
foreach (var item in items)
{
var model = converter.FromDto(item);
db.Entry(model).State = System.Data.Entity.EntityState.Modified;
}
return(db.SaveChanges());
}
}
/// <summary>
/// Returns Employee with specific ID
/// </summary>
/// <param name="employeeId">Employee ID</param>
/// <returns>Employee Business Object</returns>
public async Task <DtoEmployee> GetEmployee(int employeeId)
{
try
{
using (var data = Context)
return
(EmployeeConverter.DataAccsessToDto(
await
(from item in data.Employee where item.id == employeeId select item)
.FirstOrDefaultAsync()));
}
catch (Exception)
{
return(null);
}
}
/// <summary>
/// Returns Employee with specific email
/// </summary>
/// <param name="email">Employee e-mail</param>
/// <returns>Employee Business Object</returns>
public async Task <DtoEmployee> GetEmployee(string email)
{
using (var data = Context)
{
var emps = await data.Employee.Where(e => e.email == email).ToListAsync();
if (!emps.Any())
{
return(null);
}
if (emps.Count > 1)
{
throw new Exception("Emails are not unique");
}
return(EmployeeConverter.DataAccsessToDto(emps.First()));
}
}
public async Task <EmployeeViewModel> GetEmployeeByIdAsync(int id,
CancellationToken ct = default(CancellationToken))
{
var employeeViewModel = EmployeeConverter.Convert(await _employeeRepository.GetByIdAsync(id, ct));
employeeViewModel.Customers = await GetCustomerBySupportRepIdAsync(employeeViewModel.EmployeeId, ct);
employeeViewModel.DirectReports = await GetEmployeeDirectReportsAsync(employeeViewModel.EmployeeId, ct);
employeeViewModel.Manager = employeeViewModel.ReportsTo.HasValue
? await GetEmployeeReportsToAsync(employeeViewModel.ReportsTo.GetValueOrDefault(), ct)
: null;
employeeViewModel.ReportsToName = employeeViewModel.ReportsTo.HasValue
? $"{employeeViewModel.Manager.LastName}, {employeeViewModel.Manager.FirstName}"
: string.Empty;
return(employeeViewModel);
}
public resultForEmployees QueryEmployees(criteriaForEmployees criteria)
{
using (IOPContext db = new IOPContext())
{
int pageSize = criteria.pageSize;
int pageIndex = criteria.pageIndex;
criteria.employeeCode = criteria.employeeCode == null ? "" : criteria.employeeCode;
criteria.employeeName = criteria.employeeName == null ? "" : criteria.employeeName;
int totalCount = 0;
EmployeeConverter converter = new EmployeeConverter(db);
IList <Employee> list = Utils.LoadPageItems <Employee, string>(db, pageSize, pageIndex, out totalCount, e => e.Code.Contains(criteria.employeeCode) && e.Name.Contains(criteria.employeeName), e => e.Code, true).ToList();
resultForEmployees result = new resultForEmployees();
result.employees = list.Select(i => converter.ToDto(i)).ToArray();
result.totalCount = totalCount;
result.currentIndex = result.currentIndex;
return(result);
}
}
public EmployeeDTO createEmployee(EmployeeDTO employeeDTO)
{
ApplicationUser user = employeeRepository.GetByID(employeeDTO.Id);
if (user == null)
{
ApplicationUser newUser = new ApplicationUser()
{
Email = employeeDTO.Username,
SecurityStamp = Guid.NewGuid().ToString(),
UserName = employeeDTO.Username,
RegisterDate = DateTime.Now
};
return(EmployeeConverter.toDto(employeeRepository.GetByID(employeeDTO.Id)));
}
else
{
throw new InvalidOperationException("User already exists");
}
}
public LoginController(IBLLFacade facade)
{
_facade = facade;
_employeeConverter = new EmployeeConverter();
}
/// <summary>
/// Adding or Updating Employee in a database
/// </summary>
/// <param name="employee">Business Object Employee</param>
/// <returns>True if succeeded and false otherwise</returns>
public async Task <bool> SaveEmployee(DtoEmployee employee)
{
try
{
using (var data = Context)
{
var e =
await
(from item in data.Employee where employee.Id == item.id select item).FirstOrDefaultAsync();
// Updating Employee
if (e != null)
{
e.name = employee.Name;
e.surname = employee.Surname;
e.street = employee.Street;
e.postalCode = employee.PostalCode;
e.phoneNumber = employee.PhoneNumber;
e.personalIdentityNumber = employee.PersonalIdentityNumber;
e.identityCardNumber = employee.IdentityCardNumber;
e.icePhoneNumber = employee.IcePhoneNumber;
e.houseNumber = employee.HouseNumber;
e.email = employee.Email;
e.city = employee.City;
e.apartmentNumber = employee.ApartmentNumber;
e.description = employee.Description;
e.positionID = employee.Position.Id;
e.supervisorID = employee.SupervisorId;
e.password = AuthenticationLogic.HashPassword(employee.Password, employee);
e.SportType.Clear();
foreach (var item in employee.SportTypes)
{
var st = data.SportType.First(s => s.id == item.Id);
e.SportType.Add(st);
}
}
// Adding new Employee
else
{
if (await(from item in data.Employee
where
employee.PersonalIdentityNumber == item.personalIdentityNumber ||
employee.IdentityCardNumber == item.identityCardNumber
select item).AnyAsync())
{
return(false);
}
var emp = EmployeeConverter.DtoToDataAccess(employee);
foreach (var item in employee.SportTypes)
{
var st = data.SportType.First(s => s.id == item.Id);
emp.SportType.Add(st);
}
data.Employee.Add(emp);
}
await data.SaveChangesAsync();
}
return(true);
}
catch (Exception)
{
return(false);
}
}
public IEnumerable <EmployeeDTO> getAllEmployees()
{
return(EmployeeConverter.toDtos(employeeRepository.Get()));
}
public async Task <bool> SaveEmployee(Employee e)
{
return(await Post <DtoEmployee, bool>("SaveEmployee", EmployeeConverter.ViewModelToDto(e)));
}
public async Task <Employee> GetEmployee(int id)
{
return(EmployeeConverter.DtoToViewModel(await Post <int, DtoEmployee>("GetEmployee", id)));
}
public EmployeeConverterTests()
{
var contractConverter = new ContractTypeConverter();
_employeeConverter = new EmployeeConverter(contractConverter);
}
public EmployeeService(IDALFacade facade)
{
_employeeConverter = new EmployeeConverter();
_mailto = new sendMail();
_facade = facade;
}
public RestController(ILogger <RestController> logger, IHumanResourcesService service, EmployeeConverter converter)
{
_logger = logger;
_service = service;
_converter = converter;
}
