public void test_THAT_daterangesoverlap_operation_IS_rendered_to_caml_properly()
{
// arrange
var startFieldRefOperandStub = MockRepository.GenerateStub <FieldRefOperand>("");
var stopFieldRefOperandStub = MockRepository.GenerateStub <FieldRefOperand>("");
var recurrenceFieldRefOperandStub = MockRepository.GenerateStub <FieldRefOperand>("");
var dateTimevalueOperandStub = MockRepository.GenerateStub <TextValueOperand>("");
startFieldRefOperandStub.Stub(o => o.ToCaml()).Return(new XElement("startFieldRefOperandStub"));
stopFieldRefOperandStub.Stub(o => o.ToCaml()).Return(new XElement("stopFieldRefOperandStub"));
recurrenceFieldRefOperandStub.Stub(o => o.ToCaml()).Return(new XElement("recurrenceFieldRefOperandStub"));
dateTimevalueOperandStub.Stub(o => o.ToCaml()).Return(new XElement("dateTimevalueOperandStub"));
var resultBuilder = new OperationResultBuilder();
var operation = new DateRangesOverlapOperation(resultBuilder,
startFieldRefOperandStub, stopFieldRefOperandStub, recurrenceFieldRefOperandStub, dateTimevalueOperandStub);
// act
var caml = operation.ToResult().ToString();
// assert
const string expected =
@"<DateRangesOverlap>
<startFieldRefOperandStub />
<stopFieldRefOperandStub />
<recurrenceFieldRefOperandStub />
<dateTimevalueOperandStub />
</DateRangesOverlap>";
Assert.That(caml, Is.EqualTo(expected).Using(new CamlComparer()));
}
private async Task <IOperationResult <T> > ParseInternalAsync(
Stream stream,
CancellationToken cancellationToken)
{
using (JsonDocument document = await JsonDocument.ParseAsync(stream)
.ConfigureAwait(false))
{
var builder = OperationResultBuilder.New <T>();
if (document.RootElement.TryGetProperty(
_data, out JsonElement data))
{
builder.SetData(ParserData(data));
}
if (document.RootElement.TryGetProperty(
_error, out JsonElement errors))
{
builder.AddErrors(ParseErrors(errors));
}
if (TryParseExtensions(
document.RootElement,
out IReadOnlyDictionary <string, object?>?extensions))
{
builder.AddExtensions(extensions !);
}
return(builder.Build());
}
}
public async Task <OperationResult <UserDataResponse> > Handle(UpdateUserDataRequest message, CancellationToken cancellationToken)
{
using (var context = _companyContextFactory())
using (var transaction = context.Database.BeginTransaction())
{
try
{
var userEntity = await context.Users.SingleAsync(x => x.Id == message.Id, cancellationToken)
.ConfigureAwait(false);
_mapper.Map(message, userEntity);
await context.SaveChangesAsync(cancellationToken)
.ConfigureAwait(false);
transaction.Commit();
var response = _mapper.Map <UserDataResponse>(userEntity);
return(OperationResultBuilder.CreateSuccess(response));
}
catch (TaskCanceledException)
{
transaction.Rollback();
return(OperationResultBuilder.CreateFailure <UserDataResponse>(Resources.Exception_Update_Canceled));
}
}
}
private async Task <IOperationResult <T> > ParseInternalAsync(
Stream stream,
CancellationToken cancellationToken)
{
using (JsonDocument document = await JsonDocument.ParseAsync(stream)
.ConfigureAwait(false))
{
var builder = OperationResultBuilder.New <T>();
if (document.RootElement.TryGetProperty(
_data, out JsonElement data))
{
builder.SetData(ParserData(data));
}
if (document.RootElement.TryGetProperty(
_error, out JsonElement errors))
{
// TODO : add error deserialization
}
if (document.RootElement.TryGetProperty(
_extensions, out JsonElement extensions))
{
// TODO : add extension deserialization
}
return(builder.Build());
}
}
public void test_WHEN_single_xelement_passed_THEN_xelement_operation_result_is_created()
{
var operationResultBuilder = new OperationResultBuilder();
var result = operationResultBuilder.CreateResult(new XElement("foo"));
Assert.That(result, Is.InstanceOf <XElementOperationResult>());
}
public void test_WHEN_multiple_xelements_passed_THEN_xelement_array_operation_result_is_created()
{
var operationResultBuilder = new OperationResultBuilder();
var result = operationResultBuilder.CreateResult(new[] { new XElement("foo"), new XElement("foo") });
Assert.That(result, Is.InstanceOf <XElementArrayOperationResult>());
}
public void test_THAT_andalso_with_nested_andalso_IS_translated_to_caml_properly()
{
// arrange
var leftEqOperation = MockRepository.GenerateStub <EqOperation>(null, null, null);
var rightEqOperation = MockRepository.GenerateStub <EqOperation>(null, null, null);
var resultBuilder = new OperationResultBuilder();
var leftOperation = new AndAlsoOperation(resultBuilder, leftEqOperation, rightEqOperation);
leftEqOperation.Stub(o => o.ToResult()).Return(xelementResult("Eq1"));
rightEqOperation.Stub(o => o.ToResult()).Return(xelementResult("Eq2"));
var operation = new AndAlsoOperation(resultBuilder, leftOperation, rightEqOperation);
// act
string caml = operation.ToResult().ToString();
// assert
string expected =
@"<And>
<And>
<Eq1 />
<Eq2 />
</And>
<Eq2 />
</And>";
Assert.That(caml, Is.EqualTo(expected).Using(new CamlComparer()));
}
public async Task <OperationResult <UserDataResponse> > Handle(RegisterCustomerRequest message, CancellationToken cancellationToken)
{
var customerEntity = _mapper.Map <CustomerEntity>(message);
using (var context = _companyContextFactory())
using (var transaction = context.Database.BeginTransaction())
{
try
{
var username = message.Username.ToUpper();
var isUnique = !await context.Users.AnyAsync(x => username == x.Username.ToUpper(), cancellationToken)
.ConfigureAwait(false);
if (!isUnique)
{
return(OperationResultBuilder.CreateFailure <UserDataResponse>(Resources.Exception_Registration_Username_Already_Taken));
}
var userEntity = context.Users.Add(customerEntity);
await context.SaveChangesAsync(cancellationToken)
.ConfigureAwait(false);
transaction.Commit();
var response = _mapper.Map <UserDataResponse>(userEntity);
return(OperationResultBuilder.CreateSuccess(response));
}
catch (TaskCanceledException)
{
transaction.Rollback();
return(OperationResultBuilder.CreateFailure <UserDataResponse>(Resources.Exception_Registration_Canceled));
}
}
}
public async Task <OperationResult <UserWalletsDTO> > GetUserWalletsAsync
(Guid userId)
{
var result = new UserWalletsDTO();
var user = _userService.Get(userId);
if (user != null)
{
result.Wallets = _walletRepo
.Get(w => w.UserFK.Equals(user.Id))
.Select(w => new WalletDTO()
{
Currency = w.CurrencyISOCode,
Amount = w.Amount
});
}
else
{
user = await _userService.CreateUserAsync();
}
result.UserId = user.Id;
return(OperationResultBuilder <UserWalletsDTO> .BuildSuccess(result));
}
static SPSearch()
{
// factories setup
var operandBuilder = new OperandBuilder();
var operationResultBuilder = new OperationResultBuilder();
var analyzerFactory = new AnalyzerFactory(operandBuilder, operationResultBuilder);
TranslatorFactory = new TranslatorFactory(analyzerFactory);
}
public async Task <OperationResult <bool> > Handle(VerifyUsernameUniqueRequest message, CancellationToken cancellationToken)
{
using (var context = _companyContextFactory())
{
var username = message.Username.ToUpper();
var isUnique = !await context.Users.AnyAsync(x => username == x.Username.ToUpper(), cancellationToken)
.ConfigureAwait(false);
return(OperationResultBuilder.CreateSuccess(isUnique));
}
}
public async Task <OperationResult <UserWalletsDTO> > ChangeWalletBalanceAsync
(UserWalletBalanceOperationDTO userWallet)
{
if (!userWallet.UserId.HasValue)
{
throw new ArgumentNullException(nameof(userWallet.UserId), "User ID must not be null.");
}
var user = _userService.Get(userWallet.UserId.Value);
if (user == null)
{
user = await _userService.CreateUserAsync();
}
if (!await _currencySrv.IsExists(userWallet.Wallet.Currency))
{
return(OperationResultBuilder <UserWalletsDTO>
.BuildError(null, "Currency does not exist or is not supported."));
}
var wallet = _walletRepo.Data
.FirstOrDefault(w =>
w.UserFK.Equals(user.Id) &&
string.Equals(w.CurrencyISOCode, userWallet.Wallet.Currency, StringComparison.InvariantCultureIgnoreCase));
if (wallet == null)
{
wallet = new Wallet()
{
UserFK = user.Id,
Amount = 0,
CurrencyISOCode = userWallet.Wallet.Currency
};
wallet = await _walletRepo.AddAsync(wallet);
}
wallet.Amount += userWallet.Wallet.Amount;
if (wallet.Amount < 0)
{
return(OperationResultBuilder <UserWalletsDTO> .BuildError(null,
"Operation rejected, insufficient funds."));
}
wallet = await _walletRepo.UpdateAsync(wallet);
return(await GetUserWalletsAsync(user.Id));
}
static Camlex()
{
// factories setup
var operandBuilder = new OperandBuilder();
var operationResultBuilder = new OperationResultBuilder();
var analyzerFactory = new AnalyzerFactory(operandBuilder, operationResultBuilder);
translatorFactory = new TranslatorFactory(analyzerFactory);
// re
var reoperandBuilder = new ReOperandBuilderFromCaml();
var reanalyzerFactory = new ReAnalyzerFromCamlFactory(reoperandBuilder);
retranslatorFactory = new ReTranslatorFromCamlFactory(reanalyzerFactory);
relinkerFactory = new ReLinkerFromCamlFactory();
}
public override IOperationResult ToResult()
{
string result;
if (ValueOperand is TextValueOperand)
{
string value = ((string)ValueOperand.GetValue()).TrimEnd('*').TrimStart('*');
result = string.Format("CONTAINS({0},'\"{1}*\"')", ColumnOperand, value);
}
else
{
result = string.Format("CONTAINS({0},'\"{1}*\"')", ColumnOperand, ValueOperand.GetValue());
}
return(OperationResultBuilder.CreateResult(result));
}
public override IOperationResult ToResult()
{
string result;
if (ValueOperand is TextValueOperand)
{
string value = (string)ValueOperand.GetValue();
result = value.Contains("*")
? string.Format("CONTAINS({0},'\"{1}\"')", ColumnOperand, value)
: string.Format("CONTAINS({0},{1})", ColumnOperand, ValueOperand);
}
else
{
result = string.Format("CONTAINS({0},{1})", ColumnOperand, ValueOperand);
}
return(OperationResultBuilder.CreateResult(result));
}
public async Task <IOperationResult> ExecuteAsync(
IOperation operation,
CancellationToken cancellationToken)
{
if (operation is null)
{
throw new ArgumentNullException(nameof(operation));
}
var resultBuilder = OperationResultBuilder.New(operation.ResultType);
await ExecuteOperationAsync(
operation,
resultBuilder,
cancellationToken)
.ConfigureAwait(false);
return(resultBuilder.Build());
}
public async Task <IOperationResult <T> > ExecuteAsync <T>(
IOperation <T> operation,
CancellationToken cancellationToken)
where T : class
{
if (operation is null)
{
throw new ArgumentNullException(nameof(operation));
}
var resultBuilder = OperationResultBuilder.New <T>();
await ExecuteOperationAsync(
operation,
resultBuilder,
cancellationToken)
.ConfigureAwait(false);
return(resultBuilder.Build());
}
public void test_THAT_operation_IS_rendered_to_caml_properly()
{
// arrange
var fieldRefOperandStub1 = MockRepository.GenerateStub <FieldRefOperand>("");
var fieldRefOperandStub2 = MockRepository.GenerateStub <FieldRefOperand>("");
fieldRefOperandStub1.Stub(o => o.ToCaml()).Return(new XElement("fieldRefOperandStub1"));
fieldRefOperandStub2.Stub(o => o.ToCaml()).Return(new XElement("fieldRefOperandStub2"));
var resultBuilder = new OperationResultBuilder();
var operation = new ArrayOperation(resultBuilder, fieldRefOperandStub1, fieldRefOperandStub2);
// act
string caml = operation.ToResult().ToString();
// assert
string expected =
@"<fieldRefOperandStub1 />
<fieldRefOperandStub2 />";
Assert.That(caml, Is.EqualTo(expected).Using(new CamlComparer()));
}
private OperationMessage DeserializeSubscriptionResultMessage(
GraphQLSocketMessage parsedMessage)
{
if (parsedMessage.Id is null || !parsedMessage.HasPayload)
{
// TODO : resources
throw new InvalidOperationException("Invalid message structure.");
}
if (_subscriptionManager.TryGetSubscription(
parsedMessage.Id,
out ISubscription? subscription))
{
IResultParser parser = subscription !.ResultParser;
OperationResultBuilder resultBuilder =
OperationResultBuilder.New(parser.ResultType);
parser.Parse(parsedMessage.Payload, resultBuilder);
return(new DataResultMessage(parsedMessage.Id, resultBuilder));
}
return(KeepConnectionAliveMessage.Default);
}
public void test_THAT_isnotnull_operation_IS_rendered_to_caml_properly()
{
// arrange
var fieldRefOperandStub = MockRepository.GenerateStub <FieldRefOperand>("");
var valueOperandStub = MockRepository.GenerateStub <IntegerValueOperand>(0);
fieldRefOperandStub.Stub(o => o.ToCaml()).Return(new XElement("fieldRefOperandStub"));
valueOperandStub.Stub(o => o.ToCaml()).Return(new XElement("valueOperandStub"));
var resultBuilder = new OperationResultBuilder();
var operation = new IsNotNullOperation(resultBuilder, fieldRefOperandStub);
// act
string caml = operation.ToResult().ToString();
// assert
string expected =
@"<IsNotNull>
<fieldRefOperandStub />
</IsNotNull>";
Assert.That(caml, Is.EqualTo(expected).Using(new CamlComparer()));
}
public async Task <OperationResult <UserDataResponse> > Handle(GetUserByCredentialsRequest message, CancellationToken cancellationToken)
{
using (var context = _companyContextFactory())
{
var username = message.Username.ToUpper();
var userDb = await context.Users.AsNoTracking()
.SingleOrDefaultAsync(x => username == x.Username.ToUpper(), cancellationToken)
.ConfigureAwait(false);
if (userDb == null)
{
return(OperationResultBuilder.CreateFailure <UserDataResponse>(Resources.Exception_Authorization_Username_Not_Found));
}
if (!_passwordHasher.VerifyPasswordHash(message.Password, userDb.PasswordHash))
{
return(OperationResultBuilder.CreateFailure <UserDataResponse>(Resources.Authorization_Message_Validation_Errors));
}
var response = _mapper.Map <UserDataResponse>(userDb);
return(OperationResultBuilder.CreateSuccess(response));
}
}
public void test_THAT_membership_operation_IS_rendered_to_caml_properly()
{
// arrange
var fieldRefOperandStub = MockRepository.GenerateStub <FieldRefOperand>("");
var membershipTypeStub = MockRepository.GenerateStub <Camlex.MembershipType>();
fieldRefOperandStub.Stub(o => o.ToCaml()).Return(new XElement("fieldRefOperandStub"));
membershipTypeStub.Stub(o => o.ToString()).Return("membershipTypeStub");
var resultBuilder = new OperationResultBuilder();
var operation = new MembershipOpeartion(resultBuilder,
fieldRefOperandStub, membershipTypeStub);
// act
var caml = operation.ToResult().ToString();
// assert
const string expected =
@"<Membership Type=""membershipTypeStub"">
<fieldRefOperandStub />
</Membership>";
Assert.That(caml, Is.EqualTo(expected).Using(new CamlComparer()));
}
public void test_THAT_beginswith_operation_IS_renderedtocaml_properly()
{
// arrange
var fieldRefOperandStub = MockRepository.GenerateStub <FieldRefOperand>("");
var valueOperandStub = MockRepository.GenerateStub <TextValueOperand>("");
fieldRefOperandStub.Stub(o => o.ToCaml()).Return(new XElement("fieldRefOperandStub"));
valueOperandStub.Stub(o => o.ToCaml()).Return(new XElement("valueOperandStub"));
var resultBuilder = new OperationResultBuilder();
var operation = new BeginsWithOperation(resultBuilder, fieldRefOperandStub, valueOperandStub);
// act
var caml = operation.ToResult().ToString();
// assert
const string expected =
@"<BeginsWith>
<fieldRefOperandStub />
<valueOperandStub />
</BeginsWith>";
Assert.That(caml, Is.EqualTo(expected).Using(new CamlComparer()));
}
public ExpenseGroupWorker(IExpenseGroupService expenseGroupService)
{
this.expenseGroupService = expenseGroupService;
this.workerResultBuilder = new OperationResultBuilder <ExpenseGroupDto>();
}
public ExpenseGroupService(IUnitOfWork unitOfwork)
{
this.unitOfwork = unitOfwork;
this.serviceResultBuilder = new OperationResultBuilder <ExpenseGroup>();
}
public async Task <OperationResult <UserWalletsDTO> > ConvertWalletCurrencyAsync
(WalletConversionDTO walletConversion)
{
if (!walletConversion.UserId.HasValue)
{
throw new ArgumentNullException(nameof(walletConversion.UserId), "User ID must not be null.");
}
var user = _userService.Get(walletConversion.UserId.Value);
if (user == null)
{
user = await _userService.CreateUserAsync();
return(OperationResultBuilder <UserWalletsDTO> .BuildError(null,
"New user does not have actual wallets."));
}
if (!await _currencySrv.IsExists(walletConversion.BaseCurrency) ||
!await _currencySrv.IsExists(walletConversion.TargetCurrency))
{
return(OperationResultBuilder <UserWalletsDTO> .BuildError(null,
"Currency does not exist or is not supported."));
}
var baseWallet = _walletRepo.Data
.FirstOrDefault(w =>
w.UserFK.Equals(user.Id) &&
string.Equals(w.CurrencyISOCode, walletConversion.BaseCurrency,
StringComparison.InvariantCultureIgnoreCase));
if (baseWallet == null)
{
return(OperationResultBuilder <UserWalletsDTO> .BuildError(null, "Base wallet does not exist."));
}
var targetWallet = _walletRepo.Data
.FirstOrDefault(w =>
w.UserFK.Equals(user.Id) &&
string.Equals(w.CurrencyISOCode, walletConversion.TargetCurrency,
StringComparison.InvariantCultureIgnoreCase));
if (targetWallet == null)
{
targetWallet = new Wallet()
{
UserFK = user.Id,
CurrencyISOCode = walletConversion.TargetCurrency
};
await _walletRepo.AddAsync(targetWallet);
}
var conversionRate = await _currencySrv.GetConversionRate
(walletConversion.BaseCurrency, walletConversion.TargetCurrency);
var targetCurrencyAmount = walletConversion.Amount * conversionRate;
baseWallet.Amount -= walletConversion.Amount;
targetWallet.Amount += targetCurrencyAmount;
await _walletRepo.UpdateAsync(new[] { baseWallet, targetWallet });
return(await GetUserWalletsAsync(user.Id));
}
