// Added By Hojjat:
public JsonResult Employee_Insert(AddEmployeeRequest request)
{
GeneralResponse response = new GeneralResponse();
#region Access Check
bool hasPermission = GetEmployee().IsGuaranteed("Employee_Insert");
if (!hasPermission)
{
response.ErrorMessages.Add("AccessDenied");
return(Json(response, JsonRequestBehavior.AllowGet));
}
#endregion
try
{
}
catch (Exception ex)
{
//response.success = false;
response.ErrorMessages.Add("در آپلود کردن فایل خطایی به وجود آمده است.");
return(Json(response, JsonRequestBehavior.AllowGet));
}
request.Discontinued = false;
response = _employeeService.AddEmployee(request, GetEmployee().ID);
return(Json(response, JsonRequestBehavior.AllowGet));
}
public IActionResult AddEmployee([FromBody] AddEmployeeRequest addEmployee)
{
addEmployeeValidator.ValidateAndThrow(addEmployee);
var employeeId = employeeRepository.AddEmployee(addEmployee);
return(Ok(employeeId));
}
public async Task <StatusData <long> > AddEmployment(AddEmployeeRequest request, SystemSession session)
{
var serviceRequest = new Employment
{
Mode = (byte)SystemDbStatus.Updated,
City = new City {
CityId = request.CityId
},
PersonEmploymentId = 0,
//RequestId = request.RequestId != 0 ? request.RequestId : 0,
UserId = session.UserId,
EmployeeInfo = new CompanyEmployeeInfo {
CompanyId = request.CompanyId ?? 0, CompanyName = request.CompanyName, Position = request.Position, StartDate = request.StartDate.ToString(), EndDate = request.EndDate != null?request.EndDate.ToString() : null, EmployeeTypeId = (int)request.EmployeeTypeId
}
};
var response = await Task.Factory.StartNew(() => Client.UserService.upsertEmployeementHistory(serviceRequest, session.GetSession())).ConfigureAwait(false);
var result = new StatusData <long> {
Status = (SystemDbStatus)response.DbStatus.DbStatusCode, Message = response.DbStatus.DbStatusMsg, SubStatus = response.DbStatus.DbSubStatusCode
};
if (!request.EndDate.HasValue && result.Status.IsOperationSuccessful())
{
result.Data = response.PersonEmploymentId;
var empSch = new EmployeeWorkScheduleUpdateRequest {
PersonEmploymentId = response.PersonEmploymentId, ScheduleType = request.WorkSchedule.ScheduleType, Schedules = request.WorkSchedule.Schedules
};
await UpdateEmployeeWorkSchedule(empSch, session).ConfigureAwait(false);
}
return(result);
}
public async Task <IHttpActionResult> AddAsync(AddEmployeeRequest request)
{
var employee = new Employee
{
Name = request.Name,
Department = request.Department
};
if (await _employeeService.AnyAsync(a => a.Name == request.Name && a.Department == request.Department))
{
return(Fail("存在重名"));
}
var result = await _employeeService.AddAsync(employee);
if (result > 0)
{
return(Succeed(new AddEmployeeResponse
{
Id = employee.Id
}, "添加成功"));
}
else
{
return(Fail("修改失败"));
}
}
public ActionResult Registration(Employee employee)
{
if (ModelState.IsValid)
{
using (var client = new WcfHost.EmployeeService.EmployeeServiceClient())
{
AddEmployeeRequest addEmployeeRequest = new AddEmployeeRequest();
addEmployeeRequest.Lastname = employee.Lastname;
addEmployeeRequest.Firstname = employee.Firstname;
addEmployeeRequest.Title = employee.Title;
addEmployeeRequest.Titleofcourtesy = employee.Titleofcourtesy;
addEmployeeRequest.Birthdate = employee.Birthdate;
addEmployeeRequest.Hiredate = employee.Hiredate;
addEmployeeRequest.Address = employee.Address;
addEmployeeRequest.City = employee.City;
addEmployeeRequest.Region = employee.Region;
addEmployeeRequest.Postalcode = employee.Postalcode;
addEmployeeRequest.Country = employee.Country;
addEmployeeRequest.Phone = employee.Phone;
addEmployeeRequest.Mgrid = employee.Mgrid;
client.AddEmployee(addEmployeeRequest);
}
}
return(View(employee));
}
public IHttpActionResult PostEmployee(AddEmployeeRequest addEmployeeRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var employee = new Employee
{
Name = addEmployeeRequest.Name,
Address = new Address
{
Address1 = addEmployeeRequest.Address1,
Locality = addEmployeeRequest.Locality
}
};
_employeeService.Add(employee);
return(CreatedAtRoute(
"DefaultApi",
new { id = employee.Id },
new EmployeeResult
{
Id = employee.Id,
Name = employee.Name,
Address = new AddressResult
{
Id = employee.Address.Id,
Address1 = employee.Address.Address1,
Locality = employee.Address.Locality,
}
}));
}
private List <ValidationResult> ValidateRequest(AddEmployeeRequest request)
{
var validationContext = new ValidationContext(request, null, null);
var validationResults = new List <ValidationResult>();
Validator.TryValidateObject(request, validationContext, validationResults, true);
return(validationResults);
}
public override async Task <AddEmployeeResponse> AddEmployee(AddEmployeeRequest request, ServerCallContext context)
{
var reslut = new AddEmployeeResponse();
var employee = await _employeeRepository.Add(request.Employee);
reslut.Employee = employee;
return(reslut);
}
public long AddEmployee(AddEmployeeRequest employee)
{
var newEmployee = mapper.Map <Employees>(employee);
newEmployee.DateHired = DateTime.Now;
newEmployee.LastUpdate = DateTime.Now;
context.Add(newEmployee);
context.SaveChanges();
return(newEmployee.Id);
}
public async Task <ActionResult> CreateEmployee([FromBody] AddEmployeeRequest request)
{
try
{
await _mediator.Send(request);
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
//Review : how to handle when the domain layer throws an exception?
}
public AddEmployeeRequest Map(EmployeeViewModel viewModel, Guid userId)
{
var result = new AddEmployeeRequest()
{
EmployeeReference = viewModel.EmployeeReference,
Title =
(string.IsNullOrEmpty(viewModel.NameTitle) ||
viewModel.NameTitle.ToLower().Contains("select")
? string.Empty
: viewModel.NameTitle),
Forename = viewModel.Forename,
Surname = viewModel.Surname,
MiddleName = viewModel.MiddleName,
PreviousSurname = viewModel.PreviousSurname,
Sex = viewModel.Sex,
DateOfBirth = viewModel.DateOfBirth.GetValueOrDefault(),
NationalityId = viewModel.NationalityId,
HasDisability = viewModel.HasDisability,
DisabilityDescription = viewModel.DisabilityDescription,
SiteId = viewModel.SiteId,
JobTitle = viewModel.JobTitle,
EmploymentStatusId = viewModel.EmploymentStatusId,
NINumber = viewModel.NINumber,
PassportNumber = viewModel.PassportNumber,
PPSNumber = viewModel.PPSNumber,
WorkVisaNumber = viewModel.WorkVisaNumber,
WorkVisaExpirationDate = viewModel.WorkVisaExpirationDate.GetValueOrDefault(),
DrivingLicenseNumber = viewModel.DrivingLicenseNumber,
DrivingLicenseExpirationDate =
viewModel.DrivingLicenseExpirationDate.GetValueOrDefault(),
HasCompanyVehicle = viewModel.HasCompanyVehicle,
CompanyVehicleTypeId = viewModel.CompanyVehicleTypeId,
CompanyVehicleRegistration = viewModel.CompanyVehicleRegistration,
Address1 = viewModel.Address1,
Address2 = viewModel.Address2,
Address3 = viewModel.Address3,
County = viewModel.County,
CountryId = viewModel.CountryId.GetValueOrDefault(),
Postcode = viewModel.Postcode,
Telephone = viewModel.Telephone,
Mobile = viewModel.Mobile,
Email = viewModel.Email,
UserId = userId,
CompanyId = viewModel.CompanyId,
NotificationType = MapNotificationType( viewModel.NotificationType ),
NotificiationFrequency = viewModel.NotificationFrequency
};
return result;
}
public async Task <bool> AddEmployee(AddEmployeeRequest request)
{
Employee employee = new Employee()
{
UserId = request.UserId,
DateOfBirth = request.DateOfBirth,
Position = request.Position
};
await _context.Employees.AddAsync(employee);
var created = await _context.SaveChangesAsync();
return(created > 0);
}
public bool UpdateEmployee(AddEmployeeRequest request)
{
if (request != null)
{
Employee employees = new Employee();
Employee emp = _db.Employees.SingleOrDefault(a => a.EmployeeId == request.Id);
emp.EmployeeName = request.EmployeeName;
emp.Manager = request.Manager;
_db.SaveChanges();
return(true);
}
return(false);
}
public string AddEmployee(AddEmployeeRequest request)
{
if (request != null)
{
Employee employee = new Employee();
employee.EmployeeName = request.EmployeeName;
// employee.ProjectId = request.ProjectId;
employee.Manager = request.Manager;
_db.Employees.Add(employee);
_db.SaveChanges();
return("ONE ROW IS ADDED IN EMPLOYEE TABLE");
}
return("COULD NOT BE ADDED");
}
public void AddEmployee_400_Name_Missing()
{
var controller = new ServiceController(mockAppSettings.Object, mockDatabaseRepository.Object);
var request = new AddEmployeeRequest()
{
};
var validationResults = ValidateRequest(request);
foreach (var validationResult in validationResults)
{
controller.ModelState.AddModelError(validationResult.MemberNames.First(), validationResult.ErrorMessage);
}
var response = controller.AddEmployee(request) as ObjectResult;
var result = response.Value as AddEmployeeResponse;
Assert.AreEqual(result.Success, false);
Assert.IsTrue(result.ErrorResponse.Message.Contains("Name"));
Assert.AreEqual(response.StatusCode, 400);
}
public void AddEmployee_200_OK()
{
var controller = new ServiceController(mockAppSettings.Object, mockDatabaseRepository.Object);
var request = new AddEmployeeRequest()
{
Name = "Unit Testing", Address = "TestAddress", DepartmentId = 1002, Salary = 3200
};
var validationResults = ValidateRequest(request);
foreach (var validationResult in validationResults)
{
controller.ModelState.AddModelError(validationResult.MemberNames.First(), validationResult.ErrorMessage);
}
var response = controller.AddEmployee(request) as ObjectResult;
var result = response.Value as AddEmployeeResponse;
Assert.AreEqual(result.Success, true);
Assert.AreEqual(response.StatusCode, 200);
}
private async void UxAddEmployeeServiceRequestButton_Clicked(object sender, RoutedEventArgs e)
{
if (uxPasswordEntry.Password == uxPasswordReentry.Password)
{
var validAddEmployeeRequest = await AddEmployeeRequest.SendAddEmployeeRequest(uxFirstNameEntry.Text, uxLastNameEntry.Text, uxUsernameEntry.Text, uxPasswordEntry.Password, Convert.ToInt32(uxPositionComboBox.SelectedItem), Convert.ToDouble(uxWageBox.Text));
if (validAddEmployeeRequest)
{
ContentDialog responseAlert = new ContentDialog
{
Title = "Successful",
Content = "Employee has been added to the database successfully",
CloseButtonText = "Ok"
};
ContentDialogResult result = await responseAlert.ShowAsync();
}
else
{
ContentDialog responseAlert = new ContentDialog
{
Title = "Unsuccessful",
Content = "Employee was not created successfully",
CloseButtonText = "Ok"
};
ContentDialogResult result = await responseAlert.ShowAsync();
}
}
else
{
ContentDialog responseAlert = new ContentDialog
{
Title = "Password do not match",
Content = "Please try entering your password again",
CloseButtonText = "Ok"
};
ContentDialogResult result = await responseAlert.ShowAsync();
}
RefreshEmployeeList();
}
public IActionResult AddEmployee([FromBody] AddEmployeeRequest request)
{
var response = new AddEmployeeResponse();
if (!ModelState.IsValid)
{
var errors = ModelState.Where(e => e.Value.Errors.Count > 0).Select(ee => ee.Value.Errors.First().ErrorMessage);
response.ErrorResponse = Helpers.Helper.ConvertToErrorResponse(errors.FirstOrDefault(), ErrorsType.ValidationError.ToString(), ErrorMessageType.Validation.ToString());
return(BadRequest(response));
}
var result = _dbRepository.AddEmployee(request.Name, request.Address, request.Salary, request.DepartmentId);
if (result > 0)
{
response.Result = true;
response.Success = true;
}
else
{
response.ErrorResponse = Helpers.Helper.ConvertToErrorResponse("Some error occured in adding employee..", ErrorsType.DatabaseError.ToString(), ErrorMessageType.Error.ToString());
}
return(Ok(response));
}
// TODO: move into imported record class
private AddEmployeeRequest MapEmployeeRecordToAddEmployeeRequest(ImportedData importedData, int idx)
{
var addEmployeeRequest = new AddEmployeeRequest();
var dictionary = importedData.GetRecordAsDictionary(idx);
addEmployeeRequest.CompanyId = _clientID;
addEmployeeRequest.UserId = SystemUserId;
// Mandatory fields
addEmployeeRequest.Forename = dictionary["Forename"];
if (String.IsNullOrEmpty(addEmployeeRequest.Forename))
{
throw new Exception("Record " + (idx + 1).ToString() + " - Forename cannot be empty");
}
addEmployeeRequest.Surname = dictionary["Surname"];
if (String.IsNullOrEmpty(addEmployeeRequest.Surname))
{
throw new Exception("Record " + (idx + 1).ToString() + " - Surname cannot be empty");
}
// Non-mandatory fields
addEmployeeRequest.EmployeeReference = GetStringValueByKeyReturnNullIfNotFound(dictionary, "EmployeeReference");
addEmployeeRequest.Title = GetStringValueByKeyReturnNullIfNotFound(dictionary, "Title");
addEmployeeRequest.Sex = GetStringValueByKeyReturnNullIfNotFound(dictionary, "Gender");
addEmployeeRequest.DateOfBirth = DateOfBirth(dictionary);
addEmployeeRequest.NationalityId = GetIntValueByKeyReturnNullIfNotFound(dictionary, "NationalityId");
addEmployeeRequest.NINumber = GetStringValueByKeyReturnNullIfNotFound(dictionary, "NI Number");
addEmployeeRequest.DrivingLicenseNumber = GetStringValueByKeyReturnNullIfNotFound(dictionary, "Driving Licence No.");
addEmployeeRequest.PPSNumber = GetStringValueByKeyReturnNullIfNotFound(dictionary, "PPSNumber");
addEmployeeRequest.PassportNumber = GetStringValueByKeyReturnNullIfNotFound(dictionary, "Passport No");
addEmployeeRequest.WorkVisaNumber = GetStringValueByKeyReturnNullIfNotFound(dictionary, "WorkVisaNumber");
addEmployeeRequest.WorkVisaExpirationDate = GetDateTimeValueByKeyReturnNullIfNotFound(dictionary, "WorkVisaExpiryDate");
addEmployeeRequest.HasDisability = GetBooleanValueByKeyReturnFalseIfNotFound(dictionary, "Disabled");
addEmployeeRequest.HasCompanyVehicle = GetBooleanValueByKeyReturnFalseIfNotFound(dictionary, "CompanyCar");
addEmployeeRequest.Address1 = GetStringValueByKeyReturnNullIfNotFound(dictionary, "Address Line 1");
addEmployeeRequest.Address2 = GetStringValueByKeyReturnNullIfNotFound(dictionary, "Address Line 2");
addEmployeeRequest.Address3 = GetStringValueByKeyReturnNullIfNotFound(dictionary, "Address Line 3");
addEmployeeRequest.Town = GetStringValueByKeyReturnNullIfNotFound(dictionary, "Town");
addEmployeeRequest.County = GetStringValueByKeyReturnNullIfNotFound(dictionary, "County");
addEmployeeRequest.Postcode = GetStringValueByKeyReturnNullIfNotFound(dictionary, "Postcode");
addEmployeeRequest.Telephone = GetStringValueByKeyReturnNullIfNotFound(dictionary,
new string[]
{
"Telephone",
"Home Telephone"
});
addEmployeeRequest.Mobile = GetStringValueByKeyReturnNullIfNotFound(dictionary, "Mobile");
addEmployeeRequest.Mobile = GetStringValueByKeyReturnNullIfNotFound(dictionary, "Mobile No.");
addEmployeeRequest.Email = GetStringValueByKeyReturnNullIfNotFound(dictionary, "Email");
addEmployeeRequest.JobTitle = GetStringValueByKeyReturnNullIfNotFound(dictionary,
new string[]
{
"Job Title",
"Job Role"
});
return addEmployeeRequest;
}
public Task <StatusData <long> > AddEmployment(AddEmployeeRequest request, SystemSession session)
{
return(_jUnitOfWork.ProfilePersonal.AddEmployment(request, session));
}
public async Task <IActionResult> Create(AddEmployeeRequest request)
{
var isCreated = await _employee.AddEmployee(request);
return(Ok(isCreated));
}
private AddUpdateEmployeeParameters GetAddingEmployeeParameters(AddEmployeeRequest addEmployeeRequest)
{
return _employeeParametersMapper.Map(addEmployeeRequest);
}
public GeneralResponse AddEmployee(AddEmployeeRequest request, Guid CreateEmployeeID)
{
GeneralResponse response = new GeneralResponse();
try
{
Employee employee = new Employee();
employee.ID = Guid.NewGuid();
employee.CreateDate = PersianDateTime.Now;
employee.CreateEmployee = _employeeRepository.FindBy(CreateEmployeeID);
employee.BirthDate = request.BirthDate;
employee.FirstName = request.FirstName;
Group group = _groupRepository.FindBy(request.GroupID);
employee.Group = group;
employee.HireDate = request.HireDate;
employee.InstallExpert = request.InstallExpert;
employee.LastName = request.LastName;
employee.LoginName = request.LoginName;
employee.ParentEmployee = this._employeeRepository.FindBy(request.ParentEmployeeID);
employee.Password = request.Password;
employee.Phone = request.Phone;
employee.Mobile = request.Mobile;
employee.Address = request.Address;
employee.Note = request.Note;
employee.Discontinued = request.Discontinued;
employee.Picture = request.Picture;
IList <Permit> permits = group.Permissions.ToList();
//foreach (var permit in permits)
//{
// permit.Group = null;
//}
employee.Permissions = GetNewPermitList(group.Permissions.ToList());
employee.RowVersion = 1;
#region Validation
if (employee.GetBrokenRules().Count() > 0)
{
foreach (BusinessRule businessRule in employee.GetBrokenRules())
{
response.ErrorMessages.Add(businessRule.Rule);
}
return(response);
}
#endregion
_employeeRepository.Add(employee);
_uow.Commit();
}
catch (Exception ex)
{
//if (ex.InnerException != null)
// if (ex.InnerException.Message == "Violation of UNIQUE KEY constraint 'IX_Employee'. Cannot insert duplicate key in object 'Emp.Employee'. The duplicate key value is (a).")
response.ErrorMessages.Add(ex.Message);
}
return(response);
}
public async Task <BaseResponse> Add([FromBody] AddEmployeeRequest request)
{
if (request == null)
{
return(BaseResponse.GetFail("Тело запроса пустое"));
}
var access = await CheckAccessToken(request.AccessToken, new List <ClaimsTypeEnum>() { ClaimsTypeEnum.Admin });
if (!access.IsSuccess)
{
return(access);
}
if (request.Employee == null)
{
return(BaseResponse.GetFail("Поле 'Сотрудник' в запросе пустое"));
}
if (!request.Employee.Birthday.HasValue)
{
return(BaseResponse.GetFail("Дата рождения не задана"));
}
var validateBirthday = ValidateBirthday(request.Employee.Birthday.Value);
if (!validateBirthday.IsSuccess)
{
return(validateBirthday);
}
if (!request.Employee.Sex.HasValue)
{
return(BaseResponse.GetFail("Пол не задан"));
}
if (string.IsNullOrWhiteSpace(request.Employee.FirstName))
{
return(BaseResponse.GetFail("Имя не задано"));
}
var validateFirstName = ValidateNames(request.Employee.FirstName);
if (!validateFirstName.IsSuccess)
{
return(validateFirstName);
}
if (string.IsNullOrWhiteSpace(request.Employee.LastName))
{
return(BaseResponse.GetFail("Фамилия не задана"));
}
var validateLastName = ValidateNames(request.Employee.LastName);
if (!validateLastName.IsSuccess)
{
return(validateLastName);
}
if (!string.IsNullOrWhiteSpace(request.Employee.FatherName))
{
var validateFatherName = ValidateNames(request.Employee.FatherName);
if (!validateFatherName.IsSuccess)
{
return(validateFatherName);
}
}
if (string.IsNullOrWhiteSpace(request.Employee.Phone))
{
return(BaseResponse.GetFail("Телефон не задан"));
}
if (!request.Employee.PositionId.HasValue)
{
return(BaseResponse.GetFail("Должность не задана"));
}
try
{
await _employeeRepository.InsertAsync(ConvertEmployeeModelToEmployee(request.Employee));
}
catch (Exception ex)
{
_logger.LogError(ex.Message, ex);
return(BaseResponse.GetFail("Непредвиденная ошибка при добавлении пользователя"));
}
return(new BaseResponse()
{
IsSuccess = true
});
}
public async Task <HttpResponseMessage> AddEmployment([FromBody] AddEmployeeRequest request)
{
var response = await _profilePersonalService.AddEmployment(request, Request.GetSession()).ConfigureAwait(false);
return(Request.SystemResponse(response.Status, new { response.Data }));
}
public AddEmployeeRequest Build()
{
_request = new AddEmployeeRequest
{
EmployeeReference = _employeeReference,
Title = _title,
Forename = _forename,
Surname = _surname,
MiddleName = _middleName,
PreviousSurname = _previousSurname,
Sex = _sex,
DateOfBirth = DateTime.Parse(_dob),
NationalityId = _nationalityId,
HasDisability = _hasDisability,
DisabilityDescription = _disabilityDescription,
NINumber = _niNumber,
PassportNumber = _passportNumber,
PPSNumber = _pps,
WorkVisaNumber = _workingVisaNumber,
WorkVisaExpirationDate = _workingVisaExpirationDate,
DrivingLicenseNumber = _drivingLicenseNumber,
DrivingLicenseExpirationDate = _drivingLicenseExpirationDate,
HasCompanyVehicle = _hasCompanyVehicle,
CompanyVehicleRegistration = _registration,
CompanyVehicleTypeId = _companyVehicleTypeId,
SiteId = _siteId,
JobTitle = _jobTitle,
EmploymentStatusId = _employmentStatusId,
Address1 = _address1,
Address2 = _address2,
Address3 = _address3,
County = _county,
Postcode = _postcode,
CountryId = _countryId,
Telephone = _telephone,
Mobile = _mobile,
Email = _email,
UserId = _userId
};
return _request;
}
private bool DoesEmployeeAlreadyExistForThisClient(AddEmployeeRequest addEmployeeRequest)
{
var employeeAlreadyExistsForThisClient =
_existingEmployeesList.Count(
e =>
e.Surname.Equals(addEmployeeRequest.Surname) &&
e.Forename.Equals(addEmployeeRequest.Forename)) > 0;
return employeeAlreadyExistsForThisClient;
}
private static Expression<Func<Employee, bool>> matchesAddEmployeeRequestProperties(AddEmployeeRequest request)
{
return y => y.EmployeeReference == request.EmployeeReference &&
y.Title == request.Title &&
y.Forename == request.Forename &&
y.Surname == request.Surname &&
y.MiddleName == request.MiddleName &&
y.PreviousSurname == request.PreviousSurname &&
y.Sex == request.Sex &&
y.DateOfBirth == request.DateOfBirth &&
y.Nationality.Id == request.NationalityId &&
y.HasDisability == request.HasDisability &&
y.DisabilityDescription == request.DisabilityDescription &&
y.NINumber == request.NINumber &&
y.PassportNumber == request.PassportNumber &&
y.PPSNumber == request.PPSNumber &&
y.WorkVisaNumber == request.WorkVisaNumber &&
y.WorkVisaExpirationDate == request.WorkVisaExpirationDate &&
y.DrivingLicenseNumber == request.DrivingLicenseNumber &&
y.DrivingLicenseExpirationDate == request.DrivingLicenseExpirationDate &&
y.HasCompanyVehicle == request.HasCompanyVehicle &&
y.CompanyVehicleRegistration == request.CompanyVehicleRegistration &&
y.CompanyVehicleType.Id == request.CompanyVehicleTypeId &&
y.Site.Id == request.SiteId &&
y.JobTitle == request.JobTitle &&
y.EmploymentStatus.Id == request.EmploymentStatusId &&
y.ContactDetails.First().Address1 == request.Address1 &&
y.ContactDetails.First().Address2 == request.Address2 &&
y.ContactDetails.First().Address3 == request.Address3 &&
y.ContactDetails.First().County == request.County &&
y.ContactDetails.First().PostCode == request.Postcode &&
y.ContactDetails.First().Country.Id == request.CountryId &&
y.ContactDetails.First().Telephone1 == request.Telephone &&
y.ContactDetails.First().Telephone2 == request.Mobile &&
y.ContactDetails.First().Email == request.Email;
}
public void AddEmployee(AddEmployeeRequest emp)
{
}
public AddEmployeeResponse Add(AddEmployeeRequest request)
{
_log.Add(request);
try
{
var user = _userForAuditingRepository.GetById(request.UserId);
var employeeParameters = GetAddingEmployeeParameters(request);
var employee = Employee.Create(employeeParameters, user);
var contactDetailsParameters = GetEmployeeContactDetailParameters(request);
var contactDetails = EmployeeContactDetail.Create(contactDetailsParameters, user, employee);
employee.AddContactDetails(contactDetails);
_employeeRepository.SaveOrUpdate(employee);
return new AddEmployeeResponse
{
Success = true,
EmployeeId = employee.Id
};
}
catch (InvalidAddUpdateEmployeeContactDetailsParameters ex)
{
return new AddEmployeeResponse
{
Success = false,
EmployeeId = Guid.Empty,
Errors = ex.Errors
};
}
catch (Exception ex)
{
_log.Add(ex);
throw;
}
}
public AddUpdateEmployeeParameters Map(AddEmployeeRequest request)
{
var employeeParameters = CreateEmployeeParameters(request);
return employeeParameters;
}
public IActionResult AddEmployee(AddEmployeeRequest data)
{
return(Ok(repository.AddEmployee(data)));
}
public virtual bool AddEmployee([Validate] AddEmployeeRequest request)
{
//TODO: Impliment Logic
return(true);
}
public Task <IActionResult> AddEmployee([FromBody] AddEmployeeRequest request)
{
return(this.HandleRequest <AddEmployeeRequest, AddEmployeeResponse>(request));
}
public async Task <BaseResponse> Add(AddEmployeeRequest request)
=> await ExecutePostAsync <BaseResponse, AddEmployeeRequest>("api/employee/add", request);
