public UserInteractUIServiceTest()
{
realRedisService = new RedisService();
userInteractUIService = new UserInteractUIService(realRedisService);
EntityMapping.Config();
realRedisService.FlushAll();
configID = realRedisService.Add<PushConfig>(new PushConfig {
AllowedPeriodFrom = DateTime.Now,
AllowedPeriodTo = DateTime.Now.AddSeconds(10000),
DelaySeconds = 123,
ExecuteTimes = 2,
FailGotoActionId = 1,
SuccessGotoActionId =1,
IntervalSeconds = 60
});
configID2 = realRedisService.Add<PushConfig>(new PushConfig
{
AllowedPeriodFrom = DateTime.Now,
AllowedPeriodTo = DateTime.Now.AddSeconds(1000),
DelaySeconds = 321,
ExecuteTimes = 20,
FailGotoActionId = 10,
SuccessGotoActionId = 10,
IntervalSeconds = 600
});
}
public void Same_model_to_save_twice_will_update_the_existed_values()
{
var app = new App();
app.Id = "Same_model_to_save_twice_will_update_the_existed_values";
app.Name = "SameAppToSaveTwice";
app.Price = 111;
using (var redis = new RedisService())
{
var exited = redis.Get<App>(app.Id);
redis.Delete<App>(exited);
redis.Add<App>(app);
app.Name = "Name1";
redis.Add<App>(app);
var getApp = redis.Get<App>(app.Id);
Assert.NotEmpty(getApp.Name);
redis.Delete<App>(exited);
}
}
private int QuantidadeComentariosCached(int noticiaId)
{
string key = primeKey + "CarregarComentarios:TNoticias:TComentario:" + noticiaId;
int retorno = 0;
Func <object, int> funcao = t => QuantidadeComentariosDB(noticiaId);
retorno = RedisService.GetOrSetToRedis(key, funcao, 30, noticiaId);
return(retorno);
}
private List <ComentarioPagedListViewModel> CarregarComentariosCached(int pagina, int noticiaId, OrdemComentario?ordem)
{
string key = primeKey + "CarregarComentarios:TNoticias:TComentario:" + pagina + ":" + noticiaId;
List <ComentarioPagedListViewModel> retorno = null;
Func <object, List <ComentarioPagedListViewModel> > funcao = t => CarrregarComentariosDB(pagina, noticiaId, ordem);
retorno = RedisService.GetOrSetToRedis(key, funcao, 30, pagina, noticiaId, ordem);
return(retorno);
}
public override Task OnDisconnected(bool stopCalled)
{
var containsKey = Connections.ContainsKey(Context.ConnectionId);
if (containsKey)
{
bool removed = Connections.Remove(this.Context.ConnectionId);
RedisService.UpdateRedis(RedisKeys.Connections, Connections);
}
return(base.OnDisconnected(stopCalled));
}
public void DeleteSessionFromRedis()
{
try
{
RedisService.Remove(this._SessionId);
}
catch (Exception ex)
{
Config.logger.LogError("DeleteSessionFromRedis of {0} fail error: {1}", this._SessionId, ex.Message);
throw ex;
}
}
public void AddSessionToSetInRedis()
{
try
{
RedisService.AddItemToSet(Config.AllSessionsRedisKey, _SessionId);
}
catch (Exception e)
{
Config.logger.LogError("AddSessionToSetInRedis fail error:" + e.Message);
throw e;
}
}
public ValuesController(RedisService redisService,
RedisListService redisListService,
RedisSetService redisSetService,
RedisHashSetService redisHashSetService,
MongoService mongoService)
{
_redisService = redisService;
_redisListService = redisListService;
_redisSetService = redisSetService;
_redisHashSetService = redisHashSetService;
_mongoService = mongoService;
}
public UserController(UserDataDapper userDataDapper,
EmailService emailService,
EncryptionTools encryptionTools,
RedisService redisService,
UserService userService)
{
this.userDataDapper = userDataDapper;
this.emailService = emailService;
this.encryptionTools = encryptionTools;
this.redisService = redisService;
this.userService = userService;
}
public ActionResult T2(string chave, int?page, string palavraChave = "", string dataInicio = "", string dataFinal = "")
{
var hoje = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, 0, 0, 0);
string key = primeKey + "T2:Noticias:" + chave;
Func <object, List <NoticiaEspecialViewModel> > funcao = t => NoticiasEditoriaCached(chave);
var noticiasEditoria = RedisService.GetOrSetToRedis(key, funcao, 60);
key = primeKey + "T2:Editoria:" + chave;
Func <object, EditoriaEspecialViewModel> funcao2 = t => EditoriaEspecial(chave);
var editoria = RedisService.GetOrSetToRedis(key, funcao2, 600);
if (!string.IsNullOrEmpty(palavraChave))
{
noticiasEditoria = noticiasEditoria.Where(n =>
n.titulo.ToLower().Contains(palavraChave.ToLower()) ||
n.texto.ToLower().Contains(palavraChave.ToLower()) ||
n.subTitulo.ToLower().Contains(palavraChave.ToLower()) ||
n.tituloCapa.ToLower().Contains(palavraChave.ToLower()) ||
n.chamada.ToLower().Contains(palavraChave.ToLower())
).ToList();
}
if (!string.IsNullOrEmpty(dataInicio))
{
DateTime DataInicio = DateTime.Parse(dataInicio).AddHours(0).AddMinutes(0).AddSeconds(0);
noticiasEditoria = noticiasEditoria.Where(d => d.dataCadastro >= DataInicio).ToList();
}
if (!string.IsNullOrEmpty(dataFinal))
{
DateTime DataFim = DateTime.Parse(dataFinal).AddHours(23).AddMinutes(59).AddSeconds(59);
noticiasEditoria = noticiasEditoria.Where(d => d.dataCadastro <= DataFim).ToList();
}
var noticiasDestaque = noticiasEditoria.Where(x => x.Destaque)
.Take(2).ToList();
int pageNumber = (page ?? 1);
var pagination = noticiasEditoria.Where(q => !noticiasDestaque.Select(n => n.Id).Contains(q.Id));
var viewModel = new EspeciaisViewModel
{
Editoria = editoria,
destaques = noticiasDestaque,
noticias = pagination.ToPagedList(pageNumber, 9)
};
return(View(viewModel));
}
public App SetupApp <T>(T appItem, AppProject appProject, App app) where T : QihooAppStoreApp
{
var originalApp = CloneHelper.DeepClone <App>(app);
var originalApp2 = RedisService.Get <App>(app.Id);
app.AppNo = appProject.AppNo;
app.AppProjectId = appProject.Id;
app.UseGreaterVersion = true;
ClientImageInfo lg = new ClientImageInfo
{
BelongsToAppId = app.Id,
FileUrl = Path.Combine(LogoDirRoot, GetFileNameFromUri(appItem.IconURL)),
TypeId = AppConfigKey.CLIENT_IMAGE_TYPE_ID
};
RedisService.Add <ClientImageInfo>(lg);
app.ClientLogos = new List <ClientImageInfo>
{
lg
};
ImageInfo lg2 = new ImageInfo
{
BelongsToAppId = app.Id,
FileUrl = Path.Combine(LogoDirRoot, GetFileNameFromUri(appItem.IconURL))
};
RedisService.Add <ImageInfo>(lg2);
app.Logo = lg2;
app.Name = appItem.Name;
app.OrderNumber = appItem.DownloadTimes.ToInt32();
app.DownloadTimes = appItem.DownloadTimes.ToInt32();
app.Status = 1;
var screenShotlist = GetScreenShotlist(appItem);
foreach (var s in screenShotlist)
{
ImageInfo ss = new ImageInfo
{
BelongsToAppId = app.Id,
FileUrl = Path.Combine(ScreenshotDirRoot, GetFileNameFromUri(s))
};
RedisService.Add <ImageInfo>(ss);
app.ScreenShot.Add(ss);
}
app.PlatformType = AppConfigKey.PLATFORM_TYPE_ID.ConfigValue().ToInt32();
app.Summary = appItem.Description.Replace("<br/>", string.Empty).Replace("<br>", string.Empty);
RedisService.UpdateWithRebuildIndex <App>(originalApp2, app);
return(app);
}
public TenantController(
TenantDbContext _db,
RedisService _redis,
IStringLocalizer <TenantController> _localizer,
TenantService _tenantService
)
{
// 多语言
l = _localizer;
redis = _redis;
tenantDb = _db;
tenantService = _tenantService;
}
public ActionResult ReportagensEspeciais()
{
string key = primeKey + "ReportagensEspeciais";
Func <object, List <ReportagemEspecialViewModel> > funcao = t => ReportagensEspeciaisDB();
var reportagensEspeciais = RedisService.GetOrSetToRedis(key, funcao, 60);
var retorno = new ReportagensEspeciaisViewModel {
Reportagens = reportagensEspeciais
};
return(View(retorno));
}
public YearsController(
RedisService redis,
DbService db,
ArtistService artistService,
ShowService showService,
SourceService sourceService,
YearService yearService
) : base(redis, db, artistService)
{
_showService = showService;
_yearService = yearService;
_sourceService = sourceService;
}
static void Main(string[] args)
{
Program program = new Program();
Console.WriteLine("Hello World!");
IRedisService redisService = new RedisService();
Console.Write("Connection : " + redisService.GetRedisClient());
Console.WriteLine("Save in memory database");
program.ReadData();
program.SaveData();
Console.ReadKey();
}
public CodeGenController(
AzureStorageService _storageService,
IStringLocalizer <CodeGenController> localizer,
SwaggerCodeGenService _swagerCodeGen,
INodeServices _nodeServices,
RedisService _redis)
{
l = localizer;
swagerCodeGen = _swagerCodeGen;
nodeServices = _nodeServices;
storageService = _storageService;
redis = _redis;
}
public static void Start(bool shouldFlush)
{
if (!_hasBeenIntialized)
{
if (shouldFlush)
{
// clear data
var svc = new RedisService();
svc.FlushAll();
}
_hasBeenIntialized = true;
}
}
public static bool UpdateAutoUploadTime(int devId)
{
var rst = false;
if (_devStatusDic.ContainsKey(devId))
{
_devStatusDic[devId].AutoUploadTime = DateTime.Now;
RedisService.GetRedisDatabase().StringSet($"Device-LastAutoUploadTime:{AppConfig.CompanyName}-{devId}", $"{DateTime.Now:yyyy-MM-dd HH:mm:ss fff}");
rst = true;
}
return(rst);
}
public ImportController(
RedisService redis,
DbService db,
ArtistService artistService,
ImporterService importer,
ScheduledService scheduledService,
IConfiguration configuration
) : base(redis, db, artistService)
{
_configuration = configuration;
_scheduledService = scheduledService;
_importer = importer;
}
public TestService(
ILogger <TestService> logger,
IDbService dbService,
IJwtService jwtService,
RedisService redisService,
ElasticSearchService es)
{
this._logger = logger;
base._dbService = dbService;
this._jwtService = jwtService;
this._redis = redisService;
this._es = es;
}
public FunctionOpenResult<bool> UpdateByID(AppToken info) {
var r = new FunctionOpenResult<bool>();
r.Data = AppTokenDal.Update(info) > 0;
if (r.Data&&info.Status)
{
RedisService.Set<AppToken>("default", String.Format(ConfigAuthorityCacheKey.AuthorityCacheKey, info.AppId), info);
}
else
{
RedisService.Delete("default", String.Format(ConfigAuthorityCacheKey.AuthorityCacheKey, info.AppId));
}
return r;
}
public static List <BannerTopoViewModel> getBanners()
{
string key = primeKey + "getBanners:TBanners";
List <BannerTopoViewModel> retorno = null;
Func <object, List <BannerTopoViewModel> > funcao = t => getBannersDB();
retorno = RedisService.GetOrSetToRedis(key, funcao, 600);
return(retorno
.OrderBy(x => Guid.NewGuid())
.Take(5).ToList());
}
public UserController(UserDataDapper userDataDapper,
EmailService emailService,
EncryptionTools encryptionTools,
IOptions <APPConfiguration> configuration,
RedisService redisService,
UserService userService)
{
this.userDataDapper = userDataDapper;
this.emailService = emailService;
this.encryptionTools = encryptionTools;
this.configuration = configuration.Value;
this.redisService = redisService;
this.userService = userService;
}
private static void BannersToFIFO(List <PublicidadeViewModel> lista)
{
var banners = lista.Select(p => new BannersVisualizacoesCliques {
CodigoBanner = p.Id,
Visualizacao = true,
Clique = false,
DataCadastro = DateTime.Now
}).ToList();
foreach (var banner in banners)
{
RedisService.LeftPush(banner, ConfigurationManager.AppSettings["BannersFIFOKey"]);
}
}
/// <summary>
/// 通过配置字符串强行获取Redis服务
/// </summary>
/// <param name="configIp"></param>
/// <returns></returns>
public static IRedisService GetService(string configIp)
{
if (_RedisDic == null)
{
_RedisDic = new Dictionary<string, IRedisService>();
}
IRedisService redis;
if (!_RedisDic.TryGetValue(configIp, out redis))
{
redis = new RedisService(configIp);
_RedisDic.Add(configIp, redis);
}
return redis;
}
public AppProject SetupAppProject(BaiduAppDetail appItem, AppProject appProject)
{
var originalAppProject = CloneHelper.DeepClone <AppProject>(appProject);
appProject.AppNo = "baidu_" + appItem.Id;
appProject.Creator = appItem.SourceName;
appProject.LogoFile = GetFileNameFromUri(GetDownloadUrl(appItem.IconUrl));
appProject.Name = appItem.Name;
appProject.PackageName = appItem.PackageName;
//appProject.Rate = appItem.Rating.ToInt32();
RedisService.UpdateWithRebuildIndex <AppProject>(originalAppProject, appProject);
return(appProject);
}
public AccountController(UserDataDapper userDataDapper,
EmailService emailService,
EncryptionTools encryptionTools,
IOptions <APPConfiguration> configuration,
RedisService redisService
)
{
this.userDataDapper = userDataDapper;
this.emailService = emailService;
this.encryptionTools = encryptionTools;
this.configuration = configuration.Value;
this.redisService = redisService;
this.authClient = GetOAuthClient();
}
public static bool Register(int devId)//对这个设备进行注册
{
var rst = false;
if (_devStatusDic.ContainsKey(devId))
{
RedisService.GetRedisDatabase().StringSet($"Device-LastConnectTime:{AppConfig.CompanyName}-{devId}", $"{DateTime.Now:yyyy-MM-dd HH:mm:ss fff}");
_devStatusDic[devId].IsRegistered = true;
rst = true;
}
return(rst);
}
public AppProject SetupAppProject <T>(T appItem, AppProject appProject) where T : QihooAppStoreApp
{
var originalAppProject = CloneHelper.DeepClone <AppProject>(appProject);
appProject.AppNo = "qh360_" + appItem.Id;
appProject.Creator = appItem.Developer;
appProject.LogoFile = GetFileNameFromUri(appItem.IconURL);
appProject.Name = appItem.Name;
appProject.PackageName = appItem.PackageName;
appProject.Rate = appItem.Rating.ToInt32();
RedisService.UpdateWithRebuildIndex <AppProject>(originalAppProject, appProject);
return(appProject);
}
public static Boolean UserAuth(String token)
{
Boolean result = false;
var info = RedisService.Get <LoginToken>(DefineTable.CacheName, String.Format(UserAuthorityCacheKey.AuthorityCacheKey, token));
if (info != null)
{
if ((info.Status) && (info.EndTime > DateTime.Now))
{
result = true;
}
}
return(result);
}
public AttackController(ILogger <AttackController> logger,
IHubContext <AttackHub> hubContext,
DnsDbContext dnsDb,
AttackService attackService,
NotifyService notifyService,
RedisService redisService)
{
_logger = logger;
_hubContext = hubContext;
_dnsDb = dnsDb;
_attackService = attackService;
_notifyService = notifyService;
_redisService = redisService;
}
public void DeleteUser(string id, UserModel model)
{
db = new TimeAttendanceEntities();
var objectDelete = db.User.Where(r => r.UserId.Equals(id) && r.DeleteFlg == Constants.DeleteFalse);
if (objectDelete == null)
{
throw new BusinessException(ErrorMessage.ERR003);
}
using (var trans = db.Database.BeginTransaction())
{
try
{
var type = objectDelete.FirstOrDefault().Type;
var userName = objectDelete.FirstOrDefault().Name;
//Xóa Tokens
var deleteAuth = authContext.RefreshTokens.Where(r => r.Subject.Equals(userName));
authContext.RefreshTokens.RemoveRange(deleteAuth);
authContext.SaveChanges();
//Xóa logic tài khoản, gán lại cờ Delete = true
objectDelete.First().DeleteFlg = Constants.DeleteTrue;
//luu Log lich su
string decription = "Xóa thông tin có tên là: " + userName;
LogBusiness.SaveLogEvent(db, model.LogUserId, decription, null);
db.SaveChanges();
trans.Commit();
//xóa cache
// var RedisConnection = System.Configuration.ConfigurationManager.AppSettings["RedisConnection"];
var redis = RedisService <LoginCacheModel> .GetInstance(RedisConnection);
LoginCacheModel RefreshToken;
RefreshToken = redis.Get <LoginCacheModel>(Constants.ATLogin + userName);
if (RefreshToken != null)
{
redis.Remove(Constants.ATLogin + userName);
}
}
catch (Exception ex)
{
trans.Rollback();
throw new ErrorException(ErrorMessage.ERR001, ex.InnerException);
}
}
}
public static List <HouseDashboard> LoadDashboard()
{
string houseDashboardJson = RedisService.ReadCache("HouseDashboard");
if (string.IsNullOrEmpty(houseDashboardJson))
{
List <HouseDashboard> dashboards = HouseDapper.GetHouseDashboard();
RedisService.WriteCache("HouseDashboard", Newtonsoft.Json.JsonConvert.SerializeObject(dashboards));
return(dashboards);
}
else
{
return(Newtonsoft.Json.JsonConvert.DeserializeObject <List <HouseDashboard> >(houseDashboardJson));
}
}
public void DeleteAppsByAppProject(string appProjectId)
{
var apps = this.AppStoreUIService.GetAppsFromAppList <AppProject>(appProjectId);
if (apps != null)
{
foreach (var app in apps)
{
DeleteTags(app);
DeleteRedundanceForAppBranch(app.Id);
RedisService.DeleteWithCustomProperties <App, CustomProperty>(app.Id);
DeleteAppSettingForAppColumn(app.Id);
}
}
}
public void ShouldAddCommentLikeSuccessfullyEndToEnd()
{
_commentsLogic = new Mock<ICommentsLogic>();
_commentsLogic.Setup(a => a.Get(It.IsAny<int>())).Returns(new Comment { Id = 1, PostId = 1 });
_commentLikesLogic = new Mock<ICommentLikesLogic>();
_commentLikesLogic.Setup(a => a.Get(It.IsAny<int>())).Returns(_commentLikes);
_commentLikesLogic.Setup(a => a.Add(It.IsAny<CommentLike>()))
.Returns(new CommentLike { CommentLikeId = 1, CommentId = 1 });
var redisService = new RedisService(new ConfigurationHelper());
var commentLikesService = new CommentLikesService(_commentLikesLogic.Object, _commentsLogic.Object, redisService);
Assert.DoesNotThrow(() => commentLikesService.Add(new CommentLike { CommentLikeId = 1, CommentId = 1 }));
}
public GameCenterServiceTest()
{
var redis = new RedisService();
_gamecenterUIService = new Mock<IGameCenterUIService>();
AppStoreUIService = new Mock<IAppStoreUIService>();
_mailService = new Mock<IMailService>();
mailService = _mailService.Object;
GameCenterUIService = new GameCenterUIService(redis);
EntityMapping.ResetMapper();
EntityMapping.Config();
Bootstrapper.ConfigueInjection();
if (!ConfigurationManager.ConnectionStrings["ConnectionStringOracleGeneral"].ConnectionString.Contains("192.168.1.184"))
{
throw new Exception("please using 192.168.1.184 as test oracle DB.");
}
this.Repository = new SimpleRepository("ConnectionStringOracleGeneral", SimpleRepositoryOptions.RunMigrations);
}
public void update_model_should_throw_exception_if_they_have_differentIds()
{
using (var redis = new RedisService())
{
var app = new App();
app.Id = "update_model_should_throw_exception_if_they_have_differentIds";
app.Name = "test_update";
redis.Delete<App>(app);
redis.Add<App>(app);
//change the property
var newApp = new App();
newApp.Id = "new_update_model_should_throw_exception_if_they_have_differentIds";
var ex = Assert.Throws<ArgumentException>(() => redis.UpdateWithRebuildIndex<App>(app, newApp));
Assert.True(ex.Message.Contains("different"));
redis.Delete<App>(app);
}
}
public RedisMapperTests()
{
redis = new RedisService();
redis.FlushAll();
}
public void intersect_variable_set_test()
{
using (var redis = new RedisService())
{
var ids = new List<string>();
ids.Add("a");
ids.Add("b");
ids.Add("c");
redis.DoIndexBySet<App>("b", "2", "And");
redis.DoIndexBySet<App>("c", "2", "And");
redis.DoIndexBySet<App>("d", "2", "And");
redis.DoIndexBySet<App>("c", "3", "And");
redis.DoIndexBySet<App>("d", "3", "And");
redis.DoIndexBySet<App>("e", "3", "And");
redis.DoIndexBySet<App>("f", "4", "And");
redis.DoIndexBySet<App>("d", "4", "And");
redis.DoIndexBySet<App>("e", "4", "And");
var result = redis.GetIntersectIdsByPropertyFromSets<App>(ids, "2:And", "3:And");
Assert.Equal(result.Count, 1);
Assert.Equal(result[0], "c");
var result2 = redis.GetIntersectIdsByPropertyFromSets<App>(ids, "2:And", "4:And");
Assert.Equal(result2.Count, 0);
redis.DoIndexBySet<App>("b", "2", "And",true);
redis.DoIndexBySet<App>("c", "2", "And",true);
redis.DoIndexBySet<App>("d", "2", "And",true);
redis.DoIndexBySet<App>("c", "3", "And",true);
redis.DoIndexBySet<App>("d", "3", "And",true);
redis.DoIndexBySet<App>("e", "3", "And",true);
redis.DoIndexBySet<App>("c", "4", "And",true);
redis.DoIndexBySet<App>("d", "4", "And",true);
redis.DoIndexBySet<App>("e", "4", "And",true);
}
}
public void Start(IPEndPoint localEndPoint)
{
listenSocket = new Socket(localEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
listenSocket.Bind(localEndPoint);
listenSocket.Listen(m_numConnections);
StartAccept(null);
m_daemonThread = new DaemonThread(this);
RedisService redis = new RedisService();
SocketServer = this;
}
public void integration_test_for_user_upload_info()
{
var namevalues = new NameValueCollection();
namevalues[MobileParam.Key_IMSI] = TEST_IMSI;
_requestRepoMock.Setup<NameValueCollection>(m => m.Header).Returns(namevalues);
MobileParam mobileParam = new MobileParam(requestRepo);
var realRedisService = new RedisService();
var realRedisLogger = new RedisLogger();
realRedisService.FlushAll();
realRedisLogger.Flush();
UserInteractService userInteractService = new UserInteractService(realRedisLogger, realRedisService, new UserInteractUIService(realRedisService));
//first time , add
UserUploadInfo userUploadInfo = new UserUploadInfo
{
ActivityInfos = GetAndroidUserAppActivityInfos(),
AppInfos = GetAppInfos(),
AppTrafficInfos = GetAppTrafficInfos()
};
userInteractService.SaveUserUploadInfos(mobileParam, userUploadInfo);
//second time , update
namevalues = new NameValueCollection();
namevalues[MobileParam.Key_IMSI] = TEST_IMSI;
namevalues[MobileParam.Key_IsTouch] = "1";
_requestRepoMock.Setup<NameValueCollection>(m => m.Header).Returns(namevalues);
mobileParam = new MobileParam(requestRepo);
userInteractService.SaveUserUploadInfos(mobileParam, userUploadInfo);
Assert.NotNull(realRedisService.GetValueFromHash<string>("U:9460002850533220", "com.packagename.app1"));
using (var redis = RedisClientManager.GetReadOnlyClient())
{
Assert.Equal(2, redis.GetListCount("Queue:AndroidUserUploadInfo:Logger"));
var secondAndroidUserUploadInfo = JsonConvert.DeserializeObject<LogModel>(redis.GetItemFromList("Queue:AndroidUserUploadInfo:Logger", 1));
Assert.Equal(LogOperationType.Update, secondAndroidUserUploadInfo.Operation);
Assert.Equal(6, redis.GetListCount("Queue:AndroidUserAppInfo:Logger"));
Assert.Equal(4, redis.GetListCount("Queue:AndroidUserAppTrafficInfo:AndroidUserAppTrafficInfoLogger"));
Assert.Equal(4, redis.GetListCount("Queue:AndroidUserAppActivityInfo:AndroidUserAppActivityInfoLogger"));
}
}
public void parse_client_upload_json_to_proper_entity()
{
string json = "{\"apps\":[{\"pkg\":\"com.tyd.weather\",\"ver\":\"21\",\"vername\":\"1.2.1\",\"md5\":\"5454212125454asfda3\",\"action\":0},{\"pkg\":\"com.tyd.music\",\"ver\":\"21\",\"vername\":\"2.2.1\",\"md5\":\"jdlfjalj459895894\",\"action\":0}],\"traffics\":[{\"pkg\":\"com.tyd.weather\",\"traffic\":10024},{\"pkg\":\"com.tyd.music\",\"traffic\":23232}],\"activities\":[{\"pkg\":\"com.tyd.weather\",\"times\":\"0|0|0|0|0|0|0|0|0|0|22|3|3|0|2|2|2|2|2|2|2|0|0|0\"},{\"pkg\":\"com.tyd.music\",\"times\":\"0|0|0|0|0|0|0|0|0|0|22|3|3|0|2|2|2|2|2|2|2|0|0|0\"}],\"from\":\"2012-05-13T00:00:00+08:00\",\"to\":\"2012-05-15T00:00:00+08:00\"}";
ClientData clientData = JsonConvert.DeserializeObject<ClientData>(json);
var realRedisService = new RedisService();
var realRedisLogger = new RedisLogger();
UserInteractService userInteractService = new UserInteractService(realRedisLogger, realRedisService, new UserInteractUIService(realRedisService));
var userUploadInfo = userInteractService.GetUserUploadInfo(clientData, TEST_IMSI);
Assert.Equal(2, userUploadInfo.ActivityInfos.Count);
Assert.Equal(22, userUploadInfo.ActivityInfos[0].Eleven);
Assert.Equal(2, userUploadInfo.AppInfos.Count);
Assert.Equal("5454212125454asfda3", userUploadInfo.AppInfos[0].AndroidUserAppInfo.MD5);
Assert.Equal(2, userUploadInfo.AppTrafficInfos.Count);
Assert.Equal(10024, userUploadInfo.AppTrafficInfos[0].Traffic);
}
public ActionResult CheckDupFile()
{
var redis = new RedisService();
var appStore = new AppStoreUIService(new FileService(), redis);
var appIds = redis.GetAllActiveModelIds<App>().ToIdsWithNoPrefix<App>();
List<App> apps = new List<App>();
Dictionary<string, List<string>> batchCategory = new Dictionary<string, List<string>>();
foreach (var id in appIds)
{
if (redis.IsExist("App:" + id))
{
var app = redis.GetModelWithCustomProperties<App, CustomProperty>(id);
//if (app.CustomProperties.ContainsKey("1"))
//{
// if (batchCategory.ContainsKey(app.CustomProperties["1"].ToString()))
// {
// batchCategory[app.CustomProperties["1"].ToString()].Add(id);
// }
// else
// {
// batchCategory[app.CustomProperties["1"].ToString()] = new List<string> { id };
// }
//}
// if (app.CustomProperties.ContainsValue("MTK_6255*"))
//{
apps.Add(app);
//}
}
}
Dictionary<string, List<string>> dups = new Dictionary<string, List<string>>();
foreach (var app in apps)
{
string flag6255 = string.Empty;
if (app.CustomProperties != null && app.CustomProperties.ContainsKey("1") && app.CustomProperties["1"].ToString().Equals("MTK_6255*")
&& app.CustomProperties.ContainsKey("2") && app.CustomProperties["2"].ToString().Equals("480x800"))
{
flag6255 = "<lable style=\"color:red\"> <<<<<<<<<<<< MTK_6255* & 480x800</label>";
}
if (!string.IsNullOrEmpty(app.CurrentTestVersion))
{
var ver = appStore.GetCurrentTestVersionForApp(app.Id);
if (ver != null)
{
if (dups.ContainsKey(ver.FileUrl))
{
dups[ver.FileUrl].Add(string.Format("<a href=\"http://inet.kk570.com/AppStoresUI/AppDetails?appProjectId={0}&appId={1}\"> click here to fix Internal Test publish App {2} </a> {3}", app.AppProjectId, app.Id, app.Name, flag6255));
}
else
{
dups[ver.FileUrl] = new List<string> { string.Format("<a href=\"http://inet.kk570.com/AppStoresUI/AppDetails?appProjectId={0}&appId={1}\"> click here to fix Internal Test publish App {2} </a>{3}", app.AppProjectId, app.Id, app.Name, flag6255) };
}
}
}
if (!string.IsNullOrEmpty(app.CurrentVer))
{
var ver = appStore.GetCurrentVersionForApp(app.Id);
if (ver != null)
{
if (dups.ContainsKey(ver.FileUrl))
{
dups[ver.FileUrl].Add(string.Format("<a href=\"http://inet.kk570.com/AppStoresUI/AppDetails?appProjectId={0}&appId={1}\"> click here to fix Published App {2} </a>{3}", app.AppProjectId, app.Id, app.Name, flag6255));
}
else
{
dups[ver.FileUrl] = new List<string> { string.Format("<a href=\"http://inet.kk570.com/AppStoresUI/AppDetails?appProjectId={0}&appId={1}\"> click here to fix Published App {2} </a>{3}", app.AppProjectId, app.Id, app.Name, flag6255) };
}
}
}
}
StringBuilder sb = new StringBuilder();
foreach (var kv in dups)
{
if (kv.Value.Count > 1)
{
sb.Append(string.Format("<lable style=\"color:gray\">File {0} duplicate in:</label> <br/>", kv.Key));
foreach (var v in kv.Value)
{
sb.Append(v + "<br/>");
}
sb.Append("<br/>");
}
}
return Content(sb.ToString(), "text/html");
}
public void Market31()
{
var redis = new RedisService();
var appstoreService = new AppStoreService(MockFileService.Object, redis, MockAppStoreUIService.Object, MockFullTextSearchService.Object,MockIMEICacheService.Object);
_processor = new StatisticDataProcessor(redis);
_processor.oracleRepo = MockOracleRepo.Object;
var globalKey = _processor.GetKey(StatisticConsts.Market31.GLOBAL_IMEI);
redis.AddItemToSet(globalKey, "0");
//var globalIMEIList = new List<string> { "0" };
// the exist imei is 0 only
appstoreService.MarketStatistic(MarketStatisticType.Market31, DateTime.Now.AddDays(-1), GetMobileParam("N1", "F1", "0"));
appstoreService.MarketStatistic(MarketStatisticType.Market31, DateTime.Now.AddDays(-1), GetMobileParam("N1", "F1", "1"));
appstoreService.MarketStatistic(MarketStatisticType.Market31, DateTime.Now.AddDays(-1), GetMobileParam("N2", "F1", "2"));
appstoreService.MarketStatistic(MarketStatisticType.Market31, DateTime.Now.AddDays(-1), GetMobileParam("N1", "F2", "3"));
appstoreService.MarketStatistic(MarketStatisticType.Market31, DateTime.Now.AddDays(-1), GetMobileParam("N2", "F2", "4"));
//setup oracle
MockOracleRepo.Setup(x => x.Find<Market31StatisticSummary>(It.IsAny<Expression<Func<Market31StatisticSummary, bool>>>())).Returns(default(IList<Market31StatisticSummary>));
MockOracleRepo.Setup(x => x.Find<Market31ActiveUserUVStatistic>(It.IsAny<Expression<Func<Market31ActiveUserUVStatistic, bool>>>())).Returns(default(IList<Market31ActiveUserUVStatistic>));
MockOracleRepo.Setup(x => x.Find<Market31AddUserUVStatistic>(It.IsAny<Expression<Func<Market31AddUserUVStatistic, bool>>>())).Returns(default(IList<Market31AddUserUVStatistic>));
MockOracleRepo.Setup(x => x.Find<Market31PVStatistic>(It.IsAny<Expression<Func<Market31PVStatistic, bool>>>())).Returns(default(IList<Market31PVStatistic>));
MockOracleRepo.Setup(x => x.Add<Market31StatisticSummary>(It.IsAny<Market31StatisticSummary>()));
MockOracleRepo.Setup(x => x.Add<Market31AddUserUVStatistic>(It.IsAny<Market31AddUserUVStatistic>()));
MockOracleRepo.Setup(x => x.Add<Market31ActiveUserUVStatistic>(It.IsAny<Market31ActiveUserUVStatistic>()));
MockOracleRepo.Setup(x => x.Add<Market31PVStatistic>(It.IsAny<Market31PVStatistic>()));
_processor.SaveStatisticData(StatisticActionType.Market_31);
// verify
MockOracleRepo.Verify(x => x.Add<Market31StatisticSummary>(It.IsAny<Market31StatisticSummary>()), Times.Exactly(2));
MockOracleRepo.Verify(x => x.Add<Market31AddUserUVStatistic>(It.IsAny<Market31AddUserUVStatistic>()), Times.Exactly(4));
MockOracleRepo.Verify(x => x.Add<Market31ActiveUserUVStatistic>(It.IsAny<Market31ActiveUserUVStatistic>()), Times.Exactly(4));
MockOracleRepo.Verify(x => x.Add<Market31PVStatistic>(It.IsAny<Market31PVStatistic>()), Times.Exactly(4));
var globalIMEICount = redis.GetAllItemsFromSet(globalKey);
Assert.Equal(5, globalIMEICount.Count);
}
public void get_sequence_num_should_work_in_concurrent_situation()
{
using (var redis = new RedisService())
{
const string key = "SEQ_key";
Action<object> action = (object id) =>
{
Console.WriteLine(redis.GetNextSequenceNum(key));
};
Task t1 = Task.Factory.StartNew(action, "1");
Task t2 = Task.Factory.StartNew(action, "2");
Task t3 = Task.Factory.StartNew(action, "3");
Task t4 = Task.Factory.StartNew(action, "4");
Task t5 = Task.Factory.StartNew(action, "5");
Task t6 = Task.Factory.StartNew(action, "6");
Task t7 = Task.Factory.StartNew(action, "7");
Task t8 = Task.Factory.StartNew(action, "8");
Task t9 = Task.Factory.StartNew(action, "9");
Task t0 = Task.Factory.StartNew(action, "10");
t1.Wait();
t2.Wait();
t3.Wait();
t4.Wait();
t5.Wait();
t6.Wait();
t7.Wait();
t8.Wait();
t9.Wait();
t0.Wait();
long result = redis.GetNextSequenceNum(key);
Assert.Equal(11, result);
redis.FlushAll();
}
}
