public async Task <IActionResult> Edit(int id, [Bind("TaskTypeMappingId,TaskTypeId,MappingType,MappingName,SourceSystemType,SourceType,TargetSystemType,TargetType,TaskDatafactoryIr,TaskTypeJson,ActiveYn,TaskMasterJsonSchema,TaskInstanceJsonSchema")] TaskTypeMapping taskTypeMapping)
{
if (id != taskTypeMapping.TaskTypeMappingId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(taskTypeMapping);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TaskTypeMappingExists(taskTypeMapping.TaskTypeMappingId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(IndexDataTable)));
}
ViewData["TaskTypeId"] = new SelectList(_context.TaskType.OrderBy(x => x.TaskTypeName), "TaskTypeId", "TaskTypeName", taskTypeMapping.TaskTypeId);
return(View(taskTypeMapping));
}
public async Task <IActionResult> Edit(int id, [Bind("SubjectAreaFormId,FormJson,FormStatus,UpdatedBy,ValidFrom,ValidTo,Revision")] SubjectAreaForm subjectAreaForm)
{
if (id != subjectAreaForm.SubjectAreaFormId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(subjectAreaForm);
if (!await CanPerformCurrentActionOnRecord(subjectAreaForm))
{
return(new ForbidResult());
}
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SubjectAreaFormExists(subjectAreaForm.SubjectAreaFormId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(IndexDataTable)));
}
return(View(subjectAreaForm));
}
public async Task <IActionResult> Edit(int id, [Bind("TaskExecutionType,TaskTypeId,TaskTypeName,TaskTypeJson,ActiveYn")] TaskType taskType)
{
if (id != taskType.TaskTypeId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(taskType);
if (!await CanPerformCurrentActionOnRecord(taskType))
{
return(new ForbidResult());
}
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TaskTypeExists(taskType.TaskTypeId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(IndexDataTable)));
}
return(View(taskType));
}
public async Task <IActionResult> Edit(long id, [Bind("SystemId,SystemName,SystemType,SystemDescription,SystemServer,SystemAuthType,SystemUserName,SystemSecretName,SystemKeyVaultBaseUrl,SystemJson,ActiveYn")] SourceAndTargetSystems sourceAndTargetSystems)
{
if (id != sourceAndTargetSystems.SystemId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(sourceAndTargetSystems);
if (!await CanPerformCurrentActionOnRecord(sourceAndTargetSystems))
{
return(new ForbidResult());
}
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SourceAndTargetSystemsExists(sourceAndTargetSystems.SystemId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(IndexDataTable)));
}
return(View(sourceAndTargetSystems));
}
public async Task <IActionResult> Edit(int id, [Bind("SubjectAreaId,SubjectAreaName,ActiveYn,SubjectAreaFormId,DefaultTargetSchema,UpdatedBy")] SubjectArea subjectArea)
{
if (id != subjectArea.SubjectAreaId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(subjectArea);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SubjectAreaExists(subjectArea.SubjectAreaId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(subjectArea));
}
public async Task <IActionResult> Edit(long id, [Bind("AncestorTaskGroupId,DescendantTaskGroupId,DependencyType")] TaskGroupDependency taskGroupDependency)
{
if (id != taskGroupDependency.AncestorTaskGroupId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(taskGroupDependency);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TaskGroupDependencyExists(taskGroupDependency.AncestorTaskGroupId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(IndexDataTable)));
}
ViewData["AncestorTaskGroupId"] = new SelectList(_context.TaskGroup.OrderBy(x => x.TaskGroupName), "TaskGroupId", "TaskGroupName", taskGroupDependency.AncestorTaskGroupId);
ViewData["DescendantTaskGroupId"] = new SelectList(_context.TaskGroup.OrderBy(x => x.TaskGroupName), "TaskGroupId", "TaskGroupName", taskGroupDependency.DescendantTaskGroupId);
return(View(taskGroupDependency));
}
public async Task <IActionResult> Edit(int id, [Bind("TaskRunnerId,TaskRunnerName,ActiveYn,Status,MaxConcurrentTasks")] FrameworkTaskRunner frameworkTaskRunner)
{
if (id != frameworkTaskRunner.TaskRunnerId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(frameworkTaskRunner);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!FrameworkTaskRunnerExists(frameworkTaskRunner.TaskRunnerId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(IndexDataTable)));
}
return(View(frameworkTaskRunner));
}
public async Task <IActionResult> Edit(long id, [Bind("ScheduleMasterId,ScheduleDesciption,ScheduleCronExpression,ActiveYn")] ScheduleMaster scheduleMaster)
{
if (id != scheduleMaster.ScheduleMasterId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(scheduleMaster);
if (!await CanPerformCurrentActionOnRecord(scheduleMaster))
{
return(new ForbidResult());
}
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ScheduleMasterExists(scheduleMaster.ScheduleMasterId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(IndexDataTable)));
}
return(View(scheduleMaster));
}
public async Task <IActionResult> Edit(string id, [Bind("SystemType,JsonSchema")] SourceAndTargetSystemsJsonSchema sourceAndTargetSystemsJsonSchema)
{
if (id != sourceAndTargetSystemsJsonSchema.SystemType)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(sourceAndTargetSystemsJsonSchema);
if (!await CanPerformCurrentActionOnRecord(sourceAndTargetSystemsJsonSchema))
{
return(new ForbidResult());
}
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SourceAndTargetSystemsJsonSchemaExists(sourceAndTargetSystemsJsonSchema.SystemType))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(IndexDataTable)));
}
return(View(sourceAndTargetSystemsJsonSchema));
}
public async Task <IActionResult> Edit(long id, [Bind("TaskMasterId,TaskMasterName,TaskTypeId,TaskGroupId,ScheduleMasterId,SourceSystemId,TargetSystemId,DegreeOfCopyParallelism,AllowMultipleActiveInstances,TaskDatafactoryIr,TaskMasterJson,ActiveYn,DependencyChainTag,DataFactoryId")] TaskMaster taskMaster)
{
if (id != taskMaster.TaskMasterId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(taskMaster);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TaskMasterExists(taskMaster.TaskMasterId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(IndexDataTable)));
}
ViewData["ScheduleMasterId"] = new SelectList(_context.ScheduleMaster.OrderBy(x => x.ScheduleDesciption), "ScheduleMasterId", "ScheduleDesciption", taskMaster.ScheduleMasterId);
ViewData["SourceSystemId"] = new SelectList(_context.SourceAndTargetSystems.OrderBy(x => x.SystemName), "SystemId", "SystemName", taskMaster.SourceSystemId);
ViewData["TargetSystemId"] = new SelectList(_context.SourceAndTargetSystems.OrderBy(x => x.SystemName), "SystemId", "SystemName", taskMaster.TargetSystemId);
ViewData["TaskGroupId"] = new SelectList(_context.TaskGroup.OrderBy(x => x.TaskGroupName), "TaskGroupId", "TaskGroupName", taskMaster.TaskGroupId);
ViewData["TaskTypeId"] = new SelectList(_context.TaskType.OrderBy(x => x.TaskTypeName), "TaskTypeId", "TaskTypeName", taskMaster.TaskTypeId);
return(View(taskMaster));
}
public async Task <IActionResult> Edit(long id, [Bind("Id,Name,ResourceGroup,SubscriptionUid,DefaultKeyVaultUrl,LogAnalyticsWorkspaceId")] DataFactory dataFactory)
{
if (id != dataFactory.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(dataFactory);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DataFactoryExists(dataFactory.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(IndexDataTable)));
}
return(View(dataFactory));
}
public async Task <IActionResult> Edit(long id, [Bind("LastExecutionStatus,TaskInstanceId,TaskMasterId,ScheduleInstanceId,ExecutionUid,Adfpipeline,TaskInstanceJson,LastExecutionComment,NumberOfRetries,ActiveYn,CreatedOn,TaskRunnerId,UpdatedOn")] TaskInstance taskInstance)
{
if (id != taskInstance.TaskInstanceId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(taskInstance);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TaskInstanceExists(taskInstance.TaskInstanceId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(IndexDataTable)));
}
ViewData["ScheduleInstanceId"] = new SelectList(_context.ScheduleInstance.OrderBy(x => x.ScheduleInstanceId), "ScheduleInstanceId", "ScheduleInstanceId", taskInstance.ScheduleInstanceId);
ViewData["TaskMasterId"] = new SelectList(_context.TaskMaster.OrderBy(x => x.TaskMasterName), "TaskMasterId", "TaskMasterName", taskInstance.TaskMasterId);
return(View(taskInstance));
}
public async Task <IActionResult> Edit(long id, [Bind("TaskMasterId,TaskMasterWaterMarkColumn,TaskMasterWaterMarkColumnType,TaskMasterWaterMarkDateTime,TaskMasterWaterMarkBigInt,TaskWaterMarkJson,ActiveYn,UpdatedOn")] TaskMasterWaterMark taskMasterWaterMark)
{
if (id != taskMasterWaterMark.TaskMasterId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(taskMasterWaterMark);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TaskMasterWaterMarkExists(taskMasterWaterMark.TaskMasterId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(IndexDataTable)));
}
ViewData["TaskMasterId"] = new SelectList(_context.TaskMaster.OrderBy(x => x.TaskMasterName), "TaskMasterId", "TaskMasterName", taskMasterWaterMark.TaskMasterId);
return(View(taskMasterWaterMark));
}
public async Task <IActionResult> Edit(long id, [Bind("ScheduleInstanceId,ScheduleMasterId,ScheduledDateUtc,ScheduledDateTimeOffset,ActiveYn")] ScheduleInstance scheduleInstance)
{
if (id != scheduleInstance.ScheduleInstanceId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(scheduleInstance);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ScheduleInstanceExists(scheduleInstance.ScheduleInstanceId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(IndexDataTable)));
}
ViewData["ScheduleMasterId"] = new SelectList(_context.ScheduleMaster.OrderBy(x => x.ScheduleDesciption), "ScheduleMasterId", "ScheduleDesciption", scheduleInstance.ScheduleMasterId);
return(View(scheduleInstance));
}
public async Task <IActionResult> Edit(long id, [Bind("TaskGroupId,TaskGroupName,TaskGroupPriority,TaskGroupConcurrency,TaskGroupJson,SubjectAreaId,ActiveYn")] TaskGroup taskGroup)
{
if (id != taskGroup.TaskGroupId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(taskGroup);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TaskGroupExists(taskGroup.TaskGroupId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(IndexDataTable)));
}
ViewData["SubjectAreaId"] = new SelectList(_context.SubjectArea.OrderBy(x => x.SubjectAreaId), "SubjectAreaId", "SubjectAreaId", taskGroup.SubjectAreaId);
return(View(taskGroup));
}
public async Task <IActionResult> Edit(int id, [Bind("SubjectAreaId,SubjectAreaName,ActiveYn,SubjectAreaFormId,DefaultTargetSchema,UpdatedBy")] SubjectArea subjectArea)
{
if (id != subjectArea.SubjectAreaId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(subjectArea);
if (!await CanPerformCurrentActionOnRecord(subjectArea))
{
return(new ForbidResult());
}
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SubjectAreaExists(subjectArea.SubjectAreaId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(IndexDataTable)));
}
ViewData["SubjectAreaFormId"] = new SelectList(_context.SubjectAreaForm.OrderBy(x => x.SubjectAreaFormId), "SubjectAreaFormId", "SubjectAreaFormId", subjectArea.SubjectAreaFormId);
return(View(subjectArea));
}