Exemple #1
0
        public async Task <PluginPaginationResponse <AccountEntity> > Post([FromBody] SearchRequestInfo <AccountEntity> request, CancellationToken token)
        {
            if (request.Method == PluginRequestMethod.Update)
            {
                var updateRawData = request.RawData;
                if (updateRawData != null)
                {
                    var filterDefinition = Builders <AccountEntity> .Filter.Where(e => e.Id == updateRawData.Id);

                    var updateDefinition = Builders <AccountEntity> .Update.Set(e => e.AccountStatus, updateRawData.AccountStatus);

                    await this.UCenterDatabase.Accounts.UpdateOneAsync(updateRawData, filterDefinition, updateDefinition, token);
                }
            }

            string keyword = request.Keyword;
            int    page    = request.Page;
            int    count   = request.PageSize;

            Expression <Func <AccountEntity, bool> > filter = null;

            if (!string.IsNullOrEmpty(keyword))
            {
                filter = a => a.AccountName.Contains(keyword) ||
                         a.Email.Contains(keyword) ||
                         a.Phone.Contains(keyword);
            }

            var total = await this.UCenterDatabase.Accounts.CountAsync(filter, token);

            IQueryable <AccountEntity> queryable = this.UCenterDatabase.Accounts.Collection.AsQueryable();

            if (filter != null)
            {
                queryable = queryable.Where(filter);
            }
            queryable = queryable.OrderByDescending(a => a.CreatedTime);

            var result = queryable.Skip((page - 1) * count).Take(count).ToList();

            // todo: add orderby support.
            var model = new PluginPaginationResponse <AccountEntity>
            {
                Page     = page,
                PageSize = count,
                Raws     = result,
                Total    = total
            };

            return(model);
        }
Exemple #2
0
        public async Task <PluginPaginationResponse <AppConfigurationEntity> > Post([FromBody] SearchRequestInfo <AppConfigurationEntity> request, CancellationToken token)
        {
            if (request.Method == PluginRequestMethod.Update)
            {
                var updateRawData = request.RawData;
                if (updateRawData != null)
                {
                    var filterDefinition = Builders <AppConfigurationEntity> .Filter.Where(e => e.Id == updateRawData.Id);

                    var updateDefinition = Builders <AppConfigurationEntity> .Update
                                           .Set(e => e.Configuration, updateRawData.Configuration);

                    await this.UCenterDatabase.AppConfigurations.UpdateOneAsync(updateRawData, filterDefinition, updateDefinition, token);
                }
            }

            string keyword = request.GetParameterValue <string>("keyword");
            int    page    = request.GetParameterValue <int>("page", 1);
            int    count   = request.GetParameterValue <int>("pageSize", 10);

            Expression <Func <AppConfigurationEntity, bool> > filter = null;

            if (!string.IsNullOrEmpty(keyword))
            {
                filter = a => a.Name.Contains(keyword);
            }

            var total = await this.UCenterDatabase.AppConfigurations.CountAsync(filter, token);

            IQueryable <AppConfigurationEntity> queryable = this.UCenterDatabase.AppConfigurations.Collection.AsQueryable();

            if (filter != null)
            {
                queryable = queryable.Where(filter);
            }

            var result = queryable.Skip((page - 1) * count).Take(count).ToList();

            // todo: add orderby support.
            var model = new PluginPaginationResponse <AppConfigurationEntity>
            {
                Page     = page,
                PageSize = count,
                Raws     = result,
                Total    = total
            };

            return(model);
        }
Exemple #3
0
        public async Task <PluginPaginationResponse <ExceptionEventEntity> > Post([FromBody] SearchRequestInfo <ExceptionEventEntity> request, CancellationToken token)
        {
            if (request.Method == PluginRequestMethod.Delete)
            {
                var deleteRawData = request.RawData;
                if (deleteRawData != null)
                {
                    await this.UCenterEventDatabase.ExceptionEvents.DeleteAsync(
                        v => v.Id == deleteRawData.Id, token);
                }
            }

            string keyword = request.GetParameterValue <string>("keyword");
            int    page    = request.GetParameterValue <int>("page", 1);
            int    count   = request.GetParameterValue <int>("pageSize", 10);

            Expression <Func <ExceptionEventEntity, bool> > filter = null;

            if (!string.IsNullOrEmpty(keyword))
            {
                filter = a => a.Message.Contains(keyword);
            }

            var total = await this.UCenterEventDatabase.ExceptionEvents.CountAsync(filter, token);

            IQueryable <ExceptionEventEntity> queryable = this.UCenterEventDatabase.ExceptionEvents.Collection.AsQueryable();

            if (filter != null)
            {
                queryable = queryable.Where(filter);
            }
            queryable = queryable.OrderByDescending(e => e.CreatedTime);

            var result = queryable.Skip((page - 1) * count).Take(count).ToList();

            // todo: add orderby support.
            var model = new PluginPaginationResponse <ExceptionEventEntity>
            {
                Page     = page,
                PageSize = count,
                Raws     = result,
                Total    = total
            };

            return(model);
        }