Exemplo n.º 1
0
        /// <summary>
        /// Performs execution of the command
        /// </summary>
        protected override void ProcessRecord()
        {
            try
            {
                List <NPodGroupFilter> filters = new List <NPodGroupFilter>();

                if (ParameterPresent("Guid"))
                {
                    NPodGroupFilter f = new NPodGroupFilter();
                    f.Guid           = new GuidFilter();
                    f.Guid.MustEqual = Guid;
                    filters.Add(f);
                }

                if (ParameterPresent("Name"))
                {
                    NPodGroupFilter f = new NPodGroupFilter();
                    f.Name           = new StringFilter();
                    f.Name.MustEqual = Name;
                    filters.Add(f);
                }

                // convert to filter
                NPodGroupFilter filter = GenerateFilter(filters);

                PageInput     page = PageInput.First;
                NPodGroupList list = Connection.GetNebNPodGroups(page, filter, null);

                foreach (NPodGroup item in list.Items)
                {
                    WriteObject(item);
                }

                while (list.More)
                {
                    // advance the page
                    page.Page = page.Page + 1;

                    list = Connection.GetNebNPodGroups(page, filter, null);
                    foreach (NPodGroup item in list.Items)
                    {
                        WriteObject(item);
                    }
                }
            }
            catch (AggregateException exceptions)
            {
                foreach (Exception ex in exceptions.InnerExceptions)
                {
                    WriteError(ex);
                }
            }
            catch (Exception ex)
            {
                WriteError(ex);
            }
        }
        /// <summary>
        /// Retrieves the number of nPod groups matching the filter
        /// </summary>
        /// <param name="filter">
        /// A filter object to filter the items on the server. If omitted, all
        /// items are counted on the server
        /// </param>
        /// <returns>The number of nPod groups matching the filter</returns>
        public long GetNPodGroupCount(NPodGroupFilter filter = null)
        {
            // setup query parameters
            GraphQLParameters parameters = new GraphQLParameters();

            parameters.Add("filter", filter);

            return(RunQuery <long>("getNPodGroupCount", parameters));
        }
        /// <summary>
        /// Retrieves a list of nPod group objects
        /// </summary>
        /// <param name="page">
        /// The requested page from the server. This is an optional
        /// argument and if omitted the server will default to returning the
        /// first page with a maximum of <c>100</c> items.
        /// </param>
        /// <param name="filter">
        /// A filter object to filter the items on the server. If omitted, the
        /// server will return all objects as a paginated response.
        /// </param>
        /// <param name="sort">
        /// A sort definition object to sort the objects on supported
        /// properties.If omitted objects are returned in the order as they
        /// were created in.
        /// </param>
        /// <returns>Paginated list of nPod groups</returns>
        public NPodGroupList GetNebNPodGroups(
            PageInput page         = null,
            NPodGroupFilter filter = null,
            NPodGroupSort sort     = null)
        {
            // setup parameters
            GraphQLParameters parameters = new GraphQLParameters();

            parameters.Add("page", page, true);
            parameters.Add("filter", filter, true);
            parameters.Add("sort", sort, true);

            // this should return exactly one item.
            return(RunQuery <NPodGroupList>(@"getNPodGroups", parameters));
        }
Exemplo n.º 4
0
        /// <summary>
        /// Compiles a single filter from a list of filters by combining them
        /// with a logical AND
        /// </summary>
        /// <param name="filters">
        /// List of filters to combine
        /// </param>
        /// <returns></returns>
        private NPodGroupFilter GenerateFilter(List <NPodGroupFilter> filters)
        {
            NPodGroupFilter result = null;

            foreach (NPodGroupFilter filter in filters)
            {
                if (result == null)
                {
                    result = filter;
                    continue;
                }

                filter.And = result;
                result     = filter;
            }

            return(result);
        }