public RpcComputerRepository(IRepositoryFactory repositoryFactory, Persistence.Models.User user)
{
_repositoryFactory = repositoryFactory;
_user = user;
_computerRepository = _repositoryFactory.GetComputerRepository();
}
private static Persistence.Models.Computer GetSerializableVersion(Persistence.Models.Computer computer)
{
Persistence.Models.User owner = null;
if (computer.Owner != null)
{
owner = new Persistence.Models.User(
alias: computer.Owner.Alias,
email: null,
id: computer.Owner.Id,
registeredTimestamp: null,
secret: null,
token: null
);
}
var result = new Persistence.Models.Computer(
accessKey: computer.AccessKey,
address: computer.Address,
encryptionKey: computer.EncryptionKey,
id: computer.Id,
lastPing: computer.LastPing,
lastScript: computer.LastScript,
name: computer.Name,
owner: owner
);
return(result);
}
public RpcDeviceRepository(IRepositoryFactory repositoryFactory, Persistence.Models.User user)
{
_repositoryFactory = repositoryFactory;
_user = user;
_deviceRepository = _repositoryFactory.GetDeviceRepository();
}
public RpcWebHookSessionRepository(IRepositoryFactory repositoryFactory, Persistence.Models.User user)
{
_repositoryFactory = repositoryFactory;
_user = user;
_sessionRepository = _repositoryFactory.GetSessionRepository();
}
public RpcNetworkRepository(IRepositoryFactory repositoryFactory, Persistence.Models.User user)
{
_repositoryFactory = repositoryFactory;
_user = user;
_networkRepository = _repositoryFactory.GetNetworkRepository();
}
private static Persistence.Models.UserSession GetSerializableVersion(Persistence.Models.UserSession model)
{
Persistence.Models.User user = null;
if (model.User != null)
{
user = new Persistence.Models.User(
alias: model.User.Alias,
email: null,
id: model.User.Id,
registeredTimestamp: null,
secret: null,
token: null
);
}
var result = new Persistence.Models.UserSession(
creationTimeStamp: model.CreationTimeStamp,
id: model.Id,
lastContactTimeStamp: model.LastContactTimeStamp,
token: null,
user: user
);
return(result);
}
protected override void Initialize(HttpControllerContext controllerContext)
{
var userSession = GetCurrentUserSession(controllerContext.Request);
if (userSession != null)
{
User = userSession.User;
}
var webHookSession = GetCurrentWebHookSession(controllerContext.Request);
if (webHookSession != null)
{
Computer = webHookSession.Computer;
User = Computer.Owner;
}
var sessionlessWebHookComputer = GetSessionlessWebHookComputer(controllerContext.Request);
if (sessionlessWebHookComputer != null)
{
Computer = sessionlessWebHookComputer;
User = Computer.Owner;
}
base.Initialize(controllerContext);
}
public RpcTaskRepository(Persistence.Models.Computer computer, IRepositoryFactory repositoryFactory, Persistence.Models.User user)
{
_computer = computer;
_repositoryFactory = repositoryFactory;
_user = user;
_taskRepository = _repositoryFactory.GetTaskRepository();
}
/// <summary>
/// Register an user
/// </summary>
/// <param name="user">user that must be registered</param>
public void RegisterUser(ref Persistence.Models.User user)
{
if (this._uow.UserRepository.GetUserPerEmail(user.Email) != null)
{
throw new InvalidOperationException($"Email already used.");
}
this._uow.UserRepository.Add(user);
base.mbs.SendMessage(nameof(RegisteredUserEvent), new RegisteredUserEvent(user.Id));
}
public void Run(Persistence.Models.User user, Persistence.Models.Computer computer, string source, string scriptText, bool updateLastRunScript)
{
var script = Persistence.Models.Script.Create(false, scriptText);
_scriptRepository.Add(script);
var task = Persistence.Models.Task.Create(user, source, computer, script);
_taskRepository.Add(task);
if (updateLastRunScript)
{
computer.UpdateLastScript(task.Script);
_computerRepository.Update(computer);
}
}
private Persistence.Models.Task GetSerializableVersion(Persistence.Models.Task task)
{
if (task == null)
{
return(null);
}
Persistence.Models.User owner = null;
if (task.Owner != null)
{
owner = new Persistence.Models.User(
alias: task.Owner.Alias,
email: null,
id: task.Owner.Id,
registeredTimestamp: null,
secret: null,
token: null
);
}
Persistence.Models.Computer target = null;
if (task.Target != null)
{
target = new Persistence.Models.Computer(
accessKey: null,
address: null,
encryptionKey: null,
id: task.Target.Id,
lastPing: null,
lastScript: null,
name: task.Target.Name,
owner: null
);
}
var result = new Persistence.Models.Task(
expiration: task.Expiration,
id: task.Id,
origin: task.Origin,
owner: owner,
receivedTimestamp: task.ReceivedTimestamp,
script: task.Script,
target: target
);
return(result);
}
public Persistence.Models.Device[] Run(Persistence.Models.Computer computer, Persistence.Models.User user, Persistence.Models.Network network, IDeviceState[] sentDevices)
{
computer.UpdatePing();
_computerRepository.Update(computer);
network.UpdatePing(computer);
_networkRepository.Update(network);
var existingDevices = _deviceRepository.Get(network);
UpdateDevices(sentDevices, existingDevices, network);
var devicesToRemove = GetRemovedDevices(sentDevices, existingDevices);
RemoveDevices(devicesToRemove);
return(existingDevices);
}
public string Run(TimeSpan?timeout, Persistence.Models.User user)
{
var cache = new InMemoryRepositoryModelCache();
var deleted = 0;
var skipped = 0;
ListFilter filter = null;
DoWork.UntilTimeout(((int?)timeout?.TotalSeconds) ?? 5, () =>
{
var result = _taskRepository.Clean(user, filter, cache);
deleted += result.Deleted;
skipped += result.Skipped;
filter = result.NextFilter;
return(result.Done);
});
return(deleted + " tasks cleaned up, " + skipped + " tasks skipped");
}
public Persistence.Models.Device[] Run(Persistence.Models.Computer computer, Persistence.Models.User user, Persistence.Models.Network network, IEnumerable <XElement> sentDevices)
{
return(Run(computer, user, network, ProcessSentDevices(sentDevices, network)));
}
private static Persistence.Models.Network GetSerializableVersion(Persistence.Models.Network network)
{
Persistence.Models.Computer computer = null;
if (network.AttatchedComputer != null)
{
computer = new Persistence.Models.Computer(
accessKey: null,
address: null,
encryptionKey: null,
id: network.AttatchedComputer.Id,
lastPing: network.AttatchedComputer.LastPing,
lastScript: null,
name: network.AttatchedComputer.Name,
owner: null
);
}
Persistence.Models.Device[] devices = null;
if (network.Devices != null)
{
devices = network.Devices
.Select(x => new Persistence.Models.Device(
address: x.Address,
id: x.Id,
lastPing: null,
name: x.Name,
network: null,
scripts: null,
state: null,
tasks: null,
type: x.Type
))
.ToArray();
}
Persistence.Models.User owner = null;
if (network.Owner != null)
{
owner = new Persistence.Models.User(
alias: network.Owner.Alias,
email: null,
id: network.Owner.Id,
registeredTimestamp: null,
secret: null,
token: null
);
}
return(new Persistence.Models.Network(
address: network.Address,
attatchedComputer: computer,
devices: devices,
id: network.Id,
lastPing: network.LastPing,
name: network.Name,
owner: owner
));
}
