private async Task SubmitAddingNewEmployee()
{
var addedEmployee = await EmployeeDataService.AddEmployee(Employee);
if (addedEmployee != null)
{
StatusClass = "alert-success";
Message = "New employee added successfully";
Saved = true;
}
else
{
StatusClass = "alert-danger";
Message = "Something went wrong adding the new employee. Please try again.";
Saved = false;
}
}
private async Task DeleteEmployee()
{
try
{
await EmployeeDataService.DeleteEmployee(EmployeeId);
StatusClass = "alert-success";
Message = $"{Employee.FirstName} was deleted";
Saved = true;
}
catch (Exception)
{
StatusClass = "alert-danger";
Message = $"Something went wrong deleting {Employee.FirstName}";
Saved = false;
}
}
protected async Task HandleValidSubmit()
{
Saved = false;
Employee.CountryId = int.Parse(CountryId);
//Employee.JobCategoryId = int.Parse(JobCategoryId);
if (Employee.EmployeeId == 0) //new
{
if (selectedFiles != null)
{
var file = selectedFiles[0];
Stream stream = file.OpenReadStream();
MemoryStream memoryStream = new MemoryStream();
await stream.CopyToAsync(memoryStream);
stream.Close();
Employee.ImageContent = memoryStream.ToArray();
Employee.ImageName = file.Name;
}
var addedEmployee = await EmployeeDataService.AddEmployee(Employee);
if (addedEmployee != null)
{
StatusClass = "alert-success";
Message = "New employee added successfully.";
Saved = true;
}
else
{
StatusClass = "alert-danger";
Message = "Something went wrong adding the new employee. Please try again.";
Saved = false;
}
}
else
{
await EmployeeDataService.UpdateEmployee(Employee);
StatusClass = "alert-success";
Message = "Employee updated successfully.";
Saved = true;
}
}
protected override async Task OnInitializedAsync()
{
Saved = false;
//Employee = await EmployeeDataService.GetEmployeeDetails(int.Parse(EmployeeId));
Countries = (await CountryDataService.GetAllCountries()).ToList();
JobCategories = (await JobCategoryDataService.GetAllJobCategories()).ToList();
int.TryParse(EmployeeId, out var employeeId);
if (employeeId == 0)
{
}
else
{
Employee = await EmployeeDataService.GetEmployeeDetails(int.Parse(EmployeeId));
}
CountryId = Employee.CountryId.ToString();
JobCategoryId = Employee.JobCategoryId.ToString();
}
public MainWindow(EmployeeDataService dataService)
{
_dbService = dataService;
InitializeComponent();
RefreshEmployeesList();
NewEmployeeGrid.DataContext = _newEmployee;
// Does this count as the obligitory "Hello World"?
Task.Factory.StartNew(() =>
{
Thread.Sleep(2500);
}).ContinueWith(t =>
{
MainSnackbar.MessageQueue.Enqueue("Welcome to the Grover Employee Management App");
}, TaskScheduler.FromCurrentSynchronizationContext());
Snackbar = this.MainSnackbar;
}
private void btnInloggen_Click(object sender, RoutedEventArgs e)
{
EmployeeDataService employeeDataService = new EmployeeDataService(new EmployeeRepository(), txtGebruikersnaam.Text); // The username of the employee will be saved throughout the application
bool loginDetailsCorrect = employeeDataService.CheckLoginDetails(txtGebruikersnaam.Text, txtWachtwoord.Password); // checks whether the login details are correct
if (loginDetailsCorrect)
{
OverviewView overzicht = new OverviewView();
overzicht.Show();
Messenger.Default.Send(employeeDataService);
Close();
}
else
{
MessageBox.Show("Gebruikersnaam of wachtwoord is incorrect");
}
}
public void GetData_WhenCalled_GetsDataFromTheAPI()
{
using (var httpTest = new HttpTest())
{
//Arrange
var service = new EmployeeDataService();
var employeesData = new List <EmployeeViewModel>();
httpTest.RespondWithJson(employeesData, 200);
//Act
var result = service.GetData().Result;
//Assert
httpTest.ShouldHaveCalled("https://localhost:5501/api/employees")
.WithVerb(HttpMethod.Get);
Assert.IsAssignableFrom <IList <EmployeeViewModel> >(result);
}
}
protected override async Task OnInitializedAsync()
{
Saved = false;
Departments = (await DepartmentDataService.GetAllDepartments()).ToList();
int.TryParse(Id, out var employeeId);
if (employeeId == 0) //new employee is being created
{
//add some defaults
Employee = new Employee {
DepartmentId = 1, BirthDate = DateTime.Now, JoinedDate = DateTime.Now
};
}
else
{
Employee = await EmployeeDataService.GetEmployeeDetails(int.Parse(Id));
}
DepartmentId = Employee.DepartmentId.ToString();
}
async Task DeleteEmployeeAsync(int employeeId)
{
var parameters = new ModalParameters();
parameters.Add("Title", "Please Confirm");
parameters.Add("Message", "Do you really wish to delete this Employee?");
parameters.Add("ButtonColour", "danger");
var employee = await EmployeeDataService.GetEmployeeDetails(employeeId);
var formModal = Modal.Show <BlazoredModalConfirmDialog>($"Delete Employee: {employee?.FullName}?", parameters);
var result = await formModal.Result;
if (!result.Cancelled)
{
await EmployeeDataService.DeleteEmployee(employeeId);
NavigateToOverview();
}
}
protected async Task OnValidSubmitHandle()
{
var res = await EmployeeDataService.AddEmployee(Employee);
if (res != null)
{
ShowDialog = false;
Saved = true;
Status = "alert-success";
Message = "New Added";
await ClosedDialogEvent.InvokeAsync(res);
}
else
{
Saved = false;
Status = "alert-danger";
Message = "Something went wrong";
}
StateHasChanged();
}
protected override async Task OnInitializedAsync()
{
Saved = false;
int.TryParse(EmployeeId, out int employeeId);
if (employeeId == 0)
{
Employee = new Employee {
CountryId = 1, JobCategoryId = 1, BirthDate = DateTime.Now, JoinedDate = DateTime.Now
};
}
else
{
Employee = await EmployeeDataService.GetEmployeeDetails(int.Parse(EmployeeId));
}
Countries = (await CountryDataService.GetAllCountries()).ToList();
JobCategories = (await JobCategoryDataService.GetAllJobCategories()).ToList();
CountryId = Employee.CountryId.ToString();
JobCategoryId = Employee.JobCategoryId.ToString();
}
protected override async Task OnInitializedAsync()
{
Saved = false;
Countries = (await CountryDataService.GetAllCountries()).ToList();
JobCategories = (await JobCategoryDataService.GetAllJobCategories()).ToList();
if (int.Parse(EmployeeId) == 0) //new employee is being created
{
//add some defaults
Employee = new Employee {
CountryId = 1, JobCategoryId = 1, BirthDate = DateTime.Now, JoinedDate = DateTime.Now
};
}
else
{
Employee = await EmployeeDataService.GetEmployeeDetails(int.Parse(EmployeeId));
}
CountryId = Employee.CountryId.ToString();
JobCategoryId = Employee.JobCategoryId.ToString();
}
public async Task HandleValidSubmit()
{
Saved = false;
Employee.CountryId = int.Parse(CountryId);
Employee.JobCategoryId = int.Parse(JobCategoryId);
if (Employee.EmployeeId == 0)
{
var addedEmployee = EmployeeDataService.AddEmployee(Employee);
if (addedEmployee != null)
{
StatusClass = "alert-success";
Message = "New employee added successfuly.";
Saved = true;
}
else
{
StatusClass = "alert-danger";
Message = "Something went wrong adding new employee. Please try again later.";
Saved = false;
}
}
else
{
try
{
await EmployeeDataService.UpdateEmployee(Employee);
StatusClass = "alert-success";
Message = "Employee updated successfuly.";
Saved = true;
}
catch (Exception err)
{
StatusClass = "alert-danger";
Message = err.Message;
Saved = true;
}
}
}
protected async Task HandelValidSubmit()
{
if (Employee.EmployeeId == 0)
{
if (selectedFiles != null)
{
var file = selectedFiles[0];
using var stream = file.OpenReadStream();
using var ms = new MemoryStream();
await stream.CopyToAsync(ms);
stream.Close();
Employee.ImageName = file.Name;
Employee.ImageContent = ms.ToArray();
}
var addedEmployee = await EmployeeDataService.AddEmployee(Employee);
if (addedEmployee != null)
{
StatusClass = "alert-success";
Message = "Employee updated successfully.";
Saved = true;
}
else
{
StatusClass = "alert-danger";
Message = "Something went wrong added th new employee. Please try again.";
Saved = false;
}
}
else
{
await EmployeeDataService.UpdateEmployee(Employee);
StatusClass = "alert-success";
Message = "Employee updated successfully.";
Saved = true;
}
}
protected override async Task OnInitializedAsync()
{
if (HRTaskId > 0)
{
try
{
Task = (await TaskDataService.GetTaskById(HRTaskId));
}
catch (System.Exception exception)
{
Message = exception.Message;
}
}
else
{
Task = new HRTask {
Status = HRTaskStatus.Open
};
}
Employees = (await EmployeeDataService.GetAllEmployees()).ToList();
}
protected override async Task OnInitializedAsync()
{
Saved = false;
Countries = (await CountryDataService.GetAllCountries().ConfigureAwait(false))?.ToList();
JobCategories = (await JobCategoryDataService.GetAllJobCategories().ConfigureAwait(false))?.ToList();
int.TryParse(EmployeeId, out var employeeId);
if (employeeId == 0) // new employee is being created
{
Employee = new Employee {
CountryId = 1, JobCategoryId = 1, BirthDate = DateTime.Now
};
}
else
{
Employee = await EmployeeDataService.GetEmployeeDetails(int.Parse(EmployeeId)).ConfigureAwait(false);
}
CountryId = Employee.CountryId.ToString();
JobCategoryId = Employee.JobCategoryId.ToString();
}
protected override async Task OnInitializedAsync()
{
Saved = false;
Countries = await CountryDataService.GetAllCountries();
JobCategories = await JobCategoryDataService.GetAllJobCategories();
if (EmployeeId == 0)
{
Employee = new Employee {
CountryId = 1, JobCategoryId = 1, BirthDate = DateTime.Now, JoinedDate = DateTime.Now
}
}
;
else
{
Employee = await EmployeeDataService.GetEmployeeDetails(EmployeeId);
}
JobCategoryId = Employee.JobCategoryId.ToString();
CountryId = Employee.CountryId.ToString();
}
protected override async Task OnInitializedAsync()
{
Employees = (await EmployeeDataService.GetAllEmployees()).ToList();
Currencies = (await ExpenseService.GetAllCurrencies()).ToList();
int.TryParse(ExpenseId, out var expenseId);
if (expenseId != 0)
{
Expense = await ExpenseService.GetExpenseById(int.Parse(ExpenseId));
}
else
{
Expense = new Expense()
{
EmployeeId = 1, CurrencyId = 1, Status = ExpenseStatus.Open, ExpenseType = ExpenseType.Other
};
}
CurrencyId = Expense.CurrencyId.ToString();
EmployeeId = Expense.EmployeeId.ToString();
}
protected override async Task OnInitializedAsync()
{
Saved = false;
// Employee = await EmployeeDataService.GetEmployeeDetails(int.Parse(EmployeeId));
Countries = (await CountryDataService.GetAllCountries()).ToList();
JobCategories = (await JobCategoryDataService.GetAllJobCategories()).ToList();
int.TryParse(EmployeeId, out var employeeId);
if (employeeId == 0) // No Id, new employee being created
{
// Add default
Employee = new EmployeeModel {
CountryId = 1, JobCategoryId = 1, BirthDate = DateTime.Now
};
}
else
{
Employee = await EmployeeDataService.GetEmployeeDetails(int.Parse(EmployeeId));
}
CountryId = Employee.CountryId.ToString();
JobCategoryId = Employee.JobCategoryId.ToString();
}
protected override async Task OnInitializedAsync( )
{
Saved = false;
Countries = (await CountryDataService.GetAllCountries( )).ToList( );
JobCategories = (await JobCategoryDataService.GetAllJobCategories( )).ToList( );
if (!int.TryParse(EmployeeID, out int employeeID))
{
Employee = new Employee {
CountryId = 1, JobCategoryId = 1, BirthDate = DateTime.Now
}
}
;
else
{
Employee = await EmployeeDataService.GetEmployeeDetails(employeeID);
}
CountryID = Employee.CountryId.ToString( );
JobCategoryID = Employee.JobCategoryId.ToString( );
await base.OnInitializedAsync( );
}
protected async Task HandleValidSubmit()
{
Saved = false;
Employee.CountryId = int.Parse(CountryId);
Employee.JobCategoryId = int.Parse(JobCategoryId);
if (file != null)
{
await fileUpload.UploadAsync(file);
Employee.FileName = file.Name;
}
if (Employee.EmployeeId == 0) //new
{
var addedEmployee = await EmployeeDataService.AddEmployee(Employee);
if (addedEmployee != null)
{
StatusClass = "alert-success";
Message = "New employee added successfully.";
Saved = true;
}
else
{
StatusClass = "alert-danger";
Message = "Something went wrong adding the new employee. Please try again.";
Saved = false;
}
}
else
{
await EmployeeDataService.UpdateEmployee(Employee);
StatusClass = "alert-success";
Message = "Employee updated successfully.";
Saved = true;
}
}
protected async Task HandleValidSubmit()
{
Employee.CountryId = int.Parse(CountryId);
Employee.JobCategoryId = int.Parse(JobCategoryId);
if (Employee.EmployeeId == 0) //new
{
var addedEmployee = await EmployeeDataService.AddEmployee(Employee);
var newEmployee = new Employee();
Employee.UpdateEntity(newEmployee);
AppDbContext.Add(newEmployee);
await AppDbContext.SaveChangesAsync();
if (addedEmployee != null)
{
StatusClass = "alert-success";
Message = "New employee added successfully.";
Saved = true;
}
else
{
StatusClass = "alert-danger";
Message = "Something went wrong adding the new employee. Please try again.";
Saved = false;
}
}
else
{
await EmployeeDataService.UpdateEmployee(Employee);
StatusClass = "alert-success";
Message = "Employee updated successfully.";
Saved = true;
}
}
public void DoesCreateWorks()
{
var options = new DbContextOptionsBuilder <MDManagementDbContext>()
.UseInMemoryDatabase(databaseName: "testDb")
.Options;
using (var dbContext = new MDManagementDbContext(options))
{
var userManager = new Mock <UserManager <Employee> >().Object;
IJobTitleDataService jobTitleService = new JobTittleDataServie(dbContext);
ICompanyDataService companyService = new CompanyDataSerive(dbContext);
IEmployeeDataService employeeService = new EmployeeDataService(dbContext, jobTitleService, companyService, userManager);
IProjectDataService projectService = new ProjectDataService(dbContext, employeeService);
var modelService = new ProjectServiceModel
{
Name = "AI",
Description = "nope",
};
Assert.AreEqual("AI", dbContext.Projects.FirstOrDefault().Name);
}
}
public void GetDataService()
{
//Given
List <Employee> expectedList = new List <Employee>();
expectedList.Add(new Employee {
id = 1, name = "Juan", contractTypeName = "HourlySalaryEmployee", roleId = 1, roleName = "Administrator", roleDescription = null, hourlySalary = 60000, monthlySalary = 80000
});
expectedList.Add(new Employee {
id = 2, name = "Sebastian", contractTypeName = "MonthlySalaryEmployee", roleId = 2, roleName = "Contractor", roleDescription = null, hourlySalary = 60000, monthlySalary = 80000
});
//When
var employeeService = new EmployeeDataService();
List <Employee> result = employeeService.GetDataEmployeeService();
// Assert
result.WithDeepEqual(expectedList)
.SkipDefault <List <Employee> >()
.Assert();
}
protected override async Task OnInitializedAsync()
{
// Employee = await EmployeeDataService.GetEmployeeDetails(Convert.ToInt32(EmployeeId));
Countries = await CountryDataService.GetAllCountries();
JobCategories = await JobCategoryDataService.GetAllJobCategories();
int.TryParse(EmployeeId, out var id);
if (id == 0)
{
Employee = new Employee {
CountryId = 1, JobCategoryId = 1, BirthDate = DateTime.Now
};
}
else
{
Employee = await EmployeeDataService.GetEmployeeDetails(Convert.ToInt32(EmployeeId));
}
CountryId = Employee.CountryId.ToString();
JobCategoryId = Employee.JobCategoryId.ToString();
await base.OnInitializedAsync();
}
protected async Task HandleValidSubmit()
{
Employee.CountryId = int.Parse(CountryId);
Employee.JobCategoryId = int.Parse(JobCategoryId);
if (ValidateTasks() == false)
{
Saved = false;
StatusClass = "alert-danger";
TaskMessage = "There is a validation problem with the tasks please check and try again.";
return;
}
if (Employee.EmployeeId == 0) //new
{
var addedEmployee = await EmployeeDataService.AddEmployee(Employee);
if (addedEmployee != null)
{
StatusClass = "alert-success";
Message = "New employee added successfully.";
Saved = true;
}
else
{
StatusClass = "alert-danger";
Message = "Something went wrong adding the new employee. Please try again.";
Saved = false;
}
}
else
{
await EmployeeDataService.UpdateEmployee(Employee);
StatusClass = "alert-success";
Message = "Employee updated successfully.";
Saved = true;
}
}
public async void AddEmployeeDialog_OnDialogClose()
{
Employees = (await EmployeeDataService.GetAllEmployees()).ToList();
StateHasChanged();
}
protected async override Task OnInitializedAsync()
{
Employees = (await EmployeeDataService.GetAllEmployees()).ToList();
}
protected override async Task OnInitializedAsync()
{
Employee = await EmployeeDataService.GetEmployeeDetails(Convert.ToInt32(EmployeeId));
await base.OnInitializedAsync();
}
protected override async Task OnInitializedAsync()
{
Employee = (await EmployeeDataService.GetEmployeeDetails(int.Parse(EmployeeId)));
}
