public bool ChangeStateRoulette(RouletteModel roulette)
{
string sql = $"UPDATE ROULETTE SET ISOPEN = '{ roulette.IsOpen }'" +
$"WHERE ROULETTEID = ({ roulette.RouletteId })";
SqlCommand cmd = new SqlCommand(sql, _db.connection)
{
CommandType = CommandType.Text
};
_db.connection.Open();
try
{
int rouletteId = cmd.ExecuteNonQuery();
return(rouletteId != 0);
}
catch (Exception ex)
{
//todo: implementar logs;
return(false);
}
finally
{
_db.connection.Close();
}
}
public static CreateRouletteModel Map(RouletteModel roulette)
{
return(new CreateRouletteModel()
{
id = roulette.id
});
}
public static OpenRouletteModel MapOp(RouletteModel roulette)
{
return(new OpenRouletteModel()
{
status = roulette.open
});
}
/// <summary>
/// Method to create roulette
/// </summary>
/// <returns> Object with the transaction information </returns>
public TransactionDTO <long> CreateRoulette()
{
TransactionDTO <long> transaction = new TransactionDTO <long>();
transaction.Data = 0;
try
{
RouletteModel rouletteModel = new RouletteModel();
string name = RouletteNameGenerator();
rouletteModel.Name = name;
rouletteModel.Code = name;
long createRouletteId = _rouletteRepository.CreateRoulette(rouletteModel);
if (createRouletteId < 0)
{
transaction.Status = Common.Status.Failure;
transaction.Message = "No fue posible crear la nueva ruleta de juego.";
return(transaction);
}
transaction.Data = createRouletteId;
}
catch (ArgumentException ex)
{
transaction.Status = Common.Status.Failure;
transaction.Message = ex.Message;
}
return(transaction);
}
public IEnumerable <RouletteModel> Get()
{
List <RouletteModel> lstRoulette = new List <RouletteModel>();;
try
{
var command = CrearComando("spGetRoulettes");
command.CommandType = System.Data.CommandType.StoredProcedure;
using (var reader = command.ExecuteReader())
{
DataTable dt = new DataTable();
dt.Load(reader);
if (dt.Rows.Count > 0)
{
foreach (DataRow item in dt.Rows)
{
RouletteModel objRoulette = SetRoulette(item);
lstRoulette.Add(objRoulette);
}
}
return(lstRoulette);
}
}
catch (Exception ex)
{
throw ex;
}
}
private RouletteModel SetRoulette(DataRow row)
{
RouletteModel objResponse = new RouletteModel();
try
{
objResponse.iRouletteId = Convert.ToInt32(row["ROULETTE_ID"].ToString());
objResponse.strRouletteCode = row["ROULETTE_CODE"].ToString();
objResponse.strRouletteStatus = row["ROULETTE_STATUS"].ToString();
if (row["OPENING_DATE"].ToString() != string.Empty)
{
objResponse.dttOpeningDate = DateTime.Parse(row["OPENING_DATE"].ToString());
}
if (row["CLOSING_DATE"].ToString() != string.Empty)
{
objResponse.dttClosingDate = DateTime.Parse(row["CLOSING_DATE"].ToString());
}
return(objResponse);
}
catch (Exception ex)
{
throw ex;
}
}
public RouletteModel GetById(int Id)
{
RouletteModel objRoulette = new RouletteModel();;
try
{
var command = CrearComando("spGetRouletteById");
command.CommandType = System.Data.CommandType.StoredProcedure;
command.Parameters.Add("@ROULETTE_ID", SqlDbType.Int).Value = Id;
using (var reader = command.ExecuteReader())
{
DataTable dt = new DataTable();
dt.Load(reader);
if (dt.Rows.Count > 0)
{
foreach (DataRow item in dt.Rows)
{
objRoulette = SetRoulette(item);
}
}
return(objRoulette);
}
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <GeneralResponse> CloseBets(CloseBetsRequest request)
{
try
{
RouletteModel rouletteModel = await GetRuletteModel();
if (rouletteModel == null)
{
return(new GeneralResponse(false, Constants.CIERRE_APUESTA_FALLIDA));
}
RouletteClosedDTO rouletteClosed = new RouletteClosedDTO();
rouletteClosed.NumberWinner = new Random().Next(0, 1);
rouletteClosed.WinnerUsers = GetWinnerUsers(rouletteClosed.NumberWinner, rouletteModel);
rouletteModel = ChangeRuletteEnabled(request.RouletteId, false, rouletteModel);
await cacheService.SetUsingCache("Roulette", rouletteModel);
GeneralResponse generalResponse = new GeneralResponse(Constants.CERRADO_RULETA_EXITOSA, rouletteClosed.WinnerUsers);
return(generalResponse);
}
catch (Exception)
{
return(new GeneralResponse(false, Constants.CIERRE_APUESTA_FALLIDA));
}
}
public long CreateRoulette(RouletteModel roulette)
{
long id = 0;
using (SqlConnection connection = new SqlConnection(ConnectionString))
{
using (SqlCommand sqlCommand = new SqlCommand("develop.CreateRoulette", connection))
{
sqlCommand.CommandType = CommandType.StoredProcedure;
sqlCommand.Parameters.Add(new SqlParameter("@Name", SqlDbType.NVarChar, 50));
sqlCommand.Parameters["@Name"].Value = roulette.Name;
sqlCommand.Parameters.Add(new SqlParameter("@Code", SqlDbType.NVarChar, 10));
sqlCommand.Parameters["@Code"].Value = roulette.Code;
sqlCommand.Parameters.Add(new SqlParameter("@Id", SqlDbType.BigInt));
sqlCommand.Parameters["@Id"].Direction = ParameterDirection.Output;
try
{
connection.Open();
sqlCommand.ExecuteNonQuery();
id = (long)sqlCommand.Parameters["@Id"].Value;
}
catch (Exception ex)
{
throw new ArgumentException("Error 06: Ocurrió un error consultando la base de datos.");
}
finally
{
connection.Close();
}
return(id);
}
}
}
public List <RouletteModel> GetAllRoulette()
{
QueryBuilder queryBuilder = new QueryBuilder();
List <RouletteModel> listRoulette = new List <RouletteModel>();
string queryString = queryBuilder.ConstructorSelectAll(_context);
using (SqlConnection connection = new SqlConnection(ConnectionString))
{
SqlCommand command = new SqlCommand(queryString, connection);
try
{
connection.Open();
SqlDataReader reader = command.ExecuteReader();
while (reader.Read())
{
RouletteModel roulette = new RouletteModel();
roulette.Id = (long)reader[0];
roulette.Name = reader[1].ToString();
roulette.Code = reader[2].ToString();
roulette.AllowBets = (bool)reader[3];
roulette.State = (bool)reader[4];
roulette.CreationDate = (DateTime)reader[5];
listRoulette.Add(roulette);
}
reader.Close();
}
catch (Exception ex)
{
throw new ArgumentException("Error 05: Ocurrió un error consultando la base de datos.");
}
return(listRoulette);
}
}
public IEnumerable <string> Get(int rouletteId)
{
RouletteRepositorySQL rouletteRepository = new RouletteRepositorySQL();
RouletteModel roulette = rouletteRepository.GetRouletteById(rouletteId: rouletteId);
if (roulette.IsValidToClose())
{
roulette.IsOpen = false;
rouletteRepository.ChangeStateRoulette(roulette: roulette);
}
else
{
return(new string[] { $"La ruleta {rouletteId} no se puede cerrar." });
}
BetRepositorySQL betRepository = new BetRepositorySQL();
List <BetModel> bets = betRepository.GetActiveBets(rouletteId: rouletteId);
if (!bets.Any())
{
return new string[] { $"La ruleta {rouletteId} se cerró, pero no tenia apuestas." }
}
;
betRepository.CloseBets(rouletteId: rouletteId);
return(GetBetsResults(bets: bets));
}
public RouletteModel GetRouletteById(long rouletteId)
{
RouletteModel roulette = new RouletteModel();
string queryString = "SELECT * FROM develop.Roulette WHERE Id = " + rouletteId + " AND State = 1;";
using (SqlConnection connection = new SqlConnection(ConnectionString))
{
SqlCommand command = new SqlCommand(queryString, connection);
try
{
connection.Open();
SqlDataReader reader = command.ExecuteReader();
while (reader.Read())
{
roulette.Id = (long)reader[0];
roulette.Name = reader[1].ToString();
roulette.Code = reader[2].ToString();
roulette.AllowBets = (bool)reader[3];
roulette.State = (bool)reader[4];
roulette.CreationDate = (DateTime)reader[5];
}
reader.Close();
}
catch (Exception ex)
{
throw new ArgumentException("Error 06: Ocurrió un error consultando la base de datos.");
}
return(roulette);
}
}
public string Bet([FromBody] RouletteModel roulette)
{
roulette.Bet.Bettor = Request.Headers["UserId"];
return(new RouletteBL(configuration["DBServer"]).Bet(bet: roulette.Bet, maxAmount: Double.Parse(configuration["BetMaxAmount"]),
id: roulette.Id, allowedColors: configuration["ColorsForBet"].Split(","), rangeNumbersBet: configuration["RangeNumberForBet"].Split(",")));
}
public int AddRoulette(RouletteModel roulette)
{
string sql = $"INSERT INTO ROULETTE (ISOPEN)" +
$"VALUES ('{ roulette.IsOpen }');" +
"SELECT SCOPE_IDENTITY()";
SqlCommand cmd = new SqlCommand(sql, _db.connection)
{
CommandType = CommandType.Text
};
_db.connection.Open();
try
{
int rouletteId = Convert.ToInt32(cmd.ExecuteScalar());
return(rouletteId);
}
catch (Exception ex)
{
//todo: implementar logs;
return(0);
}
finally
{
_db.connection.Close();
}
}
public async Task <GeneralResponse> MakeBet(MakeBetRequest request)
{
try
{
RouletteModel rouletteModel = await GetRuletteModel();
if (rouletteModel == null)
{
return(new GeneralResponse(false, Constants.CREACION_APUESTA_FALLIDA));
}
var elementIndex = rouletteModel.Roulette.FindIndex(t => t.RouletteId == request.RouletteId && t.Enabled);
var newItem = rouletteModel.Roulette[elementIndex];
newItem.Bets.Add(new BetDTO()
{
UserId = request.UserId,
BetNumber = request.BetNumber,
BetCash = request.BetCash,
BetColor = request.BetColor
}
);
rouletteModel.Roulette[elementIndex] = newItem;
await cacheService.SetUsingCache("Roulette", rouletteModel);
GeneralResponse generalResponse = new GeneralResponse(Constants.CREACION_APUESTA_EXITOSA);
return(generalResponse);
}
catch (Exception)
{
return(new GeneralResponse(false, Constants.CREACION_APUESTA_FALLIDA));
}
}
public BetValidation(IDistributedCache distributedCache)
{
betModel = new BetModel(distributedCache);
gamblerValidation = new GamblerValidation(distributedCache);
rouletteValidation = new RouletteValidation(distributedCache);
gamblerModel = new GamblerModel(distributedCache);
rouletteModel = new RouletteModel(distributedCache);
}
public static CloseRouletteModel MapClose(RouletteModel roulette)
{
return(new CloseRouletteModel()
{
id = roulette.id,
open = roulette.open
});
}
private RouletteModel ChangeRuletteEnabled(int rouletteId, bool enabled, RouletteModel roulette)
{
var elementIndex = roulette.Roulette.FindIndex(t => t.RouletteId == rouletteId);
var newItem = roulette.Roulette[elementIndex];
newItem.Enabled = enabled;
roulette.Roulette[elementIndex] = newItem;
return(roulette);
}
public int Post()
{
RouletteModel roulette = new RouletteModel {
IsOpen = false
};
RouletteRepositorySQL rouletteRepository = new RouletteRepositorySQL();
int rouletteId = rouletteRepository.AddRoulette(roulette: roulette);
return(rouletteId);
}
public CBet(IDistributedCache distributedCache)
{
betModel = new BetModel(distributedCache);
betResultModel = new BetResultModel(distributedCache);
gamblerModel = new GamblerModel(distributedCache);
rouletteModel = new RouletteModel(distributedCache);
gamblingModel = new GamblingModel(distributedCache);
betValidation = new BetValidation(distributedCache);
gamblingValidation = new GamblingValidation(distributedCache);
cGambling = new CGambling(distributedCache);
}
private IEnumerable <WinnerUserDto> GetWinnerUsers(int numberWinner, RouletteModel roulette)
{
var winnerUsers = roulette.Roulette.SelectMany(t => t.Bets)
.Where(t => t.BetNumber == numberWinner)
.Select(t => new WinnerUserDto()
{
UserId = t.UserId,
Value = String.IsNullOrEmpty(t.BetColor) ? t.BetCash * 5 : t.BetCash * 1.8
});
return(winnerUsers);
}
/// <summary>
/// Create Roulete
/// </summary>
/// <returns>Data of roulette created</returns>
public async Task <RouletteModel> PostRouletteModel()
{
RouletteModel rouletteModel = new RouletteModel
{
Id = Guid.NewGuid(),
RouletteOpen = false,
Open = null,
Close = null
};
_context.Roulettes.Add(rouletteModel);
await _context.SaveChangesAsync();
return(rouletteModel);
}
public string Put(int rouletteId)
{
RouletteRepositorySQL rouletteRepository = new RouletteRepositorySQL();
RouletteModel roulette = rouletteRepository.GetRouletteById(rouletteId: rouletteId);
if (roulette.IsValidToOpen())
{
roulette.IsOpen = true;
rouletteRepository.ChangeStateRoulette(roulette: roulette);
return($"La apertura de la ruleta {rouletteId} fue exitosa");
}
else
{
return($"La ruleta {rouletteId} ya está abierta o no existe");
}
}
public async Task <GeneralResponse> GetRouletteList()
{
try
{
RouletteModel response = await GetRuletteModel();
if (response == null)
{
throw new Exception();
}
GeneralResponse generalResponse = new GeneralResponse(Constants.LISTAR_RULESTAS_EXITOSO, response);
return(generalResponse);
}
catch (Exception)
{
return(new GeneralResponse(false, Constants.LISTAR_RULETAS_FALLIDA));
}
}
public RouletteModel OpenRoulette(int Id)
{
RouletteModel objResponse = new RouletteModel();
try
{
using (var context = _unitOfWork.Create())
{
objResponse = context.Repositories.RouletteRepository.OpenRoulette(Id);
context.SaveChanges();
return(objResponse);
}
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <GeneralResponse> CreateRoulette()
{
try
{
RouletteModel rouletteModel = await GetRuletteModel() != null ? await GetRuletteModel() : new RouletteModel();
RouletteDTO rouletteDto = new RouletteDTO();
rouletteDto.RouletteId = new Random().Next(0, 999999999);
rouletteModel.Roulette.Add(rouletteDto);
await cacheService.SetUsingCache("Roulette", rouletteModel);
GeneralResponse generalResponse = new GeneralResponse(Constants.CREACION_RULETA_EXITOSA, rouletteDto.RouletteId);
return(generalResponse);
}
catch (Exception)
{
return(new GeneralResponse(false, Constants.CREACION_RULETA_FALLIDA));
}
}
public ActionResult <IEnumerable <string> > CreateRoulette()
{
try
{
RouletteModel objRoulette = new RouletteModel();
ResponseAPI <RouletteModel> response = new ResponseAPI <RouletteModel>(Parameters.OK_REQUEST, "Success", _RouletteService.Create(objRoulette));
return(Ok(
response
));
}
catch (Exception ex)
{
ResponseAPI <BetModel> response = new ResponseAPI <BetModel>(Parameters.INTERNAL_SERVER_ERROR, ex.Message, false);
return(Ok(
response
));
}
}
public async Task <RouletteModel> CreateNewRoulette()
{
var roulettes = await _redisRepository.Read("Roulettes");
if (roulettes == null)
{
roulettes = emptyRoulettes();
}
else
{
int countRoulettes = roulettes.Count() + 1;
RouletteModel roulette = new RouletteModel {
id = countRoulettes,
open = false
};
roulettes.Add(roulette);
}
await _redisRepository.Add("Roulettes", roulettes);
return(roulettes.FirstOrDefault(x => x.id == roulettes.Count()));
}
public async Task <RouletteModel> CloseRoulette(int id)
{
var roulettes = await _redisRepository.Read("Roulettes");
RouletteModel roulette = roulettes.FirstOrDefault(x => x.id == id);
if (roulette == null)
{
return(new RouletteModel {
id = 0,
open = false
});
}
else
{
roulette.open = false;
await _redisRepository.Add("Roulettes", roulettes);
return(roulettes.Find(x => x.id == id));
}
}
public async Task <GeneralResponse> OpeningRoulette(RouletteOpeningRequest request)
{
try
{
RouletteModel rouletteModel = await GetRuletteModel();
if (rouletteModel == null)
{
return(new GeneralResponse(false, Constants.APERTURA_RULETA_FALLIDA));
}
rouletteModel = ChangeRuletteEnabled(request.RouletteId, true, rouletteModel);
await cacheService.SetUsingCache("Roulette", rouletteModel);
GeneralResponse generalResponse = new GeneralResponse(Constants.APERTURA_RULETA_EXITOSA);
return(generalResponse);
}
catch (Exception)
{
return(new GeneralResponse(false, Constants.APERTURA_RULETA_FALLIDA));
}
}
