//TODO need to have validation logic here (or on PlayedGame similar to what is on NewlyCompletedGame)
public PlayedGame CreatePlayedGame(NewlyCompletedGame newlyCompletedGame, TransactionSource transactionSource, ApplicationUser currentUser)
{
GameDefinition gameDefinition = dataContext.FindById <GameDefinition>(newlyCompletedGame.GameDefinitionId);
securedEntityValidatorForGameDefinition.ValidateAccess(gameDefinition, currentUser, typeof(GameDefinition), newlyCompletedGame.GameDefinitionId);
this.ValidateAccessToPlayers(newlyCompletedGame, currentUser);
List <PlayerGameResult> playerGameResults = TransformNewlyCompletedGamePlayerRanksToPlayerGameResults(newlyCompletedGame);
PlayedGame playedGame = TransformNewlyCompletedGameIntoPlayedGame(
newlyCompletedGame,
currentUser.CurrentGamingGroupId,
currentUser.Id,
playerGameResults);
dataContext.Save(playedGame, currentUser);
playedGameTracker.TrackPlayedGame(currentUser, transactionSource);
foreach (PlayerGameResult result in playerGameResults)
{
nemesisRecalculator.RecalculateNemesis(result.PlayerId, currentUser);
}
championRecalculator.RecalculateChampion(playedGame.GameDefinitionId, currentUser);
return(playedGame);
}
public static TransactionSourceModel FromEntity(TransactionSource transactionSource)
{
var transactionSourceModel = new TransactionSourceModel(transactionSource.Id);
transactionSourceModel.MapFromEntity(transactionSource);
return(transactionSourceModel);
}
public Context()
{
StepDelay = TimeSpan.FromMilliseconds(20);
TransactionSource = Substitute.For <ITxSource>();
BlockchainProcessor = Substitute.For <IBlockchainProcessor>();
Sealer = Substitute.For <ISealer>();
BlockTree = Substitute.For <IBlockTree>();
BlockProcessingQueue = Substitute.For <IBlockProcessingQueue>();
StateProvider = Substitute.For <IStateProvider>();
Timestamper = Substitute.For <ITimestamper>();
AuRaStepCalculator = Substitute.For <IAuRaStepCalculator>();
NodeAddress = TestItem.AddressA;
TransactionSource.GetTransactions(Arg.Any <BlockHeader>(), Arg.Any <long>()).Returns(Array.Empty <Transaction>());
Sealer.CanSeal(Arg.Any <long>(), Arg.Any <Keccak>()).Returns(true);
Sealer.SealBlock(Arg.Any <Block>(), Arg.Any <CancellationToken>()).Returns(c => Task.FromResult(c.Arg <Block>()));
Sealer.Address.Returns(TestItem.AddressA);
BlockProcessingQueue.IsEmpty.Returns(true);
AuRaStepCalculator.TimeToNextStep.Returns(StepDelay);
BlockTree.BestKnownNumber.Returns(1);
BlockTree.Head.Returns(Build.A.Block.WithHeader(Build.A.BlockHeader.WithAura(10, Array.Empty <byte>()).TestObject).TestObject);
BlockchainProcessor.Process(Arg.Any <Block>(), ProcessingOptions.ProducingBlock, Arg.Any <IBlockTracer>()).Returns(returnThis: c =>
{
Block block = c.Arg <Block>();
block.TrySetTransactions(TransactionSource.GetTransactions(BlockTree.Head !.Header, block.GasLimit).ToArray());
return(block);
});
//TODO need to have validation logic here (or on PlayedGame similar to what is on NewlyCompletedGame)
public PlayedGame CreatePlayedGame(NewlyCompletedGame newlyCompletedGame, TransactionSource transactionSource, ApplicationUser currentUser)
{
if (newlyCompletedGame.GamingGroupId.HasValue && newlyCompletedGame.GamingGroupId != currentUser.CurrentGamingGroupId)
{
_securedEntityValidator.RetrieveAndValidateAccess<GamingGroup>(newlyCompletedGame.GamingGroupId.Value, currentUser);
}
var gameDefinition = _securedEntityValidator.RetrieveAndValidateAccess<GameDefinition>(newlyCompletedGame.GameDefinitionId, currentUser);
_linkedPlayedGameValidator.Validate(newlyCompletedGame);
var gamingGroupId = newlyCompletedGame.GamingGroupId ?? currentUser.CurrentGamingGroupId;
ValidateAccessToPlayers(newlyCompletedGame.PlayerRanks, gamingGroupId, currentUser);
var playerGameResults = MakePlayerGameResults(newlyCompletedGame, gameDefinition.BoardGameGeekGameDefinitionId);
var playedGame = TransformNewlyCompletedGameIntoPlayedGame(
newlyCompletedGame,
gamingGroupId,
currentUser.Id,
playerGameResults);
playedGame = _dataContext.Save(playedGame, currentUser);
CreateApplicationLinkages(newlyCompletedGame.ApplicationLinkages, playedGame.Id);
DoPostSaveStuff(transactionSource, currentUser, playedGame.Id, playedGame.GameDefinitionId, playerGameResults);
return playedGame;
}
public virtual NewlyCreatedGamingGroupResult CreateNewGamingGroup(
string gamingGroupName,
TransactionSource registrationSource,
ApplicationUser currentUser)
{
ValidateGamingGroupName(gamingGroupName);
var gamingGroup = new GamingGroup()
{
OwningUserId = currentUser.Id,
Name = gamingGroupName
};
var newlyCreatedGamingGroupResult = new NewlyCreatedGamingGroupResult();
var newGamingGroup = dataContext.Save<GamingGroup>(gamingGroup, currentUser);
newlyCreatedGamingGroupResult.NewlyCreatedGamingGroup = newGamingGroup;
//commit changes since we'll need the GamingGroup.Id
dataContext.CommitAllChanges();
var newlyCreatedPlayer = this.AssociateUserWithGamingGroup(currentUser, newGamingGroup);
newlyCreatedGamingGroupResult.NewlyCreatedPlayer = newlyCreatedPlayer;
new Task(() => eventTracker.TrackGamingGroupCreation(registrationSource)).Start();
return newlyCreatedGamingGroupResult;
}
public virtual NewlyCreatedGamingGroupResult CreateNewGamingGroup(
string gamingGroupName,
TransactionSource registrationSource,
ApplicationUser currentUser)
{
ValidateGamingGroupName(gamingGroupName);
GamingGroup gamingGroup = new GamingGroup()
{
OwningUserId = currentUser.Id,
Name = gamingGroupName
};
NewlyCreatedGamingGroupResult newlyCreatedGamingGroupResult = new NewlyCreatedGamingGroupResult();
GamingGroup newGamingGroup = dataContext.Save <GamingGroup>(gamingGroup, currentUser);
newlyCreatedGamingGroupResult.NewlyCreatedGamingGroup = newGamingGroup;
//commit changes since we'll need the GamingGroup.Id
dataContext.CommitAllChanges();
Player newlyCreatedPlayer = this.AssociateUserWithGamingGroup(currentUser, newGamingGroup);
newlyCreatedGamingGroupResult.NewlyCreatedPlayer = newlyCreatedPlayer;
new Task(() => eventTracker.TrackGamingGroupCreation(registrationSource)).Start();
return(newlyCreatedGamingGroupResult);
}
public async Task Create(DonorContext db, IIntegrationEventQueue queue, bool commitTransaction = true)
{
if (!IsValidated)
{
throw new Exception("Please validate model before creation.");
}
var donor = await db.Donors.FilterDeletedItems().SingleOrDefaultAsync(x => x.Id == DonorId);
if (donor == null)
{
throw new ArgumentException($"Donor with ID '{DonorId}' does not exist.", nameof(DonorId));
}
var transactionSource = new TransactionSource();
MapToEntity(transactionSource);
db.TransactionSources.Add(transactionSource);
MapFromEntity(transactionSource);
if (commitTransaction)
{
await db.SaveChangesAsync();
Id = transactionSource.Id;
var integrationEvent = new IntegrationEvent <DonorTransactionSourceEvent>(ServiceNames.DonorService.ToString(), EventNames.AddDonorTransactionSource.ToString(), ToDonorTransactionSourceEvent());
queue.Post(integrationEvent);
}
}
public PlayedGameCreatedEvent(int playedGameId, int gameDefinitionId, List <int> participatingPlayerIds, TransactionSource expectedTransactionSource, ApplicationUser currentUser)
{
TriggerEntityId = playedGameId;
TransactionSource = expectedTransactionSource;
GameDefinitionId = gameDefinitionId;
ParticipatingPlayerIds = participatingPlayerIds;
CurrentUser = currentUser;
}
private void MapToEntity(TransactionSource transactionSource)
{
transactionSource.DonorId = DonorId;
transactionSource.FinancialInstitution = FinancialInstitution;
transactionSource.Identifier = Identifier;
transactionSource.Type = Enum.Parse <TransactionSourceType>(Type, true);
transactionSource.TransactionSourceIdentifier = TransactionSourceIdentifier ?? Guid.NewGuid();
}
public void MapFromEntity(TransactionSource transactionSource)
{
Id = transactionSource.Id;
DonorId = transactionSource.DonorId;
FinancialInstitution = transactionSource.FinancialInstitution;
Identifier = transactionSource.Identifier;
Type = transactionSource.Type.ToString();
TransactionSourceIdentifier = transactionSource.TransactionSourceIdentifier;
}
public void SetUp()
{
var userStoreMock = MockRepository.GenerateMock<IUserStore<ApplicationUser>>();
var dataProtector = MockRepository.GenerateMock<IDataProtector>();
dataProtectionProviderMock = MockRepository.GenerateMock<IDataProtectionProvider>();
dataProtectionProviderMock.Expect(mock => mock.Create(Arg<string>.Is.Anything)).Return(dataProtector);
applicationUserManagerMock = MockRepository.GenerateMock<ApplicationUserManager>(userStoreMock, dataProtectionProviderMock);
gamingGroupSaverMock = MockRepository.GenerateMock<IGamingGroupSaver>();
configurationManagerMock = MockRepository.GenerateMock<IConfigurationManager>();
dataContextMock = MockRepository.GenerateMock<IDataContext>();
firstTimeAuthenticator = new FirstTimeAuthenticator(
gamingGroupSaverMock,
applicationUserManagerMock,
configurationManagerMock,
dataContextMock);
applicationUser = new ApplicationUser
{
Id = "user id",
UserName = "******"
};
registrationSource = TransactionSource.RestApi;
var appSettingsMock = MockRepository.GenerateMock<IAppSettings>();
configurationManagerMock.Expect(mock => mock.AppSettings)
.Return(appSettingsMock);
appSettingsMock.Expect(mock => mock.Get(FirstTimeAuthenticator.APP_KEY_EMAIL_CONFIRMATION_CALLBACK_URL))
.Return(callbackUrl);
expectedNewlyCreatedGamingGroupResult = new NewlyCreatedGamingGroupResult
{
NewlyCreatedGamingGroup = new GamingGroup { Id = 1 },
NewlyCreatedPlayer = new Player { Id = 100, Name = "some awesome player name"}
};
gamingGroupSaverMock.Expect(mock => mock.CreateNewGamingGroup(
Arg<string>.Is.Anything,
Arg<TransactionSource>.Is.Anything,
Arg<ApplicationUser>.Is.Anything))
.Return(expectedNewlyCreatedGamingGroupResult);
applicationUserManagerMock.Expect(mock => mock.GenerateEmailConfirmationTokenAsync(applicationUser.Id))
.Return(Task.FromResult(confirmationToken));
string expectedCallbackUrl = callbackUrl + string.Format(
FirstTimeAuthenticator.CONFIRMATION_EMAIL_CALLBACK_URL_SUFFIX,
applicationUser.Id,
HttpUtility.UrlEncode(confirmationToken));
string expectedEmailBody = string.Format(FirstTimeAuthenticator.CONFIRMATION_EMAIL_BODY, expectedCallbackUrl);
applicationUserManagerMock.Expect(mock => mock.SendEmailAsync(
applicationUser.Id,
FirstTimeAuthenticator.EMAIL_SUBJECT,
expectedEmailBody))
.Return(Task.FromResult(-1));
}
public ITransactionSource Convert()
{
ITransactionSource transactionSource = new TransactionSource()
{
TransactionSourceId = TransactionSourceId,
Name = Name
};
return(transactionSource);
}
public void TrackGamingGroupCreation(TransactionSource registrationSource)
{
IUniversalAnalyticsEvent universalAnalyticsEvent = eventFactory.MakeUniversalAnalyticsEvent(
DEFAULT_ANONYMOUS_CLIENT_ID,
EventCategoryEnum.GamingGroups.ToString(),
EventActionEnum.Created.ToString(),
registrationSource.ToString());
eventTracker.TrackEvent(universalAnalyticsEvent);
}
public void TrackPlayedGame(ApplicationUser currentUser, TransactionSource transactionSource)
{
IUniversalAnalyticsEvent universalAnalyticsEvent = eventFactory.MakeUniversalAnalyticsEvent(
currentUser.AnonymousClientId,
EventCategoryEnum.PlayedGames.ToString(),
EventActionEnum.Created.ToString(),
transactionSource.ToString());
eventTracker.TrackEvent(universalAnalyticsEvent);
}
public PlayedGame UpdatePlayedGame(UpdatedGame updatedGame, TransactionSource transactionSource, ApplicationUser currentUser)
{
if (updatedGame.GamingGroupId.HasValue)
{
_securedEntityValidator.RetrieveAndValidateAccess <GamingGroup>(updatedGame.GamingGroupId.Value, currentUser);
}
_securedEntityValidator.RetrieveAndValidateAccess <PlayedGame>(updatedGame.PlayedGameId, currentUser);
_securedEntityValidator.RetrieveAndValidateAccess <GameDefinition>(updatedGame.GameDefinitionId, currentUser);
var playedGameWithStuff = _dataContext.GetQueryable <PlayedGame>()
.Where(x => x.Id == updatedGame.PlayedGameId)
.Include(x => x.ApplicationLinkages)
.Include(x => x.GameDefinition)
.Include(x => x.PlayerGameResults)
.FirstOrDefault();
if (playedGameWithStuff == null)
{
throw new EntityDoesNotExistException(typeof(PlayedGame), updatedGame.PlayedGameId);
}
var gamingGroupId = updatedGame.GamingGroupId ?? playedGameWithStuff.GamingGroupId;
ValidateAccessToPlayers(updatedGame.PlayerRanks, gamingGroupId, currentUser, _dataContext);
var playerGameResults = MakePlayerGameResults(updatedGame, playedGameWithStuff.GameDefinition?.BoardGameGeekGameDefinitionId, _dataContext);
var updatedPlayedGame = TransformNewlyCompletedGameIntoPlayedGame(updatedGame, gamingGroupId, currentUser.Id, playerGameResults);
updatedPlayedGame.Id = updatedGame.PlayedGameId;
updatedPlayedGame.DateUpdated = DateTime.UtcNow;
CleanupPlayerResultsAndApplicationLinkages(currentUser, playedGameWithStuff);
var returnPlayedGame = _dataContext.Save(updatedPlayedGame, currentUser);
//--Entity Framework doesn't appear to save new child entities when updating the parent entity so we have to save them separately
playerGameResults.ForEach(x =>
{
x.PlayedGameId = returnPlayedGame.Id;
_dataContext.Save(x, currentUser);
});
CreateApplicationLinkages(updatedGame.ApplicationLinkages, updatedGame.PlayedGameId, _dataContext);
var playerIds = playerGameResults.Select(x => x.PlayerId).ToList();
_businessLogicEventSender.SendEvent(new PlayedGameCreatedEvent(
updatedGame.PlayedGameId,
updatedGame.GameDefinitionId,
playerIds,
transactionSource,
currentUser));
return(returnPlayedGame);
}
public void TrackUserRegistration(TransactionSource registrationSource)
{
IUniversalAnalyticsEvent universalAnalyticsEvent = eventFactory.MakeUniversalAnalyticsEvent(
DEFAULT_ANONYMOUS_CLIENT_ID,
EventCategoryEnum.Users.ToString(),
EventActionEnum.Created.ToString(),
registrationSource.ToString(),
nonInteractionEvent: IsNonInteractionEvent(TransactionSource.RestApi));
eventTracker.TrackEvent(universalAnalyticsEvent);
}
internal virtual void DoPostSaveStuff(TransactionSource transactionSource,
ApplicationUser currentUser, int playedGameId, int gameDefinitionId, List<PlayerGameResult> playerGameResults)
{
_playedGameTracker.TrackPlayedGame(currentUser, transactionSource);
foreach (var result in playerGameResults)
{
_nemesisRecalculator.RecalculateNemesis(result.PlayerId, currentUser);
}
_championRecalculator.RecalculateChampion(gameDefinitionId, currentUser, false);
SendEvents(new IBusinessLogicEvent[] {new PlayedGameCreatedEvent() {TriggerEntityId = playedGameId}});
}
public void ItSetsTheEventLabelToTheTransactionSource()
{
TransactionSource transactionSource = TransactionSource.RestApi;
eventFactoryMock.Expect(mock => mock.MakeUniversalAnalyticsEvent(
Arg <string> .Is.Anything,
Arg <string> .Is.Anything,
Arg <string> .Is.Anything,
Arg <string> .Is.Equal(transactionSource.ToString()),
Arg <string> .Is.Anything))
.Return(analyticsEvent);
tracker.TrackPlayedGame(currentUser, transactionSource);
eventTrackerMock.AssertWasCalled(mock => mock.TrackEvent(analyticsEvent));
}
public void ItTracksTheGamingGroupCreation()
{
GamingGroup expectedGamingGroup = new GamingGroup()
{
Id = 123
};
autoMocker.Get <IDataContext>().Expect(mock => mock.Save(Arg <GamingGroup> .Is.Anything, Arg <ApplicationUser> .Is.Anything))
.Repeat.Once()
.Return(expectedGamingGroup);
TransactionSource expectedRegistrationSource = TransactionSource.RestApi;
autoMocker.ClassUnderTest.CreateNewGamingGroup(gamingGroupName, expectedRegistrationSource, currentUser);
autoMocker.Get <INemeStatsEventTracker>().AssertWasCalled(mock => mock.TrackGamingGroupCreation(expectedRegistrationSource));
}
public void ItSetsTheLabelToTheSpecifiedRegistrationSource()
{
TransactionSource registrationSource = TransactionSource.RestApi;
eventFactoryMock.Expect(mock => mock.MakeUniversalAnalyticsEvent(
Arg <string> .Is.Anything,
Arg <string> .Is.Anything,
Arg <string> .Is.Anything,
Arg <string> .Is.Equal(registrationSource.ToString()),
Arg <string> .Is.Anything))
.Return(analyticsEvent);
tracker.TrackGamingGroupCreation(registrationSource);
eventTrackerMock.AssertWasCalled(mock => mock.TrackEvent(analyticsEvent));
}
public void ItSetsTheEventLabelToTheTransactionSource()
{
TransactionSource transactionSource = TransactionSource.RestApi;
_autoMocker.Get <IUniversalAnalyticsEventFactory>().Expect(mock => mock.MakeUniversalAnalyticsEvent(
Arg <string> .Is.Anything,
Arg <string> .Is.Anything,
Arg <string> .Is.Anything,
Arg <string> .Is.Equal(transactionSource.ToString()),
Arg <string> .Is.Anything,
Arg <string> .Is.Anything,
Arg <bool> .Is.Anything))
.Return(analyticsEvent);
_autoMocker.ClassUnderTest.TrackPlayedGame(currentUser, transactionSource);
_autoMocker.Get <IEventTracker>().AssertWasCalled(mock => mock.TrackEvent(analyticsEvent));
}
public void ItSetsTheLabelToTheSpecifiedRegistrationSource()
{
TransactionSource registrationSource = TransactionSource.RestApi;
_autoMocker.Get <IUniversalAnalyticsEventFactory>().Expect(mock => mock.MakeUniversalAnalyticsEvent(
Arg <string> .Is.Anything,
Arg <string> .Is.Anything,
Arg <string> .Is.Anything,
Arg <string> .Is.Equal(registrationSource.ToString()),
Arg <string> .Is.Anything,
Arg <string> .Is.Anything,
Arg <bool> .Is.Anything))
.Return(analyticsEvent);
_autoMocker.ClassUnderTest.TrackGamingGroupCreation(registrationSource);
_autoMocker.Get <IEventTracker>().AssertWasCalled(mock => mock.TrackEvent(analyticsEvent));
}
private void AddDonation(TransactionSource transactionSource, TransactionIntegrationEvent @event)
{
var charities = _donorContext.DonorCharities
.FilterDeletedItems()
.Include(x => x.DonorCharityProportions)
.Include(x => x.Donor)
.Where(x => x.DonorId == transactionSource.DonorId)
.ToList();
if (!charities.Any())
{
return;
}
foreach (var charity in charities)
{
var donorCharityProportion = charity
.DonorCharityProportions
.LastOrDefault(x => @event.TransactionDateTimeUtc >= x.ValidFromUtc && @event.TransactionDateTimeUtc <= x.ValidToUtc);
if (donorCharityProportion == null)
{
continue;
}
var donationPercentage = donorCharityProportion.DonationPercentage;
var donation = new Donation
{
Amount = (@event.Amount * (charity.Donor.TransactionDonationPercentage / (decimal)100.0)) * (donationPercentage / (decimal)100.0),
Currency = @event.Currency,
DonorCharityProportionId = donorCharityProportion.Id,
TransactionIdentifier = @event.TransactionIdentifier,
DonationDateTimeUtc = DateTime.UtcNow,
MerchantName = @event.MerchantName,
TransactionAmount = @event.Amount,
TransactionDateTimeUtc = @event.TransactionDateTimeUtc,
TransactionDonationPercentage = charity.Donor.TransactionDonationPercentage
};
_donorContext.Donations.Add(donation);
}
}
public void ItRecordsAGamePlayedEvent()
{
PlayerRank playerRank = new PlayerRank()
{
GameRank = 1,
PlayerId = 1
};
NewlyCompletedGame newlyCompletedGame = new NewlyCompletedGame()
{
GameDefinitionId = gameDefinition.Id,
PlayerRanks = new List <PlayerRank>()
{
playerRank
}
};
TransactionSource transactionSource = TransactionSource.RestApi;
autoMocker.ClassUnderTest.CreatePlayedGame(newlyCompletedGame, transactionSource, this.currentUser);
autoMocker.Get <INemeStatsEventTracker>().AssertWasCalled(mock => mock.TrackPlayedGame(currentUser, transactionSource));
}
public async Task<NewlyRegisteredUser> CreateGamingGroupAndSendEmailConfirmation(
ApplicationUser applicationUser,
TransactionSource registrationSource)
{
//fetch this first since we want to fail as early as possible if the config entry is missing
var callbackUrl = this.GetCallbackUrlFromConfig();
NewlyCreatedGamingGroupResult result = this.gamingGroupSaver.CreateNewGamingGroup(
applicationUser.UserName + "'s Gaming Group",
registrationSource,
applicationUser);
await this.SendConfirmationEmail(applicationUser, callbackUrl);
return new NewlyRegisteredUser
{
GamingGroupId = result.NewlyCreatedGamingGroup.Id,
GamingGroupName = result.NewlyCreatedGamingGroup.Name,
PlayerId = result.NewlyCreatedPlayer.Id,
PlayerName = result.NewlyCreatedPlayer.Name,
UserId = applicationUser.Id
};
}
public async Task <NewlyRegisteredUser> CreateGamingGroupAndSendEmailConfirmation(
ApplicationUser applicationUser,
TransactionSource registrationSource)
{
//fetch this first since we want to fail as early as possible if the config entry is missing
var callbackUrl = this.GetCallbackUrlFromConfig();
NewlyCreatedGamingGroupResult result = this.gamingGroupSaver.CreateNewGamingGroup(
applicationUser.UserName + "'s Gaming Group",
registrationSource,
applicationUser);
await this.SendConfirmationEmail(applicationUser, callbackUrl);
return(new NewlyRegisteredUser
{
GamingGroupId = result.NewlyCreatedGamingGroup.Id,
GamingGroupName = result.NewlyCreatedGamingGroup.Name,
PlayerId = result.NewlyCreatedPlayer.Id,
PlayerName = result.NewlyCreatedPlayer.Name,
UserId = applicationUser.Id
});
}
public async Task <IActionResult> PostTransactions(string accountId, [FromQuery] TransactionSource transactionSource)
{
var bytes = new byte[HttpContext.Request.ContentLength.Value];
using (var ms = new MemoryStream(bytes.Length))
{
await HttpContext.Request.Body.CopyToAsync(ms);
ms.Seek(0, SeekOrigin.Begin);
using (var sr = new StreamReader(ms))
{
switch (transactionSource)
{
case TransactionSource.Hac:
await _accountHandler.ProcessHacTransactions(accountId, await sr.ReadToEndAsync());
break;
case TransactionSource.OtpBank:
await _accountHandler.ProcessOtpBankTransactions(accountId, await sr.ReadToEndAsync());
break;
case TransactionSource.Revolut:
await _accountHandler.ProcessRevolutTransactions(accountId, await sr.ReadToEndAsync());
break;
default:
throw new System.Exception();
}
}
}
return(Ok());
}
public async Task Handle(JsonElement transaction, JsonElement contractCall, TransactionSource transactionSource, CancellationToken cancellationToken)
{
if (contractCall.GetProperty(Blocknative.Properties.MethodName).ValueEquals(Uniswap.SwapExactEthForTokens))
{
var transactionHash = transaction.GetProperty(Blocknative.Properties.Hash).GetString();
_logger.LogTrace($"Transaction {transactionHash} received");
var transactionStatus = EnumHelper.GetValueFromDescription <TransactionStatus>(transaction.GetProperty(Blocknative.Properties.Status).GetString());
switch (transactionStatus)
{
case TransactionStatus.Pending:
var @params = contractCall.GetProperty(Blocknative.Properties.Params);
await _transactionProcessorService.Process(new Swap
{
TransactionHash = transactionHash,
AmountIn = TryParseJsonString(transaction, Blocknative.Properties.Value),
Gas = transaction.GetProperty(Blocknative.Properties.Gas).GetUInt64(),
GasPrice = TryParseJsonString(transaction, Blocknative.Properties.GasPrice),
AmountOutMin = TryParseJsonString(@params, Blocknative.Properties.AmountOutMin),
Deadline = (long)TryParseJsonString(@params, Blocknative.Properties.Deadline),
Path = @params.GetProperty(Blocknative.Properties.Path).EnumerateArray().Select(e => e.GetString()).ToList(),
Source = transactionSource
}, cancellationToken);
public Application(TransactionSource transactionSource)
{
_source = transactionSource;
}
public PlayedGame UpdatePlayedGame(UpdatedGame updatedGame, TransactionSource transactionSource, ApplicationUser currentUser)
{
if (updatedGame.GamingGroupId.HasValue)
{
_securedEntityValidator.RetrieveAndValidateAccess<GamingGroup>(updatedGame.GamingGroupId.Value, currentUser);
}
_securedEntityValidator.RetrieveAndValidateAccess<PlayedGame>(updatedGame.PlayedGameId, currentUser);
_securedEntityValidator.RetrieveAndValidateAccess<GameDefinition>(updatedGame.GameDefinitionId, currentUser);
var playedGameWithStuff = _dataContext.GetQueryable<PlayedGame>()
.Where(x => x.Id == updatedGame.PlayedGameId)
.Include(x => x.ApplicationLinkages)
.Include(x => x.GameDefinition)
.Include(x => x.PlayerGameResults)
.FirstOrDefault();
if (playedGameWithStuff == null)
{
throw new EntityDoesNotExistException(typeof(PlayedGame), updatedGame.PlayedGameId);
}
var gamingGroupId = updatedGame.GamingGroupId ?? playedGameWithStuff.GamingGroupId;
ValidateAccessToPlayers(updatedGame.PlayerRanks, gamingGroupId, currentUser);
var playerGameResults = MakePlayerGameResults(updatedGame, playedGameWithStuff.GameDefinition?.BoardGameGeekGameDefinitionId);
var updatedPlayedGame = TransformNewlyCompletedGameIntoPlayedGame(updatedGame, gamingGroupId, currentUser.Id, playerGameResults);
updatedPlayedGame.Id = updatedGame.PlayedGameId;
updatedPlayedGame.DateUpdated = DateTime.UtcNow;
CleanupPlayerResultsAndApplicationLinkages(currentUser, playedGameWithStuff);
var returnPlayedGame = _dataContext.Save(updatedPlayedGame, currentUser);
//--Entity Framework doesn't appear to save new child entities when updating the parent entity so we have to save them separately
playerGameResults.ForEach(x =>
{
x.PlayedGameId = returnPlayedGame.Id;
_dataContext.Save(x, currentUser);
});
CreateApplicationLinkages(updatedGame.ApplicationLinkages, updatedGame.PlayedGameId);
DoPostSaveStuff(transactionSource, currentUser, playedGameWithStuff.Id, playedGameWithStuff.GameDefinitionId, playerGameResults);
return returnPlayedGame;
}
internal virtual bool IsNonInteractionEvent(TransactionSource transactionSource)
{
return(transactionSource == TransactionSource.RestApi);
}
public TransactionApp(TransactionSource ts)
{
this.ts = ts;
}
public PayrollApp(TransactionSource ts) : base(ts)
{
PayrollFactory.paymentFactory = new PaymentFactoryImplementation();
RequestFactory.rf = new RequestFactoryImplementation();
}
public void AddTransactionSource(TransactionSource source)
{
source.Id = _nextSourceId;
_sources.Add(source);
_nextSourceId++;
}