public async Task <ActionResult <JobResponseModel> > Schedule(JobCreateRequestModel model)
        {
            var services = await this.garageService.Services(model.DepartmentId);

            JobScheduleData scheduleJobModel = new JobScheduleData()
            {
                CreatedByEmployeeId  = this.currentEmployeeService.CurrentEmployeeId,
                CreateByEmployeeName = this.currentEmployeeService.EmployeeName,
                DeadLine             = DateTime.UtcNow,
                DepartmentId         = model.DepartmentId,
                PurchasedServices    = services.Where(x => model.PurchasedServices.Contains(x.Id)).Select(s => new PurchasedServiceModel()
                {
                    Name  = s.Name,
                    Id    = s.Id,
                    Price = s.Price,
                }),
                VehicleId = model.VehicleId,
            };

            JobResponseModel scheludeJob = await jobSchedulerService.Schedule(
                scheduleJobModel,
                this.currentEmployeeService.GarageRole.ToString(),
                this.currentEmployeeService.CurrentGarageId.ToString(),
                this.currentEmployeeService.CurrentEmployeeId.ToString(),
                this.currentEmployeeService.EmployeeName);

            return(Created(nameof(Schedule), scheludeJob));
        }
Ejemplo n.º 2
0
        public void TestBooleanFlagsFromJobStatus()
        {
            var status = new JobResponseModel {
                JobStatus = "Pending"
            };

            Assert.That(status.JobPending);
            Assert.That(!(status.JobCompletedOk || status.JobCompletedWithErrors || status.JobStarted || status.InvalidJob));

            status.JobStatus = "Started";
            Assert.That(status.JobStarted);
            Assert.That(!(status.JobCompletedOk || status.JobCompletedWithErrors || status.JobPending || status.InvalidJob));

            status.JobStatus = "CompletedOk";
            Assert.That(status.JobCompletedOk);
            Assert.That(!(status.JobStarted || status.JobCompletedWithErrors || status.JobPending || status.InvalidJob));

            status.JobStatus = "TransactionError";
            Assert.That(status.JobCompletedWithErrors);
            Assert.That(!(status.JobStarted || status.JobCompletedOk || status.JobPending || status.InvalidJob));

            status.JobStatus = "NotRegistered";
            Assert.That(status.InvalidJob);
            Assert.That(!(status.JobStarted || status.JobCompletedOk || status.JobPending || status.JobCompletedWithErrors));

            status.JobStatus = "Unknown";
            Assert.That(status.JobCompletedWithErrors);
            Assert.That(!(status.JobStarted || status.JobCompletedOk || status.JobPending || status.InvalidJob));
        }
        public async Task <JobResponseModel> Schedule(JobScheduleData model)
        {
            Job job = new Job()
            {
                CreatedDate          = DateTime.UtcNow,
                CreatedByEmployeeId  = model.CreatedByEmployeeId,
                CreateByEmployeeName = model.CreateByEmployeeName,
                DeadLine             = DateTime.UtcNow,
                DepartmentId         = model.DepartmentId,
                JobStatus            = JobStatus.Pending,
                VehicleId            = model.VehicleId,
            };

            job.PurchasedServices = model.PurchasedServices.Select(ps => new JobService()
            {
                Name      = ps.Name,
                Price     = ps.Price,
                ServiceId = ps.Id
            }).ToList();

            this.dbContext.Add(job);

            await this.dbContext.SaveChangesAsync();


            var scheduledJob = new JobResponseModel()
            {
                AssignedEmployeeId   = job.AssignedEmployeeId,
                CreatedByEmployeeId  = job.CreatedByEmployeeId,
                CreateByEmployeeName = job.CreateByEmployeeName,
                AssignedEmployeeName = job.AssignedEmployeeName,
                CreatedDate          = job.CreatedDate,
                DeadLine             = job.DeadLine,
                DepartmentId         = job.DepartmentId,
                FinishedDate         = job.FinishedDate,
                Id                = job.Id,
                JobStatus         = job.JobStatus,
                PurchasedServices = job.PurchasedServices.Select(s => new PurchasedServiceModel()
                {
                    Name  = s.Name,
                    Price = s.Price,
                    Id    = s.ServiceId,
                }),
                StratedDate = job.StratedDate,
                VehicleId   = job.VehicleId,
            };

            return(scheduledJob);
        }
Ejemplo n.º 4
0
        public async Task <ActionResult <JobResponseModel> > GetJob(int id)
        {
            var job = await _context.Jobs
                      .Include(p => p.Renter)
                      .Include(p => p.Freelancer)
                      .Include(p => p.Form)
                      .Include(p => p.Type)
                      .Include(p => p.JobSkills).ThenInclude(p => p.Skill)
                      .Include(p => p.S).ThenInclude(p => p.Service)
                      .Include(p => p.S).ThenInclude(p => p.Specialty)
                      .Include(p => p.Payform)
                      .Include(p => p.JobSkills).ThenInclude(p => p.Skill)
                      .Include(p => p.Province)
                      .SingleOrDefaultAsync(p => p.Id == id);

            if (job == null)
            {
                return(NotFound());
            }
            var jobresponse = new JobResponseModel(job);

            return(jobresponse);
        }