public HrUnitOfWork(IContextFactory <DbContext> contextFactory) // , int companyId, string culture
: base(contextFactory)
{
// Initialize
CompanyRepository = new CompanyRepository(Context); // , companyId, culture
PagesRepository = new PagesRepository(Context);
MenuRepository = new MenuRepository(Context);
PageEditorRepository = new PageEditorRepository(Context);
LookUpRepository = new LookUpRepoitory(Context);
CompanyStructureRepository = new CompanyStructureRepository(Context);
JobRepository = new JobRepository(Context);
PeopleRepository = new PeopleRepository(Context);
PositionRepository = new PositionRepository(Context);
BudgetRepository = new BudgetRepository(Context);
QualificationRepository = new QualificationRepository(Context);
LeaveRepository = new LeaveRepository(Context);
EmployeeRepository = new EmployeeRepository(Context);
CustodyRepository = new CustodyRepository(Context);
TrainingRepository = new TrainingRepository(Context);
BenefitsRepository = new BenefitsRepository(Context);
AudiTrialRepository = new AudiTrialRepository(Context);
TerminationRepository = new TerminationRepository(Context);
DisciplineRepository = new DisciplineRepository(Context);
CheckListRepository = new CheckListRepository(Context);
ComplaintRepository = new ComplaintRepository(Context);
MessageRepository = new MessageRepository(Context);
MedicalRepository = new MedicalRepository(Context);
HrLettersRepository = new HRLettersRepository(Context);
PayrollRepository = new PayrollRepository(Context);
SalaryDesignRepository = new SalaryDesignRepository(Context);
NotificationRepository = new NotificationRepository(Context);
MissionRepository = new MissionRepository(Context);
MeetingRepository = new MeetingRepository(Context);
}
public void DeleteComplaint(int id)
{
//unitOfWork.StartTransaction();
ComplaintRepository repo = new ComplaintRepository(unitOfWork);
ComplaintModel complaintModel = new ComplaintModel();
Complaint complaint = new Complaint();
complaint = repo.GetAll().Where(x => x.ComplaintId == id).SingleOrDefault();
repo.Delete(x => x.ComplaintId == complaint.ComplaintId);
//unitOfWork.Commit();
}
public ComplaintModel GetComplaintByComplaintId(int complaintId)
{
//unitOfWork.StartTransaction();
ComplaintRepository repo = new ComplaintRepository(unitOfWork);
ComplaintModel complaintModel = new ComplaintModel();
Complaint complaint = new Complaint();
complaint = repo.GetAll().Where(x => x.ComplaintId == complaintId).FirstOrDefault();
//unitOfWork.Commit();
AutoMapper.Mapper.Map(complaint, complaintModel);
return complaintModel;
}
public ComplaintTests()
{
/* Create a Memory Database instead of using the SQL */
var optionsBuilder = new DbContextOptionsBuilder <AppDBContext>()
.UseInMemoryDatabase(databaseName: "temp")
.Options;
Context = new AppDBContext(optionsBuilder);
ComplaintRepo = new ComplaintRepository(this.Context);
CommentRepo = new CommentRepository(this.Context);
}
public RoomController(IConfiguration configuration)
{
roomRepository = new RoomRepository(configuration);
equipmentRepository = new EquipmentRepository(configuration);
buildingRepository = new BuildingRepository(configuration);
accountRepository = new AccountRepository(configuration);
complaintRepository = new ComplaintRepository(configuration);
departmentRepository = new DepartmentRepository(configuration);
maintenanceRepository = new MaintenanceRepository(configuration);
surveyRepository = new SurveyRepository(configuration);
historyRepository = new HistoryRepository(configuration);
}
public void DeleteComplaintbyEmployeeId(string id)
{
//unitOfWork.StartTransaction();
ComplaintRepository repo = new ComplaintRepository(unitOfWork);
ComplaintModel complaintModel = new ComplaintModel();
List<Complaint> complaints = new List<Complaint>();
complaints = repo.GetAll().Where(x => x.EmployeeId == id).ToList();
complaints.ForEach(x =>
{
repo.Delete(y => y.ComplaintId == x.ComplaintId);
});
//unitOfWork.Commit();
}
public IHttpActionResult SaveComplaint(Complaint C)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
else
{
IComplaint obj = new ComplaintRepository();
obj.SaveComplaint(C);
return(Ok());
}
}
public SolutionProvidedController()
{
_complaint = new ComplaintRepository();
_vComplaint = new vComplaintRepository();
_complaintActivity = new ComplaintActivityRepository();
_vComplaintActivity = new vComplaintActivityRepository();
_complaintType = new ComplaintTypeRepository();
_slnStatus = new SolutionStatusRepository();
_user = new ASPNetUserRepository();
_complaintStatus = new ComplaintStatusRepository();
_help = new Helper();
}
public ControllerFixture()
{
Mapper.Initialize(cfg =>
{
cfg.AddProfile <DeploymentProfile>();
cfg.AddProfile <TripProfile>();
cfg.AddProfile <CollisionProfile>();
cfg.AddProfile <ComplaintProfile>();
});
DbContextOptions <ScootertownDbContext> options;
var builder = new DbContextOptionsBuilder <ScootertownDbContext>();
builder.UseInMemoryDatabase("API");
options = builder.Options;
var context = new ScootertownDbContext(options, new VehicleStoreOptions());
var cache = new Mock <IMemoryCache>();
var entry = new Mock <ICacheEntry>();
int expectedKey = 1;
object expectedValue = expectedKey;
cache
.Setup(x => x.TryGetValue(It.IsAny <object>(), out expectedValue))
.Returns(true);
cache
.Setup(m => m.CreateEntry(It.IsAny <object>()))
.Returns(entry.Object);
DeploymentRepository = new DeploymentRepository(context);
TripRepository = new TripRepository(context);
CollisionRepository = new CollisionRepository(context);
ComplaintRepository = new ComplaintRepository(context);
CalendarRepository = new CalendarRepository(context, cache.Object);
CompanyRepository = new CompanyRepository(context, cache.Object);
NeighborhoodRepository = new NeighborhoodRepository(context, cache.Object);
PatternAreaRepository = new PatternAreaRepository(context, cache.Object);
PaymentTypeRepository = new PaymentTypeRepository(context, cache.Object);
PlacementReasonRepository = new PlacementReasonRepository(context, cache.Object);
RemovalReasonRepository = new RemovalReasonRepository(context, cache.Object);
StatusRepository = new StatusRepository(context, cache.Object);
VehicleRepository = new VehicleRepository(context, cache.Object);
VehicleTypeRepository = new VehicleTypeRepository(context, cache.Object);
Context = context;
}
public ComplaintControllerTests(ControllerFixture fixture)
{
Context = fixture.Context;
ComplaintRepository = fixture.ComplaintRepository;
CalendarRepository = fixture.CalendarRepository;
CompanyRepository = fixture.CompanyRepository;
VehicleRepository = fixture.VehicleRepository;
VehicleTypeRepository = fixture.VehicleTypeRepository;
StatusRepository = fixture.StatusRepository;
TripRepository = fixture.TripRepository;
Controller = new ComplaintController(
new Mock <ILogger <ComplaintController> >().Object,
ComplaintRepository,
CalendarRepository,
CompanyRepository,
VehicleRepository
);
}
public ComplaintModel GetComplaintDetailByComplaintId(int compliantId)
{
//unitOfWork.StartTransaction();
ComplaintRepository repo = new ComplaintRepository(unitOfWork);
ComplaintModel complaintModelList = new ComplaintModel();
Complaint complaintlist = new Complaint();
var complaints = (from data in db.Complaint
join e in db.Employee on data.EmployeeId equals e.EmployeeId
join cl in db.Client on data.ClientId equals cl.ClientId
join ul in db.UserLocation on cl.ClientId equals ul.UserId
join u in db.Users on cl.ClientId equals u.Id
join sp in db.ServiceProvider on data.ServiceProviderId equals sp.ServiceProviderId
join j in db.Job on data.JobId equals j.JobId
select new
{
ComplainId = data.ComplaintId,
Description = data.Description,
ServiceProviderId = data.ServiceProviderId,
EmployeeName = e.FirstName,
ClientName = cl.FirstName,
ClientAddress = ul.Address,
ClientPhoneNumber = u.PhoneNumber,
ServiceProviderName = sp.CompanyName,
Status = data.Status,
jobDescription = j.Description,
JobAddress = j.JobAddress
}).Where(x => x.ComplainId == compliantId).FirstOrDefault();
ComplaintModel model = new ComplaintModel();
model.ComplaintId = complaints.ComplainId;
model.Description = complaints.Description;
model.EmployeeName = complaints.EmployeeName;
model.ClientName = complaints.ClientName;
model.ServiceProviderName = complaints.ServiceProviderName;
model.Status = complaints.Status;
model.JobDescription = complaints.jobDescription;
model.JobAddress = complaints.JobAddress;
model.ClientAddress = complaints.ClientAddress;
model.ClientPhoneNumber = complaints.ClientPhoneNumber;
//unitOfWork.Commit();
return model;
}
public List<ComplaintModel> GetComplaints()
{
//unitOfWork.StartTransaction();
ComplaintRepository repo = new ComplaintRepository(unitOfWork);
List<ComplaintModel> complaintModel = new List<ComplaintModel>();
List<Complaint> complaint = new List<Complaint>();
complaint = repo.GetAll().ToList();
AutoMapper.Mapper.Map(complaint, complaintModel);
//var complaints = (from data in db.Complaint
// join e in db.Employee on data.EmployeeId equals e.EmployeeId into es
// from e in es.DefaultIfEmpty()
// join cl in db.Client on data.ClientId equals cl.ClientId into cls
// from cl in cls.DefaultIfEmpty()
// join ul in db.UserLocation on cl.ClientId equals ul.UserId into uls
// from ul in uls.DefaultIfEmpty()
// join u in db.Users on cl.ClientId equals u.Id into us
// from u in us.DefaultIfEmpty()
// join sp in db.ServiceProvider on data.ServiceProviderId equals sp.ServiceProviderId into sps
// from sp in sps.DefaultIfEmpty()
// join j in db.Job on data.JobId equals j.JobId into js
// from j in js.DefaultIfEmpty()
// select new
// {
// ComplainId = data.ComplaintId,
// Description = data.Description,
// ServiceProviderId = data.ServiceProviderId,
// EmployeeName = e.FirstName,
// ClientName = cl.FirstName,
// ServiceProviderName = sp.CompanyName,
// Status = data.Status,
// jobDescription = j.Description,
// ClientAddress = ul.Address,
// JobAddress = j.JobAddress,
// ClientPhoneNumber = u.PhoneNumber,
// }).OrderByDescending(x=>x.ComplainId).ToList();
//foreach (var item in complaints)
//{
// ComplaintModel model = new ComplaintModel();
// model.ComplaintId = item.ComplainId;
// model.Description = item.Description;
// model.EmployeeName = item.EmployeeName;
// model.ClientName = item.ClientName;
// model.ServiceProviderName = item.ServiceProviderName;
// model.Status = item.Status;
// model.JobDescription = item.jobDescription;
// model.JobAddress = item.JobAddress;
// model.ClientAddress = item.ClientAddress;
// model.ClientPhoneNumber = item.ClientPhoneNumber;
// complaintModel.Add(model);
//}
//unitOfWork.Commit();
return complaintModel;
}
public void UpdateComplaintStatus([FromUri] int ComplaintID, [FromUri] int StatusID)
{
IComplaint obj = new ComplaintRepository();
obj.UpdateComplaintStatus(ComplaintID, StatusID);
}
public List <Complaint> LoadComplaintsWithDetails()
{
IComplaint obj = new ComplaintRepository();
return(obj.LoadComplaintsWithDetails());
}
public List <Complaint> LoadComplaintWithDetailsByProfileID(int ProfileID)
{
IComplaint obj = new ComplaintRepository();
return(obj.LoadComplaintWithDetailsByProfileID(ProfileID));
}
public ComplaintModel UpdateComplaint(ComplaintModel model)
{
//unitOfWork.StartTransaction();
ComplaintRepository repo = new ComplaintRepository(unitOfWork);
ComplaintModel complaintModel = new ComplaintModel();
Complaint complaint = new Complaint();
complaint = repo.GetAll().Where(x => x.ComplaintId == model.ComplaintId).FirstOrDefault();
AutoMapper.Mapper.Map(model, complaint);
repo.Update(complaint);
//unitOfWork.Commit();
return complaintModel;
}
public ComplaintModel InsertComplaint(ComplaintModel model)
{
//unitOfWork.StartTransaction();
ComplaintRepository repo = new ComplaintRepository(unitOfWork);
Complaint complaint = new Complaint();
AutoMapper.Mapper.Map(model, complaint);
repo.Insert(complaint);
AutoMapper.Mapper.Map(complaint,model);
//unitOfWork.Commit();
return model;
}
public Complaint LoadComplaintByComplaintID(int Complaintid)
{
IComplaint obj = new ComplaintRepository();
return(obj.LoadComplaintByComplaintID(Complaintid));
}
