/// <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]); }