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