public IActionResult Get(string firstLetter,
                                 [FromQuery] ApiParams apiParams)
        {
            var model = _service.GetCategories(firstLetter, apiParams);

            return(Ok(model));
        }
Exemple #2
0
        public PagedList GetCategories(string firstLetter, ApiParams apiParams)
        {
            var query = _categories.Where(c => c.Code.ToLower().StartsWith(firstLetter.ToLower()))
                        .AsQueryable();

            return(FilterAndReturnPagedList(apiParams, ref query));
        }
        public IActionResult GetFromCategory(string id,
                                             [FromQuery] ApiParams apiParams)
        {
            var model = _service.GetCodesFromCategory(id, apiParams);

            return(Ok(model));
        }
Exemple #4
0
        public PagedList GetCodesFromCategory(string categoryCode, ApiParams apiParams)
        {
            var query = _codes.Where(c => c.Category.Code == categoryCode)
                        .AsQueryable();

            return(FilterAndReturnPagedList(apiParams, ref query));
        }
Exemple #5
0
        /// <summary>
        /// 开始写入执行日志
        /// </summary>
        /// <param name="param">传入参数</param>
        /// <param name="action">方法名</param>
        /// <returns></returns>
        public t_logs AddBeginLogs(ApiParams param, string action)
        {
            t_logs m = new t_logs();

            m.ctype  = "xxkj_api_logs";
            m.action = action;
            m.ip     = param.ip;
            m.accout = param.accout;
            m.param  = param.paramMain + "/" + param.paramDetails;
            m.b_date = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");

            return(m);
        }
Exemple #6
0
        private static PagedList FilterAndReturnPagedList(ApiParams apiParams, ref IQueryable <ICD10Category> query)
        {
            var filterBy = apiParams.FilterBy.Trim().ToLowerInvariant();

            if (!string.IsNullOrEmpty(filterBy))
            {
                query = query
                        .Where(m => m.Title.ToLowerInvariant().Contains(filterBy) ||
                               m.Code.ToLowerInvariant().Contains(filterBy));
            }

            return(new PagedList(query, apiParams.PageNumber, apiParams.PageSize));
        }
Exemple #7
0
        static PagedList FilterAndReturnPagedList(ApiParams apiParams,
                                                  ref IQueryable <ICD9Code> query)
        {
            var filterBy = apiParams.FilterBy.Trim().ToLowerInvariant();

            if (!string.IsNullOrEmpty(filterBy))
            {
                query = query
                        .Where(m => m.LongDescription.ToLowerInvariant().Contains(filterBy) ||
                               m.ShortDescription.ToLowerInvariant().Contains(filterBy) ||
                               m.Code.ToLowerInvariant().Contains(filterBy));
            }
            return(new PagedList(query, apiParams.PageNumber, apiParams.PageSize));
        }
Exemple #8
0
        public ApiResponse <ArenaTeamReportOpposingTeams> GetArenaTeamReportOpposingTeams(int teamSize, string teamName, Realm realm)
        {
            if (realm.GetRealmExpansion() > Expansion.Cataclysm)
            {
                return new ApiResponse <ArenaTeamReportOpposingTeams>()
                       {
                           CustomError = CustomError.InvalidRealm, ErrorMessage = InvalidExpansion
                       }
            }
            ;

            ApiParams param = new ApiParams(Endpoints.ArenaTeamReportOpposingTeams, Secret, new ArenaTeamRequest(teamSize, teamName, realm));

            return(Communicate <ArenaTeamReportOpposingTeams>(param));
        }
Exemple #9
0
        public ApiResponse <ArenaLadder> GetArenaLadder(int teamSize, Realm realm)
        {
            if (realm.GetRealmExpansion() > Expansion.Cataclysm)
            {
                return new ApiResponse <ArenaLadder>()
                       {
                           CustomError = CustomError.InvalidRealm, ErrorMessage = InvalidExpansion
                       }
            }
            ;

            ApiParams param = new ApiParams(Endpoints.ArenaLadder, Secret, new ArenaLadderRequest(teamSize, realm));

            return(Communicate <ArenaLadder>(param));
        }
        public ApiResponse <AuctionHouseInfoResponse> GetBlackMarketInfo(Realm realm)
        {
            if (realm.GetRealmExpansion() < Expansion.MistsOfPandaria)
            {
                return new ApiResponse <AuctionHouseInfoResponse>()
                       {
                           ErrorMessage = InvalidExpansion
                       }
            }
            ;

            ApiParams param = new ApiParams(Endpoints.AuctionsInfo, Secret, new AuctionHouseBaseRequest(realm));

            return(Communicate <AuctionHouseInfoResponse>(param));
        }
        public async Task <ApiResponse <BlackMarketResponse> > GetBlackMarketAuctionsAsync(Realm realm)
        {
            if (realm.GetRealmExpansion() < Expansion.MistsOfPandaria)
            {
                return new ApiResponse <BlackMarketResponse>()
                       {
                           ErrorMessage = InvalidExpansion
                       }
            }
            ;

            ApiParams param = new ApiParams(Endpoints.AuctionsData, Secret, new AuctionHouseBaseRequest(realm));

            return(await CommunicateAsync <BlackMarketResponse>(param));
        }
Exemple #12
0
        public async Task <ApiResponse <ArenaTeamGameChart> > GetArenaTeamGameChartAsync(int teamSize, string teamName, Realm realm)
        {
            if (realm.GetRealmExpansion() > Expansion.Cataclysm)
            {
                return new ApiResponse <ArenaTeamGameChart>()
                       {
                           CustomError = CustomError.InvalidRealm, ErrorMessage = InvalidExpansion
                       }
            }
            ;

            ApiParams param = new ApiParams(Endpoints.ArenaTeamGameChart, Secret, new ArenaTeamRequest(teamSize, teamName, realm));

            return(await CommunicateAsync <ArenaTeamGameChart>(param));
        }
Exemple #13
0
        public ApiResponse <ArenaGame> GetArenaGame(int matchId, Realm realm)
        {
            if (realm.GetRealmExpansion() > Expansion.Cataclysm)
            {
                return new ApiResponse <ArenaGame>()
                       {
                           CustomError = CustomError.InvalidRealm, ErrorMessage = InvalidExpansion
                       }
            }
            ;

            ApiParams param = new ApiParams(Endpoints.ArenaGame, Secret, new ArenaGameRequest(matchId, realm));

            return(Communicate <ArenaGame>(param));
        }
        public async Task <ActionResult <VmPage <VmCountryList> > > List([FromQuery] ApiParams apiParams)
        {
            var results = await _listService.Get(new PageParams
            {
                PageIndex = apiParams.PageIndex,
                PageSize  = apiParams.PageLimit,
            });

            return(Ok(new VmPage <VmCountryList>
            {
                Items = VmCountryList.Build(results),
                PageIndex = results.PageIndex,
                PageSize = results.PageSize,
                TotalCount = results.Total
            }));
        }
Exemple #15
0
        public async Task Returns_OkResult_With_PageResults()
        {
            // Arrange
            const int pageSize       = 15;
            const int pageIndex      = 2;
            const int totalItems     = 31;
            const int totalPageCount = 3;

            var queryResults = new PageResults <Country>
            {
                PageSize  = pageSize,
                PageIndex = pageIndex,
                Total     = totalItems
            };

            GetMock <ICountryListService>()
            .Setup(x => x.Get(
                       It.Is <PageParams>(p => p.PageSize == pageSize && p.PageIndex == pageIndex)
                       ))
            .Returns(Task.FromResult(queryResults));

            // Act
            var apiParams = new ApiParams
            {
                PageIndex = pageIndex,
                PageLimit = pageSize
            };
            var result = await ClassUnderTest.List(apiParams);

            // Assert
            var okResult    = Assert.IsType <OkObjectResult>(result.Result);
            var returnValue = Assert.IsType <VmPage <VmCountryList> >(okResult.Value);

            returnValue.PageSize.Should().Be(pageSize);
            returnValue.PageIndex.Should().Be(pageIndex);
            returnValue.TotalCount.Should().Be(totalItems);
            returnValue.TotalPageCount.Should().Be(totalPageCount);
        }
Exemple #16
0
        public static async Task <bool> DoLogin(string username, string password)
        {
            try
            {
                var methodParam = new ApiParams();
                methodParam.Add("idUsuario", username);
                methodParam.Add("clave", password);

                var userJson = await APICaller.Call("ValidarAccesoMovil", methodParam);

                var user = Models.User.FromJsonToken(userJson);
                if (user == null)
                {
                    return(false);
                }
                Models.Shared.User = user;
                return(true);
            }
            catch
            {
                return(false);
            }
        }
Exemple #17
0
        public ApiResponse <CharacterReputation> GetCharacterReputation(string characterName, Realm realm)
        {
            ApiParams param = new ApiParams(Endpoints.Reputation, Secret, new CharacterRequest(characterName, realm));

            return(Communicate <CharacterReputation>(param));
        }
Exemple #18
0
        public async Task <ApiResponse <CharacterSheet> > GetCharacterSheetAsync(string characterName, Realm realm)
        {
            ApiParams param = new ApiParams(Endpoints.TooltipUrl, Secret, new CharacterRequest(characterName, realm));

            return(await CommunicateAsync <CharacterSheet>(param));
        }
        public IActionResult Get([FromQuery] ApiParams apiParams)
        {
            var model = _service.GetCodes(apiParams);

            return(Ok(model));
        }
Exemple #20
0
        public async Task <ApiResponse <CharacterReputation> > GetCharacterReputationAsync(string characterName, Realm realm)
        {
            ApiParams param = new ApiParams(Endpoints.Reputation, Secret, new CharacterRequest(characterName, realm));

            return(await CommunicateAsync <CharacterReputation>(param));
        }
        public async Task <ApiResponse <CharacterAchievementsLoader> > GetCharacterAchievementsLoaderAsync(string characterName, int categoryId, Realm realm)
        {
            ApiParams param = new ApiParams(Endpoints.AchievementsLoader, Secret, new AchievementsLoaderRequest(characterName, categoryId, realm));

            return(await CommunicateAsync <CharacterAchievementsLoader>(param));
        }
        public async Task <ApiResponse <CharacterAchievements> > GetCharacterAchievementsAsync(string characterName, Realm realm)
        {
            ApiParams param = new ApiParams(Endpoints.CharacterAchievements, Secret, new CharacterAchievementsRequest(characterName, realm));

            return(await CommunicateAsync <CharacterAchievements>(param));
        }
        public async Task <ApiResponse <AchievementFirst> > GetAchievementFirstsAsync(Realm realm)
        {
            ApiParams param = new ApiParams(Endpoints.AchievementFirsts, Secret, new AchievementBaseRequest(realm));

            return(await CommunicateAsync <AchievementFirst>(param));
        }
Exemple #24
0
        public ApiResponse <CharacterSheet> GetCharacterSheet(string characterName, Realm realm)
        {
            ApiParams param = new ApiParams(Endpoints.TooltipUrl, Secret, new CharacterRequest(characterName, realm));

            return(Communicate <CharacterSheet>(param));
        }
        public retmsg ProWare(ApiParams param)
        {
            retmsg ret    = new retmsg();
            string constr = "";
            //起始日志
            t_logs LogsModel = new Bll.CommBll.LogsBll().AddBeginLogs(param, "ProWare");

            //获取数据库链接
            ret    = new Bll.CommBll.AccoutBll().getAccout(param.ip, param.accout);
            constr = ret.message;
            if (ret.flag == "error")
            {
                //结尾日志--失败
                new Bll.CommBll.LogsBll().AddEndLogs(LogsModel, ret.flag, ret.message);
                return(ret);
            }

            try
            {
                //翻译参数
                //主表
                MyRdRecord01 model;
                using (System.IO.StringReader sr = new System.IO.StringReader(param.paramMain))
                {
                    model = (MyRdRecord01) new Newtonsoft.Json.JsonSerializer().Deserialize(new JsonTextReader(sr), typeof(MyRdRecord01));
                }

                //子表
                List <MyRdRecords01> list;
                using (System.IO.StringReader sr = new System.IO.StringReader(param.paramDetails))
                {
                    list = (List <MyRdRecords01>) new Newtonsoft.Json.JsonSerializer().Deserialize(new JsonTextReader(sr), typeof(List <MyRdRecords01>));
                }

                //检测参数
                ret = new Bll.MyU8Bll.CheckParamData().CheckMyRd01(model, list, constr);
                if (ret.flag == "error")
                {
                    //throw new Exception(ret.message);
                    //结尾日志--失败
                    new Bll.CommBll.LogsBll().AddEndLogs(LogsModel, ret.flag, ret.message);
                    return(ret);
                }

                //检测是不是已经记账
                ret = new Bll.CommBll.GL_mend().CheckGL_mend(model.create_date, constr);
                if (ret.flag == "error")
                {
                    //结尾日志--失败
                    new Bll.CommBll.LogsBll().AddEndLogs(LogsModel, ret.flag, ret.message);
                    return(ret);
                }

                //翻译字段
                list = new Bll.MyU8Bll.TransField().TransFieldMyRd01(list, constr);

                model.bredvouch = 0;//蓝单标识
                //调用方法 --主表部门字段,子表金额数量等字段待处理
                ret = new Bll.MyU8Bll.MyRd01Bll().Add(model, list, constr);



                //结尾日志--完成
                new Bll.CommBll.LogsBll().AddEndLogs(LogsModel, ret.flag, ret.message);
                return(ret);
            }
            catch (Exception ex)
            {
                ret.flag    = "error";
                ret.message = "001:" + ex.Message;
                //结尾日志--失败
                new Bll.CommBll.LogsBll().AddEndLogs(LogsModel, ret.flag, ret.message);
                return(ret);
            }
        }
        public ApiResponse <AchievementFirst> GetAchievementFirsts(Realm realm)
        {
            ApiParams param = new ApiParams(Endpoints.AchievementFirsts, Secret, new AchievementBaseRequest(realm));

            return(Communicate <AchievementFirst>(param));
        }
Exemple #27
0
        public PagedList GetCodes(ApiParams apiParams)
        {
            var query = _codes.AsQueryable();

            return(FilterAndReturnPagedList(apiParams, ref query));
        }
        public ApiResponse <CharacterAchievements> GetCharacterAchievements(string characterName, Realm realm)
        {
            ApiParams param = new ApiParams(Endpoints.CharacterAchievements, Secret, new CharacterAchievementsRequest(characterName, realm));

            return(Communicate <CharacterAchievements>(param));
        }
Exemple #29
0
        public ApiResponse <GuildBankLog> GetGuildBankLogs(string guildName, Realm realm = Realm.Evermoon)
        {
            ApiParams param = new ApiParams(Endpoints.GuildBankLogs, Secret, new GuildRequest(guildName, realm));

            return(Communicate <GuildBankLog>(param));
        }
Exemple #30
0
        public async Task <ApiResponse <AuctionHouseResponse> > GetAuctionsByItemIDAsync(int itemID, Realm realm)
        {
            ApiParams param = new ApiParams(Endpoints.AuctionItemData, Secret, new AuctionHouseItemPriceRequest(itemID, realm.ToMasterRealm()));

            return(await CommunicateAsync <AuctionHouseResponse>(param));
        }