/// <summary>
/// Saves a string of text to the storage locations(s) for this trial. A column will be added in the trial_results CSV listing the location(s) of these data.
/// </summary>
/// <param name="text">The data to be saved.</param>
/// <param name="dataName">Name to be used in saving. It will be appended with the trial number.</param>
/// <param name="dataType"></param>
public void SaveText(string text, string dataName, UXFDataType dataType = UXFDataType.OtherTrialData)
{
if (!CheckDataTypeIsValid(dataName, dataType))
{
dataType = UXFDataType.OtherTrialData;
}
int i = 0;
foreach (var dataHandler in session.ActiveDataHandlers)
{
string location = dataHandler.HandleText(text, session.experimentName, session.ppid, session.number, dataName, dataType, number);
result[string.Format("{0}_location_{1}", dataName, i++)] = location.Replace("\\", "/");
}
}
public bool CheckDataTypeIsValid(string dataName, UXFDataType dataType)
{
if (dataType.GetDataLevel() != UXFDataLevel.PerTrial)
{
Debug.LogErrorFormat(
"Error trying to save data '{0}' of type UXFDataType.{1} associated with the Trial. The valid types for this method are {2}. Reverting to type UXFDataType.OtherTrialData.",
dataName,
dataType,
string.Join(", ", UXFDataLevel.PerTrial.GetValidDataTypes())
);
return(false);
}
else
{
return(true);
}
}
public static string GetFolderName(this UXFDataType dt)
{
switch (dt)
{
case UXFDataType.TrialResults:
return("");
case UXFDataType.SessionLog:
case UXFDataType.Settings:
case UXFDataType.ParticipantDetails:
case UXFDataType.SummaryStatistics:
return("session_info");
case UXFDataType.Trackers:
return("trackers");
default:
return("other");
}
}
public override string HandleJSONSerializableObject(Dictionary <string, object> serializableObject, string experiment, string ppid, int sessionNum, string dataName, UXFDataType dataType, int optionalTrialNum = 0)
{
if (dataType != UXFDataType.TrialResults && trialResultsOnly)
{
return("NA");
}
if (dataType.GetDataLevel() == UXFDataLevel.PerTrial)
{
dataName = string.Format("{0}_T{1:000}", dataName, optionalTrialNum);
}
string text = MiniJSON.Json.Serialize(serializableObject);
string fname = string.Format("{0}.json", dataName);
CreateNewItem(text, fname);
return(fname);
}
public override string HandleDataTable(UXFDataTable table, string experiment, string ppid, int sessionNum, string dataName, UXFDataType dataType, int optionalTrialNum = 0)
{
if (dataType != UXFDataType.TrialResults && trialResultsOnly)
{
return("NA");
}
if (dataType.GetDataLevel() == UXFDataLevel.PerTrial)
{
dataName = string.Format("{0}_T{1:000}", dataName, optionalTrialNum);
}
string[] lines = table.GetCSVLines();
string fname = string.Format("{0}.csv", dataName);
string content = string.Join("\n", lines);
// if trial results, push to top of list for convenience
CreateNewItem(content, fname, pushToTop: dataType == UXFDataType.TrialResults);
return(fname);
}
public abstract string HandleJSONSerializableObject(Dictionary <string, object> serializableObject, string experiment, string ppid, int sessionNum, string dataName, UXFDataType dataType, int optionalTrialNumber = 0);
/// <summary>
/// Handle a JSON-Serializable object. Should not normally be called by the user. Instead, call session.SaveJSONSerializableObject() or trial.SaveJSONSerializableObject().
/// </summary>
/// <param name="serializableObject"></param>
/// <param name="experiment"></param>
/// <param name="ppid"></param>
/// <param name="sessionNum"></param>
/// <param name="dataName"></param>
/// <param name="dataType"></param>
/// <param name="optionalTrialNum"></param>
/// <returns></returns>
public override string HandleJSONSerializableObject(Dictionary <string, object> serializableObject, string experiment, string ppid, int sessionNum, string dataName, UXFDataType dataType, int optionalTrialNum)
{
if (!CheckCurrentTargetOK())
{
return("not supported in editor");
}
// most of the other methods end up calling this
serializableObject = new Dictionary <string, object>(serializableObject); // copy
string primaryKeyValue = GetFormattedPrimaryKeyValue(ppid, sessionNum, dataName);
string tableName = GetTableName(experiment, dataType);
string outName;
serializableObject.Add(primaryKey, primaryKeyValue);
if (DatabaseDataLevel(dataType) == UXFDataLevel.PerTrial)
{
serializableObject.Add(sortKey, optionalTrialNum);
outName = string.Format("dynamodb:{0}:{1}:{2}", tableName, primaryKeyValue, optionalTrialNum);
}
else
{
outName = string.Format("dynamodb:{0}:{1}", tableName, primaryKeyValue);
}
string req = MiniJSON.Json.Serialize(serializableObject);
DDB_PutItem(tableName, req, gameObject.name);
return(outName);
}
/// <summary>
/// Handles a byte array. Should not normally be called by the user. Instead, call session.SaveBytes() or trial.SaveBytes().
/// </summary>
/// <param name="bytes"></param>
/// <param name="experiment"></param>
/// <param name="ppid"></param>
/// <param name="sessionNum"></param>
/// <param name="dataName"></param>
/// <param name="dataType"></param>
/// <param name="optionalTrialNum"></param>
/// <returns></returns>
public override string HandleBytes(byte[] bytes, string experiment, string ppid, int sessionNum, string dataName, UXFDataType dataType, int optionalTrialNum)
{
if (!CheckCurrentTargetOK())
{
return("not supported in editor");
}
string content = System.Text.Encoding.UTF8.GetString(bytes);
return(HandleText(content, experiment, ppid, sessionNum, dataName, dataType, optionalTrialNum));
}
/// <summary>
/// Handles a UXF Data Table. Should not normally be called by the user. Instead, call session.SaveDataTable() or trial.SaveDataTable().
/// </summary>
/// <param name="table"></param>
/// <param name="experiment"></param>
/// <param name="ppid"></param>
/// <param name="sessionNum"></param>
/// <param name="dataName"></param>
/// <param name="dataType"></param>
/// <param name="optionalTrialNum"></param>
public override string HandleDataTable(UXFDataTable table, string experiment, string ppid, int sessionNum, string dataName, UXFDataType dataType, int optionalTrialNum)
{
if (!CheckCurrentTargetOK())
{
return("not supported in editor");
}
if (dataType == UXFDataType.TrialResults)
{
// special case, one item per trial, but multiple items
// so we need BatchWriteItem
string primaryKeyValue = GetFormattedPrimaryKeyValue(ppid, sessionNum, dataName);
string tableName = GetTableName(experiment, dataType);
if (!table.Headers.Contains("trial_num"))
{
Debug.LogError("Data supplied is supposed to be per-trial but does not contain 'trial_num' column!");
return("error");
}
var dataList = table.GetAsListOfDict()
.Select(item => {
item[primaryKey] = primaryKeyValue;
return(item);
})
.Cast <object>()
.ToList();
if (dataList.Count <= 25)
{
string req = MiniJSON.Json.Serialize(dataList);
DDB_BatchWriteItem(tableName, req, gameObject.name);
}
else
{
// BatchWriteItem accepts 25 items at most
while (dataList.Any())
{
var dataListChunk = dataList.Take(25).ToList();
dataList = dataList.Skip(25).ToList();
string req = MiniJSON.Json.Serialize(dataListChunk);
DDB_BatchWriteItem(tableName, req, gameObject.name);
}
}
return(string.Format("dynamodb:{0}:{1}", tableName, primaryKeyValue));
}
else
{
Dictionary <string, object> dataDict = table
.GetAsDictOfList()
.ToDictionary(kvp => kvp.Key,
kvp => (object)kvp.Value);
return(HandleJSONSerializableObject(dataDict, experiment, ppid, sessionNum, dataName, dataType, optionalTrialNum));
}
}
/// <summary>
/// Saves a JSON Serializable Object to the storage locations(s).
/// </summary>
/// <param name="serializableObject">The data to be saved.</param>
/// <param name="dataName">Name to be used in saving.</param>
/// <param name="dataType"></param>
public void SaveJSONSerializableObject(Dictionary <string, object> serializableObject, string dataName, UXFDataType dataType = UXFDataType.OtherSessionData)
{
if (!CheckDataTypeIsValid(dataName, dataType))
{
dataType = UXFDataType.OtherSessionData;
}
foreach (var dataHandler in ActiveDataHandlers)
{
string location = dataHandler.HandleJSONSerializableObject(serializableObject, experimentName, ppid, number, dataName, dataType);
}
}
public override string HandleJSONSerializableObject(List <object> serializableObject, string experiment, string ppid, int sessionNum, string dataName, UXFDataType dataType, int optionalTrialNum = 0)
{
// get data as text
string text = MiniJSON.Json.Serialize(serializableObject);
string ext = Path.GetExtension(dataName);
dataName = Path.GetFileNameWithoutExtension(dataName);
if (dataType.GetDataLevel() == UXFDataLevel.PerTrial)
{
dataName = string.Format("{0}_T{1:000}", dataName, optionalTrialNum);
}
string directory = GetSessionPathRelative(experiment, ppid, sessionNum);
if (dataType != UXFDataType.TrialResults)
{
directory = Path.Combine(directory, dataType.ToLower());
}
string name = string.IsNullOrEmpty(ext) ? string.Format("{0}.json", dataName) : string.Format("{0}{1}", dataName, ext);
string savePath = Path.Combine(directory, name);
savePath = savePath.Replace('\\', '/');
// here we send our data request
AuthenticatedRequest(savePath, text);
// return a string representing the location of the data. Will be stored in the trial_results output.
return(savePath);
}
public override string HandleText(string text, string experiment, string ppid, int sessionNum, string dataName, UXFDataType dataType, int optionalTrialNum = 0)
{
Debug.LogFormat("Handling a JSON Serializale Object for session: {0}, {1}, {2}", experiment, ppid, sessionNum);
Debug.LogFormat("The data name is: {0}, and the type is: ", dataName, dataType);
if (dataType.GetDataLevel() == UXFDataLevel.PerTrial)
{
Debug.LogFormat("Data is per-trial, trial number is {0}.", optionalTrialNum);
}
else
{
Debug.Log("Data is per-session.");
}
// here we "write" our data, you could upload to database, or do whatever.
Debug.Log(text);
// return a string representing the location of the data. Will be stored in the trial_results output.
return("Data printed to console.");
}
public override string HandleDataTable(UXFDataTable table, string experiment, string ppid, int sessionNum, string dataName, UXFDataType dataType, int optionalTrialNum = 0)
{
if (dataType.GetDataLevel() == UXFDataLevel.PerTrial)
{
dataName = string.Format("{0}_T{1:000}", dataName, optionalTrialNum);
}
string[] lines = table.GetCSVLines();
string directory = GetSessionPath(experiment, ppid, sessionNum);
if (sortDataIntoFolders && dataType != UXFDataType.TrialResults)
{
directory = Path.Combine(directory, dataType.ToLower());
}
Directory.CreateDirectory(directory);
string savePath = Path.Combine(directory, string.Format("{0}.csv", dataName));
if (verboseDebug)
{
Utilities.UXFDebugLogFormat("Queuing save of file: {0}", savePath);
}
ManageInWorker(() => { File.WriteAllLines(savePath, lines); });
return(GetRelativePath(storagePath, savePath));;
}
public abstract string HandleBytes(byte[] bytes, string experiment, string ppid, int sessionNum, string dataName, UXFDataType dataType, int optionalTrialNumber = 0);
public abstract string HandleText(string text, string experiment, string ppid, int sessionNum, string dataName, UXFDataType dataType, int optionalTrialNumber = 0);
public override string HandleText(string text, string experiment, string ppid, int sessionNum, string dataName, UXFDataType dataType, int optionalTrialNum = 0)
{
if (dataType != UXFDataType.TrialResults && trialResultsOnly)
{
return("NA");
}
if (dataType.GetDataLevel() == UXFDataLevel.PerTrial)
{
dataName = string.Format("{0}_T{1:000}", dataName, optionalTrialNum);
}
string fname = string.Format("{0}.txt", dataName);
CreateNewItem(text, fname);
return(fname);
}
public override string HandleBytes(byte[] bytes, string experiment, string ppid, int sessionNum, string dataName, UXFDataType dataType, int optionalTrialNum = 0)
{
string ext = Path.GetExtension(dataName);
dataName = Path.GetFileNameWithoutExtension(dataName);
if (dataType.GetDataLevel() == UXFDataLevel.PerTrial)
{
dataName = string.Format("{0}_T{1:000}", dataName, optionalTrialNum);
}
string directory = GetSessionPath(experiment, ppid, sessionNum);
if (sortDataIntoFolders && dataType != UXFDataType.TrialResults)
{
directory = Path.Combine(directory, dataType.ToLower());
}
Directory.CreateDirectory(directory);
string name = string.IsNullOrEmpty(ext) ? string.Format("{0}.txt", dataName) : string.Format("{0}{1}", dataName, ext);
string savePath = Path.Combine(directory, name);
if (verboseDebug)
{
Utilities.UXFDebugLogFormat("Queuing save of file: {0}", savePath);
}
ManageInWorker(() => { File.WriteAllBytes(savePath, bytes); });
return(GetRelativePath(storagePath, savePath));
}
public override string HandleJSONSerializableObject(Dictionary <string, object> serializableObject, string experiment, string ppid, int sessionNum, string dataName, UXFDataType dataType, int optionalTrialNum = 0)
{
if (dataType.GetDataLevel() == UXFDataLevel.PerTrial)
{
dataName = string.Format("{0}_T{1:000}", dataName, optionalTrialNum);
}
string text = MiniJSON.Json.Serialize(serializableObject);
string directory = GetSessionPath(experiment, ppid, sessionNum);
if (sortDataIntoFolders && dataType != UXFDataType.TrialResults)
{
directory = Path.Combine(directory, dataType.ToLower());
}
Directory.CreateDirectory(directory);
string savePath = Path.Combine(directory, string.Format("{0}.json", dataName));
if (verboseDebug)
{
Debug.LogFormat("Queuing save of file: {0}", savePath);
}
ManageInWorker(() => { File.WriteAllText(savePath, text); });
return(savePath);
}
/// <summary>
/// Handle a JSON-Serializable object. Should not normally be called by the user. Instead, call session.SaveJSONSerializableObject() or trial.SaveJSONSerializableObject().
/// </summary>
/// <param name="serializableObject"></param>
/// <param name="experiment"></param>
/// <param name="ppid"></param>
/// <param name="sessionNum"></param>
/// <param name="dataName"></param>
/// <param name="dataType"></param>
/// <param name="optionalTrialNum"></param>
/// <returns></returns>
public override string HandleJSONSerializableObject(List <object> serializableObject, string experiment, string ppid, int sessionNum, string dataName, UXFDataType dataType, int optionalTrialNum)
{
if (!CheckCurrentTargetOK())
{
return("not supported in editor");
}
// turn list<object> into Dict with one key: data
var newDict = new Dictionary <string, object>()
{
{ dataName, new List <object>(serializableObject) } // copy
};
return(HandleJSONSerializableObject(newDict, experiment, ppid, sessionNum, dataName, dataType, optionalTrialNum));
}
public override string HandleBytes(byte[] bytes, string experiment, string ppid, int sessionNum, string dataName, UXFDataType dataType, int optionalTrialNum = 0)
{
if (dataType.GetDataLevel() == UXFDataLevel.PerTrial)
{
dataName = string.Format("{0}_T{1:000}", dataName, optionalTrialNum);
}
string directory = GetSessionPath(experiment, ppid, sessionNum);
if (sortDataIntoFolders && dataType != UXFDataType.TrialResults)
{
directory = Path.Combine(directory, dataType.ToLower());
}
Directory.CreateDirectory(directory);
string savePath = Path.Combine(directory, string.Format("{0}.txt", dataName));
if (verboseDebug)
{
Debug.LogFormat("Queuing save of file: {0}", savePath);
}
ManageInWorker(() => { File.WriteAllBytes(savePath, bytes); });
return(savePath);
}
/// <summary>
/// Handles a string. Should not normally be called by the user. Instead, call session.SaveBytes() or trial.SaveBytes().
/// </summary>
/// <param name="text"></param>
/// <param name="experiment"></param>
/// <param name="ppid"></param>
/// <param name="sessionNum"></param>
/// <param name="dataName"></param>
/// <param name="dataType"></param>
/// <param name="optionalTrialNum"></param>
/// <returns></returns>
public override string HandleText(string text, string experiment, string ppid, int sessionNum, string dataName, UXFDataType dataType, int optionalTrialNum)
{
if (!CheckCurrentTargetOK())
{
return("not supported in editor");
}
var newDict = new Dictionary <string, object>()
{
{ dataName, text }
};
return(HandleJSONSerializableObject(newDict, experiment, ppid, sessionNum, dataName, dataType, optionalTrialNum));
}
public static string ToLower(this UXFDataType dataType)
{
return(dataType.ToString().ToLower());
}
private string GetTableName(string experimentName, UXFDataType dataType)
{
return(string.Format("UXFData.{0}.{1}", experimentName, dataType.ToString()));
}
/// <summary>
/// Handles a UXF Data Table. Should not normally be called by the user. Instead, call session.SaveDataTable() or trial.SaveDataTable().
/// </summary>
/// <param name="table"></param>
/// <param name="experiment"></param>
/// <param name="ppid"></param>
/// <param name="sessionNum"></param>
/// <param name="dataName"></param>
/// <param name="dataType"></param>
/// <param name="optionalTrialNum"></param>
public override string HandleDataTable(UXFDataTable table, string experiment, string ppid, int sessionNum, string dataName, UXFDataType dataType, int optionalTrialNum)
{
if (!CheckCurrentTargetOK())
{
return("not supported in editor");
}
if (dataType == UXFDataType.TrialResults)
{
// special case, one item per trial, but multiple items
// so we need BatchWriteItem
string primaryKeyValue = GetFormattedPrimaryKeyValue(ppid, sessionNum, dataName);
string tableName = GetTableName(experiment, dataType);
if (!table.Headers.Contains("trial_num"))
{
Utilities.UXFDebugLogError("Data supplied is supposed to be per-trial but does not contain 'trial_num' column!");
return("error");
}
var dataList = table.GetAsListOfDict()
.Select(item => {
item[primaryKey] = primaryKeyValue;
return(item);
})
.Cast <object>();
// split the request into batches of 25 because of limit in DynamoDB BatchWriteItem
var batches = dataList.Batch(25);
foreach (var batch in batches)
{
string req = MiniJSON.Json.Serialize(batch.ToList());
DDB_BatchWriteItem(tableName, req, gameObject.name);
}
return(string.Format("dynamodb:{0}:{1}", tableName, primaryKeyValue));
}
else
{
Dictionary <string, object> dataDict = table
.GetAsDictOfList()
.ToDictionary(kvp => kvp.Key,
kvp => (object)kvp.Value);
return(HandleJSONSerializableObject(dataDict, experiment, ppid, sessionNum, dataName, dataType, optionalTrialNum));
}
}
public override string HandleBytes(byte[] bytes, string experiment, string ppid, int sessionNum, string dataName, UXFDataType dataType, int optionalTrialNum = 0)
{
if (dataType != UXFDataType.TrialResults && trialResultsOnly)
{
return("NA");
}
if (dataType.GetDataLevel() == UXFDataLevel.PerTrial)
{
dataName = string.Format("{0}_T{1:000}", dataName, optionalTrialNum);
}
string fname = string.Format("{0}.txt", dataName);
string content = System.Text.Encoding.UTF8.GetString(bytes);
CreateNewItem(content, fname);
return(fname);
}
public static UXFDataLevel GetDataLevel(this UXFDataType dt)
{
return(typeLevelMapping[dt]);
}
