public ActionResult Create(CreateJobViewModel model)
{
if (ModelState.IsValid)
{
try
{
JobModel job = _mapper.Map <JobModel>(model);
job.Description = job.Description.Replace(System.Environment.NewLine, "<br />");
job.RecruterId = _usermanager.GetUserId(User);
_context.jobs.Add(job);
var result = _context.SaveChanges();
if (result == 1)
{
return(RedirectToAction("Index"));
}
}
catch {
ModelState.AddModelError("Error", "Unexpected Error.");
}
}
ViewBag.Categories = Categories;
return(View(model));
}
public string CreateRecurringJob(CreateJobViewModel newJob)
{//string id_repository, string nombre_job, string fecha_inicio, string cron_expression, string fecha = null, string set = null
string guidAdded;
Object newCreateRecuringJob = new
{
id_repository = newJob.IdRepository.ToString(),
set = newJob.Set,
codigo_objeto = newJob.CodigoObjeto,
nombre_job = newJob.Nombre_job,
cron_expression = newJob.CronExpression
};
string stringData = JsonConvert.SerializeObject(newCreateRecuringJob);
string uriParams = stringData.Replace(':', '=').Replace(',', '&').Replace("\"", "").Replace("{", "").Replace("}", "").Replace("null", "");
if (newJob.FechaIinicio.HasValue)
{
uriParams += $"&fecha_inicio={newJob.FechaIinicio.Value.ToString("dd/MM/yyyy HH:mm")}";
}
if (newJob.FechaFrom.HasValue)
{
uriParams += $"&fecha={newJob.FechaFrom.Value.ToString("dd/MM/yyyy HH:mm")}";
}
string result = _serviceApi.CallPostApi($"{ _urlRecurringJobApi}?{uriParams}", null);
guidAdded = JsonConvert.DeserializeObject <string>(result);
return(guidAdded);
}
public CreateJobControl(CreateJobViewModel viewModel)
{
InitializeComponent();
this.viewModel = viewModel;
this.DataContext = viewModel;
}
public ActionResult Create(CreateJobViewModel model)
{
try
{
if (ModelState.IsValid)
{
var errors = _jobValidatorService.ValidateJob(model);
if (ResolveErrors(errors))
{
return(View(model));
}
_jobService.CreateJob(model.Name, model.DoAfter);
}
else
{
return(View(model));
}
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
// POST : SQLJobs/Create but no to entity db, create to SQL server
public IActionResult CreateJob(CreateJobViewModel job)
{
if (ModelState.IsValid)
{
int frequency = 0; //days of week in sql agent jobs are handled by a single integer, need to parse selected days and generate that number
foreach (string s in job.SelectedDays)
{
frequency += int.Parse(s);
}
AM_SqlServer.Models.WAMSQLJob wsj = new AM_SqlServer.Models.WAMSQLJob();
wsj.Name = job.Name;
wsj.Description = job.Description;
wsj.OriginatingServer = job.Server;
wsj.ScheduleName = job.ScheduleName;
wsj.ScheduleFrequencyInterval = frequency;
wsj.ScheduleFrequencyRecurrenceFactor = 1;
wsj.ScheduleFrequencyType = FrequencyTypes.Weekly;
wsj.ScheduleActiveStartTimeOfDay = TimeSpan.Parse(job.RunTime);
wsj.JobStepName = job.StepName;
wsj.JobStepCommand = job.Command;
//AM_SqlServer.SqlServerManager ssm = new AM_SqlServer.SqlServerManager();
_ssm.CreateJob(wsj);
}
return(RedirectToAction("Index"));
}
public async Task <JobsDto> CreateJobSetup(CreateJobViewModel createJob)
{
var job = new Jobs(createJob);
job.Company = await _companyRepository.Get(createJob.CompanyId);
if (createJob.Employees.Count > 0)
{
foreach (var employeeId in createJob.Employees)
{
Employee employee = await _employeeRepository.Get(employeeId);
job.JobsEmployees.Add(new JobsEmployee()
{
JobsId = job.Id, EmployeeId = employeeId, Employee = employee
});
}
}
var createdJob = await _jobsRepository.Create(job);
var jobToView = _mapper.Map <Jobs, JobsDto>(createdJob);
return(jobToView);
}
public void CreateJob(CreateJobViewModel model)
{
Job createdJob = new Job()
{
Name = model.Title,
Description = model.Description,
ProjectId = model.ProjectId,
DateOfPost = model.PostedTime,
Location = model.Location,
TypeOfWork = model.TypeOfWork,
Experience = model.Level,
};
var skills = model.Skills;
foreach (var skill in skills)
{
var skillDB = Database.Skills.GetAll().FirstOrDefault(s => s.Name == skill);
if (skillDB == null)
{
skillDB = Database.Skills.Add(new Skill {
Name = skill, Description = null
});
}
createdJob.JobSkills.Add(new JobSkill {
Skill = skillDB, Job = createdJob
});
}
Database.Jobs.Add(createdJob);
Database.Save();
}
public async Task <IActionResult> CreateJob(CreateJobViewModel model, string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
if (ModelState.IsValid)
{
var user = await GetCurrentUserAsync();
if (user == null)
{
return(RedirectToAction("Index", "Home"));
}
if (!user.EmailConfirmed)
{
return(RedirectToAction("Index", "Manage"));
}
var userId = user?.Id;
var j = new Job {
Title = model.Title, Description = model.Description, Price = model.Price, DateCreated = DateTime.Now, DateExpire = DateTime.Now.AddDays(10), Status = "1", ApplicationUser = _users.GetById(userId), RequiredSkills = model.RequiredSkills
};
_jobs.Add(j);
return(RedirectToAction("Detail", new { id = j.Id }));
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <IActionResult> Put(string id, [FromBody] CreateJobViewModel request)
{
try
{
Job updatedJob = _jobManager.UpdateJob(id, request, applicationUser);
var result = await base.PutEntity(id, updatedJob);
if (request.EndTime != null)
{
_jobManager.UpdateAutomationAverages(updatedJob.Id);
}
//send SignalR notification to all connected client and update IntegrationEvents
await _hub.Clients.All.SendAsync("sendjobnotification", string.Format("Job id {0} updated.", updatedJob.Id));
await _webhookPublisher.PublishAsync("Jobs.JobUpdated", updatedJob.Id.ToString()).ConfigureAwait(false);
return(result);
}
catch (Exception ex)
{
return(ex.GetActionResult());
}
}
// GET: Jobs/Create
public ActionResult Create()
{
CreateJobViewModel tempVM = new CreateJobViewModel();
tempVM.Company = repo.Companies().Select(c => new SelectListItem
{
Text = c.Name,
Value = c.Id.ToString()
});
return View(tempVM);
}
public async Task <IActionResult> Post([FromBody] CreateJobViewModel request)
{
if (request == null)
{
ModelState.AddModelError("Save", "No data passed");
return(BadRequest(ModelState));
}
Guid entityId = Guid.NewGuid();
if (request.Id == null || !request.Id.HasValue || request.Id.Equals(Guid.Empty))
{
request.Id = entityId;
}
try
{
Job job = request.Map(request); //assign request to job entity
Automation automation = automationRepo.GetOne(job.AutomationId ?? Guid.Empty);
if (automation == null) //no automation was found
{
ModelState.AddModelError("Save", "No automation was found for the specified automation id");
return(NotFound(ModelState));
}
AutomationVersion automationVersion = automationVersionRepo.Find(null, q => q.AutomationId == automation.Id).Items?.FirstOrDefault();
job.AutomationVersion = automationVersion.VersionNumber;
job.AutomationVersionId = automationVersion.Id;
foreach (var parameter in request.JobParameters ?? Enumerable.Empty <JobParameter>())
{
parameter.JobId = entityId;
parameter.CreatedBy = applicationUser?.UserName;
parameter.CreatedOn = DateTime.UtcNow;
parameter.Id = Guid.NewGuid();
jobParameterRepo.Add(parameter);
}
//send SignalR notification to all connected clients
await _hub.Clients.All.SendAsync("botnewjobnotification", request.AgentId.ToString());
await _hub.Clients.All.SendAsync("sendjobnotification", "New Job added.");
await _hub.Clients.All.SendAsync("broadcastnewjobs", Tuple.Create(request.Id, request.AgentId, request.AutomationId));
await webhookPublisher.PublishAsync("Jobs.NewJobCreated", job.Id.ToString()).ConfigureAwait(false);
return(await base.PostEntity(job));
}
catch (Exception ex)
{
return(ex.GetActionResult());
}
}
public async Task <IActionResult> CreateJob()
{
var schedules = await _adminService.GetJobSchedules();
var model = new CreateJobViewModel
{
Schedules = _mapper.Map <List <ScheduleTypeViewModel> >(schedules)
};
return(View(model));
}
public async Task AddNewJob()
{
// Arrange
Guid jobId = new Guid("52464bcd-2fc9-41ad-8e55-5559516468fe");
Guid companyId = new Guid("9721601d-6a2b-4a76-ae24-cd7948f498b5");
Guid employee1Id = new Guid("6bf5d345-a7ac-41a6-bd72-940741eebca6");
Guid employee2Id = new Guid("fd0a2732-f21d-4d40-adb6-ce0a5069b3fe");
List <Guid> EmployeeList = new List <Guid>()
{
employee1Id, employee2Id
};
var company = new Company {
Id = companyId, Name = "CompanyTest"
};
var employee1 = new Employee {
Id = employee1Id, FirstName = "employee1"
};
var employee2 = new Employee {
Id = employee2Id, FirstName = "employee2"
};
var createJob = new CreateJobViewModel {
CompanyId = companyId, Address = "123 street", Employees = EmployeeList
};
var job = new Jobs(createJob)
{
Id = jobId
};
job.JobsEmployees.Add(new JobsEmployee()
{
JobsId = job.Id, EmployeeId = employee1.Id
});
job.JobsEmployees.Add(new JobsEmployee()
{
JobsId = job.Id, EmployeeId = employee2.Id
});
var mockJobsRepository = new Mock <IJobsRepository>();
///mockJobsRepository.Setup(repo => repo.CreateJobSetup(createJob))
//.ReturnsAsync(new JobsViewModel());
// Act
//var resultFromJobCreate = await mockJobsRepository.Object.CreateJobSetup(createJob);
// Assert
//Assert.NotNull(resultFromJobCreate);
//Assert.IsType<JobsViewModel>(resultFromJobCreate);
//Assert.Equal(companyId, resultFromJobCreate.CompanyId);
// Assert.Equal(2, resultFromJobCreate.JobsEmployees.Count);
}
public async Task <IActionResult> Create([Bind("Id,Title,Location,Status,SalaryRange,Notes")] Job job)
{
CreateJobViewModel model = new CreateJobViewModel(_context);
if (ModelState.IsValid)
{
_context.Add(job);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(job));
}
/// <summary>
/// Crea una tarea de sincronización para un repositorio
/// </summary>
/// <param name="repositoryId">Identificador del repositorio</param>
/// <returns></returns>
public IActionResult Syncro(Guid repositoryId)
{
CreateJobViewModel jobModel = new CreateJobViewModel()
{
IdRepository = repositoryId
};
string id = _serviceApi.CreateJob(jobModel);
resultCreated item = new resultCreated()
{
Id = id
};
return(View("Created", item));
}
public async Task <IActionResult> CreateJob(CreateJobViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var createModel = _mapper.Map <JobServiceModel>(model);
createModel.ScheduleType = await _adminService.GetJobSchedule(model.ScheduleId);
await _adminService.CreateJob(createModel);
return(RedirectToAction(nameof(Jobs)));
}
/// <summary>
/// Devuelve la página de creación de una tarea con el idetificador del repositorio asociado
/// </summary>
/// <param name="IdRepository">Identificador del repositorio</param>
/// <returns></returns>
public IActionResult Create(Guid?IdRepository = null)
{
if (IdRepository.HasValue)
{
CreateJobViewModel createJobViewModel = new CreateJobViewModel()
{
IdRepository = IdRepository.Value
};
return(View(createJobViewModel));
}
else
{
return(View());
}
}
public Jobs(CreateJobViewModel src)
{
JobsEmployees = new List <JobsEmployee>();
DateOfJob = src.DateOfJob;
Address = src.Address;
Contact = src.Contact;
PhoneNumber = src.PhoneNumber;
NumberOfPositions = src.NumberOfPositions;
Positions = src.Positions;
CompanyId = src.CompanyId;
IsJobComplete = false;
DateOfJob = src.DateOfJob.ToUniversalTime();
//EmployeeIds = src.Employees;
//JobsEmployees = src.JobsEmployees;
}
public ResponseMessage CreateJob([FromBody] CreateJobViewModel job)
{
if (ModelState.IsValid)
{
_jobService.CreateJob(job);
return(new ResponseMessage {
IsSuccess = true
});
}
else
{
return(new ResponseMessage {
IsSuccess = false, Message = "Model is not valid"
});
}
}
public async Task <ActionResult> CreateJob(CreateJobViewModel model)
{
try
{
var modelDTO = _mapper.Map <CreateJobViewModel, JobDTO>(model);
var user = await _userService.FindUserByEmail(User.Identity.Name);
await _jobService.AddJob(modelDTO, user);
return(RedirectToAction("MyJobs"));
}
catch
{
return(View());
}
}
public IActionResult Create(CreateJobViewModel jobModel)
{
if (jobModel.IdRepository.Equals(Guid.Empty))
{
ModelState.AddModelError("IdRepository", "id del repositorio no válido");
}
if ((jobModel.Nombre_job != null && jobModel.CronExpression == null) || (jobModel.CronExpression != null && jobModel.Nombre_job == null))
{
ModelState.AddModelError("Nombre_job", "faltan datos para crear un job recurrente");
}
else if (!string.IsNullOrEmpty(jobModel.Nombre_job) && !string.IsNullOrEmpty(jobModel.CronExpression))
{
var correct = CrontabSchedule.TryParse(jobModel.CronExpression);
if (correct == null)
{
ModelState.AddModelError("CronExpression", "expresión del cron inválida");
}
}
if (!ModelState.IsValid)
{
return(View("Create", jobModel));
}
else
{
if (jobModel.Nombre_job != null)
{
_serviceApi.CreateRecurringJob(jobModel);
resultCreated item = new resultCreated()
{
Id = jobModel.Nombre_job
};
return(RedirectToAction("Details", "RepositoryConfig", new { id = jobModel.IdRepository }));
}
else
{
string id = _serviceApi.CreateJob(jobModel);
resultCreated item = new resultCreated()
{
Id = id
};
return(RedirectToAction("Details", "RepositoryConfig", new { id = jobModel.IdRepository }));
}
}
}
public Job UpdateJob(string jobId, CreateJobViewModel request, ApplicationUser applicationUser)
{
Guid entityId = new Guid(jobId);
var existingJob = _repo.GetOne(entityId);
if (existingJob == null)
{
throw new EntityDoesNotExistException("Unable to find a job for the specified id");
}
Automation automation = _automationRepo.GetOne(existingJob.AutomationId ?? Guid.Empty);
if (automation == null) //no automation was found
{
throw new EntityDoesNotExistException("No automation was found for the specified automation id");
}
AutomationVersion automationVersion = _automationVersionRepo.Find(null, q => q.AutomationId == automation.Id).Items?.FirstOrDefault();
existingJob.AutomationVersion = automationVersion.VersionNumber;
existingJob.AutomationVersionId = automationVersion.Id;
existingJob.AgentId = request.AgentId;
existingJob.AgentGroupId = request.AgentGroupId;
existingJob.StartTime = request.StartTime;
existingJob.EndTime = request.EndTime;
existingJob.ExecutionTimeInMinutes = (existingJob.EndTime.Value - existingJob.StartTime).Value.TotalMinutes;
existingJob.DequeueTime = request.DequeueTime;
existingJob.AutomationId = request.AutomationId;
existingJob.JobStatus = request.JobStatus;
existingJob.Message = request.Message;
existingJob.IsSuccessful = request.IsSuccessful;
UpdateJobParameters(request.JobParameters, existingJob.Id);
if (request.EndTime != null)
{
UpdateAutomationAverages(existingJob.Id);
}
return(existingJob);
}
public ActionResult Create(CreateJobViewModel createJobViewModel, int customerId, int carId)
{
var currentUser = manager.FindById(User.Identity.GetUserId());
var customer = customersRepo.GetCustomerById(customerId);
var car = carsRepo.GetCarById(carId);
if (customer.User != currentUser || car.Customer != customer)
{
return(new HttpStatusCodeResult(HttpStatusCode.NotFound));
}
if (ModelState.IsValid)
{
var job = new Job();
createJobViewModel.SpareParts = createJobViewModel.SpareParts ?? new List <CreateSparePartViewModel>();
var spareParts = createJobViewModel.SpareParts.Select(sp =>
new SparePart()
{
Name = sp.Name,
Code = sp.Code,
Price = sp.Price,
Quantity = sp.Quantity,
Supplier = suppliersRepo.GetSupplierById(sp.Suppliers.SelectedSupplierId),
Job = job
}).ToList();
job.Car = car;
job.Customer = customer;
job.User = currentUser;
job.Mileage = createJobViewModel.Mileage;
job.Description = createJobViewModel.Description;
job.DateStarted = DateTime.Now;
job.LastModified = DateTime.Now;
job.IsFinished = false;
job.IsPaid = false;
job.SpareParts = spareParts;
jobsRepo.InsertJob(job);
jobsRepo.Save();
return(RedirectToAction("Index"));
}
return(View(createJobViewModel));
}
public async Task <Jobs> CreateJob()
{
Guid jobId = new Guid("52464bcd-2fc9-41ad-8e55-5559516468fe");
Guid companyId = new Guid("9721601d-6a2b-4a76-ae24-cd7948f498b5");
Guid employee1Id = new Guid("6bf5d345-a7ac-41a6-bd72-940741eebca6");
Guid employee2Id = new Guid("fd0a2732-f21d-4d40-adb6-ce0a5069b3fe");
List <Guid> EmployeeList = new List <Guid>()
{
employee1Id, employee2Id
};
var company = new Company {
Id = companyId, Name = "CompanyTest"
};
var employee1 = new Employee {
Id = employee1Id, FirstName = "employee1"
};
var employee2 = new Employee {
Id = employee2Id, FirstName = "employee2"
};
var createJob = new CreateJobViewModel {
CompanyId = companyId, Address = "123 street", NumberOfPositions = 0
};
var job = new Jobs(createJob)
{
Id = jobId
};
var mockJobsRepository = new Mock <IJobsRepository>();
mockJobsRepository.Setup(repo => repo.Create(job))
.ReturnsAsync(job);
var resultFromJobCreate = await mockJobsRepository.Object.Create(job);
return(resultFromJobCreate);
}
public IActionResult CreateJob(CreateJobViewModel model)
{
model.Job.Id = _context.Job.Count() + 1;
model.Job.Status = true;
model.Job.DeId = Int32.Parse(model.Department);
model.Job.ExId = Int32.Parse(model.ExperienceLevel);
model.Job.LId = Int32.Parse(model.Location);
model.Job.PostDate = DateTime.Now;
model.Job.ExpireDate = model.Job.PostDate.AddMonths(4);
_context.Job.Add(model.Job);
_context.SaveChanges();
foreach (var requirement in model.Requirements.Split(","))
{
_context.JobRequirement.Add(new JobRequirement
{
Id = _context.JobRequirement.Count() + 1,
JobId = model.Job.Id,
Skill = requirement.Trim()
});
}
_context.SaveChanges();
return(RedirectToAction("Jobs"));
}
public ActionResult Create(CreateJobViewModel jobModel)
{
if (!ModelState.IsValid)
{
ViewBag.Skills = GetCategories();
return(View(jobModel));
}
CreateJobParams jobParams = new CreateJobParams()
{
CustomerId = User.Identity.GetUserId(),
SkillsId = jobModel.SelectedSkills,
Title = jobModel.Title,
Description = jobModel.Description,
Price = jobModel.Price,
PriceDiscussed = jobModel.PriceDiscussed
};
_jobService.CreateJob(jobParams);
_commitProvider.SaveChanges();
return(RedirectToAction("Jobs", "Job"));
}
public ActionResult Create(CreateJobViewModel createJobViewModel)
{
if (!this.ModelState.IsValid)
{
var errorList = this.ModelState.Values.SelectMany(x => x.Errors).ToList();
return(this.Json(new { Url = String.Empty, Error = errorList }));
}
try
{
String selectedFolder = this.GetSelectedFolder(createJobViewModel.SelectedFolder, createJobViewModel.DocTypeCode);
var currentUser = this.userService.GetApplicationUser();
this.jobService.CreateJob(
(String)this.HttpContext.Session[SessionObject.Environment],
createJobViewModel.ManCo,
createJobViewModel.DocTypeCode,
createJobViewModel.DocTypeName,
createJobViewModel.ChosenFiles,
currentUser.Id,
createJobViewModel.AllowReprocessing,
createJobViewModel.AdditionalInfoRequired,
createJobViewModel.AdditionalSetupViewModel.AdditionalFileContent,
String.Format("{0}{1}{2}", createJobViewModel.AdditionalSetupViewModel.SortCodeOne, createJobViewModel.AdditionalSetupViewModel.SortCodeTwo, createJobViewModel.AdditionalSetupViewModel.SortCodeThree),
createJobViewModel.AdditionalSetupViewModel.AccountNumber,
createJobViewModel.AdditionalSetupViewModel.ChequeNumber,
selectedFolder);
var redirectUrl = Url.Action("Index", "Jobs");
return(this.Json(new { Url = redirectUrl, Error = string.Empty }));
}
catch (DocProcessingFileAlreadyProcessedException)
{
return(this.Json(new { Url = string.Empty, Error = "File has already been processed" }));
}
}
// GET: Customers/{customerId}/Cars/{carId}/Jobs/Create
public ActionResult Create(int customerId, int carId)
{
var createJobViewModel = new CreateJobViewModel();
var suppliersSelectList = GetUserSuppliers();
// TODO: Dynamically resizable list of parts
createJobViewModel.SpareParts = new List <CreateSparePartViewModel>()
{
new CreateSparePartViewModel()
{
Suppliers = new UserSuppliersViewModel()
{
UserSuppliers = suppliersSelectList,
SelectedSupplierId = int.Parse(suppliersSelectList.FirstOrDefault().Value)
}
},
new CreateSparePartViewModel()
{
Suppliers = new UserSuppliersViewModel()
{
UserSuppliers = suppliersSelectList,
SelectedSupplierId = int.Parse(suppliersSelectList.FirstOrDefault().Value)
}
},
new CreateSparePartViewModel()
{
Suppliers = new UserSuppliersViewModel()
{
UserSuppliers = suppliersSelectList,
SelectedSupplierId = int.Parse(suppliersSelectList.FirstOrDefault().Value)
}
},
};
return(View(createJobViewModel));
}
// GET: Jobs/Create
public IActionResult Create()
{
CreateJobViewModel model = new CreateJobViewModel(_context);
return(View(model));
}
// GET: SQLJobs/Create
public IActionResult Create()
{
CreateJobViewModel cjvm = new CreateJobViewModel();
return(View(cjvm));
}
public async Task <IActionResult> Put(string id, [FromBody] CreateJobViewModel request)
{
try
{
Guid entityId = new Guid(id);
var existingJob = repository.GetOne(entityId);
if (existingJob == null)
{
return(NotFound("Unable to find a Job for the specified ID"));
}
Automation automation = automationRepo.GetOne(existingJob.AutomationId ?? Guid.Empty);
if (automation == null) //no automation was found
{
ModelState.AddModelError("Save", "No automation was found for the specified automation ID");
return(NotFound(ModelState));
}
AutomationVersion automationVersion = automationVersionRepo.Find(null, q => q.AutomationId == automation.Id).Items?.FirstOrDefault();
existingJob.AutomationVersion = automationVersion.VersionNumber;
existingJob.AutomationVersionId = automationVersion.Id;
existingJob.AgentId = request.AgentId;
existingJob.StartTime = request.StartTime;
existingJob.EndTime = request.EndTime;
existingJob.ExecutionTimeInMinutes = (existingJob.EndTime.Value - existingJob.StartTime).Value.TotalMinutes;
existingJob.DequeueTime = request.DequeueTime;
existingJob.AutomationId = request.AutomationId;
existingJob.JobStatus = request.JobStatus;
existingJob.Message = request.Message;
existingJob.IsSuccessful = request.IsSuccessful;
var response = await base.PutEntity(id, existingJob);
jobManager.DeleteExistingParameters(entityId);
var set = new HashSet <string>();
foreach (var parameter in request.JobParameters ?? Enumerable.Empty <JobParameter>())
{
if (!set.Add(parameter.Name))
{
ModelState.AddModelError("JobParameter", "JobParameter Name Already Exists");
return(BadRequest(ModelState));
}
parameter.JobId = entityId;
parameter.CreatedBy = applicationUser?.UserName;
parameter.CreatedOn = DateTime.UtcNow;
parameter.Id = Guid.NewGuid();
jobParameterRepo.Add(parameter);
}
if (request.EndTime != null)
{
jobManager.UpdateAutomationAverages(existingJob.Id);
}
//send SignalR notification to all connected clients
await webhookPublisher.PublishAsync("Jobs.JobUpdated", existingJob.Id.ToString()).ConfigureAwait(false);
await _hub.Clients.All.SendAsync("sendjobnotification", string.Format("Job id {0} updated.", existingJob.Id));
return(response);
}
catch (Exception ex)
{
ModelState.AddModelError("Job", ex.Message);
return(BadRequest(ModelState));
}
}
