public IActionResult GetAllWorkers()
{
using (var context = new tasktDbContext())
{
var workers = context.Workers.ToList();
//get pools
var workerPools = context.WorkerPools.Include(f => f.PoolWorkers);
foreach (var pool in workerPools)
{
if (pool.PoolWorkers.Count == 0)
{
continue;
}
var worker = new Worker
{
WorkerID = pool.WorkerPoolID,
UserName = string.Concat("Pool '", pool.WorkerPoolName, "'")
};
workers.Add(worker);
}
return(Ok(workers));
}
}
public IActionResult GetTopWorkers()
{
using (var context = new tasktDbContext())
{
var topWorkerList = new List <TopWorker>();
var groupedWorker = context.Tasks.ToList().Where(f => f.TaskStarted >= DateTime.Now.AddDays(-1)).GroupBy(f => f.WorkerID).OrderByDescending(f => f.Count());
foreach (var wrkr in groupedWorker)
{
var workerInfo = context.Workers.Where(f => f.WorkerID == wrkr.Key).FirstOrDefault();
string userName = "******";
if (!(workerInfo is null))
{
userName = workerInfo.UserName + " (" + workerInfo.MachineName + ")";
}
topWorkerList.Add(new TopWorker
{
WorkerID = wrkr.Key,
UserName = userName,
TotalTasks = wrkr.Count(),
RunningTasks = wrkr.Where(f => f.Status == "Running").Count(),
CompletedTasks = wrkr.Where(f => f.Status == "Completed").Count(),
ClosedTasks = wrkr.Where(f => f.Status == "Closed").Count(),
ErrorTasks = wrkr.Where(f => f.Status == "Error").Count()
});
}
return(Ok(topWorkerList));
}
}
public IActionResult AddDataToBotStore([FromBody] BotStoreModel storeData)
{
using (var context = new tasktDbContext())
{
if (!context.Workers.Any(f => f.WorkerID == storeData.LastUpdatedBy))
{
return(Unauthorized());
}
if (context.BotStore.Any(f => f.BotStoreName == storeData.BotStoreName))
{
var existingItem = context.BotStore.Where(f => f.BotStoreName == storeData.BotStoreName).FirstOrDefault();
existingItem.BotStoreValue = storeData.BotStoreValue;
existingItem.LastUpdatedOn = DateTime.Now;
existingItem.LastUpdatedBy = storeData.LastUpdatedBy;
}
else
{
storeData.LastUpdatedOn = DateTime.Now;
context.BotStore.Add(storeData);
}
context.SaveChanges();
return(Ok(storeData));
}
}
public IActionResult GetDataBotStore([FromBody] BotStoreRequest requestData)
{
using (var context = new tasktDbContext())
{
if (!context.Workers.Any(f => f.WorkerID == requestData.workerID))
{
return(Unauthorized());
}
var requestedItem = context.BotStore.Where(f => f.BotStoreName == requestData.BotStoreName).FirstOrDefault();
if (requestedItem == null)
{
return(NotFound());
}
switch (requestData.requestType)
{
case BotStoreRequest.RequestType.BotStoreValue:
return(Ok(requestedItem.BotStoreValue));
case BotStoreRequest.RequestType.BotStoreModel:
return(Ok(requestedItem));
default:
return(StatusCode(400));
}
}
}
public IActionResult GetAllPublishedScripts()
{
using (var context = new tasktDbContext())
{
//var publishedScripts = context.PublishedScripts.ToList().OrderBy(f => f.WorkerID);
//var workers = context.Workers.Include(d => context.Workers.Where(f => f.WorkerID == d.WorkerID));
//context.PublishedScripts.Include(context.Workers.ToList());
var scripts = (from publishedScripts in context.PublishedScripts
join worker in context.Workers on publishedScripts.WorkerID equals worker.WorkerID
select new PublishedScript
{
FriendlyName = publishedScripts.FriendlyName,
PublishedOn = publishedScripts.PublishedOn,
PublishedScriptID = publishedScripts.PublishedScriptID,
ScriptData = publishedScripts.ScriptData,
ScriptType = publishedScripts.ScriptType,
WorkerID = publishedScripts.WorkerID,
MachineName = worker.MachineName,
WorkerName = worker.UserName
}).ToList();
return(Ok(scripts));
}
}
public IActionResult GetAllAssignments()
{
using (var context = new tasktDbContext())
{
var assignments = context.Assignments.ToList().OrderByDescending(f => f.NewTaskDue);
return(Ok(assignments));
}
}
public IActionResult ScriptExistsCheck([FromQuery] Guid workerID, string friendlyName)
{
using (var context = new tasktDbContext())
{
var exists = context.PublishedScripts.Where(f => f.WorkerID == workerID && f.FriendlyName == friendlyName).Any();
return(Ok(exists));
}
}
public IActionResult GetAllTasks()
{
using (var context = new tasktDbContext())
{
var runningTasks = context.Tasks.ToList().OrderByDescending(f => f.TaskStarted).Take(5);
return(Ok(runningTasks));
}
}
public IActionResult GetAuthorizedWorkers()
{
using (var context = new tasktDbContext())
{
var workers = context.Workers.Count();
return(Ok(workers + " known worker(s)"));
}
}
public IActionResult AddAssignment([FromBody] Assignment assignment)
{
using (var context = new tasktDbContext())
{
context.Assignments.Add(assignment);
context.SaveChanges();
return(Ok(assignment));
}
}
public IActionResult ScheduleTask([FromBody] NewTaskRequest request)
{
//Todo: Add Auth Check, Change to HTTPPost and validate workerID is valid
if (request is null)
{
return(BadRequest());
}
using (var context = new tasktDbContext())
{
var publishedScript = context.PublishedScripts.Where(f => f.PublishedScriptID == request.publishedScriptID).FirstOrDefault();
if (publishedScript == null)
{
return(BadRequest());
}
//find worker
var workerRecord = context.Workers.Where(f => f.WorkerID == request.workerID).FirstOrDefault();
//if worker wasnt found then search for pool
if (workerRecord == null)
{
//find from pool
var poolExists = context.WorkerPools.Any(s => s.WorkerPoolID == request.workerID);
//if pool wasnt found
if (!poolExists)
{
//return bad request
return(BadRequest());
}
}
//create new task
var newTask = new Task();
newTask.WorkerID = request.workerID;
newTask.TaskStarted = DateTime.Now;
newTask.Status = "Scheduled";
newTask.ExecutionType = "Remote";
newTask.Script = publishedScript.PublishedScriptID.ToString();
newTask.Remark = "Scheduled by tasktServer";
var entry = context.Tasks.Add(newTask);
context.SaveChanges();
return(Ok(newTask));
}
}
public IActionResult GetRunningTasks([FromQuery] DateTime?startDate = null)
{
if (startDate == null)
{
startDate = DateTime.Today;
}
using (var context = new tasktDbContext())
{
var runningTasks = context.Tasks.Where(f => f.Status == "Running").Where(f => f.TaskStarted >= startDate).Count();
return(Ok(runningTasks + " running"));
}
}
public IActionResult AddNewWorker(string userName, string machineName)
{
using (var context = new tasktDbContext())
{
var newWorker = new Worker();
newWorker.UserName = userName;
newWorker.MachineName = machineName;
newWorker.LastCheckIn = DateTime.Now;
newWorker.Status = WorkerStatus.Pending;
context.Workers.Add(newWorker);
context.SaveChanges();
return(Ok(newWorker));
}
}
public IActionResult NewTask(Guid workerID, string taskName, string userName, string machineName)
{
//Todo: Add Auth Check, Change to HTTPPost and validate workerID is valid
using (var context = new tasktDbContext())
{
var workerExists = context.Workers.Where(f => f.WorkerID == workerID).Count() > 0;
if (!workerExists)
{
//create new worker
var newWorker = new Worker();
newWorker.WorkerID = workerID;
newWorker.UserName = userName;
newWorker.MachineName = machineName;
newWorker.LastCheckIn = DateTime.Now;
newWorker.Status = WorkerStatus.AutoPending;
context.Workers.Add(newWorker);
context.SaveChanges();
//return Unauthorized();
}
//close out any stale tasks
var staleTasks = context.Tasks.Where(f => f.WorkerID == workerID && f.Status == "Running");
foreach (var task in staleTasks)
{
task.Status = "Closed";
}
var newTask = new Task();
newTask.WorkerID = workerID;
newTask.UserName = userName;
newTask.MachineName = machineName;
newTask.TaskStarted = DateTime.Now;
newTask.Status = "Running";
newTask.ExecutionType = "Local";
newTask.Script = taskName;
var entry = context.Tasks.Add(newTask);
context.SaveChanges();
return(Ok(newTask));
}
}
public IActionResult PublishScript([FromBody] PublishedScript script)
{
using (var context = new tasktDbContext())
{
if (script.OverwriteExisting)
{
var currentItem = context.PublishedScripts.Where(f => f.WorkerID == script.WorkerID && f.FriendlyName == script.FriendlyName).OrderByDescending(f => f.PublishedOn).FirstOrDefault();
currentItem.PublishedOn = DateTime.Now;
currentItem.ScriptData = script.ScriptData;
context.SaveChanges();
return(Ok("The script has been updated on the server."));
}
else
{
script.PublishedOn = DateTime.Now;
context.PublishedScripts.Add(script);
context.SaveChanges();
return(Ok("The script has been successfully published."));
}
}
}
public IActionResult UpdateTask(Guid taskID, string status, Guid workerID, string userName, string machineName, string remark)
{
//Todo: Needs Testing
using (var context = new tasktDbContext())
{
var taskToUpdate = context.Tasks.Where(f => f.TaskID == taskID).FirstOrDefault();
if (status == "Completed")
{
taskToUpdate.TaskFinished = DateTime.Now;
taskToUpdate.TotalSeconds = (taskToUpdate.TaskFinished - taskToUpdate.TaskStarted).TotalSeconds;
}
taskToUpdate.UserName = userName;
taskToUpdate.MachineName = machineName;
taskToUpdate.Remark = remark;
taskToUpdate.Status = status;
context.SaveChanges();
return(Ok(taskToUpdate));
}
}
private void DoWork(object state)
{
tasktDbContext dbContext = new tasktDbContext();
var assignments = dbContext.Assignments.Where(f => f.Enabled);
//look through each assignment to see if anything is required to be executed
foreach (var assn in assignments)
{
if (assn.NewTaskDue <= DateTime.Now)
{
//create task
var newTask = new Shared.DbModels.Task();
newTask.WorkerID = assn.AssignedWorker;
newTask.TaskStarted = DateTime.Now;
newTask.Status = "Scheduled";
newTask.ExecutionType = "Assignment";
newTask.Script = assn.PublishedScriptID.ToString();
newTask.Remark = "Scheduled by tasktServer";
dbContext.Tasks.Add(newTask);
//update database
switch (assn.Interval)
{
case Assignment.TimeInterval.Seconds:
assn.NewTaskDue = DateTime.Now.AddSeconds(assn.Frequency);
break;
case Assignment.TimeInterval.Minutes:
assn.NewTaskDue = DateTime.Now.AddMinutes(assn.Frequency);
break;
case Assignment.TimeInterval.Days:
assn.NewTaskDue = DateTime.Now.AddDays(assn.Frequency);
break;
case Assignment.TimeInterval.Months:
assn.NewTaskDue = DateTime.Now.AddMonths(assn.Frequency);
break;
default:
break;
}
}
}
//look through stale tasks to expire after 10 minutes
var staleTasks = dbContext.Tasks.Where(f => f.ExecutionType == "Assignment" && f.TaskStarted <= DateTime.Now.AddMinutes(-10) && f.Status == "Scheduled");
foreach (var task in staleTasks)
{
task.Status = "Closed";
task.Remark = "Closed by service due to unavailable client";
task.TaskFinished = DateTime.Now;
}
dbContext.SaveChanges();
_logger.LogInformation("Timed Background Service is working.");
}
public IActionResult CheckInWorker(Guid workerID, bool engineBusy)
{
using (var context = new tasktDbContext())
{
var targetWorker = context.Workers.Where(f => f.WorkerID == workerID).FirstOrDefault();
if (targetWorker is null)
{
return(BadRequest());
}
else
{
targetWorker.LastCheckIn = DateTime.Now;
Task scheduledTask = null;
PublishedScript publishedScript = null;
if (!engineBusy)
{
scheduledTask = context.Tasks.Where(f => f.WorkerID == workerID && f.Status == "Scheduled").FirstOrDefault();
if (scheduledTask != null)
{
//worker directly scheduled
publishedScript = context.PublishedScripts.Where(f => f.PublishedScriptID.ToString() == scheduledTask.Script).FirstOrDefault();
if (publishedScript != null)
{
scheduledTask.Status = "Deployed";
}
else
{
scheduledTask.Status = "Deployment Failed";
}
}
else
{
//check if any pool tasks
var workerPools = context.WorkerPools
.Include(f => f.PoolWorkers)
.Where(f => f.PoolWorkers.Any(s => s.WorkerID == workerID)).ToList();
foreach (var pool in workerPools)
{
scheduledTask = context.Tasks.Where(f => f.WorkerID == pool.WorkerPoolID && f.Status == "Scheduled").FirstOrDefault();
if (scheduledTask != null)
{
//worker directly scheduled
publishedScript = context.PublishedScripts.Where(f => f.PublishedScriptID.ToString() == scheduledTask.Script).FirstOrDefault();
if (publishedScript != null)
{
scheduledTask.Status = "Deployed";
}
else
{
scheduledTask.Status = "Deployment Failed";
}
break;
}
}
}
}
context.SaveChanges();
return(Ok(new CheckInResponse
{
Worker = targetWorker,
ScheduledTask = scheduledTask,
PublishedScript = publishedScript
}));
}
}
}
