public string VipLevelView(Guid id)
{
var vipLevel = _brandQueries.GetVipLevel(id);
var gameProviders = _gameQueries.GetGameProviders(vipLevel.Brand.Id);
var data = new
{
licensee = vipLevel.Brand.Licensee.Name,
brand = vipLevel.Brand.Name,
defaultForNewPlayers = vipLevel.Brand.DefaultVipLevelId == vipLevel.Id,
code = vipLevel.Code,
name = vipLevel.Name,
rank = vipLevel.Rank,
description = vipLevel.Description,
color = vipLevel.ColorCode,
remark = vipLevel.UpdatedRemark,
limits = vipLevel.VipLevelGameProviderBetLimits.Select(x => new
{
currency = x.Currency.Code,
gameProvider = gameProviders.Single(y => y.Id == x.GameProviderId).Name,
betLimit = _gameQueries.GetBetLimitDto(x.BetLimitId).Name
}).OrderBy(x => x.betLimit)
};
return(SerializeJson(data));
}
public string GameProviders(Guid brandId)
{
var allowedProductIds = _brandQueries
.GetBrandOrNull(brandId)
.Products
.Select(x => x.ProductId)
.ToList();
var gameProviders = _gameQueries
.GetGameProviders()
.Where(x => allowedProductIds.Contains(x.Id))
.Select(x => new { name = x.Name, id = x.Id });
return(SerializeJson(gameProviders));
}
public static IEnumerable <ProductViewModel> BuildFromIds(IGameQueries queries, IEnumerable <Guid> productIds)
{
var gameProviders = queries.GetGameProviders().Where(x => productIds.Contains(x.Id));
return(gameProviders.Select(x => new ProductViewModel {
Id = x.Id, Name = x.Name, Code = x.Code
}));
}
private IEnumerable <BrandProductData> GetBrandProductViewModels(Guid?brandId)
{
var brandProducts = _brandQueries.GetAllowedProducts(UserId, brandId).ToList();
var productIds = brandProducts.Select(x => x.ProductId).Distinct();
var gameProviders = _gameQueries.GetGameProviders().Where(x => productIds.Contains(x.Id));
return(brandProducts.Join(gameProviders, b => b.ProductId, s => s.Id,
(b, s) => new BrandProductData()
{
BrandId = b.BrandId,
// Investigation: looks like in some cases b.Brand is null
BrandName = b.Brand != null ? b.Brand.Name : string.Empty,
GameProviderId = s.Id,
GameProviderName = s.Name
}));
}
private void ValidatePlayersWinningsRules(Guid withdrawalId, Guid playerId)
{
if (!_configuration.HasWinnings)
{
return;
}
var allWinningRules = _configuration.WinningRules.ToList();
foreach (var rule in allWinningRules)
{
var startDate = GetStartDate(rule, playerId);
var endDate = GetEndDate(rule);
var actualTransactions = _gameQueries.GetWinLossGameActions(rule.ProductId)
.Where(o => o.Round.PlayerId == playerId)
.Where(o => o.Timestamp >= startDate && o.Timestamp <= endDate);
var wonAmount = actualTransactions.Where(o => o.GameActionType == GameActionType.Won).Sum(o => o.Amount);
var lostAmount = actualTransactions.Where(o => o.GameActionType == GameActionType.Lost).Sum(o => o.Amount);
var winningsAmount = wonAmount - lostAmount;
var productForThatRule = _gameQueries.GetGameProviders().FirstOrDefault(x => x.Id == rule.ProductId);
var productName = productForThatRule != null ? productForThatRule.Name : string.Empty;
var metadataForRule = GenerateFullRuleDescriptionAndValue(
VerificationStep.HasWinnings,
ComparisonEnum.For,
rule.WinningRuleDescription(productName),
winningsAmount.ToString(CultureInfo.InvariantCulture));
if (!IsRulePassed(rule.Comparison, rule.Amount, winningsAmount))
{
OnRuleFinish(false, withdrawalId, VerificationStep.HasWinnings, metadataForRule);
break;
}
OnRuleFinish(true, withdrawalId, VerificationStep.HasWinnings, metadataForRule);
}
}
public void Can_Create_GameProvider()
{
var gameProvider = new GameProvider
{
Id = Guid.NewGuid(),
Name = "GameProvider",
Code = "GameProviderCode",
};
Assert.AreEqual(0, _queries.GetGameProviders().Count(x => x.Id == gameProvider.Id));
_gameManagement.CreateGameProvider(gameProvider);
Assert.AreEqual(1, _queries.GetGameProviders().Count(x => x.Id == gameProvider.Id));
Assert.NotNull(gameProvider.CreatedBy);
Assert.NotNull(gameProvider.CreatedDate);
}
public async Task <TemplateDataResponse> GetRelatedData(Guid?id = null)
{
VerifyPermission(Permissions.View, Modules.BonusTemplateManager);
VerifyPermission(Permissions.View, Modules.BonusManager);
Template template = null;
if (id.HasValue)
{
var templateData = await _bonusApiProxy.GetTemplateOrNull(id.Value);
template = Mapper.Map <Template>(templateData);
CheckBrand(template.Info.BrandId.Value);
}
var getBonusesTask = _bonusApiProxy.GetBonusesAsync();
var notificationTriggers = _messageTemplateQueries.GetBonusNotificationTriggerMessageTypes()
.Select(x => Enum.GetName(typeof(MessageType), x));
var licenseeFilterSelections = _adminQueries.GetLicenseeFilterSelections();
var brandFilterSelections = _adminQueries.GetBrandFilterSelections();
var licensees = _brandQueries.GetFilteredLicensees()
.Include(l => l.Brands.Select(b => b.VipLevels))
.Include(l => l.Brands.Select(b => b.BrandCurrencies.Select(bc => bc.Currency)))
.Include(l => l.Brands.Select(b => b.WalletTemplates))
.Include(l => l.Brands.Select(b => b.Products))
.Where(l => licenseeFilterSelections.Contains(l.Id))
.OrderBy(l => l.Name)
.ToList()
.Select(l => new Licensee
{
Id = l.Id,
Name = l.Name,
Brands = _brandQueries.GetFilteredBrands(l.Brands, UserId)
.Where(b =>
b.Status == BrandStatus.Active &&
brandFilterSelections.Contains(b.Id))
.OrderBy(b => b.Name)
.Select(b => new TemplateBrand
{
Id = b.Id,
Name = b.Name,
VipLevels = b.VipLevels.Select(v => new TemplateVipLevel {
Code = v.Code, Name = v.Name
}),
Currencies = b.BrandCurrencies.Select(v => new TemplateCurrency {
Code = v.Currency.Code, Name = v.Currency.Name
}),
WalletTemplates = b.WalletTemplates.OrderBy(wt => wt.Name).Select(wt => new TemplateWalletTemplate {
Id = wt.Id, Name = wt.Name, IsMain = wt.IsMain
}),
Products = b.Products.Select(p => p.ProductId),
RiskLevels = _riskLevelQueries.GetByBrand(b.Id)
.Select(riskLevel => new TemplateRiskLevel {
Id = riskLevel.Id, Name = riskLevel.Name
})
.OrderBy(riskLevel => riskLevel.Name)
})
}).ToList();
var products = _gameQueries.GetGameProviders().ToList();
var games =
_gameQueries.GetGameDtos()
.Select(g => new Game {
Id = g.Id.Value, Name = g.Name, ProductId = g.ProductId, ProductName = products.Single(p => p.Id == g.ProductId).Name
})
.ToList();
if (template != null)
{
if (template.Info != null)
{
template.Info.LicenseeId = licensees.Single(l => l.Brands.Select(b => b.Id).Contains(template.Info.BrandId.Value)).Id;
template.Info.LicenseeName = licensees.Single(l => l.Brands.Select(b => b.Id).Contains(template.Info.BrandId.Value)).Name;
template.Info.BrandName = licensees.SelectMany(l => l.Brands).Single(b => b.Id == template.Info.BrandId).Name;
}
if (template.Wagering != null)
{
foreach (var gc in template.Wagering.GameContributions)
{
var game = games.Single(g => g.Id == gc.GameId);
gc.Name = game.Name;
gc.ProductId = game.ProductId;
gc.ProductName = game.ProductName;
}
}
}
var bonuses = await getBonusesTask;
bonuses = bonuses.Where(b => brandFilterSelections.Contains(b.BrandId)).OrderBy(bonus => bonus.Name).ToList();
return(new TemplateDataResponse
{
Template = template,
NotificationTriggers = notificationTriggers,
Bonuses = bonuses,
Licensees = licensees,
Games = games
});
}
public JsonResult ProductList()
{
var products = _gameQueries.GetGameProviders().OrderBy(p => p.Name).Select(p => p.Name);
return(Json(products, JsonRequestBehavior.AllowGet));
}
public string Update(EditGameProviderModel model)
{
GameProvider gameProvider = null;
if (model.Id.HasValue)
{
gameProvider = _queries.GetGameProviders().SingleOrDefault(x => x.Id == model.Id);
if (gameProvider == null)
{
return(SerializeJson(new { Result = "failed", Message = "app:common.idDoesNotExist" }));
}
}
if (_queries.GetGameProviderDtos().Any(x => x.Name == model.Name && (!model.Id.HasValue || x.Id != model.Id.Value)))
{
ModelState.AddModelError("Name", "{\"text\": \"app:common.nameUnique\"}");
}
/*
* DateTimeOffset? time = null;
* if (model.SecurityKeyExpiryDate != null)
* {
* // TODO Currently expecting a date from client and assuming server timezone.
* time = DateTimeOffset.Parse(model.SecurityKeyExpiryDate);
* if ((gameProvider == null || gameProvider.SecurityKeyExpiryTime != time) && time < DateTimeOffset.Now)
* {
* ModelState.AddModelError("SecurityKeyExpiryDate", "{\"text\": \"app:common.expiryDateInPast\"}");
* }
* }
*/
if (!ModelState.IsValid)
{
var fields = ModelState.Where(p => p.Value.Errors.Count > 0)
.Select(x => new { Name = ToCamelCase(x.Key), Errors = x.Value.Errors.Select(e => e.ErrorMessage) });
return(SerializeJson(new { Result = "failed", Fields = fields }));
}
if (gameProvider == null)
{
gameProvider = Mapper.Map <GameProvider>(model);
}
else
{
Mapper.Map(model, gameProvider);
}
string message;
if (model.Id.HasValue)
{
_gameManagement.UpdateGameProvider(gameProvider);
message = "app:gameIntegration.gameProviders.gameProviderUpdated";
}
else
{
_gameManagement.CreateGameProvider(gameProvider);
message = "app:gameIntegration.gameProviders.gameProviderCreated";
}
return(SerializeJson(new { Result = "success", Data = message }));
}
