public void Add(TaskInput taskInput)
{
TodolistModel todolist = new TodolistModel();
todolist.EnrollmentDate = DateTime.Now;
todolist.TaskDescription = taskInput.TaskDescription;
_taskRepository.Add(todolist);
}
public AddTaskWindow(string boardId, string username)
{
InitializeComponent();
this.boardId = boardId;
this.username = username;
taskinput = new TaskInput();
this.DataContext = taskinput;
}
public void Edit(TaskInput taskInput)
{
TodolistModel todolistToUpdate = _taskRepository.Get(taskInput.TodolistId);
todolistToUpdate.TaskDescription = taskInput.TaskDescription;
todolistToUpdate.Approved = taskInput.Approved;
_taskRepository.Save();
}
/// <inheritdoc />
public ReturnCode Run()
{
TaskInput input = new TaskInput();
input.Target = m_Parameters.Target;
input.TypeDB = m_Parameters.ScriptInfo;
input.BuildCache = m_Parameters.UseCache ? m_Cache : null;
#if NONRECURSIVE_DEPENDENCY_DATA
input.NonRecursiveDependencies = m_Parameters.NonRecursiveDependencies;
#else
input.NonRecursiveDependencies = false;
#endif
input.Assets = m_Content.Assets;
input.ProgressTracker = m_Tracker;
input.DependencyUsageCache = m_DependencyData.DependencyUsageCache;
input.GlobalUsage = m_DependencyData.GlobalUsage;
input.Logger = m_Log;
foreach (SceneDependencyInfo sceneInfo in m_DependencyData.SceneInfo.Values)
{
input.GlobalUsage |= sceneInfo.globalUsage;
}
ReturnCode code = RunInternal(input, out TaskOutput output);
if (code == ReturnCode.Success)
{
foreach (AssetOutput o in output.AssetResults)
{
m_DependencyData.AssetInfo.Add(o.asset, o.assetInfo);
m_DependencyData.AssetUsage.Add(o.asset, o.usageTags);
if (o.spriteData != null)
{
if (m_SpriteData == null)
{
m_SpriteData = new BuildSpriteData();
}
m_SpriteData.ImporterData.Add(o.asset, o.spriteData);
}
if (!m_Parameters.DisableVisibleSubAssetRepresentations && o.extendedData != null)
{
if (m_ExtendedAssetData == null)
{
m_ExtendedAssetData = new BuildExtendedAssetData();
}
m_ExtendedAssetData.ExtendedData.Add(o.asset, o.extendedData);
}
if (o.objectTypes != null)
{
BuildCacheUtility.SetTypeForObjects(o.objectTypes);
}
}
}
return(code);
}
public TaskGeneratorResult GenerateTasks(string groupName, TaskInput defaultTask, PropertyInfo parent)
{
defaultTask.Type = "string";
return(new TaskGeneratorResult {
Inputs = new List <TaskInput> {
defaultTask
}
});
}
static void Main(string[] args)
{
TaskSolver ts = new TaskSolver(TaskInput.GetInput());
var result1 = ts.CountCanContain("shiny gold bag");
Console.WriteLine($"Result1 is {result1}");
var result2 = ts.CountBagsInside("shiny gold bag") - 1; //minus one for our gold bag, it should not be counted.
Console.WriteLine($"Result2 is {result2}");
}
static ArchiveWorkItem GetOrCreateWorkItem(TaskInput input, string bundleName, Dictionary <string, ArchiveWorkItem> bundleToWorkItem)
{
if (!bundleToWorkItem.TryGetValue(bundleName, out ArchiveWorkItem item))
{
item = new ArchiveWorkItem();
item.BundleName = bundleName;
item.Compression = input.GetCompressionForIdentifier(bundleName);
item.OutputFilePath = input.GetOutputFilePathForIdentifier(bundleName);
item.ResourceFiles = new List <ResourceFile>();
bundleToWorkItem[bundleName] = item;
}
return(item);
}
public override async Task <Int32Value> AddTask(TaskInput request, ServerCallContext context)
{
var taskId = await _dataAccess.AddTaskDataAccessAsync(request.ManagerId,
request.AssignedEmployee,
request.CreateDate.ToDateTime().ToLocalTime(),
request.Description,
request.FinalDate.ToDateTime().ToLocalTime(),
request.Priority,
request.Subject);
return(new Int32Value {
Value = taskId
});
}
/// <inheritdoc />
public ReturnCode Run()
{
TaskInput input = new TaskInput();
input.Target = m_Parameters.Target;
input.TypeDB = m_Parameters.ScriptInfo;
input.BuildCache = m_Parameters.UseCache ? m_Cache : null;
input.Assets = m_Content.Assets;
input.ProgressTracker = m_Tracker;
input.DependencyUsageCache = m_DependencyData.DependencyUsageCache;
input.GlobalUsage = m_DependencyData.GlobalUsage;
input.Logger = m_Log;
foreach (SceneDependencyInfo sceneInfo in m_DependencyData.SceneInfo.Values)
{
input.GlobalUsage |= sceneInfo.globalUsage;
}
ReturnCode code = RunInternal(input, out TaskOutput output);
if (code == ReturnCode.Success)
{
foreach (AssetOutput o in output.AssetResults)
{
m_DependencyData.AssetInfo.Add(o.asset, o.assetInfo);
m_DependencyData.AssetUsage.Add(o.asset, o.usageTags);
if (o.spriteData != null)
{
if (m_SpriteData == null)
{
m_SpriteData = new BuildSpriteData();
}
m_SpriteData.ImporterData.Add(o.asset, o.spriteData);
}
if (o.extendedData != null)
{
if (m_ExtendedAssetData == null)
{
m_ExtendedAssetData = new BuildExtendedAssetData();
}
m_ExtendedAssetData.ExtendedData.Add(o.asset, o.extendedData);
}
}
}
return(code);
}
/*
* Provides a TaskInputDto object of the logged in Patient for a particular date.
*/
public async Task <TaskInputDto> GetTaskInputByDate(DateTimeOffset date, string userName)
{
var patientDetails = lapbaseNewContext.Patient.Where(p => p.Username == userName).FirstOrDefault();
TaskInput taskInput = await lapbaseNewContext.TaskInput.Where(t =>
t.DateAssigned.Date.ToShortDateString().Equals(date.Date.ToShortDateString()) &&
t.PatientId.Equals(patientDetails.PatientCode) &&
t.OrganizationCode.Equals(patientDetails.OrganisationCode)
).FirstOrDefaultAsync();
if (taskInput == default)
{
return(new TaskInputDto(date));
}
return(new TaskInputDto(taskInput));
}
static Dictionary <string, ulong> CalculateHashFileOffsets(TaskInput input)
{
Dictionary <string, ulong> fileOffsets = new Dictionary <string, ulong>();
foreach (var pair in input.InternalFilenameToWriteResults)
{
foreach (ResourceFile serializedFile in pair.Value.resourceFiles)
{
if (!serializedFile.serializedFile)
{
continue;
}
ObjectSerializedInfo firstObject = pair.Value.serializedObjects.First(x => x.header.fileName == serializedFile.fileAlias);
fileOffsets[serializedFile.fileName] = firstObject.header.offset;
}
}
return(fileOffsets);
}
static List <ArchiveWorkItem> CreateWorkItems(TaskInput input)
{
using (input.Log.ScopedStep(LogLevel.Info, "CreateWorkItems"))
{
List <KeyValuePair <string, List <ResourceFile> > > bundleResources;
Dictionary <string, List <ResourceFile> > bundleToResources = new Dictionary <string, List <ResourceFile> >();
foreach (var pair in input.InternalFilenameToWriteResults)
{
string bundle = input.InternalFilenameToBundleName[pair.Key];
List <ResourceFile> resourceFiles;
bundleToResources.GetOrAdd(bundle, out resourceFiles);
resourceFiles.AddRange(pair.Value.resourceFiles);
}
#if UNITY_2019_3_OR_NEWER
foreach (var pair in input.InternalFilenameToAdditionalFiles)
{
List <ResourceFile> resourceFiles;
bundleToResources.GetOrAdd(pair.Key, out resourceFiles);
foreach (var file in pair.Value)
{
resourceFiles.Add(file);
input.InternalFilenameToBundleName[file.fileAlias] = pair.Key;
}
}
#endif
bundleResources = bundleToResources.ToList();
List <ArchiveWorkItem> allItems = bundleResources.Select((x, index) =>
new ArchiveWorkItem
{
Index = index,
BundleName = x.Key,
ResourceFiles = x.Value.ToArray(),
Compression = input.GetCompressionForIdentifier(x.Key),
OutputFilePath = input.GetOutputFilePathForIdentifier(x.Key)
}
).ToList();
return(allItems);
}
}
public async Task <IHttpActionResult> CreateTask([FromBody] TaskInput task)
{
try
{
var userId = GetUserIdFromRequest();
if (userId == null)
{
return(BadRequest("Invalid operation"));
}
var data = await _taskUseCase.Create((Guid)userId, task);
return(Created($"/tasks/{data.Id}", data));
}
catch (Exception e)
{
// returns a 500 Error
return(GetFormattedError("Could not create user tasks", e));
}
}
public async Task <IHttpActionResult> UpdateTask([FromBody] TaskInput task)
{
try
{
var userId = GetUserIdFromRequest();
if (userId == null)
{
return(BadRequest("Invalid operation"));
}
await _taskUseCase.Update((Guid)userId, task);
return(StatusCode(HttpStatusCode.NoContent));
}
catch (Exception e)
{
// returns a 500 Error
return(GetFormattedError("Could not create user tasks", e));
}
}
public async Task GetTaskInputByDate_WithUsedDate_ReturnsExistingTaskInputDto()
{
// Arrange
TaskInputService service = new TaskInputService(config, context);
TaskInput taskInput = context.TaskInput.Add(new TaskInput
{
Id = Guid.NewGuid(),
PatientId = patient.PatientCode,
OrganizationCode = patient.OrganisationCode,
DateAssigned = new DateTimeOffset(2019, 05, 05, 0, 0, 0, new TimeSpan())
}).Entity;
context.SaveChanges();
// Act
var result = await service.GetTaskInputByDate(new DateTimeOffset(2019, 05, 05, 0, 0, 0, new TimeSpan()), patient.Username);
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result.Id, Is.EqualTo(taskInput.Id));
}
static List <ArchiveWorkItem> CreateWorkItems(TaskInput input)
{
using (input.Log.ScopedStep(LogLevel.Info, "CreateWorkItems"))
{
Dictionary <string, ArchiveWorkItem> bundleNameToWorkItem = new Dictionary <string, ArchiveWorkItem>();
foreach (var pair in input.InternalFilenameToWriteResults)
{
string internalName = pair.Key;
string bundleName = input.InternalFilenameToBundleName[internalName];
ArchiveWorkItem item = GetOrCreateWorkItem(input, bundleName, bundleNameToWorkItem);
if (input.InternalFilenameToWriteMetaData.TryGetValue(pair.Key, out SerializedFileMetaData md))
{
item.SeriliazedFileMetaDatas.Add(md);
}
else
{
throw new Exception($"Archive {bundleName} with internal name {internalName} does not have associated SerializedFileMetaData");
}
item.ResourceFiles.AddRange(pair.Value.resourceFiles);
#if UNITY_2019_3_OR_NEWER
if (input.BundleNameToAdditionalFiles.TryGetValue(bundleName, out List <ResourceFile> additionalFiles))
{
RawHash hash = HashResourceFiles(additionalFiles);
item.SeriliazedFileMetaDatas.Add(new SerializedFileMetaData()
{
ContentHash = hash.ToHash128(), RawFileHash = hash.ToHash128()
});
item.ResourceFiles.AddRange(additionalFiles);
}
#endif
}
List <ArchiveWorkItem> allItems = bundleNameToWorkItem.Select((x, index) => { x.Value.Index = index; return(x.Value); }).ToList();
return(allItems);
}
}
/// <summary>
/// Receives data from file
/// </summary>
/// <param name="context"></param>
/// <param name="input"></param>
/// <returns></returns>
protected override TAdapterOutput ReceiveData(TaskContext context, TaskInput input)
{
try
{
FileReceiveAdapterConfig config = this.GetConfiguration <FileReceiveAdapterConfig>(input.Orchestration);
LogManager.TraceInfStartFileReceiveAdapter(config != null ? config.FileMask : "NULL", config != null? config.QueueFolder : "NULL");
if (!Directory.Exists(config.QueueFolder))
{
throw new Exception("No receive folder!");
}
var mapper = Factory.GetAdapterMapper(config.MapperQualifiedName);
foreach (var file in Directory.GetFiles(config.QueueFolder, config.FileMask))
{
TAdapterOutput inst = (TAdapterOutput)mapper.Map(file);
FileInfo fi = new FileInfo(file);
File.Move(file, file + ".tmp");
LogManager.TraceInfEndFileReceiveAdapter(file);
return(inst);
}
LogManager.TraceInfEndFileReceiveAdapter("No file found");
}
catch (Exception ex)
{
LogManager.TraceErrFileReceiveAdapter(ex);
throw;
}
return(null);
}
/// <summary>
/// Schedules list of defined routed tasks calculated from list of specified routing rules.
/// </summary>
/// <param name="rulesPipeline"></param>
/// <returns></returns>
public Task <RoutingRuleResult>[] ScheduleRoutedTasks(TaskInput taskArgument,
RoutingRulesPipeline rulesPipeline)
{
List <Task <RoutingRuleResult> > tasks = new List <Task <RoutingRuleResult> >();
if (rulesPipeline == null || rulesPipeline.Rules == null)
{
return(tasks.ToArray());
}
// We set the instance which will be checked by rule.
// Not every rule can process every instance.
rulesPipeline.EntityInstance = taskArgument;
var routingTasks = RulesManager.GetRoutingTasks(rulesPipeline);
foreach (var routingTaskType in routingTasks)
{
tasks.Add(m_Context.ScheduleTask <RoutingRuleResult>(routingTaskType, taskArgument));
}
return(tasks.ToArray());
}
public void Apply(IEnumerable <IFile> files, ITaskContext context)
{
if (files == null)
{
throw new ArgumentNullException("files");
}
if (_tasks == null)
{
return;
}
var filteredFiles = (from file in files where IsMatch(file) && File.Exists(file.Path) select new TaskFile(file));
Logger.Info("RULE {0}: applicable files count {1} from {2} total", Title, filteredFiles.Count(), files.Count());
var @params = GetEqualParamsFromFiles(filteredFiles);
foreach (var p in @params)
{
if (!context.CommonParams.ContainsKey(p.Key))
{
context.CommonParams.Add(p.Key, p.Value);
}
else
{
context.CommonParams[p.Key] = p.Value;
}
}
var taskSource = new TaskInput(filteredFiles, context.CommonParams);
var orderedTasks = _tasks.OrderBy(t => t.ParentTask == null);
foreach (var task in orderedTasks)
{
task.ExecuteTaskTree(taskSource, context);
}
}
/// <summary>
/// This method schedules dynamically set of rules as defined in orchestrationInput.RoutingRules.
/// It can be optionally used to simplify execution of orchestration.
/// RoutingRules implement usually some kind of Business Rule Engine.
/// </summary>
/// <param name="context"></param>
/// <param name="instance"></param>
/// <returns></returns>
protected async Task <List <RoutingRuleResult> > ScheduleRoutedTasks(OrchestrationContext context,
TaskInput instance)
{
List <RoutingRuleResult> results = new List <RoutingRuleResult>();
RoutingManager mgr = new RoutingManager(context);
var tasks = mgr.ScheduleRoutedTasks(instance, this.Configuration.RoutingRulesPipeline);
await Task.WhenAll(tasks.ToArray());
//bool hasFaulted = false;
foreach (var task in tasks)
{
RoutingRuleResult res;
if (task.IsFaulted)
{
res = new RoutingRuleResult();
res.Exception = task.Exception.InnerExceptions.First().ToString();
//hasFaulted = true;
}
else
{
res = task.Result;
}
results.Add(res);
}
//if (hasFaulted)
// throw new Exception("One or more routed tasks has failed.");
return(results);
}
public JsonResult Create(TaskInput taskInput)
{
try
{
if (_taskService.SearchTaskDescription(taskInput.TaskDescription, 0))
{
return(Json(new { EnableError = true, ErrorMsg = "Такая задача уже существует, введите другое название!" }));
}
if (ModelState.IsValid)
{
_taskService.Add(taskInput);
}
else
{
string validationErrors = string.Join(",", ModelState.Values.Where(E => E.Errors.Count > 0).SelectMany(E => E.Errors).Select(E => E.ErrorMessage).ToArray());
return(Json(new { EnableError = true, ErrorMsg = validationErrors }));
}
return(Json(new { EnableSuccess = true, SuccessMsg = "Задача успешно создана!" }));
}
catch (Exception)
{
return(Json(new { EnableError = true, ErrorMsg = "Что-то идет неправильно, попробуйте ещё раз или обратитесь к системному администратору!" }));
}
}
/// <summary>
/// Schedules specified task. It sets the ParentLoggingContext on context of orchestration.
/// </summary>
/// <param name="taskType"></param>
/// <param name="taskInput"></param>
/// <returns></returns>
protected async Task <TTaskOutput> ScheduleTask <TTaskOutput>(Type taskType, TaskInput taskInput) where TTaskOutput : class
{
taskInput.Context = m_OrchestrationInput.Context;
return(await m_OrchestrationConext.ScheduleTask <TTaskOutput>(taskType, taskInput));
}
//private static List<string> m_TraceSourceInitialized = new List<string>();
private void initializeLog(TaskContext context, TaskInput inputArg)
{
if (m_Log == null)
{
string logTraceSourceName = null;
ILogManager parentLogMgr = new LogManager(inputArg.LoggerFactory, "not-used");
LoggingContext parentLoggingContext = null;
if (inputArg.Context.ContainsKey("ParentLoggingContext"))
{
parentLoggingContext = inputArg.Context["ParentLoggingContext"] as LoggingContext;
if (parentLoggingContext?.LoggingScopes != null)
{
foreach (var scope in parentLoggingContext.LoggingScopes)
{
// If Log Trace Source name is in parent context it will be used.
if (scope.Key == "LogTraceSourceName")
{
logTraceSourceName = scope.Value;
}
parentLogMgr.AddScope(scope.Key, scope.Value);
}
// Copy the previous SequenceId to ParentSequenceId to keep the track.
if (parentLogMgr.CurrentScope.ContainsKey("SequenceId"))
{
parentLogMgr.AddScope("ParentSequenceId", parentLogMgr.CurrentScope["SequenceId"]);
}
else
{
parentLogMgr.AddScope("ParentSequenceId", null);
}
}
}
if (parentLoggingContext == null)
{
parentLoggingContext = new LoggingContext();
}
//
// If log trace source name is specified in the configuration it will be used even if the context contains a parent logtrace source name.
var cfg = this.GetConfiguration(inputArg.Orchestration);
if (cfg != null)
{
logTraceSourceName = cfg.LogTraceSourceName;
}
if (String.IsNullOrEmpty(logTraceSourceName))
{
logTraceSourceName = this.GetType().FullName;
}
m_Log = new LogManager(inputArg.LoggerFactory, logTraceSourceName, parentLogMgr);
// With new instance of the LogManager we always create a new SequenceId.
m_Log.AddScope("SequenceId", Guid.NewGuid().ToString());
// Add an new ActivityId if not existing yet.
if (!m_Log.CurrentScope.ContainsKey("ActivityId"))
{
m_Log.AddScope("ActivityId", Guid.NewGuid().ToString());
}
// Add OrchestrationInstanceId
if (!m_Log.CurrentScope.ContainsKey("OrchestrationInstanceId"))
{
m_Log.AddScope("OrchestrationInstanceId", context.OrchestrationInstance.InstanceId);
}
}
}
public static TaskGeneratorResult GetTaskInputs(Type programOptionsType, PropertyInfo parent)
{
var properties = programOptionsType.GetProperties(
BindingFlags.Public | BindingFlags.FlattenHierarchy | BindingFlags.Instance).Where(p =>
Attribute.IsDefined(p, typeof(OptionAttribute)) || Attribute.IsDefined(p, typeof(DisplayAttribute)))
.ToArray();
// var useServiceEndpoint = properties.Any(p => Attribute.IsDefined(p, typeof(ServiceEndpointAttribute)));
var results = new TaskGeneratorResult();
foreach (var property in properties)
{
var groupName = GetGroupName(property);
var resourceType = GetResourcetype(property);
var variableName = GetVariableName(property);
var defaultTask = new TaskInput()
{
HelpMarkDown = GetHelpmarkDown(property),
Name = variableName,
DefaultValue = GetTaskDefaultValue(property),
Label = GetLabel(property),
GroupName = groupName,
Required = GetRequired(property, parent),
VisibleRule = property.GetCustomAttribute <VisibleRuleAttribute>()?.VisibleRule,
Order = GetOrder(property),
};
defaultTask.Properties.EditableOptions = "True";
if (variableName.Contains(" "))
{
throw new ArgumentException($"The generated name for the given TaskInput contains spaces, please fix. : {defaultTask.Name}");
}
var sd = property.GetCustomAttribute <SourceDefinitionAttribute>();
if (sd != null)
{
try
{
if (!sd.Ignore)
{
results.SourceDefinitions.Add(new SourceDefinition
{
Endpoint = sd.Endpoint,
AuthKey = (Activator.CreateInstance(sd.ConnectedService ??
parent?.GetCustomAttribute <SourceDefinitionAttribute>()?.ConnectedService ??
programOptionsType.GetCustomAttribute <SourceDefinitionAttribute>()?.ConnectedService) as AuthKeyProvider).GetAuthKey(),
Selector = sd.Selector,
KeySelector = sd.KeySelector ?? "",
Target = variableName
});
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
if (typeof(ITaskInputFactory).IsAssignableFrom(resourceType))
{
ITaskInputFactory fac = null;
if (resourceType == property.PropertyType)
{
fac = property.GetValue(Activator.CreateInstance(programOptionsType)) as ITaskInputFactory;
}
if (fac == null && resourceType.IsGenericTypeDefinition && resourceType == property.PropertyType.GetGenericTypeDefinition())
{
fac = property.GetValue(Activator.CreateInstance(programOptionsType)) as ITaskInputFactory;
}
if (fac == null)
{
fac = Activator.CreateInstance(resourceType) as ITaskInputFactory;
}
var tasks = fac.GenerateTasks(groupName, defaultTask, property);
foreach (var iput in tasks.Inputs)
{
iput.GroupName = iput.GroupName ?? defaultTask.GroupName;
}
results.Add(tasks);
}
else
{
defaultTask.Type = GetTaskInputType(resourceType, property);
results.Inputs.Add(defaultTask);
}
}
results.Groups.AddRange(
programOptionsType.GetCustomAttributes <GroupAttribute>()
.Select(g => new Group
{
DisplayName = g.DisplayName,
Name = g.Name,
IsExpanded = g.isExpanded
}));
return(results);
}
public Task(TaskInput input)
{
Data = input.Data;
Date = input.Date;
Guid = input.Guid;
}
public async Task <IActionResult> GetStatusTasks([FromBody] TaskInput taskInput)
{
var tasks = await _taskService.GetStatusTasks(taskInput.Status, GetUserName());
return(Ok(tasks));
}
public async Task <IActionResult> EditTaskAsync([FromBody] TaskInput task)
{
var oResultTask = await _taskService.EditTask(task, GetUserName());
return(Ok(oResultTask));
}
static internal ReturnCode Run(TaskInput input, out TaskOutput output)
{
output = new TaskOutput();
output.BundleDetails = new Dictionary <string, BundleDetails>();
List <ArchiveWorkItem> allItems = CreateWorkItems(input);
Dictionary <string, ulong> fileOffsets = CalculateHashFileOffsets(input);
IList <CacheEntry> cacheEntries = null;
IList <CachedInfo> cachedInfo = null;
List <ArchiveWorkItem> cachedItems = new List <ArchiveWorkItem>();
List <ArchiveWorkItem> nonCachedItems = allItems;
if (input.BuildCache != null)
{
using (input.Log.ScopedStep(LogLevel.Info, "Creating Cache Entries"))
cacheEntries = allItems.Select(x => GetCacheEntry(x.BundleName, x.ResourceFiles, x.Compression)).ToList();
using (input.Log.ScopedStep(LogLevel.Info, "Load Cached Data"))
input.BuildCache.LoadCachedData(cacheEntries, out cachedInfo);
cachedItems = allItems.Where(x => cachedInfo[x.Index] != null).ToList();
nonCachedItems = allItems.Where(x => cachedInfo[x.Index] == null).ToList();
foreach (ArchiveWorkItem i in allItems)
{
i.CachedArtifactPath = string.Format("{0}/{1}", input.BuildCache.GetCachedArtifactsDirectory(cacheEntries[i.Index]), i.BundleName);
}
}
using (input.Log.ScopedStep(LogLevel.Info, "CopyingCachedFiles"))
{
foreach (ArchiveWorkItem item in cachedItems)
{
if (!input.ProgressTracker.UpdateInfoUnchecked(string.Format("{0} (Cached)", item.BundleName)))
{
return(ReturnCode.Canceled);
}
item.ResultDetails = (BundleDetails)cachedInfo[item.Index].Data[0];
item.ResultDetails.FileName = item.OutputFilePath;
item.ResultHash = item.ResultDetails.Hash;
CopyToOutputLocation(item.CachedArtifactPath, item.ResultDetails.FileName, input.Log);
}
}
// Write all the files that aren't cached
if (!ArchiveItems(nonCachedItems, fileOffsets, input.TempOutputFolder, input.ProgressTracker, input.Threaded, input.Log))
{
return(ReturnCode.Canceled);
}
PostArchiveProcessing(allItems, input.AssetToFilesDependencies.Values.ToList(), input.InternalFilenameToBundleName, input.Log);
// Put everything into the cache
if (input.BuildCache != null)
{
using (input.Log.ScopedStep(LogLevel.Info, "Copying To Cache"))
{
List <CachedInfo> uncachedInfo = nonCachedItems.Select(x => GetCachedInfo(input.BuildCache, cacheEntries[x.Index], x.ResourceFiles, x.ResultDetails)).ToList();
input.BuildCache.SaveCachedData(uncachedInfo);
}
}
output.BundleDetails = allItems.ToDictionary((x) => x.BundleName, (x) => x.ResultDetails);
if (input.OutCachedBundles != null)
{
input.OutCachedBundles.AddRange(cachedItems.Select(x => x.BundleName));
}
return(ReturnCode.Success);
}
public TaskGeneratorResult GenerateTasks(string groupName, TaskInput defaultTask, PropertyInfo parent)
{
var tasks = TaskHelper.GetTaskInputs(typeof(T), parent);
return(tasks);
}
public async Task <IActionResult> GetTasksList([FromBody] TaskInput taskInput)
{
var aCustomerTasks = await _taskService.GetTasksList(GetUserName(), taskInput.TaskId, taskInput.Type);
return(Ok(aCustomerTasks));
}
