public void TestResolve(double expected, string value)
{
var resolver = new DoubleResolver();
var model = new ArgumentModel("key", value);
Assert.Equal(expected, resolver.Resolve(model));
}
public void UpdateSlug(ArgumentModel argument)
{
var postSlug = _commonService.cleanStringPath(argument.name);
//Get all argument with father id this argument and update slug
var arguments = _argumentService.GetByFatherId(argument.id);
foreach (var arg in arguments)
{
var slug = _slugService.GetById(arg.slugId).name;
var replace = _slugService.GetById(argument.slugId).name.Split('/').Where(x => !string.IsNullOrEmpty(x)).ToArray();
var newSlug = slug.Replace(replace[replace.Length - 1], postSlug);
_slugService.Update(arg.slugId, newSlug);
}
//Get all post with this argument id and update slug
var posts = _postService.GetAllByArgumentId(argument.id);
foreach (var post in posts)
{
var slug = _slugService.GetById(post.slugId).name;
var replace = _slugService.GetById(argument.slugId).name.Split('/').Where(x => !string.IsNullOrEmpty(x)).ToArray();
var newSlug = slug.Replace(replace[replace.Length - 1], postSlug);
_slugService.Update(post.slugId, newSlug);
}
var argumentSlug = _slugService.GetById(argument.slugId).name;
var slugArray = argumentSlug.Split('/').Where(x => !string.IsNullOrEmpty(x)).ToArray();
var name = argumentSlug.Replace(slugArray[slugArray.Length - 1], postSlug);
_slugService.Update(argument.slugId, name);
}
/// <summary>
/// : parameter_name(IN | OUT | INOUT | NOCOPY) * type_spec? default_value_part ?
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override object VisitParameter([NotNull] PlSqlParser.ParameterContext context)
{
bool _in = context.IN() != null;
bool _out = context.OUT() != null;
if (context.INOUT() != null)
{
_in = _out = true;
}
bool _nocopy = context.NOCOPY() != null;
OTypeReference type = null;
var type_spec = context.type_spec();
if (type_spec != null)
{
type = (OTypeReference)VisitType_spec(type_spec);
}
var arg = new ArgumentModel()
{
//Key = method.Arguments.Count().ToString(),
Name = context.parameter_name().GetCleanedName(),
In = _in,
Out = _out,
Description = string.Empty,
};
if (type != null)
{
arg.Type = type;
}
return(arg);
}
public int InsertSlug(ArgumentModel argument, int categoryId)
{
var categorySlugId = _categoryService.GetById(categoryId).slugId;
var categorySlug = _slugService.GetById(categorySlugId).name;
var name = "";
if (argument.idPadre > 0)
{
var idPadre = _argumentService.GetById(argument.idPadre).id;
var nomePadre = _argumentService.GetById(idPadre).name;
name = string.Concat(categorySlug, nomePadre, '/', _commonService.cleanStringPath(argument.name), '/');
}
else
{
name = string.Concat(categorySlug, _commonService.cleanStringPath(argument.name), '/');
}
var model = new SlugModel();
model.name = name;
model.entityname = "Argument";
_slugService.Insert(model);
return(_slugService.GetByName(name).id);
}
private string FormatOperand(ArgumentModel operand)
{
string name = operand.Name;
if (_colCtorProvider.IsCollection(operand.Type))
{
if (operand.Optional)
{
return($"[<{name}>...]");
}
else
{
return($"<{name}>...");
}
}
if (operand.Optional)
{
return($"[<{name}>]");
}
else
{
return($"<{name}>");
}
}
private string FormatOption(ArgumentModel option)
{
string name = option.Name;
if (_colCtorProvider.IsCollection(option.Type))
{
if (option.Optional)
{
return($"[(--{name} <value>)...]");
}
else
{
return($"(--{name} <value>)...");
}
}
if (option.Optional)
{
return($"[--{name} <value>]");
}
else
{
return($"--{name} <value>");
}
}
static void Main(string[] args)
{
ConsoleHelper.WriteLineColorGreen("Access Token : " + args[1]);
ConsoleHelper.WriteLineColorGreen("Album Id : " + args[0]);
Console.WriteLine();
var argsData = new ArgumentModel
{
AccessToken = args[1],
AlbumId = args[0]
};
HandleException.Run(() => {
IHttpClientService connectionClient = new HttpClientService();
IFacebookCore worker = new FacebookCore(argsData, connectionClient);
ConsoleHelper.WriteLineColorBlue("Fetching all photo in album ...");
var allPhotoList = worker.GetAllPhotoList();
using (var webClient = new WebClient())
{
ConsoleHelper.WriteLineColorBlue("Downloading photo ...");
IDownloader downloader = new Downloader(webClient);
downloader.StartDownloadFile(allPhotoList);
}
Console.WriteLine("Done!");
});
}
public void RegisterObjectResolver()
{
var resolver = new Mock <ArgumentResolver <object> >();
var obj = new object();
resolver.Setup(_ => _.CanResolve(It.IsAny <ArgumentModel>())).Returns(true);
resolver.Setup(_ => _.Resolve(It.IsAny <ArgumentModel>())).Returns(obj);
var factory = new DefaultArgumentResolverFactory();
var dummyArg = new ArgumentModel();
factory.Register(resolver.Object);
var createdResolver_1 = factory.CreateResolver(typeof(object));
var createdResolver_2 = factory.CreateResolver <object>();
Assert.NotNull(createdResolver_1);
Assert.NotNull(createdResolver_2);
Assert.True(createdResolver_1.CanResolve(dummyArg));
Assert.True(createdResolver_2.CanResolve(dummyArg));
Assert.Same(obj, createdResolver_1.Resolve(dummyArg));
Assert.Same(obj, createdResolver_2.Resolve(dummyArg));
}
private async void AddArgument_ClickAsync(object sender, EventArgs e)
{
if (HasEmptyFields())
{
MessageBox.Show("пустое значение", "ошибка ввода", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
else
{
var model = new ArgumentModel {
Description = ArgumentsBox.Text
};
try
{
await argumentService.AddEntryAsync(model);
}
catch (Exception)
{
MessageBox.Show("Ошибка добавления данных", "добавление записи", MessageBoxButtons.OK, MessageBoxIcon.Error);
Close();
}
MessageBox.Show("данные добавлены", "добавление записи", MessageBoxButtons.OK, MessageBoxIcon.Information);
Close();
}
}
public void expect_exception_when_there_is_no_lender_offer()
{
QuoteFinder quoteFinder = new QuoteFinder(36);
var emptyMarketData = new List <MarketData>();
var externalArgument = new ArgumentModel()
{
RequestedAmount = 1000
};
Exception exception = null;
try
{
quoteFinder.GetQuote(externalArgument, emptyMarketData);
}
catch (Exception e)
{
exception = e;
}
var isTrue = CheckException(exception, ErrorMessage.ThereIsNoAvailableOffer);
Assert.IsTrue(isTrue);
}
private bool TryGetDefaultValue(ArgumentModel arg, ParseArguments parseArgs, out object defaultValue)
{
defaultValue = arg.DefaultValue;
if (defaultValue == null)
{
if (arg.Optional)
{
defaultValue = arg.Type.GetEmptyValue();
return(true);
}
return(false);
}
switch (defaultValue)
{
case string stringValue:
parseArgs.Values = new[] { stringValue };
parseArgs.ValuesOffset = 0;
defaultValue = ParseValue(arg, parseArgs, out var _);
break;
case string[] stringValues when stringValues.Length > 0:
parseArgs.Values = stringValues;
parseArgs.ValuesOffset = 0;
defaultValue = ParseValue(arg, parseArgs, out var _);
break;
default:
defaultValue = CastDefaultValue(arg, defaultValue);
break;
}
return(true);
}
public void expect_exception_when_requested_amount_is_out_of_range()
{
QuoteFinder quoteFinder = new QuoteFinder(36);
var emptyMarketData = new List <MarketData>();
var externalArgument = new ArgumentModel()
{
RequestedAmount = 500
};
Exception exception = null;
try
{
quoteFinder.GetQuote(externalArgument, emptyMarketData);
}
catch (Exception e)
{
exception = e;
}
var isTrue = CheckException(exception, ErrorMessage.RequestedAmountOutOfRange);
Assert.IsTrue(isTrue);
}
public void expect_exception_when_requested_amount_is_not_multiple_of_100()
{
QuoteFinder quoteFinder = new QuoteFinder(36);
var emptyMarketData = new List <MarketData>();
var externalArgument = new ArgumentModel()
{
RequestedAmount = 1010
};
Exception exception = null;
try
{
quoteFinder.GetQuote(externalArgument, emptyMarketData);
}
catch (Exception e)
{
exception = e;
}
var isTrue = CheckException(exception, ErrorMessage.RequestedAmountIsNotMultipleOf100);
Assert.IsTrue(isTrue);
}
public ArgumentModel List(int categoryId, int pageSize, int pageNumber)
{
var model = new ArgumentModel();
//SEO
ViewBag.description = _categoryService.GetById(categoryId).description;
//List
var excludeRecords = (pageSize * pageNumber) - pageSize;
var total = _argumentService.GetByCategoryId(categoryId).Count;
model.sectionName = _categoryService.GetById(categoryId).name;
model.pageSize = pageSize;
model.pageTotal = Math.Ceiling((double)total / pageSize);
model.arguments = _argumentService.GetByCategoryId(categoryId);
foreach (var argument in model.arguments)
{
model.argumentsDisplay.Add(new ArgumentDisplay()
{
id = argument.id,
slug = _slugService.GetById(argument.slugId).name,
coverImage = _photoService.GetById(argument.coverImageId).path,
title = argument.name
});
}
return(model);
}
public void TestResolve(string expected, string key, string value)
{
var resolver = new StringResolver();
var model = new ArgumentModel(key, value);
Assert.Equal(expected, resolver.Resolve(model));
}
public void TestCanResolve(bool expected, string key, string value)
{
var resolver = new IntResolver();
var model = new ArgumentModel(key, value);
Assert.Equal(expected, resolver.CanResolve(model));
}
public IActionResult All(int pageSize, int pageNumber)
{
var model = new ArgumentModel();
//SEO
ViewBag.description = "Categorie disponibili";
//List
var excludeRecords = (pageSize * pageNumber) - pageSize;
var total = _argumentService.GetAll().Count;
model.sectionName = "Lista Categorie";
model.pageSize = pageSize;
model.pageTotal = Math.Ceiling((double)total / pageSize);
model.arguments = _argumentService.GetAll();
foreach (var argument in model.arguments)
{
model.argumentsDisplay.Add(new ArgumentDisplay()
{
id = argument.id,
slug = _slugService.GetById(argument.slugId).name,
coverImage = _photoService.GetById(argument.coverImageId).path,
title = argument.name,
descrizione = argument.description.Length > 200 ? argument.description.Substring(0, 200) : argument.description
});
}
return(View(model));
}
public void TestResolve(TestEnum expected, string key, string value)
{
var resolver = ServiceProvider.GetRequiredService <IArgumentResolver <TestEnum> >();
var model = new ArgumentModel(key, value);
Assert.Equal(expected, resolver.Resolve(model));
}
private object CastDefaultValue(ArgumentModel arg, object value)
{
var argType = arg.Type;
var valueType = value.GetType();
bool isArgCollection = _collectionCtorProvider.TryGetConstructor(argType, out var argColCtor);
bool isValueCollection = _collectionCtorProvider.TryGetConstructor(valueType, out var valueColCtor);
if (isArgCollection && isValueCollection)
{
var argElemType = argColCtor.GetElementType(argType);
var valueElemType = valueColCtor.GetElementType(valueType);
if (!argElemType.GetTypeInfo().IsAssignableFrom(valueElemType))
{
throw new ArgumentParseException(arg,
String.Format(CastErrorMessagTemplate, valueElemType.Name, argElemType.Name));
}
return(CopyCollection(valueColCtor, value, argColCtor, argType));
}
if (argType.GetTypeInfo().IsAssignableFrom(valueType))
{
return(value);
}
throw new ArgumentParseException(arg,
String.Format(CastErrorMessagTemplate, valueType.Name, argType.Name));
}
/// <summary>
/// Get Result
/// </summary>
/// <param name="argumentModel"></param>
/// <param name="fetchMarketData"></param>
/// <returns></returns>
public MarketRateOutputModel GetQuote(ArgumentModel argumentModel, List <MarketData> fetchMarketData)
{
// validate loand amount
ValidateRequestedAmount(argumentModel.RequestedAmount, fetchMarketData);
// find possible quote
var possibleQuotes = FindPossibleQuotes(argumentModel.RequestedAmount, fetchMarketData);
// check present quotes
if (possibleQuotes.Count == 0)
{
throw new Exception(ErrorMessage.ThereIsNoAvailableOffer);
}
// assing default values
var result = new MarketRateOutputModel
{
Rate = 0,
MonthlyPayment = 0,
RequstedAmount = argumentModel.RequestedAmount,
TotalPayment = 0
};
// combine selected quote
foreach (var possibleQuote in possibleQuotes)
{
result.Rate += (double)(possibleQuote.RequstedAmount * (decimal)possibleQuote.Rate) /
(double)result.RequstedAmount;
result.MonthlyPayment += possibleQuote.MonthlyPayment;
result.TotalPayment += possibleQuote.TotalPayment;
}
return(result);
}
public void TestResolve(double expected, string value)
{
var resolver = ServiceProvider.GetRequiredService <IArgumentResolver <double> >();
var model = new ArgumentModel("key", value);
Assert.Equal(expected, resolver.Resolve(model));
}
public void TestResolve(TestEnum expected, string key, string value)
{
var resolver = new EnumResolver <TestEnum>();
var model = new ArgumentModel(key, value);
Assert.Equal(expected, resolver.Resolve(model));
}
public override void AppendMissing(ArgumentModel argSource, ProcedureModel source, ProcedureModel target)
{
if (_buckets.Add(source))
{
var d = base.AppendDifference(source, false);
Append(source, d, target);
}
}
public override void AppendChange(ArgumentModel argSource, ArgumentModel argTarget, string propertyName, ProcedureModel source, ProcedureModel target)
{
if (_buckets.Add(source))
{
var d = base.AppendDifference(source, target, propertyName);
Append(source, d, target);
}
}
public void TestResolve(string expected, string key, string value)
{
var resolver = ServiceProvider.GetRequiredService <IArgumentResolver <MyTestType> >();
var model = new ArgumentModel(key, value);
Assert.Equal(expected, resolver.Resolve(model).Result);
Assert.Equal(expected, resolver.Resolve(value).Result);
}
public void TestCanResolveWithWrongCtor(bool expected, string key, string value)
{
var resolver = ServiceProvider.GetRequiredService <IArgumentResolver <MyTestType2> >();
var model = new ArgumentModel(key, value);
Assert.Equal(expected, resolver.CanResolve(model));
Assert.Equal(expected, resolver.CanResolve(value));
}
public override bool CanResolve(ArgumentModel model)
{
if (!model.HasValue)
{
return(false);
}
return(TryResolve(model, out _));
}
public async Task <Argument> AddEntryAsync(ArgumentModel model)
{
var addedArgument = dbContext.Arguments.Add(new Argument {
Description = model.Description
});
await dbContext.SaveChangesAsync();
return(addedArgument);
}
public ArgumentModel GetByCategoryId(int id, int level = 1, int idPadre = 0)
{
var model = new ArgumentModel();
model.arguments = _argumentService.GetByCategoryId(id, level, idPadre);
model.posts = _postService.GetAllByCategoryAndArgumentId(id, idPadre);
return(model);
}
private static void SerializeArgument(
Utf8JsonWriter writer,
ArgumentModel argument)
{
writer.WriteStartObject();
writer.WriteString("name", argument.Name);
writer.WriteString("type", argument.Type.Print());
if (argument.DefaultValue is { })
