public void Handle(PlayerRegistered @event)
{
if (@event.IsActive)
{
AddActivityLog("Automatic activation performed", @event, @event.PlayerId);
}
}
public override void Attached()
{
PlayerManager = GameObject.Find("PlayerManager");
GuiManager = GetComponent <GUImanager>();
state.Health = 100;
if (!entity.IsOwner)
{
DisableRemoteBehaviour();
gameObject.layer = LayerMask.NameToLayer(REMOTE_PLAYER_LAYER);
transform.GetChild(0).gameObject.layer = LayerMask.NameToLayer(REMOTE_PLAYER_LAYER);
for (int i = 0; i < 2; i++)
{
transform.GetChild(0).GetChild(i).gameObject.layer = LayerMask.NameToLayer(REMOTE_PLAYER_LAYER);
}
}
else
{
state.Username = PlayerManager.GetComponent <PlayerAuth>().Name;
state.XP = PlayerManager.GetComponent <PlayerAuth>().XP;
state.Kills = 0;
state.Deaths = 0;
state.Score = 0;
var Event = PlayerRegistered.Create();
Event.Name = PlayerManager.GetComponent <PlayerAuth>().Name;
Event.Entity = entity;
Event.Send();
}
}
public void Consume(PlayerRegistered message)
{
_repository.Players.Add(new Player
{
Id = message.PlayerId,
Username = message.UserName,
FirstName = message.FirstName,
LastName = message.LastName,
Email = message.Email,
PhoneNumber = message.PhoneNumber,
LanguageCode = message.CultureCode,
Language = _repository.Languages.Single(x => x.Code == message.CultureCode),
BrandId = message.BrandId,
Brand = _repository.Brands.Single(x => x.Id == message.BrandId),
VipLevelId = message.VipLevelId,
VipLevel = _repository.VipLevels.Single(x => x.Id == message.VipLevelId),
PaymentLevelId = message.PaymentLevelId,
PaymentLevel = message.PaymentLevelId.HasValue
? _repository.PaymentLevels.SingleOrDefault(x => x.Id == message.PaymentLevelId)
: null,
AccountAlertEmail = message.AccountAlertEmail,
AccountAlertSms = message.AccountAlertSms,
IsActive = message.IsActive,
DateRegistered = message.DateRegistered
});
_repository.SaveChanges();
}
public void Consume(PlayerRegistered @event)
{
var paymentRepository = _container.Resolve <IPaymentRepository>();
var brandQueries = _container.Resolve <BrandQueries>();
var player = @event;
var defaultPaymentLevelId = brandQueries.GetDefaultPaymentLevelId(player.BrandId, player.CurrencyCode);
var paymentLevel = player.PaymentLevelId.HasValue
? paymentRepository.PaymentLevels.SingleOrDefault(l => l.Id == player.PaymentLevelId.Value)
: paymentRepository.PaymentLevels.SingleOrDefault(l => l.Id == defaultPaymentLevelId);
if (paymentLevel == null)
{
throw new RegoException("No appropriate payment level found. Brand: " + player.BrandId + " Currency: " +
player.CurrencyCode);
}
paymentRepository.PlayerPaymentLevels.Add(new Data.PlayerPaymentLevel
{
PlayerId = player.PlayerId,
PaymentLevel = paymentLevel
});
var newPlayer = AutoMapper.Mapper.DynamicMap <Data.Player>(player);
newPlayer.Id = player.PlayerId;
paymentRepository.Players.Add(newPlayer);
paymentRepository.SaveChanges();
}
private async Task OnPlayerRegistered(PlayerRegistered playerRegistered, CancellationToken ct)
{
_playerId = playerRegistered.ReceivingPlayerId;
SendHearBeat();
await _client.SendAsync(new StartGame(playerRegistered.ReceivingPlayerId),
ct); // TODO: Create a factory for requests?
await _client.SendAsync(
new ClientInfo("C#", "8", "Windows", "10", "1", playerRegistered.ReceivingPlayerId), ct);
Console.WriteLine(playerRegistered);
}
public void Handle(PlayerRegistered @event)
{
var bonusRepository = _container.Resolve <IBonusRepository>();
var bonusCommands = _container.Resolve <BonusCommands>();
var bonusQueries = _container.Resolve <BonusQueries>();
using (var scope = CustomTransactionScope.GetTransactionScope())
{
var player = bonusRepository.Players.SingleOrDefault(p => p.Id == @event.PlayerId);
if (player != null)
{
throw new RegoException($"Player is already saved. Id: {@event.PlayerId}");
}
var brand = bonusRepository.Brands.SingleOrDefault(b => b.Id == @event.BrandId);
if (brand == null)
{
throw new RegoException($"Unable to find a brand with Id: {@event.BrandId}");
}
player = new Player(@event, brand);
if (@event.ReferralId.HasValue)
{
var referrer = bonusRepository.Players.Single(p => p.ReferralId == @event.ReferralId.Value);
player.ReferredBy = referrer.Id;
var referralBonus =
bonusQueries.GetQualifiedBonuses(referrer.Id, BonusType.ReferFriend).FirstOrDefault();
if (referralBonus != null)
{
player.ReferredWith =
bonusRepository.Bonuses.Single(
b => b.Id == referralBonus.Id && b.Version == referralBonus.Version);
bonusCommands.RedeemBonus(referrer.Id, referralBonus.Id);
}
}
bonusRepository.Players.Add(player);
bonusRepository.SaveChanges();
var verificationBonus =
bonusQueries.GetQualifiedBonuses(player.Id, BonusType.MobilePlusEmailVerification)
.FirstOrDefault();
if (verificationBonus != null)
{
bonusCommands.RedeemBonus(player.Id, verificationBonus.Id, new RedemptionParams());
}
scope.Complete();
}
}
public void NotifyNewPlayer(List <Player> PlayersRegistered, IDominoServiceCallbackContract Callback,
int PlayerPosition, string PlayerName)
{
PlayerData playerData = new PlayerData(PlayerName, PlayerPosition);
Callback.NewPlayerJoined(playerData);
foreach (Player PlayerRegistered in PlayersRegistered)
{
PlayerData PlayerRegisteredData = new PlayerData(PlayerRegistered.getName(), PlayerRegistered.getPosition());
PlayerRegistered.getCallback().NewPlayerJoined(playerData);
Callback.NewPlayerJoined(PlayerRegisteredData);
}
}
public async Task Handle(PlayerRegistered message, CancellationToken token = new CancellationToken())
{
var newPlayer = new PlayerDto(message.PlayerId, message.PlayerName);
if (message.PlayerNumber == 1)
{
await _databaseService.UpdatePlayer1Async(message.Id, message.Version, newPlayer);
}
else if (message.PlayerNumber == 2)
{
await _databaseService.UpdatePlayer2Async(message.Id, message.Version, newPlayer);
}
await _gameHub.Clients.Group(message.Id.ToString()).PlayerJoinedGame(message.Id);
}
public void Handle(PlayerRegistered registeredEvent)
{
var playerRegisteredEvent = registeredEvent;
var repository = _container.Resolve <IReportRepository>();
var record = repository.PlayerRecords.SingleOrDefault(r => r.PlayerId == playerRegisteredEvent.PlayerId);
if (record != null)
{
throw new RegoException(string.Format("Player record with Id '{0}' already exists", playerRegisteredEvent.PlayerId));
}
var brand = _container.Resolve <BrandQueries>().GetBrandOrNull(playerRegisteredEvent.BrandId);
var streetAddress = String.Join("\n", playerRegisteredEvent.AddressLines).Trim('\n');
record = new PlayerRecord
{
PlayerId = registeredEvent.PlayerId,
Username = registeredEvent.UserName,
Brand = brand != null ? brand.Name : null,
Licensee = brand != null && brand.Licensee != null ? brand.Licensee.Name : null,
IsInternalAccount = false, // TODO: implement HousePlayer when it's passing in PlayerRegistered event,
RegistrationDate = playerRegisteredEvent.DateRegistered,
SignUpIP = playerRegisteredEvent.IPAddress ?? "127.0.0.1",
PlayerName = playerRegisteredEvent.DisplayName,
Birthday = playerRegisteredEvent.DateOfBirth.Date,
Title = playerRegisteredEvent.Title,
Gender = playerRegisteredEvent.Gender,
Email = playerRegisteredEvent.Email,
Mobile = playerRegisteredEvent.PhoneNumber,
Language = playerRegisteredEvent.Language,
Currency = playerRegisteredEvent.CurrencyCode,
Country = playerRegisteredEvent.CountryName,
IsInactive = !playerRegisteredEvent.IsActive,
VipLevel = playerRegisteredEvent.VipLevel,
//[KB] TODO: Taking only first 100 characters so that EF will not throw exception during SaveChanges.
StreetAddress = streetAddress.Length > 100 ? streetAddress.Substring(0, 100): streetAddress,
PostCode = playerRegisteredEvent.ZipCode,
Created = registeredEvent.EventCreated,
CreatedBy = registeredEvent.EventCreatedBy
};
if (playerRegisteredEvent.IsActive)
{
record.Activated = registeredEvent.EventCreated;
record.ActivatedBy = registeredEvent.EventCreatedBy;
}
repository.PlayerRecords.Add(record);
repository.SaveChanges();
}
private Task HandleResponseAsync(Response response, CancellationToken ct)
{
return(response switch
{
PlayerRegistered playerRegistered => OnPlayerRegistered(playerRegistered, ct),
MapUpdated mapUpdated => OnMapUpdated(mapUpdated, ct),
GameLink gameLink => OnGameLink(gameLink),
GameStarting gameStarting => OnGameStarting(gameStarting),
GameResult gameResult => OnInfoEvent(gameResult),
CharacterStunned characterStunned => OnInfoEvent(characterStunned),
HeartBeatResponse heartBeatResponse => OnHearBeatEvent(heartBeatResponse, ct),
GameEnded gameEnded => OnGameEnded(gameEnded),
TournamentEnded tournamentEnded => OnTournamentEnded(tournamentEnded),
InvalidPlayerName invalidPlayerName => OnInfoEvent(invalidPlayerName),
_ => Task.CompletedTask
});
public Player(PlayerRegistered registrationData, Brand brand)
{
Id = registrationData.PlayerId;
Name = registrationData.UserName;
Email = registrationData.Email;
PhoneNumber = registrationData.PhoneNumber;
VipLevel = registrationData.VipLevel;
CurrencyCode = registrationData.CurrencyCode;
DateRegistered = registrationData.DateRegistered.ToBrandOffset(brand.TimezoneId);
ReferralId = registrationData.RefIdentifier;
Brand = brand;
Wallets = brand.WalletTemplates.Select(wt => new Wallet {
Player = this, Template = wt
}).ToList();
RiskLevels = new List <RiskLevel>();
}
private void Apply(PlayerRegistered e)
{
if (e.PlayerNumber == 1)
{
_player1Id = e.PlayerId;
}
else
{
_player2Id = e.PlayerId;
}
if (_player1Id != Guid.Empty && _player2Id != Guid.Empty)
{
_gameStarted = true;
_playersTurn = 1;
}
}
public void Consume(PlayerRegistered @event)
{
var repository = _container.Resolve <IFraudRepository>();
var player = new Fraud.Data.Player
{
DateRegistered = @event.DateRegistered,
Email = @event.Email,
FirstName = @event.FirstName,
Id = @event.PlayerId,
BrandId = @event.BrandId,
IPAddress = @event.IPAddress,
LastName = @event.LastName,
Phone = @event.PhoneNumber,
Username = @event.UserName,
ZipCode = @event.ZipCode,
Address = @event.AddressLines.Aggregate((x, y) => x + y)
};
try
{
repository.Players.Add(player);
repository.SaveChanges();
var duplicationMatchingService = _container.Resolve <IDuplicationMatchingService>();
var duplicationService = _container.Resolve <IDuplicationService>();
//Todo: sould replace it with async task.
duplicationMatchingService.Match(player.Id);
duplicationService.ApplyAction(player.Id);
}
catch (Exception e)
{
throw new RegoException(e.Message, e);
}
}
public void Consume(PlayerRegistered message)
{
_playerHandlers.Handle(message);
_playerRecordEditHandlers.Handle(message);
}
public void Consume(PlayerRegistered message)
{
_eventHandlers.Handle(message);
}
public void Consume(PlayerRegistered message)
{
_playerSubscriber.Handle(message);
}
public void Handle(PlayerRegistered @event)
{
AddActivityLog(AdminActivityLogCategory.Player, @event);
}
public override void OnEvent(PlayerRegistered evnt)
{
matchManager.RegisterPlayer(evnt.Entity);
}
public void Handle(PlayerRegistered @event)
{
AddPlayerLog(@event.PlayerId);
}
