public void NullParameter()
{
TaskParameter t = new TaskParameter(null);
Assert.IsNull(t.WrappedParameter);
Assert.AreEqual(TaskParameterType.Null, t.ParameterType);
((INodePacketTranslatable)t).Translate(TranslationHelpers.GetWriteTranslator());
TaskParameter t2 = TaskParameter.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
Assert.IsNull(t2.WrappedParameter);
Assert.AreEqual(TaskParameterType.Null, t2.ParameterType);
}
public void StringParameter()
{
TaskParameter t = new TaskParameter("foo");
Assert.AreEqual("foo", t.WrappedParameter);
Assert.AreEqual(TaskParameterType.String, t.ParameterType);
((INodePacketTranslatable)t).Translate(TranslationHelpers.GetWriteTranslator());
TaskParameter t2 = TaskParameter.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
Assert.AreEqual("foo", t2.WrappedParameter);
Assert.AreEqual(TaskParameterType.String, t2.ParameterType);
}
public void StringArrayParameter()
{
TaskParameter t = new TaskParameter(new string[] { "foo", "bar" });
Assert.AreEqual(TaskParameterType.StringArray, t.ParameterType);
string[] wrappedParameter = t.WrappedParameter as string[];
Assert.IsNotNull(wrappedParameter);
Assert.AreEqual(2, wrappedParameter.Length);
Assert.AreEqual("foo", wrappedParameter[0]);
Assert.AreEqual("bar", wrappedParameter[1]);
((INodePacketTranslatable)t).Translate(TranslationHelpers.GetWriteTranslator());
TaskParameter t2 = TaskParameter.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
Assert.AreEqual(TaskParameterType.StringArray, t2.ParameterType);
string[] wrappedParameter2 = t2.WrappedParameter as string[];
Assert.IsNotNull(wrappedParameter2);
Assert.AreEqual(2, wrappedParameter2.Length);
Assert.AreEqual("foo", wrappedParameter2[0]);
Assert.AreEqual("bar", wrappedParameter2[1]);
}
public async Task <DataResolverResult> Resolve(string identifier, TaskParameter parameters, CancellationToken token)
{
ImageSource source = parameters.Source;
if (!string.IsNullOrWhiteSpace(parameters.LoadingPlaceholderPath) && parameters.LoadingPlaceholderPath == identifier)
{
source = parameters.LoadingPlaceholderSource;
}
else if (!string.IsNullOrWhiteSpace(parameters.ErrorPlaceholderPath) && parameters.ErrorPlaceholderPath == identifier)
{
source = parameters.ErrorPlaceholderSource;
}
var resolvedData = await(Configuration.DataResolverFactory ?? new DataResolverFactory())
.GetResolver(identifier, source, parameters, Configuration)
.Resolve(identifier, parameters, token).ConfigureAwait(false);
if (resolvedData?.Stream == null)
{
throw new FileNotFoundException(identifier);
}
var svg = new SKSvg()
{
ThrowOnUnsupportedElement = false,
};
SKPicture picture;
if (ReplaceStringMap == null || ReplaceStringMap.Count == 0)
{
using (var svgStream = resolvedData.Stream)
{
picture = svg.Load(svgStream);
}
}
else
{
using (var svgStream = resolvedData.Stream)
using (var reader = new StreamReader(svgStream))
{
var inputString = await reader.ReadToEndAsync();
foreach (var map in ReplaceStringMap
.Where(v => v.Key.StartsWith("regex:")))
{
inputString = Regex.Replace(inputString, map.Key.Substring(0, 6), map.Value);
}
var builder = new StringBuilder(inputString);
foreach (var map in ReplaceStringMap
.Where(v => !v.Key.StartsWith("regex:", StringComparison.OrdinalIgnoreCase)))
{
builder.Replace(map.Key, map.Value);
}
using (var svgFinalStream = new MemoryStream(Encoding.UTF8.GetBytes(builder.ToString())))
{
picture = svg.Load(svgFinalStream);
}
}
}
double sizeX = 0;
double sizeY = 0;
if (VectorWidth == 0 && VectorHeight == 0)
{
if (picture.CullRect.Width > 0)
{
sizeX = picture.CullRect.Width;
}
else
{
sizeX = 300;
}
if (picture.CullRect.Height > 0)
{
sizeY = picture.CullRect.Height;
}
else
{
sizeY = 300;
}
}
else if (VectorWidth > 0 && VectorHeight > 0)
{
sizeX = VectorWidth;
sizeY = VectorHeight;
}
else if (VectorWidth > 0)
{
sizeX = VectorWidth;
sizeY = (VectorWidth / picture.CullRect.Width) * picture.CullRect.Height;
}
else
{
sizeX = (VectorHeight / picture.CullRect.Height) * picture.CullRect.Width;
sizeY = VectorHeight;
}
if (UseDipUnits)
{
sizeX = sizeX.DpToPixels();
sizeY = sizeY.DpToPixels();
}
lock (_encodingLock)
{
using (var bitmap = new SKBitmap(new SKImageInfo((int)sizeX, (int)sizeY)))
//using (var bitmap = new SKBitmap((int)sizeX, (int)sizeY))
using (var canvas = new SKCanvas(bitmap))
using (var paint = new SKPaint())
{
canvas.Clear(SKColors.Transparent);
float scaleX = (float)sizeX / picture.CullRect.Width;
float scaleY = (float)sizeY / picture.CullRect.Height;
var matrix = SKMatrix.MakeScale(scaleX, scaleY);
canvas.DrawPicture(picture, ref matrix, paint);
canvas.Flush();
using (var image = SKImage.FromBitmap(bitmap))
//using (var data = image.Encode(SKImageEncodeFormat.Png, 100)) //TODO disabled because of https://github.com/mono/SkiaSharp/issues/285
using (var data = image.Encode())
{
var stream = new MemoryStream();
data.SaveTo(stream);
stream.Position = 0;
resolvedData.ImageInformation.SetType(ImageInformation.ImageType.SVG);
return(new DataResolverResult(stream, resolvedData.LoadingResult, resolvedData.ImageInformation));
}
}
}
}
/// <summary>
/// Downloads the image request into disk cache for future use if not already exists.
/// Only Url Source supported.
/// IMPORTANT: It throws image loading exceptions - you should handle them
/// </summary>
/// <param name="parameters">Image parameters.</param>
public static async Task DownloadOnlyAsync(this TaskParameter parameters)
{
throw new Exception(DoNotReference);
}
public Task <Tuple <Stream, LoadingResult, ImageInformation> > Resolve(string identifier, TaskParameter parameters, CancellationToken token)
{
var imageInformation = new ImageInformation();
imageInformation.SetPath(identifier);
if (identifier.StartsWith("<", StringComparison.OrdinalIgnoreCase))
{
var streamXML = new MemoryStream(Encoding.UTF8.GetBytes(identifier));
return(Task.FromResult(new Tuple <Stream, LoadingResult, ImageInformation>(
streamXML, LoadingResult.EmbeddedResource, imageInformation)));
}
var mime = string.Empty;
var data = string.Empty;
var encoding = "base64";
var match1 = _regex1.Match(identifier);
var success = false;
if (match1.Success)
{
mime = match1.Groups["mime"].Value;
encoding = match1.Groups["encoding"].Value;
data = match1.Groups["data"].Value;
success = true;
}
else
{
var match2 = _regex2.Match(identifier);
if (match2.Success)
{
mime = match2.Groups["mime"].Value;
data = match2.Groups["data"].Value;
success = true;
}
}
if (!success || (!mime.StartsWith("image/", StringComparison.OrdinalIgnoreCase) &&
!mime.StartsWith("text/", StringComparison.OrdinalIgnoreCase)))
{
throw new NotImplementedException("Data type not supported");
}
if (!encoding.Equals("base64", StringComparison.OrdinalIgnoreCase) ||
data.StartsWith("<", StringComparison.OrdinalIgnoreCase))
{
var stream = new MemoryStream(Encoding.UTF8.GetBytes(data));
return(Task.FromResult(new Tuple <Stream, LoadingResult, ImageInformation>(
stream, LoadingResult.EmbeddedResource, imageInformation)));
}
var streamBase64 = new MemoryStream(Convert.FromBase64String(data));
return(Task.FromResult(new Tuple <Stream, LoadingResult, ImageInformation>(
streamBase64, LoadingResult.EmbeddedResource, imageInformation)));
}
internal static IImageLoaderTask CreateTask(TaskParameter parameters)
{
return(new PlatformImageLoaderTask <object>(null, parameters, Instance));
}
/// <summary>
/// Preloads the image request into memory cache/disk cache for future use.
/// IMPORTANT: It throws image loading exceptions - you should handle them
/// </summary>
/// <param name="parameters">Image parameters.</param>
public static Task PreloadAsync(this TaskParameter parameters)
{
throw new Exception(DoNotReference);
}
private void btnSolveRAlg2_Click(object sender, EventArgs e)
{
try
{
this.btnSolveRAlg2.Enabled = false;
int tick = Environment.TickCount;
this.inf2 = null;
//List<List<double>> sp = this.GetRandomStartParam();
List<List<double>> sp = this.randomStartParameters;
RAlgSolver ra = new RAlgSolver(this.tw, this.res, sp, this.startVector);
ra.FUNCT = new RAlgSolver.FUNCTDelegate(ra.FUNCT4);
ra.R_Algorithm();
for (int i = 0; i < res.Count - this.setCount; i++)
{
if (this.setCount == 1)
{
(this.tblResList as List<ResPointViewType1>)[i].M2 = ra.itab[i];
}
else
{
(this.tblResList as List<ResPointViewType2>)[i].M2 = ra.itab[i];
}
}
this.dgvTabRes.RefreshDataSource();
Dictionary<double, int> tt = this.GetTT(this.res, ra.itab);
StringBuilder sb = new StringBuilder();
//-- draw res ---
if (!this.curves.ContainsKey(this.curveName2))
{
this.curves.Add(this.curveName2, new PointPairList());
LineItem curve = new LineItem(this.curveName2, this.curves[curveName2], Color.Blue, SymbolType.None);
curve.Line.Style = System.Drawing.Drawing2D.DashStyle.DashDot;
curve.Line.Width = 2;
this.zgcMainChart2.GraphPane.CurveList.Add(curve);
}
else
{
this.curves[this.curveName2].Clear();
}
int k = 0;
List<TaskParameter> listDraw = new List<TaskParameter>();
for (int i = 0; i < tps.Count; i++)
{
TaskParameter tpDraw = new TaskParameter(tps[i].Param.Length);
string line = string.Format("{0}) ", i);
for (int j = 0; j < tps[0].Param.Length; j++)
{
tpDraw.Param[j] = ra.x[k];
line += string.Format("a{0}={1:f6} ", j, ra.x[k]);
k++;
}
sb.AppendLine(line);
listDraw.Add(tpDraw);
}
sb.AppendLine("-----");
sb.Append(string.Format("f={0}", ra.f));
rtbResult2.Text = sb.ToString();
TaskParameters tps1 = new TaskParameters(listDraw, tt);
TaskWorker tw1 = new TaskWorker(tps1, this.funcDescr.GetType(), this.funcDescr.MainFuncName, this.funcDescr.SecFuncName, this.funcDescr);
RKVectorForm rk1 = new RKVectorForm(tw1, curveName2, double.Parse(this.txtT0.Text), double.Parse(this.txtT1.Text), this.startVector);
RKResults res1 = rk1.SolveWithConstH(n, RKMetodType.RK2_1);
//if (this.setCount == 1)
//{
// res1.ForEach(r => this.curves[this.curveName2].Add(r.X, r.Y[0]));
//}
//else
//{
// res1.ForEach(r => this.curves[this.curveName2].Add(r.Y[0], r.Y[1]));
//}
int nn = this.setCount == 1 ? 1 : 2;
for (int i = 0; i < res1.Count - nn; i++)
{
if (nn == 1)
{
this.curves[curveName2].Add(res1[i].X, res1[i].Y[0]);
}
else
{
this.curves[curveName2].Add(res1[i].Y[0], res1[i].Y[1]);
}
}
this.zgcMainChart2.AxisChange();
this.zgcMainChart2.Refresh();
this.ra2 = ra;
double t = ((Environment.TickCount - tick) / (double)1000);
this.rtbResult2.Text += string.Format("\r\n-----\r\ntime = {0} sec", t);
this.inf2 = string.Format("Result: f = {0:f6} time = {1} sec", ra.f, t);
}
finally
{
this.btnSolveRAlg2.Enabled = true;
}
}
public void ValueTypeArrayParameter()
{
TaskParameter t = new TaskParameter(new int[] { 2, 15 });
Assert.AreEqual(TaskParameterType.ValueTypeArray, t.ParameterType);
int[] wrappedParameter = t.WrappedParameter as int[];
Assert.IsNotNull(wrappedParameter);
Assert.AreEqual(2, wrappedParameter.Length);
Assert.AreEqual(2, wrappedParameter[0]);
Assert.AreEqual(15, wrappedParameter[1]);
((INodePacketTranslatable)t).Translate(TranslationHelpers.GetWriteTranslator());
TaskParameter t2 = TaskParameter.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
Assert.AreEqual(TaskParameterType.ValueTypeArray, t2.ParameterType);
int[] wrappedParameter2 = t2.WrappedParameter as int[];
Assert.IsNotNull(wrappedParameter2);
Assert.AreEqual(2, wrappedParameter2.Length);
Assert.AreEqual(2, wrappedParameter2[0]);
Assert.AreEqual(15, wrappedParameter2[1]);
}
public void ITaskItemParameter_EscapableNotEscapedMetadata()
{
IDictionary metadata = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
metadata.Add("a", "a1(b1");
metadata.Add("b", "c1)d1");
TaskParameter t = new TaskParameter(new TaskItem("foo", metadata));
Assert.AreEqual(TaskParameterType.ITaskItem, t.ParameterType);
ITaskItem2 foo = t.WrappedParameter as ITaskItem2;
Assert.IsNotNull(foo);
Assert.AreEqual("foo", foo.ItemSpec);
Assert.AreEqual("a1(b1", foo.GetMetadata("a"));
Assert.AreEqual("c1)d1", foo.GetMetadata("b"));
Assert.AreEqual("a1(b1", foo.GetMetadataValueEscaped("a"));
Assert.AreEqual("c1)d1", foo.GetMetadataValueEscaped("b"));
((INodePacketTranslatable)t).Translate(TranslationHelpers.GetWriteTranslator());
TaskParameter t2 = TaskParameter.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
Assert.AreEqual(TaskParameterType.ITaskItem, t2.ParameterType);
ITaskItem2 foo2 = t2.WrappedParameter as ITaskItem2;
Assert.IsNotNull(foo2);
Assert.AreEqual("foo", foo2.ItemSpec);
Assert.AreEqual("a1(b1", foo2.GetMetadata("a"));
Assert.AreEqual("c1)d1", foo2.GetMetadata("b"));
Assert.AreEqual("a1(b1", foo2.GetMetadataValueEscaped("a"));
Assert.AreEqual("c1)d1", foo2.GetMetadataValueEscaped("b"));
}
/// <summary>
/// Loads the image into given imageView using defined parameters.
/// </summary>
/// <param name="parameters">Parameters for loading the image.</param>
/// <param name="imageView">Image view that should receive the image.</param>
public static IScheduledWork Into(this TaskParameter parameters, UIImageView imageView)
{
var target = new UIImageViewTarget(imageView);
return(parameters.Into(target));
}
public void ITaskItemParameter_EscapableNotEscapedItemSpec()
{
TaskParameter t = new TaskParameter(new TaskItem("foo;bar"));
Assert.AreEqual(TaskParameterType.ITaskItem, t.ParameterType);
ITaskItem2 foo = t.WrappedParameter as ITaskItem2;
Assert.IsNotNull(foo);
Assert.AreEqual("foo;bar", foo.ItemSpec);
Assert.AreEqual("foo;bar", foo.EvaluatedIncludeEscaped);
((INodePacketTranslatable)t).Translate(TranslationHelpers.GetWriteTranslator());
TaskParameter t2 = TaskParameter.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
Assert.AreEqual(TaskParameterType.ITaskItem, t2.ParameterType);
ITaskItem2 foo2 = t2.WrappedParameter as ITaskItem2;
Assert.IsNotNull(foo2);
Assert.AreEqual("foo;bar", foo2.ItemSpec);
Assert.AreEqual("foo;bar", foo2.EvaluatedIncludeEscaped);
}
public void ValueTypeParameter()
{
TaskParameter t = new TaskParameter(1);
Assert.Equal(1, t.WrappedParameter);
Assert.Equal(TaskParameterType.ValueType, t.ParameterType);
((INodePacketTranslatable)t).Translate(TranslationHelpers.GetWriteTranslator());
TaskParameter t2 = TaskParameter.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
Assert.Equal(1, t2.WrappedParameter);
Assert.Equal(TaskParameterType.ValueType, t2.ParameterType);
}
public void ITaskItemParameter_DoubleEscapedItemSpec()
{
TaskParameter t = new TaskParameter(new TaskItem("foo%253bbar"));
Assert.AreEqual(TaskParameterType.ITaskItem, t.ParameterType);
ITaskItem foo = t.WrappedParameter as ITaskItem;
Assert.IsNotNull(foo);
Assert.AreEqual("foo%3bbar", foo.ItemSpec);
((INodePacketTranslatable)t).Translate(TranslationHelpers.GetWriteTranslator());
TaskParameter t2 = TaskParameter.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
Assert.AreEqual(TaskParameterType.ITaskItem, t2.ParameterType);
ITaskItem foo2 = t2.WrappedParameter as ITaskItem;
Assert.IsNotNull(foo2);
Assert.AreEqual("foo%3bbar", foo2.ItemSpec);
TaskParameter t3 = new TaskParameter(t2.WrappedParameter);
((INodePacketTranslatable)t3).Translate(TranslationHelpers.GetWriteTranslator());
TaskParameter t4 = TaskParameter.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
Assert.AreEqual(TaskParameterType.ITaskItem, t4.ParameterType);
ITaskItem foo4 = t4.WrappedParameter as ITaskItem;
Assert.IsNotNull(foo4);
Assert.AreEqual("foo%3bbar", foo4.ItemSpec);
}
public void ITaskItemArrayParameter()
{
TaskParameter t = new TaskParameter(new ITaskItem[] { new TaskItem("foo"), new TaskItem("bar") });
Assert.AreEqual(TaskParameterType.ITaskItemArray, t.ParameterType);
ITaskItem[] wrappedParameter = t.WrappedParameter as ITaskItem[];
Assert.IsNotNull(wrappedParameter);
Assert.AreEqual(2, wrappedParameter.Length);
Assert.AreEqual("foo", wrappedParameter[0].ItemSpec);
Assert.AreEqual("bar", wrappedParameter[1].ItemSpec);
((INodePacketTranslatable)t).Translate(TranslationHelpers.GetWriteTranslator());
TaskParameter t2 = TaskParameter.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
Assert.AreEqual(TaskParameterType.ITaskItemArray, t.ParameterType);
ITaskItem[] wrappedParameter2 = t.WrappedParameter as ITaskItem[];
Assert.IsNotNull(wrappedParameter2);
Assert.AreEqual(2, wrappedParameter2.Length);
Assert.AreEqual("foo", wrappedParameter2[0].ItemSpec);
Assert.AreEqual("bar", wrappedParameter2[1].ItemSpec);
}
public void ITaskItemParameterWithMetadata()
{
TaskItem baseItem = new TaskItem("foo");
baseItem.SetMetadata("a", "a1");
baseItem.SetMetadata("b", "b1");
TaskParameter t = new TaskParameter(baseItem);
Assert.AreEqual(TaskParameterType.ITaskItem, t.ParameterType);
ITaskItem foo = t.WrappedParameter as ITaskItem;
Assert.IsNotNull(foo);
Assert.AreEqual("foo", foo.ItemSpec);
Assert.AreEqual("a1", foo.GetMetadata("a"));
Assert.AreEqual("b1", foo.GetMetadata("b"));
((INodePacketTranslatable)t).Translate(TranslationHelpers.GetWriteTranslator());
TaskParameter t2 = TaskParameter.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
Assert.AreEqual(TaskParameterType.ITaskItem, t2.ParameterType);
ITaskItem foo2 = t2.WrappedParameter as ITaskItem;
Assert.IsNotNull(foo2);
Assert.AreEqual("foo", foo2.ItemSpec);
Assert.AreEqual("a1", foo2.GetMetadata("a"));
Assert.AreEqual("b1", foo2.GetMetadata("b"));
}
private async void UpdateSource()
{
Element.SetIsLoading(true);
Xamarin.Forms.ImageSource source = Element.Source;
Cancel();
TaskParameter imageLoader = null;
var ffSource = await ImageSourceBinding.GetImageSourceBinding(source, Element).ConfigureAwait(false);
if (ffSource == null)
{
if (Control != null)
{
Control.Source = null;
}
ImageLoadingFinished(Element);
}
else if (ffSource.ImageSource == FFImageLoading.Work.ImageSource.Url)
{
imageLoader = ImageService.Instance.LoadUrl(ffSource.Path, Element.CacheDuration);
}
else if (ffSource.ImageSource == FFImageLoading.Work.ImageSource.CompiledResource)
{
imageLoader = ImageService.Instance.LoadCompiledResource(ffSource.Path);
}
else if (ffSource.ImageSource == FFImageLoading.Work.ImageSource.ApplicationBundle)
{
imageLoader = ImageService.Instance.LoadFileFromApplicationBundle(ffSource.Path);
}
else if (ffSource.ImageSource == FFImageLoading.Work.ImageSource.Filepath)
{
imageLoader = ImageService.Instance.LoadFile(ffSource.Path);
}
else if (ffSource.ImageSource == FFImageLoading.Work.ImageSource.Stream)
{
imageLoader = ImageService.Instance.LoadStream(ffSource.Stream);
}
if (imageLoader != null)
{
// CustomKeyFactory
if (Element.CacheKeyFactory != null)
{
var bindingContext = Element.BindingContext;
imageLoader.CacheKey(Element.CacheKeyFactory.GetKey(source, bindingContext));
}
// LoadingPlaceholder
if (Element.LoadingPlaceholder != null)
{
var placeholderSource = await ImageSourceBinding.GetImageSourceBinding(Element.LoadingPlaceholder, Element).ConfigureAwait(false);
if (placeholderSource != null)
{
imageLoader.LoadingPlaceholder(placeholderSource.Path, placeholderSource.ImageSource);
}
}
// ErrorPlaceholder
if (Element.ErrorPlaceholder != null)
{
var placeholderSource = await ImageSourceBinding.GetImageSourceBinding(Element.ErrorPlaceholder, Element).ConfigureAwait(false);
if (placeholderSource != null)
{
imageLoader.ErrorPlaceholder(placeholderSource.Path, placeholderSource.ImageSource);
}
}
// Enable vector image source
var vect1 = Element.Source as IVectorImageSource;
var vect2 = Element.LoadingPlaceholder as IVectorImageSource;
var vect3 = Element.ErrorPlaceholder as IVectorImageSource;
if (vect1 != null)
{
imageLoader.WithCustomDataResolver(vect1.GetVectorDataResolver());
}
if (vect2 != null)
{
imageLoader.WithCustomLoadingPlaceholderDataResolver(vect2.GetVectorDataResolver());
}
if (vect3 != null)
{
imageLoader.WithCustomErrorPlaceholderDataResolver(vect3.GetVectorDataResolver());
}
if (Element.CustomDataResolver != null)
{
imageLoader.WithCustomDataResolver(Element.CustomDataResolver);
imageLoader.WithCustomLoadingPlaceholderDataResolver(Element.CustomDataResolver);
imageLoader.WithCustomErrorPlaceholderDataResolver(Element.CustomDataResolver);
}
// Downsample
if (Element.DownsampleToViewSize && (Element.Width > 0 || Element.Height > 0))
{
if (Element.Height > Element.Width)
{
imageLoader.DownSampleInDip(height: (int)Element.Height);
}
else
{
imageLoader.DownSampleInDip(width: (int)Element.Width);
}
}
else if (Element.DownsampleToViewSize && (Element.WidthRequest > 0 || Element.HeightRequest > 0))
{
if (Element.HeightRequest > Element.WidthRequest)
{
imageLoader.DownSampleInDip(height: (int)Element.HeightRequest);
}
else
{
imageLoader.DownSampleInDip(width: (int)Element.WidthRequest);
}
}
else if ((int)Element.DownsampleHeight != 0 || (int)Element.DownsampleWidth != 0)
{
if (Element.DownsampleHeight > Element.DownsampleWidth)
{
if (Element.DownsampleUseDipUnits)
{
imageLoader.DownSampleInDip(height: (int)Element.DownsampleHeight);
}
else
{
imageLoader.DownSample(height: (int)Element.DownsampleHeight);
}
}
else
{
if (Element.DownsampleUseDipUnits)
{
imageLoader.DownSampleInDip(width: (int)Element.DownsampleWidth);
}
else
{
imageLoader.DownSample(width: (int)Element.DownsampleWidth);
}
}
}
// RetryCount
if (Element.RetryCount > 0)
{
imageLoader.Retry(Element.RetryCount, Element.RetryDelay);
}
if (Element.BitmapOptimizations.HasValue)
{
imageLoader.BitmapOptimizations(Element.BitmapOptimizations.Value);
}
// FadeAnimation
if (Element.FadeAnimationEnabled.HasValue)
{
imageLoader.FadeAnimation(Element.FadeAnimationEnabled.Value);
}
// TransformPlaceholders
if (Element.TransformPlaceholders.HasValue)
{
imageLoader.TransformPlaceholders(Element.TransformPlaceholders.Value);
}
// Transformations
if (Element.Transformations != null && Element.Transformations.Count > 0)
{
imageLoader.Transform(Element.Transformations);
}
imageLoader.WithPriority(Element.LoadingPriority);
if (Element.CacheType.HasValue)
{
imageLoader.WithCache(Element.CacheType.Value);
}
if (Element.LoadingDelay.HasValue)
{
imageLoader.Delay(Element.LoadingDelay.Value);
}
var element = Element;
imageLoader.Finish((work) =>
{
element.OnFinish(new CachedImageEvents.FinishEventArgs(work));
ImageLoadingFinished(element);
});
imageLoader.Success((imageInformation, loadingResult) =>
element.OnSuccess(new CachedImageEvents.SuccessEventArgs(imageInformation, loadingResult)));
imageLoader.Error((exception) =>
element.OnError(new CachedImageEvents.ErrorEventArgs(exception)));
imageLoader.DownloadStarted((downloadInformation) =>
element.OnDownloadStarted(new CachedImageEvents.DownloadStartedEventArgs(downloadInformation)));
imageLoader.DownloadProgress((progress) =>
element.OnDownloadProgress(new CachedImageEvents.DownloadProgressEventArgs(progress)));
imageLoader.FileWriteFinished((fileWriteInfo) =>
element.OnFileWriteFinished(new CachedImageEvents.FileWriteFinishedEventArgs(fileWriteInfo)));
_currentTask = imageLoader.Into(Control);
}
}
/// <summary>
/// Loads the image into given UIButton using defined parameters.
/// </summary>
/// <param name="parameters">Parameters for loading the image.</param>
/// <param name="button">UIButton that should receive the image.</param>
public static IScheduledWork Into(this TaskParameter parameters, UIButton button)
{
var target = new UIButtonTarget(button);
return(parameters.Into(target));
}
public async Task <IDecodedImage <Bitmap> > DecodeAsync(Stream stream, string path, ImageSource source, ImageInformation imageInformation, TaskParameter parameters)
{
var result = new DecodedImage <Bitmap>();
var helper = new PlatformGifHelper();
await helper.ReadGifAsync(stream, path, parameters);
result.IsAnimated = helper.Frames.Count > 1;
if (result.IsAnimated && Configuration.AnimateGifs)
{
result.AnimatedImages = new AnimatedImage <Bitmap> [helper.Frames.Count];
for (int i = 0; i < helper.Frames.Count; i++)
{
var animatedImage = new AnimatedImage <Bitmap>();
animatedImage.Delay = helper.Frames[i].Delay;
animatedImage.Image = helper.Frames[i].Image;
result.AnimatedImages[i] = animatedImage;
}
}
else
{
result.IsAnimated = false;
result.Image = helper.Frames[0].Image;
}
if (result.Image != null)
{
imageInformation.SetOriginalSize(result.Image.Width, result.Image.Height);
imageInformation.SetCurrentSize(result.Image.Width, result.Image.Height);
}
else if (result.AnimatedImages != null)
{
if (result.AnimatedImages.Length > 0)
{
if (result.AnimatedImages[0].Image != null)
{
imageInformation.SetOriginalSize(result.AnimatedImages[0].Image.Width, result.AnimatedImages[0].Image.Height);
imageInformation.SetCurrentSize(result.AnimatedImages[0].Image.Width, result.AnimatedImages[0].Image.Height);
}
}
}
return(result);
}
/// <summary>
/// Loads the image into given imageView using defined parameters.
/// IMPORTANT: It throws image loading exceptions - you should handle them
/// </summary>
/// <returns>An awaitable Task.</returns>
/// <param name="parameters">Parameters for loading the image.</param>
/// <param name="item">Image view that should receive the image.</param>
public static Task <IScheduledWork> IntoAsync(this TaskParameter parameters, UITabBarItem item)
{
return(parameters.IntoAsync(param => param.Into(item)));
}
public void ITaskItemParameter_DoubleEscapedMetadata()
{
IDictionary metadata = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
metadata.Add("a", "a1%2525b1");
metadata.Add("b", "c1%2528d1");
TaskParameter t = new TaskParameter(new TaskItem("foo", metadata));
Assert.Equal(TaskParameterType.ITaskItem, t.ParameterType);
ITaskItem foo = t.WrappedParameter as ITaskItem;
Assert.NotNull(foo);
Assert.Equal("foo", foo.ItemSpec);
Assert.Equal("a1%25b1", foo.GetMetadata("a"));
Assert.Equal("c1%28d1", foo.GetMetadata("b"));
((INodePacketTranslatable)t).Translate(TranslationHelpers.GetWriteTranslator());
TaskParameter t2 = TaskParameter.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
Assert.Equal(TaskParameterType.ITaskItem, t2.ParameterType);
ITaskItem foo2 = t2.WrappedParameter as ITaskItem;
Assert.NotNull(foo2);
Assert.Equal("foo", foo2.ItemSpec);
Assert.Equal("a1%25b1", foo2.GetMetadata("a"));
Assert.Equal("c1%28d1", foo2.GetMetadata("b"));
TaskParameter t3 = new TaskParameter(t2.WrappedParameter);
((INodePacketTranslatable)t3).Translate(TranslationHelpers.GetWriteTranslator());
TaskParameter t4 = TaskParameter.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
Assert.Equal(TaskParameterType.ITaskItem, t4.ParameterType);
ITaskItem foo4 = t4.WrappedParameter as ITaskItem;
Assert.NotNull(foo4);
Assert.Equal("foo", foo4.ItemSpec);
Assert.Equal("a1%25b1", foo4.GetMetadata("a"));
Assert.Equal("c1%28d1", foo4.GetMetadata("b"));
}
void AppendTaskAdapterProperty(StringBuilder builder, TaskParameter parameter, HashSet<Type> referencedTypes)
{
var type = parameter.Property.PropertyType;
referencedTypes.Add(type);
builder.Append(Indent).AppendFormat("@{0} as {1}:", parameter.Name, type.FullName.Replace('+', '.')).AppendLine();
if (parameter.Property.GetGetMethod() != null) {
// yes, there are such properties in NAnt
builder.Append(Indent2).AppendLine("get:");
builder.Append(Indent3).AppendLine("return task." + parameter.Property.Name);
}
if (parameter.Property.GetSetMethod() != null) {
builder.Append(Indent2).AppendLine("set:");
builder.Append(Indent3).AppendFormat("task.{0} = value", parameter.Property.Name).AppendLine().AppendLine();
}
}
/// <summary>
/// Loads the image into given imageView using defined parameters.
/// </summary>
/// <param name="parameters">Parameters for loading the image.</param>
/// <param name="item">Image view that should receive the image.</param>
public static IScheduledWork Into(this TaskParameter parameters, UITabBarItem item)
{
var target = new UIBarItemTarget(item);
return(parameters.Into(target));
}
/// <summary>
/// Constructs a new TaskParameter to load an image from a URL.
/// </summary>
/// <returns>The new TaskParameter.</returns>
/// <param name="url">URL to the file</param>
/// <param name="cacheDuration">How long the file will be cached on disk</param>
public TaskParameter LoadUrl(string url, TimeSpan?cacheDuration = null)
{
InitializeIfNeeded();
return(TaskParameter.FromUrl(url, cacheDuration));
}
/// <summary>
/// Loads the image into given imageView using defined parameters.
/// IMPORTANT: It throws image loading exceptions - you should handle them
/// </summary>
/// <returns>An awaitable Task.</returns>
/// <param name="parameters">Parameters for loading the image.</param>
/// <param name="imageView">Image view that should receive the image.</param>
public static Task <IScheduledWork> IntoAsync(this TaskParameter parameters, UIImageView imageView)
{
return(parameters.IntoAsync(param => param.Into(imageView)));
}
/// <summary>
/// Constructs a new TaskParameter to load an image from a file from application bundle.
/// </summary>
/// <returns>The new TaskParameter.</returns>
/// <param name="filepath">Path to the file.</param>
public TaskParameter LoadFileFromApplicationBundle(string filepath)
{
InitializeIfNeeded();
return(TaskParameter.FromApplicationBundle(filepath));
}
internal static IImageLoaderTask CreateTask <TImageView>(TaskParameter parameters, ITarget <MockBitmap, TImageView> target) where TImageView : class
{
return(new PlatformImageLoaderTask <TImageView>(target, parameters, Instance));
}
/// <summary>
/// Constructs a new TaskParameter to load an image from a compiled drawable resource.
/// </summary>
/// <returns>The new TaskParameter.</returns>
/// <param name="resourceName">Name of the resource in drawable folder without extension</param>
public TaskParameter LoadCompiledResource(string resourceName)
{
InitializeIfNeeded();
return(TaskParameter.FromCompiledResource(resourceName));
}
/// <summary>
/// Invalidate the image corresponding to given parameters from given caches.
/// </summary>
/// <param name="parameters">Image parameters.</param>
/// <param name="cacheType">Cache type.</param>
public static Task InvalidateAsync(this TaskParameter parameters, CacheType cacheType)
{
throw new Exception(DoNotReference);
}
/// <summary>
/// Constructs a new TaskParameter to load an image from a Stream.
/// </summary>
/// <returns>The new TaskParameter.</returns>
/// <param name="resourceName">A function that allows a CancellationToken and returns the Stream to use. This function will be invoked by LoadStream().</param>
public TaskParameter LoadStream(Func <CancellationToken, Task <Stream> > stream)
{
InitializeIfNeeded();
return(TaskParameter.FromStream(stream));
}
/// <summary>
/// Downloads the image request into disk cache for future use if not already exists.
/// Only Url Source supported.
/// </summary>
/// <param name="parameters">Image parameters.</param>
public static void DownloadOnly(this TaskParameter parameters)
{
throw new Exception(DoNotReference);
}
protected void CreateResultList(decimal shareAmount, User shareUser, TaskParameter parameter, ShareBaseConfig config, IList <ITaskResult> resultList, string configName = "")
{
CreateResultList(shareAmount, base.ShareOrderUser, shareUser, parameter, config, resultList, configName = "");
}
/// <summary>
/// 对module配置与参数进行基础验证，子类重写后需要显式调用并判定返回值，如返回值不为Success，则不再执行子类后续逻辑
/// </summary>
/// <param name="parameter">参数</param>
public override ExecuteResult <ITaskResult[]> Execute(TaskParameter parameter)
{
var baseResult = base.Execute(parameter);
if (baseResult.Status != ResultStatus.Success)
{
return(baseResult);
}
if (parameter.TryGetValue(TriggerTypeKey, out int triggerType))
{
TriggerType = (TriggerType)triggerType;
if (Configuration.TriggerType != TriggerType)
{
//触发类型与配置的触发类型不一致，直接退出
return(ExecuteResult <ITaskResult[]> .Cancel($"模块实际触发类型{triggerType}与模块设置的触发类型{Configuration.TriggerType}不一致,退出模块."));
}
}
else
{
TriggerType = Configuration.TriggerType;
}
// 触发类型为会员注册
if (TriggerType == TriggerType.UserReg)
{
parameter.TryGetValue(FenRunAmountKey, out decimal amount);
BaseFenRunAmount = amount;
if (BaseFenRunAmount <= 0)
{
return(ExecuteResult <ITaskResult[]> .Cancel($"分润基数价格获取为0. BaseFenRunAmount={BaseFenRunAmount}"));
}
}
// 触发类型为会员升级
if (TriggerType == TriggerType.UserUpgrade)
{
parameter.TryGetValue(FenRunAmountKey, out decimal amount);
BaseFenRunAmount = amount;
if (BaseFenRunAmount <= 0)
{
return(ExecuteResult <ITaskResult[]> .Cancel($"分润基数价格获取为0. BaseFenRunAmount={BaseFenRunAmount},会员Id为{ShareOrder.UserId}"));
}
}
// 触发类型为商城购物
if (TriggerType == TriggerType.Order)
{
//TODO 重构注释
////获取价格基数
//if (parameter.TryGetValue("OrderId", out long orderId)) {
// // 获取符合条件的商品 价格依赖范围 所有商品 按所属商品线选择 按所属商城选择
// var effectiveOrderProductListAll = GetEffectiveOrderProduct(orderId);
// if (effectiveOrderProductListAll == null || effectiveOrderProductListAll.Count == 0) {
// return ExecuteResult<ITaskResult[]>.Cancel($"没有符合的产品可分润,退出模块.");
// }
// var effectiveOrderProductList = new List<OrderProduct>();
// // 商品单价限制
// if (Configuration.PriceLimitType == PriceLimitType.ProductPrice) {
// foreach (var productItem in effectiveOrderProductListAll) {
// if (productItem.Amount > Configuration.BaseRule.MaxAmount && Configuration.BaseRule.MaxAmount > 0) {
// continue;
// }
// if (productItem.Amount < Configuration.BaseRule.MinimumAmount && Configuration.BaseRule.MinimumAmount > 0) {
// continue;
// }
// effectiveOrderProductList.Add(productItem);
// }
// } else {
// effectiveOrderProductList = effectiveOrderProductListAll;
// }
// //如果价格模式为销售价，则触发金额为有效的商品实际售价之和
// if (Configuration.ProductRule.AmountType == PriceType.Price) {
// // 根据实际支付方式获取价格 （PaymentAmount为人民币支付的价格）
// BaseFenRunAmount = effectiveOrderProductList.Sum(e => e.PaymentAmount);
// }
// //如果价格模式为分润价，则触发金额为有效的商品分润价之和
// if (Configuration.ProductRule.AmountType == PriceType.FenRun) {
// BaseFenRunAmount = effectiveOrderProductList.Sum(e => e.FenRunAmount);
// }
// //如果价格模式为商品数 ：有效商品数量之和
// if (Configuration.ProductRule.AmountType == PriceType.ProductNum) {
// BaseFenRunAmount = effectiveOrderProductList.Sum(e => e.Count);
// }
// //如果价格模式为商品数 ：有效商品数量之和
// if (Configuration.ProductRule.AmountType == PriceType.OrderNum) {
// BaseFenRunAmount = 1;
// }
// //如果价格模式为服务费
// if (Configuration.ProductRule.AmountType == PriceType.OrderFeeAmount) {
// BaseFenRunAmount = effectiveOrderProductList.Sum(e => e.OrderProductExtension?.OrderAmount?.FeeAmount).ConvertToDecimal();
// }
//}
//OrderId = orderId;
//if (BaseFenRunAmount <= 0) {
// return ExecuteResult<ITaskResult[]>.Cancel($"分润基数价格获取为0. BaseFenRunAmount={BaseFenRunAmount},订单id为{OrderId}");
//}
}
// 触发类型为内部连锁
if (TriggerType == TriggerType.Chain)
{
if (!parameter.TryGetValue(DefaultAmountKey, out decimal amount))
{
amount = 0;
}
BaseFenRunAmount = amount;
}
// 触发类型为其他、提现、充值,订单金额为ShareOrder的Amount
if (TriggerType == TriggerType.Other || TriggerType == TriggerType.WithDraw || TriggerType == TriggerType.Recharge)
{
parameter.TryGetValue(FenRunAmountKey, out decimal amount);
BaseFenRunAmount = amount;
if (BaseFenRunAmount <= 0)
{
return(ExecuteResult <ITaskResult[]> .Cancel($"分润基数价格获取为0. BaseFenRunAmount={BaseFenRunAmount}"));
}
}
if (!parameter.TryGetValue("ShareOrderId", out long shareOrderId))
{
return(ExecuteResult <ITaskResult[]> .Fail("分润订单ShareOrderId未找到."));
}
// 线程停止3s中，重新读取数据库，保证ShardeOdeer状态正确，不重复触发
//Thread.Sleep(TimeSpan.FromSeconds(3));
var shareOrder = Resolve <IShareService>().GetSingleNative(shareOrderId);
if (shareOrder == null)
{
return(ExecuteResult <ITaskResult[]> .Fail("分润订单未找到."));
}
if (shareOrder.Status != ShareOrderStatus.Pending)
{
return(ExecuteResult <ITaskResult[]> .Fail("分润订单原生查询，状态不正常."));
}
var teamConfig = Resolve <IAutoConfigService>().GetValue <TeamConfig>();
this.TeamLevel = teamConfig.TeamLevel;
return(ExecuteResult <ITaskResult[]> .Success());
}
/// <summary>
/// 生成订单
/// </summary>
/// <param name="shareAmount">分润金额</param>
/// <param name="orderUser">下单用户</param>
/// <param name="shareUser">收益用户</param>
/// <param name="parameter">参数</param>
/// <param name="config">分润配置</param>
/// <param name="resultList"></param>
/// <param name="configName"></param>
protected void CreateResultList(decimal shareAmount, User orderUser, User shareUser, TaskParameter parameter, ShareBaseConfig config, IList <ITaskResult> resultList, string configName = "")
{
//如果分润金额小于等于0,则退出
if (shareAmount > 0 && shareUser != null)
{
if (shareUser.Status == Alabo.Domains.Enums.Status.Normal)
{
parameter.TryGetValue("OrderId", out long orderId);
// 如果限制供应商购买过的店铺
// 检查该会员是否购买过该店铺的商品,核对User_TypeUser表
if (Configuration.ProductRule.IsLimitStoreBuy)
{
//TODO 重构
//// 如果是订单用户
//if (TriggerType == TriggerType.Order) {
// var order = Ioc.Resolve<IOrderService>().GetSingle(orderId);
// if (order != null) {
// var storeUser = Ioc.Resolve<ITypeUserService>()
// .GetStoreUser(order.StoreId, shareUser.Id);
// if (storeUser == null) {
// //分润用户不是该店铺的用户 退出
// return;
// // ExecuteResult<ITaskResult>.Cancel($"分润用户不是该店铺的用户");
// }
// }
//}
}
var moneyTypes = Resolve <IAutoConfigService>().GetList <MoneyTypeConfig>(r => r.Status == Alabo.Domains.Enums.Status.Normal);
foreach (var rule in Configuration.RuleItems)
{
var ruleAmount = shareAmount * rule.Ratio;
var ruleMoneyType = moneyTypes.FirstOrDefault(r => r.Id == rule.MoneyTypeId);
if (ruleMoneyType == null)
{
continue;
//ExecuteResult<ITaskResult>.Cancel($"资产分润规则设置错误，货币类型Id{ruleMoneyType.Id}");
}
var shareResult = new ShareResult {
OrderUser = orderUser,
ShareUser = shareUser,
ShareOrder = base.ShareOrder,
Amount = ruleAmount,
MoneyTypeId = rule.MoneyTypeId,
ModuleConfigId = config.Id,
ModuleId = config.ModuleId,
SmsNotification = config.TemplateRule.SmsNotification
};
//描述
shareResult.Intro = Configuration.TemplateRule.LoggerTemplate.Replace("{OrderUserName}", orderUser.GetUserName())
.Replace("{ShareUserName}", shareUser.GetUserName())
.Replace("{ConfigName}", configName)
.Replace("{AccountName}", ruleMoneyType.Name)
.Replace("{OrderId}", orderId.ToString())
.Replace("{OrderPrice}", base.ShareOrder.Amount.ToString("F2"))
.Replace("{ShareAmount}", ruleAmount.ToString("F2"));
//短信内容
shareResult.SmsIntro = Configuration.TemplateRule.LoggerTemplate.Replace("{OrderUserName}", orderUser.GetUserName())
.Replace("{ShareUserName}", shareUser.GetUserName())
.Replace("{ConfigName}", configName)
.Replace("{AccountName}", ruleMoneyType.Name)
.Replace("{OrderId}", orderId.ToString())
.Replace("{OrderPrice}", base.ShareOrder.Amount.ToString("F2"))
.Replace("{ShareAmount}", ruleAmount.ToString("F2"));
var queueResult = new TaskQueueResult <ITaskResult>(Context)
{
ShareResult = shareResult
};
resultList.Add(queueResult);
}
}
}
}
protected virtual void UpdateImageLoadingTask()
{
var ffSource = GetImageSourceBinding(ImagePath, ImageStream);
var placeholderSource = GetImageSourceBinding(LoadingPlaceholderImagePath, null);
Cancel();
TaskParameter imageLoader = null;
if (ffSource == null)
{
_internalImage.Source = null;
IsLoading = false;
return;
}
IsLoading = true;
if (ffSource.ImageSource == FFImageLoading.Work.ImageSource.Url)
{
imageLoader = ImageService.Instance.LoadUrl(ffSource.Path, CacheDuration);
}
else if (ffSource.ImageSource == FFImageLoading.Work.ImageSource.CompiledResource)
{
imageLoader = ImageService.Instance.LoadCompiledResource(ffSource.Path);
}
else if (ffSource.ImageSource == FFImageLoading.Work.ImageSource.ApplicationBundle)
{
imageLoader = ImageService.Instance.LoadFileFromApplicationBundle(ffSource.Path);
}
else if (ffSource.ImageSource == FFImageLoading.Work.ImageSource.Filepath)
{
imageLoader = ImageService.Instance.LoadFile(ffSource.Path);
}
else if (ffSource.ImageSource == FFImageLoading.Work.ImageSource.Stream)
{
imageLoader = ImageService.Instance.LoadStream(ffSource.Stream);
}
else if (ffSource.ImageSource == FFImageLoading.Work.ImageSource.EmbeddedResource)
{
imageLoader = ImageService.Instance.LoadEmbeddedResource(ffSource.Path);
}
if (imageLoader != null)
{
// LoadingPlaceholder
if (placeholderSource != null)
{
if (placeholderSource != null)
{
imageLoader.LoadingPlaceholder(placeholderSource.Path, placeholderSource.ImageSource);
}
}
// ErrorPlaceholder
if (!string.IsNullOrWhiteSpace(ErrorPlaceholderImagePath))
{
var errorPlaceholderSource = GetImageSourceBinding(ErrorPlaceholderImagePath, null);
if (errorPlaceholderSource != null)
{
imageLoader.ErrorPlaceholder(errorPlaceholderSource.Path, errorPlaceholderSource.ImageSource);
}
}
if (CustomDataResolver != null)
{
imageLoader.WithCustomDataResolver(CustomDataResolver);
imageLoader.WithCustomLoadingPlaceholderDataResolver(CustomLoadingPlaceholderDataResolver);
imageLoader.WithCustomErrorPlaceholderDataResolver(CustomErrorPlaceholderDataResolver);
}
// Downsample
if ((int)DownsampleHeight != 0 || (int)DownsampleWidth != 0)
{
if (DownsampleHeight > DownsampleWidth)
{
if (DownsampleUseDipUnits)
{
imageLoader.DownSampleInDip(height: (int)DownsampleHeight);
}
else
{
imageLoader.DownSample(height: (int)DownsampleHeight);
}
}
else
{
if (DownsampleUseDipUnits)
{
imageLoader.DownSampleInDip(width: (int)DownsampleWidth);
}
else
{
imageLoader.DownSample(width: (int)DownsampleWidth);
}
}
}
// RetryCount
if (RetryCount > 0)
{
imageLoader.Retry(RetryCount, RetryDelay);
}
if (BitmapOptimizations.HasValue)
{
imageLoader.BitmapOptimizations(BitmapOptimizations.Value);
}
// FadeAnimation
if (FadeAnimationEnabled.HasValue)
{
imageLoader.FadeAnimation(FadeAnimationEnabled.Value, duration: FadeAnimationDuration);
}
// FadeAnimationForCachedImages
if (FadeAnimationEnabled.HasValue && FadeAnimationForCachedImages.HasValue)
{
imageLoader.FadeAnimation(FadeAnimationEnabled.Value, FadeAnimationForCachedImages.Value, FadeAnimationDuration);
}
// TransformPlaceholders
if (TransformPlaceholders.HasValue)
{
imageLoader.TransformPlaceholders(TransformPlaceholders.Value);
}
// Transformations
if (Transformations != null && Transformations.Count > 0)
{
imageLoader.Transform(Transformations);
}
if (InvalidateLayoutAfterLoaded.HasValue)
{
imageLoader.InvalidateLayout(InvalidateLayoutAfterLoaded.Value);
}
imageLoader.WithPriority(LoadingPriority);
if (CacheType.HasValue)
{
imageLoader.WithCache(CacheType.Value);
}
if (LoadingDelay > 0)
{
imageLoader.Delay(LoadingDelay);
}
imageLoader.Finish((work) =>
{
IsLoading = false;
OnFinish?.Invoke(this, new Args.FinishEventArgs(work));
});
imageLoader.Success((imageInformation, loadingResult) =>
{
OnSuccess?.Invoke(this, new Args.SuccessEventArgs(imageInformation, loadingResult));
_lastImageSource = ffSource;
});
if (OnError != null)
{
imageLoader.Error((ex) => OnError?.Invoke(this, new Args.ErrorEventArgs(ex)));
}
if (OnDownloadStarted != null)
{
imageLoader.DownloadStarted((downloadInformation) => OnDownloadStarted(this, new Args.DownloadStartedEventArgs(downloadInformation)));
}
if (OnDownloadProgress != null)
{
imageLoader.DownloadProgress((progress) => OnDownloadProgress(this, new Args.DownloadProgressEventArgs(progress)));
}
if (OnFileWriteFinished != null)
{
imageLoader.FileWriteFinished((info) => OnFileWriteFinished(this, new Args.FileWriteFinishedEventArgs(info)));
}
if (!string.IsNullOrWhiteSpace(CustomCacheKey))
{
imageLoader.CacheKey(CustomCacheKey);
}
SetupOnBeforeImageLoading(imageLoader);
_scheduledWork = imageLoader.Into(_internalImage);
}
}
/// <summary>
/// Loads the image into given UIButton using defined parameters.
/// IMPORTANT: It throws image loading exceptions - you should handle them
/// </summary>
/// <returns>An awaitable Task.</returns>
/// <param name="parameters">Parameters for loading the image.</param>
/// <param name="button">UIButton that should receive the image.</param>
public static Task <IScheduledWork> IntoAsync(this TaskParameter parameters, UIButton button)
{
return(parameters.IntoAsync(param => param.Into(button)));
}
public async virtual Task <Tuple <Stream, LoadingResult, ImageInformation> > Resolve(string identifier, TaskParameter parameters, CancellationToken token)
{
StorageFile file = null;
try
{
string resPath = identifier.TrimStart('\\', '/');
if (!resPath.StartsWith(@"Assets\") && !resPath.StartsWith("Assets/"))
{
resPath = @"Assets\" + resPath;
}
var imgUri = new Uri("ms-appx:///" + resPath);
file = await StorageFile.GetFileFromApplicationUriAsync(imgUri);
}
catch (Exception)
{
try
{
var imgUri = new Uri("ms-appx:///" + identifier);
file = await StorageFile.GetFileFromApplicationUriAsync(imgUri);
}
catch (Exception)
{
}
}
if (file != null)
{
var imageInformation = new ImageInformation();
imageInformation.SetPath(identifier);
imageInformation.SetFilePath(file.Path);
token.ThrowIfCancellationRequested();
var stream = await file.OpenStreamForReadAsync();
return(new Tuple <Stream, LoadingResult, ImageInformation>(stream, LoadingResult.CompiledResource, imageInformation));
}
throw new FileNotFoundException(identifier);
}
public static Task <UIImage> AsPImageAsync(this TaskParameter parameters)
{
return(AsUIImageAsync(parameters));
}
/// <summary>
/// 对module配置与参数进行基础验证，子类重写后需要显式调用并判定返回值，如返回值不为Success，则不再执行子类后续逻辑
/// </summary>
/// <param name="parameter">参数</param>
public override ExecuteResult <ITaskResult[]> Execute(TaskParameter parameter)
{
var baseResult = base.Execute(parameter);
if (baseResult.Status != ResultStatus.Success)
{
return(ExecuteResult <ITaskResult[]> .Cancel("未找到触发会员的Parent Map."));
}
var userMap = Resolve <IUserMapService>().GetParentMapFromCache(ShareOrderUser.Id);
var map = userMap.ParentMap.DeserializeJson <List <ParentMap> >();
if (map == null)
{
return(ExecuteResult <ITaskResult[]> .Cancel("未找到触发会员的Parent Map."));
}
IList <ITaskResult> resultList = new List <ITaskResult>();
// 获取最大极差比例
var maxRate = Configuration.TeamRangeRateItems.Max(r => r.MaxRate);
for (var i = 0; i < TeamLevel; i++)
{
if (map.Count < i + 1)
{
break;
}
var item = map[i];
base.GetShareUser(item.UserId, out var shareUser); //从基类获取分润用户
var shareGrade = Resolve <IGradeService>().GetGrade(shareUser.GradeId);
if (shareGrade == null)
{
continue;
}
var userRule = Configuration.TeamRangeRateItems.FirstOrDefault(r => r.GradeId == shareGrade.Id);
if (userRule == null)
{
continue;
}
//当前分润用户最大极差
var shareUserRate = userRule.MaxRate;
//剩余极差比例
var ratio = maxRate - shareUserRate;
if (ratio <= 0)
{
continue;
}
var shareAmount = ratio * BaseFenRunAmount; // 极差分润
CreateResultList(shareAmount, ShareOrderUser, shareUser, parameter, Configuration, resultList);
// 计算推荐人的管理收益
var parentUer = base.GetShareUser(shareUser.ParentId, out var shareParentShareUser);
if (shareParentShareUser != null)
{
var parentUserRule =
Configuration.TeamRangeRateItems.FirstOrDefault(r => r.GradeId == shareParentShareUser.GradeId);
if (parentUserRule != null)
{
var parentUserManagerRadio = parentUserRule.ManagerRate * shareAmount; // 管理收益
CreateResultList(parentUserManagerRadio, ShareOrderUser, shareParentShareUser, parameter,
Configuration, resultList);
}
}
}
//分期
return(ExecuteResult <ITaskResult[]> .Success(resultList.ToArray()));
}
/// <summary>
/// Loads the image into PNG Stream
/// </summary>
/// <returns>The PNG Stream async.</returns>
/// <param name="parameters">Parameters.</param>
public static async Task <Stream> AsPNGStreamAsync(this TaskParameter parameters)
{
var result = await AsUIImageAsync(parameters);
return(result.AsPngStream());
}
/// <summary>
/// Only use this method if you plan to handle exceptions in your code. Awaiting this method will give you this flexibility.
/// </summary>
/// <returns>An awaitable Task.</returns>
/// <param name="parameters">Parameters for loading the image.</param>
/// <param name="imageView">Image view that should receive the image.</param>
/// <param name="imageScale">Optional scale factor to use when interpreting the image data. If unspecified it will use the device scale (ie: Retina = 2, non retina = 1)</param>
public static Task <IScheduledWork> IntoAsync(this TaskParameter parameters, UIImageView imageView, float imageScale = -1f)
{
return(parameters.IntoAsync(param => param.Into(imageView, imageScale)));
}
/// <summary>
/// Loads the image into JPG Stream
/// </summary>
/// <returns>The JPG Stream async.</returns>
/// <param name="parameters">Parameters.</param>
/// <param name="quality">Quality.</param>
public static async Task <Stream> AsJPGStreamAsync(this TaskParameter parameters, int quality = 80)
{
var result = await AsUIImageAsync(parameters);
return(result.AsJpegStream(quality));
}
private void btnSolveRK_Click(object sender, EventArgs e)
{
this.rtbResult1.Text = this.rtbResult2.Text = string.Empty;
this.dgvTabRes.DataSource = null;
this.n = int.Parse(this.txtN.Text);
this.setCount = this.rbN1.Checked ? 1 : 2;
//this.gamma = double.Parse(txtGamma.Text);
ZedGraph.GraphPane gp = this.zgcMainChart2.GraphPane;
gp.CurveList.Clear();
this.curves.Clear();
this.curves.Add(this.curveName, new PointPairList());
gp.AddCurve(this.curveName, this.curves[curveName], Color.Black, SymbolType.None);
List<double> gammaList = new List<double>();
List<double> p = new List<double>();
for (int i = 0; i < dgvGama.ColumnCount; i++)
{
gammaList.Add(Convert.ToDouble(dgvGama.Rows[0].Cells[i].Value));
}
List<TaskParameter> list = new List<TaskParameter>();
for (int i = 0; i < dgvParameters.RowCount; i++)
{
TaskParameter tp = new TaskParameter(dgvParameters.ColumnCount);
for (int j = 0; j < dgvParameters.ColumnCount; j++)
{
double val = Convert.ToDouble(dgvParameters.Rows[i].Cells[j].Value);
tp.Param[j] = val;
}
list.Add(tp);
}
this.tps = new TaskParameters(list, gammaList);
string mfName = this.setCount == 1 ? "MF1" : "MF2";
this.funcDescr = new Functions_2_2(mfName, this.fnames[(sfList.SelectedItem as string).ToUpper()]);
this.tw = new TaskWorker(tps, funcDescr.GetType(), funcDescr.MainFuncName, funcDescr.SecFuncName, funcDescr);
this.startVector = this.setCount == 1 ? new Vector(1, double.Parse(this.txtY0.Text)) :
new Vector(2, double.Parse(this.txtY00.Text), double.Parse(this.txtY01.Text));
RKVectorForm rk = new RKVectorForm(tw, curveName, double.Parse(this.txtT0.Text), double.Parse(this.txtT1.Text), startVector);
this.res = rk.SolveWithConstH(n, RKMetodType.RK4_1);
if (this.rbN1.Checked)
{
res.ForEach(r => this.curves[curveName].Add(r.X, r.Y[0]));
}
else
{
res.ForEach(r => this.curves[curveName].Add(r.Y[0], r.Y[1]));
}
this.zgcMainChart2.AxisChange();
this.zgcMainChart2.Refresh();
if (this.setCount == 1)
{
this.tblResList = new List<ResPointViewType1>();
for (int i = 0; i < res.Count - 1; i++)
(this.tblResList as List<ResPointViewType1>).Add(new ResPointViewType1(res[i].X, res[i].Y[0], -1, -1));
this.dgvTabRes.DataSource = null;
this.dgvTabRes.DataSource = tblResList;
}
else
{
this.tblResList = new List<ResPointViewType2>();
for (int i = 0; i < res.Count - 2; i++)
(this.tblResList as List<ResPointViewType2>).Add(new ResPointViewType2(res[i].X, res[i].Y[0], res[i].Y[1], -1, -1));
this.dgvTabRes.DataSource = null;
this.dgvTabRes.DataSource = tblResList;
}
this.dgvTabRes.RefreshDataSource();
this.randomStartParameters = this.GetRandomStartParam();
}
public void ITaskItemParameter()
{
TaskParameter t = new TaskParameter(new TaskItem("foo"));
Assert.Equal(TaskParameterType.ITaskItem, t.ParameterType);
ITaskItem foo = t.WrappedParameter as ITaskItem;
Assert.NotNull(foo);
Assert.Equal("foo", foo.ItemSpec);
((INodePacketTranslatable)t).Translate(TranslationHelpers.GetWriteTranslator());
TaskParameter t2 = TaskParameter.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
Assert.Equal(TaskParameterType.ITaskItem, t2.ParameterType);
ITaskItem foo2 = t2.WrappedParameter as ITaskItem;
Assert.NotNull(foo2);
Assert.Equal("foo", foo2.ItemSpec);
}
