Example #1
0
 /// <summary>
 /// 페이징 처리된 메뉴 리스트를 반환한다.
 /// </summary>
 public PagedModel <MenuItem> GetMenuPagedList(PagingOption option)
 {
     using (var repo = new MenuRepository())
     {
         return(repo.SelectMenuPagedList(option));
     }
 }
        private IEnumerable <Vehicle> ApplyPaging(IQueryable <Vehicle> query, PagingOption paging)
        {
            // Apply paging
            if (paging != null && paging.PageSize > 0 && paging.PageNumber > 0)
            {
                int pageSize   = paging.PageSize;
                int pageNumber = paging.PageNumber;

                IOrderByClause <Vehicle>[] orderBy = GetOrderByClause(paging);

                // Apply sorting
                bool isFirstSort = true;
                orderBy.ToList().ForEach(by =>
                {
                    query       = by.ApplySort(query, isFirstSort);
                    isFirstSort = false;
                });

                return(query
                       .Skip(pageSize * (pageNumber - 1))
                       .Take(pageSize).ToList());
            }
            else
            {
                // No paging
                return(query.ToList());
            }
        }
Example #3
0
        public List<Employee> SelectEmployees(PagingOption option)
        {
            if (option.GetRecordCount)
            {
                option.RecordCount = 1000;

                if (option.RecordCount < option.Start)
                {
                    option.RecordCount = option.Start;
                }
            }

            List<Employee> list = new List<Employee>();

            for (int index = option.Start; index < option.Start + option.Length; index++)
            {
                list.Add(new Employee
                {
                    Name = "Name " + index.ToString(),
                    Email = string.Format("Email{0}@163.com", index),
                    Telephone = "1234567"
                });
            }

            return list;
        }
Example #4
0
        /// <inheritdoc/>
        public IEnumerable <Adaccount> GetByOrganizationId(string organizationId, PagingOption pagingOption)
        {
#pragma warning disable SA1305 // Field names should not use Hungarian notation
            var adAccounts = ExecutePagedRequest <AdAccountRootObject, AdaccountWrapper, Adaccount>($"/organizations/{organizationId}/adaccounts", pagingOption);
#pragma warning restore SA1305 // Field names should not use Hungarian notation

            return(adAccounts);
        }
        /// <inheritdoc/>
        public IEnumerable <Adsquad> GetByCampaignId(string campaignId, PagingOption pagingOption)
        {
#pragma warning disable SA1305 // Field names should not use Hungarian notation
            var adSquads = ExecutePagedRequest <AdSquadRootObject, AdsquadWrapper, Adsquad>($"/campaigns/{campaignId}/adsquads", pagingOption);
#pragma warning restore SA1305 // Field names should not use Hungarian notation

            return(adSquads);
        }
Example #6
0
 public List<Project> SelectProjects(ProjectFilter filter, PagingOption option)
 {
     var list = _dal.ProjectRepository.SelectProjects(filter, option);
     foreach(Project item in list)
     {
         FillReferenceProperties(item);
     }
     return list;
 }
Example #7
0
        protected PagingOption GetPagingOption(int page, int pageSize)
        {
            PagingOption option = new PagingOption();

            option.Start          = (page - 1) * pageSize + 1;
            option.Length         = pageSize;
            option.GetRecordCount = true;
            return(option);
        }
Example #8
0
        public List <Project> SelectProjects(ProjectFilter filter, PagingOption option)
        {
            var list = _dal.ProjectRepository.SelectProjects(filter, option);

            foreach (Project item in list)
            {
                FillReferenceProperties(item);
            }
            return(list);
        }
Example #9
0
        /// <summary>
        /// 페이징 처리 된 대시보드 테이블 리스트를 반환한다,
        /// </summary>
        public PagedModel <FormTable> GetFormTablePagedList(PagingOption option)
        {
            option.ThrowIfNull(nameof(option));
            option.Validate();

            using (var repo = new FormTableRepository())
            {
                return(repo.SelectFormTablePagedList(option));
            }
        }
Example #10
0
        /// <summary>
        /// 페이징 처리된 대시보드 테이블 리스트를 반환한다.
        /// </summary>
        public PagedModel <FormTable> SelectFormTablePagedList(PagingOption option)
        {
            string procCommandName = "up_FormTable_SelectPagedList";

            try
            {
                var command = Connection.GetStoredProcCommand(procCommandName);
                Connection.AddInParameter(command, "PageNumber", DbType.Int32, option.PageNumber);
                Connection.AddInParameter(command, "PageCount", DbType.Int32, option.PageCount);
                Connection.AddInParameter(command, "SortBy", DbType.String, option.SortBy);
                Connection.AddInParameter(command, "OrderBy", DbType.String, option.OrderBy.ToEnumMemberString());

                using (DataSet ds = Connection.ExecuteDataSet(command))
                {
                    ValidateTableCount(ds, 2);

                    var result = new PagedModel <FormTable>(option)
                    {
                        PagingOption = option
                    };
                    int totalCount = 0;

                    // 1. 대시보드 테이블 리스트
                    foreach (DataRow dr in ds.Tables[0].Rows)
                    {
                        var form = FormTable.ParseFrom(dr, out totalCount);
                        result.Items.Add(form);
                    }

                    // 2. 대시보드 테이블 양식 리스트
                    foreach (DataRow dr in ds.Tables[1].Rows)
                    {
                        var template = FormHtmlTemplate.ParseFrom(dr);
                        var forms    = result.Items.FindAll(o => o.FormId == template.FormId && o.HtmlTemplateId == template.HtmlTemplateId);
                        if (forms.Any())
                        {
                            forms.ForEach(o =>
                            {
                                o.HtmlTemplate = template;
                            });
                        }
                    }

                    result.TotalCount = totalCount;

                    return(result);
                }
            }
            catch (Exception ex)
            {
                throw new DataException($"프로시져 실행 중 예기치 못한 에러가 발생했습니다.\r\n 프로시저: \"{procCommandName}\"", ex);
            }
        }
Example #11
0
        public ActionResult ProjectsList(ProjectFilter filter, int page = 1)
        {
            PagingOption option = GetPagingOption15(page);

            var model = new ProjectsViewModel
            {
                Projects     = bll.ProjectManager.SelectProjects(filter, option),
                PagingOption = new WebPagingOption {
                    CurrentPage = page, ItemsPerPage = PageSize15, TotalItems = option.RecordCount
                }
            };

            return(PartialView(model));
        }
Example #12
0
        public List<Proposal> SelectProposals(ProposalFilter filter, PagingOption option)
        {
            List<Proposal> list = new List<Proposal>();

            string sql = "SELECT * FROM dbo.Proposal WHERE 1 = 1" + filter.GetFilterString();
            string orderBy = "";
            var table = ExecuteDataTable(sql, option, orderBy);
            foreach (DataRow row in table.Rows)
            {
                list.Add(DataRowToProposal(row));
            }

            return list;
        }
Example #13
0
        /// <summary>
        /// 페이징 처리된 메뉴 리스트를 반환한다.
        /// </summary>
        public PagedModel <MenuItem> SelectMenuPagedList(PagingOption option)
        {
            string procCommandName = "up_Menu_SelectPagedList";

            try
            {
                var command = Connection.GetStoredProcCommand(procCommandName);
                Connection.AddInParameter(command, "PageNumber", DbType.Int32, option.PageNumber);
                Connection.AddInParameter(command, "PageCount", DbType.Int32, option.PageCount);
                Connection.AddInParameter(command, "SortBy", DbType.String, option.SortBy);
                Connection.AddInParameter(command, "OrderBy", DbType.String, option.OrderBy.ToEnumMemberString());

                using (DataSet ds = Connection.ExecuteDataSet(command))
                {
                    ValidateTableCount(ds, 2);

                    var result = new PagedModel <MenuItem>(option)
                    {
                        PagingOption = option
                    };
                    int totalCount = 0;

                    // 메뉴 정보
                    foreach (DataRow dr1 in ds.Tables[0].Rows)
                    {
                        var menu = MenuItem.ParseFrom(dr1, out totalCount);
                        result.Items.Add(menu);

                        // 메뉴와 매핑된 대시보드 테이블 정보
                        foreach (DataRow dr2 in ds.Tables[1].Rows)
                        {
                            var formTableMenuId = dr2.Get <Guid>("MenuId");
                            if (formTableMenuId == menu.MenuId)
                            {
                                menu.FormTables.Add(FormTable.ParseFrom(dr2));
                            }
                        }
                    }

                    result.TotalCount = totalCount;

                    return(result);
                }
            }
            catch (Exception ex)
            {
                throw new DataException($"프로시져 실행 중 예기치 못한 에러가 발생했습니다.\r\n 프로시저: \"{procCommandName}\"", ex);
            }
        }
Example #14
0
        public List <Project> SelectProjects(ProjectFilter filter, PagingOption option)
        {
            List <Project> list = new List <Project>();

            string sql     = "SELECT * FROM dbo.Projects WHERE 1 = 1" + filter.GetFilterString();
            string orderBy = "[Order] DESC";
            var    table   = ExecuteDataTable(sql, option, orderBy);

            foreach (DataRow row in table.Rows)
            {
                list.Add(DataRowToProject(row, false));
            }

            return(list);
        }
Example #15
0
        public List <Proposal> SelectProposals(ProposalFilter filter, PagingOption option)
        {
            List <Proposal> list = new List <Proposal>();

            string sql     = "SELECT * FROM dbo.Proposal WHERE 1 = 1" + filter.GetFilterString();
            string orderBy = "";
            var    table   = ExecuteDataTable(sql, option, orderBy);

            foreach (DataRow row in table.Rows)
            {
                list.Add(DataRowToProposal(row));
            }

            return(list);
        }
Example #16
0
        public async Task <IActionResult> GetAttendanceSheets(
            [FromQuery] OrderingOption orderingOption,
            [FromQuery] PagingOption pagingOption
            )
        {
            var specification = new SimpleAttendanceSheetsSpecification(
                orderingOption.GetOrderByInfos(),
                pagingOption.CurrentPage, pagingOption.PageSize
                );
            var qro = await _uow.Repository <AttendanceSheet>().Find(specification);

            if (qro == null || qro.QueryResult == null)
            {
                return(StatusCode(StatusCodes.Status500InternalServerError));
            }
            return(Ok(_mapper.Map <SimpleAttendanceSheetsResultDTO>(qro)));
        }
        public Criterion(int currentPage, int pageSize, PagingOption defaultPagingOption, string sortBy = "", string sortOrder = "")
        {
            if (currentPage <= 0)
            {
                throw new ValidationException("CurrentPage could not be less than zero.");
            }

            if (pageSize <= 0)
            {
                throw new ValidationException("PageSize could not be less than zero.");
            }

            CurrentPage         = currentPage - 1;
            PageSize            = pageSize;
            DefaultPagingOption = defaultPagingOption;
            SortBy    = sortBy;
            SortOrder = sortOrder;
        }
Example #18
0
 protected DataTable ExecuteDataTable(string sql, PagingOption option, string orderBy = null)
 {
     if (option == null)
     {
         sqlProc.Clear();
         sqlProc.CommandText = sql + (string.IsNullOrEmpty(orderBy) ? "" : " ORDER BY " + orderBy);
         sqlProc.CommandType = CommandType.Text;
         return(sqlProc.ExecuteDataTable());
     }
     else
     {
         sqlProc.Clear();
         sqlProc.CommandText = sql;
         sqlProc.CommandType = CommandType.Text;
         option.OrderBy      = orderBy;
         return(sqlProc.GetPagingRecord(option));
     }
 }
Example #19
0
 protected DataTable ExecuteDataTable(string sql, PagingOption option, string orderBy = null)
 {
     if (option == null)
     {
         sqlProc.Clear();
         sqlProc.CommandText = sql + (string.IsNullOrEmpty(orderBy) ? "" : " ORDER BY " + orderBy);
         sqlProc.CommandType = CommandType.Text;
         return sqlProc.ExecuteDataTable();
     }
     else
     {
         sqlProc.Clear();
         sqlProc.CommandText = sql;
         sqlProc.CommandType = CommandType.Text;
         option.OrderBy = orderBy;
         return sqlProc.GetPagingRecord(option);
     }
 }
        private IOrderByClause <Vehicle>[] GetOrderByClause(PagingOption paging)
        {
            switch (paging.SortColumn)
            {
            case "Id":
                return(new IOrderByClause <Vehicle>[] { new OrderByClause <Vehicle, long>(i => i.Id, paging.SortDirection) });

            case "VehicleIdentifier":
                return(new IOrderByClause <Vehicle>[] { new OrderByClause <Vehicle, string>(i => i.VehicleIdentifier, paging.SortDirection) });

            case "RegisterNumber":
                return(new IOrderByClause <Vehicle>[] { new OrderByClause <Vehicle, string>(i => i.RegisterNumber, paging.SortDirection) });

            case "LastSignalTime":
                return(new IOrderByClause <Vehicle>[] { new OrderByClause <Vehicle, DateTime>(i => i.LastSignalTime, paging.SortDirection) });

            default:
                return(new IOrderByClause <Vehicle>[] { new OrderByClause <Vehicle, long>(i => i.Id, paging.SortDirection) });
            }
        }
Example #21
0
        /// <summary>
        /// 페이징 처리된 대시보드 테이블 html 양식 리스트를 반환한다.
        /// </summary>
        public PagedModel <FormHtmlTemplate> SelectFormHtmlTemplatePagedList(PagingOption option)
        {
            string procCommandName = "up_FormHtmlTemplate_SelectPagedList";

            try
            {
                var command = Connection.GetStoredProcCommand(procCommandName);
                Connection.AddInParameter(command, "PageNumber", DbType.Int32, option.PageNumber);
                Connection.AddInParameter(command, "PageCount", DbType.Int32, option.PageCount);
                Connection.AddInParameter(command, "SortBy", DbType.String, option.SortBy);
                Connection.AddInParameter(command, "OrderBy", DbType.String, option.OrderBy.ToEnumMemberString());

                using (DataSet ds = Connection.ExecuteDataSet(command))
                {
                    ValidateTableCount(ds, 1);

                    var result = new PagedModel <FormHtmlTemplate>(option)
                    {
                        PagingOption = option
                    };
                    int totalCount = 0;

                    foreach (DataRow dr in ds.Tables[0].Rows)
                    {
                        var template = FormHtmlTemplate.ParseFrom(dr, out totalCount);
                        result.Items.Add(template);
                    }

                    result.TotalCount = totalCount;

                    return(result);
                }
            }
            catch (Exception ex)
            {
                throw new DataException($"프로시져 실행 중 예기치 못한 에러가 발생했습니다.\r\n 프로시저: \"{procCommandName}\"", ex);
            }
        }
Example #22
0
 public List <Proposal> SelectProposals(ProposalFilter filter, PagingOption option)
 {
     return(_dal.ProposalRepository.SelectProposals(filter, option));
 }
        /// <inheritdoc/>
        public IEnumerable <Ad> GetByAdSquadId(string adsquadId, PagingOption pagingOption)
        {
            var ads = ExecutePagedRequest <AdRootObject, AdWrapper, Ad>($"/adsquads/{adsquadId}/ads", pagingOption);

            return(ads);
        }
        /// <summary>
        /// Ajaxes the pager.
        /// </summary>
        /// <param name="html">The HTML.</param>
        /// <param name="options">The options.</param>
        /// <param name="options">The options.</param>
        /// <returns></returns>
        public static string AjaxPager(this HtmlHelper html, PagingOption pagingOptions, AjaxPaginationOption ajaxOptions)
        {
            var param = html.ViewContext.HttpContext.Request.Form;

            // merge data of ajax pagination option and request
            var data = new RouteValueDictionary(ajaxOptions.Data);

            if (ajaxOptions.AutoLoadParam == true)
            {
                foreach (var key in param.AllKeys)
                {
                    if (key != null && !data.ContainsKey(key))
                    {
                        data.Add(key, param[key]);
                    }
                }
            }

            int firstPage = 1;
            var before    = (int)Math.Ceiling((double)(pagingOptions.PageSize / 2));
            var after     = pagingOptions.PageSize - before;
            var startPage = Math.Max(1, pagingOptions.CurrentPage - before);
            int lastPage  = (int)Math.Ceiling((double)(pagingOptions.TotalRows) / (double)(pagingOptions.PageSize));
            var endPage   = Math.Min(lastPage, pagingOptions.CurrentPage + after);


            var dataObj = Json.Decode <Object>(Json.EncodeDictionary(data));

            // autload htmlID
            var HtmlID = ajaxOptions.HtmlID;

            if (ajaxOptions.AutoLoadHtmlID == true && param["HtmlID"] != null)
            {
                HtmlID = param["HtmlID"];
            }

            string hiddenRefresh = html.ButtonToRemote("", "cmdRefresh", new RemoteOption {
                URL = pagingOptions.UrlMaker(pagingOptions.CurrentPage), Update = HtmlID, Data = dataObj
            }, new { style = "display:none" });

            if (pagingOptions.TotalRows <= pagingOptions.PageSize)
            {
                return(hiddenRefresh);
            }


            var ret = new List <String>();


            //pager.LinkPattern = linkPagePattern;
            string currentLinkPattern = "<b>" + pagingOptions.CurrentPage + "</b>";

            // first page
            if (pagingOptions.CurrentPage != firstPage)
            {
                ret.Add(html.LinkToRemote("First", new RemoteOption {
                    URL = pagingOptions.UrlMaker(firstPage), Update = HtmlID, Data = dataObj
                }));
            }

            // previous page
            if (pagingOptions.CurrentPage > 1)
            {
                ret.Add(html.LinkToRemote("Previous", new RemoteOption {
                    URL = pagingOptions.UrlMaker(pagingOptions.CurrentPage - 1), Update = HtmlID, Data = dataObj
                }));
            }

            // pages
            for (int i = startPage; i <= endPage; i++)
            {
                if (i == pagingOptions.CurrentPage)
                {
                    ret.Add(currentLinkPattern);
                }
                else
                {
                    ret.Add(html.LinkToRemote(i.ToString(), new RemoteOption {
                        URL = pagingOptions.UrlMaker(i), Update = HtmlID, Data = dataObj
                    }));
                }
            }

            // next page
            if (pagingOptions.CurrentPage < endPage)
            {
                ret.Add(html.LinkToRemote("Next", new RemoteOption {
                    URL = pagingOptions.UrlMaker(pagingOptions.CurrentPage + 1), Update = HtmlID, Data = dataObj
                }));
            }

            // last page
            if (pagingOptions.CurrentPage != lastPage)
            {
                ret.Add(html.LinkToRemote("Last", new RemoteOption {
                    URL = pagingOptions.UrlMaker(lastPage), Update = HtmlID, Data = dataObj
                }));
            }
            ret.Add(hiddenRefresh);
            return(String.Join(" ", ret.ToArray()));
        }
Example #25
0
        /// <summary>
        /// 페이징 처리된 대시보드 테이블 업무 영역을 반환한다.
        /// </summary>
        public PagedModel <FormTableSection> SelectFormTableSectionPagedList(PagingOption option)
        {
            string procCommandName = "up_FormTableSection_SelectPagedList";

            try
            {
                var command = Connection.GetStoredProcCommand(procCommandName);
                Connection.AddInParameter(command, "PageNumber", DbType.Int32, option.PageNumber);
                Connection.AddInParameter(command, "PageCount", DbType.Int32, option.PageCount);
                Connection.AddInParameter(command, "SortBy", DbType.String, option.SortBy);
                Connection.AddInParameter(command, "OrderBy", DbType.String, option.OrderBy.ToEnumMemberString());

                using (DataSet ds = Connection.ExecuteDataSet(command))
                {
                    ValidateTableCount(ds, 4);

                    var result = new PagedModel <FormTableSection>(option)
                    {
                        PagingOption = option
                    };
                    int totalCount = 0;

                    // 1. 업무 영역
                    foreach (DataRow dr in ds.Tables[0].Rows)
                    {
                        var formSection = FormTableSection.ParseFrom(dr, out totalCount);
                        result.Items.Add(formSection);
                    }

                    // 2. 파일 템플릿 정보
                    foreach (DataRow dr in ds.Tables[1].Rows)
                    {
                        var fileTemplate = DataFileTemplate.ParseFrom(dr);
                        var formSections = result.Items.FindAll(o => o.FileTemplateId == fileTemplate.FileTemplateId);
                        if (formSections.Any())
                        {
                            formSections.ForEach(o =>
                            {
                                o.FileTemplate = fileTemplate;
                            });
                        }
                    }

                    // 3. 파일 소스 정보
                    foreach (DataRow dr in ds.Tables[2].Rows)
                    {
                        var fileSource   = DataFileSource.ParseFrom(dr);
                        var formSections = result.Items.FindAll(o => o.FormId == fileSource.FormId && o.FormSectionId == fileSource.FormSectionId);
                        if (formSections.Any())
                        {
                            formSections.ForEach(o =>
                            {
                                o.FileSource = fileSource;
                            });
                        }
                    }

                    // 4. 데이터 업로더 정보
                    foreach (DataRow dr in ds.Tables[3].Rows)
                    {
                        var uploader     = DataFileSourceUploader.ParseFrom(dr);
                        var formSections = result.Items.FindAll(o => o.FormId == uploader.FormId && o.FormSectionId == uploader.FormSectionId);
                        if (formSections.Any())
                        {
                            formSections.ForEach(o =>
                            {
                                o.FileSourceUploaders[uploader.UserId] = uploader;
                            });
                        }
                    }

                    result.TotalCount = totalCount;

                    return(result);
                }
            }
            catch (Exception ex)
            {
                throw new DataException($"프로시져 실행 중 예기치 못한 에러가 발생했습니다.\r\n 프로시저: \"{procCommandName}\"", ex);
            }
        }
Example #26
0
        /// <inheritdoc/>
        public IEnumerable <Organization> Get(PagingOption pagingOption)
        {
            var organizations = ExecutePagedRequest <OrganizationRootObject, OrganizationWrapper, Organization>("/me/organizations", pagingOption);

            return(organizations);
        }
        /// <inheritdoc/>
        public IEnumerable <Creative> GetByAdAccountId(string adAccountId, PagingOption pagingOption)
        {
            var creatives = ExecutePagedRequest <CreativeRootObject, CreativeWrapper, Creative>($"/adaccounts/{adAccountId}/creatives", pagingOption);

            return(creatives);
        }
Example #28
0
        /// <summary>
        /// Executed paged API request.
        /// </summary>
        /// <typeparam name="TRoot">Object of type <see cref="IRootObject{TWrapper, TEntity}"/>>.</typeparam>
        /// <typeparam name="TWrapper">Object of type <see cref="IWrapper{TEntity}"/>.</typeparam>
        /// <typeparam name="TEntity">Object of type <see cref="IEntity"/>.</typeparam>
        /// <param name="url">API request url.</param>
        /// <param name="pagingOption">API Paging options.</param>
        /// <returns>List of <see cref="IEntity"/>.</returns>
#pragma warning disable CA1054 // Uri parameters should not be strings
#pragma warning disable CA1822 // Mark members as static
        protected IEnumerable <TEntity> ExecutePagedRequest <TRoot, TWrapper, TEntity>(string url, PagingOption pagingOption)
            where TRoot : class, IRootObject <TWrapper, TEntity>, new()
            where TWrapper : class, IWrapper <TEntity>, new()
            where TEntity : class, IEntity, new()
#pragma warning restore CA1822 // Mark members as static
#pragma warning restore CA1054 // Uri parameters should not be strings
        {
            if (pagingOption is null)
            {
#pragma warning disable CA1303 // Do not pass literals as localized parameters
                throw new ArgumentNullException(nameof(pagingOption), Constants.INVALID_PAGEOPTIONS);
            }

            List <TEntity> entities = null;
            var            counter  = 0;

            do
            {
                var request = new RestRequest(url, Method.GET);

                var response    = Execute <TRoot>(request);
                var tmpEntities = Extract <TRoot, TWrapper, TEntity>(response);

                if (!tmpEntities.Any())
                {
                    break;
                }

                if (entities == null)
                {
                    entities = new List <TEntity>();
                }

                entities.AddRange(tmpEntities);

                if (string.IsNullOrEmpty(response.Paging.NextLink))
                {
                    break;
                }

                url = GetRestReqestUrlFromPagingUrl(response.Paging.NextLink);

                counter++;
            }while (counter < pagingOption.NumberOfPages);

            return(entities);
        }
Example #29
0
 public List<Proposal> SelectProposals(ProposalFilter filter, PagingOption option)
 {
     return _dal.ProposalRepository.SelectProposals(filter, option);
 }
 public IEnumerable <Vehicle> Get(PagingOption paging)
 {
     return(ApplyPaging(Enumerable.Empty <Vehicle>().AsQueryable(), paging));
 }
Example #31
0
        /// <inheritdoc/>
        public IEnumerable <Campaign> GetByAccountId(string adAccountId, PagingOption pagingOption)
        {
            var campaigns = ExecutePagedRequest <CampaignRootObject, CampaignWrapper, Campaign>($"/adaccounts/{adAccountId}/campaigns", pagingOption);

            return(campaigns);
        }