public SessionDefinition Load(string userName)
{
//Debug.Print($"SqliteSessionRepository.Load({userName})");
SessionDefinition result = null;
try
{
var db = redis.GetDatabase();
var key = getKey(Main.worldID, userName);
var json = (string)db.StringGet(key);
if (db.KeyExists(key))
{
result = JsonConvert.DeserializeObject <SessionDefinition>(json);
}
else
{
result = null;
}
}
catch (Exception ex)
{
ServerApi.LogWriter.PluginWriteLine(LevelingPlugin.Instance, $"Load error: ({ex.Message})", TraceLevel.Error);
}
return(result);
}
// public bool CanLockDevices => false;
public SessionDefinition GetDefinition()
{
var definition = SessionDefinition.Create();
definition.Name = Name;
definition.Project = Name;
definition.Source = "Local";
definition.Welcome.Ignore = true;
definition.StrictStart = true;
definition.Recorders.Add(new SessionRecorderDefinition("Local"));
definition.Recorders.Add(new SessionRecorderDefinition("Buffer"));
definition.Devices = SelectedDevices.Select(d => new SessionDeviceDefinition(d)).ToList();
//bool hasEyeTracker = definition.SelectedDeviceTypes.Any(device => device.Equals(DeviceType.Physiological.EYETRACKER));
//if (hasEyeTracker)
//{
// definition.PreSessionSteps.Add(new SessionStep() { Action = new EyeTrackerCalibrationActionSettings() });
// definition.SessionSteps.Add(new SessionStep() { Action = new EyeTrackerValidationActionSettings() { PointDuration = TimeSpan.FromSeconds(1) } });
//}
definition.SessionSteps.Add(new SessionStep()
{
Action = new ShowDesktopActionSettings()
{
MinimizeAll = false
}
});
return(definition);
}
public void Should_ReadDefinition_ReturnTheRigthSetOfDefinitions_WhenInputFileIsCorrect()
{
// Given
var sessionDefinition = new SessionDefinition("Title #1", 45);
var inputReader = Substitute.For <IFileInputReader>();
inputReader.ReadContent(Arg.Any <string>()).Returns(new[] { "sample" });
var inputOptionAccessor = Substitute.For <IOptions <InputOptions> >();
inputOptionAccessor.Value.Returns(new InputOptions());
var parser = Substitute.For <ISessionDefinitionParser>();
parser.Parse(Arg.Any <string>()).Returns(ParsingResult.FromResult(sessionDefinition));
var reader = new SessionDefinitionReader(inputReader, inputOptionAccessor, new[] { parser });
// When
var result = reader.ReadDefinition();
// Then
result.Should()
.NotBeNull()
.And.HaveCount(1)
.And.Contain(sessionDefinition);
}
private bool TryCreateSessionDefinition(SessionInfo sessionInfo, out SessionDefinition definition)
{
try
{
definition = SessionDefinition.Create();
string definitionJson = (string)sessionInfo.Definition.Value ?? String.Empty;
JsonConvert.PopulateObject(definitionJson, definition, _serializerSettings);
definition.Project = sessionInfo.Project;
definition.Name = sessionInfo.Name;
definition.CreatedAt = sessionInfo.CreatedAt;
definition.Source = "UXR";
definition.SerializationFormat = "JSON";
if (definition.Recorders.Any(r => r.Name.Equals("Local", StringComparison.CurrentCultureIgnoreCase)) == false)
{
definition.Recorders.Add(new SessionRecorderDefinition("Local"));
}
if (definition.Recorders.Any(r => r.Name.Equals("UXR", StringComparison.CurrentCultureIgnoreCase)) == false)
{
definition.Recorders.Add(new SessionRecorderDefinition("UXR"));
}
return(true);
}
catch (Exception ex)
{
}
definition = null;
return(false);
}
private void Open()
{
var files = OpenFiles();
if (files != null && files.Any())
{
SessionDefinition definition;
SessionDefinition lastDefinition = null;
foreach (var file in files)
{
try
{
if (_import.TryAdd(file, out definition))
{
lastDefinition = definition;
}
}
catch
{
// TODO LOG
// TODO ! show error message
}
}
if (lastDefinition != null)
{
var id = lastDefinition.Id;
var vm = Selection.Items.FirstOrDefault(s => s.Id == id);
Selection.SelectedIndex = Selection.Items.IndexOf(vm);
}
// TODO select added definition
}
}
public SessionDefinition Load(string userName)
{
Debug.Print($"SqliteSessionRepository.Load({userName})");
SessionDefinition result = null;
using (var connection = new SqliteConnection(ConnectionString))
{
using (var cmd = connection.CreateCommand())
{
cmd.CommandText = "SELECT data FROM sessions " +
$"WHERE player='{userName}';";
connection.Open();
var reader = cmd.ExecuteReader(CommandBehavior.SingleRow);
if (reader.HasRows)
{
try
{
reader.Read();
var json = reader.GetString(0);
result = JsonConvert.DeserializeObject <SessionDefinition>(json);
}
catch (Exception ex)
{
ServerApi.LogWriter.PluginWriteLine(LevelingPlugin.Instance, $"Load error: ({ex.Message})", TraceLevel.Error);
}
}
}
}
return(result);
}
public void Save(string userName, SessionDefinition sessionDefinition)
{
//Debug.Print($"SqliteSessionRepository.Save({userName})");
using (var connection = new SqliteConnection(ConnectionString))
{
//we now try to copy the session definition, in hopes of minimizing "rare" exceptions from definition collections being touched during serialization.
//we also catch the exception, and just log the error. Hopefully next call to save will work.
try
{
var defCopy = new SessionDefinition(sessionDefinition);
var json = JsonConvert.SerializeObject(defCopy, Formatting.Indented);
using (var cmd = connection.CreateCommand())
{
cmd.CommandText = "INSERT OR REPLACE INTO sessions ( player, data ) " +
"VALUES ( @player, @data );";
cmd.Parameters.AddWithValue("@player", userName);
cmd.Parameters.AddWithValue("@data", json);
connection.Open();
cmd.ExecuteNonQuery();
}
}
catch (Exception ex)
{
ServerApi.LogWriter.PluginWriteLine(LevelingPlugin.Instance, $"Error: {ex.Message}", TraceLevel.Error);
ServerApi.LogWriter.PluginWriteLine(LevelingPlugin.Instance, $"Session data not saved.", TraceLevel.Error);
}
}
}
public void Add(SessionDefinition definition)
{
definition.ThrowIfNull(nameof(definition));
_definitions.Add(definition);
DefinitionsChanged?.Invoke(this, CollectionChangedEventArgs <SessionDefinition> .CreateForAddedItem(definition));
}
public bool TryGetUXRSessionId(SessionDefinition definition, out int id)
{
int?sessionId = _definitions.Where(kvp => kvp.Value.Id == definition.Id)
.Select(kvp => kvp.Key)
.FirstOrDefault();
id = sessionId ?? -1;
return(sessionId.HasValue);
}
public static SessionDefinition List()
{
Tlv tlv = new Tlv();
var result = Core.InvokeMeterpreterBinding(true, tlv.ToRequest("core_transport_list"));
if (result != null)
{
System.Diagnostics.Debug.Write("[PSH BINDING] List result returned");
var responseTlv = Tlv.FromResponse(result);
if (responseTlv[TlvType.Result].Count > 0 &&
(int)responseTlv[TlvType.Result][0] == 0)
{
System.Diagnostics.Debug.Write("[PSH BINDING] List succeeded");
var expirySeconds = Tlv.GetValue <int>(responseTlv, TlvType.TransSessExp);
var session = new SessionDefinition(DateTime.Now.AddSeconds(expirySeconds));
foreach (var transportObj in responseTlv[TlvType.TransGroup])
{
var transportDict = (Dictionary <TlvType, List <object> >)transportObj;
var transport = new TransportInstance
{
Url = Tlv.GetValue <string>(transportDict, TlvType.TransUrl, string.Empty),
CommTimeout = Tlv.GetValue <int>(transportDict, TlvType.TransCommTimeout),
RetryTotal = Tlv.GetValue <int>(transportDict, TlvType.TransRetryTotal),
RetryWait = Tlv.GetValue <int>(transportDict, TlvType.TransRetryWait),
UserAgent = Tlv.GetValue <string>(transportDict, TlvType.TransUa, string.Empty),
ProxyHost = Tlv.GetValue <string>(transportDict, TlvType.TransProxyHost, string.Empty),
ProxyUser = Tlv.GetValue <string>(transportDict, TlvType.TransProxyUser, string.Empty),
ProxyPass = Tlv.GetValue <string>(transportDict, TlvType.TransProxyPass, string.Empty),
};
var hash = Tlv.GetValue <byte[]>(transportDict, TlvType.TransCertHash);
if (hash != null && hash.Length > 0)
{
transport.CertHash = BitConverter.ToString(hash).Replace("-", "");
}
session.Transports.Add(transport);
}
return(session);
}
System.Diagnostics.Debug.Write("[PSH BINDING] List failed");
}
else
{
System.Diagnostics.Debug.Write("[PSH BINDING] List result was null");
}
return(null);
}
public void Should_FromResult_ReturnTrueMatchFlagAndResult()
{
// Given
var sessionDefinition = new SessionDefinition("Title", 15);
// When
var result = ParsingResult.FromResult(sessionDefinition);
// Then
result.Should().NotBeNull();
result.IsMatched.Should().Be(true);
result.SessionDefinition.ShouldBeEquivalentTo(sessionDefinition);
}
private static IMapper CreateEntitiesMapper()
{
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap <SessionDeviceDefinition, SessionDeviceDefinitionInfo>()
.ForMember(i => i.Device,
e => e.MapFrom(definition => definition.Device.Code));
//.ForMember(i => i.Configuration)
//e => e.ResolveUsing((SessionDeviceDefinition definition) => definition.Configuration
//.Select(d => new SessionDeviceConfigurationSettingInfo() { Setting = d.Key, Value = Convert.ToString(d.Value) })));
cfg.CreateMap <SessionDeviceDefinitionInfo, SessionDeviceDefinition>()
.ConstructUsing((SessionDeviceDefinitionInfo info) =>
{
DeviceType device;
if (DeviceType.TryResolveExistingType(info.Device, out device))
{
return(new SessionDeviceDefinition
(
device,
info.Configuration?.ToDictionary(c => c.Key, c => c.Value)
));
}
return(null);
});
cfg.CreateMap <SessionRecorderDefinition, SessionRecorderDefinitionInfo>();
cfg.CreateMap <SessionRecorderDefinitionInfo, SessionRecorderDefinition>()
.ConstructUsing((SessionRecorderDefinitionInfo info) =>
{
return(new SessionRecorderDefinition(info.Name, info.Configuration));
});
cfg.CreateMap <SessionDefinition, SessionDefinitionInfo>();
cfg.CreateMap <SessionDefinitionCreate, SessionDefinition>()
.ConstructUsing((SessionDefinitionCreate _) => SessionDefinition.Create());
cfg.CreateMap <SessionRecording, SessionRecordingInfo>();
cfg.CreateMap <SessionStepExecution, SessionStepExecutionInfo>()
.ForMember(i => i.ActionType,
e => e.MapFrom(execution => execution.Step.Action.ActionType))
.ForMember(i => i.Tag,
e => e.MapFrom(execution => execution.Step.Action.Tag));
});
return(config.CreateMapper());
}
public static SessionDefinition List()
{
Tlv tlv = new Tlv();
var result = Core.InvokeMeterpreterBinding(true, tlv.ToRequest("core_transport_list"));
if (result != null)
{
System.Diagnostics.Debug.Write("[PSH BINDING] List result returned");
var responseTlv = Tlv.FromResponse(result);
if (responseTlv[TlvType.Result].Count > 0 &&
(int)responseTlv[TlvType.Result][0] == 0)
{
System.Diagnostics.Debug.Write("[PSH BINDING] List succeeded");
var expirySeconds = Tlv.GetValue<int>(responseTlv, TlvType.TransSessExp);
var session = new SessionDefinition(DateTime.Now.AddSeconds(expirySeconds));
foreach (var transportObj in responseTlv[TlvType.TransGroup])
{
var transportDict = (Dictionary<TlvType, List<object>>)transportObj;
var transport = new TransportInstance
{
Url = Tlv.GetValue<string>(transportDict, TlvType.TransUrl, string.Empty),
CommTimeout = Tlv.GetValue<int>(transportDict, TlvType.TransCommTimeout),
RetryTotal = Tlv.GetValue<int>(transportDict, TlvType.TransRetryTotal),
RetryWait = Tlv.GetValue<int>(transportDict, TlvType.TransRetryWait),
UserAgent = Tlv.GetValue<string>(transportDict, TlvType.TransUa, string.Empty),
ProxyHost = Tlv.GetValue<string>(transportDict, TlvType.TransProxyHost, string.Empty),
ProxyUser = Tlv.GetValue<string>(transportDict, TlvType.TransProxyUser, string.Empty),
ProxyPass = Tlv.GetValue<string>(transportDict, TlvType.TransProxyPass, string.Empty),
CertHash = Tlv.GetValue<byte[]>(transportDict, TlvType.TransCertHash)
};
session.Transports.Add(transport);
}
return session;
}
System.Diagnostics.Debug.Write("[PSH BINDING] List failed");
}
else
{
System.Diagnostics.Debug.Write("[PSH BINDING] List result was null");
}
return null;
}
public void AllocateSession(SessionDefinition sessionDefinition)
{
if (sessionDefinition == null)
{
throw new ArgumentNullException(nameof(sessionDefinition));
}
var lastSession = _trackSlot.TrackSessions.LastOrDefault();
var slot = lastSession != null
? lastSession.GetNextSlot(sessionDefinition.Duration)
: _trackSlot.GetNextSlot(sessionDefinition.Duration);
var trackSession = new TrackSession(sessionDefinition.Title, slot);
_trackSlot.TrackSessions.Add(trackSession);
UnallocatedTime -= sessionDefinition.Duration;
}
public void Save(string userName, SessionDefinition sessionDefinition)
{
//we now try to copy the session definition, in hopes of minimizing "rare" exceptions from definition collections being touched during serialization.
//we also catch the exception, and just log the error. Hopefully next call to save will work.
try
{
var defCopy = new SessionDefinition(sessionDefinition);
var json = JsonConvert.SerializeObject(defCopy, Formatting.Indented);
var key = getKey(Main.worldID, userName);
var db = redis.GetDatabase();
db.StringSet(key, json);
}
catch (Exception ex)
{
ServerApi.LogWriter.PluginWriteLine(LevelingPlugin.Instance, $"Error: {ex.Message}", TraceLevel.Error);
ServerApi.LogWriter.PluginWriteLine(LevelingPlugin.Instance, $"Session data not saved.", TraceLevel.Error);
}
}
private Dictionary <int, SessionDefinition> CreateDefinitions(IEnumerable <SessionInfo> sessions)
{
//var newUXRSessions = sessions.Where(i => ContainsUXRDefinition(i.Id) == false).ToList();
var definitions = new Dictionary <int, SessionDefinition>();
foreach (var uxrSession in sessions)
{
SessionDefinition definition = null;
if (TryCreateSessionDefinition(uxrSession, out definition))
{
definitions.Add(uxrSession.Id, definition);
}
else
{
// TODO LOG failed adding UXR definition
}
}
return(definitions);
}
public void Should_AllocateSession_AllocateTheSessionBasedOnTheSlotAndCalculateRemainigCorrectly()
{
// Given
var trackSlot = new TrackSlot("Title", new TimeSlot(9, 0, 120));
var calculatedTrackSlot = new CalculatedTrackSlot(trackSlot);
var sessionDefinition = new SessionDefinition("Session 1", 60);
// When
calculatedTrackSlot.AllocateSession(sessionDefinition);
// Then
trackSlot.TrackSessions
.Should().HaveCount(1);
trackSlot.TrackSessions[0].Title.Should().Be(sessionDefinition.Title);
trackSlot.TrackSessions[0].Time.DurationInMinute.Should().Be(sessionDefinition.Duration);
trackSlot.TrackSessions[0].Time.Hour.Should().Be(trackSlot.TimeSlot.Hour);
trackSlot.TrackSessions[0].Time.Minute.Should().Be(trackSlot.TimeSlot.Minute);
}
internal Session GetOrCreateSession(TSPlayer player)
{
var session = player.GetData <Session>(SessionKey);
if (session == null)
{
var username = player.User?.Name ?? player.Name;
//first try the database
SessionDefinition definition = SessionRepository.Load(username);
//otherwise we need to create
if (definition == null)
{
definition = new SessionDefinition();
definition.Initialize();
}
session = new Session(player, definition);
session.Resolve(_classes);
player.SetData(SessionKey, session);
}
return(session);
}
public SessionDefinitionViewModel(SessionDefinition definition)
{
_definition = definition;
SelectedDevices = definition.SelectedDeviceTypes.ToList();
}
