github/lidarr
1
0
Fork 0
mirror of https://github.com/lidarr/lidarr.git synced 2025-08-14 02:37:08 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Unused

Browse source 
(cherry picked from commit d348232e0d43c0b6e1a5d22bb7b86c7c709e9acc)
This commit is contained in:
ta264 2021-08-04 21:42:40 +01:00 • committed by Qstick
commit fe956f340c
10 changed files with 0 additions and 480 deletions
Download patch file Download diff file Expand all files Collapse all files

54
src/Lidarr.Http/Mapping/MappingValidation.cs
View file

@ -1,54 +0,0 @@
using System;
using System.Linq;
using System.Reflection;
using Lidarr.Http.REST;
using NzbDrone.Common.Reflection;
namespace Lidarr.Http.Mapping
{
public static class MappingValidation
{
public static void ValidateMapping(Type modelType, Type resourceType)
{
var errors = modelType.GetSimpleProperties().Where(c => !c.GetGetMethod().IsStatic).Select(p => GetError(resourceType, p)).Where(c => c != null).ToList();
if (errors.Any())
{
throw new ResourceMappingException(errors);
}
PrintExtraProperties(modelType, resourceType);
}
private static void PrintExtraProperties(Type modelType, Type resourceType)
{
var resourceBaseProperties = typeof(RestResource).GetProperties().Select(c => c.Name);
var resourceProperties = resourceType.GetProperties().Select(c => c.Name).Except(resourceBaseProperties);
var modelProperties = modelType.GetProperties().Select(c => c.Name);
var extra = resourceProperties.Except(modelProperties);
foreach (var extraProp in extra)
{
Console.WriteLine("Extra: [{0}]", extraProp);
}
}
private static string GetError(Type resourceType, PropertyInfo modelProperty)
{
var resourceProperty = resourceType.GetProperties().FirstOrDefault(c => c.Name == modelProperty.Name);
if (resourceProperty == null)
{
return string.Format("public {0} {1} {{ get; set; }}", modelProperty.PropertyType.Name, modelProperty.Name);
}
if (resourceProperty.PropertyType != modelProperty.PropertyType && !typeof(RestResource).IsAssignableFrom(resourceProperty.PropertyType))
{
return string.Format("Expected {0}.{1} to have type of {2} but found {3}", resourceType.Name, resourceProperty.Name, modelProperty.PropertyType, resourceProperty.PropertyType);
}
return null;
}
}
}

14
src/Lidarr.Http/Mapping/ResourceMappingException.cs
View file

@ -1,14 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
namespace Lidarr.Http.Mapping
{
public class ResourceMappingException : ApplicationException
{
public ResourceMappingException(IEnumerable<string> error)
: base(Environment.NewLine + string.Join(Environment.NewLine, error.OrderBy(c => c)))
{
}
}
}

12
src/NzbDrone.Common/Expansive/CircularReferenceException.cs
View file

@ -1,12 +0,0 @@
using System;
namespace NzbDrone.Common.Expansive
{
public class CircularReferenceException : Exception
{
public CircularReferenceException(string message)
: base(message)
{
}
}
}

213
src/NzbDrone.Common/Expansive/Expansive.cs
View file

@ -1,213 +0,0 @@
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Dynamic;
using System.Linq;
using System.Text.RegularExpressions;
namespace NzbDrone.Common.Expansive
{
public static class Expansive
{
private static PatternStyle _patternStyle;
public static bool RequireAllExpansions { get; set; }
public static Func<string, string> DefaultExpansionFactory { get; set; }
static Expansive()
{
Initialize();
}
public static string Expand(this string source)
{
return source.Expand(DefaultExpansionFactory);
}
public static string Expand(this string source, params string[] args)
{
var output = source;
var tokens = new List<string>();
var pattern = new Regex(_patternStyle.TokenMatchPattern, RegexOptions.IgnoreCase);
var calls = new Stack<string>();
string callingToken = null;
while (pattern.IsMatch(output))
{
foreach (Match match in pattern.Matches(output))
{
var token = _patternStyle.TokenReplaceFilter(match.Value);
var tokenIndex = 0;
if (!tokens.Contains(token))
{
tokens.Add(token);
tokenIndex = tokens.Count - 1;
}
else
{
tokenIndex = tokens.IndexOf(token);
}
output = Regex.Replace(output, _patternStyle.OutputFilter(match.Value), "{" + tokenIndex + "}");
}
}
var newArgs = new List<string>();
foreach (var arg in args)
{
var newArg = arg;
var tokenPattern = new Regex(_patternStyle.TokenFilter(string.Join("|", tokens)));
while (tokenPattern.IsMatch(newArg))
{
foreach (Match match in tokenPattern.Matches(newArg))
{
var token = _patternStyle.TokenReplaceFilter(match.Value);
if (calls.Contains(string.Format("{0}:{1}", callingToken, token)))
{
throw new CircularReferenceException(string.Format("Circular Reference Detected for token '{0}'.", callingToken));
}
calls.Push(string.Format("{0}:{1}", callingToken, token));
callingToken = token;
newArg = Regex.Replace(newArg, _patternStyle.OutputFilter(match.Value), args[tokens.IndexOf(token)]);
}
}
newArgs.Add(newArg);
}
return string.Format(output, newArgs.ToArray());
}
public static string Expand(this string source, Func<string, string> expansionFactory)
{
return source.ExpandInternal(expansionFactory);
}
public static string Expand(this string source, object model)
{
return source.ExpandInternal(
name =>
{
IDictionary<string, object> modelDict = model.ToDictionary();
if (RequireAllExpansions && !modelDict.ContainsKey(name))
{
return "";
}
if (modelDict[name] == null)
{
return "";
}
return modelDict[name].ToString();
});
}
private static void Initialize()
{
_patternStyle = new PatternStyle
{
TokenMatchPattern = @"\{[a-zA-Z]\w*\}",
TokenReplaceFilter = token => token.Replace("{", "").Replace("}", ""),
OutputFilter = output => (output.StartsWith("{") && output.EndsWith("}") ? output : @"\{" + output + @"\}"),
TokenFilter = tokens => "{(" + tokens + ")}"
};
}
private static string ExpandInternal(this string source, Func<string, string> expansionFactory)
{
if (expansionFactory == null)
{
throw new ApplicationException("ExpansionFactory not defined.\nDefine a DefaultExpansionFactory or call Expand(source, Func<string, string> expansionFactory))");
}
var pattern = new Regex(_patternStyle.TokenMatchPattern, RegexOptions.IgnoreCase);
var callTreeParent = new Tree<string>("root").Root;
return source.Explode(pattern, _patternStyle, expansionFactory, callTreeParent);
}
private static string Explode(this string source, Regex pattern, PatternStyle patternStyle, Func<string, string> expansionFactory, TreeNode<string> parent)
{
var output = source;
while (output.HasChildren(pattern))
{
foreach (Match match in pattern.Matches(source))
{
var child = match.Value;
var token = patternStyle.TokenReplaceFilter(match.Value);
var thisNode = parent.Children.Add(token);
// if we have already encountered this token in this call tree, we have a circular reference
if (thisNode.CallTree.Contains(token))
{
throw new CircularReferenceException(string.Format("Circular Reference Detected for token '{0}'. Call Tree: {1}->{2}",
token,
string.Join("->", thisNode.CallTree.ToArray().Reverse()),
token));
}
// expand this match
var expandedValue = expansionFactory(token);
// Replace the match with the expanded value
child = Regex.Replace(child, patternStyle.OutputFilter(match.Value), expandedValue);
// Recursively expand the child until we no longer encounter nested tokens (or hit a circular reference)
child = child.Explode(pattern, patternStyle, expansionFactory, thisNode);
// finally, replace the match in the output with the fully-expanded value
output = Regex.Replace(output, patternStyle.OutputFilter(match.Value), child);
}
}
return output;
}
private static bool HasChildren(this string token, Regex pattern)
{
return pattern.IsMatch(token);
}
/// <summary>
/// Turns the object into an ExpandoObject
/// </summary>
private static dynamic ToExpando(this object o)
{
var result = new ExpandoObject();
var d = result as IDictionary<string, object>; //work with the Expando as a Dictionary
if (o is ExpandoObject)
{
return o; //shouldn't have to... but just in case
}
if (o is NameValueCollection || o.GetType().IsSubclassOf(typeof(NameValueCollection)))
{
var nv = (NameValueCollection)o;
nv.Cast<string>().Select(key => new KeyValuePair<string, object>(key, nv[key])).ToList().ForEach(i => d.Add(i));
}
else
{
var props = o.GetType().GetProperties();
foreach (var item in props)
{
d.Add(item.Name, item.GetValue(o, null));
}
}
return result;
}
/// <summary>
/// Turns the object into a Dictionary
/// </summary>
private static IDictionary<string, object> ToDictionary(this object thingy)
{
return (IDictionary<string, object>)thingy.ToExpando();
}
}
}

12
src/NzbDrone.Common/Expansive/PatternStyle.cs
View file

@ -1,12 +0,0 @@
using System;
namespace NzbDrone.Common.Expansive
{
internal class PatternStyle
{
public string TokenMatchPattern { get; set; }
public Func<string, string> TokenFilter { get; set; }
public Func<string, string> TokenReplaceFilter { get; set; }
public Func<string, string> OutputFilter { get; set; }
}
}

11
src/NzbDrone.Common/Expansive/Tree.cs
View file

@ -1,11 +0,0 @@
namespace NzbDrone.Common.Expansive
{
internal class Tree<T> : TreeNode<T>
{
public Tree(T rootValue)
: base(rootValue)
{
Value = rootValue;
}
}
}

94
src/NzbDrone.Common/Expansive/TreeNode.cs
View file

@ -1,94 +0,0 @@
using System.Collections.Generic;
namespace NzbDrone.Common.Expansive
{
internal class TreeNode<T>
{
private List<T> _CallTree;
private TreeNode<T> _Parent;
public TreeNode(T value)
{
Value = value;
Parent = null;
Children = new TreeNodeList<T>(this);
_CallTree = new List<T>();
}
public TreeNode(T value, TreeNode<T> parent)
{
Value = value;
Parent = parent;
Children = new TreeNodeList<T>(this);
_CallTree = new List<T>();
}
public TreeNode<T> Parent
{
get
{
return _Parent;
}
set
{
if (value == _Parent)
{
return;
}
if (_Parent != null)
{
_Parent.Children.Remove(this);
}
if (value != null && !value.Children.Contains(this))
{
value.Children.Add(this);
}
_Parent = value;
}
}
public TreeNode<T> Root
{
get
{
//return (Parent == null) ? this : Parent.Root;
TreeNode<T> node = this;
while (node.Parent != null)
{
node = node.Parent;
}
return node;
}
}
public TreeNodeList<T> Children { get; private set; }
public List<T> CallTree
{
get
{
_CallTree = new List<T>();
TreeNode<T> node = this;
while (node.Parent != null)
{
node = node.Parent;
_CallTree.Add(node.Value);
}
return _CallTree;
}
private set
{
_CallTree = value;
}
}
public T Value { get; set; }
}
}

31
src/NzbDrone.Common/Expansive/TreeNodeList.cs
View file

@ -1,31 +0,0 @@
using System.Collections.Generic;
namespace NzbDrone.Common.Expansive
{
internal class TreeNodeList<T> : List<TreeNode<T>>
{
public TreeNode<T> Parent;
public TreeNodeList(TreeNode<T> parent)
{
Parent = parent;
}
public new TreeNode<T> Add(TreeNode<T> node)
{
base.Add(node);
node.Parent = Parent;
return node;
}
public TreeNode<T> Add(T value)
{
return Add(new TreeNode<T>(value));
}
public override string ToString()
{
return "Count=" + Count.ToString();
}
}
}

2
src/NzbDrone.Common/Expansive/license.txt
View file

@ -1,2 +0,0 @@
Source: https://github.com/anderly/Expansive
Microsoft Public License (MS-PL): http://opensource.org/licenses/MS-PL

37
src/NzbDrone.Common/Instrumentation/LogEventExtensions.cs
View file

@ -1,37 +0,0 @@
using NLog;
using NzbDrone.Common.Serializer;
namespace NzbDrone.Common.Instrumentation
{
public static class LogEventExtensions
{
public static string GetHash(this LogEventInfo logEvent)
{
var stackString = logEvent.StackTrace.ToJson();
var hashSeed = string.Concat(logEvent.LoggerName, logEvent.Exception.GetType().ToString(), stackString, logEvent.Level);
return HashUtil.CalculateCrc(hashSeed);
}
public static string GetFormattedMessage(this LogEventInfo logEvent)
{
var message = logEvent.FormattedMessage;
if (logEvent.Exception != null)
{
if (logEvent.Exception != null)
{
if (string.IsNullOrWhiteSpace(message))
{
message = logEvent.Exception.Message;
}
else
{
message += ": " + logEvent.Exception.Message;
}
}
}
return message;
}
}
}