public InstancesBuilder(IEnumerable <T> data, int classindex, int trainingsize = 0)
{
this.data = data.ToArray();
if (this.data.Any(row => row is string))
{
throw new ArgumentException("data are strings, perhaps you intended to call Runtime.LoadFromFiles<>");
}
this.classindex = classindex;
this.trainingsize = trainingsize;
T template = this.data[0];
type = typeof(T) == typeof(object) ? template.GetType() : typeof(T);
attsbuilder = new AttributesBuilder <T>(this.data);
var pis = template is IExtendableObj <object>?
Helpers.GetProps(((IExtendableObj <object>)template).BaseObject.GetType()) :
Helpers.GetProps(type);
properties = pis.
Where(pi => !InternalHelpers.IsAtt <IgnoreFeatureAttribute>(pi)).
Select(pi => pi.Name).
ToArray();
var tohasclasspis = pis.Where(InternalHelpers.IsAtt <AppendHasClassifierAttribute>).ToArray();
tohasclass = tohasclasspis.Select(pi => pi.Name).ToArray();
tobinarize = pis.Where(InternalHelpers.IsAtt <BinarizeAttribute>).Select(pi => pi.Name).ToArray();
expected_has_classes = tohasclasspis.ToDictionary(
pi => pi.Name,
pi => InternalHelpers.ToAtt <AppendHasClassifierAttribute>(pi).Classifier);
}
public void SqlDecimalUtilsPerformanceTest(byte scale)
{
var sourceValue = sourceDecimal;
var counter = new Stopwatch();
var sqlDecimal = new SqlDecimal(sourceValue.Precision, scale, sourceValue.IsPositive, sourceValue.Data);
var list = new List <long>();
for (var i = 0; i < 100; i++)
{
counter.Restart();
for (var j = 0; j < 100000; j++)
{
_ = InternalHelpers.TruncateToNetDecimal(sqlDecimal);
}
counter.Stop();
list.Add(counter.ElapsedMilliseconds);
}
Console.WriteLine(
"Val:{0} Scale:{1} Min:{2} Avg:{3}",
sqlDecimal,
sqlDecimal.Scale,
list.Min(),
list.Average());
}
public static ILogResponseBodyStrategy Create(Stream stream, Encoding encoding, Logger logger)
{
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
if (encoding == null)
{
throw new ArgumentNullException(nameof(encoding));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (!stream.CanRead)
{
return(new NullLogResponseBody());
}
if (stream.Length > Constants.MaximumAllowedFileSizeInBytes)
{
return(new LogResponseBodySizeTooLargeException(logger, stream.Length, Constants.MaximumAllowedFileSizeInBytes));
}
var headers = logger.DataContainer.HttpProperties.Response?.Properties?.Headers;
string contentType = headers?.FirstOrDefault(p => string.Compare(p.Key, "Content-Type", StringComparison.OrdinalIgnoreCase) == 0).Value;
string responseFileName = InternalHelpers.GenerateResponseFileName(headers);
IReadStreamStrategy strategy = ReadStreamStrategyFactory.Create(stream, encoding, contentType);
return(new LogResponseBody(logger, responseFileName, strategy));
}
public void ContainsFileAttribute()
{
FileAttributes attr = FileAttributes.Archive;
InternalHelpers.ContainsFileAttribute(attr, FileAttributes.Archive).Should().Be(true);
InternalHelpers.ContainsFileAttribute(attr, FileAttributes.System).Should().Be(false);
}
public override void LoadDataFromPropertiesDictionary(DiscountOrder discount, IPropertyProvider fields, ILocalization localization)
{
discount.Localization = localization;
LoadBaseProperties(discount, fields, localization, _storeService);
discount.RequiredItemIds = StoreHelper.ReadMultiStoreItemFromPropertiesDictionary(_aliasses.items, localization, fields).Split(',').Select(id => Common.Helpers.ParseInt(id)).Distinct().Where(id => id > 0).ToList();
discount.AffectedOrderlines = StoreHelper.ReadMultiStoreItemFromPropertiesDictionary(_aliasses.affectedOrderlines, localization, fields).Split(',').Select(id => Common.Helpers.ParseInt(id)).Distinct().Where(id => id > 0).ToList();
var tagsValue = StoreHelper.ReadMultiStoreItemFromPropertiesDictionary(_aliasses.affectedTags, localization, fields);
discount.AffectedProductTags = InternalHelpers.ParseTagsString(tagsValue);
DiscountOrderCondition condition;
var discountOrderConditionParseResult = Enum.TryParse(StoreHelper.ReadMultiStoreItemFromPropertiesDictionary(_aliasses.orderCondition, localization, fields), out condition);
discount.Condition = discountOrderConditionParseResult ? condition : DiscountOrderCondition.None;
discount.NumberOfItemsCondition = StoreHelper.GetMultiStoreIntValue(_aliasses.numberOfItemsCondition, localization, fields);
discount.MinimumOrderAmountInCents = StoreHelper.GetMultiStoreIntValue(_aliasses.minimumAmount, localization, fields);
var shippingDiscountable = StoreHelper.ReadMultiStoreItemFromPropertiesDictionary(_aliasses.shippingDiscountable, localization, fields);
discount.IncludeShippingInOrderDiscountableAmount = shippingDiscountable == "enable" || shippingDiscountable == "1" || shippingDiscountable == "true";
// for backwards compatibility
discount.CouponCode = StoreHelper.ReadMultiStoreItemFromPropertiesDictionary("couponCode", localization, fields);
var oncePerCustomer = StoreHelper.ReadMultiStoreItemFromPropertiesDictionary(_aliasses.oncePerCustomer, localization, fields);
discount.OncePerCustomer = oncePerCustomer == "enable" || oncePerCustomer == "1" || oncePerCustomer == "true";
}
public static void Notify(Logger[] loggers)
{
if (loggers == null)
{
throw new ArgumentNullException();
}
if (!loggers.Any())
{
return;
}
FlushLogArgs args = FlushLogArgsFactory.Create(loggers);
Guid?httpRequestId = args.HttpProperties == null ? (Guid?)null : args.HttpProperties.Request.Id;
List <LogListenerDecorator> logListeners = KissLogConfiguration.Listeners.GetAll();
foreach (LogListenerDecorator decorator in logListeners)
{
InternalHelpers.WrapInTryCatch(() =>
{
Notify(args, decorator, httpRequestId);
});
}
foreach (Logger logger in loggers)
{
logger.Reset();
}
}
public void OnFlush(FlushLogArgs args)
{
bool isValid = ValidateProperties();
if (!isValid)
{
return;
}
InternalLogger.Log("RequestLogsApiListener: OnFlush begin", LogLevel.Trace);
ObfuscateFlushLogArgsService obfuscateService = new ObfuscateFlushLogArgsService(ObfuscationService);
obfuscateService.Obfuscate(args);
CreateRequestLogRequest request = PayloadFactory.Create(args);
request.OrganizationId = _application.OrganizationId;
request.ApplicationId = _application.ApplicationId;
request.Keywords = InternalHelpers.WrapInTryCatch(() => Options.Handlers.GenerateSearchKeywords(args));
FlushOptions flushOptions = new FlushOptions
{
UseAsync = UseAsync,
OnException = OnException
};
IPublicApi kisslogApi = _kisslogApi ?? new PublicRestApi(ApiUrl, IgnoreSslCertificate);
Flusher.FlushAsync(flushOptions, kisslogApi, args, request).ConfigureAwait(false);
InternalLogger.Log("RequestLogsApiListener: OnFlush complete", LogLevel.Trace);
}
public void OnFlush(FlushLogArgs args, ILogger logger)
{
FlushProperties flushProperties = GetAndValidateFlushProperties(args);
if (flushProperties == null)
{
return;
}
InternalHelpers.Log("KissLogApiListener: OnFlush begin", LogLevel.Trace);
ObfuscateService?.Obfuscate(args);
TruncateService?.Truncate(args);
Requests.CreateRequestLogRequest request = CreateRequestLogRequestFactory.Create(args);
request.OrganizationId = flushProperties.Application.OrganizationId;
request.ApplicationId = flushProperties.Application.ApplicationId;
request.Keywords = Configuration.Configuration.Options.ApplyAddRequestKeywordstHeader(args);
// we need to copy files, because we start a new Thread, and the existing files will be deleted before accessing them
IList <LoggerFile> copy = CopyFiles(args.Files?.ToList());
IFlusher flusher = CreateFlusher(flushProperties);
if (UseAsync == true)
{
flusher.FlushAsync(request, copy).ConfigureAwait(false);
}
else
{
flusher.Flush(request, copy);
}
InternalHelpers.Log("KissLogApiListener: OnFlush complete", LogLevel.Trace);
}
static KissLogWebApiExceptionFilterAttribute()
{
InternalHelpers.WrapInTryCatch(() =>
{
ModuleInitializer.Init();
});
}
static KissLogExceptionLogger()
{
InternalHelpers.WrapInTryCatch(() =>
{
ModuleInitializer.Init();
});
}
/// <summary>
/// Converts a list of property names and values to a list of type of <typeparamref name="T"/>.
///
/// Population of complex nested child properties is supported by underscoring "_" into the
/// nested child properties in the property name.
/// </summary>
/// <typeparam name="T">Type to instantiate and automap to</typeparam>
/// <param name="listOfProperties">List of property names and values</param>
/// <returns>List of type <typeparamref name="T"/></returns>
public static IEnumerable <T> Map <T>(IEnumerable <IDictionary <string, object> > listOfProperties)
{
var instanceCache = new Dictionary <object, object>();
foreach (var properties in listOfProperties)
{
var getInstanceResult = InternalHelpers.GetInstance(typeof(T), properties, 0);
object instance = getInstanceResult.Item2;
int instanceIdentifierHash = getInstanceResult.Item3;
if (instanceCache.ContainsKey(instanceIdentifierHash) == false)
{
instanceCache.Add(instanceIdentifierHash, instance);
}
var caseInsensitiveDictionary = new Dictionary <string, object>(properties, StringComparer.OrdinalIgnoreCase);
InternalHelpers.Map(caseInsensitiveDictionary, instance);
}
foreach (var pair in instanceCache)
{
yield return(( T )pair.Value);
}
}
public BaseAttributeSelectionEvaluator(Runtime rt, I impl)
{
this.rt = rt;
Impl = impl;
InternalHelpers.SetSeedOnInstance(impl);
}
internal static void UpdateSiteName(Activity activity, string newID)
{
if (activity == null)
{
throw new ArgumentException("activity");
}
string str = newID;
if (Helpers.IsActivityLocked(activity))
{
str = InternalHelpers.GenerateQualifiedNameForLockedActivity(activity, newID);
}
activity.Site.Name = str;
if (activity is CompositeActivity)
{
foreach (Activity activity2 in Helpers.GetNestedActivities(activity as CompositeActivity))
{
if (Helpers.IsActivityLocked(activity2))
{
Activity declaringActivity = Helpers.GetDeclaringActivity(activity2);
activity2.Site.Name = declaringActivity.Site.Name + "." + activity2.Name;
}
}
}
}
/// <summary>
/// Converts a list of property names and values to a list of type of <typeparamref name="T"/>.
///
/// Population of complex nested child properties is supported by underscoring "_" into the
/// nested child properties in the property name.
/// </summary>
/// <typeparam name="T">Type to instantiate and automap to</typeparam>
/// <param name="listOfProperties">List of property names and values</param>
/// <param name="keepCache">If false, clears instance cache after mapping is completed. Defaults to true, meaning instances are kept between calls.</param>
/// <returns>List of type <typeparamref name="T"/></returns>
public static IEnumerable <T> Map <T>(IEnumerable <IDictionary <string, object> > listOfProperties, bool keepCache = true)
{
var instanceCache = new Dictionary <object, object>();
foreach (var properties in listOfProperties)
{
var getInstanceResult = InternalHelpers.GetInstance(typeof(T), properties);
object instance = getInstanceResult.Item2;
var key = getInstanceResult.Item3;
if (instanceCache.ContainsKey(key) == false)
{
instanceCache.Add(key, instance);
}
var caseInsensitiveDictionary = new Dictionary <string, object>(properties, StringComparer.OrdinalIgnoreCase);
InternalHelpers.Map(caseInsensitiveDictionary, instance);
}
if (!keepCache)
{
Cache.ClearInstanceCache();
}
return(instanceCache.Select(pair => ( T )pair.Value));
}
public BaseAssociation(Runtime rt, I impl)
{
this.rt = rt;
Impl = impl;
InternalHelpers.SetSeedOnInstance(impl);
}
public void GetServerNameFromHttpRequestDoesNotThrowExceptionForNullServerVariables()
{
var httpRequest = new Mock <HttpRequestBase>();
httpRequest.Setup(p => p.ServerVariables).Returns((NameValueCollection)null);
InternalHelpers.GetServerNameFromHttpRequest(httpRequest.Object);
}
public void MachineNameIsCopied(string url)
{
FlushLogArgs item = FlushLogArgsFactory.Create(new[] { new Logger(url: url) });
string machineName = InternalHelpers.GetMachineName();
Assert.AreEqual(machineName, item.HttpProperties.Request.MachineName);
}
public void MachineNameIsCopied()
{
HttpProperties result = HttpPropertiesFactory.Create("/");
string machineName = InternalHelpers.GetMachineName();
Assert.AreEqual(machineName, result.Request.MachineName);
}
public void AddFileAttrribute()
{
FileAttributes attr = FileAttributes.Archive;
FileAttributes result = InternalHelpers.AddFileAttrribute(attr, FileAttributes.System);
InternalHelpers.ContainsFileAttribute(result, FileAttributes.Archive).Should().Be(true);
InternalHelpers.ContainsFileAttribute(result, FileAttributes.System).Should().Be(true);
}
public void RemoveFileAttribute()
{
FileAttributes attr = FileAttributes.Archive | FileAttributes.System;
FileAttributes result = InternalHelpers.RemoveFileAttribute(attr, FileAttributes.Archive);
InternalHelpers.ContainsFileAttribute(result, FileAttributes.Archive).Should().Be(false);
InternalHelpers.ContainsFileAttribute(result, FileAttributes.System).Should().Be(true);
}
public void ClaimsIdentityToKeyValuePairIgnoresEmptyKeyNames(string keyName)
{
ClaimsIdentity collection = new ClaimsIdentity();
collection.AddClaim(new Claim(keyName, Guid.NewGuid().ToString()));
var result = InternalHelpers.ToKeyValuePair(collection);
Assert.AreEqual(0, result.Count);
}
public void HttpCookieCollectionToKeyValuePairIgnoresEmptyKeyNames(string keyName)
{
HttpCookieCollection collection = new HttpCookieCollection();
collection.Add(new HttpCookie(keyName, Guid.NewGuid().ToString()));
var result = InternalHelpers.ToKeyValuePair(collection);
Assert.AreEqual(0, result.Count);
}
public static void UnloadFrozenObject(object o)
{
var optr = Marshal.ReadIntPtr((IntPtr)Unsafe.AsPointer(ref o));
var baseAddress = optr - IntPtr.Size - IntPtr.Size - IntPtr.Size; // 3 because optr is actually pointing to MT*
var length = Marshal.ReadIntPtr(baseAddress);
var segmentHandle = Marshal.ReadIntPtr(baseAddress, IntPtr.Size);
InternalHelpers.UnregisterFrozenSegment(segmentHandle);
FreeMemory(baseAddress, length);
}
private static string FormatAsSimpleType(object value, ConstructionLogContext context)
{
Func <object, string> formatter;
return(value == null || value.GetType().IsSimpleType()
? InternalHelpers.DumpValue(value)
: context.ValueFormatters.TryGetValue(value.GetType(), out formatter)
? formatter(value)
: null);
}
public void SqlDecimalUtilsBigScaleTest(byte scale)
{
var sourceValue = sourceDecimal;
var sqlDecimal = new SqlDecimal(sourceValue.Precision, scale, sourceValue.IsPositive, sourceValue.Data);
var output = InternalHelpers.TruncateToNetDecimal(sqlDecimal);
var dec = decimal.Parse(sqlDecimal.ToString(), CultureInfo.InvariantCulture);
Assert.That(output, Is.EqualTo(dec));
}
public void TryAddFileAttrribute()
{
FileAttributes attr = FileAttributes.Archive;
InternalHelpers.TryAddFileAttrribute(attr, FileAttributes.System, out attr).Should().BeTrue("First add failed");
InternalHelpers.ContainsFileAttribute(attr, FileAttributes.System).Should().Be(true, "First test failed");
InternalHelpers.TryAddFileAttrribute(attr, FileAttributes.System, out attr).Should().BeFalse("Second add failed");
InternalHelpers.ContainsFileAttribute(attr, FileAttributes.System).Should().Be(true, "Second test failed");
}
public void TryRemoveFileAttrribute()
{
FileAttributes attr = FileAttributes.Archive | FileAttributes.System;
InternalHelpers.TryRemoveFileAttrribute(attr, FileAttributes.System, out attr).Should().BeTrue("First remove failed");
InternalHelpers.ContainsFileAttribute(attr, FileAttributes.System).Should().Be(false, "First test failed");
InternalHelpers.TryRemoveFileAttrribute(attr, FileAttributes.System, out attr).Should().BeFalse("Second remove failed");
InternalHelpers.ContainsFileAttribute(attr, FileAttributes.System).Should().Be(false, "First test failed");
}
public void QueryCollectionToKeyValuePairIgnoresEmptyKeyNames(string keyName)
{
CustomQueryCollection collection = new CustomQueryCollection(new Dictionary <string, StringValues>
{
{ keyName, Guid.NewGuid().ToString() }
});
var result = InternalHelpers.ToKeyValuePair(collection);
Assert.AreEqual(0, result.Count);
}
public void CanReadResponseBody(string contentType, bool canRead)
{
List <KeyValuePair <string, string> > headers = new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>("Content-Type", contentType)
};
var result = InternalHelpers.CanReadResponseBody(headers);
Assert.AreEqual(canRead, result);
}
public void GetExplicitLogResponseBodyReturnsNullIfNoValueIsFound()
{
Logger logger1 = new Logger();
Logger logger2 = new Logger();
bool?value = InternalHelpers.GetExplicitLogResponseBody(new List <Logger> {
logger1, logger2
});
Assert.IsNull(value);
}
