public void Should_return_unset_if_field_hidden()
{
var source = 123;
var result = ValueConverters.ExcludeHidden()(source, stringField.Hide());
Assert.Same(Value.Unset, result);
}
public void Should_return_same_value_if_decoding_null_value()
{
var source = JsonValue.Null;
var result = ValueConverters.DecodeJson(TestUtils.DefaultSerializer)(source, jsonField);
Assert.Same(source, result);
}
public void Should_decode_json_values()
{
var source = "e30=";
var result = ValueConverters.DecodeJson()(source, jsonField);
Assert.Equal(new JObject(), result);
}
public void Should_return_same_value_if_decoding_null_value()
{
var source = JValue.CreateNull();
var result = ValueConverters.DecodeJson()(source, jsonField);
Assert.Same(source, result);
}
public void Should_return_same_value_if_encoding_non_json_field()
{
var source = (JToken)"NO-JSON";
var result = ValueConverters.EncodeJson()(source, stringField);
Assert.Same(source, result);
}
public void Should_encode_json_value()
{
var source = new JObject();
var result = ValueConverters.EncodeJson()(source, jsonField);
Assert.Equal("e30=", result);
}
public void Should_return_null_if_field_has_wrong_type()
{
var source = JsonValue.Create("invalid");
var result = ValueConverters.ExcludeChangedTypes(TestUtils.DefaultSerializer)(source, numberField);
Assert.Null(result);
}
public void Should_return_same_value_if_decoding_non_json_field()
{
var source = JValue.CreateNull();
var result = ValueConverters.EncodeJson()(source, stringField);
Assert.Same(source, result);
}
public void Should_return_unset_if_field_has_wrong_type()
{
var source = "invalid";
var result = ValueConverters.ExcludeChangedTypes()(source, numberField);
Assert.Same(Value.Unset, result);
}
public static NamedContentData FromMongoModel(this IdContentData result, Schema schema, IJsonSerializer serializer)
{
return(result.ConvertId2Name(schema,
FieldConverters.ForValues(
ValueConverters.DecodeJson(serializer)),
FieldConverters.ForNestedId2Name(
ValueConverters.DecodeJson(serializer))));
}
public void Should_return_same_value_if_encoding_non_json_field()
{
var source = JsonValue.Create("NO-JSON");
var result = ValueConverters.EncodeJson(TestUtils.DefaultSerializer)(source, stringField);
Assert.Same(source, result);
}
public void Should_decode_json_values()
{
var source = JsonValue.Create("e30=");
var result = ValueConverters.DecodeJson(TestUtils.DefaultSerializer)(source, jsonField);
Assert.Equal(JsonValue.Object(), result);
}
public static IdContentData ToMongoModel(this NamedContentData result, Schema schema)
{
return(result.ConvertName2Id(schema,
FieldConverters.ForValues(
ValueConverters.EncodeJson()),
FieldConverters.ForNestedName2Id(
ValueConverters.EncodeJson())));
}
public void Should_return_null_if_field_hidden()
{
var source = JsonValue.Create(123);
var result = ValueConverters.ExcludeHidden(source, stringField.Hide());
Assert.Null(result);
}
public void TryGetByTargetTypeReturnsTrueWhenThereIsAMatch()
{
var valueConverters = new ValueConverters()
.Add(typeof(Bar), value => new Bar(int.Parse(value)))
.Add(typeof(Baz), ParseBaz);
Assert.True(valueConverters.TryGet(typeof(Bar), out var convertBar));
Assert.True(valueConverters.TryGet(typeof(Baz), out var convertBaz));
}
public void TryGetByDeclaringTypeAndMemberNameReturnsTrueWhenThereIsAMatch()
{
var valueConverters = new ValueConverters()
.Add(typeof(Foo), "bar", value => new Bar(int.Parse(value)))
.Add(typeof(Foo), "baz", ParseBaz);
Assert.True(valueConverters.TryGet(typeof(Foo), "bar", out var convertBar));
Assert.True(valueConverters.TryGet(typeof(Foo), "baz", out var convertBaz));
}
public static NamedContentData FromMongoModel(this IdContentData result, Schema schema, List <Guid> deletedIds)
{
return(result.ConvertId2Name(schema,
FieldConverters.ForValues(
ValueConverters.DecodeJson(),
ValueReferencesConverter.CleanReferences(deletedIds)),
FieldConverters.ForNestedId2Name(
ValueConverters.DecodeJson(),
ValueReferencesConverter.CleanReferences(deletedIds))));
}
public MapperContext Clone()
{
var context = new MapperContext();
Naming.CloneTo(context.Naming);
UserConfigurations.CloneTo(context.UserConfigurations);
ValueConverters.CloneTo(context.ValueConverters);
return(context);
}
private static void AddLoggerFromLoggerFactory(this IServiceCollection services, string rockLibLoggerName,
DefaultTypes defaultTypes, ValueConverters valueConverters)
{
services.AddSingleton <ILogProcessor, BackgroundLogProcessor>();
services.AddTransient(serviceProvider =>
{
var resolver = new Resolver(t => serviceProvider.GetService(t));
return(LoggerFactory.Create(rockLibLoggerName, defaultTypes, valueConverters, resolver, reloadOnConfigChange: false));
});
}
public void GivenReturnTypeOfFunctionIsNotAssignableToTargetType_ThrowsArgumentException()
{
var valueConverters = new ValueConverters();
var actual = Assert.Throws <ArgumentException>(() => valueConverters.Add(typeof(Bar), value => new Qux()));
#if DEBUG
var expected = Exceptions.ReturnTypeOfConvertFuncIsNotAssignableToTargetType(typeof(Bar), typeof(Qux));
Assert.Equal(expected.Message, actual.Message);
#endif
}
public void GivenNoMatchingMembers_ThrowsArgumentException()
{
var valueConverters = new ValueConverters();
var actual = Assert.Throws <ArgumentException>(() => valueConverters.Add(typeof(Foo), "qux", value => new Bar(int.Parse(value))));
#if DEBUG
var expected = Exceptions.NoMatchingMembers(typeof(Foo), "qux");
Assert.Equal(expected.Message, actual.Message);
#endif
}
/// <summary>
/// Creates an instance of the <see cref="ISender"/> interface identified by
/// its name from the 'senders' section of the <paramref name="configuration"/> parameter.
/// </summary>
/// <param name="configuration">
/// A configuration object that contains the specified sender in its 'senders' section.
/// </param>
/// <param name="name">The name that identifies which sender from configuration to create.</param>
/// <param name="defaultTypes">
/// An object that defines the default types to be used when a type is not explicitly specified by a
/// configuration section.
/// </param>
/// <param name="valueConverters">
/// An object that defines custom converter functions that are used to convert string configuration
/// values to a target type.
/// </param>
/// <param name="resolver">
/// An object that can retrieve constructor parameter values that are not found in configuration. This
/// object is an adapter for dependency injection containers, such as Ninject, Unity, Autofac, or
/// StructureMap. Consider using the <see cref="Resolver"/> class for this parameter, as it supports
/// most depenedency injection containers.
/// </param>
/// <param name="reloadOnConfigChange">
/// Whether to create an instance of <see cref="ISender"/> that automatically reloads itself when its
/// configuration changes. Default is true.
/// </param>
/// <returns>A new instance of the <see cref="ISender"/> interface.</returns>
public static ISender CreateSender(this IConfiguration configuration, string name,
DefaultTypes defaultTypes = null, ValueConverters valueConverters = null,
IResolver resolver = null, bool reloadOnConfigChange = true)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
return(configuration.CreateScenario <ISender>("senders", name, defaultTypes, valueConverters, resolver, reloadOnConfigChange));
}
public void Should_not_convert_asset_ids_if_field_name_does_not_match(string path)
{
var field = Fields.Assets(1, "assets", Partitioning.Invariant);
var source = JsonValue.Array(id1, id2);
var expected = source;
var result = ValueConverters.ResolveAssetUrls(appId, HashSet.Of(path), urlGenerator)(source, field, null);
Assert.Equal(expected, result);
}
public List <RepaymentView> ReadRepayment(TellerMobileDeposit tellerDeposit)
{
List <RepaymentView> repayments = new List <RepaymentView>();
var loanproductNames = loanProductsMgr.GetLoanCodes(db, false).ToList();
var investnames = investMgr.InvestmentsCodes(db).ToList();
String ledger = tellerDeposit.ProductCode;
if (ledger.Substring(0, 1) == "0")
{
ledger = "SAVINGS";
}
else
{
ledger = ledger.Substring(0, 1).In("A", "L") ? "LOANS" : "INVESTMENTS";
}
string productName = tellerDeposit.ProductCode;
switch (ledger)
{
case "LOANS":
if (loanproductNames.FirstOrDefault(x => x.LoanCode == tellerDeposit.ProductCode) != null)
{
productName = ValueConverters.ConvertNullToEmptyString(
loanproductNames.FirstOrDefault(x => x.LoanCode == tellerDeposit.ProductCode).LoanName.ToString());
}
break;
case "INVESTMENTS":
if (investnames.FirstOrDefault(x => x.InvestmentCode == tellerDeposit.ProductCode) != null)
{
productName = ValueConverters.ConvertNullToEmptyString(
investnames.FirstOrDefault(x => x.InvestmentCode == tellerDeposit.ProductCode).InvestmentName.ToString());
}
break;
default:
break;
}
repayments.Add(new RepaymentView
{
CustomerNo = tellerDeposit.CustomerNo,
ProductCode = tellerDeposit.ProductCode,
ProductName = productName,
Amount = ValueConverters.ConvertDecimaltoDouble(tellerDeposit.TrxAmount),
Ledger = ledger,
Section = 1
});
return(repayments);
}
public void Validate_Teller_Transaction(string transactionType, string tellerAccount, double transactionAmount, bool interTellerTransaction = false)
{
if (ValueConverters.IsStringEmpty(tellerAccount))
{
_validationDictionary.AddError("TransactionAmount", "You do not have a Valid Teller Account !");
_validationDictionary.AddError("PaidTo", "You do not have a Valid Teller Account !");
_validationDictionary.AddError("CustomerNo", "You do not have a Valid Teller Account !");
return;
}
if (transactionAmount <= 0.00)
{
_validationDictionary.AddError("TransactionAmount", "Transaction Amount is Zero/Negative");
_validationDictionary.AddError("GlCredit", "Transaction Amount is Zero/Negative");
_validationDictionary.AddError("CustomerNo", "Transaction Amount is Zero/Negative");
_validationDictionary.AddError("PaidTo", "Transaction Amount is Zero/Negative");
}
double tellerBalance = TellerAccountBalance(tellerAccount);
Company companyDetails = companyManager.GetCompanyDetails();
if (interTellerTransaction || transactionType.ToUpper().In("MISCPAYMENTS", "AGENCYWITHDRAWAL", "CASHWITHDRAWAL"))
{
if (tellerBalance - transactionAmount < 0)
{
_validationDictionary.AddError("TransactionAmount", "You Have Insufficient Funds for this Transaction !");
_validationDictionary.AddError("CustomerNo", "You Have Insufficient Funds for this Transaction !");
_validationDictionary.AddError("TrType", "You Have Insufficient Funds for this Transaction !");
_validationDictionary.AddError("PaidTo", "You Have Insufficient Funds for this Transaction !");
}
}
else
{
if (!transactionType.ToUpper().In("CHEQUEDEPOSIT"))
{
if ((decimal)tellerBalance > companyDetails.TellerCashInsuranceLimit)
{
if (transactionType == "PRODUCTREPAYMENTS")
{
_validationDictionary.AddError("customerDetails.CustomerNo", "Insurance Limit Has been Exceeded !");
}
else
{
_validationDictionary.AddError("TransactionAmount", "Insurance Limit Has been Exceeded !");
_validationDictionary.AddError("CustomerNo", "Insurance Limit Has been Exceeded !");
_validationDictionary.AddError("PaidTo", "You Have Insufficient Funds for this Transaction !");
}
}
}
}
TellerDayClosed(tellerAccount);
}
public void Should_not_convert_nested_asset_ids_when_field_name_does_not_match(string path)
{
var field = Fields.Array(1, "parent", Partitioning.Invariant, Fields.Assets(11, "assets"));
var source = JsonValue.Array(id1, id2);
var expected = source;
var result = ValueConverters.ResolveAssetUrls(HashSet.Of(path), urlGenerator)(source, field.Fields[0], field);
Assert.Equal(expected, result);
}
public void Should_convert_asset_ids_to_urls(string path)
{
var field = Fields.Assets(1, "assets", Partitioning.Invariant);
var source = JsonValue.Array(id1, id2);
var expected = JsonValue.Array($"url/to/{id1}", $"url/to/{id2}");
var result = ValueConverters.ResolveAssetUrls(HashSet.Of(path), urlGenerator)(source, field);
Assert.Equal(expected, result);
}
private IEnumerable <FieldConverter> GenerateConverters(Context context, ValueConverter?cleanReferences)
{
if (!context.IsFrontendClient)
{
yield return(excludedHiddenField);
yield return(excludedHiddenValue);
}
yield return(excludedChangedField);
yield return(excludedChangedValue);
if (cleanReferences != null)
{
yield return(FieldConverters.ForValues(cleanReferences));
yield return(FieldConverters.ForValues(ValueConverters.ForNested(cleanReferences)));
}
yield return(FieldConverters.ResolveInvariant(context.App.Languages));
yield return(FieldConverters.ResolveLanguages(context.App.Languages));
if (!context.IsFrontendClient)
{
if (context.ShouldResolveLanguages())
{
yield return(FieldConverters.ResolveFallbackLanguages(context.App.Languages));
}
var languages = context.Languages();
if (languages.Any())
{
yield return(FieldConverters.FilterLanguages(context.App.Languages, languages));
}
var assetUrls = context.AssetUrls().ToList();
if (assetUrls.Count > 0)
{
var appId = context.App.NamedId();
var resolveAssetUrls = ValueConverters.ResolveAssetUrls(appId, assetUrls, urlGenerator);
yield return(FieldConverters.ForValues(resolveAssetUrls));
yield return(FieldConverters.ForValues(ValueConverters.ForNested(resolveAssetUrls)));
}
}
}
public ConvertData(IUrlGenerator urlGenerator, IJsonSerializer jsonSerializer,
IAssetRepository assetRepository, IContentRepository contentRepository)
{
this.urlGenerator = urlGenerator;
this.assetRepository = assetRepository;
this.contentRepository = contentRepository;
excludedChangedField = FieldConverters.ExcludeChangedTypes(jsonSerializer);
excludedChangedValue = FieldConverters.ForValues(ValueConverters.ExcludeChangedTypes(jsonSerializer));
excludedHiddenField = FieldConverters.ExcludeHidden;
excludedHiddenValue = FieldConverters.ForValues(ValueConverters.ExcludeHidden);
}
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
base.OnConfiguring(optionsBuilder);
optionsBuilder.UseSqlServer(ConnectionString);
optionsBuilder.UseLoggerFactory(Logger);
// Magically make queries faster!
optionsBuilder.AddInterceptors(new SpeedInterceptor());
// Always use bigint for TimeSpan columns.
ValueConverters.Add(typeof(TimeSpan), new TimeSpanToTicksConverter());
}
