public IHttpActionResult Post([FromBody] WorkerDTO worker)
{
try
{
if (ModelState.IsValid && worker != null)
{
OperationDetails result = _workerService.AddWorker(worker);
if (result.Succedeed)
{
return(Ok());
}
else
{
return(BadRequest(result.Message));
}
}
else
{
return(BadRequest(ModelState.Values.FirstOrDefault().Errors.FirstOrDefault().ErrorMessage));
}
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public void validateHasAllFields(ClientDTO client = null, WorkerDTO worker = null)
{
if (client.Email == null || client.Password == null || client.RepeatedPassword == null)
{
throw new InsufficientDataException("No se han suministrado todos los datos requeridos para el registro del cliente.");
}
}
public static bool addWorker(WorkerDTO s)
{
using (libraryEntities db = new libraryEntities())
{
string mailBody = $" Hi " + s.name + " You have successfully joined our team \n " +
$"your password is " + s.password + " \n Thanks ";
if (db.Workers.FirstOrDefault(x => x.idWorker == s.idWorker) != null)
{
s.status = true;
updateWorker(s);
}
else
{
db.Workers.Add(Converters.WorkerConverter.ConvertWorkerDTOToDAL(s));
//bool b = SendMail(s.address, "ברוכים הבאים לצוות עובדנו", mailBody);
}
try
{
db.SaveChanges();
bool b = SendMail(s.address, "ברוכים הבאים לצוות עובדנו", mailBody);
return(true);
}
catch (Exception e)
{
return(false);
}
}
}
public void AddWorker(WorkerDTO workerDto)
{
Worker w = Mapper.Map <WorkerDTO, Worker>(workerDto);
Database.Workers.Create(w);
Database.Save();
}
public void AddWorker_ExistEmail_FalseResult()
{
// arrange
var workers = new List <Worker>();
workers.Add(new Worker {
FirstName = "", SurName = "", Id = 1, Email = "*****@*****.**", Telephone = ""
});
var workerManagerMock = new Mock <IWorkerManager>();
workerManagerMock.Setup(m => m.Get()).Returns(workers);
var unitOfWorkMock = new Mock <IUnitOfWork>();
unitOfWorkMock.Setup(m => m.WorkerManager).Returns(workerManagerMock.Object);
var clockMock = new Mock <IClock>();
var workerService = new WorkerService(unitOfWorkMock.Object, clockMock.Object);
var model = new WorkerDTO
{
Name = "Ivan",
SurName = "Ivanov",
Telephone = "+375251234567",
Email = "*****@*****.**"
};
// act
var actual = workerService.AddWorker(model);
// assert
actual.Should().NotBeNull();
actual.Succedeed.Should().BeFalse();
}
public JsonResult SaveWorker(WorkerDTO Worker, HttpPostedFileBase file = null)
{
if (file != null && file.ContentLength > 0)
{
string path = Path.Combine(Server.MapPath("~/SystemData/WorkerImages"), Worker.NIC + Path.GetExtension(file.FileName));
if (!Directory.Exists(Server.MapPath("~/SystemData/WorkerImages")))
{
Directory.CreateDirectory(Server.MapPath("~/SystemData/WorkerImages"));
}
file.SaveAs(path);
Bitmap img = new Bitmap(file.InputStream);
var imageHeight = Convert.ToInt32(((350.0 / img.Width) * img.Height));
Stream imagestream = UserController.GetResizedImageStream(file.InputStream, 0, 0, 160, 160, 350, imageHeight);
Image image = Image.FromStream(imagestream);
path = Path.Combine(Server.MapPath("~/SystemData/WorkerImages"), Worker.NIC + "-thumb" + Path.GetExtension(file.FileName));
image.Save(path, System.Drawing.Imaging.ImageFormat.Jpeg);
Worker.Image = "/SystemData/WorkerImages/" + Worker.NIC + Path.GetExtension(file.FileName);
}
else
{
Worker.Image = "/Images/blank-profile-hi.png";
}
int result = BusinessLayer.BusinessStore.Worker.SaveNewWorker(Worker);
return(Json(result, JsonRequestBehavior.AllowGet));
}
public async Task <bool> UpDateAsync(WorkerDTO workerDTO)
{
var worker = _mapper.Map <WorkerDTO, Worker>(workerDTO);
var result = await _workerRepository.Update(worker);
return(result);
}
public List <WorkerDTO> GetWorkers()
{
var entities = Database.Workers.GetAll().ToList();
var workersDTO = new List <WorkerDTO>();
foreach (var item in entities)
{
EmployeeService employeeService = new EmployeeService();
var employee = Database.Employees.Find(item.EmployeeId);
var employeeDTO = employeeService.CreateEmployeeDTO(employee);
var project = Database.Projects.Find(item.ProjectId);
var ProjectDTO = CreateProjectDTO(project);
var worker = new WorkerDTO
{
Id = item.Id,
Employee = employeeDTO,
Project = ProjectDTO
};
workersDTO.Add(worker);
}
return(workersDTO);
}
public IHttpActionResult PostWorker(WorkerDTO worker)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
int workerId = WorkerService.RegisterNewWorker(worker);
JsonMessager message = new JsonMessager(workerId.ToString());
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.OK, message)));
}
catch (InsufficientDataException ex)
{
return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex.Message)));
}
catch (PasswordsDoNotMatchException ex)
{
return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex.Message)));
}
catch (WrongDataTypeException ex)
{
return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex.Message)));
}
catch (UserAlreadyRegisteredException ex)
{
return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex.Message)));
}
}
public static WorkerDTO GetWorkerByID(int WorkerID)
{
try
{
var WorkerFromDatabase = db.Manali_Worker_GetWorkerByID(WorkerID).FirstOrDefault();
if (WorkerFromDatabase != null)
{
WorkerDTO worker = new WorkerDTO
{
WorkerID = WorkerFromDatabase.WorkerID,
Name = WorkerFromDatabase.Name,
NIC = WorkerFromDatabase.NIC,
Mobile = WorkerFromDatabase.Mobile,
Address = WorkerFromDatabase.Address,
Designation = WorkerFromDatabase.Designation,
Image = WorkerFromDatabase.Image
};
return(worker);
}
}
catch (Exception ex)
{
}
return(null);
}
public void SerializerExtensionTestInitialize()
{
jsonObject = new Worker
{
Id = "1",
NameOrDescription = "Luiz Arthur P. Mussa",
AssociationType = "Teste",
BirthDate = DateTime.Now,
BranchLine = "0800787878",
BusinessTitle = "Application Architect",
DeptId = "1",
LbcId = "1",
Login = "******",
Applications = new List <SsoApplication>
{
new SsoApplication {
Id = "PORTARIA",
HomeUrl = "www.dev-intra.soa.alcoa.com/portaria",
Mnemonic = "PORTARIA",
Profiles = new List <SsoProfile>
{
new SsoProfile {
Id = "1",
ApplicationId = "PORTARIA",
IsPublic = "N",
NameOrDescription = "Teste",
}
}
}
}
};
xmlObject = jsonObject.Map <Worker, WorkerXML>();
datacontractObject = jsonObject.Map <Worker, WorkerDTO>();
}
public static int InsertNewWorker(WorkerDTO WorkerDTO)
{
try
{
int?NewWorkerID = 0;
db.Manali_Worker_CreateWorker(
WorkerDTO.Name,
WorkerDTO.NIC,
WorkerDTO.Mobile,
WorkerDTO.Address,
WorkerDTO.Image,
WorkerDTO.Designation,
ref NewWorkerID);
if (NewWorkerID != null && NewWorkerID != 0)
{
return(NewWorkerID.Value);
}
else
{
return(0);
}
}
catch (Exception ex)
{
}
return(0);
}
public static List <WorkerDTO> GetAllWorkers()
{
try
{
List <WorkerDTO> lstWorkers = new List <WorkerDTO>();
var lstWorkersFromDatabase = db.Manali_Worker_GetAllWorkers();
foreach (var item in lstWorkersFromDatabase)
{
WorkerDTO worker = new WorkerDTO
{
WorkerID = item.WorkerID,
Name = item.Name,
NIC = item.NIC,
Mobile = item.Mobile,
Address = item.Address,
Designation = item.Designation,
Image = item.Image
};
lstWorkers.Add(worker);
}
return(lstWorkers);
}
catch (Exception ex)
{
}
return(null);
}
public void validatePasswordsMatch(ClientDTO client = null, WorkerDTO worker = null)
{
if (worker.Password != worker.RepeatedPassword)
{
throw new PasswordsDoNotMatchException("La contraseña de verificacion no coincide con la original.");
}
}
public static bool updateWorker(WorkerDTO a)
{
using (libraryEntities db = new libraryEntities())
{
Worker au = db.Workers.First(x => x.idWorker == a.idWorker);
au.name = a.name;
au.status = a.status;
au.address = a.address;
au.phone = a.phone;
au.password = a.password;
au.typeWork = a.typeWork;
try
{
db.SaveChanges();
bool b = SendMail(a.name, "ברוכים הבאים לצוות עובדנו", "פרטיך עודכנו בהצלחה במערכת ");
return(true);
}
catch (Exception e)
{
return(false);
}
}
}
public void AddWorker_TrueWorkerModel_CreateWorker()
{
// arrange
var workers = new List <Worker>();
var workerManagerMock = new Mock <IWorkerManager>();
workerManagerMock.Setup(m => m.Get()).Returns(workers);
workerManagerMock.Setup(s => s.Create(It.IsAny <Worker>())).Verifiable();
var unitOfWorkMock = new Mock <IUnitOfWork>();
var clockMock = new Mock <IClock>();
unitOfWorkMock.Setup(m => m.WorkerManager).Returns(workerManagerMock.Object);
var workerService = new WorkerService(unitOfWorkMock.Object, clockMock.Object);
var model = new WorkerDTO
{
Name = "Ivan",
SurName = "Ivanov",
Telephone = "+375251234567",
Email = "*****@*****.**"
};
// act
var actual = workerService.AddWorker(model);
// assert
workerManagerMock.VerifyAll();
actual.Should().NotBeNull();
actual.Succedeed.Should().BeTrue();
}
public void ValidateGetAvailableDaysCount_1()
{
IWorkerService service = new WorkerService(new UnitOfWork());
WorkerDTO workerToAdd = new WorkerDTO();
workerToAdd.Email = "*****@*****.**";
workerToAdd.Password = "******";
workerToAdd.RepeatedPassword = "******";
workerToAdd.IsWalker = false;
workerToAdd.Disponibility = new List <DayOfWeek>()
{
0
};
workerToAdd.Latitude = "validLength";
workerToAdd.Longitude = "validLength";
int newId = service.RegisterNewWorker(workerToAdd);
try
{
int count = service.GetWorkerAvailableInformsCount(newId);
}
catch (WorkerHasNotBookingsToInformException ex)
{
Assert.IsInstanceOfType(ex, typeof(WorkerHasNotBookingsToInformException));
service.DeleteWorker(newId);
}
}
public void ValidateGetReviews_1()
{
IWorkerService service = new WorkerService(new UnitOfWork());
WorkerDTO workerToAdd = new WorkerDTO();
workerToAdd.Email = "*****@*****.**";
workerToAdd.Password = "******";
workerToAdd.RepeatedPassword = "******";
workerToAdd.IsWalker = false;
workerToAdd.Disponibility = new List <DayOfWeek>()
{
0
};
workerToAdd.Latitude = "validLength";
workerToAdd.Longitude = "validLength";
int newId = service.RegisterNewWorker(workerToAdd);
try
{
IEnumerable <ReviewToReturn> reviews = service.GetWorkerReviews(newId);
}
catch (NoReviewsForWorkerException ex)
{
Assert.IsInstanceOfType(ex, typeof(NoReviewsForWorkerException));
service.DeleteWorker(newId);
}
}
public void ValidateRegisterWorker_9()
{
IWorkerService service = new WorkerService(new UnitOfWork());
WorkerDTO workerToAdd = new WorkerDTO();
workerToAdd.Email = "*****@*****.**";
workerToAdd.Password = "******";
workerToAdd.RepeatedPassword = "******";
workerToAdd.IsWalker = false;
workerToAdd.Disponibility = new List <DayOfWeek>()
{
0
};
workerToAdd.Latitude = "validLength";
workerToAdd.Longitude = "validLength";
int newId = service.RegisterNewWorker(workerToAdd);
WorkerBundle workerToUpdate = new WorkerBundle();
workerToUpdate.Password = "******";
workerToUpdate.PhoneNumber = "222333444";
try
{
service.UpdateWorkerInfo(newId, workerToUpdate);
}
catch (Exception ex)
{
Assert.Fail();
}
service.DeleteWorker(newId);
}
private Worker convertDTO(WorkerDTO newWorker)
{
Worker worker = new Worker(newWorker.Email, newWorker.Password, newWorker.IsWalker,
convertToWeekDayList(newWorker.Disponibility), 0, "", "");
worker.Location = new Location(newWorker.Latitude, newWorker.Longitude);
return(worker);
}
public void AddWorker(WorkerDTO workerDTO)
{
var worker = _workerMapper.GetWorkersFromWorkerDTO(workerDTO);
_workerRepository.AddWorkers(worker);
workerDTO.Id = worker.WorkerId;
}
public ActionResult Create()
{
WorkerDTO worker = new WorkerDTO();
ViewBag.Types = GetWorkerTypesToSelect(0);
return(PartialView("_Edit", worker));
}
public AddWorkerPageViewModel(INavigationService navigationService, IEventAggregator ea,
IWorkerDataAccessService dataAccessService) : base(navigationService)
{
Title = "Add a new worker";
_ea = ea;
NewWorker = new WorkerDTO();
_workerDAService = dataAccessService;
}
public static WorkerDTO GetQuotationsMarketedByWorker(int WorkerID)
{
try
{
var WorkerFromDatabase = db.Manali_Worker_GetWorkerByID(WorkerID).FirstOrDefault();
if (WorkerFromDatabase != null)
{
WorkerDTO worker = new WorkerDTO
{
WorkerID = WorkerFromDatabase.WorkerID,
Name = WorkerFromDatabase.Name,
NIC = WorkerFromDatabase.NIC,
Mobile = WorkerFromDatabase.Mobile,
Address = WorkerFromDatabase.Address,
Designation = WorkerFromDatabase.Designation,
Image = WorkerFromDatabase.Image,
ListOfMarketedQuotations = new List <QuotationDTO>(),
ListOfSuccessfullQuotations = new List <QuotationDTO>()
};
List <QuotationDTO> lstQuotationsMarketedByWorker = new List <QuotationDTO>();
var QuotationsMarketedByWorkerFromDatabase = db.Manali_Worker_GetAllQuotationsByWorkerID(WorkerID);
foreach (var item in QuotationsMarketedByWorkerFromDatabase)
{
QuotationDTO quotation = new QuotationDTO
{
QuotationID = item.QuotationID,
DateOfWedding = item.DateOfWedding.Value,
NameOfBride = item.Bride,
BrideAddress = item.BrideAddress,
BrideEmail = item.BrideEmail,
BrideContactNo = item.BrideContactNo,
DateOfHomecoming = item.DateOfHomecoming.Value,
NameOfGroom = item.Groom,
GroomAddress = item.GroomAddress,
GroomContactNo = item.GroomContactNo
};
worker.ListOfMarketedQuotations.Add(quotation);
if (item.EventID != null)
{
worker.ListOfSuccessfullQuotations.Add(quotation);
}
}
return(worker);
}
}
catch (Exception ex)
{
}
return(null);
}
public void ValidateRegisterWorker_8()
{
IWorkerService service = new WorkerService(new UnitOfWork());
WorkerDTO workerToAdd = new WorkerDTO();
workerToAdd.Email = "validMailmail.com";
service.RegisterNewWorker(workerToAdd);
}
public static List <AppointmentDTO> GetAllAppointments()
{
try
{
List <AppointmentDTO> lstAppointment = new List <AppointmentDTO>();
var lstAppointmentsFromDB = db.Manali_Appointment_GetAllAppointments();
foreach (var item in lstAppointmentsFromDB)
{
QuotationDTO quotation = new QuotationDTO
{
QuotationID = item.QuotationID,
DateOfWedding = item.DateOfWedding.Value,
NameOfBride = item.Bride,
BrideAddress = item.BrideAddress,
BrideEmail = item.BrideEmail,
DateOfHomecoming = item.DateOfHomecoming.Value,
NameOfGroom = item.Groom,
GroomAddress = item.GroomAddress,
GroomContactNo = item.GroomContactNo,
createdDate = item.CreatedDate.Value
};
WorkerDTO worker = new WorkerDTO
{
WorkerID = item.WorkerID,
Name = item.Name,
NIC = item.NIC,
Mobile = item.Mobile,
Address = item.Address,
Image = item.Image,
Designation = item.Designation
};
AppointmentDTO appointment = new AppointmentDTO
{
AppointmentID = item.AppointmentID,
Quotation = quotation,
AppointmentDateTime = item.AppointmentDateTime.Value,
ResponsibleWorker = worker,
IsBrideVisited = item.IsBrideVisited.Value,
Duration = item.Duration.Value,
Notes = item.Notes,
Status = item.Status.Value
};
lstAppointment.Add(appointment);
}
return(lstAppointment);
}
catch (Exception ex)
{
}
return(null);
}
public ImplantationDTO()
{
Episode = new EpisodeEngineDTO();
WorkerType = new WorkerTypeEntity();
Worker = new WorkerDTO();
Team = new TeamEngineDTO();
Metric = new MetricEngineDTO();
Goal = new List <GoalEngineDTO>();
}
public async Task <IActionResult> Worker([FromBody] WorkerDTO workerDTO)
{
await _commandDispatcher.DispatchAsync(new AddWorker()
{
Worker = workerDTO
});
return(Ok());
}
public void UpdateWorker(WorkerDTO workerDTO)
{
IMapper mapper = new MapperConfiguration(cfg => cfg.CreateMap <WorkerDTO, Worker>()).CreateMapper();
Worker worker = unitOfWork.Workers.Get(workerDTO.Id);
worker = mapper.Map <WorkerDTO, Worker>(workerDTO);
unitOfWork.Workers.Update(worker);
unitOfWork.Save();
}
public ActionResult ChangePassword(int playerId)
{
WorkerDTO worker = WorkerRepository.Instance.GetDTOById(playerId);
//PlayerEngineDTO player = PlayerEngineService.Instance.GetById(playerId);
AccountHandler.ChangePassword(worker.Email, "Gamific123");
return(Json(new { ok = true }, JsonRequestBehavior.AllowGet));
}
