public async Task <BetEntity> Bet(string idRoulette, string userId, BetModel betRquest)
{
string message = string.Empty;
RouletteEntity roulette = await _rouletteRepository.GetById(idRoulette);
message = _utilities.ValidateRoulette(roulette, isbetting: true);
if (message != "")
{
throw new Exception(message);
}
message = _utilities.ValidateBetRequest(betRquest);
if (message != "")
{
throw new Exception(message);
}
BetEntity bet = new BetEntity()
{
BetDate = DateTime.Now.ToString("yyyy'-'MM'-'dd'T'HH':'mm':'ss'Z'"),
UserId = userId,
BetModel = betRquest,
Winner = false,
EarnedMoney = 0,
Roulette = roulette
};
await _betRepository.InsertDocument(bet);
return(bet);
}
public string ValidateRoulette(RouletteEntity roulette, bool isbetting = false, bool isClosing = false, bool isOpening = false)
{
string message = string.Empty;
if (roulette == null)
{
message = "La ruleta no existe.";
}
else
{
if (roulette.State == "create" && (isbetting || isClosing))
{
message = "La ruleta aún no se encuentra abierta.";
}
if (roulette.State == "open" && (isOpening))
{
message = "La ruleta ya se encuentra abierta.";
}
if (roulette.State == "closed" && (isOpening || isbetting || isClosing))
{
message = "La ruleta ya fue cerrada.";
}
}
return message;
}
private bool RouletteExistsOrOpen(string id)
{
bool result = false;
RouletteEntity roulette = _rouletteRepository.GetById(id).Result.Result;
if (roulette != null && roulette.Open)
{
result = true;
}
return(result);
}
public async Task <bool> PlayByColor(BetByColorEntity bet)
{
if (bet.Amount < 1 || bet.Amount > 10000)
{
throw new Exception("El monto a apostar debe estar entre 1 y 10,000.");
}
RouletteEntity roulette = await GetFromCache(bet.IdRoulette);
roulette.BetsByColor.Add(bet);
await SaveToCache(roulette);
return(true);
}
public async Task <RouletteEntity> Create()
{
RouletteEntity roulette = new RouletteEntity()
{
State = "create",
OpeningDate = null,
ClosingDate = null,
WinningNumber = -1,
WinningColor = ""
};
await _rouletteRepository.InsertDocument(roulette);
return(roulette);
}
public async Task <string> Create()
{
RouletteEntity roulette = new RouletteEntity()
{
Id = Guid.NewGuid().ToString(),
IsOpen = false,
BetsByNumber = new List <BetByNumberEntity>(),
BetsByColor = new List <BetByColorEntity>()
};
await SaveToCache(roulette);
return(roulette.Id);
}
public object CreateRoulette()
{
var vInput = new RouletteEntity
{
State = Constant.Created,
Date = DateTime.UtcNow.ToString("O")
};
var vRoulette = _rouletteDal.Create(vInput);
var vResult = new
{
vRoulette.Id
};
return(vResult);
}
public async Task <IEnumerable <WinnerDto> > Close(string idRoulette)
{
RouletteEntity roulette = await GetFromCache(idRoulette);
List <WinnerDto> winners = new List <WinnerDto>();
if (roulette.IsOpen)
{
int numberWinner = new Random().Next(0, 36);
winners = GetWinners(roulette, numberWinner);
}
roulette.IsOpen = false;
await SaveToCache(roulette);
return(winners);
}
public async Task <bool> Open(string idRoulette)
{
RouletteEntity roulette = await GetFromCache(idRoulette);
bool success = false;
if (!roulette.IsOpen)
{
roulette.IsOpen = true;
await SaveToCache(roulette);
success = true;
}
return(success);
}
public async Task <RouletteEntity> Open(string Id)
{
RouletteEntity roulette = await _rouletteRepository.GetById(Id);
string message = _utilities.ValidateRoulette(roulette, isOpening: true);
if (message != "")
{
throw new Exception(message);
}
roulette.OpeningDate = DateTime.Now.ToString("yyyy'-'MM'-'dd'T'HH':'mm':'ss'Z'");
roulette.State = "open";
await _rouletteRepository.UpdateDocument(roulette);
return(roulette);
}
public async Task <GenericResponseEntity <string> > OpenBet(string id)
{
RouletteEntity rouletteUpd = _rouletteRepository.GetById(id).Result.Result;
if (rouletteUpd != null)
{
rouletteUpd.Open = true;
rouletteUpd.OpenDate = DateTime.Now;
return(await _rouletteRepository.UpdateDocument(rouletteUpd));
}
GenericResponseEntity <string> response = new GenericResponseEntity <string>()
{
Result = "El Id de la ruleta ha actualizar no existe. Por favor verifique el Id"
};
return(response);
}
public async Task <IEnumerable <BetEntity> > Close(string id)
{
RouletteEntity roulette = await _rouletteRepository.GetById(id);
string message = _utilities.ValidateRoulette(roulette, isClosing: true);
if (message != "")
{
throw new Exception(message);
}
var winningNumber = _utilities.GetWinningNumber();
var winningColor = (_utilities.ValidateEvenNumber(winningNumber)) ? "rojo" : "negro";
roulette.ClosingDate = DateTime.Now.ToString("yyyy'-'MM'-'dd'T'HH':'mm':'ss'Z'");
roulette.WinningNumber = winningNumber;
roulette.WinningColor = winningColor;
roulette.State = "closed";
await _rouletteRepository.UpdateDocument(roulette);
var listBet = await _betRepository.GetByFilter(Builders <BetEntity> .Filter.Eq(doc => doc.Roulette.Id, id));
foreach (var bet in listBet)
{
bet.Roulette = roulette;
if (bet.BetModel.BetType.ToLower() == "color")
{
if (bet.BetModel.BetValue.ToLower() == winningColor)
{
bet.Winner = true;
bet.EarnedMoney = (bet.BetModel.BetMoney * 1.8);
}
}
else
{
if (Convert.ToInt32(bet.BetModel.BetValue) == winningNumber)
{
bet.Winner = true;
bet.EarnedMoney = (bet.BetModel.BetMoney * 5);
}
}
await _betRepository.UpdateDocument(bet);
}
return(listBet);
}
private List <WinnerDto> GetWinners(RouletteEntity roulette, int numberWinner)
{
List <WinnerDto> winners = new List <WinnerDto>();
string colorWinner = (numberWinner % 2 == 0) ? "Red" : "Black";
var winnersByNumber = roulette.BetsByNumber.Where(x => x.Number == numberWinner).ToList();
var winnersByColor = roulette.BetsByColor.Where(x => x.Color == colorWinner).ToList();
winnersByNumber.ForEach(x => winners.Add(new WinnerDto
{
IdUser = x.IdUser,
Amount = x.Amount * 5
}));
winnersByColor.ForEach(x => winners.Add(new WinnerDto
{
IdUser = x.IdUser,
Amount = x.Amount * 1.8
}));
return(winners);
}
public bool ValidRouletteIsOpen(int id, List <RouletteEntity> objRoulettes)
{
try
{
RouletteEntity objRoulette = objRoulettes.Where(r => r.Id == id).FirstOrDefault();
if (objRoulette != null)
{
if (objRoulette.Status)
{
return(true);
}
}
return(false);
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <IActionResult> OpenRulette(string id)
{
try
{
RouletteEntity roulette = await _rouletteService.Open(id);
if (roulette.State == "open")
{
return(Ok(new { state = "Operación exitosa.", errorMessge = "" }));
}
else
{
return(Ok(new { state = "Operación denegada.", errorMessge = "No se abrió la ruleta." }));
}
}
catch (Exception e)
{
Console.WriteLine(e);
return(Ok(new { state = "Operación denegada.", errorMessge = e.Message }));
}
}
public RouletteEntity Create(RouletteEntity pObject)
{
_roulette.InsertOne(pObject);
return(pObject);
}
private async Task SaveToCache(RouletteEntity roulette)
{
await _distributedCache.SetAsync(roulette.Id, ToByteArray(roulette));
}
private byte[] ToByteArray(RouletteEntity roulette)
{
return(JsonSerializer.SerializeToUtf8Bytes(roulette));
}
public void Update(string id, RouletteEntity objIn) => _roulette.ReplaceOne(x => x.Id == id, objIn);
public void Remove(RouletteEntity objIn) => _roulette.DeleteOne(x => x.Id == objIn.Id);
public async Task <ActionResult <GenericResponseEntity <string> > > Post()
{
RouletteEntity roulette = new RouletteEntity();
return(Ok(await _rouletteGenericRepository.InsertDocument(roulette)));
}
public async Task <IActionResult> NewRulette()
{
RouletteEntity roulette = await _rouletteService.Create();
return(Ok(new { Id = roulette.Id }));
}
