public HttpResponseMessage NewOngoingTask([FromBody] dynamic data)
{
SLW_DatabaseInfo db = new SLW_DatabaseInfo();
KeyDetail detail = db.GetKeyDetail((string)data.access_key);
if (detail.data_present)
{
UnassignedTask unassigned = db.GetSingleUnassignedTask((string)data.application_id);
db.DeleteUnassignedTask((string)data.application_id);
UserDetails userDetailsAdmin = db.GetUserDetails(detail.username);
db.NewOngoingTask((string)data.application_id, (string)data.assigned_to, unassigned.username, (string)data.status, unassigned.created_date_raw, userDetailsAdmin.fullname, userDetailsAdmin.username);
db.UpdateApplicationStatus((string)data.application_id, Commons.Constants.PENDING_TYPE, DateTime.Now);
OngoingTask ongoing = db.GetSingleOngoingTask((string)data.application_id);
UserDetails userDetails = db.GetUserDetails(ongoing.assigned_to);
ongoing.assigned_to = userDetails.fullname;
db.SaveActivity(new UserActivity(detail.username, Commons.Constants.ACTIVITY_NEW_ONGOING, (string)data.application_id, (string)data.assigned_to, 1));
Form form = db.GetApplication((string)data.application_id);
Email.Send(userDetails.email, "New Type Approval Application", "Type approval application " + form.application_id + " for Device with Model number " + form.product_identification + " from " + ongoing.submitted_by + " is assigned to you for processing.");
return(Request.CreateResponse(HttpStatusCode.OK, ongoing));
}
else
{
return(Request.CreateResponse(HttpStatusCode.Forbidden, "invalid key"));
}
}
public HttpResponseMessage ReassignTask([FromBody] dynamic data)
{
SLW_DatabaseInfo db = new SLW_DatabaseInfo();
KeyDetail detail = db.GetKeyDetail((string)data.access_key);
if (detail.data_present)
{
OngoingTask prev_ongoing = db.GetSingleOngoingTask((string)data.application_id);
db.ReassignTask((string)data.application_id, (string)data.assign_to);
OngoingTask ongoing = db.GetSingleOngoingTask((string)data.application_id);
UserDetails prevUserDetails = db.GetUserDetails(prev_ongoing.assigned_to);
UserDetails userDetails = db.GetUserDetails(ongoing.assigned_to);
Form form = db.GetApplication((string)data.application_id);
ongoing.assigned_to = userDetails.fullname;
db.SaveActivity(new UserActivity(detail.username, Commons.Constants.ACTIVITY_REASSIGN_TASK, (string)data.application_id, (string)data.assign_to, 1));
Email.Send(userDetails.email, "New Type Approval Application", "Type approval application " + form.application_id + " for Device with Model number " + form.product_identification + " from " + ongoing.submitted_by + " is assigned to you for processing.");
Email.Send(prevUserDetails.email, "Assigned Type Approval Application", "Application " + form.application_id + " that had been assigned to you has been reassigned.");
return(Request.CreateResponse(HttpStatusCode.OK, ongoing));
}
else
{
return(Request.CreateResponse(HttpStatusCode.Unauthorized, "invalid key"));
}
}
private void WriteResult(JsonOperationContext context, OngoingTask taskInfo)
{
HttpContext.Response.StatusCode = (int)HttpStatusCode.OK;
using (var writer = new BlittableJsonTextWriter(context, ResponseBodyStream()))
{
context.Write(writer, taskInfo.ToJson());
writer.Flush();
}
}
public HttpResponseMessage MoveToUnassigned([FromBody] dynamic data)
{
SLW_DatabaseInfo db = new SLW_DatabaseInfo();
KeyDetail detail = db.GetKeyDetail((string)data.access_key);
if (detail.data_present)
{
OngoingTask ongoing = db.GetSingleOngoingTask((string)data.application_id);
db.DeleteOngoingTask((string)data.application_id);
db.NewUnassignedTask(ongoing.application_id, ongoing.submitted_by_username, ongoing.created_date_raw);
db.UpdateApplicationStatus((string)data.application_id, Commons.Constants.SUBMITTED_TYPE, DateTime.Now);
db.SaveActivity(new UserActivity(detail.username, Commons.Constants.ACTIVITY_MOVE_UNASSAIGNED, (string)data.application_id, "", 1));
return(Request.CreateResponse(HttpStatusCode.OK, new UnassignedTask(ongoing.application_id, ongoing.created_date, ongoing.created_date_raw, ongoing.submitted_by, ongoing.submitted_by_username)));
}
else
{
return(Request.CreateResponse(HttpStatusCode.Unauthorized, "invalid key"));
}
}
public async Task CanPassNodeTagToRestoreBackupOperation()
{
var myBackupsList = new List <MyBackup>();
var backupPath = NewDataPath(suffix: "BackupFolder");
var clusterSize = 3;
var databaseName = GetDatabaseName();
var cluster = await CreateRaftCluster(clusterSize, false);
using (var store = new DocumentStore
{
Urls = new[] { cluster.Leader.WebUrl },
Database = databaseName,
}.Initialize())
{
var doc = new DatabaseRecord(databaseName);
var databaseResult = await store.Maintenance.Server.SendAsync(new CreateDatabaseOperation(doc, clusterSize));
await store.Maintenance.SendAsync(new CreateSampleDataOperation());
var myNodesList = databaseResult.Topology.AllNodes.ToList();
Assert.True(clusterSize == myNodesList.Count, $"clusterSize({clusterSize}) == myNodesList.Count({myNodesList.Count})");
foreach (var node in myNodesList)
{
var myGuid = Guid.NewGuid();
var backupConfig = Backup.CreateBackupConfiguration(Path.Combine(backupPath, myGuid.ToString()), name: $"Task_{node}_{myGuid}", mentorNode: node);
var result = await store.Maintenance.SendAsync(new UpdatePeriodicBackupOperation(backupConfig));
await WaitForRaftIndexToBeAppliedOnClusterNodes(result.RaftCommandIndex, cluster.Nodes);
OngoingTask res = null;
await WaitForValueAsync(async() =>
{
res = await store.Maintenance.SendAsync(new GetOngoingTaskInfoOperation(result.TaskId, OngoingTaskType.Backup));
return(res.ResponsibleNode.NodeTag);
}, node, interval : 333);
Assert.NotNull(res);
Assert.True(node == res.MentorNode, $"node({node}) == res.MentorNode({res.MentorNode})");
Assert.True(node == res.ResponsibleNode.NodeTag, $"node({node}) == res.ResponsibleNode.NodeTag({res.ResponsibleNode.NodeTag})");
myBackupsList.Add(new MyBackup
{
BackupTaskId = result.TaskId,
Guid = myGuid,
NodeTag = res.ResponsibleNode.NodeTag
});
}
foreach (var myBackup in myBackupsList)
{
var res = await store.Maintenance.SendAsync(new StartBackupOperation(isFullBackup : true, myBackup.BackupTaskId));
Assert.True(myBackup.NodeTag == res.Result.ResponsibleNode, $"myBackup.NodeTag({myBackup.NodeTag}) == res.ResponsibleNode({res.Result.ResponsibleNode})");
var operation = new GetPeriodicBackupStatusOperation(myBackup.BackupTaskId);
PeriodicBackupStatus status = null;
var value = WaitForValue(() =>
{
status = store.Maintenance.Send(operation).Status;
if (status?.LastEtag == null)
{
return(false);
}
return(true);
}, true);
Assert.True(value, $"Got status: {status != null}, exception: {status?.Error?.Exception}, LocalBackup.Exception: {status?.LocalBackup?.Exception}");
Assert.True(status != null, $"status != null, exception: {status?.Error?.Exception}, LocalBackup.Exception: {status?.LocalBackup?.Exception}");
Assert.True(myBackup.NodeTag == status.NodeTag, $"myBackup.NodeTag({myBackup.NodeTag}) == status.NodeTag({status.NodeTag})");
var prePath = Path.Combine(backupPath, myBackup.Guid.ToString());
myBackup.BackupPath = Path.Combine(prePath, status.FolderName);
}
var dbs = new List <string>();
foreach (var myBackup in myBackupsList)
{
var name = $"restored_DB1_{myBackup.NodeTag}";
var restoreConfig = new RestoreBackupConfiguration
{
DatabaseName = name,
BackupLocation = myBackup.BackupPath
};
dbs.Add(name);
var restoreBackupTask = store.Maintenance.Server.Send(new RestoreBackupOperation(restoreConfig, myBackup.NodeTag));
restoreBackupTask.WaitForCompletion(TimeSpan.FromSeconds(30));
}
var dbNames = await store.Maintenance.Server.SendAsync(new GetDatabaseNamesOperation(0, int.MaxValue));
Assert.Equal(clusterSize + 1, dbNames.Length);
dbs.ForEach(db => Assert.True(dbNames.Contains(db), $"numOfDbs.Contains(db), db = {db}"));
}
}
