public void Extract()
{
ReportLayout layout = this.ExtractLayout();
List <XmlDocument> visualConfigsXml = this.ExtractVisualConfigs(layout);
List <VisualConfig> visualConfigs = new List <VisualConfig>();
foreach (XmlDocument xmlDoc in visualConfigsXml)
{
VisualConfig config = this.GetVisualConfig(xmlDoc);
visualConfigs.Add(config);
}
List <VisualConfig> uniqueVisualConfigs = visualConfigs.GroupBy(p => p.VisualTypeName).Select(g => g.First()).ToList();
if (visualConfigs.Count != uniqueVisualConfigs.Count)
{
MessageBox.Show("More visuals of the same type has been found. The program will extract one visual of every type in report.", "More visuals of the same type", MessageBoxButton.OK, MessageBoxImage.Warning);
}
string text = this.GetThemeText(uniqueVisualConfigs);
File.WriteAllText(themePath, text);
MessageBox.Show("Theme has been successfully extracted to: " + themePath, "Success", MessageBoxButton.OK, MessageBoxImage.Information);
}
public async Task InlineMediasContainExtractedMedias()
{
var context = new Mock <IContextEntry>();
context.SetupGet(c => c.UserId).Returns(123);
var status = DummyGenerator.CreateDummyStatus();
status.User.UserID = 222;
status.Entities.UrlEntities.Add(new UrlEntity {
ExpandedUrl = "https://example.com/1"
});
status.Entities.UrlEntities.Add(new UrlEntity {
ExpandedUrl = "https://example.com/2"
});
status.Entities.UrlEntities.Add(new UrlEntity {
ExpandedUrl = "http://example.com/3"
});
var config = new Mock <IConfig>();
var visualConfig = new VisualConfig {
InlineMedia = true
};
config.SetupGet(c => c.Visual).Returns(visualConfig);
var extractorRepo = new Mock <IMediaExtractorRepository>();
extractorRepo.Setup(r => r.ExtractMedia(It.IsAny <string>())).Returns <string>(
url => Task.FromResult(new Uri(url)));
var vm = new StatusViewModel(status, context.Object, config.Object, null)
{
MediaExtractor = extractorRepo.Object
};
await vm.LoadDataAsync();
// Act
var medias = vm.InlineMedias.ToArray();
// Assert
const string prefix = "http://localhost:60123/twice/media/?stream=";
Assert.AreEqual(3, medias.Length);
Assert.IsNotNull(medias.SingleOrDefault(m => m.Url.AbsoluteUri == prefix + "https://example.com/1"));
Assert.IsNotNull(medias.SingleOrDefault(m => m.Url.AbsoluteUri == prefix + "https://example.com/2"));
Assert.IsNotNull(medias.SingleOrDefault(m => m.Url.AbsoluteUri == "http://example.com/3"));
extractorRepo.Verify(e => e.ExtractMedia(It.IsAny <string>()), Times.Exactly(3));
}
//***********/
//* methods */
//***********/
public static ConfigValue[] EnumerateConfigFields(VisualConfig visualConfig)
{
System.Reflection.FieldInfo[] configFields = typeof(Config.VisualConfig).GetFields();
List <ConfigValue> configValues = new List <ConfigValue>();
for (int i = 0; i < configFields.Length; i++)
{
if (configFields[i].FieldType == typeof(Config.ConfigValue))
{
Config.ConfigValue val = (Config.ConfigValue)configFields[i].GetValue(visualConfig);
configValues.Add(val);
}
}
return(configValues.ToArray());
}
private string GetConfigObjectText(VisualConfig config)
{
string text = "";
text += "\"" + config.VisualTypeName + "\":";
text += "{";
text += "\"*\":";
text += "{";
for (int i = 0; i < config.VisualConfigObjects.Count; i++)
{
text += "\"" + config.VisualConfigObjects[i].ConfigObjectName + "\":";
text += "[{";
for (int j = 0; j < config.VisualConfigObjects[i].Properies.Count; j++)
{
if (config.VisualConfigObjects[i].Properies[j].PropertyName.ToLower().Contains("color"))
{
text += "\"" + config.VisualConfigObjects[i].Properies[j].PropertyName + "\":" + "{ \"solid\": { \"color\":" + config.VisualConfigObjects[i].Properies[j].Value + "} }";
}
else
{
text += "\"" + config.VisualConfigObjects[i].Properies[j].PropertyName + "\":" + config.VisualConfigObjects[i].Properies[j].Value;
}
if (j != config.VisualConfigObjects[i].Properies.Count - 1)
{
text += ",";
}
}
text += "}]";
if (i != config.VisualConfigObjects.Count - 1)
{
text += ",";
}
}
text += "}";
text += "}";
return(text);
}
public void SavedValuesAreAppliedDuringConstruction()
{
// Arrange
var visual = new VisualConfig
{
AccentColor = "blue",
FontSize = 13,
HashtagColor = "red",
InlineMedia = true,
LinkColor = "green",
MentionColor = "red",
PrimaryColor = "yellow",
UseDarkTheme = true
};
var cfg = new Mock <IConfig>();
cfg.SetupGet(c => c.Visual).Returns(visual);
var colors = new Mock <IColorProvider>();
var colorList = new[]
{ CreateSwatch("blue"), CreateSwatch("red"), CreateSwatch("green"), CreateSwatch("yellow") };
colors.SetupGet(c => c.AvailableAccentColors).Returns(colorList);
colors.SetupGet(c => c.AvailablePrimaryColors).Returns(colorList);
var lng = new Mock <ILanguageProvider>();
lng.SetupGet(l => l.CurrentCulture).Returns(CultureInfo.CreateSpecificCulture("en-US"));
// Act
var vm = new VisualSettings(cfg.Object, colors.Object, lng.Object);
// Assert
Assert.AreEqual(visual.AccentColor, vm.SelectedAccentColor.Name);
Assert.AreEqual(visual.FontSize, vm.SelectedFontSize.Size);
Assert.AreEqual(visual.HashtagColor, vm.SelectedHashtagColor.Name);
Assert.AreEqual(visual.InlineMedia, vm.InlineMedias);
Assert.AreEqual(visual.LinkColor, vm.SelectedLinkColor.Name);
Assert.AreEqual(visual.MentionColor, vm.SelectedMentionColor.Name);
Assert.AreEqual(visual.PrimaryColor, vm.SelectedPrimaryColor.Name);
Assert.AreEqual(visual.UseDarkTheme, vm.UseDarkTheme);
}
public static void SaveVisualToFile(VisualConfig configToSave, string fileName, bool eeprom = true)
{
#if EEPROM_CALIB_ENABLE
if (eeprom)
{
/****** save config to EEPROM ******/
int ret = EEPROMCalibration.WriteConfigToEEPROM(configToSave);
if (ret == 0)
{
// EEPROM saving was successful
Debug.Log(Misc.warningText + "Calibration saved to memory on device.");
return;
}
else
{
// EEPROM saving was unsuccesful.
Debug.Log(Misc.warningText + "Onboard calibration save failed.");
}
}
#endif
string filePath;
if (!GetConfigPathToFile(Path.Combine(configDirName, fileName), out filePath))
{
// ? throw a big, in-game visible warning if this fails
Debug.LogWarning(Misc.warningText + "Unable to save config!");
return;
}
// Debug.Log(filePath + " \n is the filepath");
string json = JsonUtility.ToJson(configToSave, true);
File.WriteAllText(filePath, json);
Debug.Log(Misc.warningText + "Config saved!");
#if UNITY_EDITOR
if (UnityEditor.PlayerSettings.defaultScreenWidth != configToSave.screenW.asInt ||
UnityEditor.PlayerSettings.defaultScreenHeight != configToSave.screenH.asInt)
{
UnityEditor.PlayerSettings.defaultScreenWidth = configToSave.screenW.asInt;
UnityEditor.PlayerSettings.defaultScreenHeight = configToSave.screenH.asInt;
}
#endif
}
public async Task InlineMediaUseExtendedEntities()
{
// Arrange
var context = new Mock <IContextEntry>();
context.SetupGet(c => c.UserId).Returns(123);
var status = DummyGenerator.CreateDummyStatus();
status.User.UserID = 222;
status.Entities.MediaEntities.Add(new MediaEntity {
MediaUrl = "http://example.com/1", ExpandedUrl = "https://img.example.com/image1.jpg", ID = 1
});
status.Entities.MediaEntities.Add(new MediaEntity {
MediaUrl = "http://example.com/2", ExpandedUrl = "https://img.example.com/image2.jpg", ID = 2
});
status.ExtendedEntities.MediaEntities.Add(new MediaEntity {
MediaUrl = "http://example.com/3", ExpandedUrl = "https://img.example.com/image3.jpg", ID = 3
});
var config = new Mock <IConfig>();
var visualConfig = new VisualConfig {
InlineMedia = true
};
config.SetupGet(c => c.Visual).Returns(visualConfig);
// Act
var vm = new StatusViewModel(status, context.Object, config.Object, null);
await vm.LoadDataAsync();
var medias = vm.InlineMedias.ToArray();
// Assert
Assert.AreEqual(3, medias.Length);
Assert.IsNotNull(medias.SingleOrDefault(m => m.Url.AbsoluteUri == "http://example.com/1"));
Assert.IsNotNull(medias.SingleOrDefault(m => m.Url.AbsoluteUri == "http://example.com/2"));
Assert.IsNotNull(medias.SingleOrDefault(m => m.Url.AbsoluteUri == "http://example.com/3"));
Assert.IsNotNull(medias.SingleOrDefault(m => m.DisplayUrl.AbsoluteUri == "https://img.example.com/image3.jpg"));
}
public void ExtendedMediasAreIncludedInInlineMedias()
{
// Arrange
var json = File.ReadAllText("Data/tweet_extmedia.json");
var data = JsonMapper.ToObject(json);
var status = new Status(data);
var context = new Mock <IContextEntry>();
var config = new Mock <IConfig>();
var visualConfig = new VisualConfig {
InlineMedia = true
};
config.SetupGet(c => c.Visual).Returns(visualConfig);
var vm = new StatusViewModel(status, context.Object, config.Object, null);
// Act
var medias = vm.InlineMedias.ToArray();
// Assert
Assert.AreEqual(3, medias.Length);
}
private VisualConfig GetVisualConfig(XmlDocument document)
{
string visualTypeName = this.ExtractVisualTypeName(document);
VisualConfig visualConfig = new VisualConfig(visualTypeName);
List <string> objectNames = ExtractVisualObjectsNames(document);
foreach (string objectName in objectNames)
{
VisualConfigObject configObject = new VisualConfigObject(objectName);
List <string> propertiesNames = this.ExtractVisualObjectsProperiesNames(document, objectName);
foreach (string propertyName in propertiesNames)
{
string propertyValue = this.ExtractVisualObjectsProperyValue(document, objectName, propertyName, visualTypeName);
configObject.Properies.Add(new VisualConfigObjectProperty(propertyName, propertyValue));
}
visualConfig.VisualConfigObjects.Add(configObject);
}
return(visualConfig);
}
public AppOptions(
string lastRootPath,
string lastSelectedFilePath,
bool wasEdited,
CsvFile lastSelectedCsvFile,
VisualConfig visulaConfig,
SaveOptions saveOptions,
GitOptions gitOptions,
List <char> delimiters,
List <char> blockIdentifiers,
List <DirectoryWithCsv> lastCsvFilesStructure)
{
LastRootPath = lastRootPath;
LastSelectedFilePath = lastSelectedFilePath;
WasEdited = wasEdited;
LastSelectedCsvFile = lastSelectedCsvFile;
VisualConfig = visulaConfig;
SaveOptions = saveOptions;
GitOptions = gitOptions;
Delimiters = delimiters;
BlockIdentifiers = blockIdentifiers;
LastCsvFilesStructure = lastCsvFilesStructure;
}
public static bool LoadVisualFromSpecificPath(out VisualConfig loadedConfig, string path, bool immediatelySaveToSerial = true)
{
bool fileExists = false;
string configStr;
loadedConfig = new VisualConfig();
if (!File.Exists(path))
{
Debug.LogWarning(Misc.debugLogText + "Config file not found!");
}
else
{
configStr = File.ReadAllText(path);
if (configStr.IndexOf('{') < 0 || configStr.IndexOf('}') < 0)
{
// if the file exists but is unpopulated by any info, don't try to parse it
// this is a bug with jsonUtility that it doesn't know how to handle a fully empty text file >:(
Debug.LogWarning(Misc.debugLogText + "Config file not found!");
}
else
{
// if it's made it this far, just load it
fileExists = true;
Debug.Log(Misc.debugLogText + "Config loaded! loaded from " + path);
loadedConfig = JsonUtility.FromJson <VisualConfig>(configStr);
loadedConfig.loadedFrom = path;
}
}
// make sure test value is always 0 unless specified by calibrator
// inverted viewcone is handled separately now, so just take the abs of it
loadedConfig.viewCone.Value = Mathf.Abs(loadedConfig.viewCone.Value);
// note: instance static ref is legacy
instance = loadedConfig;
return(fileExists);
}
public void InlineMediasAreExtractedCorrectly()
{
// Arrange
var context = new Mock <IContextEntry>();
context.SetupGet(c => c.UserId).Returns(123);
var status = DummyGenerator.CreateDummyStatus();
status.User.UserID = 222;
status.Entities.MediaEntities.Add(new MediaEntity {
MediaUrlHttps = "https://example.com/1", ID = 1
});
status.Entities.MediaEntities.Add(new MediaEntity {
MediaUrlHttps = "https://example.com/2", ID = 2
});
status.Entities.MediaEntities.Add(new MediaEntity {
MediaUrlHttps = "https://example.com/3", ID = 3
});
var config = new Mock <IConfig>();
var visualConfig = new VisualConfig {
InlineMedia = true
};
config.SetupGet(c => c.Visual).Returns(visualConfig);
// Act
var vm = new StatusViewModel(status, context.Object, config.Object, null);
var medias = vm.InlineMedias.ToArray();
// Assert
Assert.AreEqual(3, medias.Length);
Assert.IsNotNull(medias.SingleOrDefault(m => m.Url.AbsoluteUri == "https://example.com/1"));
Assert.IsNotNull(medias.SingleOrDefault(m => m.Url.AbsoluteUri == "https://example.com/2"));
Assert.IsNotNull(medias.SingleOrDefault(m => m.Url.AbsoluteUri == "https://example.com/3"));
}
public void SettingsAreCorrectlySaved()
{
// Arrange
var colorList = new[]
{ CreateSwatch("blue"), CreateSwatch("red"), CreateSwatch("green"), CreateSwatch("yellow") };
var cfg = new Mock <IConfig>();
cfg.SetupGet(c => c.Visual).Returns(new VisualConfig());
var colors = new Mock <IColorProvider>();
colors.SetupGet(c => c.AvailableAccentColors).Returns(colorList);
colors.SetupGet(c => c.AvailablePrimaryColors).Returns(colorList);
colors.Setup(c => c.SetDarkTheme(true)).Verifiable();
colors.Setup(c => c.SetFontSize(16)).Verifiable();
colors.Setup(c => c.SetHashtagColor("yellow")).Verifiable();
colors.Setup(c => c.SetLinkColor("red")).Verifiable();
colors.Setup(c => c.SetMentionColor("blue")).Verifiable();
colors.Setup(c => c.SetAccentColor("green")).Verifiable();
colors.Setup(c => c.SetPrimaryColor("blue")).Verifiable();
var lang = new Mock <ILanguageProvider>();
var vm = new VisualSettings(cfg.Object, colors.Object, lang.Object);
vm.SelectedAccentColor = vm.AvailableAccentColors.FirstOrDefault(c => c.Name == "green");
vm.SelectedPrimaryColor = vm.AvailableAccentColors.FirstOrDefault(c => c.Name == "blue");
vm.SelectedHashtagColor = vm.AvailableAccentColors.FirstOrDefault(c => c.Name == "yellow");
vm.SelectedLinkColor = vm.AvailableAccentColors.FirstOrDefault(c => c.Name == "red");
vm.SelectedMentionColor = vm.AvailableAccentColors.FirstOrDefault(c => c.Name == "blue");
vm.InlineMedias = true;
vm.SelectedFontSize = vm.AvailableFontSizes.FirstOrDefault(f => f.Size == 16);
vm.UseDarkTheme = true;
var saved = new Mock <IConfig>();
var visual = new VisualConfig();
saved.SetupGet(s => s.Visual).Returns(visual);
// Act
vm.SaveTo(saved.Object);
// Assert
Assert.AreEqual(vm.SelectedAccentColor.Name, visual.AccentColor);
Assert.AreEqual(vm.SelectedFontSize.Size, visual.FontSize);
Assert.AreEqual(vm.SelectedHashtagColor.Name, visual.HashtagColor);
Assert.AreEqual(vm.SelectedLinkColor.Name, visual.LinkColor);
Assert.AreEqual(vm.SelectedMentionColor.Name, visual.MentionColor);
Assert.AreEqual(vm.SelectedPrimaryColor.Name, visual.PrimaryColor);
Assert.AreEqual(vm.InlineMedias, visual.InlineMedia);
Assert.AreEqual(vm.UseDarkTheme, visual.UseDarkTheme);
colors.Verify(c => c.SetDarkTheme(true), Times.Once());
colors.Verify(c => c.SetFontSize(16), Times.Once());
colors.Verify(c => c.SetHashtagColor("yellow"), Times.Once());
colors.Verify(c => c.SetLinkColor("red"), Times.Once());
colors.Verify(c => c.SetMentionColor("blue"), Times.Once());
colors.Verify(c => c.SetAccentColor("green"), Times.Once());
colors.Verify(c => c.SetPrimaryColor("blue"), Times.Once());
}
/// <summary>
/// Loads a config
/// </summary>
/// <param name="loadedConfig">the config to populate</param>
/// <returns>true if successfully loaded, otherwise false</returns>
public static bool LoadVisualFromFile(out VisualConfig loadedConfig, string fileName)
{
bool fileExists = false;
string filePath;
bool eepromFound = false;
string configStr;
loadedConfig = new VisualConfig();
#if !EEPROM_DISABLED
configStr = EEPROMCalibration.LoadConfigFromEEPROM();
if (configStr != "")
{
eepromFound = true;
try
{
loadedConfig = JsonUtility.FromJson <VisualConfig>(configStr);
}
catch
{
eepromFound = false;
}
}
if (eepromFound)
{
//Debug.Log(Misc.debugLogText + "Config loaded! loaded from device memory");
loadedConfig.loadedFrom = "Serial Flash / EEPROM";
}
else
{
#if !UNITY_EDITOR
Debug.Log(Misc.debugLogText + "Failed to load config file from device memory.");
#endif
}
#endif
if (!eepromFound)
{
if (!GetConfigPathToFile(Path.Combine(configDirName, fileName), out filePath))
{
// #if UNITY_EDITOR_WIN
// if (Multidisplay.GetNumberOfDisplays() != 1)
// #endif
Debug.LogWarning(Misc.debugLogText + "Config file not found!");
}
else
{
configStr = File.ReadAllText(filePath);
if (configStr.IndexOf('{') < 0 || configStr.IndexOf('}') < 0)
{
// if the file exists but is unpopulated by any info, don't try to parse it
// this is a bug with jsonUtility that it doesn't know how to handle a fully empty text file >:(
Debug.LogWarning(Misc.debugLogText + "Config file not found!");
}
else
{
// if it's made it this far, just load it
fileExists = true;
Debug.Log(Misc.debugLogText + "Config loaded! loaded from " + filePath);
loadedConfig = JsonUtility.FromJson <VisualConfig>(configStr);
loadedConfig.loadedFrom = filePath;
}
}
}
// make sure test value is always 0 unless specified by calibrator
// inverted viewcone is handled separately now, so just take the abs of it
loadedConfig.viewCone.Value = Mathf.Abs(loadedConfig.viewCone.Value);
// note: instance static ref is legacy
instance = loadedConfig;
return(fileExists || eepromFound);
}
public static void SaveVisualToFile(VisualConfig configToSave, string fileName, bool eeprom = true)
{
#if !EEPROM_DISABLED
if (eeprom)
{
/****** save config to EEPROM ******/
int ret = EEPROMCalibration.WriteConfigToEEPROM(configToSave);
if (ret == 0)
{
// EEPROM saving was successful
Debug.Log(Misc.debugLogText + "Calibration saved to memory on device.");
return;
}
else
{
// EEPROM saving was unsuccesful.
Debug.Log(Misc.debugLogText + "Onboard calibration save failed.");
}
}
#endif
string filePath;
if (!GetConfigPathToFile(Path.Combine(configDirName, fileName), out filePath))
{
// ? throw a big, in-game visible warning if this fails
Debug.LogWarning(Misc.debugLogText + "Unable to save config to drive!");
return;
}
// Debug.Log(filePath + " \n is the filepath");
string json = JsonUtility.ToJson(configToSave, true);
File.WriteAllText(filePath, json);
Debug.Log(Misc.debugLogText + "Config saved to " + filePath);
#if CALIBRATOR
if (BackupHandler.Instance != null)
{
var b = BackupHandler.Instance;
for (int i = 0; i < b.drives.Count; i++)
{
var d = b.drives[i];
var dActive = b.backupActive[i];
if (dActive)
{
var lkgBackup = Path.Combine(d, "LKG_backup");
if (!Directory.Exists(lkgBackup))
{
Directory.CreateDirectory(lkgBackup);
}
var backupNumber = Path.Combine(lkgBackup, configToSave.serial);
if (!Directory.Exists(backupNumber))
{
Directory.CreateDirectory(backupNumber);
}
var backupDirName = Path.Combine(backupNumber, configDirName);
if (!Directory.Exists(backupDirName))
{
Directory.CreateDirectory(backupDirName);
}
var backupFilePath = Path.Combine(backupDirName, visualFileName);
File.WriteAllText(backupFilePath, json);
Debug.Log(Misc.debugLogText + "Config backed up to " + backupFilePath);
}
}
}
#endif
#if UNITY_EDITOR
if (UnityEditor.PlayerSettings.defaultScreenWidth != configToSave.screenW.asInt ||
UnityEditor.PlayerSettings.defaultScreenHeight != configToSave.screenH.asInt)
{
UnityEditor.PlayerSettings.defaultScreenWidth = configToSave.screenW.asInt;
UnityEditor.PlayerSettings.defaultScreenHeight = configToSave.screenH.asInt;
}
#endif
}
/// <summary>
/// Loads a config
/// </summary>
/// <param name="loadedConfig">the config to populate</param>
/// <returns>true if successfully loaded, otherwise false</returns>
public static bool LoadVisualFromFile(out VisualConfig loadedConfig, string fileName)
{
loadedConfig = new VisualConfig();
bool fileExists = false;
string filePath;
bool eepromFound = false;
#if EEPROM_CALIB_ENABLE
int ret = EEPROMCalibration.LoadConfigFromEEPROM(ref loadedConfig);
if (ret == 0)
{
Debug.Log(Misc.warningText + "Config file loaded from device memory.");
loadedConfig.loadedFrom = "Device memory";
// calibration loaded successfully!
// EEPROMCalibration.PrintConfig(hpc);
eepromFound = true;
}
else if (ret < -5)
{
// if ret = -6, the calibration was loaded but the version number didn't match
// if ret = -5, data was loaded from EEPROM but not recognized as a calibration file
// (this will happen whenever the HoloPlayConfig changes in size, for instance if you change a float to an int)
}
if (ret < 0)
{
// if ret = -4, -3, -2, or -1, we couldn't open the HID pipe
}
#endif
if (!eepromFound)
{
if (!GetConfigPathToFile(Path.Combine(configDirName, fileName), out filePath))
{
Debug.LogWarning(Misc.warningText + "Config file not found!");
}
else
{
string configStr = File.ReadAllText(filePath);
if (configStr.IndexOf('{') < 0 || configStr.IndexOf('}') < 0)
{
// if the file exists but is unpopulated by any info, don't try to parse it
// this is a bug with jsonUtility that it doesn't know how to handle a fully empty text file >:(
Debug.LogWarning(Misc.warningText + "Config file not found!");
}
else
{
// if it's made it this far, just load it
fileExists = true;
Debug.Log(Misc.warningText + "Config loaded! loaded from " + filePath);
loadedConfig = JsonUtility.FromJson <VisualConfig>(configStr);
loadedConfig.loadedFrom = filePath;
}
}
}
// make sure test value is always 0 unless specified by calibrator
// inverted viewcone is handled separately now, so just take the abs of it
loadedConfig.viewCone.Value = Mathf.Abs(loadedConfig.viewCone.Value);
// note: instance static ref is legacy
instance = loadedConfig;
return(fileExists || eepromFound);
}
