public async override Task Execute()
{
var id = OrderHelper.GetOrderID();
await RedisDB.MGet <Northwind.Data.Order, Northwind.Data.Order>
(id.ToString(),
(id + 1).ToString());
}
public bool Remove(string key)
{
return(RedisDB.KeyDelete(key));
//T value = Get<T>(key);
//var serializedValue = JsonSerializer.Serialize<T>(value);
//var response = db.SetRemove(GetKey(key), serializedValue);
}
public CacheRepository(IOptions <RedisConnectionConfig> config)
{
_config = config.Value;
Redis = new RedisDB(_config.Db);
Redis.Host.AddWriteHost(_config.Host, _config.Port, _config.Ssl).Password = _config.Password;
}
public override Task Execute()
{
var item = OrderHelper.GetOrder();
RedisDB.StringSet(item.OrderID.ToString(), Newtonsoft.Json.JsonConvert.SerializeObject(item));
return(base.Execute());
}
public async override Task Execute()
{
var i = OrderHelper.GetOrderID();
var data = await RedisDB.StringGetAsync(i.ToString());
var item = Newtonsoft.Json.JsonConvert.DeserializeObject <Northwind.Data.Order>(data);
}
public override Task Execute()
{
var item = OrderHelper.GetOrder();
RedisDB.StringSet(item.OrderID.ToString(), System.Text.Json.JsonSerializer.Serialize(item));
return(base.Execute());
}
private static async Task <(RedisDB, int)> GetDb(int id)
{
RedisDB db = new RedisDB(id, new JsonFormater());
string redisHost = Environment.GetEnvironmentVariable("redishost") ?? throw new Exception("NO_REDIS_HOST_ENV");
int redisPort = Int32.Parse(Environment.GetEnvironmentVariable("redisport") ?? throw new Exception("NO_REDIS_PORT_ENV"));
string redisPassword = Environment.GetEnvironmentVariable("redispassword") ?? ""; // password is not necessary to login a redis db unless a user explicitly specified
db.Host.AddWriteHost(redisHost, redisPort).Password = redisPassword;
var keyspace = (await db.Info()).Keyspace;
var entries = 0;
if (!keyspace.ContainsKey($"db{id}"))
{
goto End;
}
var data = keyspace[$"db{id}"];
entries = Int32.Parse(data.Split(',')[0].Split('=')[1]);
End:
return(db, entries);
}
public TicketServiceController()
{
db = ObjectContainer.Get <RedisDB>();
if (readyTickets == null)
{
readyTickets = new ConcurrentQueue <Ticket>();
var datas = from c in db.GetAllData <Ticket>()
where c.Status == TicketStatus.Ready
select c;
foreach (var item in datas)
{
readyTickets.Enqueue(item);
}
}
if (activeTickets == null)
{
activeTickets = new ConcurrentDictionary <long, Ticket>();
var datas = from c in db.GetAllData <Ticket>()
where c.Status == TicketStatus.Active
select c;
foreach (var item in datas)
{
activeTickets.TryAdd(item.UserId, item);
}
}
}
public string GetTerSingleByTerNo(string TerNo)
{
RedisDB OBj = new RedisDB();
OBj.SetRedisPos(ConfigurationManager.ConnectionStrings["IpportString"].ConnectionString);
bool a = OBj.CreateManager();
bool b = a;
try
{
Func <DataList, bool> wheres = x => x.realtime_dataObj.TerNo.Contains(TerNo);
var list2 = OBj.List_Table_GetData <DataList>(wheres);
List <DataList> ReturnList = new List <DataList>();
foreach (DataList curData in list2)
{
DataList dd = new DataList();
dd = curData;
ReturnList.Add(curData);
}
string uu = ConvertToJsonNew(ReturnList);
return(uu);
}
catch (Exception e)
{
return("[]");
}
}
public async override Task Execute()
{
var i = OrderHelper.GetOrderID();
var data = await RedisDB.StringGetAsync(i.ToString());
var item = System.Text.Json.JsonSerializer.Deserialize <Northwind.Data.Order>(data);
}
private RedisDB CreateDB(int db, string host, int port)
{
var redisDb = new RedisDB(db);
redisDb.Host.AddWriteHost(host, port);
return(redisDb);
}
static async Task Main(string[] args)
{
config = new ConfigurationBuilder()
.AddJsonFile("settings.json", true, true)
.AddJsonFile("local.settings.json", true, true)
.Build();
AppConstants.MqttHost = config["mqtt-host"];
AppConstants.MqttUser = config["mqtt-user"];
AppConstants.MqttPass = config["mqtt-pass"];
AppConstants.MqttTopic = config["mqtt-topic"];
if (mqttService == null)
{
mqttService = new MqttService();
}
mqttService.SubscribeTopic(new string[] { AppConstants.MqttTopic });
mqttService.OnMessageReceived += MqttService_OnMessageReceived;
//storageClient = new StorageClient(config);
//storageClient.InitialiseConnection();
if (parser == null)
{
parser = new Parser();
}
redis = new RedisDB(config["RedisCon"], 7);
Task task1 = new Task(StartAISReceiver);
task1.Start();
Console.WriteLine("receiver is running, press any key to stop.");
Console.ReadLine();
task1.Dispose();
}
public void Initialize(Benchmark benchmark)
{
if (RedisDB == null)
{
RedisDB = new RedisDB(0, new JsonFormater());
RedisDB.Host.AddWriteHost(Program.Host);
}
}
public override Task Execute()
{
var i = OrderHelper.GetOrderID();
var data = RedisDB.StringGet(i.ToString());
var item = System.Text.Json.JsonSerializer.Deserialize <Northwind.Data.Order>(data);
return(base.Execute());
}
public HQRedisDB(HQRedisService Service, int DBIndex)
{
//this.Service = Service;
//this.DBIndex = DBIndex;
DB = new RedisDB(DBIndex, new JsonFormater());
DB.Host.AddWriteHost(Service.Host, Service.Prot, Service.SSL).Password = Service.Password;
}
public async void DBDisposed()
{
using (RedisDB db = new RedisDB())
{
db.Host.AddWriteHost("127.0.0.1");
await db.Ping();
}
}
public ShipRepository()
{
var db = new RedisDB {
DataFormater = new JsonFormater()
};
db.Host.AddWriteHost("localhost");
_table = db.CreateHashTable("ships");
}
public StatisticsServiceTests()
{
_redisDB = DefaultRedis.Instance;
_redisDB.DataFormater = new JsonFormater();
_redisDB.Host.AddWriteHost("redisTestServer", 6381);
_redisDB.Flushall();
_statisticsServiceBeetleXRedis = new StatisticsServiceBeetleXRedis(_redisDB);
_muxer = ConnectionMultiplexer.Connect("redisTestServer:6381");
_statisticsServiceStackExchangeRedis = new StatisticsServiceStackExchangeRedis(_muxer);
}
public bool FriendRelationUpd(string friendrelation)
{
var FriendRelation = JsonConvert.DeserializeObject <tbl_FriendRelation>(friendrelation);
var RedisKey = RelationPrefixKey + GetDatePart(FriendRelation.RelationID);
if (RedisDB.HashExists(RedisKey, FriendRelation.RelationID))
{
return(RedisDB.HashSet <tbl_FriendRelation>(RedisKey, FriendRelation.RelationID, FriendRelation));
}
return(false);
}
public MainWindow()
{
InitializeComponent();
redisDB = RedisDB.Instance;
Title = redisDB.GetConnectionInfo;
// Populate TreeView with all the keys with their values
treeView.ItemsSource = redisDB.GetKeysList();
PrintKeys();
}
public String Get()
{
RedisDB DB = new RedisDB(1);
DB.DataFormater = new JsonFormater();
// SSL
DB.Host.AddWriteHost("localhost", 6379, true);
return("Hello from RedisClientController!");
}
/// <summary>
/// 执行
/// </summary>
public override void Execute()
{
var ServiceTime = DateTime.Now;
while (true)
{
try
{
//从预约订单推送消息数据链表左边起获取一条数据
AssignOrderPushContent content = RedisDB.ListLeftPop <AssignOrderPushContent>(LegworkConfig.RedisKey.LegworkUserAddOrder);
//不存在，则休眠1秒钟，避免CPU空转
if (null == content)
{
Thread.Sleep(100);
continue;
}
//获取预约订单推送接口配置信息
var apiConfig = PushApiConfigManager.GetApiConfig(SysEnums.PushType.LegworkUserAddOrder);
if (null == apiConfig)
{
continue;
}
//将订单数据转换成为字典以便参与接口加密
var dic = content.ToMap();
if (apiConfig.Method == "get")
{
DefaultClient.DoGet(apiConfig.Url, dic, PushApiConfigManager.Config.ModuleID, PushApiConfigManager.Config.Secret);
}
else if (apiConfig.Method == "post")
{
DefaultClient.DoPost(apiConfig.Url, dic, PushApiConfigManager.Config.ModuleID, PushApiConfigManager.Config.Secret);
ExceptionLoger loger = new ExceptionLoger(@"/logs/Sccess" + DateTime.Now.ToString("yyyyMMdd") + ".txt");
loger.Success("用户下单推送给工作端推送时", "推送结果:订单编号为“" + content.OrderCode + "”");
}
}
catch (Exception ex)
{
if (ServiceTime.AddHours(1) >= DateTime.Now)
{
ServiceTime = DateTime.Now;
//异常处理
ExceptionLoger loger = new ExceptionLoger(@"/logs/Error" + DateTime.Now.ToString("yyyyMMdd") + ".txt");
loger.Write("用户下单，用户下单推送给工作端", ex);
}
Thread.Sleep(100);
continue;
}
}
}
public bool FriendGroupUpd(string friendgroup)
{
var FriendGroup = JsonConvert.DeserializeObject <tbl_FriendGroups>(friendgroup);
var RedisKey = GroupPrefixKey + GetDatePart(FriendGroup.GroupID);
if (RedisDB.HashExists(RedisKey, FriendGroup.GroupID))
{
return(RedisDB.HashSet <tbl_FriendGroups>(RedisKey, FriendGroup.GroupID, FriendGroup));
}
return(false);
}
public T Get <T>(string key)
{
var value = RedisDB.StringGet(GetKey(key));
if (value.IsNullOrEmpty)
{
return(default(T));
}
T resultModel = JsonSerializer.Deserialize <T>(value);
return(resultModel);
}
public ContextRedis(IOptions <GeneralOptions> options)
{
var settings1 = options.Value.RedisSettings;
Bd = new RedisDB(1);
Bd.DataFormater = new JsonFormater();
//_bd.Host.AddWriteHost(settings1.Server);
//SSL
Bd.Host.AddWriteHost(settings1.Server, settings1.Port, settings1.Ssl);
//password
Bd.Host.AddWriteHost(settings1.Server).Password = settings1.Password;
}
public void PushMessage(string toUserID, string bodyContent)
{
var UserInfo = _userService.GetDeviceToken(toUserID);
if (UserInfo.Status == GetDeviceTokenStatus.Success)
{
if (!string.IsNullOrWhiteSpace(UserInfo.DeviceToken))
{
IMessagePush action = null;
switch (UserInfo.DeviceType)
{
case DeviceTypeEnum.iOS:
{
action = CicadaFacade.Container.Resolve <IMessagePush>("ApplePush");
int UnreadMsgNumber = 1;
if (RedisDB.HashExists("UnreadMsgNumber", UserInfo.UserBaseId))
{
UnreadMsgNumber += RedisDB.HashGet <int>("UnreadMsgNumber", UserInfo.UserBaseId);
}
RedisDB.HashSet <int>("UnreadMsgNumber", UserInfo.UserBaseId, UnreadMsgNumber);
bodyContent = JsonConvert.SerializeObject(new
{
aps = new
{
alert = "您收到一条消息",
badge = UnreadMsgNumber,
sound = "default"
}
});
}; break;
case DeviceTypeEnum.Android:
{
var deviceNumber = UserInfo.DeviceNumber.ToLower();
if (deviceNumber.IndexOf("huawei") >= 0)
{
action = CicadaFacade.Container.Resolve <IMessagePush>("HuaWeiPush");
}
if (deviceNumber.IndexOf("xiaomi") >= 0)
{
action = CicadaFacade.Container.Resolve <IMessagePush>("XiaoMiPush");
}
}; break;
}
if (action != null)
{
action.Push(UserInfo.DeviceToken, bodyContent);
}
}
}
}
public void TestInvalidSKURedis()
{
var redis = new RedisDB();
try
{
var product = redis.GetPriceData(-15117729);
Assert.IsTrue(false);
}
catch
{
Assert.IsTrue(true);
}
}
public void TestRepoVsDataSources()
{
var productId = 13860428;
var redisRepo = new RedisRepository();
var redSky = new RedSkyApi();
var redis = new RedisDB();
var redSkyData = redSky.GetNonPriceDataById(productId);
var repoData = redisRepo.GetProductById(productId);
var redisData = redis.GetPriceData(productId);
Assert.AreEqual(repoData.name, redSkyData.name);
Assert.AreEqual(repoData.id, redSkyData.id);
Assert.AreEqual(repoData.current_price.value, redisData.value);
Assert.AreEqual(repoData.current_price.currency_code, redisData.currency_code);
}
public override Task Execute()
{
var i = OrderHelper.GetOrderID();
var values = RedisDB.StringGet(new RedisKey[] { i.ToString(), (i + 1).ToString() });
object item1, item2;
if (!values[0].IsNullOrEmpty)
{
item1 = System.Text.Json.JsonSerializer.Deserialize <Northwind.Data.Order>(values[0]);
}
if (!values[1].IsNullOrEmpty)
{
item2 = System.Text.Json.JsonSerializer.Deserialize <Northwind.Data.Order>(values[1]);
}
return(base.Execute());
}
public override Task Execute()
{
var i = OrderHelper.GetOrderID();
var values = RedisDB.StringGet(new RedisKey[] { i.ToString(), (i + 1).ToString() });
object item1, item2;
if (!values[0].IsNullOrEmpty)
{
item1 = Newtonsoft.Json.JsonConvert.DeserializeObject(values[0], typeof(Northwind.Data.Order));
}
if (!values[1].IsNullOrEmpty)
{
item2 = Newtonsoft.Json.JsonConvert.DeserializeObject(values[1], typeof(Northwind.Data.Order));
}
return(base.Execute());
}
