Merge pull request #5 from microsoftgraph/chore/generate_cli_code

Add generated code

Author: calebkiage

.github/workflows/build-cli.yml

@@ -0,0 +1,31 @@
+name: "Build CLI"
+on: [push]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    env:
+      NUGET_URL: https://nuget.pkg.github.com/microsoft/index.json
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Setup .NET Core SDK 6
+        uses: actions/setup-dotnet@v1
+        with:
+          dotnet-version: 6.x
+      - name: Add NuGet kiota source
+        # TODO: Add NUGET_USER and NUGET_PASSWORD secrets
+        # TODO: Add NUGET_URL to env
+        # NOTE: Password encryption is not supported for the linux platform (Encryption is only supported on Windows platforms.)
+        run: |
+          dotnet nuget add source ${{env.NUGET_URL}} -n github -u ${{secrets.NUGET_USER}} -p ${{secrets.NUGET_PASSWORD}} --store-password-in-clear-text
+      - uses: actions/cache@v2
+        with:
+          path: ~/.nuget/packages
+          # Look to see if there is a cache hit for the corresponding requirements file
+          key: ${{ runner.os }}-nuget-${{ hashFiles('**/packages.lock.json') }}
+          restore-keys: |
+            ${{ runner.os }}-nuget
+      - name: Install dependencies
+        run: dotnet restore
+      - name: Build
+        run: dotnet build --configuration Release --no-restore

src/Program.cs

@@ -1,4 +1,5 @@
 using System.CommandLine;
+using System.Threading.Tasks;
 
 namespace Microsoft.Graph.Cli
 {

src/generated/Admin/AdminRequestBuilder.cs

@@ -0,0 +1,162 @@
+using ApiSdk.Admin.ServiceAnnouncement;
+using ApiSdk.Models.Microsoft.Graph;
+using Microsoft.Kiota.Abstractions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System;
+using System.Collections.Generic;
+using System.CommandLine;
+using System.CommandLine.Invocation;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+namespace ApiSdk.Admin {
+    /// <summary>Builds and executes requests for operations under \admin</summary>
+    public class AdminRequestBuilder {
+        /// <summary>Path parameters for the request</summary>
+        private Dictionary<string, object> PathParameters { get; set; }
+        /// <summary>The request adapter to use to execute the requests.</summary>
+        private IRequestAdapter RequestAdapter { get; set; }
+        /// <summary>Url template to use to build the URL for the current request builder</summary>
+        private string UrlTemplate { get; set; }
+        /// <summary>
+        /// Get admin
+        /// </summary>
+        public Command BuildGetCommand() {
+            var command = new Command("get");
+            command.Description = "Get admin";
+            // Create options for all the parameters
+            command.AddOption(new Option<object>("--select", description: "Select properties to be returned"));
+            command.AddOption(new Option<object>("--expand", description: "Expand related entities"));
+            command.Handler = CommandHandler.Create<object, object>(async (select, expand) => {
+                var requestInfo = CreateGetRequestInformation();
+                requestInfo.QueryParameters.Add("select", select);
+                requestInfo.QueryParameters.Add("expand", expand);
+                var result = await RequestAdapter.SendAsync<ApiSdk.Models.Microsoft.Graph.Admin>(requestInfo);
+                // Print request output. What if the request has no return?
+                using var serializer = RequestAdapter.SerializationWriterFactory.GetSerializationWriter("application/json");
+                serializer.WriteObjectValue(null, result);
+                using var content = serializer.GetSerializedContent();
+                using var reader = new StreamReader(content);
+                var strContent = await reader.ReadToEndAsync();
+                Console.Write(strContent + "\n");
+            });
+            return command;
+        }
+        /// <summary>
+        /// Update admin
+        /// </summary>
+        public Command BuildPatchCommand() {
+            var command = new Command("patch");
+            command.Description = "Update admin";
+            // Create options for all the parameters
+            command.AddOption(new Option<string>("--body"));
+            command.Handler = CommandHandler.Create<string>(async (body) => {
+                using var stream = new MemoryStream(Encoding.UTF8.GetBytes(body));
+                var parseNode = ParseNodeFactoryRegistry.DefaultInstance.GetRootParseNode("application/json", stream);
+                var model = parseNode.GetObjectValue<ApiSdk.Models.Microsoft.Graph.Admin>();
+                var requestInfo = CreatePatchRequestInformation(model);
+                await RequestAdapter.SendNoContentAsync(requestInfo);
+                // Print request output. What if the request has no return?
+                Console.WriteLine("Success");
+            });
+            return command;
+        }
+        public Command BuildServiceAnnouncementCommand() {
+            var command = new Command("service-announcement");
+            var builder = new ApiSdk.Admin.ServiceAnnouncement.ServiceAnnouncementRequestBuilder(PathParameters, RequestAdapter);
+            command.AddCommand(builder.BuildDeleteCommand());
+            command.AddCommand(builder.BuildGetCommand());
+            command.AddCommand(builder.BuildHealthOverviewsCommand());
+            command.AddCommand(builder.BuildIssuesCommand());
+            command.AddCommand(builder.BuildMessagesCommand());
+            command.AddCommand(builder.BuildPatchCommand());
+            return command;
+        }
+        /// <summary>
+        /// Instantiates a new AdminRequestBuilder and sets the default values.
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        /// </summary>
+        public AdminRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) {
+            _ = pathParameters ?? throw new ArgumentNullException(nameof(pathParameters));
+            _ = requestAdapter ?? throw new ArgumentNullException(nameof(requestAdapter));
+            UrlTemplate = "{+baseurl}/admin{?select,expand}";
+            var urlTplParams = new Dictionary<string, object>(pathParameters);
+            PathParameters = urlTplParams;
+            RequestAdapter = requestAdapter;
+        }
+        /// <summary>
+        /// Get admin
+        /// <param name="h">Request headers</param>
+        /// <param name="o">Request options</param>
+        /// <param name="q">Request query parameters</param>
+        /// </summary>
+        public RequestInformation CreateGetRequestInformation(Action<GetQueryParameters> q = default, Action<IDictionary<string, string>> h = default, IEnumerable<IRequestOption> o = default) {
+            var requestInfo = new RequestInformation {
+                HttpMethod = HttpMethod.GET,
+                UrlTemplate = UrlTemplate,
+                PathParameters = PathParameters,
+            };
+            if (q != null) {
+                var qParams = new GetQueryParameters();
+                q.Invoke(qParams);
+                qParams.AddQueryParameters(requestInfo.QueryParameters);
+            }
+            h?.Invoke(requestInfo.Headers);
+            requestInfo.AddRequestOptions(o?.ToArray());
+            return requestInfo;
+        }
+        /// <summary>
+        /// Update admin
+        /// <param name="body"></param>
+        /// <param name="h">Request headers</param>
+        /// <param name="o">Request options</param>
+        /// </summary>
+        public RequestInformation CreatePatchRequestInformation(ApiSdk.Models.Microsoft.Graph.Admin body, Action<IDictionary<string, string>> h = default, IEnumerable<IRequestOption> o = default) {
+            _ = body ?? throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation {
+                HttpMethod = HttpMethod.PATCH,
+                UrlTemplate = UrlTemplate,
+                PathParameters = PathParameters,
+            };
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            h?.Invoke(requestInfo.Headers);
+            requestInfo.AddRequestOptions(o?.ToArray());
+            return requestInfo;
+        }
+        /// <summary>
+        /// Get admin
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="h">Request headers</param>
+        /// <param name="o">Request options</param>
+        /// <param name="q">Request query parameters</param>
+        /// <param name="responseHandler">Response handler to use in place of the default response handling provided by the core service</param>
+        /// </summary>
+        public async Task<ApiSdk.Models.Microsoft.Graph.Admin> GetAsync(Action<GetQueryParameters> q = default, Action<IDictionary<string, string>> h = default, IEnumerable<IRequestOption> o = default, IResponseHandler responseHandler = default, CancellationToken cancellationToken = default) {
+            var requestInfo = CreateGetRequestInformation(q, h, o);
+            return await RequestAdapter.SendAsync<ApiSdk.Models.Microsoft.Graph.Admin>(requestInfo, responseHandler, cancellationToken);
+        }
+        /// <summary>
+        /// Update admin
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="h">Request headers</param>
+        /// <param name="model"></param>
+        /// <param name="o">Request options</param>
+        /// <param name="responseHandler">Response handler to use in place of the default response handling provided by the core service</param>
+        /// </summary>
+        public async Task PatchAsync(ApiSdk.Models.Microsoft.Graph.Admin model, Action<IDictionary<string, string>> h = default, IEnumerable<IRequestOption> o = default, IResponseHandler responseHandler = default, CancellationToken cancellationToken = default) {
+            _ = model ?? throw new ArgumentNullException(nameof(model));
+            var requestInfo = CreatePatchRequestInformation(model, h, o);
+            await RequestAdapter.SendNoContentAsync(requestInfo, responseHandler, cancellationToken);
+        }
+        /// <summary>Get admin</summary>
+        public class GetQueryParameters : QueryParametersBase {
+            /// <summary>Expand related entities</summary>
+            public string[] Expand { get; set; }
+            /// <summary>Select properties to be returned</summary>
+            public string[] Select { get; set; }
+        }
+    }
+}