public static Dictionary <string, Dictionary <int, SatyamAggregatedResultsTableEntry> > getAggregatedEntriesPerTaskByGuidList(List <string> guids)
{
SatyamAggregatedResultsTableAccess aggDB = new SatyamAggregatedResultsTableAccess();
Dictionary <string, Dictionary <int, SatyamAggregatedResultsTableEntry> > aggEntriesPerTaskPerGUID = new Dictionary <string, Dictionary <int, SatyamAggregatedResultsTableEntry> >();
foreach (string guid in guids)
{
if (!aggEntriesPerTaskPerGUID.ContainsKey(guid))
{
aggEntriesPerTaskPerGUID.Add(guid, new Dictionary <int, SatyamAggregatedResultsTableEntry>());
}
//List<SatyamAggregatedResultsTableEntry> aggEntriesPerGUID = aggDB.getEntriesByGUID(guid);
List <SatyamAggregatedResultsTableEntry> aggEntriesPerGUID = aggDB.getEntriesByGUIDOrderByResultsAggregatedDesc(guid);
foreach (SatyamAggregatedResultsTableEntry aggEntry in aggEntriesPerGUID)
{
if (!aggEntriesPerTaskPerGUID[guid].ContainsKey(aggEntry.SatyamTaskTableEntryID))
{
aggEntriesPerTaskPerGUID[guid].Add(aggEntry.SatyamTaskTableEntryID, aggEntry);
}
}
}
aggDB.close();
return(aggEntriesPerTaskPerGUID);
}
//remove all tasks that have already been aggregated from the task table
public static void PurgeAllAggregatedTasks()
{
SatyamTaskTableAccess taskDB = new SatyamTaskTableAccess();
//List<int> IDList = taskDB.getAllIDs();
List <SatyamTaskTableEntry> taskList = taskDB.getAllEntries();
SatyamAggregatedResultsTableAccess aggDB = new SatyamAggregatedResultsTableAccess();
List <int> AggIDList = aggDB.getAllTaskIDs();
//List<SatyamAggregatedResultsTableEntry> aggEntreis = aggDB.getAllEntries();
foreach (SatyamTaskTableEntry t in taskList)
{
int id = t.ID;
if (!AggIDList.Contains(id))
{
continue;
}
//int LatestNumberAggregated = aggDB.getLatestNoResultsAggregatedByTaskID(id);
//int MinResults = TaskConstants.getMinResultsByTemplate(t.JobTemplateType);
//if(LatestNumberAggregated >= MinResults)
//{
taskDB.DeleteEntry(id);
//}
}
aggDB.close();
taskDB.close();
}
public static void SaveByGUIDSatyam(string guid)
{
//get all aggregated results
SatyamAggregatedResultsTableAccess resultsDB = new SatyamAggregatedResultsTableAccess();
List <SatyamAggregatedResultsTableEntry> results = resultsDB.getEntriesByGUID(guid);
resultsDB.close();
if (results.Count == 0)
{
return;
}
StringBuilder s = new StringBuilder();
for (int i = 0; i < results.Count; i++)
{
SatyamSaveAggregatedDataSatyam data = new SatyamSaveAggregatedDataSatyam(results[i]);
String jsonString = JSonUtils.ConvertObjectToJSon <SatyamSaveAggregatedDataSatyam>(data);
s.Append(jsonString);
if (i == results.Count - 1)
{
s.Append("\n");
}
}
string dataToBeSaved = s.ToString();
SatyamJobStorageAccountAccess storage = new SatyamJobStorageAccountAccess();
string FileName = "AggregatedResults-" + results[0].JobGUID + ".txt";
string satyamDirectoryName = SatyamTaskGenerator.JobTemplateToSatyamContainerNameMap[results[0].JobTemplateType];
//switch(results[0].JobTemplateType)
//{
// case TaskConstants.Classification_Image:
// case TaskConstants.Classification_Image_MTurk:
// satyamDirectoryName = "singleobjectlabeling";
// break;
// case TaskConstants.Classification_Video:
// case TaskConstants.Classification_Video_MTurk:
// satyamDirectoryName = "singleobjectlabelinginvideo";
// break;
// case TaskConstants.Counting_Image:
// case TaskConstants.Counting_Image_MTurk:
// satyamDirectoryName = "objectcounting";
// break;
// case TaskConstants.Counting_Video:
// case TaskConstants.Counting_Video_MTurk:
// satyamDirectoryName = "objectcountinginvideo";
// break;
// case TaskConstants.Detection_Image:
// case TaskConstants.Detection_Image_MTurk:
// satyamDirectoryName = "multiobjectlocalizationandlabeling";
// break;
// case TaskConstants.Tracking:
// case TaskConstants.Tracking_MTurk:
// satyamDirectoryName = "multiobjecttracking";
// break;
//}
storage.SaveATextFile(satyamDirectoryName, results[0].JobGUID, FileName, dataToBeSaved);
}
public static void Run([TimerTrigger("0 */1 * * * *")] TimerInfo myTimer, TraceWriter log)
{
DateTime start = DateTime.Now;
SatyamTaskTableAccess taskDB = new SatyamTaskTableAccess();
List <int> IDList = taskDB.getAllIDs();
taskDB.close();
SatyamAggregatedResultsTableAccess aggDB = new SatyamAggregatedResultsTableAccess();
List <int> AggIDList = aggDB.getAllTaskIDs();
aggDB.close();
foreach (int id in IDList)
{
if (AggIDList.Contains(id))
{
taskDB = new SatyamTaskTableAccess();
taskDB.DeleteEntry(id);
taskDB.close();
if ((DateTime.Now - start).TotalSeconds > 280)
{
break;
}
}
}
}
public static void SaveAggregatedResultImagesLocally(string jobGUID, string directoryName)
{
SatyamAggregatedResultsTableAccess resultsDB = new SatyamAggregatedResultsTableAccess();
List <SatyamAggregatedResultsTableEntry> entries = resultsDB.getEntriesByGUID(jobGUID);
resultsDB.close();
SaveAggregatedResultImagesLocally(entries, directoryName);
}
public static void SaveKITTIAggregatedResultVideosLocally(string jobGUID, string directoryName)
{
SatyamAggregatedResultsTableAccess resultsDB = new SatyamAggregatedResultsTableAccess();
List <SatyamAggregatedResultsTableEntry> entries = resultsDB.getEntriesByGUID(jobGUID);
resultsDB.close();
SaveKITTIAggregatedResultVideosLocally(entries, directoryName);
//GroupEntriesByVideoNameAndStitchAndSaveAggregatedResultVideosLocally(entries, directoryName);
}
public static void SaveAggregatedResultVideosLocally(string guid)
{
string outputDirectory = DirectoryConstants.defaultTempDirectory + guid;
SatyamAggregatedResultsTableAccess resultsDB = new SatyamAggregatedResultsTableAccess();
List <SatyamAggregatedResultsTableEntry> entries = resultsDB.getEntriesByGUID(guid);
resultsDB.close();
//SaveAggregatedResultVideosLocally(entries, outputDirectory);
GroupEntriesByVideoNameAndStitchAndSaveAggregatedResultVideosLocally(entries, outputDirectory);
}
public static void ValidateSatyamKITTIObjectCountingAggregationResultByGUID(string guid,
bool saveImage = false,
int MinHeight = TaskConstants.OBJECT_COUNTING_VALIDATION_MIN_HEIGHT,
int MaxOcclusion = TaskConstants.OBJECT_COUNTING_VALIDATION_MAX_OCCLUSION,
double Max_Truncation = TaskConstants.OBJECT_COUNTING_VALIDATION_MIN_TRUNCATION)
{
SatyamAggregatedResultsTableAccess resultsDB = new SatyamAggregatedResultsTableAccess();
List <SatyamAggregatedResultsTableEntry> results = resultsDB.getEntriesByGUID(guid);
resultsDB.close();
double totalError, totalGT;
ValidateSatyamKITTIObjectCountingAggregationResult(results, out totalError, out totalGT, MinHeight, MaxOcclusion, Max_Truncation);
}
public static void ValidateSatyamJHMDBVideoClassificationAggregationResultByGUID(string guid, string outputFile,
//string confusingImageListFilePath = null,
bool prepareDataForTraining = false, string outputDirectory = null)
{
SatyamAggregatedResultsTableAccess resultsDB = new SatyamAggregatedResultsTableAccess();
List <SatyamAggregatedResultsTableEntry> results = resultsDB.getEntriesByGUID(guid);
resultsDB.close();
int noTotal = results.Count;
int noCorrect = 0;
EvaluateAndPrintConfusionMatrixOfAggregatedResultEntries(results, outputFile, out noCorrect, prepareDataForTraining, outputDirectory);
Console.WriteLine("Result: {0}/{1}, precision: {2}", noCorrect, noTotal, (double)noCorrect / noTotal);
}
public static void TestAggregationAnalysis()
{
string guid = "86cbfe43-175a-4a5a-ba89-073f3004e7df";//20 class mturk all pascal
//string guid = "61bf62b5-d796-4b3c-9de9-9c67f04cf26f";// changed taskpage
string configString = "Min_" + 10 + "_Max_" + 10 + "_Majority_" + 0.5 + "_Ratio_" + 0.5;
SatyamAggregatedResultsTableAccess aggDB = new SatyamAggregatedResultsTableAccess();
List <SatyamAggregatedResultsTableEntry> aggEntries = aggDB.getEntriesByGUID(guid);
aggDB.close();
SatyamResultsTableAccess resDB = new SatyamResultsTableAccess();
List <SatyamResultsTableEntry> entries = resDB.getEntriesByGUID(guid);
resDB.close();
List <SatyamResultsTableEntry> filteredResults = new List <SatyamResultsTableEntry>();
//foreach (SatyamResultsTableEntry entry in entries)
//{
// SatyamResult res = JSonUtils.ConvertJSonToObject<SatyamResult>(entry.ResultString);
// string workerID = res.amazonInfo.WorkerID;
// string assignmentID = res.amazonInfo.AssignmentID;
// if (assignmentID == "" || assignmentID == "ASSIGNMENT_ID_NOT_AVAILABLE") continue;
// if (workerID == "") continue;
// /// im seg only
// ImageSegmentationResult res_imseg = JSonUtils.ConvertJSonToObject<ImageSegmentationResult>(res.TaskResult);
// if (res_imseg == null) continue;
// filteredResults.Add(entry);
//}
filteredResults = entries;
SortedDictionary <DateTime, List <SatyamResultsTableEntry> > entriesBySubmitTime =
SatyamResultValidationToolKit.SortResultsBySubmitTime_OneResultPerTurkerPerTask(filteredResults);
SatyamResultsAnalysis.AggregationAnalysis(aggEntries, entriesBySubmitTime, null, null, guid, configString,
usePreApprovalResult: false,
approvalRatioThreshold: 0.5);
}
public static void ValidatePascalVOCImageSegmentationByGUID(List <string> guids, double IoUTreshold, bool saveImage = false)
{
SatyamAggregatedResultsTableAccess resultsDB = new SatyamAggregatedResultsTableAccess();
List <SatyamAggregatedResultsTableEntry> results = new List <SatyamAggregatedResultsTableEntry>();
foreach (string guid in guids)
{
results.AddRange(resultsDB.getEntriesByGUID(guid));
}
resultsDB.close();
ValidatePascalVOCImageSegmentationResult_InstanceLevel(results, IoUTreshold);
ValidatePascalVOCImageSegmentationResult_ClassLevel(results, new List <double>()
{
0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95
});
}
public static void Run([QueueTrigger("aggregation")] string guidAndTaskID, TraceWriter log)
{
bool logging = false;
string[] fields = guidAndTaskID.Split('_');
string guid = fields[0];
int taskID = Convert.ToInt32(fields[1]);
SatyamResultsTableAccess resultsDB = new SatyamResultsTableAccess();
List <SatyamResultsTableEntry> collectedResults = resultsDB.getEntriesByGUIDAndTaskID(guid, taskID);
resultsDB.close();
if (collectedResults.Count == 0)
{
return;
}
if (logging)
{
log.Info($"Task Type: {collectedResults[0].JobTemplateType}({guid}), Task ID: {taskID}, # of Results: {collectedResults.Count}");
}
//SatyamAggregatedResultsTableAccess aggDB = new SatyamAggregatedResultsTableAccess();
//int LatestResultsAggregated = aggDB.getLatestNoResultsAggregatedByTaskID(taskID);
//aggDB.close();
//if (collectedResults.Count != LatestResultsAggregated)
//{
SatyamAggregatedResultsTableEntry aggEntry = ResultsTableAggregator.GetAggregatedResultString(taskID, collectedResults);
if (aggEntry != null)
{
//aggEntries.Add(aggEntry);
SatyamAggregatedResultsTableAccess aggDB = new SatyamAggregatedResultsTableAccess();
aggDB.AddEntry(aggEntry, collectedResults.Count);
aggDB.close();
if (logging)
{
log.Info($"Aggregated");
}
}
//}
}
public static void SaveByGUIDRequester(string guid)
{
//get all aggregated results
SatyamAggregatedResultsTableAccess resultsDB = new SatyamAggregatedResultsTableAccess();
List <SatyamAggregatedResultsTableEntry> results = resultsDB.getEntriesByGUID(guid);
resultsDB.close();
if (results.Count == 0)
{
return;
}
//get the saving location info
SatyamAggregatedResult result = JSonUtils.ConvertJSonToObject <SatyamAggregatedResult>(results[0].ResultString);
SingleObjectLabelingAggregatedResult sresult = JSonUtils.ConvertJSonToObject <SingleObjectLabelingAggregatedResult>(result.AggregatedResultString);
SatyamTask task = JSonUtils.ConvertJSonToObject <SatyamTask>(result.TaskParameters);
SatyamJob job = task.jobEntry;
string ConnectionString = job.azureInformation.AzureBlobStorageConnectionString;
string ContainerName = job.azureInformation.AzureBlobStorageContainerName;
string DirectoryName = job.azureInformation.AzureBlobStorageContainerDirectoryName;
StringBuilder s = new StringBuilder();
for (int i = 0; i < results.Count; i++)
{
SatyamSaveAggregatedDataRequester data = new SatyamSaveAggregatedDataRequester(results[i]);
String jsonString = JSonUtils.ConvertObjectToJSon <SatyamSaveAggregatedDataRequester>(data);
s.Append(jsonString);
if (i == results.Count - 1)
{
s.Append("\n");
}
}
string dataToBeSaved = s.ToString();
BlobContainerManager bcm = new BlobContainerManager();
bcm.Connect(ConnectionString);
string FileName = "AggregatedResults-" + results[0].JobGUID + ".txt";
bcm.SaveATextFile(ContainerName, DirectoryName, FileName, dataToBeSaved);
}
// If the results were not good enough, or aggregation method changed, retargeted, users might want to reopen the job
// All we need to do: (IN STRICT ORDER)
// clear all results back to inconclusive,
// remove all aggregated results
// restore the task table as it was for the guid,
// change the job status back to launched, and
// WARNING:
// for safety, this has to be run atomically synchronously, without any parallel process. for now.
public static void reopenJobForMoreResults(string guid)
{
SatyamJobSubmissionsTableAccess jobDB = new SatyamJobSubmissionsTableAccess();
SatyamJobSubmissionsTableAccessEntry jobEntry = jobDB.getEntryByJobGIUD(guid);
jobDB.close();
if (jobEntry.JobStatus != JobStatus.completed)
{
Console.WriteLine("Job not completed yet!");
return;
}
SatyamAggregatedResultsTableAccess aggResultDB = new SatyamAggregatedResultsTableAccess();
bool delSuccess = aggResultDB.DeleteEntriesByGUID(guid);
aggResultDB.close();
if (!delSuccess)
{
Console.WriteLine("Delete Agg Result DB Failed");
return;
}
SatyamResultsTableAccess resultDB = new SatyamResultsTableAccess();
if (!resultDB.UpdateStatusByGUID(guid, ResultStatus.inconclusive))
{
Console.WriteLine("Update Result DB Failed");
//resultDB.close();
//return;
}
List <SatyamResultsTableEntry> results = resultDB.getEntriesByGUID(guid);
resultDB.close();
Dictionary <int, SatyamTask> taskParamsByTaskID = new Dictionary <int, SatyamTask>();
foreach (SatyamResultsTableEntry result in results)
{
if (taskParamsByTaskID.ContainsKey(result.SatyamTaskTableEntryID))
{
continue;
}
SatyamResult satyamRes = JSonUtils.ConvertJSonToObject <SatyamResult>(result.ResultString);
SatyamTask task = JSonUtils.ConvertJSonToObject <SatyamTask>(satyamRes.TaskParametersString);
taskParamsByTaskID.Add(result.SatyamTaskTableEntryID, task);
}
SatyamTaskTableAccess taskDB = new SatyamTaskTableAccess();
foreach (int taskID in taskParamsByTaskID.Keys)
{
SatyamTask task = taskParamsByTaskID[taskID];
SatyamJob job = task.jobEntry;
bool suc = taskDB.AddEntryWithSpecificID(taskID, job.JobTemplateType, job.UserID, job.JobGUIDString, JSonUtils.ConvertObjectToJSon(task),
job.JobSubmitTime, job.amazonHITInformation.Price);
if (!suc)
{
Console.WriteLine("Update Task Table Failed");
taskDB.close();
return;
}
}
taskDB.close();
jobDB = new SatyamJobSubmissionsTableAccess();
bool success = jobDB.UpdateEntryStatus(guid, JobStatus.launched);
jobDB.close();
if (!success)
{
Console.WriteLine("Update Job Entry Failed");
return;
}
}
public static void Run([QueueTrigger("judge-result")] string myQueueItem, TraceWriter log)
{
bool logging = false;
string[] fields = myQueueItem.Split('_');
string guid = fields[0];
int taskID = Convert.ToInt32(fields[1]);
string resultID = fields[2];
if (logging)
{
log.Info($"Judge Result: {myQueueItem}");
}
SatyamResultsTableAccess resultsDB = new SatyamResultsTableAccess();
List <SatyamResultsTableEntry> results = resultsDB.getEntriesID(resultID);
resultsDB.close();
if (results.Count == 0)
{
return;
}
SatyamAggregatedResultsTableAccess aggDB = new SatyamAggregatedResultsTableAccess();
SatyamAggregatedResultsTableEntry aggResult = aggDB.getEntryByTaskID(taskID);
aggDB.close();
if (aggResult == null)
{
return;
}
SatyamResultsTableEntry result = results[0];
SatyamResult res = JSonUtils.ConvertJSonToObject <SatyamResult>(result.ResultString);
string taskTemplateType = result.JobTemplateType;
string workerID = res.amazonInfo.WorkerID;
DateTime doneTime = res.TaskEndTime;
if (AcceptanceCriterionChecker.IsAcceptable(aggResult, result))
{
resultsDB = new SatyamResultsTableAccess();
resultsDB.UpdateStatusByID(result.ID, ResultStatus.accepted);
resultsDB.close();
WorkerStatisticsManagement.UpdateWorkerStatistics(workerID, taskTemplateType, true, doneTime);
if (logging)
{
log.Info($"Accepted");
}
}
else
{
resultsDB = new SatyamResultsTableAccess();
resultsDB.UpdateStatusByID(result.ID, ResultStatus.rejected);
resultsDB.close();
WorkerStatisticsManagement.UpdateWorkerStatistics(workerID, taskTemplateType, false, doneTime);
if (logging)
{
log.Info($"Rejected");
}
}
}
public static void ValidateSatyamImageNetClassificationAggregationResultByGUID(string guid, string confusingImageListFilePath = null,
bool prepareDataForTraining = false, string outputDirectory = null)
{
Dictionary <string, ConfusingReason> imageBlackListReason = new Dictionary <string, ConfusingReason>();
if (confusingImageListFilePath != null)
{
imageBlackListReason = getConfusingImageList(confusingImageListFilePath);
}
//get all aggregated results
SatyamAggregatedResultsTableAccess resultsDB = new SatyamAggregatedResultsTableAccess();
List <SatyamAggregatedResultsTableEntry> results = resultsDB.getEntriesByGUID(guid);
resultsDB.close();
int noTotal = 0;
int noCorrect = 0;
SortedDictionary <string, Dictionary <string, int> > confusionMatrix_res_groundtruth = new SortedDictionary <string, Dictionary <string, int> >();
SortedDictionary <string, Dictionary <string, int> > confusionMatrix_groundtruth_res = new SortedDictionary <string, Dictionary <string, int> >();
StringBuilder s = new StringBuilder();
s.Append("<!DOCTYPE html>\n");
s.Append("<html>\n");
s.Append("<body>\n");
String title = String.Format("<h1>Job GUID {0} Incorrect Result Summary</h1>\n", guid);
s.Append(title);
WebClient wc = new WebClient();
for (int i = 0; i < results.Count; i++)
{
SatyamSaveAggregatedDataSatyam data = new SatyamSaveAggregatedDataSatyam(results[i]);
//String uri = data.SatyamURI;
//string[] uri_parts= uri.Split('/');
//string[] name_parts = uri_parts[uri_parts.Length - 1].Split('_');
string fileName = URIUtilities.filenameFromURI(data.SatyamURI);
string imageCategoryName = fileName.Split('_')[0];
String resultString = data.AggregatedResultString;
SingleObjectLabelingAggregatedResult result = JSonUtils.ConvertJSonToObject <SingleObjectLabelingAggregatedResult>(resultString);
// skip all ambulances and black listed
if (IsBlackListed(data.SatyamURI, imageBlackListReason))
{
continue;
}
if (!confusionMatrix_res_groundtruth.ContainsKey(result.Category))
{
confusionMatrix_res_groundtruth.Add(result.Category, new Dictionary <string, int>()
{
{ GroundTruth[imageCategoryName], 0 }
});
}
else
{
if (!confusionMatrix_res_groundtruth[result.Category].ContainsKey(GroundTruth[imageCategoryName]))
{
confusionMatrix_res_groundtruth[result.Category].Add(GroundTruth[imageCategoryName], 0);
}
}
if (!confusionMatrix_groundtruth_res.ContainsKey(GroundTruth[imageCategoryName]))
{
confusionMatrix_groundtruth_res.Add(GroundTruth[imageCategoryName], new Dictionary <string, int>()
{
{ result.Category, 0 }
});
}
else
{
if (!confusionMatrix_groundtruth_res[GroundTruth[imageCategoryName]].ContainsKey(result.Category))
{
confusionMatrix_groundtruth_res[GroundTruth[imageCategoryName]].Add(result.Category, 0);
}
}
if (result.Category.Equals(GroundTruth[imageCategoryName], StringComparison.InvariantCultureIgnoreCase))
{
noCorrect++;
}
else
{
//Console.WriteLine("{0}, Groundtruth: {1}, Aggregated: {2}, Votes: {3}",
// fileName, GroundTruth[imageCategoryName], result.Category,
// JSonUtils.ConvertObjectToJSon(result.metaData));
String record = String.Format("<p>{0}, Groundtruth: {1}, Aggregated: {2}, Votes: {3}</p>\n",
fileName, GroundTruth[imageCategoryName], result.Category,
JSonUtils.ConvertObjectToJSon(result.metaData));
String img = String.Format("<img src=\"{0}\" >\n", data.SatyamURI);
s.Append(record);
s.Append(img);
}
// prepare training dataset
if (prepareDataForTraining)
{
if (GroundTruth[imageCategoryName] != "ambulance" && result.Category != "ambulance")
{
Image im = Image.FromStream(wc.OpenRead(data.SatyamURI));
if (!Directory.Exists(outputDirectory + result.Category))
{
Directory.CreateDirectory(outputDirectory + result.Category);
}
im.Save(outputDirectory + "\\" + result.Category + "\\" + fileName);
}
}
noTotal++;
confusionMatrix_res_groundtruth[result.Category][GroundTruth[imageCategoryName]]++;
confusionMatrix_groundtruth_res[GroundTruth[imageCategoryName]][result.Category]++;
}
Console.WriteLine("Result: {0}/{1}, precision: {2}", noCorrect, noTotal, (double)noCorrect / noTotal);
// write the confusion matrix
s.Append("<p>");
String row = "\t\t";
foreach (string resultCategory in confusionMatrix_res_groundtruth.Keys)
{
row += resultCategory + "\t";
}
row += "<br>\n";
s.Append(row);
Console.WriteLine(row);
foreach (string groundTruthCategory in confusionMatrix_groundtruth_res.Keys)
{
row = groundTruthCategory + "\t";
foreach (string resultCategory in confusionMatrix_res_groundtruth.Keys)
{
if (confusionMatrix_groundtruth_res[groundTruthCategory].ContainsKey(resultCategory))
{
row += confusionMatrix_groundtruth_res[groundTruthCategory][resultCategory].ToString();
}
else
{
row += "0";
}
row += "\t";
}
row += "<br>\n";
s.Append(row);
Console.WriteLine(row);
}
s.Append("</p>\n");
s.Append("</body>\n");
s.Append("</html>\n");
string dataToBeSaved = s.ToString();
SatyamJobStorageAccountAccess storage = new SatyamJobStorageAccountAccess();
string FileName = "AggregatedIncorrectResults-" + guid + ".html";
storage.SaveATextFile("singleobjectlabeling", guid, FileName, dataToBeSaved);
}
//go through all the inconclusive results and aggregate them if they are not aggregated already
public static void AggregateResults()
{
//first get all the results that are not aggregated
SatyamResultsTableAccess resultsDB = new SatyamResultsTableAccess();
List <SatyamResultsTableEntry> results = resultsDB.getEntriesByStatus(ResultStatus.inconclusive);
if (results.Count == 0) //there is nothing to do
{
resultsDB.close();
return;
}
//first group all the results by the tasks since wach task may have multiple entries
Dictionary <int, List <SatyamResultsTableEntry> > collectedResults = new Dictionary <int, List <SatyamResultsTableEntry> >();
List <string> pendingGUID = new List <string>();
foreach (SatyamResultsTableEntry entry in results)
{
int taskID = entry.SatyamTaskTableEntryID;
if (!collectedResults.ContainsKey(taskID))
{
collectedResults.Add(taskID, new List <SatyamResultsTableEntry>());
}
collectedResults[taskID].Add(entry);
if (!pendingGUID.Contains(entry.JobGUID))
{
pendingGUID.Add(entry.JobGUID);
}
}
List <int> taskIDList = collectedResults.Keys.ToList();
taskIDList.Sort();
//check if guid is still pending
SatyamJobSubmissionsTableAccess jobDB = new SatyamJobSubmissionsTableAccess();
List <string> completedGUIDs = jobDB.getAllJobGUIDSByStatus(JobStatus.completed);
jobDB.close();
//check if this taskID has already been aggregated and exists int he aggregationDB
Dictionary <string, Dictionary <int, SatyamAggregatedResultsTableEntry> > ExistingAggEntriesPerTaskPerGUID = SatyamAggregatedResultManagement.getAggregatedEntriesPerTaskByGuidList(pendingGUID);
Console.WriteLine("Aggregating {0} Tasks", taskIDList.Count);
List <SatyamAggregatedResultsTableEntry> aggEntries = new List <SatyamAggregatedResultsTableEntry>();
//foreach (int taskId in taskIDList)
for (int i = 0; i < taskIDList.Count; i++)
{
//int taskId = taskIDList[taskIDList.Count - i - 1];
int taskId = taskIDList[i];
string guid = collectedResults[taskId][0].JobGUID;
if (completedGUIDs.Contains(guid))
{
// Hit Completed, mark results outdated.
resultsDB.UpdateStatusByTaskID(taskId, ResultStatus.outdated);
continue;
}
//SatyamAggregatedResultsTableAccess aggDB = new SatyamAggregatedResultsTableAccess();
//int LatestResultsAggregated = aggDB.getLatestNoResultsAggregatedByTaskID(taskId);
//aggDB.close();
if (ExistingAggEntriesPerTaskPerGUID.ContainsKey(guid) && ExistingAggEntriesPerTaskPerGUID[guid].ContainsKey(taskId))
{
continue;
//int MinResults = TaskConstants.getMinResultsByTemplate(ExistingAggEntriesPerTaskPerGUID[guid][taskId].JobTemplateType);
//if (LatestResultsAggregated >= MinResults)
//{
// continue;
//}
// already aggregated to MinResult Request, but leftover results will be judged. So do nothing
}
//if it does not exist only then aggregate
Console.WriteLine("Task Type: {2}({3}), Task ID: {0}, # of Results: {1}", taskId, collectedResults[taskId].Count, collectedResults[taskId][0].JobTemplateType, collectedResults[taskId][0].JobGUID);
//if (collectedResults[taskId].Count != LatestResultsAggregated)
//{
SatyamAggregatedResultsTableEntry aggEntry = ResultsTableAggregator.GetAggregatedResultString(taskId, collectedResults[taskId]);
if (aggEntry != null)
{
//aggEntries.Add(aggEntry);
SatyamAggregatedResultsTableAccess aggDB = new SatyamAggregatedResultsTableAccess();
aggDB.AddEntry(aggEntry, collectedResults[taskId].Count);
aggDB.close();
}
//}
//else
//{
// Console.WriteLine("No New Results");
//}
}
resultsDB.close();
}
