public async Task <ActionResult <RedisData> > GetKey(string keyName)
{
//TODO: include exception management policy according to technical specifications
if (keyName == null)
{
throw new ArgumentNullException("value");
}
var db = _fact.Connection().GetDatabase();
var data = await db.StringGetAsync(keyName);
RedisData rObject = new RedisData();
rObject.KeyName = keyName;
rObject.KeyValue = data;
if (data != RedisValue.Null)
{
return(Ok(rObject));
}
else
{
return(NotFound());
}
}
public async Task <IActionResult> Get(double lat, double lng, int km)
{
var db = _fact.Connection().GetDatabase();
int limit = int.Parse(Configuration.GetSection("limit").Value.ToString());
var result = await db.GeoRadiusAsync(Constants.KEY_MOTORISTA_ONLINE, lng, lat, km, GeoUnit.Kilometers);
var lista = new List <Parent>();
var taskArray = new List <Task>();
result.OrderBy(v => v.Distance).Take(limit).ToList().ForEach(x =>
{
var task = Task.Run(() =>
{
lista.Add(Helper.MapsAPICall(x, lat, lng, "driving"));
});
taskArray.Add(task);
});
Task.WaitAll(taskArray.ToArray());
var listaMotorista = lista.ToList().Where(s => s.rows.Any())
.Select(x => new
{
distancia = x.rows.ToList().Where(g => g.elements.Any()).SelectMany(i => i.elements.ToList().Select(y => y.distance.value)).ToList().FirstOrDefault(),
x.status,
x.rows,
x.destination_addresses,
x.origin_addresses,
x.CodigoMotorista,
x.Latitude,
x.Longitude
});
return(Ok(new { Count = listaMotorista.Count(), Data = listaMotorista.OrderBy(x => x.distancia).ToList() }));
}
private string Get()
{
var helloRedis = Encoding.UTF8.GetBytes("Hello Redis");
HttpContext.Session.Set("hellokey", helloRedis);
var getHello = default(byte[]);
HttpContext.Session.TryGetValue("hellokey", out getHello);
ViewData["Hello"] = Encoding.UTF8.GetString(getHello);
ViewData["SessionID"] = HttpContext.Session.Id;
_cache.SetString("CacheTest", "Redis is awesome");
ViewData["Host"] = _redis.Host;
ViewData["Port"] = _redis.Port;
ViewData["Name"] = _redis.Name;
ViewData["DistCache"] = _cache.GetString("CacheTest");
var db = _fact.Connection().GetDatabase();
db.StringSet("StackExchange.Redis.Key", "Stack Exchange Redis is Awesome");
ViewData["StackExchange"] = db.StringGet("StackExchange.Redis.Key");
return("");
}
public DeviceController(IRedisConnectionFactory redisConnectionFactory,
IDataAccess mysql_dataAccess,
IModbusFactory modbusFactory, ILoggerFactory loggerFactory)
{
redis_ai = redisConnectionFactory.Connection().GetDatabase(1);
redis_di = redisConnectionFactory.Connection().GetDatabase();
modbus = modbusFactory;
modbus_master = modbus.GetModbusMaster();
logger = loggerFactory.CreateLogger <DeviceController>();
dataAccess = mysql_dataAccess;
}
// public Chat(DatabaseContext db, UserTracker tracker, IDistributedCache cache)
public Chat(DatabaseContext db, UserTracker tracker, IRedisConnectionFactory fact)
{
_db = db;
_tracker = tracker;
_fact = fact;
_redis_db = _fact.Connection();
}
public async Task <IEnumerable <string> > GetAsync()
{
var db = _fact.Connection().GetDatabase();
var redis = new RedisVoteService <Selection>(this._fact);
var selection = new Selection();
selection.BetTypeSN = "1101";
selection.BetTypeNM = "Match Result";
var betFields = new List <BetFieldType>();
betFields.Add(new BetFieldType {
BetFieldTypeSN = "1",
BetFieldTypeNM = "1",
Odds = "1.2"
});
betFields.Add(new BetFieldType
{
BetFieldTypeSN = "2",
BetFieldTypeNM = "2",
Odds = "2.1"
});
betFields.Add(new BetFieldType
{
BetFieldTypeSN = "3",
BetFieldTypeNM = "Draw",
Odds = "1.8"
});
selection.BetFieldList = betFields;
redis.Save("RedisVote:Black", selection);
return(new string[] { "value1", "value2" });
}
public void Post()
{
try
{
var db = _fact.Connection().GetDatabase();
//db.StringSet("StackExchange.Redis.Key", "Stack Exchange Redis is Awesome");
//var aa = db.StringGet("StackExchange.Redis.Key");
var redis = new RedisMotoristaService <Motorista>(this._fact);
var model = redis.GetAll("motorista");
for (int i = 0; i < 1000; i++)
{
var motorista = new Motorista();
motorista.Latitude = 23234;
motorista.Longitude = 234234;
motorista.Nome = "Lionan Dantas";
redis.Save(i.ToString(), motorista);
// redis.Save("RedisMotorista" + i.ToString(), motorista);
//var model = redis.Get("RedisMotorista");
}
// List<Motorista> teste_ = redis.GetAllByKey<Motorista>("teste");
}
catch (Exception ex)
{
}
}
public OrdersController(IBusClient _client, IRedisConnectionFactory cachingDB)
{
this.cachingDB = cachingDB.Connection().GetDatabase();
client = _client;
client.SubscribeAsync <Orders, MessageContext>(
(order, ctx) => {
if (order.NumOfPlaces >= order.NumOfPeople)//the order received
{
order.ValidateReservation = true;
}
else
{
order.ValidateReservation = false;
}
int result = order.NumOfPlaces - order.NumOfPeople;
order.NumOfPlaces = result; //update
var hc = Helpers.CouchDBConnect.GetClient("orders");
string json = JsonConvert.SerializeObject(order);
var jsonObject = Newtonsoft.Json.Linq.JObject.Parse(json);
jsonObject.Remove("_rev");
jsonObject.Remove("_id");
json = jsonObject.ToString();
HttpContent htc = new StringContent(json, System.Text.Encoding.UTF8, "application/json");
hc.PostAsync("", htc);
Console.WriteLine("order FirstName: {0} LastName: {1} PhoneNumber: {2}, RestaurantName: {3}, NumOfPeople: {4},time: {5}", order.FirstName, order.LastName, order.PhoneNumber, order.RestaurantName, order.NumOfPeople, order.time);
return(Task.FromResult(0));
}
);
}
public void Post(int motoristaId, int solicitacaoId)
{
Boolean emTeste = true;
var db = _fact.Connection().GetDatabase();
if (emTeste)
{
Helper.InserirMotoristaSolicitacao(_fact, motoristaId, solicitacaoId);
}
else
{
MotoristaSolicitacaoViewModel motorista = new MotoristaSolicitacaoViewModel {
motoristaId = motoristaId, solicitacaoId = solicitacaoId
};
db.ListRightPush(Constants.KEY_MOTORISTA_SOLICITACAO, JsonConvert.SerializeObject(motorista).ToString());
}
}
public SendBulkEmail(IEmailSender emailSender, DatabaseContext db, UserTracker tracker, IRedisConnectionFactory fact, IHostingEnvironment env)
{
_db = db;
_emailSender = emailSender;
_tracker = tracker;
_fact = fact;
_env = env;
_redis_db = fact.Connection();
}
public NotificationController(PeiuGridDataContext peiuGridDataContext, IRedisConnectionFactory redis,
AccountDataContext accountContext,
IClaimServiceFactory claimServiceFactory)
{
this.peiuGridDataContext = peiuGridDataContext;
db = redis.Connection().GetDatabase(1);
this.claimServiceFactory = claimServiceFactory;
this._accountContext = accountContext;
}
public MyProductRepository(
HttpClient httpClient,
IOptions <ServiceDependenciesConfig> serviceDependenciesConfig,
IRedisConnectionFactory redisConnectionFactory)
: base(httpClient)
{
ServiceDependenciesConfig = serviceDependenciesConfig.Value;
RedisDatabase = redisConnectionFactory.Connection().GetDatabase();
}
public NotificationController(PeiuGridDataContext peiuGridDataContext, IRedisConnectionFactory redis,
AccountEF accountContext, ILogger <NotificationController> logger, IClaimServiceFactory claimsManager,
IClaimServiceFactory claimServiceFactory)
{
this.peiuGridDataContext = peiuGridDataContext;
db = redis.Connection().GetDatabase(1);
this._accountContext = accountContext;
this.logger = logger;
this._claimsManager = claimsManager;
}
public FilesController(IBusClient _client, IRedisConnectionFactory caching)
{
client = _client;
cachingDB = caching.Connection().GetDatabase();
client.SubscribeAsync <String>(async(json) =>
{
// download image and upload it with the new user as owner
await CopyFile(json);
});
}
public async Task <IActionResult> Get()
{
try
{
var db = _fact.Connection().GetDatabase();
var queryResult = await db.HashValuesAsync(Constants.KEY_MOTORISTA_LOGADO);
if (!queryResult.Any())
{
return(NotFound());
}
var collectionJson = string.Join(",", queryResult.ToStringArray());
return(Ok(JsonConvert.DeserializeObject <MotoristaViewModel[]>("[" + collectionJson + "]")));
}
catch (Exception ex)
{
return(StatusCode((int)System.Net.HttpStatusCode.InternalServerError, ex));
}
}
public LocalizacaoController(IOptions <RedisConfiguration> redis, IRedisConnectionFactory factory, IConfiguration configuration)
{
_redis = redis.Value;
_fact = factory;
Configuration = configuration;
var db = _fact.Connection().GetDatabase();
//if (!db.KeyExists(Constants.KEY_MOTORISTA_ONLINE))
Helper.InserirCoordenadas(db);
//db.GeoAdd(Constants.KEY_MOTORISTA, Helper.GetData().ToArray());
}
public ControlSubscribeWorker(IModbusFactory modbus_factory,
IRedisConnectionFactory redisFactory,
IConfiguration configuration, ModbusSystem modbusSystem)
{
config = configuration;
modbusFactory = modbus_factory;
SiteId = configuration.GetSection("SiteId").Get <int>();
DeviceIndex = configuration.GetSection("DeviceIndex").Get <int>();
modbus = modbusSystem;
redisDb = redisFactory.Connection().GetDatabase(1);
CancelToken = Program.CancellationTokenSource.Token;
this.Initialize();
}
public ModbusBackgroundService(ILoggerFactory loggerFactory, IModbusFactory modbus_factory,
MqttClientProxyCollection mqttClientProxies, IRedisConnectionFactory redisFactory,
IConfiguration configuration, ModbusSystem modbusSystem)
{
logger = loggerFactory.CreateLogger <ModbusBackgroundService>();
config = configuration;
modbusFactory = modbus_factory;
mqtt_clients = mqttClientProxies;
mqtt_config = configuration.GetSection("MQTTBrokers").Get <MqttConfig>();
SiteId = configuration.GetSection("SiteId").Get <int>();
DeviceIndex = configuration.GetSection("DeviceIndex").Get <int>();
modbus = modbusSystem;
redis = redisFactory.Connection().GetDatabase(1);
}
public MongoBackgroundHostService(IBackgroundMongoTaskQueue taskQueue,
IRedisConnectionFactory redis_factory,
MongoClient mongoclient, MqttSubscribeConfig mqttConfig,
ILoggerFactory loggerFactory)
{
TaskQueue = taskQueue;
_client = mongoclient;
_redisFactory = redis_factory;
_mqttConfig = mqttConfig;
_redisDb = _redisFactory.Connection().GetDatabase();
_logger = loggerFactory.CreateLogger <MongoBackgroundHostService>();
}
public PVBackgroundService(Microsoft.Extensions.Logging.ILoggerFactory loggerFactory, IModbusFactory modbus_factory,
MqttClientProxyCollection mqttClientProxies, IRedisConnectionFactory redisFactory,
IConfiguration configuration)
{
logger = loggerFactory.CreateLogger <PVBackgroundService>();
config = configuration;
mqtt_clients = mqttClientProxies;
mqtt_config = configuration.GetSection("MQTTBrokers").Get <MqttConfig>();
SiteId = configuration.GetSection("SiteId").Get <int>();
string mssql_conn = configuration.GetConnectionString("mssql");
redis = redisFactory.Connection().GetDatabase(1);
DeviceName = configuration.GetSection("Modbus:DeviceName").Get <string>();
DeviceName = DeviceName.Substring(0, DeviceName.Length - 1);
sessionFactory = new MsSqlAccessManager().CreateSessionFactory(mssql_conn);
}
public void SaveOddsToRedis(Match match, string contents)
{
var rawFullTimeResult = HtmlHandler.GetImplement("Date", contents).Gets(_fullTimeResultFilter);
var date = DateTimeOffset.Now.ToString("yyyyMMdd");
var timeStamp = DateTimeOffset.Now;
var key = $"{date}:{match.MatchId}:odds:1101";
var db = _fact.Connection().GetDatabase();
var redis = new RedisVoteService <BetFieldType>(this._fact);
if (rawFullTimeResult != null)
{
redis.Delete(key);
}
var selection = new Selection();
selection.BetTypeSN = "1101";
selection.BetTypeNM = "Match Result";
var betFields = new List <BetFieldType>();
betFields.Add(new BetFieldType
{
BetFieldTypeSN = "1",
BetFieldTypeNM = "1",
Odds = rawFullTimeResult[0],
TimeStamp = timeStamp
});
betFields.Add(new BetFieldType
{
BetFieldTypeSN = "3",
BetFieldTypeNM = "Draw",
Odds = rawFullTimeResult[1],
TimeStamp = timeStamp
});
betFields.Add(new BetFieldType
{
BetFieldTypeSN = "2",
BetFieldTypeNM = "2",
Odds = rawFullTimeResult[2],
TimeStamp = timeStamp
});
selection.BetFieldList = betFields;
redis.SaveList(key, betFields);
}
public async Task <User> Get(string id)
{
var data = await _service.GetAsync(id);
var db = _fact.Connection().GetDatabase();
db.StringSet("StackExchange.Redis.Key", "Stack Exchange Redis is Awesome");
if (data != null)
{
return(_mapper.Map <User>(data));
}
else
{
return(null);
}
}
public ModbusDigitalProcessingService(Microsoft.Extensions.Logging.ILoggerFactory loggerFactory,
IDataAccess mysql_dataAccess, IRedisConnectionFactory redisFactory,
IModbusFactory modbus_factory, IConfiguration configuration, EventPublisherWorker worker, EventMap map,
ModbusSystem modbusSystem)
{
logger = loggerFactory.CreateLogger <ModbusBackgroundService>();
config = configuration;
modbusFactory = modbus_factory;
eventPublisherWorker = worker;
UpdatePeriod = configuration.GetSection("EventPollInterval").Get <TimeSpan>();
modbus = modbusSystem;
SiteId = configuration.GetSection("SiteId").Get <short>();
redis = redisFactory.Connection().GetDatabase();
DeviceIndex = configuration.GetSection("DeviceIndex").Get <int>();
dbAccess = mysql_dataAccess;
event_map = map;
}
public StatisticsController(UserManager <UserAccount> userManager,
SignInManager <UserAccount> signInManager, RoleManager <Role> _roleManager, IRedisConnectionFactory redis, ILogger <StatisticsController> logger,
IEmailSender emailSender, IHTMLGenerator _htmlGenerator, IClaimServiceFactory claimsManager, PeiuGridDataContext peiuGridDataContext,
AccountDataContext accountContext)
{
_userManager = userManager;
_accountContext = accountContext;
_signInManager = signInManager;
_emailSender = emailSender;
htmlGenerator = _htmlGenerator;
roleManager = _roleManager;
_claimsManager = claimsManager;
_peiuGridDataContext = peiuGridDataContext;
_redisConn = redis.Connection();
_redisDb = _redisConn.GetDatabase();
this.logger = logger;
}
public BookCache(IRedisConnectionFactory factory)
{
this.cache = factory.Connection().GetDatabase();
}
public LoginController(IRedisConnectionFactory caching)
{
cachingDB = caching.Connection().GetDatabase();
}
public ManageController(IBusClient _client, IRedisConnectionFactory caching)
{
client = _client;
cachingDB = caching.Connection().GetDatabase();
}
public Redis(IRedisConnectionFactory connectionFactory)
{
_connectionFactory = connectionFactory;
_database = _connectionFactory.Connection().GetDatabase();
}
public MqttSubscribeWorker(ILogger <MqttSubscribeWorker> _logger, MqttAddress _address, IRedisConnectionFactory _redis)
{
logger = _logger;
mqttAddress = _address;
db = _redis.Connection().GetDatabase();
}
public RedisController(IRedisConnectionFactory redisConnectionFactory)
{
RedisDatabase = redisConnectionFactory.Connection().GetDatabase();
}
