Ejemplo n.º 1
0
        public async Task <IActionResult> GetBookingCountByYear()
        {
            Request.Headers.TryGetValue("Authorization", out var token);
            string role = await AuthHelper.GetRoleFromTokenAsync(token);

            if (role != "admin")
            {
                Log.Error("401 Error. Unauthorized in Analytical Controller: Get()");
                return(StatusCode(401, new { Error = "Unauthorized" }));
            }

            Log.Information("Getting Booking Count By Year for Admin.");
            IEnumerable <CountByDateNumber> data = new List <CountByDateNumber>();
            string cachedDataString = string.Empty;

            cachedDataString = await DistributedCache.GetStringAsync("_count_by_year");

            if (!string.IsNullOrEmpty(cachedDataString))
            {
                Log.Information("Returned cached results.");
                // loaded data from the redis cache.
                data = JsonSerializer.Deserialize <IEnumerable <CountByDateNumber> >(cachedDataString);
                return(Ok(new BaseResponse <IEnumerable <CountByDateNumber> >(data, true))); // IsCached = true
            }
            else
            {
                Log.Information("Cached new results.");
                var baseResponse = await Mediator.Send(new GetBookingCountByYearQuery());

                // loading from code (in real-time from database)
                // then saving to the redis cache
                data             = baseResponse.Data;
                cachedDataString = JsonSerializer.Serialize <IEnumerable <CountByDateNumber> >(baseResponse.Data);
                var expiryOptions = new DistributedCacheEntryOptions()
                {
                    AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(600),
                    SlidingExpiration = TimeSpan.FromSeconds(300)
                };
                await DistributedCache.SetStringAsync("_count_by_year", cachedDataString);

                return(Ok(baseResponse)); // IsCached = false
            }
        }
Ejemplo n.º 2
0
        public async Task <IActionResult> GetBookingByStudent(int id, int PageNumber, int PageSize)
        {
            /**  Request.Headers.TryGetValue("Authorization", out var token);
             * string role = await AuthHelper.GetRoleFromTokenAsync(token);
             * Console.WriteLine("role", role);
             * if (role != "student" || role != "admin")
             *    return StatusCode(401, new { Error = "Unauthorized" });*/

            var validFilter = new PaginationFilter(PageNumber, PageSize);

            IEnumerable <Booking> data = new List <Booking>();
            string cachedDataString    = string.Empty;

            cachedDataString = await DistributedCache.GetStringAsync("_bookings_by_students_" + id + "_" + validFilter.PageNumber);

            if (!string.IsNullOrEmpty(cachedDataString))
            {
                // loaded data from the redis cache.
                data = JsonSerializer.Deserialize <IEnumerable <Booking> >(cachedDataString);
                return(Ok(new BaseResponse <IEnumerable <Booking> >(data, true))); // IsCached = true
            }
            else
            {
                var baseResponse = await Mediator.Send(new GetBookingByStudentQuery { Id = id, PageNumber = validFilter.PageNumber, PageSize = validFilter.PageSize });

                // loading from code (in real-time from database)
                // then saving to the redis cache
                if (baseResponse.Success)
                {
                    data             = baseResponse.Data;
                    cachedDataString = JsonSerializer.Serialize <IEnumerable <Booking> >(baseResponse.Data);
                    var expiryOptions = new DistributedCacheEntryOptions()
                    {
                        AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(600),
                        SlidingExpiration = TimeSpan.FromSeconds(300)
                    };
                    await DistributedCache.SetStringAsync("_bookings_by_students_" + id + "_" + validFilter.PageNumber, cachedDataString);

                    return(Ok(baseResponse)); // IsCached = false
                }
                return(StatusCode(baseResponse.Error.StatusCode, baseResponse.Error));
            }
        }
Ejemplo n.º 3
0
        public void DistributedCache_Get_UsesRegisteredDistributedCacheProvider()
        {
            using (new MunqContext())
            {
                var registrar = Dependency.Resolve <IDependencyRegistrar>();

                var cache = A.Fake <IDistributedCache>();
                registrar.RegisterInstance(cache);

                A.CallTo(() => cache.Get <int>("SomeKey"))
                .Returns(13579);

                var actual = DistributedCache.Get <int>("SomeKey");
                Assert.Equal(13579, actual);

                A.CallTo(() => cache.Get <int>("SomeKey"))
                .MustHaveHappened(1, Times.Exactly);
            }
        }
Ejemplo n.º 4
0
        public ActionResult Login(string userName, string password)
        {
            var    users     = ConfigCenterBusiness.WebUser;
            string accesskey = Guid.NewGuid().ToString();
            var    user      = users.Where(t => t.UserName.Equals(userName) && t.PassWord.Equals(password)).FirstOrDefault();

            if (user == null)
            {
                ViewData["result"] = "用户名或密码错误";
                return(View());
            }
            Session[CacheKeys.WebUserCacheKey] = user;
            DistributedCache.Set(string.Format(CacheKeys.UserSessionKey_Arg1, accesskey), user, DateTime.Now.AddHours(8));
            HttpCookie cookie = new HttpCookie("accesskey", accesskey);

            cookie.Expires = DateTime.Now.AddYears(1);
            Response.Cookies.Add(cookie);
            return(RedirectToAction("Index", "Home"));
        }
Ejemplo n.º 5
0
        public async Task Remove(int id)
        {
            try
            {
                var payMethods = await LoadFromRedis();

                var payMethod = payMethods.FirstOrDefault(c => c.Id == id);
                if (payMethod != null)
                {
                    payMethods.Remove(payMethod);

                    await DistributedCache.Set(_cacheKey,
                                               payMethods);
                }
            }
            catch (Exception exception)
            {
                _logger.Info(exception.ToString);
            }
        }
Ejemplo n.º 6
0
        public async Task Remove(int id)
        {
            try
            {
                var invoiceStatuses = await LoadFromRedis();

                var invoiceStatus = invoiceStatuses.FirstOrDefault(c => c.Id == id);
                if (invoiceStatus != null)
                {
                    invoiceStatuses.Remove(invoiceStatus);

                    await DistributedCache.Set(_cacheKey,
                                               invoiceStatuses);
                }
            }
            catch (Exception exception)
            {
                _logger.Info(exception.ToString);
            }
        }
        public async Task Remove(int id)
        {
            try
            {
                var crmUsers = await LoadFromRedis();

                var crmUser = crmUsers.FirstOrDefault(c => c.Id == id);
                if (crmUser != null)
                {
                    crmUsers.Remove(crmUser);

                    await DistributedCache.Set(_cacheKey,
                                               crmUsers);
                }
            }
            catch (Exception exception)
            {
                _logger.Info(exception.ToString);
            }
        }
        public async Task Remove(int id)
        {
            try
            {
                var appConfigs = await LoadFromRedis();

                var appConfig = appConfigs.FirstOrDefault(c => c.Id == id);
                if (appConfig != null)
                {
                    appConfigs.Remove(appConfig);

                    await DistributedCache.Set(_cacheKey,
                                               appConfigs);
                }
            }
            catch (Exception exception)
            {
                _logger.Info(exception.ToString);
            }
        }
        public async Task Remove(int id)
        {
            try
            {
                var branches = await LoadFromRedis();

                var branch = branches.FirstOrDefault(c => c.Id == id);
                if (branch != null)
                {
                    branches.Remove(branch);

                    await DistributedCache.Set(_cacheKey,
                                               branches);
                }
            }
            catch (Exception exception)
            {
                _logger.Info(exception.ToString);
            }
        }
Ejemplo n.º 10
0
        public async Task Remove(int id)
        {
            try
            {
                var taskPriorities = await LoadFromRedis();

                var taskPriority = taskPriorities.FirstOrDefault(c => c.Id == id);
                if (taskPriority != null)
                {
                    taskPriorities.Remove(taskPriority);

                    await DistributedCache.Set(_cacheKey,
                                               taskPriorities);
                }
            }
            catch (Exception exception)
            {
                _logger.Info(exception.ToString);
            }
        }
Ejemplo n.º 11
0
        public async Task Remove(int id)
        {
            try
            {
                var customerSources = await LoadFromRedis();

                var customerSource = customerSources.FirstOrDefault(c => c.Id == id);
                if (customerSource != null)
                {
                    customerSources.Remove(customerSource);

                    await DistributedCache.Set(_cacheKey,
                                               customerSources);
                }
            }
            catch (Exception exception)
            {
                _logger.Info(exception.ToString);
            }
        }
Ejemplo n.º 12
0
        protected void Initialize()
        {
            EngineContext.Initialize(false);

            //set dependency resolver
            var dependencyResolver = new GrouponDependencyResolver();

            DependencyResolver.SetResolver(dependencyResolver);

            // initialize cache
            //普通缓存(可以是EntLib、Memcached Or Redis)
            Cache.InitializeWith(new CacheProviderFactory(ConfigurationManager.AppSettings["CacheProvider"]));
            //分布式缓存(Memcached Or Redis)
            DistributedCache.InitializeWith(new CacheProviderFactory(ConfigurationManager.AppSettings["DistributedCacheProvider"]));
            Config.SetSystemCode("S012");

            var typeAdapterFactory = EngineContext.Current.Resolve <ITypeAdapterFactory>();

            TypeAdapterFactory.SetCurrent(typeAdapterFactory);
        }
Ejemplo n.º 13
0
        public async Task Remove(int id)
        {
            try
            {
                var receiptDescriptions = await LoadFromRedis();

                var receiptDescription = receiptDescriptions.FirstOrDefault(c => c.Id == id);
                if (receiptDescription != null)
                {
                    receiptDescriptions.Remove(receiptDescription);

                    await DistributedCache.Set(_cacheKey,
                                               receiptDescriptions);
                }
            }
            catch (Exception exception)
            {
                _logger.Info(exception.ToString);
            }
        }
        public async Task Remove(int id)
        {
            try
            {
                var productGroups = await LoadFromRedis();

                var productGroup = productGroups.FirstOrDefault(c => c.Id == id);
                if (productGroup != null)
                {
                    productGroups.Remove(productGroup);

                    await DistributedCache.Set(_cacheKey,
                                               productGroups);
                }
            }
            catch (Exception exception)
            {
                _logger.Info(exception.ToString);
            }
        }
        public async Task Remove(int id)
        {
            try
            {
                var districts = await LoadFromRedis();

                var district = districts.FirstOrDefault(c => c.Id == id);
                if (district != null)
                {
                    districts.Remove(district);

                    await DistributedCache.Set(_cacheKey,
                                               districts);
                }
            }
            catch (Exception exception)
            {
                _logger.Info(exception.ToString);
            }
        }
Ejemplo n.º 16
0
        public async Task <IActionResult> SearchStudentByName(string Query)
        {
            Request.Headers.TryGetValue("Authorization", out var token);

            string role = await AuthHelper.GetRoleFromTokenAsync(token);

            if (role != "admin")
            {
                return(StatusCode(401, new { Error = "Unauthorized" }));
            }


            IEnumerable <StudentDTO> data = new List <StudentDTO>();
            string cachedDataString       = string.Empty;

            cachedDataString = await DistributedCache.GetStringAsync("_students_search_" + Query);

            if (!string.IsNullOrEmpty(cachedDataString))
            {
                // loaded data from the redis cache.
                data = JsonSerializer.Deserialize <IEnumerable <StudentDTO> >(cachedDataString);
                return(Ok(new BaseResponse <IEnumerable <StudentDTO> >(data, true))); // IsCached = true
            }
            else
            {
                var baseResponse = await Mediator.Send(new GetStudentByNameQuery { Query = Query });

                // loading from code (in real-time from database)
                // then saving to the redis cache
                data             = baseResponse.Data;
                cachedDataString = JsonSerializer.Serialize <IEnumerable <StudentDTO> >(baseResponse.Data);
                var expiryOptions = new DistributedCacheEntryOptions()
                {
                    AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(600),
                    SlidingExpiration = TimeSpan.FromSeconds(300)
                };
                await DistributedCache.SetStringAsync("_students_search_" + Query, cachedDataString);

                return(Ok(baseResponse)); // IsCached = false
            }
        }
Ejemplo n.º 17
0
        /// <exception cref="System.Exception"/>
        public virtual void TestSetupDistributedCache()
        {
            Configuration conf = new Configuration();

            conf.SetClass("fs.mockfs.impl", typeof(TestMRApps.MockFileSystem), typeof(FileSystem
                                                                                      ));
            URI        mockUri = URI.Create("mockfs://mock/");
            FileSystem mockFs  = ((FilterFileSystem)FileSystem.Get(mockUri, conf)).GetRawFileSystem
                                     ();
            URI  archive     = new URI("mockfs://mock/tmp/something.zip");
            Path archivePath = new Path(archive);
            URI  file        = new URI("mockfs://mock/tmp/something.txt#something");
            Path filePath    = new Path(file);

            Org.Mockito.Mockito.When(mockFs.ResolvePath(archivePath)).ThenReturn(archivePath);
            Org.Mockito.Mockito.When(mockFs.ResolvePath(filePath)).ThenReturn(filePath);
            DistributedCache.AddCacheArchive(archive, conf);
            conf.Set(MRJobConfig.CacheArchivesTimestamps, "10");
            conf.Set(MRJobConfig.CacheArchivesSizes, "10");
            conf.Set(MRJobConfig.CacheArchivesVisibilities, "true");
            DistributedCache.AddCacheFile(file, conf);
            conf.Set(MRJobConfig.CacheFileTimestamps, "11");
            conf.Set(MRJobConfig.CacheFilesSizes, "11");
            conf.Set(MRJobConfig.CacheFileVisibilities, "true");
            IDictionary <string, LocalResource> localResources = new Dictionary <string, LocalResource
                                                                                 >();

            MRApps.SetupDistributedCache(conf, localResources);
            NUnit.Framework.Assert.AreEqual(2, localResources.Count);
            LocalResource lr = localResources["something.zip"];

            NUnit.Framework.Assert.IsNotNull(lr);
            NUnit.Framework.Assert.AreEqual(10l, lr.GetSize());
            NUnit.Framework.Assert.AreEqual(10l, lr.GetTimestamp());
            NUnit.Framework.Assert.AreEqual(LocalResourceType.Archive, lr.GetType());
            lr = localResources["something"];
            NUnit.Framework.Assert.IsNotNull(lr);
            NUnit.Framework.Assert.AreEqual(11l, lr.GetSize());
            NUnit.Framework.Assert.AreEqual(11l, lr.GetTimestamp());
            NUnit.Framework.Assert.AreEqual(LocalResourceType.File, lr.GetType());
        }
Ejemplo n.º 18
0
        public async Task <IActionResult> Get(int PageNumber, int PageSize)
        {
            Request.Headers.TryGetValue("Authorization", out var token);
            string role = await AuthHelper.GetRoleFromTokenAsync(token);

            if (role != "admin")
            {
                return(StatusCode(401, new { Error = "Invalid token." }));
            }

            var validFilter = new PaginationFilter(PageNumber, PageSize);

            IEnumerable <BookingDTO> data = new List <BookingDTO>();
            string cachedDataString       = string.Empty;

            cachedDataString = await DistributedCache.GetStringAsync("_bookings_" + validFilter.PageNumber);

            if (!string.IsNullOrEmpty(cachedDataString))
            {
                // loaded data from the redis cache.
                data = JsonSerializer.Deserialize <IEnumerable <BookingDTO> >(cachedDataString);
                return(Ok(new BaseResponse <IEnumerable <BookingDTO> >(data, true))); // IsCached = true
            }
            else
            {
                BaseResponse <IEnumerable <BookingDTO> > baseResponse = await Mediator.Send(new GetBookingQuery { PageNumber = validFilter.PageNumber, PageSize = validFilter.PageSize });

                // loading from code (in real-time from database)
                // then saving to the redis cache
                data             = baseResponse.Data;
                cachedDataString = JsonSerializer.Serialize <IEnumerable <BookingDTO> >(baseResponse.Data);
                var expiryOptions = new DistributedCacheEntryOptions()
                {
                    AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(600),
                    SlidingExpiration = TimeSpan.FromSeconds(300)
                };
                await DistributedCache.SetStringAsync("_bookings_" + validFilter.PageNumber, cachedDataString);

                return(Ok(baseResponse)); // IsCached = false
            }
        }
Ejemplo n.º 19
0
        public async Task GetAsync_ReturnsBoolCachedValue()
        {
            // Arrange

            var        key         = Guid.NewGuid().ToString();
            const bool cachedValue = true;

            var cache = new FakeDistributedCache(new MemoryCache(new MemoryCacheOptions()));

            cache.SetString(key, JsonConvert.SerializeObject(cachedValue));

            var logger = Substitute.For <ILogger <DistributedCache> >();
            var sut    = new DistributedCache(cache, logger);


            // Act
            var result = await sut.GetAsync <bool>(key);

            // Assert
            Assert.AreEqual(cachedValue, result);
        }
        public async Task AddOrUpdate(CustomerCacheModel model)
        {
            try
            {
                var customers = await LoadFromRedis();

                var customer = customers.FirstOrDefault(c => c.Id == model.Id);
                if (customer == null)
                {
                    customers.Add(model);
                }
                else
                {
                    //customer.Code = model.Code;
                    customer.Name            = model.Name;
                    customer.Phone           = model.Phone;
                    customer.Phone2          = model.Phone2;
                    customer.Phone3          = model.Phone3;
                    customer.Email           = model.Email;
                    customer.Address         = model.Address;
                    customer.ProvinceId      = model.ProvinceId;
                    customer.DistrictId      = model.DistrictId;
                    customer.WardId          = model.WardId;
                    customer.CustomerGroupId = model.CustomerGroupId;
                    //customer.CustomerVipId = model.CustomerVipId;
                    //customer.Profit = model.Profit;
                    customer.ProfitUpdate = model.ProfitUpdate;
                    customer.Description  = model.Description;
                    customer.UserUpdated  = model.UserUpdated;
                    customer.DateUpdated  = model.DateUpdated;
                }

                await DistributedCache.Set(_cacheKey,
                                           customers);
            }
            catch (Exception exception)
            {
                _logger.Info(exception.ToString);
            }
        }
Ejemplo n.º 21
0
        /// <exception cref="System.IO.IOException"/>
        private static void AddMRFrameworkToDistributedCache(Configuration conf)
        {
            string framework = conf.Get(MRJobConfig.MapreduceApplicationFrameworkPath, string.Empty
                                        );

            if (!framework.IsEmpty())
            {
                URI uri;
                try
                {
                    uri = new URI(framework);
                }
                catch (URISyntaxException e)
                {
                    throw new ArgumentException("Unable to parse '" + framework + "' as a URI, check the setting for "
                                                + MRJobConfig.MapreduceApplicationFrameworkPath, e);
                }
                string linkedName = uri.GetFragment();
                // resolve any symlinks in the URI path so using a "current" symlink
                // to point to a specific version shows the specific version
                // in the distributed cache configuration
                FileSystem fs            = FileSystem.Get(conf);
                Path       frameworkPath = fs.MakeQualified(new Path(uri.GetScheme(), uri.GetAuthority(
                                                                         ), uri.GetPath()));
                FileContext fc = FileContext.GetFileContext(frameworkPath.ToUri(), conf);
                frameworkPath = fc.ResolvePath(frameworkPath);
                uri           = frameworkPath.ToUri();
                try
                {
                    uri = new URI(uri.GetScheme(), uri.GetAuthority(), uri.GetPath(), null, linkedName
                                  );
                }
                catch (URISyntaxException e)
                {
                    throw new ArgumentException(e);
                }
                DistributedCache.AddCacheArchive(uri, conf);
            }
        }
Ejemplo n.º 22
0
        public async Task CacheResponseAsync(string cacheKey, object response, TimeSpan timeToLive)
        {
            if (cacheKey == null)
            {
                return;
            }

            if (response == null)
            {
                return;
            }

            var serializedResponse = JsonConvert.SerializeObject(response);

            await DistributedCache.SetStringAsync(
                cacheKey,
                serializedResponse,
                new DistributedCacheEntryOptions
            {
                AbsoluteExpirationRelativeToNow = timeToLive
            });
        }
Ejemplo n.º 23
0
 public async Task RemoveAsync(
     string key,
     CancellationToken cancellationToken = default(CancellationToken))
 {
     lock (await GetOrCreateLockAsync(
               key, null, cancellationToken))
     {
         DistributedCache.Remove(key);
         MemoryCache.Remove(
             $"{KeyPrefix}{key}");
         Subscriber.Publish(
             Channel,
             JsonSerializer.Serialize(
                 new CacheMessage
         {
             Key         = key,
             PublisherId = PublisherId,
         },
                 JsonSerializerOptions));
         MemoryCache.Remove($"{LockKeyPrefix}{key}");
     }
 }
Ejemplo n.º 24
0
 public void Set(
     string key,
     byte[] value,
     DistributedCacheEntryOptions distributedCacheEntryOptions)
 {
     lock (GetOrCreateLock(key, distributedCacheEntryOptions))
     {
         DistributedCache.Set(
             key, value, distributedCacheEntryOptions);
         SetMemoryCache(
             key, value, distributedCacheEntryOptions);
         Subscriber.Publish(
             Channel,
             JsonSerializer.Serialize(
                 new CacheMessage
         {
             Key         = key,
             PublisherId = PublisherId,
         },
                 JsonSerializerOptions));
     }
 }
Ejemplo n.º 25
0
        public void GetIfCached_ReturnsCachedValue()
        {
            // Arrange

            var key         = Guid.NewGuid().ToString();
            var cachedValue = new AClass();

            var cache = new FakeDistributedCache(new MemoryCache(new MemoryCacheOptions()));

            cache.SetString(key, JsonConvert.SerializeObject(cachedValue));

            var logger = Substitute.For <ILogger <DistributedCache> >();
            var sut    = new DistributedCache(cache, logger);


            // Act
            var wasCached = sut.GetIfCached <AClass>(key, out var result);

            // Assert
            Assert.True(wasCached);
            Assert.AreEqual(cachedValue.Value, result.Value);
        }
Ejemplo n.º 26
0
        public async Task GetIfCachedAsync_ReturnsCachedValue()
        {
            // Arrange

            var key         = Guid.NewGuid().ToString();
            var cachedValue = new AClass();

            var cache = new FakeDistributedCache(new MemoryCache(new MemoryCacheOptions()));

            cache.SetString(key, JsonConvert.SerializeObject(cachedValue));

            var logger = Substitute.For <ILogger <DistributedCache> >();
            var sut    = new DistributedCache(cache, logger);


            // Act
            var result = await sut.GetIfCachedAsync <AClass>(key);

            // Assert
            Assert.True(result.wasInCache);
            Assert.AreEqual(cachedValue.Value, result.value.Value);
        }
Ejemplo n.º 27
0
        public async Task SearchByClient()
        {
            await StartServer();

            var client = await GetClient();

            var baseDir = AppDomain.CurrentDomain.BaseDirectory;

            if (baseDir == null)
            {
                throw new NullReferenceException("baseDirectory of test app is null");
            }

            var    sampleFilePath = Path.Combine(baseDir, "sampleResponse.txt");
            string resultHtml     = File.ReadAllText(sampleFilePath);

            DistributedCache.Setup(ca => ca.GetAsync("777x", It.IsAny <CancellationToken>()))
            .Returns <string, CancellationToken>((key, token) =>
            {
                var bytes = Encoding.UTF8.GetBytes(resultHtml);
                return(Task.FromResult(bytes));
            });

            var response = await client.GetAsync("/v1/AirTeam/Search?keyword=777x");

            var jsonResult = await response.Content.ReadAsStringAsync();

            Assert.IsTrue(response.IsSuccessStatusCode);
            var jArray = JArray.Parse(jsonResult);

            Assert.AreEqual(25, jArray.Count);

            var firstItem = jArray[0].ToObject <ImageDto>();

            Assert.AreEqual("353153", firstItem.ImageId);
            Assert.AreEqual("Boeing 777-9X", firstItem.Title);
            StringAssert.EndsWith(firstItem.BaseImageUrl, "pics/353/353153_200.jpg");
        }
Ejemplo n.º 28
0
 /// <summary>
 /// 创建任务
 /// </summary>
 /// <param name="taskMessage"></param>
 /// <returns></returns>
 public bool CreateTask(TaskMessage taskMessage)
 {
     lock (_lockObj)
     {
         long     batchNumber = DateTime.Now.Ticks;
         DateTime currentTime = DateTime.Now;
         _servers = GetAllServers();
         foreach (var item in _servers)
         {
             TaskMessage task = new TaskMessage();
             task.BatchNumber  = batchNumber;
             task.TaskID       = Guid.NewGuid().ToString();
             task.TaskExecutor = item;
             task.TaskType     = taskMessage.TaskType;
             task.TaskParam    = taskMessage.TaskParam;
             task.Status       = TaskMessageStatusEnum.None;
             task.CreateTime   = currentTime;
             _taskList.Add(task);
         }
         DistributedCache.Set(CacheKeys.InstuctionTaskListCacheKey, _taskList, DateTime.Now.AddYears(1));
     }
     return(true);
 }
Ejemplo n.º 29
0
        public void Should_return_user_exception_for_other_responses()
        {
            var expectedGroup = new Group {
                Id = _groupId, DisplayName = JudgeGroupName
            };

            DistributedCache.Setup(x => x.GetOrAddAsync(It.IsAny <string>(), It.IsAny <Func <Task <Group> > >())).ReturnsAsync(expectedGroup);

            _graphQueryResponse.Value.Add(_group);
            SecureHttpRequest.Setup(x => x.GetAsync(It.IsAny <string>(), _judgesGroup))
            .ReturnsAsync(ApiRequestHelper.CreateHttpResponseMessage(_graphQueryResponse, HttpStatusCode.OK));

            const string reason = "User not authorised";

            SecureHttpRequest.Setup(x => x.GetAsync(It.IsAny <string>(), _accessUri))
            .ReturnsAsync(ApiRequestHelper.CreateHttpResponseMessage(reason, HttpStatusCode.Unauthorized));

            var response = Assert.ThrowsAsync <UserServiceException>(async() => await Service.GetJudgesAsync());

            response.Should().NotBeNull();
            response.Message.Should().Be($"Failed to get users for group {_groupId}: {reason}");
            response.Reason.Should().Be(reason);
        }
Ejemplo n.º 30
0
        private void Initialize()
        {
            EngineContext.Initialize(false);
            //set dependency resolver
            var dependencyResolver = new MVCDependencyResolver();

            DependencyResolver.SetResolver(dependencyResolver);

            // initialize cache
            Cache.InitializeWith(new CacheProviderFactory(ConfigurationManager.AppSettings["CacheProvider"]));
            //分布式缓存(Memcached Or Redis)
            DistributedCache.InitializeWith(new CacheProviderFactory(ConfigurationManager.AppSettings["DistributedCacheProvider"]));
            Config.SetSystemCode("S012");

            ////initialize AutoMapper
            //Mapper.Initialize(x => x.AddProfile<AutoMapperProfile>());

            var typeAdapterFactory = EngineContext.Current.Resolve <ITypeAdapterFactory>();

            TypeAdapterFactory.SetCurrent(typeAdapterFactory);

            //ConfigureFluentValidation();
        }