public async void GetTasksForUser()
{
var adduser = new UserAdd()
{
Email = Guid.NewGuid().ToString()
};
var userTrans = new UserTransactions();
var userView = new UserViews();
var user = await userTrans.Add(adduser);
for (int i = 0; i < 10; i++)
{
var taskTrans = new TaskTransactions();
await taskTrans.Add(new TaskAdd()
{
Name = Guid.NewGuid().ToString(), UserUserId = user.UserId, CompletedDate = new DateTime(1900, 1, 1), DueDate = DateTime.Now.AddDays(30), StartedDate = DateTime.Now
});
}
var taskviews = new TaskViews();
var tasks = await taskviews.GetTasksForUser(user.UserId);
tasks.Should().HaveCount(10);
user.Tasks.Should().HaveCount(10);
var first = user.Tasks.First();
user.Tasks.First().User.UserId.Should().Be(user.UserId);
}
/// <summary>
/// fetch-and-compute loop
/// </summary>
/// <returns></returns>
private bool FindMatchingRecord()
{
bool recordFound = false;
if (!StartPosition.IsZero)
{
GatewayResult result = TaskViews.OpenCursors(Reverse, StartPosition);
if (result.Success)
{
IRecord record;
// Looking for one record only
do
{
record = GetBasicRecord();
if (record != null && RecordComputer.Compute(record, true, false, false).Success)
{
recordFound = true;
break;
}
} while (record != null);
}
TaskViews.CloseMainCursor();
}
return(recordFound);
}
public static Task CreateProbeStatisticsTask(
AuthTokens tokens,
string url,
string projectId,
string parentTaskId,
List <string> dependentOns,
List <string> caseDirs,
List <int> cpus,
List <string> sampleSets,
List <string> fields,
Dictionary <string, object> overrides,
bool create
)
{
var config = new Dictionary <string, object>
{
{ "task_type", "cfd" },
{ "cmd", "compute_mesh_independence_result" },
{ "case_dirs", caseDirs },
{ "case_dir", "independence" },
{ "cpus", cpus },
{ "sets", sampleSets },
{ "fields", fields },
};
if (overrides != null)
{
config.Add("overrides", overrides);
}
var createParams = new Dictionary <string, object>
{
{
"config", config
},
{
"dependent_on", dependentOns
}
};
var taskQueryParams = new Dictionary <string, object>
{
{ "name", "Probe Statistics" },
{ "parent", parentTaskId },
{ "project", projectId }
};
var task = TaskViews.GetCreateOrUpdateTask(
tokens,
url,
"/api/task/",
taskQueryParams,
createParams,
create
);
Logger.Info($"Created probe task: {task.UID}");
return(task);
}
public static Task CreateProbeTask(
AuthTokens tokens,
string url,
string projectId,
Dictionary <string, object> taskQueryParams,
string caseDir,
List <int> cpus,
List <Dictionary <string, object> > sampleSets,
List <string> fields,
Dictionary <string, object> overrides,
string probeCommand = "postProcess -func internalCloud",
bool create = false
)
{
var commands = new List <string> {
"write_sample_set"
};
var nCPUs = 1;
cpus.ForEach(cpu => nCPUs *= cpu);
commands.Add(nCPUs > 1 ? $"!{probeCommand}" : probeCommand);
var config = new Dictionary <string, object>
{
{ "task_type", "cfd" },
{ "cmd", "pipeline" },
{ "commands", commands },
{ "case_dir", caseDir },
{ "cpus", cpus },
{ "sets", sampleSets },
{ "fields", fields },
};
if (overrides != null)
{
config.Add("overrides", overrides);
}
var createParams = new Dictionary <string, object>
{
{
"config", config
}
};
taskQueryParams.Add("project", projectId);
var task = TaskViews.GetCreateOrUpdateTask(
tokens,
url,
$"/api/task/",
taskQueryParams,
createParams,
create
);
Logger.Info($"Created probe task: {task.UID}");
return(task);
}
/// <summary>
///
/// </summary>
internal override ReturnResultBase Execute()
{
ReturnResultBase result = null;
if (LocalDataviewManager.UserSorts != null)
{
TaskViews.ApplySort(LocalDataviewManager.UserSorts);
}
else
{
if (!KeepUserSort)
{
TaskViews.ApplySort(Task.RuntimeSorts);
}
}
TaskViews.ApplyUserRangesAndLocates();
SetTaskMode();
if (RefreshMode == ViewRefreshMode.CurrentLocation)
{
InitCurrentPosition();
if (startPosition != null)
{
result = ExecuteRefreshAndKeepCurrentLocation();
if (result.Success)
{
LocalDataviewManager.UserGatewayLocates.Clear();
LocalDataviewManager.UserLocates.Clear();
LocalDataviewManager.UserSorts = null;
}
return(result);
}
}
// clean the position cache
LocalDataviewManager.Reset();
// Release the ViewMain cursor and re-prepare it.
if (TaskViews.ViewMain != null)
{
TaskViews.ViewMain.ReleaseCursor();
TaskViews.ViewMain.Prepare();
}
result = base.Execute();
if (result.Success)
{
DataviewSynchronizer.SetCurrentRecordByIdx(0);
LocalDataviewManager.UserGatewayLocates.Clear();
LocalDataviewManager.UserLocates.Clear();
LocalDataviewManager.UserSorts = null;
}
return(result);
}
public static Task CreateRadianceTask(
AuthTokens tokens,
string url,
Task parentTask,
Task dependentOnTask,
Project project,
types.RadiationSolution solution,
string caseDir,
bool create
)
{
var taskConfig = new Dictionary <string, object>
{
{ "task_type", "radiance" },
{ "cmd", solution.Method },
{ "case_type", solution.CaseType },
{ "cpus", solution.CPUs },
{ "case_dir", caseDir },
{ "probes", solution.Probes },
};
if (solution.Overrides != null)
{
taskConfig.Add("overrides", solution.Overrides.ToDict());
}
if (!string.IsNullOrEmpty(solution.EPWFile))
{
taskConfig.Add("epw_file", Path.GetFileName(solution.EPWFile));
}
var createParams = new Dictionary <string, object>
{
{
"config", taskConfig
}
};
var radianceTask = TaskViews.GetCreateOrUpdateTask(
tokens,
url,
$"/api/task/",
new Dictionary <string, object>
{
{ "name", Utils.SnakeCaseToHumanCase(solution.Method) },
{ "parent", parentTask.UID },
{ "dependent_on", dependentOnTask.UID },
{ "project", project.UID }
},
createParams,
create
);
if (radianceTask.ErrorMessages != null && radianceTask.ErrorMessages.Count > 0)
{
throw new Exception(radianceTask.ErrorMessages.First());
}
return(radianceTask);
}
public async System.Threading.Tasks.Task GetTasksForUser(int userUserId)
{
UserUserId = userUserId;
var Tasks = new TaskViews();
var temp = await Tasks.GetAllForUser(userUserId);
TaskViews.Clear();
foreach (var taskView in temp)
{
TaskViews.Add(taskView);
}
}
/// <summary>
/// override - always get a new record, and no need to refresh the position cache
/// </summary>
/// <returns></returns>
protected override IRecord GetBasicRecord()
{
IRecord record = DataviewSynchronizer.GetRecord(false);
GatewayResult result = TaskViews.GetPrimaryView().Fetch(record);
if (!result.Success)
{
DataviewSynchronizer.RemoveRecord(record);
record = null;
}
return(record);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
internal override ReturnResultBase Execute()
{
GatewayResult result = new GatewayResult();
if (!TaskViews.Task.isAborting() && TaskViews.ApplySort(Sorts))
{
localDataViewCommandViewRefresh.DataviewManager = DataviewManager;
localDataViewCommandViewRefresh.LocalManager = LocalManager;
localDataViewCommandViewRefresh.Execute();
}
return(result);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
internal override ReturnResultBase Execute()
{
IRecord record = DataviewSynchronizer.GetCurrentRecord();
GatewayResult result = TaskViews.GetPrimaryView().FetchCurrent(record);
if (result.Success)
{
TaskViews.RecordComputer.Compute(record, false, false, false);
}
return(result);
}
internal override ReturnResultBase Execute()
{
GatewayResult result = new GatewayResult();
IRecord modifiedRecord = DataviewSynchronizer.GetModifiedRecord();
DataviewSynchronizer.PrepareForModification();
if (modifiedRecord != null)
{
result = TaskViews.ApplyModifications(modifiedRecord);
DataviewSynchronizer.UpdateDataviewAfterModification(result.Success);
}
return(result);
}
/// <summary>
/// fetch record
/// </summary>
/// <returns></returns>
protected virtual IRecord GetBasicRecord()
{
IRecord record = DataviewSynchronizer.GetRecord(UseFirstRecord);
UseFirstRecord = false;
GatewayResult result = TaskViews.GetPrimaryView().Fetch(record);
UpdateViewEnd(result);
if (!result.Success)
{
DataviewSynchronizer.RemoveRecord(record);
record = null;
}
return(record);
}
private void CloseTables()
{
foreach (DataSourceReference dataSourceRef in Task.DataSourceReferences)
{
if (dataSourceRef.IsLocal)
{
//create gw close command
GatewayCommandFileClose fileCloseCommand = GatewayCommandsFactory.CreateFileCloseCommand(dataSourceRef.DataSourceDefinition, LocalManager);
fileCloseCommand.Execute();
}
}
if (TaskViews != null)
{
TaskViews.CloseTables();
}
}
internal override ReturnResultBase Execute()
{
if (TaskViews != null)
{
TaskViews.ReleaseCursors();
}
//close transaction
CloseTables();
if (LocalDataviewManager.RecordingManager != null)
{
LocalDataviewManager.RecordingManager.StopRecording();
}
return(new GatewayResult());
}
/// <summary>
/// setup main cursor for fetch
/// executed for all types of fetches
/// </summary>
/// <returns></returns>
private GatewayResult SetupMainCursor()
{
GatewayResult gatewayResult;
UpdateViewBoundaries(StartPosition);
gatewayResult = TaskViews.OpenCursors(Reverse, StartPosition);
//move to strategy ????
if (gatewayResult.Success && StartingPositionType == StartingPositionType.AfterStartingRecord &&
PositionCache.ContainsValue(startPosition))
{
IRecord dummyRecord = DataviewSynchronizer.CreateRecord();
gatewayResult = TaskViews.FetchMain(dummyRecord);
}
return(gatewayResult);
}
public static Task CreateRadiationProbeTask(
AuthTokens tokens,
string url,
string projectId,
Dictionary <string, object> taskQueryParams,
string caseDir,
List <Dictionary <string, object> > sampleSets,
bool create
)
{
var config = new Dictionary <string, object>
{
{ "task_type", "magpy" },
{ "cmd", "radiance.io.tasks.write_radiation_samples_set" },
{ "case_dir", caseDir },
{ "sets", sampleSets },
};
var createParams = new Dictionary <string, object>
{
{ "config", config },
{ "status", "pending" }
};
taskQueryParams.Add("project", projectId);
var task = TaskViews.GetCreateOrUpdateTask(
tokens,
url,
$"/api/task/",
taskQueryParams,
createParams,
create
);
if (task.ErrorMessages != null)
{
throw new Exception(task.ErrorMessages.First());
}
return(task);
}
internal void RemoveRecord(IRecord record)
{
Record currRec = ((Record)record).getPrevRec();
if (currRec == null)
{
currRec = ((Record)record).getNextRec();
}
if (currRec != null)
{
SetCurrentRecord(currRec.getId());
}
else
{
Dataview.reset();
}
Dataview.RemoveRecord((Record)record);
TaskViews.ClearRecord(record);
UpdateTableChildrenArraysSize();
}
internal override ReturnResultBase Execute()
{
bool isEmptyDataView = ((DataView)(Task.DataView)).isEmptyDataview();
DataviewSynchronizer.SetupDataview(Reverse);
IRecord origRecord = DataviewSynchronizer.GetCurrentRecord();
TaskViews.ViewMain.IgnorePositionCache = true;
GatewayResult result = TaskViews.OpenCursors(Reverse, new DbPos(true));
if (result.Success)
{
IRecord record;
while ((record = GetBasicRecord()) != null)
{
if (RecordComputer.Compute(record, true, false, false).Success)
{
//execute event OnRecordFetchEvent
onRecordFetch((Record)record);
DataviewSynchronizer.RemoveRecord(record);
}
}
}
TaskViews.CloseMainCursor();
TaskViews.ViewMain.IgnorePositionCache = false;
if (origRecord != null)
{
DataviewSynchronizer.SetCurrentRecord(origRecord != null ? origRecord.getId() : Int32.MinValue);
((DataView)(Task.DataView)).takeFldValsFromCurrRec();
}
((DataView)(Task.DataView)).setEmptyDataview(isEmptyDataView);
return(result);
}
/// <summary>
/// execute command
/// </summary>
internal override ReturnResultBase Execute()
{
DataviewSynchronizer.SetupDataview(Reverse);
GatewayResult gatewayResult = SetupMainCursor();
ReturnResultBase result;
int fetchedRecordNumber = 0;
if (gatewayResult.Success)
{
for (fetchedRecordNumber = 0; !StopFetches(fetchedRecordNumber);)
{
IRecord record = GetBasicRecord();
if (record != null && RecordComputer.Compute(record, true, false, false).Success)
{
fetchedRecordNumber++;
}
}
}
else
{
UpdateViewEnd(gatewayResult);
}
TaskViews.CloseMainCursor();
//If PerformUpdateAfterFetch is false , the UpdateAterFetch () should be called only if recs are fetched.
if (gatewayResult.Success && (PerformUpdateAfterFetch || fetchedRecordNumber > 0))
{
result = UpdateAfterFetch();
}
else
{
result = gatewayResult;
}
return(result);
}
public static string CreatePressureCoefficientTask(
string inputJson,
List <string> probeNames,
List <int> cpus,
string dependentOn,
string overrides,
bool create
)
{
var inputData = new Inputs().FromJson(inputJson);
var tokens = inputData.Auth;
var parentTask = inputData.Task;
var subTasks = inputData.SubTasks;
var postProcessTask =
Tasks.Utils.GetDependentTask(subTasks, dependentOn, inputData.Url, tokens, parentTask.UID);
var project = inputData.Project;
var overrideDict = JsonConvert.DeserializeObject <Dictionary <string, object> >(overrides);
if (parentTask?.UID == null)
{
return(null);
}
var taskQueryParams = new Dictionary <string, object>
{
{ "name", "Pressure Coefficient" },
{ "parent", parentTask.UID },
{ "project", project.UID }
};
if (postProcessTask != null)
{
taskQueryParams.Add("dependent_on", postProcessTask.UID);
}
var taskCreateParams = new Dictionary <string, object>
{
{
"config", new Dictionary <string, object>
{
{ "task_type", "cfd" },
{ "cmd", "calculate_pressure_coefficients" },
{ "case_dir", "VWT" },
{ "probes", probeNames },
{ "cpus", cpus },
{ "overrides", overrideDict }
}
}
};
var task = TaskViews.GetCreateOrUpdateTask(tokens, inputData.Url, "/api/task/", taskQueryParams,
taskCreateParams, create);
if (task.ErrorMessages != null)
{
throw new Exception(task.ErrorMessages[0]);
}
if (inputData.SubTasks != null)
{
inputData.SubTasks.Add(task);
}
else
{
inputData.SubTasks = new List <Task> {
task
};
}
Logger.Info($"Created Pressure Coefficient task: {task.UID}");
return(inputData.ToJson());
}
internal void BuildViewsCollection(Task task)
{
TaskViews = TaskViewsBuilder.BuildViewsCollection(task);
TaskViews.ApplySort(task.RuntimeSorts);
}
public TaskPlannerOptimize(UserInterface.UserInterfaceBase userOptions, TaskViews taskSource, TaskViews taskTarget, Tasks.Tasks tasks, Tasks.FileLists fileLists, PlaylistUpdates.PlaylistUpdates playlistUpdates)
: base(userOptions, taskSource, taskTarget, tasks, fileLists, playlistUpdates)
{
similarTermsModel = new SimilarTermsModel();
}
public TaskPlannerRemoveDuplicates(UserInterface.UserInterfaceBase userOptions, TaskViews taskSource, TaskViews taskTarget, Tasks.Tasks tasks, Tasks.FileLists fileLists, TaskPlanner.DuplicatesModel Duplicates, PlaylistUpdates.PlaylistUpdates playlistUpdates)
: base(userOptions, taskSource, taskTarget, tasks, fileLists, playlistUpdates)
{
this.DuplicatesModel = Duplicates;
}
public static string ComputeWindThresholds(
string inputJson,
string epwFile,
List <string> patches,
List <string> thresholds,
List <int> cpus,
string dependentOn = "Probe",
bool create = false
)
{
var inputData = new Inputs().FromJson(inputJson);
var tokens = inputData.Auth;
var parentTask = inputData.Task;
var subTasks = inputData.SubTasks;
var postProcessTask =
Tasks.Utils.GetDependentTask(subTasks, dependentOn, inputData.Url, tokens, parentTask.UID);
var project = inputData.Project;
if (parentTask?.UID == null)
{
return(null);
}
var taskQueryParams = new Dictionary <string, object>
{
{ "name", "Wind Thresholds" },
{ "parent", parentTask.UID },
{ "project", project.UID }
};
if (postProcessTask != null)
{
taskQueryParams.Add("dependent_on", postProcessTask.UID);
}
if (!File.Exists(epwFile))
{
throw new Exception("A .epw file is needed to proceed!");
}
if (create)
{
Tasks.Upload.UploadEPWFile(tokens, inputData.Url, parentTask.UID, epwFile);
}
var _thresholds = thresholds.Select(threshold => new Thresholds.WindThreshold().FromJson(threshold))
.ToList();
var epwName = Path.GetFileName(epwFile);
var taskCreateParams = new Dictionary <string, object>
{
{
"config", new Dictionary <string, object>
{
{ "task_type", "cfd" },
{ "cmd", "run_wind_thresholds" },
{ "case_dir", "VWT/" },
{ "epw_file", $"weather/{epwName}" },
{ "patches", patches },
{ "thresholds", _thresholds },
{ "set_foam_patch_fields", false },
{ "cpus", cpus },
}
}
};
var task = TaskViews.GetCreateOrUpdateTask(tokens, inputData.Url, "/api/task/", taskQueryParams,
taskCreateParams, create);
if (task.ErrorMessages != null)
{
throw new Exception(task.ErrorMessages[0]);
}
if (inputData.SubTasks != null)
{
inputData.SubTasks.Add(task);
}
else
{
inputData.SubTasks = new List <Task> {
task
};
}
Logger.Info($"Created Wind Threshold task: {task.UID}");
return(inputData.ToJson());
}
public static string Create(
string inputJson,
string overrides,
string preset,
List <int> cpus,
string caseDir,
bool create
)
{
var inputData = new Inputs().FromJson(inputJson);
var tokens = inputData.Auth;
var parentTask = inputData.Task;
var project = inputData.Project;
var solution = inputData.RadiationSolution;
var subTasks = inputData.SubTasks;
var daylightTask = GetDaylightTask(subTasks, Utils.SnakeCaseToHumanCase(solution.Method));
var _overrides = JsonConvert.DeserializeObject <Dictionary <string, object> >(overrides);
if (parentTask == null)
{
return(null);
}
if (project == null)
{
return(null);
}
var taskQueryParams = new Dictionary <string, object>
{
{ "name", Utils.SnakeCaseToHumanCase(preset) },
{ "parent", parentTask.UID },
{ "project", project.UID }
};
if (daylightTask != null)
{
taskQueryParams.Add("dependent_on", daylightTask.UID);
}
var taskCreateParams = new Dictionary <string, object>
{
{
"config", new Dictionary <string, object>
{
{ "task_type", "radiance" },
{ "cmd", $"{preset}" },
{ "overrides", _overrides },
{ "cpus", cpus },
{ "case_dir", caseDir },
{ "result_names", solution.Probes.Keys }
}
}
};
// First Action to create Mesh Files
var metricTask = TaskViews.GetCreateOrUpdateTask(
tokens,
inputData.Url,
$"/api/task/",
taskQueryParams,
taskCreateParams,
create
);
if (metricTask.ErrorMessages != null && metricTask.ErrorMessages.Count > 0)
{
throw new Exception(metricTask.ErrorMessages.First());
}
inputData.SubTasks.Add(metricTask);
return(inputData.ToJson());
}
public static Task CreateRadianceActionTask(
AuthTokens tokens,
string url,
Task parentTask,
Task probeTask,
Project project,
types.RadiationSolution solution,
string caseDir,
bool create
)
{
var actionTaskQueryParams = new Dictionary <string, object>
{
{ "name", "Actions" },
{ "parent", parentTask.UID },
{ "project", project.UID }
};
if (probeTask != null)
{
actionTaskQueryParams.Add("dependent_on", probeTask.UID);
}
var actionTaskConfig = new Dictionary <string, object>
{
{ "task_type", "magpy" },
{ "cmd", "radiance.io.tasks.write_rad" },
{ "materials", solution.Materials.Select(material => material.ToDict()).ToList() },
{ "case_dir", caseDir },
{ "method", solution.Method },
};
if (solution.Overrides != null && solution.Overrides.ReinhartDivisions > 1)
{
actionTaskConfig.Add("reinhart_divisions", solution.Overrides.ReinhartDivisions);
}
// Tasks to Handle MagPy Celery Actions
// First Action to create Mesh Files
var actionTask = TaskViews.GetCreateOrUpdateTask(
tokens,
url,
$"/api/task/",
actionTaskQueryParams,
new Dictionary <string, object>
{
{
"config", actionTaskConfig
}
},
create
);
if (actionTask.ErrorMessages == null || actionTask.ErrorMessages.Count <= 0)
{
return(actionTask);
}
if (actionTask.ErrorMessages.First() == "No object found.")
{
return(null);
}
throw new Exception(actionTask.ErrorMessages.First());
}
public async Task Load(int taskId)
{
var uv = new TaskViews();
this.TaskView = await uv.Get(taskId);
}
public TaskPlannerMirror(UserInterface.UserInterfaceBase userOptions, TaskViews taskSource, TaskViews taskTarget, Tasks.Tasks tasks, FileLists fileLists, PlaylistUpdates.PlaylistUpdates playlistUpdates)
: base(userOptions, taskSource, taskTarget, tasks, fileLists, playlistUpdates)
{
//
}
internal override ReturnResultBase Execute()
{
return(TaskViews.Prepare());
}
public static string CreateComfortTask(
string inputJson,
string epwFile,
string method,
List <string> probes,
List <string> thresholds,
List <int> cpus,
string dependentOn = "Probe",
bool create = false)
{
var inputData = new Inputs().FromJson(inputJson);
var tokens = inputData.Auth;
var parentTask = inputData.Task;
var subTasks = inputData.SubTasks;
var postProcessTask =
Tasks.Utils.GetDependentTask(subTasks, dependentOn, inputData.Url, tokens, parentTask.UID);
var project = inputData.Project;
if (parentTask?.UID == null)
{
return(null);
}
var taskQueryParams = new Dictionary <string, object>
{
{ "name", Utils.SnakeCaseToHumanCase(method) },
{ "parent", parentTask.UID },
{ "project", project.UID }
};
if (postProcessTask != null)
{
taskQueryParams.Add("dependent_on", postProcessTask.UID);
}
if (!File.Exists(epwFile))
{
throw new Exception("A .epw file is needed to proceed!");
}
var epwName = Path.GetFileName(epwFile);
if (create)
{
Tasks.Upload.UploadEPWFile(tokens, inputData.Url, parentTask.UID, epwFile);
}
var _thresholds = thresholds.Select(threshold => new Thresholds.ComfortThreshold().FromJson(threshold))
.ToList();
var taskCreateParams = new Dictionary <string, object>
{
{
"config", new Dictionary <string, object>
{
{ "task_type", "radiance" },
{ "cmd", "outdoor_comfort" },
{ "case_dir", "results" },
{ "epw_file", epwName },
{ "probes", probes },
{ "thresholds", _thresholds },
{ "cpus", cpus },
{ "comfort_index", method },
{ "wind_dir", "urbanComfort" }
}
}
};
var task = TaskViews.GetCreateOrUpdateTask(tokens, inputData.Url, "/api/task/", taskQueryParams,
taskCreateParams, create);
if (task.ErrorMessages != null)
{
throw new Exception(task.ErrorMessages[0]);
}
if (inputData.SubTasks != null)
{
inputData.SubTasks.Add(task);
}
else
{
inputData.SubTasks = new List <Task> {
task
};
}
Logger.Info($"Created Outdoor Comfort task: {task.UID}");
return(inputData.ToJson());
}
