public async Task <APIResponse> CreateJob(BaseJobModel model)
{
if (string.IsNullOrEmpty(model.Engineer))
{
return(new APIResponse(Errors.Job_EngineerField_Invalid));
}
if (model.Customer == null)
{
return(new APIResponse(Errors.Job_CustomerField_Invalid));
}
if (model.Customer.CustomerId == 0)
{
return(new APIResponse(Errors.Id_Invalid));
}
if (model.When.Date < DateTime.Now.Date)
{
return(new APIResponse(Errors.Date_Invalid));
}
var entity = new Job()
{
Engineer = model.Engineer,
When = model.When,
CustomerId = model.Customer.CustomerId
};
var result = await _repository.CreateJob(entity);
return(new APIResponse(Errors.Success, (int)HttpStatusCode.OK)
{
Result = result
});
}
public JobModel CreateJob(BaseJobModel model)
{
var addedJob = context.Jobs.Add(model.ToDbModel());
context.SaveChanges();
return(GetJob(addedJob.Entity.JobId));
}
public static Job ToDbModel(this BaseJobModel model)
{
return(new Job
{
Engineer = model.Engineer,
When = model.When,
CustomerId = model.CustomerId
});
}
public async Task <IActionResult> Create(BaseJobModel model)
{
var newJob = await _jobService.CreateJob(model);
if (newJob.Code != (int)Errors.Success)
{
return(Error(newJob.ErrorEnum));
}
return(Ok(newJob));
}
public IActionResult Create(BaseJobModel model)
{
if (model.When.Date < DateTime.Now.Date)
{
return(BadRequest("Date cannot be in the past"));
}
var job = jobService.CreateJob(model);
return(Created($"job/{job.JobId}", job));
}
public async Task <IActionResult> CreateAsync(BaseJobModel model)
{
if (model.When.Date < DateTime.Now.Date)
{
return(BadRequest("Date cannot be in the past"));
}
var job = await _jobService.CreateJobAsync(model);
return(Created($"job/{job.JobId}", job));
}
public IActionResult Create(BaseJobModel model)
{
//not one to amend existing code that is outside the scope of the requirement but I would use FluentValidation here
if (model.When.Date < DateTime.Now.Date)
{
return(BadRequest("Date cannot be in the past"));
}
var job = jobService.CreateJob(model);
return(Created($"job/{job.JobId}", job));
}
public JobModel CreateJob(BaseJobModel model)
{
var addedJob = context.Jobs.Add(new Job
{
Engineer = model.Engineer,
When = model.When,
CustomerId = model.Customer.CustomerId
});
context.SaveChanges();
return(GetJob(addedJob.Entity.JobId));
}
public JobModel CreateJob(BaseJobModel model)
{
var selectedCustomer = context.Customers.Find(model.CustomerId);
var addedJob = context.Jobs.Add(new Job
{
Engineer = model.Engineer,
When = model.When,
Customer = selectedCustomer
});
context.SaveChanges();
return(MapEntityToModel(addedJob.Entity));
}
public JobModel CreateJob(BaseJobModel model)
{
var addedJob = context.Jobs.Add(new Job
{
Engineer = model.Engineer,
When = model.When
});
context.SaveChanges();
return(new JobModel
{
JobId = addedJob.Entity.JobId,
Engineer = addedJob.Entity.Engineer,
When = addedJob.Entity.When
});
}
public void CreateJob_Should_Create_A_Job()
{
//Arrange
var model = new BaseJobModel
{
Engineer = "Tim",
When = DateTime.Now,
CustomerId = 3
};
//Act
var job = _sut.CreateJob(model);
//Assert
Assert.IsInstanceOf <JobModel>(job);
Assert.AreEqual("Tim", job.Engineer);
Assert.AreEqual(3, _context.Jobs.Count());
}
public JobModel CreateJob(BaseJobModel model)
{
var addedJob = context.Jobs.Add(new Job
{
CustomerId = Convert.ToInt32(model.Customer),
Engineer = model.Engineer,
When = model.When
});
context.SaveChanges();
return(new JobModel
{
JobId = addedJob.Entity.JobId,
Engineer = addedJob.Entity.Engineer,
When = addedJob.Entity.When
});
}
public async Task <JobModel> CreateJobAsync(BaseJobModel model)
{
var addedJob = await _context.Jobs.AddAsync(new Job
{
Engineer = model.Engineer,
CustomerId = model.Customer.Id,
When = model.When
});
await _context.SaveChangesAsync();
return(new JobModel
{
JobId = addedJob.Entity.JobId,
Engineer = addedJob.Entity.Engineer,
Customer = model.Customer,
When = addedJob.Entity.When
});
}
public JobModel CreateJob(BaseJobModel model)
{
var addedJob = context.Jobs.Add(new Job
{
Engineer = model.Engineer,
When = model.When,
CustomerId = model.CustomerId
});
context.SaveChanges();
return(context.Jobs.Where(x => x.JobId == addedJob.Entity.JobId).Select(x => new JobModel
{
JobId = x.JobId,
Engineer = x.Engineer,
When = x.When,
Customer = x.Customer.ToModel()
}).SingleOrDefault());
}
public JobModel CreateJob([FromBody] BaseJobModel model)
{
var addedJob = context.Jobs.Add(new Job
{
Engineer = model.Engineer,
When = model.When,
CustomerId = string.IsNullOrEmpty(model.CustomerId) ? (int?)null : int.Parse(model.CustomerId)
});
context.SaveChanges();
return(new JobModel
{
JobId = addedJob.Entity.JobId,
Engineer = addedJob.Entity.Engineer,
When = addedJob.Entity.When,
CustomerId = addedJob.Entity.CustomerId
});
}
public IActionResult Create(BaseJobModel model)
{
if (model.When.Date < DateTime.Now.Date)
{
return(BadRequest("Date cannot be in the past"));
}
try
{
var job = jobService.CreateJob(model);
return(Created($"job/{job.JobId}", job));
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
return(StatusCode(500, ex.Message));
}
}
