public AddEmployeeViewModel(AddEmployee addEmployeeOpen)
{
eventObject = new EventClass();
SelectedMenager = new ManagerDto();
employee = new tblEmployee();
addEmployee = addEmployeeOpen;
locationService = new LocationService();
employeeService = new EmployeeService();
sectorService = new SectorService();
locationsInDb = locationService.GetAllLocations().ToList();
LocationList = ConvertLocationDtoList(locationsInDb);
selctedLocation = LocationList.FirstOrDefault();
LocationList.OrderByDescending(x => x.Location);
LocationList.Reverse();
managersInDb = employeeService.GetAllPotentialMenagers();
PotentialMenagers = ConvertManagerListToDto(managersInDb);
eventObject.ActionPerformed += ActionPerformed;
}
public async Task ImportManagers_OneNewManager_CallsAddOnlyOnce()
{
var manager = new Manager()
{
Id = "Test"
};
var managerDto1 = new ManagerDto()
{
SeContactUid = 1234
};
var managerDto2 = new ManagerDto();
var managersDto = new ManagersDto()
{
Managers = new List <ManagerDto> {
managerDto1, managerDto2
}
};
_mockManagersRepository.Setup(r => r.GetManagerBySeContactUid(1234)).Returns(manager);
_mockMapper.Setup(m => m.Map <ManagerDto, Manager>(It.IsAny <ManagerDto>())).Returns(manager);
await _importer.ImportManagers(managersDto);
_mockManagersRepository.Verify(m => m.Add(It.IsAny <Manager>(), It.IsAny <string>()), Times.Once);
}
public bool Update(ManagerDto dto)
{
var manager = Mapper.Map <Manager>(dto);
_managerRepository.Update(manager);
return(_managerRepository.SaveChanges() > 0);
}
public bool Save(ManagerDto managerDto)
{
Manager manager = new Manager
{
FirstName = managerDto.FirstName,
LastName = managerDto.LastName,
PhoneNumber = managerDto.PhoneNumber,
Email = managerDto.Email,
BirthDate = managerDto.BirthDate,
Nationality = managerDto.Nationality,
Salary = managerDto.Salary
};
try
{
using (CompanyRepo repo = new CompanyRepo())
{
repo.ManagerRepository.Insert(manager);
repo.Save();
}
return(true);
}
catch
{
return(false);
}
}
public string Execute(string[] commandParmas)
{
int employeeId = int.Parse(commandParmas[0]);
var employee = context.Employees
.Include(e => e.ManagedEmployees)
.FirstOrDefault(e => e.Id == employeeId);
if (employee == null)
{
return("There is no emplooyee with Id: " + employeeId);
}
ManagerDto managerDto = mapper.CreateMappedObject <ManagerDto>(employee);
StringBuilder sb = new StringBuilder();
sb.AppendLine($"{managerDto.FirstName} {managerDto.LastName} | Employees: {managerDto.ManagedEmployees.Count}");
foreach (var managedEmpoyee in managerDto.ManagedEmployees)
{
sb.AppendLine($"- {managedEmpoyee.FirstName} {managedEmpoyee.LastName} - ${managedEmpoyee.Salary:F2}");
}
return(sb.ToString().TrimEnd());
}
public IActionResult CreateManager([FromBody] ManagerDto managerDto)
{
if (managerDto is null)
{
return(BadRequest(ModelState));
}
if (!_managerRepo.ManagerExists(managerDto.Mail))
{
ModelState.AddModelError("", $"A manager already exists with mail {managerDto.Mail}");
return(StatusCode(404, ModelState));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var managerObj = _mapper.Map <Manager>(managerDto);
if (!_managerRepo.CreateManager(managerObj))
{
ModelState.AddModelError("", $"Something wrong happened when adding manager {managerObj.Mail}");
}
return(Ok(managerObj));
}
public ManagerDto GetById(int id)
{
ManagerDto managerDto = new ManagerDto();
using (CompanyRepo repo = new CompanyRepo())
{
Manager manager = repo.ManagerRepository.GetByID(id);
if (manager != null)
{
managerDto = new ManagerDto
{
Id = manager.Id,
FirstName = manager.FirstName,
LastName = manager.LastName,
PhoneNumber = manager.PhoneNumber,
Email = manager.Email,
BirthDate = manager.BirthDate,
Nationality = manager.Nationality,
Salary = manager.Salary
};
}
}
return(managerDto);
}
public string Execute(string[] arguments)
{
if (arguments.Length != 1)
{
throw new ArgumentException("Invalid id!");
}
int id = int.Parse(arguments[0]);
ManagerDto managerDto = this.managerService.ManagerInfo(id);
if (managerDto.EmployeesCount == 0)
{
return($"Manager {managerDto.FirstName} {managerDto.LastName} does not have any employees!");
}
StringBuilder sb = new StringBuilder();
sb.AppendLine($"{managerDto.FirstName} {managerDto.LastName} | Employees: {managerDto.EmployeesCount}");
foreach (EmployeeDto empDto in managerDto.Employees)
{
sb.AppendLine($" - {empDto.FirstName} {empDto.LastName} - ${empDto.Salary:F2}");
}
return(sb.ToString().Trim());
}
public string Execute(EmployeesDbContext context, string[] args)
{
int managerId = int.Parse(args[0]);
Employee manager = context.Employees
.Include(e => e.ManagedEmployees)
.FirstOrDefault(e => e.Id == managerId);
if (manager == null)
{
return($"No manager with ID {managerId} found");
}
ManagerDto managerDto = Mapper.Map <ManagerDto>(manager);
StringBuilder sb = new StringBuilder();
sb.AppendLine(
$"{managerDto.FirstName} {managerDto.LastName} | Employees: {managerDto.ManagedEmployeesCount}");
foreach (var employeeDto in managerDto.ManagedEmployees)
{
sb.AppendLine($" - {employeeDto.FirstName} {employeeDto.LastName} - ${employeeDto.Salary}");
}
return(sb.ToString());
}
public void ImportOrder_WithServiceFlagAndNoNewServices_ShouldAddTwoServices()
{
var order = new Order()
{
Id = "1", TrackingId = "TestOrder", ServiceFlag = 3, IsInternational = false
};
var transferee = new TransfereeDto()
{
Email = "*****@*****.**"
};
var consultant = new ConsultantDto()
{
SeContactUid = 1
};
var programManager = new ProgramManagerDto()
{
SeContactUid = 1
};
var manager = new Manager()
{
Id = "Test"
};
var managerDto = new ManagerDto
{
SeContactUid = 1
};
var managersDto = new ManagersDto()
{
Managers = new List <ManagerDto> {
managerDto
}
};
_mockManagersRepository.Setup(r => r.GetManagerBySeContactUid(1)).Returns(manager);
_mockMapper.Setup(m => m.Map <ManagerDto, Manager>(It.IsAny <ManagerDto>())).Returns(manager);
_mockTransfereesRepository.Setup(t => t.GetTransfereeByEmail(transferee.Email)).Returns(new Transferee()
{
Email = "*****@*****.**"
});
_mockConsultantsRepository.Setup(c => c.GetConsultantBySeContactUid(1)).Returns(new Consultant()
{
SeContactUid = 1
});
var cats = new List <ServiceCategory>();
var ids = new List <int>();
_mockServiceTypeRepository.Setup(st => st.GetDefaultServiceTypes(cats, ids, order.IsInternational)).Returns(new List <ServiceType>());
var orderDto = new OrderDto();
orderDto.Consultant = consultant;
orderDto.Transferee = transferee;
orderDto.ProgramManager = programManager;
_mockMapper.Setup(o => o.Map <OrderDto, Order>(It.IsAny <OrderDto>())).Returns(order);
_orderImporter.ImportOrder(orderDto);
_mockOrdersRepository.Verify(v => v.Add(It.IsAny <Order>()), Times.Once);
order.Services.Count.Should().Be(0);
}
public IActionResult Login([FromBody] ManagerDto managerDto)
{
var manager = _userService.Authenticate(managerDto.Login, managerDto.Password);
if (manager == null)
{
return(BadRequest(new { message = "Username or password is incorrect" }));
}
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_appSettings.Secret);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.NameIdentifier, manager.Id.ToString())
}),
Expires = DateTime.UtcNow.AddDays(7),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
var tokenString = tokenHandler.WriteToken(token);
return(Ok(new
{
manager.Id,
manager.Login,
manager.Name,
Token = tokenString
}));
}
public string Execute(string[] args)
{
int managerId = int.Parse(args[0]);
ManagerDto managerDto = controller.ManagerInfo(managerId);
return(managerDto.ToString());
}
public bool IsManagerValid(ManagerDto managerDto)
{
return(true);
var managers = _managerRepository.Find(m => m.LastName == managerDto.LastName);
return(managers.Count() != 0);
}
public async Task <GetUserResponse> Handle(GetUserRequest request, CancellationToken cancellationToken)
{
dynamic query;
object mapTypeObject;
if (request.Me == "Me" || request.Me == "me")
{
if (request.AuthenticatorRole == AppRole.Employee)
{
query = new GetEmployeeQuery()
{
Id = request.AuthenticatorId,
CompanyId = request.AuthenticatorCompanyId
};
mapTypeObject = new EmployeeDto();
}
else if (request.AuthenticatorRole == AppRole.Manager)
{
query = new GetManagerQuery()
{
Id = request.AuthenticatorId,
CompanyId = request.AuthenticatorCompanyId
};
mapTypeObject = new ManagerDto();
}
else
{
return(new GetUserResponse()
{
Error = new ErrorModel(ErrorType.Unauthorized)
});
}
}
else
{
return(new GetUserResponse()
{
Error = new ErrorModel(ErrorType.UnsupportedMethod)
});
}
var resorce = await queryExecutor.Execute(query);
if (resorce == null)
{
return(new GetUserResponse()
{
Error = new ErrorModel(ErrorType.NotFound)
});
}
var mappedResorce = mapper.Map(resorce, mapTypeObject);
return(new GetUserResponse()
{
Data = mappedResorce
});
}
public string PostManager(ManagerDto managerDto)
{
if (!managerService.Save(managerDto))
{
return("Manager is not inserted");
}
return("Manager is inserted");
}
//<employeeId>
public string Execute(params string[] data)
{
int managerId = int.Parse(data[0]);
ManagerDto managerDto = employeeService.ManagerInfo(managerId);
string result = managerDto.ToString();
return(result);
}
public string PutManager(ManagerDto managerDto)
{
if (!managerService.Update(managerDto))
{
return("Manager is not updated");
}
return("Manager is updated");
}
public string Execute(params string[] args)
{
int emplId = int.Parse(args[0]);
Employee employee = this.employeeService.ById(emplId);
ManagerDto manager = Mapper.Map <ManagerDto>(employee);
return(manager.ToString().Trim());
}
public OperationDetails Edit(ManagerDto managerDto)
{
var manager = UnitOfWork.ManagerRepository.GetById(managerDto.Id);
manager.LastName = managerDto.LastName;
UnitOfWork.ManagerRepository.Update(manager);
UnitOfWork.Save();
return(new OperationDetails(true, ConstantStorage.ManagerUpdated, string.Empty));
}
ManagerDto ConvertToManagerDto(tblEmployee manager)
{
ManagerDto managerDto = new ManagerDto();
managerDto.ManagerData = string.Format("{0} {1} {2}", manager.FirstName, manager.LastName,
manager.JMBG);
managerDto.ID = manager.EmployeeID;
return(managerDto);
}
public ManagerDto ManagerInfo(int managerId)
{
Employee manager = this.context.Employees
.Where(m => m.EmployeeId == managerId).SingleOrDefault();
ManagerDto managerInfo = Mapper.Map <ManagerDto>(manager);
return(managerInfo);
}
public ManagerViewModel(ManagerDto managerDto)
{
Id = managerDto.Id;
FirstName = managerDto.FirstName;
LastName = managerDto.LastName;
PhoneNumber = managerDto.PhoneNumber;
Email = managerDto.Email;
BirthDate = managerDto.BirthDate;
Nationality = managerDto.Nationality;
Salary = managerDto.Salary;
}
public ManagerDto GetManagerById(int id)
{
var manager = UnitOfWork.ManagerRepository.GetById(id);
var managerDto = new ManagerDto
{
Id = manager.Id,
LastName = manager.LastName
};
return(managerDto);
}
public OperationDetails Create(ManagerDto managerDto)
{
var manager = new Manager {
LastName = managerDto.LastName
};
UnitOfWork.ManagerRepository.Create(manager);
UnitOfWork.Save();
return(new OperationDetails(true, ConstantStorage.ManagerCreated, string.Empty));
}
public IHttpActionResult AddManager(ManagerDto x)
{
try
{
m.addManager(x);
return(Ok("pppp0"));
}
catch (Exception e)
{
return(BadRequest("fff"));
}
}
public void ImportOrderTest_New()
{
var order = new Order()
{
Id = "1", TrackingId = "TestOrder"
};
var transferee = new TransfereeDto()
{
Email = "*****@*****.**"
};
var consultant = new ConsultantDto()
{
SeContactUid = 1
};
var programManager = new ProgramManagerDto()
{
SeContactUid = 1
};
var manager = new Manager()
{
Id = "Test"
};
var managerDto = new ManagerDto
{
SeContactUid = 1
};
var managersDto = new ManagersDto()
{
Managers = new List <ManagerDto> {
managerDto
}
};
_mockManagersRepository.Setup(r => r.GetManagerBySeContactUid(1)).Returns(manager);
_mockMapper.Setup(m => m.Map <ManagerDto, Manager>(It.IsAny <ManagerDto>())).Returns(manager);
_mockTransfereesRepository.Setup(t => t.GetTransfereeByEmail(transferee.Email)).Returns(new Transferee()
{
Email = "*****@*****.**"
});
_mockConsultantsRepository.Setup(c => c.GetConsultantBySeContactUid(1)).Returns(new Consultant()
{
SeContactUid = 1
});
var orderDto = new OrderDto();
orderDto.Consultant = consultant;
orderDto.Transferee = transferee;
orderDto.ProgramManager = programManager;
_mockMapper.Setup(o => o.Map <OrderDto, Order>(It.IsAny <OrderDto>())).Returns(order);
_orderImporter.ImportOrder(orderDto);
_mockOrdersRepository.Verify(v => v.Add(It.IsAny <Order>()), Times.Once);
}
public IHttpActionResult UpdateManager(ManagerDto x)
{
try
{
m.updateManager(x);
return(Ok("success"));
}
catch
{
return(BadRequest("fds"));
}
}
public IHttpActionResult UpdateManager(ManagerDto um)
{
try
{
ML.UpdateManager(um);
Console.WriteLine("dfd");
return(Ok("pppp0"));
}
catch (Exception e)
{
return(BadRequest(e.ToString()));
}
}
public void Execute(string[] data)
{
if (data.Length != 1)
{
throw new ArgumentException("Invalid command!");
}
int managerId = int.Parse(data[0]);
ManagerDto manager = this.managerControler.GetManagerInfo(managerId);
Console.WriteLine(manager.ToString());
}
public void Execute(string[] data)
{
if (data.Length != 1)
{
throw new ArgumentException("Invalid command!");
}
int employeeId = int.Parse(data[0]);
ManagerDto dto = this.employeeService.GetEmploye <ManagerDto>(employeeId);
writer.WriteLine(dto.ToString());
}