public void ShouldAddDepartment()
{
// Arrange
using (IEmployeeContext employeeContext = new EmployeeContext())
{
IEmployeeRepository employeeRepository = new EmployeeRepository(employeeContext);
employeeRepository.Add(CreateEntity.Employee1);
employeeRepository.Add(CreateEntity.Employee2);
employeeRepository.Add(CreateEntity.Employee3);
employeeContext.SaveChanges();
IDepartmentRepository departmentRepository = new DepartmentRepository(employeeContext);
var department = CreateEntity.Department1;
// Act
departmentRepository.Add(department);
var numberOfChangesCommitted = employeeContext.SaveChanges();
// Assert
numberOfChangesCommitted.Should().BeGreaterThan(0);
var allDepartments = departmentRepository.GetAll().ToList();
allDepartments.Should().HaveCount(1);
allDepartments.ElementAt(0).ShouldBeEquivalentTo(department, options => options.IncludingAllDeclaredProperties());
}
}
public void ShouldDeleteEmployee()
{
// Arrange
using (IEmployeeContext employeeContext = new EmployeeContext(new DropCreateDatabaseAlways<EmployeeContext>()))
{
IEmployeeRepository employeeRepository = new EmployeeRepository(employeeContext);
var employee1 = CreateEntity.Employee1;
var employee2 = CreateEntity.Employee2;
employeeRepository.Add(employee1);
employeeRepository.Add(employee2);
var numberOfAdds = +employeeContext.SaveChanges();
// Act
employeeRepository.Remove(employee2);
var numberOfDeletes =+ employeeContext.SaveChanges();
// Assert
numberOfAdds.Should().Be(2);
numberOfDeletes.Should().Be(1);
var allEmployees = employeeRepository.GetAll().ToList();
allEmployees.Should().HaveCount(1);
allEmployees.ElementAt(0).ShouldBeEquivalentTo(employee1, options => options.IncludingAllDeclaredProperties());
}
}
public void ShouldDeleteDepartment()
{
// Arrange
using (IEmployeeContext employeeContext = new EmployeeContext())
{
IDepartmentRepository departmentRepository = new DepartmentRepository(employeeContext);
var department1 = CreateEntity.Department1;
var department2 = CreateEntity.Department2;
departmentRepository.Add(department1);
departmentRepository.Add(department2);
var numberOfAdds = +employeeContext.SaveChanges();
// Act
departmentRepository.Remove(department2);
var numberOfDeletes =+ employeeContext.SaveChanges();
// Assert
numberOfAdds.Should().BeGreaterThan(0); ;
numberOfDeletes.Should().BeGreaterThan(0);
var allDepartments = departmentRepository.GetAll().ToList();
allDepartments.Should().HaveCount(1);
allDepartments.ElementAt(0).ShouldBeEquivalentTo(department1, options => options.IncludingAllDeclaredProperties());
}
}
static void Main(string[] args)
{
EmployeeContext context = new EmployeeContext();
var employees = context.Employees.ToList();
Console.WriteLine("Count of employees " + employees.Count);
Console.ReadLine();
}
protected void Dispose(bool disposing) {
if (disposing) {
if (db != null) {
db.Dispose();
db = null;
}
}
}
public void ShouldReturnEmptyGetAll()
{
// Arrange
using (IEmployeeContext employeeContext = new EmployeeContext())
{
var departmentRepository = new DepartmentRepository(employeeContext);
// Act
var allDepartments = departmentRepository.GetAll().ToList();
// Assert
allDepartments.Should().HaveCount(0);
}
}
public void ShouldReturnEmptyGetAll()
{
// Arrange
using (IEmployeeContext employeeContext = new EmployeeContext(new DropCreateDatabaseAlways<EmployeeContext>()))
{
IEmployeeRepository employeeRepository = new EmployeeRepository(employeeContext);
// Act
var allEmployees = employeeRepository.GetAll().ToList();
// Assert
allEmployees.Should().HaveCount(0);
}
}
public EmployeeServiceTests()
{
// Setup WCF host
this.serviceHost = new ServiceHost(typeof(EmployeeService));
this.serviceHost.Opened += (sender, args) => { Bootstrapper.RegisterIoc(); };
this.endpoint = this.serviceHost.AddServiceEndpoint(
typeof(IEmployeeService),
new BasicHttpBinding(),
"http://*****:*****@"C:\src\EmployeeManagement\Employee.Service\App_Data");
using (var context = new EmployeeContext())
{
Database.SetInitializer(
new ForceDeleteInitializer<EmployeeContext>(
new DropCreateDatabaseAlways<EmployeeContext>()));
context.Database.Initialize(force: true);
}
}
private async Task Next()
{
switch (WizardStep)
{
case WizardStep.Profile:
var employeeNameExist = await EmployeeService.CheckEmployeeNameExistAsync(Employee);
if (employeeNameExist)
{
EmployeeValidationErrorMessage.DisplayError(nameof(Core.Entities.Employee.FirstName), $"{Employee.FirstName} {Employee.LastName} already exists.");
return;
}
var employeeIsValid = EmployeeContext.Validate();
if (!employeeIsValid)
{
return;
}
WizardStep = WizardStep.HardwareVault;
break;
case WizardStep.HardwareVault:
if (SelectedHardwareVault == null)
{
WarningMessage = "Please, select a vault.";
break;
}
WizardStep = WizardStep.WorkstationAccount;
break;
case WizardStep.WorkstationAccount:
if (AccountType == AccountType.Personal)
{
var accountIsValid = PersonalAccountContext.Validate();
if (!accountIsValid)
{
return;
}
}
WizardStep = WizardStep.Overview;
break;
case WizardStep.Overview:
await CreateAsync();
if (SelectedHardwareVault == null)
{
await ToastService.ShowToastAsync("Employee created.", ToastType.Success);
await SynchronizationService.UpdateEmployees(ExceptPageId);
await ModalDialogService.CloseAsync();
break;
}
Code = await HardwareVaultService.GetVaultActivationCodeAsync(SelectedHardwareVault.Id);
Email = Employee.Email;
WizardStep = WizardStep.Activation;
break;
case WizardStep.Activation:
await ToastService.ShowToastAsync("Employee created.", ToastType.Success);
await SynchronizationService.UpdateEmployees(ExceptPageId);
await ModalDialogService.CloseAsync();
break;
}
}
public static Task Initialize()
{
return Task.Run(() =>
{
_database = new RailwayDataModelContainer();
Clients = new ClientContext();
Employees = new EmployeeContext();
Stations = new StationContext();
Seats = new SeatContext();
Tickets = new TicketContext();
TrainWagons = new TrainWagonContext();
Trains = new TrainContext();
Routes = new RouteContext();
VoyageRoutes = new VoyageRouteContext();
Voyages = new VoyageContext();
Wagons = new WagonContext();
WagonSeats = new WagonSeatContext();
Clients.Repository = _database.ClientSet;
Employees.Repository = _database.EmployeeSet;
Stations.Repository = _database.StationSet;
Seats.Repository = _database.SeatSet;
Tickets.Repository = _database.TicketSet;
TrainWagons.Repository = _database.TrainWagonSet;
Trains.Repository = _database.TrainSet;
VoyageRoutes.Repository = _database.VoyageRouteSet;
Routes.Repository = _database.RouteSet;
Voyages.Repository = _database.VoyageSet;
Wagons.Repository = _database.WagonSet;
WagonSeats.Repository = _database.WagonSeatSet;
DataBase.Database.Connection.OpenAsync();
});
}
public EmployeeStorage()
{
_db = new EmployeeContext();
}
public EmployeeController(EmployeeContext context)
{
_context = context;
}
public SqlEmployeeData(EmployeeContext employeeContext)
{
_employeeContext = employeeContext;
}
public EmployeeRepository(EmployeeContext context)
{
_context = context;
}
public ActionResult Details(int id)
{
EmployeeContext employeeContext = new EmployeeContext();
Employee employee = employeeContext.Employees.Single(emp=>emp.EmployeeId==id);
return View(employee);
}
public ListUserModel(EmployeeContext application)
{
_context = application;
}
public DeparmentsController(EmployeeContext context, IUnitOfWork unitOfWork)
{
this.context = context;
this.unitOfWork = unitOfWork;
}
public GenericRepository(EmployeeContext context)
{
_context = context;
}
public EmployeeController(EmployeeContext context, IOptionsSnapshot <EmpoyeeSettings> settings)
{
this._employeeContext = context ?? throw new ArgumentNullException(nameof(context));
this._settings = settings.Value;
((DbContext)context).ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;
}
public EmployeeController()
{
_db = new EmployeeContext();
}
public EmployeeRepository()
{
_db = new EmployeeContext();
}
public EmployeeRL(EmployeeContext context)
{
this.context = context;
}
public EmployeeController(EmployeeContext emloyeeContext)
{
_employeeContext = emloyeeContext;
}
public EmployeeDataAccessLayer(EmployeeContext employeeContext)
{
db = employeeContext;
}
public AccountController(EmployeeContext context)
{
_context = context;
}
public ManagerInfoCommand(EmployeeContext context, Mapper mapper)
{
this.context = context;
this.mapper = mapper;
}
public EmployeeManager(EmployeeContext context)
{
_employeeContext = context;
}
public LeaveDetailsController(EmployeeContext context)
{
_context = context;
}
public PositionSkillRepository(IEmployeeContext context, IMapper mapper)
{
this._context = context as EmployeeContext;
this._mapper = mapper;
}
public EmployeeRepository(EmployeeContext context) : base(context)
{
}
public EmployeeCreator(EmployeeContext employeeContext)
{
this.employeeContext = employeeContext;
}
public LogRepository(IEmployeeContext context)
{
this._context = context as EmployeeContext;
this._mapper = (IMapper)IoCHelper.GetResolveService(typeof(IMapper));
}
public DetailsRepository(EmployeeContext context)
{
_dataBase = context;
}
public EmployeeRespository(ILogger <IEmployeeRepository> logger, EmployeeContext employeeContext)
{
_employeeContext = employeeContext;
_logger = logger;
}
public CompensationRepository(ILogger <ICompensationRepository> logger, EmployeeContext compensationContext)
{
_context = compensationContext;
_logger = logger;
}
public TokenController(IConfiguration configuration, EmployeeContext employeeContext)
{
_configuration = configuration;
_employeeContext = employeeContext;
}
//
// GET: /Employee/
public ActionResult Index(int departmentId)
{
EmployeeContext employeeContext = new EmployeeContext();
List<Employee> employees = employeeContext.Employees.Where(emp => emp.DepartmentId == departmentId).ToList();
return View(employees);
}
public EmployeeService(EmployeeContext c)
{
ctx = c;
}
public DepartmentsController(EmployeeContext context)
{
_context = context;
}
