public static async Task <UserDto> Register(UserDto userDto)
{
LoadManagerContext dbContext = new LoadManagerContext();
User usr;
using (dbContext)
{
using (var transaction = dbContext.Database.BeginTransaction())
{
User user = new User
{
UserName = userDto.UserName,
Password = userDto.Password,
};
await dbContext.AddAsync <User>(user);
await dbContext.SaveChangesAsync();
usr = user;
transaction.Commit();
}
}
return(new UserDto
{
UserId = usr.UserId,
UserName = usr.UserName,
Password = usr.Password,
});
}
public static async Task <WorkerServerDto> GetServerByAssignedTaskId(int taskId)
{
using (var dbContext = new LoadManagerContext())
{
var serverId = await dbContext.Tasks.Where(p => p.TaskID == taskId).Select(p => p.ServerID).FirstAsync();
var server = await dbContext.WorkerServers.Where(p => p.WorkerServerID == serverId).Select(s =>
new WorkerServerDto
{
IpAddress = s.IpAddress,
IsConnected = s.IsConnected,
Port = s.Port,
WorkerServerID = s.WorkerServerID
}).FirstAsync();
// new {p.ServerID, p.TaskID}).Where(p => p.TaskID == taskId)
// .LeftJoin(dbContext.WorkerServers, p => p.ServerID, o => o.WorkerServerID, (a, g) => new
// {
// a.TaskID,
// g.IpAddress,
// g.IsConnected,
// g.Port,
// g.WorkerServerID
// }).GroupBy(p => p.WorkerServerID).Select(p =>
//new WorkerServerDto {
// IpAddress = p.IpAddress,
// IsConnected = p.IsConnected,
// Port = p.Port,
// WorkerServerID = p.WorkerServerID
//}).FirstAsync();
return(server);
}
}
public static async Task <List <int> > GetAssignedTasks()
{
using (var dbContext = new LoadManagerContext())
{
return(await dbContext.Tasks.Where(t => t.Status.Equals("Assigned"))
.Select(p => p.TaskID).ToListAsync());
}
}
public static async Task <int?> FindLessLoadedServer()
{
using (var dbContext = new LoadManagerContext())
{
int?serverId = await dbContext.WorkerServers.Select(b => b.WorkerServerID).Where(b =>
dbContext.Tasks.Count(p => p.ServerID == b) == 0).FirstOrDefaultAsync();
return(serverId ?? 0);
}
}
public static async Task UpdateTaskPercent(int taskId, byte percent)
{
using (var dbContext = new LoadManagerContext())
{
var entity = await dbContext.Tasks.FirstOrDefaultAsync(e => e.TaskID == taskId);
entity.DonePercent = percent;
dbContext.Tasks.Update(entity);
await dbContext.SaveChangesAsync();
}
}
public static async Task <int> GetIdByUserName(string userName)
{
LoadManagerContext dbContext = new LoadManagerContext();
using (dbContext)
{
User usr = await dbContext.Users.FirstOrDefaultAsync(u => u.UserName == userName);
return(usr.UserId);
}
}
public static async Task <bool> CheckUserCredentials(string userName)
{
using (var dbContext = new LoadManagerContext())
{
var query = await dbContext.Users.Select(b => new
{
b.UserName,
}).CountAsync(o => o.UserName == userName);
return(query == 0);
}
}
public static async Task <List <TaskDto> > GetCanceledTasks()
{
using (var dbContext = new LoadManagerContext())
{
return(await dbContext.Tasks.Where(t => t.Status.Equals("Canceled"))
.Select(p => new TaskDto {
TaskID = p.TaskID,
ServerID = p.ServerID,
Status = p.Status,
UserId = p.UserId
}).ToListAsync());
}
}
public static async Task <TaskDto> GetTask(int taskId)
{
using (var dbContext = new LoadManagerContext())
{
return(await dbContext.Tasks.Select(x => new TaskDto
{
TaskID = x.TaskID,
DonePercent = x.DonePercent,
ServerID = x.ServerID,
Status = x.Status,
Size = x.Size
}).FirstOrDefaultAsync(x => x.TaskID == taskId));
}
}
public static async Task <int> CreateNewTask(int size, int userId)
{
var emptyTask = new Models.Task()
{
Status = "Waiting", DonePercent = (byte)0, Size = size, UserId = userId
};
using (var dbContext = new LoadManagerContext())
{
dbContext.Tasks.Add(emptyTask);
await dbContext.SaveChangesAsync();
return(emptyTask.TaskID);
}
}
public static async Task <UserDto> Login(UserDto loginObject)
{
LoadManagerContext dbContext = new LoadManagerContext();
using (dbContext)
{
return(await dbContext.Users.Select(o => new
UserDto
{
UserName = o.UserName,
Password = o.Password,
UserId = o.UserId
}).Where(u => u.UserName == loginObject.UserName && u.Password == loginObject.Password).FirstOrDefaultAsync());
}
}
public static async Task <List <WorkerServerDto> > GetWorkerServer()
{
using (var dbContext = new LoadManagerContext())
{
var server = await dbContext.WorkerServers.Select(p => new WorkerServerDto()
{
WorkerServerID = p.WorkerServerID,
Port = p.Port,
IpAddress = p.IpAddress,
IsConnected = p.IsConnected
}).ToListAsync();
return(server);
}
}
public static async Task <List <TaskDto> > GetUnassignedTasks()
{
using (var dbContext = new LoadManagerContext())
{
var tasks = await dbContext.Tasks.Select(e => new TaskDto
{
TaskID = e.TaskID,
Status = e.Status,
ServerID = e.ServerID,
Size = e.Size
}).Where(e => e.ServerID == null && e.Status.Equals("Waiting")).ToListAsync();
return(tasks);
}
}
public static async Task UpdateTaskStatus(int taskId, string status)
{
using (var dbContext = new LoadManagerContext())
{
using (var transaction = dbContext.Database.BeginTransaction())
{
var entity = await dbContext.Tasks.FirstOrDefaultAsync(e => e.TaskID == taskId);
entity.Status = status;
dbContext.Tasks.Update(entity);
await dbContext.SaveChangesAsync();
transaction.Commit();
}
}
}
public static async Task UnAssignTask(int taskId)
{
using (var dbContext = new LoadManagerContext())
{
using (var transaction = dbContext.Database.BeginTransaction())
{
var entity = await dbContext.Tasks.FirstOrDefaultAsync(e => e.TaskID == taskId);
entity.ServerID = null;
dbContext.Tasks.Update(entity);
await dbContext.SaveChangesAsync();
transaction.Commit();
}
}
}
public static async Task <List <TaskDto> > GetTasks(int userId)
{
using (var dbContext = new LoadManagerContext())
{
var tasks = await dbContext.Tasks.Select(t => new TaskDto
{
TaskID = t.TaskID,
Status = t.Status,
DonePercent = t.DonePercent,
ServerID = t.ServerID,
Size = t.Size,
UserId = t.UserId
}).Where(i => i.UserId.Equals(userId)).ToListAsync();
return(tasks);
}
}
public static async Task <List <TaskDto> > GetWorkingTasks()
{
using (var dbContext = new LoadManagerContext())
{
var tasks = await dbContext.Tasks.Where(t => t.Status == "Working").Select(t => new TaskDto
{
TaskID = t.TaskID,
Status = t.Status,
DonePercent = t.DonePercent,
ServerID = t.ServerID,
Size = t.Size
})
.ToListAsync();
return(tasks);
}
}
public static async Task <bool> AddNewWorkerServer(WorkerServerDto server)
{
using (var dbContext = new LoadManagerContext())
{
if (dbContext.WorkerServers.Count(b => b.IpAddress == server.IpAddress && b.Port == server.Port) != 0)
{
return(true);
}
dbContext.WorkerServers.Add(new WorkerServer()
{
IpAddress = server.IpAddress,
IsConnected = server.IsConnected,
Port = server.Port
});
return(await dbContext.SaveChangesAsync() == 1);
}
}
public static async Task <List <WorkerTaskDto> > FindAllServers()
{
using (var dbContext = new LoadManagerContext())
{
var serverList = await dbContext.WorkerServers.Select(b => new { b.WorkerServerID, b.IpAddress, b.IsConnected, b.Port })
.LeftJoin(dbContext.Tasks, p => p.WorkerServerID, s => s.ServerID, (a, g) => new
{
g.ServerID,
a.IpAddress,
a.IsConnected,
a.Port
}).GroupBy(g => g.ServerID).Select(p => new WorkerTaskDto
{
IpAddress = p.Select(p => p.IpAddress).First(),
TaskCount = p.Count(),
IsConnected = p.Select(p => p.IsConnected).First(),
Port = p.Select(p => p.Port).First()
}).OrderBy(p => p.TaskCount).ToListAsync();
return(serverList);
}
}
