/// <summary>
/// Метод получает задания в статусе "В аукционе".
/// </summary>
/// <returns>Список заданий в аукционе.</returns>
public async Task <GetTaskResultOutput> LoadAuctionTasks()
{
try
{
GetTaskResultOutput resultTasks = new GetTaskResultOutput();
IEnumerable auctionTasks = await(from tasks in _postgre.Tasks
join categories in _postgre.TaskCategories on tasks.CategoryCode equals categories.CategoryCode
join statuses in _postgre.TaskStatuses on tasks.StatusCode equals statuses.StatusCode
join users in _postgre.Users on tasks.OwnerId equals users.Id
where statuses.StatusName.Equals(StatusTask.AUCTION)
select new
{
tasks.CategoryCode,
tasks.CountOffers,
tasks.CountViews,
tasks.OwnerId,
tasks.SpecCode,
categories.CategoryName,
tasks.StatusCode,
statuses.StatusName,
TaskBegda = string.Format("{0:f}", tasks.TaskBegda),
TaskEndda = string.Format("{0:f}", tasks.TaskEndda),
tasks.TaskTitle,
tasks.TaskDetail,
tasks.TaskId,
TaskPrice = string.Format("{0:0,0}", tasks.TaskPrice),
tasks.TypeCode,
users.UserName
})
.OrderBy(o => o.TaskId)
.ToListAsync();
// Приводит к типу коллекции GetTaskResultOutput.
foreach (object task in auctionTasks)
{
string jsonString = JsonSerializer.Serialize(task);
TaskOutput result = JsonSerializer.Deserialize <TaskOutput>(jsonString);
// Считает кол-во ставок к заданию, либо проставит 0.
int countResponds = await _postgre.Responds
.Where(r => r.TaskId == result.TaskId)
.Select(r => r.RespondId)
.CountAsync();
result.CountOffers = countResponds > 0 ? countResponds : 0;
resultTasks.Tasks.Add(result);
}
return(resultTasks);
}
catch (Exception ex)
{
Logger _logger = new Logger(_db, ex.GetType().FullName, ex.Message.ToString(), ex.StackTrace);
await _logger.LogCritical();
throw new Exception(ex.Message.ToString());
}
}
public override async Task GetTrackingTasks(Int32Value request, IServerStreamWriter <TaskOutput> responseStream, ServerCallContext context)
{
var result = await _dataAccess.GetTrackingTasksDataAccessAsync(request.Value);
if (result is null)
{
await responseStream.WriteAsync(new TaskOutput());
return;
}
foreach (var taskModel in result)
{
var task = new TaskOutput
{
TaskId = taskModel.TaskId,
FinalDate = taskModel.FinalDate.ToUniversalTime().ToTimestamp(),
Subject = taskModel.Subject,
Description = taskModel.Description,
Priority = taskModel.Priority,
IsArchive = taskModel.IsArchive,
IsCompleted = taskModel.IsCompleted,
EmployeeId = taskModel.UserId,
CreatedDate = taskModel.CreatedDate.ToUniversalTime().ToTimestamp()
};
await responseStream.WriteAsync(task);
}
}
private object RegisterTaskNotification(MapReduceOperation operation)
{
string taskID = (string)operation.TaskID;
if (taskID == null || string.IsNullOrEmpty(taskID))
{
throw new OperationFailedException("Task can not be null or empty");
}
TaskBase t = null;
if (runningTasks.ContainsKey(taskID))
{
t = (TaskBase)runningTasks[taskID];
t.AddTaskCallbackInfo((TaskCallbackInfo)operation.CallbackInfo);
}
else if (waitingTasks.ContainsKey(taskID))
{
t = (TaskBase)waitingTasks[taskID];
t.AddTaskCallbackInfo((TaskCallbackInfo)operation.CallbackInfo);
}
else if (taskOutputStore != null && taskOutputStore.TaskOutputExists(taskID))
{
//Put listener info into taskoutput and then call notify client async
TaskOutput output = taskOutputStore.TaskOutput(taskID);
if (output != null)
{
output.AddToListeners(operation.CallbackInfo);
}
if (_context.CacheImpl != null && _context.CacheInternal != null)
{
EventContext eventContext = new EventContext();
eventContext.TaskStatus = TaskStatus.Success;
IList listeners = new ArrayList();
listeners.Add((TaskCallbackInfo)operation.CallbackInfo);
_context.CacheInternal.NotifyTaskCallback(taskID, listeners, true, null, eventContext);
}
}
else if (this.cancelledTask.Contains(taskID))
{
throw new OperationFailedException("Task with Specified TaskId was cancelled.");
}
else
{
throw new OperationFailedException("Task with Specified Task id does not exists");
}
return(true);
}
private object UnregisterTaskNotification(MapReduceOperation operation)
{
String taskID = (String)operation.TaskID;
if (taskID == null || string.IsNullOrEmpty(taskID))
{
throw new OperationFailedException("Task can not be null or empty");
}
TaskBase t = null;
if (runningTasks.ContainsKey(taskID))
{
t = (TaskBase)runningTasks[taskID];
t.RemoveTaskCallbackInfo((TaskCallbackInfo)operation.CallbackInfo);
}
else if (waitingTasks.ContainsKey(taskID))
{
t = (TaskBase)waitingTasks[taskID];
t.RemoveTaskCallbackInfo((TaskCallbackInfo)operation.CallbackInfo);
}
else if (taskOutputStore != null && taskOutputStore.TaskOutputExists(taskID))
{
//remove listener info from taskoutput
TaskOutput output = taskOutputStore.TaskOutput(taskID);
if (output != null)
{
output.RemoveFromListeners(operation.CallbackInfo);
}
}
else if (this.cancelledTask.Contains(taskID))
{
throw new OperationFailedException("Task with Specified TaskId was cancelled.");
}
else
{
throw new OperationFailedException("Task with Specified Task id does not exists");
}
return(true);
}
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);
}
protected override void WriteOutput(TaskOutput output) => Output.Enqueue(output);
static internal ReturnCode RunInternal(TaskInput input, out TaskOutput output)
{
#if !UNITY_2020_2_OR_NEWER
input.EngineHooks = input.EngineHooks != null ? input.EngineHooks : new CalculateAssetDependencyHooks();
#endif
output = new TaskOutput();
output.AssetResults = new AssetOutput[input.Assets.Count];
IList <CachedInfo> cachedInfo = null;
if (input.BuildCache != null)
{
IList <CacheEntry> entries = input.Assets.Select(x => input.BuildCache.GetCacheEntry(x, kVersion)).ToList();
input.BuildCache.LoadCachedData(entries, out cachedInfo);
}
using (input.Logger.ScopedStep(LogLevel.Info, "Calculate Dependencies"))
{
for (int i = 0; i < input.Assets.Count; i++)
{
AssetOutput assetResult = new AssetOutput();
assetResult.asset = input.Assets[i];
if (cachedInfo != null && cachedInfo[i] != null)
{
assetResult.assetInfo = cachedInfo[i].Data[0] as AssetLoadInfo;
assetResult.usageTags = cachedInfo[i].Data[1] as BuildUsageTagSet;
assetResult.spriteData = cachedInfo[i].Data[2] as SpriteImporterData;
assetResult.extendedData = cachedInfo[i].Data[3] as ExtendedAssetData;
assetResult.objectTypes = cachedInfo[i].Data[4] as List <KeyValuePair <ObjectIdentifier, System.Type[]> >;
output.AssetResults[i] = assetResult;
output.CachedAssetCount++;
continue;
}
GUID asset = input.Assets[i];
string assetPath = AssetDatabase.GUIDToAssetPath(asset.ToString());
if (!input.ProgressTracker.UpdateInfoUnchecked(assetPath))
{
return(ReturnCode.Canceled);
}
assetResult.assetInfo = new AssetLoadInfo();
assetResult.usageTags = new BuildUsageTagSet();
assetResult.assetInfo.asset = asset;
var includedObjects = ContentBuildInterface.GetPlayerObjectIdentifiersInAsset(asset, input.Target);
assetResult.assetInfo.includedObjects = new List <ObjectIdentifier>(includedObjects);
var referencedObjects = ContentBuildInterface.GetPlayerDependenciesForObjects(includedObjects, input.Target, input.TypeDB);
assetResult.assetInfo.referencedObjects = new List <ObjectIdentifier>(referencedObjects);
var allObjects = new List <ObjectIdentifier>(includedObjects);
allObjects.AddRange(referencedObjects);
ContentBuildInterface.CalculateBuildUsageTags(allObjects.ToArray(), includedObjects, input.GlobalUsage, assetResult.usageTags, input.DependencyUsageCache);
var importer = AssetImporter.GetAtPath(assetPath) as TextureImporter;
if (importer != null && importer.textureType == TextureImporterType.Sprite)
{
assetResult.spriteData = new SpriteImporterData();
assetResult.spriteData.PackedSprite = false;
assetResult.spriteData.SourceTexture = includedObjects.FirstOrDefault();
if (EditorSettings.spritePackerMode != SpritePackerMode.Disabled)
{
assetResult.spriteData.PackedSprite = referencedObjects.Length > 0;
}
#if !UNITY_2020_1_OR_NEWER
if (EditorSettings.spritePackerMode == SpritePackerMode.AlwaysOn || EditorSettings.spritePackerMode == SpritePackerMode.BuildTimeOnly)
{
assetResult.spriteData.PackedSprite = !string.IsNullOrEmpty(importer.spritePackingTag);
}
#endif
}
#if !UNITY_2020_2_OR_NEWER
GatherAssetRepresentations(assetPath, input.EngineHooks.LoadAllAssetRepresentationsAtPath, includedObjects, out assetResult.extendedData);
#else
GatherAssetRepresentations(asset, input.Target, out assetResult.extendedData);
#endif
output.AssetResults[i] = assetResult;
}
}
if (input.BuildCache != null)
{
List <CachedInfo> toCache = new List <CachedInfo>();
for (int i = 0; i < input.Assets.Count; i++)
{
AssetOutput r = output.AssetResults[i];
if (cachedInfo[i] == null)
{
toCache.Add(GetCachedInfo(input.BuildCache, input.Assets[i], r.assetInfo, r.usageTags, r.spriteData, r.extendedData));
}
}
input.BuildCache.SaveCachedData(toCache);
}
return(ReturnCode.Success);
}
private void TaskTest()
{
var now = DateTime.Now;
var task = Task.Factory.StartNew<TaskOutput>(() =>
{
var to = new TaskOutput() ;
Thread.Sleep(2000);
to.Msg = "success";
return to;
});
Console.WriteLine(task.Result.Msg);
var span = DateTime.Now - now;
Console.WriteLine("Total(ms):" + span.TotalMilliseconds);
}
static internal ReturnCode RunInternal(TaskInput input, out TaskOutput output)
{
input.EngineHooks = input.EngineHooks != null ? input.EngineHooks : new CalculateAssetDependencyHooks();
output = new TaskOutput();
output.AssetResults = new AssetOutput[input.Assets.Count];
IList <CachedInfo> cachedInfo = null;
if (input.BuildCache != null)
{
IList <CacheEntry> entries = input.Assets.Select(x => input.BuildCache.GetCacheEntry(x, kVersion)).ToList();
input.BuildCache.LoadCachedData(entries, out cachedInfo);
}
for (int i = 0; i < input.Assets.Count; i++)
{
AssetOutput assetResult = new AssetOutput();
assetResult.asset = input.Assets[i];
if (cachedInfo != null && cachedInfo[i] != null)
{
assetResult.assetInfo = cachedInfo[i].Data[0] as AssetLoadInfo;
assetResult.usageTags = cachedInfo[i].Data[1] as BuildUsageTagSet;
assetResult.spriteData = cachedInfo[i].Data[2] as SpriteImporterData;
assetResult.extendedData = cachedInfo[i].Data[3] as ExtendedAssetData;
output.AssetResults[i] = assetResult;
output.CachedAssetCount++;
continue;
}
GUID asset = input.Assets[i];
string assetPath = AssetDatabase.GUIDToAssetPath(asset.ToString());
if (!input.ProgressTracker.UpdateInfoUnchecked(assetPath))
{
return(ReturnCode.Canceled);
}
assetResult.assetInfo = new AssetLoadInfo();
assetResult.usageTags = new BuildUsageTagSet();
assetResult.assetInfo.asset = asset;
var includedObjects = ContentBuildInterface.GetPlayerObjectIdentifiersInAsset(asset, input.Target);
assetResult.assetInfo.includedObjects = new List <ObjectIdentifier>(includedObjects);
var referencedObjects = ContentBuildInterface.GetPlayerDependenciesForObjects(includedObjects, input.Target, input.TypeDB);
assetResult.assetInfo.referencedObjects = new List <ObjectIdentifier>(referencedObjects);
var allObjects = new List <ObjectIdentifier>(includedObjects);
allObjects.AddRange(referencedObjects);
ContentBuildInterface.CalculateBuildUsageTags(allObjects.ToArray(), includedObjects, input.GlobalUsage, assetResult.usageTags, input.DependencyUsageCache);
var importer = AssetImporter.GetAtPath(assetPath) as TextureImporter;
if (importer != null && importer.textureType == TextureImporterType.Sprite)
{
assetResult.spriteData = new SpriteImporterData();
assetResult.spriteData.PackedSprite = false;
assetResult.spriteData.SourceTexture = includedObjects.First();
if (EditorSettings.spritePackerMode != SpritePackerMode.Disabled)
{
assetResult.spriteData.PackedSprite = referencedObjects.Length > 0;
}
#if !UNITY_2020_1_OR_NEWER
if (EditorSettings.spritePackerMode == SpritePackerMode.AlwaysOn || EditorSettings.spritePackerMode == SpritePackerMode.BuildTimeOnly)
{
assetResult.spriteData.PackedSprite = !string.IsNullOrEmpty(importer.spritePackingTag);
}
#endif
}
var representations = input.EngineHooks.LoadAllAssetRepresentationsAtPath(assetPath);
if (!representations.IsNullOrEmpty())
{
assetResult.extendedData = new ExtendedAssetData();
for (int j = 0; j < representations.Length; j++)
{
if (representations[j] == null)
{
BuildLogger.LogWarning($"SubAsset {j} inside {assetPath} is null. It will not be included in the build.");
continue;
}
if (AssetDatabase.IsMainAsset(representations[j]))
{
continue;
}
string guid;
long localId;
if (!AssetDatabase.TryGetGUIDAndLocalFileIdentifier(representations[j], out guid, out localId))
{
continue;
}
assetResult.extendedData.Representations.AddRange(includedObjects.Where(x => x.localIdentifierInFile == localId));
}
}
output.AssetResults[i] = assetResult;
}
if (input.BuildCache != null)
{
List <CachedInfo> toCache = new List <CachedInfo>();
for (int i = 0; i < input.Assets.Count; i++)
{
AssetOutput r = output.AssetResults[i];
if (cachedInfo[i] == null)
{
toCache.Add(GetCachedInfo(input.BuildCache, input.Assets[i], r.assetInfo, r.usageTags, r.spriteData, r.extendedData));
}
}
input.BuildCache.SaveCachedData(toCache);
}
return(ReturnCode.Success);
}
