derightdirection / therightdirectionlibraries Goto Github PK

MannusEtten/MyMoney#23

de fakerepository die in mymoney zit overhevelen naar unit testing uwp project

deRightDirection/BikeTouringGIS#13

in alle projecten vier main projecten zit een converter die een bepaalde waarde vergelijkt en dan een bepaalde output geeft

bijvoorbeeld:
enumsportstype == basketball -> kleur groen

waarde x = 10 -> true

hier een algemene converter voor maken, samen met de convertercollection die al in WinUX aanwezig is kan zo een set van regels gemaakt worden

alles van de repository unit testing toevoegen
documenten schrijven
oude repository verwijderen
nuget package updaten

onedrive service en interface overzetten

MannusEtten/MyMoney#37

de mouse over en vooral weg van de control als de tekst is geselecteerd werkt niet goed voor de editable textbox in een lijst

service ontwikkelen die het automatisch updaten van de app bij start mogelijk maakt

een vm inrichten met Jenkins om alle projecten te unit testen, builden en de test results te mailen

script maken voor compileren van nuget package voor unit-testing library

in drie projecten wordt iets met onedrive gedaan en dit samenvoegen tot 1 class en een interface

MannusEtten/MyMoney#22

MannusEtten/MyMoney#36

create an editable textbox user control

MannusEtten/BasketBalNieuwsEditor#63

public static partial class Extensions
{
public static void CopyProperties(this object from, object to, bool includePropertiesFromBaseType = false, string[] excludedProperties = null)
{
if (to == null)
{
return;
}
Dictionary<string, PropertyInfo> sourceProperties = GetProperties(from.GetType(), includePropertiesFromBaseType);
Dictionary<string, PropertyInfo> targetProperties = GetProperties(to.GetType(), includePropertiesFromBaseType);
IEnumerable commonPropertiesName = sourceProperties.Values.Intersect(targetProperties.Values, new PropertyInfoComparer()).Select(x => x.Name);
foreach (var commonPropertyName in commonPropertiesName)
{
if (excludedProperties != null
&& excludedProperties.Contains(commonPropertyName))
continue;
var hasExcludeAttribute = FindAttribute(targetProperties[commonPropertyName]);
if (!hasExcludeAttribute)
{
var value = sourceProperties[commonPropertyName].GetValue(from, null);
if (targetProperties[commonPropertyName].CanWrite)
{
targetProperties[commonPropertyName].SetValue(to, value, null);
}
}
}
}

    public static int GetHashCodeOnProperties(this object inspect)
    {
        return inspect.GetType().GetTypeInfo().DeclaredProperties.Select(o => o.GetValue(inspect)).GetListHashCode();
    }

    public static int GetListHashCode(this IEnumerable<object> sequence)
    {
        return sequence.Where(x => x != null)
            .Select(item => item.GetHashCode())
            .Aggregate((total, nextCode) => total ^ nextCode);
    }

    private static bool FindAttribute(PropertyInfo commonProperty)
    {
        var attribute = commonProperty.GetCustomAttribute<ExcludeFromCopyPropertyAttribute>();
        return attribute != null;
    }

    private static Dictionary<string, PropertyInfo> GetProperties(Type type, bool recursive)
    {
        if (recursive)
        {
            Dictionary<string, PropertyInfo> properties = new Dictionary<string, PropertyInfo>();
            var retrievedProperties = GetProperties(type);
            foreach(var retrievedProperty in retrievedProperties)
            {
                properties.Add(retrievedProperty.Key, retrievedProperty.Value);
            }
            var typeInfo = type.GetTypeInfo();
            while (typeInfo.BaseType != null)
            {
                var baseType = typeInfo.BaseType;
                retrievedProperties = GetProperties(baseType);
                foreach (var retrievedProperty in retrievedProperties)
                {
                    if (!properties.ContainsKey(retrievedProperty.Key))
                    {
                        properties.Add(retrievedProperty.Key, retrievedProperty.Value);
                    }
                }
                typeInfo = baseType.GetTypeInfo();
            }
            return properties;
        }
        return GetProperties(type);
    }

    private static Dictionary<string, PropertyInfo> GetProperties(Type type)
    {
        var typeInfo = type.GetTypeInfo();
        Dictionary<string, PropertyInfo> properties = new Dictionary<string, PropertyInfo>();
        foreach (var property in typeInfo.DeclaredProperties)
        {
            properties.Add(property.Name, property);
        }
        return properties;
    }
}