public static async Task <CharacterCache> DownloadSINnerExtended(SINners.Models.SINner sinner, CharacterCache objCache)
{
try
{
try
{
var client = await StaticUtils.GetClient();
var onlinesinner = await client.GetSINByIdWithHttpMessagesAsync(sinner.Id.Value);
var json = onlinesinner.Body.MyExtendedAttributes.JsonSummary;
var onlineCache = Newtonsoft.Json.JsonConvert.DeserializeObject <CharacterCache>(json);
objCache.CharacterAlias = onlineCache.CharacterAlias;
objCache.CharacterName = onlineCache.CharacterName;
objCache.MugshotBase64 = onlineCache.MugshotBase64;
objCache.Background = onlineCache.Background;
objCache.CharacterNotes = onlineCache.CharacterNotes;
objCache.BuildMethod = onlineCache.BuildMethod;
objCache.Concept = onlineCache.Concept;
objCache.Created = onlineCache.Created;
objCache.Description = onlineCache.Description;
objCache.ErrorText = onlineCache.ErrorText;
objCache.Essence = onlineCache.Essence;
objCache.FileName = onlineCache.FileName;
objCache.FilePath = onlineCache.FilePath;
objCache.GameNotes = onlineCache.GameNotes;
objCache.Karma = onlineCache.Karma;
objCache.Metatype = onlineCache.Metatype;
objCache.Metavariant = onlineCache.Metavariant;
objCache.Mugshot = onlineCache.Mugshot;
}
catch (Exception ex)
{
System.Diagnostics.Trace.TraceError(ex.Message);
if (objCache != null)
{
objCache.ErrorText = ex.Message;
}
}
return(objCache);
}
catch (Exception e)
{
System.Diagnostics.Trace.TraceError(e.Message);
objCache.ErrorText = e.Message;
throw;
}
}
public static List <TreeNode> CharacterRosterTreeNodifyGroupList(List <SINnerSearchGroup> groups)
{
if (groups == null)
{
return(MyTreeNodeList);
}
foreach (var parentlist in groups)
{
try
{
//list.SiNner.DownloadedFromSINnersTime = DateTime.Now;
var objListNode = GetCharacterRosterTreeNodeRecursive(parentlist);
PluginHandler.MainForm.DoThreadSafe(() =>
{
if (objListNode != null)
{
MyTreeNodeList.Add(objListNode);
}
else
{
TreeNode node = new TreeNode("no owned chummers found")
{
Tag = "",
Name = "no owned chummers found",
ToolTipText =
"To upload a chummer go into the sinners-tabpage after opening a character and press upload (and wait a bit)."
};
MyTreeNodeList.Add(node);
}
});
}
catch (Exception e)
{
System.Diagnostics.Trace.TraceWarning("Could not deserialize CharacterCache-Object: " + e.ToString());
TreeNode errorNode = new TreeNode()
{
Text = "Error loading Char from WebService"
};
var objCache = new CharacterCache();
objCache.ErrorText = e.ToString();
errorNode.Tag = objCache;
return(new List <TreeNode>()
{
errorNode
});
}
}
if (MyTreeNodeList.Count == 0)
{
PluginHandler.MainForm.DoThreadSafe(() =>
{
TreeNode node = new TreeNode("Online, but no chummers uploaded");
node.Tag = node.Text;
node.ToolTipText =
"To upload a chummer, open it go to the sinners-tabpage and click upload (and wait a bit).";
MyTreeNodeList.Add(node);
});
}
return(MyTreeNodeList);
}
private static TreeNode GetCharacterRosterTreeNodeRecursive(SINnerSearchGroup ssg)
{
TreeNode objListNode = new TreeNode
{
Text = ssg.Groupname,
Name = ssg.Groupname
};
foreach (var member in ssg.MyMembers)
{
var sinner = member.MySINner;
sinner.DownloadedFromSINnersTime = DateTime.Now;
CharacterCache objCache = null;
if (!String.IsNullOrEmpty(sinner?.MyExtendedAttributes?.JsonSummary))
{
objCache =
Newtonsoft.Json.JsonConvert.DeserializeObject <CharacterCache>(sinner.MyExtendedAttributes
.JsonSummary);
}
else
{
objCache = new CharacterCache
{
CharacterName = "pending",
CharacterAlias = sinner.Alias,
BuildMethod = "online"
};
}
SetEventHandlers(sinner, objCache);
TreeNode memberNode = new TreeNode
{
Text = objCache.CalculatedName(),
Name = objCache.CalculatedName(),
Tag = sinner.Id.Value.ToString(),
ToolTipText = "Last Change: " + sinner.LastChange,
ContextMenuStrip = PluginHandler.MainForm.CharacterRoster.ContextMenuStrip
};
if (String.IsNullOrEmpty(sinner.DownloadUrl))
{
objCache.ErrorText = "File is not uploaded - only metadata available." + Environment.NewLine
+ "Please upload this file again from a client," +
Environment.NewLine
+ "that has saved a local copy." +
Environment.NewLine + Environment.NewLine
+ "Open the character locally, make sure to have \"online mode\"" +
Environment.NewLine
+ "selected in option->plugins->sinner and press the \"save\" symbol.";
}
if (!objListNode.Nodes.ContainsKey(memberNode.Name))
{
objListNode.Nodes.Insert(0, memberNode);
}
if (!string.IsNullOrEmpty(objCache.ErrorText))
{
memberNode.ForeColor = Color.Red;
memberNode.ToolTipText += Environment.NewLine + Environment.NewLine +
LanguageManager.GetString("String_Error", GlobalOptions.Language)
+ LanguageManager.GetString("String_Colon", GlobalOptions.Language) +
Environment.NewLine + objCache.ErrorText;
}
CharacterCache delObj;
PluginHandler.MainForm.CharacterRoster.MyCharacterCacheDic.TryRemove(sinner.Id.Value.ToString(), out delObj);
PluginHandler.MainForm.CharacterRoster.MyCharacterCacheDic.TryAdd(sinner.Id.Value.ToString(), objCache);
if (ssg.MySINSearchGroups != null)
{
foreach (var childlist in ssg.MySINSearchGroups)
{
var childnode = GetCharacterRosterTreeNodeRecursive(childlist);
if (childnode != null)
{
if (!objListNode.Nodes.ContainsKey(childnode.Text))
{
objListNode.Nodes.Add(childnode);
}
}
}
}
}
if (ssg.MySINSearchGroups != null)
{
foreach (var childssg in ssg.MySINSearchGroups)
{
var childnode = GetCharacterRosterTreeNodeRecursive(childssg);
if (childnode != null)
{
if (!objListNode.Nodes.ContainsKey(childnode.Name))
{
objListNode.Nodes.Add(childnode);
}
else
{
var list = objListNode.Nodes.Find(childnode.Name, false).ToList();
foreach (var mergenode in list)
{
foreach (TreeNode what in childnode.Nodes)
{
if (!mergenode.Nodes.ContainsKey(what.Name))
{
mergenode.Nodes.Add(what);
}
}
}
}
}
}
}
return(objListNode);
}
public static Task <string> DownloadSINnerExtendedTask(SINners.Models.SINner sinner, CharacterCache objCache)
{
try
{
if ((objCache.DownLoadRunning != null) && (objCache.DownLoadRunning.Status == TaskStatus.Running))
{
return(objCache.DownLoadRunning);
}
objCache.DownLoadRunning = Task.Factory.StartNew <string>(() =>
{
objCache = DownloadSINnerExtended(sinner, objCache).Result;
//objCache.FilePath = filepath;
return(objCache.ErrorText);
});
return(objCache.DownLoadRunning);
}
catch (Exception ex)
{
objCache.ErrorText = ex.ToString();
throw;
}
}
/// <summary>
/// Generates a character cache, which prevents us from repeatedly loading XmlNodes or caching a full character.
/// </summary>
/// <param name="strFile"></param>
internal async static Task <IEnumerable <TreeNode> > GetCharacterRosterTreeNode(bool forceUpdate, Func <Task <HttpOperationResponse <SINSearchGroupResult> > > myGetSINnersFunction)
{
if ((MyTreeNodeList != null) && !forceUpdate)
{
return(MyTreeNodeList);
}
MyTreeNodeList = new List <TreeNode>();
try
{
PluginHandler.MainForm.DoThreadSafe(() =>
{
MyTreeNodeList.Clear();
});
HttpOperationResponse <SINSearchGroupResult> response = null;
try
{
response = await myGetSINnersFunction();
}
catch (Microsoft.Rest.SerializationException e)
{
if (e.Content.Contains("Log in - ChummerHub"))
{
TreeNode node = new TreeNode("Online, not logged in");
node.ToolTipText = "Please log in (Options -> Plugins -> Sinners (Cloud) -> Login";
PluginHandler.MainForm.DoThreadSafe(() =>
{
MyTreeNodeList.Add(node);
});
return(MyTreeNodeList);
}
else
{
string msg = "Could not load response from SINners:" + Environment.NewLine;
msg += e.Message;
if (e.InnerException != null)
{
msg += Environment.NewLine + e.InnerException.Message;
}
System.Diagnostics.Trace.TraceWarning(msg);
PluginHandler.MainForm.DoThreadSafe(() =>
{
MyTreeNodeList.Add(new TreeNode()
{
ToolTipText = msg
});
});
return(MyTreeNodeList);
}
}
if (response == null || (response.Response.StatusCode == HttpStatusCode.BadRequest))
{
string msg = "Could not load online Sinners: " + response?.Response.ReasonPhrase;
if (response != null)
{
var content = await response.Response.Content.ReadAsStringAsync();
msg += Environment.NewLine + "Content: " + content;
}
System.Diagnostics.Trace.TraceWarning(msg);
var errornode = new TreeNode()
{
Text = "Error contacting SINners"
};
CharacterCache errorCache = new CharacterCache
{
ErrorText = "Error is copied to clipboard!" + Environment.NewLine + Environment.NewLine + msg,
CharacterAlias = "Error loading SINners"
};
errorCache.OnMyAfterSelect += (sender, args) =>
{
PluginHandler.MainForm.DoThreadSafe(() =>
{
System.Windows.Forms.Clipboard.SetText(msg);
});
};
errornode.Tag = errorCache;
PluginHandler.MainForm.DoThreadSafe(() =>
{
MyTreeNodeList.Add(errornode);
});
return(MyTreeNodeList);
}
SINSearchGroupResult result = response.Body as SINSearchGroupResult;
if (result?.Roles != null)
{
StaticUtils.UserRoles = result.Roles?.ToList();
}
System.Diagnostics.Trace.TraceInformation("Connected to SINners in version " + result?.Version?.AssemblyVersion + ".");
var groups = result?.SinGroups.ToList();
MyTreeNodeList = CharacterRosterTreeNodifyGroupList(groups);
return(MyTreeNodeList);
}
catch (Exception ex)
{
System.Diagnostics.Trace.TraceError(ex.ToString());
throw;
}
}
public static async Task <string> DownloadFile(SINners.Models.SINner sinner, CharacterCache objCache)
{
try
{
//currently only one chum5-File per chum5z ZipFile is implemented!
string loadFilePath = null;
string zipPath = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "SINner", sinner.Id.Value.ToString());
if (Directory.Exists(zipPath))
{
var files = Directory.EnumerateFiles(zipPath, "*.chum5", SearchOption.TopDirectoryOnly);
foreach (var file in files)
{
DateTime lastwrite = File.GetLastWriteTime(file);
if ((lastwrite >= sinner.LastChange) ||
sinner.LastChange == null)
{
loadFilePath = file;
objCache.FilePath = loadFilePath;
break;
}
//no recent file found - download it (again).
File.Delete(file);
}
}
else
{
Directory.CreateDirectory(zipPath);
}
Character objOpenCharacter = null;
objOpenCharacter = PluginHandler.MainForm?.OpenCharacters?.FirstOrDefault(x => x.FileName == loadFilePath);
if ((objOpenCharacter != null))
{
return(loadFilePath);
}
if (String.IsNullOrEmpty(loadFilePath))
{
try
{
string zippedFile = Path.Combine(System.IO.Path.GetTempPath(), "SINner", sinner.Id.Value + ".chum5z");
if (File.Exists(zippedFile))
{
File.Delete(zippedFile);
}
var client = await StaticUtils.GetClient();
var filestream = client.GetDownloadFile(sinner.Id.Value);
var array = ReadFully(filestream);
File.WriteAllBytes(zippedFile, array);
System.IO.Compression.ZipFile.ExtractToDirectory(zippedFile, zipPath);
var files = Directory.EnumerateFiles(zipPath, "*.chum5", SearchOption.TopDirectoryOnly);
foreach (var file in files)
{
if (sinner.UploadDateTime != null)
{
File.SetCreationTime(file, sinner.UploadDateTime.Value);
}
if (sinner.LastChange != null)
{
File.SetLastWriteTime(file, sinner.LastChange.Value);
}
loadFilePath = file;
objCache.FilePath = loadFilePath;
}
}
catch (Exception ex)
{
System.Diagnostics.Trace.TraceError(ex.Message);
if (objCache != null)
{
objCache.ErrorText = ex.Message;
}
}
}
return(objCache.FilePath);
}
catch (Exception e)
{
System.Diagnostics.Trace.TraceError(e.Message);
objCache.ErrorText = e.Message;
throw;
}
}
public static async Task <string> DownloadFile(SINners.Models.SINner sinner, CharacterCache objCache)
{
try
{
//currently only one chum5-File per chum5z ZipFile is implemented!
string loadFilePath = null;
string zipPath = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "SINner", sinner.Id.Value.ToString());
if (Directory.Exists(zipPath))
{
var files = Directory.EnumerateFiles(zipPath, "*.chum5", SearchOption.TopDirectoryOnly);
foreach (var file in files)
{
DateTime lastwrite = File.GetLastWriteTime(file);
if ((lastwrite >= sinner.LastChange) ||
sinner.LastChange == null)
{
loadFilePath = file;
objCache.FilePath = loadFilePath;
break;
}
File.Delete(file);
}
}
else
{
Directory.CreateDirectory(zipPath);
}
Character objOpenCharacter = null;
objOpenCharacter = PluginHandler.MainForm?.OpenCharacters?.FirstOrDefault(x => x.FileName == loadFilePath);
if ((objOpenCharacter != null))
{
return(loadFilePath);
}
if (String.IsNullOrEmpty(loadFilePath))
{
try
{
string zippedFile = Path.Combine(System.IO.Path.GetTempPath(), "SINner", sinner.Id.Value + ".chum5z");
if (File.Exists(zippedFile))
{
File.Delete(zippedFile);
}
Exception rethrow = null;
bool downloadedFromGoogle = false;
try
{
using (WebClient wc = new WebClient())
{
//wc.DownloadProgressChanged += wc_DownloadProgressChanged;
//wc.DownloadFileCompleted += (sender, e) =>
//{
// if (e.Error == null)
// {
// PluginHandler.MainForm.DoThreadSafe(() =>
// {
// PluginHandler.MainForm.Text = PluginHandler.MainForm.MainTitle;
// });
// }
// else
// {
// PluginHandler.MainForm.DoThreadSafe(() =>
// {
// PluginHandler.MainForm.Text =
// PluginHandler.MainForm.MainTitle + "Error while loading " +
// sinner.Alias + " from SINners-WebService";
// });
// }
//};
wc.DownloadFile(
// Param1 = Link of file
new System.Uri(sinner.DownloadUrl),
// Param2 = Path to save
zippedFile
);
}
}
catch (Exception e)
{
rethrow = e;
if (!File.Exists(zippedFile))
{
var client = await StaticUtils.GetClient();
var filestream = client.GetDownloadFile(sinner.Id.Value);
var array = ReadFully(filestream);
File.WriteAllBytes(zippedFile, array);
}
}
if (!File.Exists(zippedFile))
{
if (rethrow != null)
{
throw rethrow;
}
}
System.IO.Compression.ZipFile.ExtractToDirectory(zippedFile, zipPath);
var files = Directory.EnumerateFiles(zipPath, "*.chum5", SearchOption.TopDirectoryOnly);
foreach (var file in files)
{
if (sinner.UploadDateTime != null)
{
File.SetCreationTime(file, sinner.UploadDateTime.Value);
}
if (sinner.LastChange != null)
{
File.SetLastWriteTime(file, sinner.LastChange.Value);
}
loadFilePath = file;
objCache.FilePath = loadFilePath;
}
}
catch (Exception ex)
{
System.Diagnostics.Trace.TraceError(ex.Message);
if (objCache != null)
{
objCache.ErrorText = ex.Message;
}
}
}
return(objCache.FilePath);
}
catch (Exception e)
{
System.Diagnostics.Trace.TraceError(e.Message);
objCache.ErrorText = e.Message;
throw;
}
}
public static Task <Character> DownloadFileTask(SINners.Models.SINner sinner, CharacterCache objCache)
{
try
{
if (objCache.DownLoadRunning != null)
{
return(objCache.DownLoadRunning);
}
objCache.DownLoadRunning = Task.Factory.StartNew <Character>(() =>
{
return(DownloadFile(sinner, objCache));
});
return(objCache.DownLoadRunning);
}
catch (Exception ex)
{
objCache.ErrorText = ex.ToString();
throw;
}
}
private static void SetEventHandlers(SINners.Models.SINner sinner, CharacterCache objCache)
{
objCache.OnMyDoubleClick -= objCache.OnDefaultDoubleClick;
objCache.OnMyDoubleClick += (sender, e) =>
{
var t = DownloadFileTask(sinner, objCache);
t.ContinueWith((downloadtask) =>
{
PluginHandler.MySINnerLoading = sinner;
PluginHandler.MainForm.CharacterRoster.SetMyEventHandlers(true);
string filepath = downloadtask.Result as string;
PluginHandler.MainForm.DoThreadSafe(() =>
{
Character c = PluginHandler.MainForm.LoadCharacter(filepath);
if (c != null)
{
SwitchToCharacter(c);
}
SwitchToCharacter(objCache);
PluginHandler.MainForm.CharacterRoster.SetMyEventHandlers(false);
PluginHandler.MySINnerLoading = null;
});
});
};
objCache.OnMyAfterSelect -= objCache.OnDefaultAfterSelect;
objCache.OnMyAfterSelect += (sender, treeViewEventArgs) =>
{
objCache.FilePath = DownloadFileTask(sinner, objCache).Result;
};
objCache.OnMyKeyDown -= objCache.OnDefaultKeyDown;
objCache.OnMyKeyDown += async(sender, args) =>
{
try
{
using (new CursorWait(true, PluginHandler.MainForm))
{
if (args.Item1.KeyCode == Keys.Delete)
{
var client = await StaticUtils.GetClient();
client.Delete(sinner.Id.Value);
objCache.ErrorText = "deleted!";
PluginHandler.MainForm.DoThreadSafe(() =>
{
PluginHandler.MainForm.CharacterRoster.LoadCharacters(false, false, false, true);
});
}
}
}
catch (HttpOperationException e)
{
objCache.ErrorText = e.Message;
objCache.ErrorText += Environment.NewLine + e.Response.Content;
System.Diagnostics.Trace.TraceWarning(e.ToString());
}
catch (Exception e)
{
objCache.ErrorText = e.Message;
System.Diagnostics.Trace.TraceWarning(e.ToString());
}
};
}
internal static void Reset()
{
Class=null;
Character=new CharacterCache();
Combat=new CombatCache();
Target=new TargetHandler();
NavigationCache=new Navigation();
Stats=new BotStatistics();
shuttingDownBot=false;
}
/// <summary>
/// Generates a character cache, which prevents us from repeatedly loading XmlNodes or caching a full character.
/// </summary>
/// <param name="strFile"></param>
internal async static Task <IEnumerable <TreeNode> > GetCharacterRosterTreeNode(ConcurrentDictionary <string, CharacterCache> CharCache, bool forceUpdate)
{
if ((MyTreeNodeList != null) && !forceUpdate)
{
return(MyTreeNodeList);
}
try
{
var response = await StaticUtils.Client.GetSINnersByAuthorizationWithHttpMessagesAsync();
if (MyOnlineTreeNode == null)
{
MyOnlineTreeNode = new TreeNode()
{
Text = "Online",
Tag = "OnlineTag"
};
}
else
{
PluginHandler.MainForm.DoThreadSafe(() =>
{
MyOnlineTreeNode.Nodes.Clear();
});
}
if (response.Response.StatusCode == HttpStatusCode.BadRequest)
{
string msg = "Could not load online Sinners: " + response.Response.ReasonPhrase;
var content = await response.Response.Content.ReadAsStringAsync();
msg += Environment.NewLine + "Content: " + content;
System.Diagnostics.Trace.TraceWarning(msg);
MyOnlineTreeNode.ToolTipText = msg;
return(new List <TreeNode>()
{
MyOnlineTreeNode
});
}
if (response == null || response.Body == null || response.Body?.SinLists == null)
{
return(new List <TreeNode>()
{
MyOnlineTreeNode
});
}
foreach (var list in response.Body.SinLists)
{
try
{
if (!list.SiNners.Any())
{
continue;
}
TreeNode objListNode = new TreeNode
{
Text = list.Header,
Tag = list,
ContextMenuStrip = PluginHandler.MainForm.CharacterRoster.ContextMenuStrip
};
foreach (var sinner in list.SiNners)
{
if (String.IsNullOrEmpty(sinner.JsonSummary))
{
continue;
}
CharacterCache objCache = Newtonsoft.Json.JsonConvert.DeserializeObject <CharacterCache>(sinner.JsonSummary);
SetEventHandlers(sinner, objCache);
TreeNode objNode = new TreeNode
{
Text = objCache.CalculatedName(),
Tag = sinner.Id.Value.ToString(),
ToolTipText = "Last Change: " + sinner.LastChange,
ContextMenuStrip = PluginHandler.MainForm.CharacterRoster.ContextMenuStrip
};
if (!string.IsNullOrEmpty(objCache.ErrorText))
{
objNode.ForeColor = Color.Red;
objNode.ToolTipText += Environment.NewLine + Environment.NewLine + LanguageManager.GetString("String_Error", GlobalOptions.Language)
+ LanguageManager.GetString("String_Colon", GlobalOptions.Language) + Environment.NewLine + objCache.ErrorText;
}
CharacterCache delObj;
CharCache.TryRemove(sinner.Id.Value.ToString(), out delObj);
CharCache.TryAdd(sinner.Id.Value.ToString(), objCache);
PluginHandler.MainForm.DoThreadSafe(() =>
{
objListNode.Nodes.Add(objNode);
});
}
PluginHandler.MainForm.DoThreadSafe(() =>
{
MyOnlineTreeNode.Nodes.Add(objListNode);
});
}
catch (Exception e)
{
System.Diagnostics.Trace.TraceWarning("Could not deserialize CharacterCache-Object: " + list.Header);
}
}
if (MyOnlineTreeNode.Nodes.Count > 0)
{
return MyTreeNodeList = new List <TreeNode>()
{
MyOnlineTreeNode
}
}
;
else
{
return(MyTreeNodeList = null);
}
}
catch (Exception ex)
{
System.Diagnostics.Trace.TraceError(ex.ToString());
throw;
}
}
public override int Read()
{
while (true)
{
if (replacement != null && charPointer < replacement.Length)
{
return(replacement[charPointer++]);
}
int firstChar = NextChar();
if (firstChar == -1)
{
return(-1);
}
NormalizeCharMap nm = normMap.submap != null?(NormalizeCharMap)normMap.submap[CharacterCache.ValueOf((char)firstChar)]:null;
if (nm == null)
{
return(firstChar);
}
NormalizeCharMap result = Match(nm);
if (result == null)
{
return(firstChar);
}
replacement = result.normStr;
charPointer = 0;
if (result.diff != 0)
{
int prevCumulativeDiff = GetLastCumulativeDiff();
if (result.diff < 0)
{
for (int i = 0; i < -result.diff; i++)
{
AddOffCorrectMap(nextCharCounter + i - prevCumulativeDiff, prevCumulativeDiff - 1 - i);
}
}
else
{
AddOffCorrectMap(nextCharCounter - result.diff - prevCumulativeDiff, prevCumulativeDiff + result.diff);
}
}
}
}
public CharacterExtended(Character character, string fileElement = null, SINner mySINnerLoading = null, CharacterCache myCharacterCache = null) : this(character, fileElement, myCharacterCache)
{
if (mySINnerLoading != null)
{
var backup = MySINnerFile;
MySINnerFile = mySINnerLoading;
if (MySINnerFile?.SiNnerMetaData != null)
{
if (MySINnerFile.SiNnerMetaData.Id == null || MySINnerFile.SiNnerMetaData.Id == Guid.Empty)
{
MySINnerFile.SiNnerMetaData.Id = backup.SiNnerMetaData.Id;
}
if (MySINnerFile.SiNnerMetaData.Tags?.Count < backup?.SiNnerMetaData?.Tags?.Count)
{
MySINnerFile.SiNnerMetaData.Tags = new List <Tag>(backup.SiNnerMetaData.Tags);
}
}
}
}
public CharacterExtended(Character character, string fileElement = null, CharacterCache myCharacterCache = null)
{
MyCharacter = character ?? throw new ArgumentNullException(nameof(character));
MyCharacterCache = myCharacterCache ?? new CharacterCache(MyCharacter.FileName);
if (!string.IsNullOrEmpty(fileElement))
{
try
{
MySINnerFile = JsonConvert.DeserializeObject <SINner>(fileElement);
}
catch (Exception e)
{
Log.Error(e);
}
}
if (MySINnerFile == null)
{
MySINnerFile = new SINner
{
Language = GlobalOptions.Language
};
//MySINnerFile.MyExtendedAttributes = new SINnerExtended(MySINnerFile);
}
if (MySINnerFile.SiNnerMetaData == null)
{
MySINnerFile.SiNnerMetaData = new SINnerMetaData
{
Id = Guid.NewGuid(),
Tags = new List <Tag>(),
Visibility = new SINnerVisibility
{
IsGroupVisible = true,
IsPublic = true
}
};
}
if (!string.IsNullOrEmpty(Settings.Default.SINnerVisibility))
{
MySINnerFile.SiNnerMetaData.Visibility =
JsonConvert.DeserializeObject <SINnerVisibility>(Settings.Default.SINnerVisibility);
}
if (MySINnerFile.SiNnerMetaData.Visibility?.Id == null)
{
if (MySINnerFile.SiNnerMetaData.Visibility != null)
{
MySINnerFile.SiNnerMetaData.Visibility.Id = Guid.NewGuid();
}
}
MySINnerFile.LastChange = MyCharacter.FileLastWriteTime;
if (MySINnerIds.TryGetValue(MyCharacter.FileName, out var singuid))
{
MySINnerFile.Id = singuid;
}
else
{
MySINnerFile.Id = Guid.NewGuid();
MySINnerIds.Add(MyCharacter.FileName, MySINnerFile.Id.Value);
MySINnerIds = MySINnerIds; //Save it!
}
}
public UserManagementService(CharacterSessionManager characterSessionManager, CharacterCache characterCache, EventManager eventManager)
{
this.characterSessionManager = characterSessionManager;
this.characterCache = characterCache;
this.eventManager = eventManager;
}
public bool ShouldFilter(CharacterDrop.Drop drop, DropExtended extended, CharacterDrop characterDrop)
{
var character = CharacterCache.GetCharacter(characterDrop);
var inventory = CharacterCache.GetInventory(character);
if (inventory is null)
{
#if DEBUG
Log.LogDebug("No inventory for creature were found.");
#endif
//No inventory to compare against. Assume that all is allowed.
return(false);
}
var items = extended.Config.ConditionHasItem.Value.SplitByComma(true);
if (items.Count == 0)
{
return(false);
}
HashSet <string> inventoryItems;
if (InstallationManager.RRRInstalled && character.name.StartsWith("RRR"))
{
// This is an RRR creature, item names will have been set with a specific pattern.
inventoryItems = new();
foreach (var item in inventory.GetAllItems())
{
var firstSection = item.m_dropPrefab.name.IndexOf('@');
if (firstSection < 0)
{
// Unformatted item, add as is
inventoryItems.Add(PrepareName(item.m_dropPrefab));
continue;
}
var endSection = item.m_dropPrefab.name.IndexOf('@', firstSection + 1);
if (endSection < 0)
{
inventoryItems.Add(CleanName(item.m_dropPrefab.name.Substring(firstSection + 1)));
}
else
{
inventoryItems.Add(CleanName(item.m_dropPrefab.name.Substring(firstSection + 1, endSection - firstSection - 1)));
}
}
}
else
{
inventoryItems = inventory
.GetAllItems()
.Select(x => x.m_dropPrefab.name.Trim().ToUpperInvariant())
.ToHashSet();
}
#if DEBUG
Log.LogTrace("Inventory: " + inventoryItems.Join());
#endif
if (!items.Any(x => inventoryItems.Contains(x)))
{
//No inventory items matched an item in condition list.
Log.LogTrace($"{nameof(CharacterDropItemConfiguration.ConditionHasItem)}: Found none of the required items '{items.Join()}' in inventory.");
return(true);
}
return(false);
}
