LUIS Programmatic APIs v2.0 Helper

LUIS Service Docs
LUIS Service REST

  最近的项目中使用了微软认知服务系列提供的Language Understanding (LUIS)服务。 鉴于每次调整LUIS都需要到luis.ai进行相关调整感觉很麻烦。 于是将LUIS提供的REST API封装为LUIS Services Helper以供项目自身调用。

Model:

namespace KnowledgeBot.Portal.Service.Luis.Model    
{    
    public class Entity    
    {    
        public string Id { get; set; }    
        public string Name { get; set; }    
        public long TypeId { get; set; }    
        public string ReadableType { get; set; }    
    }    
 }    

using System.Collections.Generic;    

namespace KnowledgeBot.Portal.Service.Luis.Model    
{    
    public class Example    
    {    
        public string Text { get; set; }    
        public string IntentName { get; set; }    
        public IEnumerable<EntityLabel> EntityLabels { get; set; }    
     }    

     public class JSONExample    
     {    
         public string Text { get; set; }    
         public string Intent { get; set; }    
         public IEnumerable<EntityLabel> Entities { get; set; }    
     }    

     public class EntityLabel    
     {    
         public string EntityName { get; set; }    
         public int StartCharIndex { get; set; }    
         public int EndCharIndex { get; set; }    
     }    
 }    

namespace KnowledgeBot.Portal.Service.Luis.Model    
{    
    public class Intent    
    {    
        public string Id { get; set; }    
        public string Name { get; set; }    
    }    
}    

using System;    

namespace KnowledgeBot.Portal.Service.Luis.Model    
{    
    public class LuisApp    
    {    
        public string Id { get; set; }    
        public string Name { get; set; }    
        public string Description { get; set; }    
        public string Culture { get; set; }    
        public string UsageScenario { get; set; }    
        public string Domain { get; set; }    
        public int VersionsCount { get; set; }    
        public DateTime CreatedDateTime { get; set; }    
        public Endpoints Endpoints { get; set; }    
        public int EndpointHitsCount { get; set; }    
     }    

     public class Endpoints    
     {    
         public Production Production { get; set; }    
     }    

     public class Production    
     {    
         public string VersionId { get; set; }    
         public bool IsStaging { get; set; }    
         public string EndpointUrl { get; set; }    
         public string EndpointRegion { get; set; }    
         public string AssignedEndpointKey { get; set; }    
         public string PublishedDateTime { get; set; }    
     }    
 }    

using Newtonsoft.Json;    

namespace KnowledgeBot.Portal.Service.Luis.Model    
{    
    public class Publish    
    {    
        public string EndpointUrl { get; set; }    

        [JsonProperty(“subscription-key”)]    
         public string SubscriptionKey { get; set; }    
         public string EndpointRegion { get; set; }    
         public bool IsStaging { get; set; }    
     }    
 }    

using Newtonsoft.Json;    
using System;    

namespace KnowledgeBot.Portal.Service.Luis.Model    
{    
    publicclass Training    
    {    
        publicstring ModelId { get; set; }    

         [JsonProperty(“details”)]    
         public TrainingDetails Details { get; set; }    
     }    

     public class TrainingDetails    
     {    
         public int StatusId { get; set; }    
         public string Status { get; set; }    
         public int ExampleCount { get; set; }    
         public DateTime? TrainingDateTime { get; set; }    
         public string FailureReason { get; set; }    
     }    
 }    

 namespace KnowledgeBot.Portal.Service.Luis.Model    
 {    
     public class Utterance    
     {    
         public string UtteranceText { get; set; }    
         public int ExampleId { get; set; }    
     }    
 }

ServiceClient:

using Newtonsoft.Json;    
using Newtonsoft.Json.Serialization;    
using System;    
using System.Net.Http;    
using System.Net.Http.Headers;    
using System.Text;    
using System.Threading.Tasks;    
using System.Web.Configuration;    

 namespace KnowledgeBot.Portal.Service.Luis    
 {    
     public class ServiceClient    
     {    
         private string BASE_URL = WebConfigurationManager.AppSettings[“LuisAPIDomain”] ?? “https://westus.api.cognitive.microsoft.com/luis/api/v2.0”;  
         //private string BASE_URL = WebConfigurationManager.AppSettings[“LuisAPIDomain”] ?? “https://westus.api.cognitive.microsoft.com/luis/api/v2.0”;  
         private readonly string _subscriptionKey;    

         public ServiceClient(string subscriptionKey) =>    
             _subscriptionKey = subscriptionKey;    

         protected async Task<HttpResponseMessage> Get(string path)    
         {    
             using (var client = new HttpClient())    
             {    
                 client.DefaultRequestHeaders.Add(“Ocp-Apim-Subscription-Key”, _subscriptionKey);    
                 return await client.GetAsync($“{BASE_URL}{path}”);    
             }    
         }    

         protected async Task<string> Post(string path)    
         {    
             using (var client = new HttpClient())    
             {    
                 client.DefaultRequestHeaders.Add(“Ocp-Apim-Subscription-Key”, _subscriptionKey);    
                 var response = await client.PostAsync($“{BASE_URL}{path}”, null);    
                 var responseContent = await response.Content.ReadAsStringAsync();    
                 if (response.IsSuccessStatusCode)    
                     return responseContent;    
                 else
                 {    
                     var exception = JsonConvert.DeserializeObject<ServiceException>(responseContent);    
                     thrownew Exception($“{exception.Error?.Message ?? exception.Message}”);    
                 }    
             }    
         }    

         protected async Task<string> Post<TRequest>(string path, TRequest requestBody)    
         {    
             using (var client = new HttpClient())    
             {    
                 using (var content = new ByteArrayContent(GetByteData(requestBody)))    
                 {    
                     client.DefaultRequestHeaders.Add(“Ocp-Apim-Subscription-Key”, _subscriptionKey);    
                     content.Headers.ContentType = new MediaTypeHeaderValue(“application/json”);    
                     var response = await client.PostAsync($“{BASE_URL}{path}”, content);    
                     var responseContent = await response.Content.ReadAsStringAsync();    
                     if (response.IsSuccessStatusCode)    
                         return responseContent;    
                     else
                     {    
                         var exception = JsonConvert.DeserializeObject<ServiceException>(responseContent);    
                         thrownew Exception($“{exception.Error?.Message ?? exception.Message}”);    
                     }    
                 }    
             }    
         }    

         protected async Task Put<TRequest>(string path, TRequest requestBody)    
         {    
             using (var client = new HttpClient())    
             {    
                 using (var content = new ByteArrayContent(GetByteData(requestBody)))    
                 {    
                     client.DefaultRequestHeaders.Add(“Ocp-Apim-Subscription-Key”, _subscriptionKey);    
                     content.Headers.ContentType = new MediaTypeHeaderValue(“application/json”);    
                     var response = await client.PutAsync($“{BASE_URL}{path}”, content);    
                     if (!response.IsSuccessStatusCode)    
                     {    
                         var responseContent = await response.Content.ReadAsStringAsync();    
                         var exception = JsonConvert.DeserializeObject<ServiceException>(responseContent);    
                         thrownew Exception($“{exception.Error?.Message ?? exception.Message}”);    
                     }    
                 }    
             }    
         }    

         protected async Task Delete(string path)    
         {    
             using (var client = new HttpClient())    
             {    
                 client.DefaultRequestHeaders.Add(“Ocp-Apim-Subscription-Key”, _subscriptionKey);    
                 var response = await client.DeleteAsync($“{BASE_URL}{path}”);    
                 if (!response.IsSuccessStatusCode)    
                 {    
                     var responseContent = await response.Content.ReadAsStringAsync();    
                     var exception = JsonConvert.DeserializeObject<ServiceException>(responseContent);    
                     thrownew Exception($“{exception.Error?.Message ?? exception.Message}”);    
                 }    
             }    
          }    

          private byte[] GetByteData<TRequest>(TRequest requestBody)    
          {    
              var settings = new JsonSerializerSettings { ContractResolver = new CamelCasePropertyNamesContractResolver() };    
              var body = JsonConvert.SerializeObject(requestBody, settings);    
              return Encoding.UTF8.GetBytes(body);    
          }    
      }    
  }

ServiceException:

namespace KnowledgeBot.Portal.Service.Luis    
{    
    publicclass ServiceException    
    {    
        public Error Error { get; set; }    
        publicstring Message { get; set; }    
    }    

    publicclass Error    
     {    
         publicstring Code { get; set; }    
         publicstring Message { get; set; }    
     }    
 }

Interface:

using KnowledgeBot.Portal.Service.Luis.Model;    
using System.Collections.Generic;    
using System.Threading.Tasks;    

namespace KnowledgeBot.Portal.Service.Luis    
{    
    public interface ILuisClientService    
    {    
        Task<IReadOnlyCollection<LuisApp>> GetAllAppsAsync();    
         Task<LuisApp> GetAppByIdAsync(string id);    
         Task<LuisApp> GetAppByNameAsync(string name);    
         Task<string> AddAppAsync(string name, string description, string culture, string usageScenario, string domain, string initialVersionId);    
         Task RenameAppAsync(string id, string name, string description);    
         Task DeleteAppAsync(string id);    

         Task<IReadOnlyCollection<Intent>> GetAllIntentsAsync(string appId, string appVersionId);    
         Task<Intent> GetIntentByIdAsync(string id, string appId, string appVersionId);    
         Task<Intent> GetIntentByNameAsync(string name, string appId, string appVersionId);    
         Task<string> AddIntentAsync(string name, string appId, string appVersionId);    
         Task RenameIntentAsync(string id, string name, string appId, string appVersionId);    
         Task DeleteIntentAsync(string id, string appId, string appVersionId);    

         Task<IReadOnlyCollection<Entity>> GetAllEntitiesAsync(string appId, string appVersionId);    
         Task<Entity> GetEntityByIdAsync(string id, string appId, string appVersionId);    
         Task<Entity> GetEntityByNameAsync(string name, string appId, string appVersionId);    
         Task<string> AddEntityAsync(string name, string appId, string appVersionId);    
         Task RenameEntityAsync(string id, string name, string appId, string appVersionId);    
         Task DeleteEntityAsync(string id, string appId, string appVersionId);    

         Task<Utterance> AddExampleAsync(string appId, string appVersionId, Example model);    

         Task<TrainingDetails> TrainAsync(string appId, string appVersionId);    
         Task<IEnumerable<Training>> GetTrainingStatusListAsync(string appId, string appVersionId);    

         Task<Publish> PublishAsync(string appId, string appVersionId, bool isStaging, string region);    
     }    
 }

Interface implement:

using KnowledgeBot.Portal.Service.Luis;    
using KnowledgeBot.Portal.Service.Luis.Model;    
using Newtonsoft.Json;    
using System;    
using System.Collections.Generic;    
using System.Linq;    
using System.Threading.Tasks;    

namespace KnowledgeBot.Portal.Service    
 {    
     public class LuisClientService : ServiceClient, ILuisClientService    
     {    
         public LuisClientService(string subscriptionKey) : base(subscriptionKey) {    

         }    

         #region Apps  

         /// <summary>  
         /// Lists all of the user applications  
         /// </summary>  
         /// <returns>A List of LUIS apps</returns>  
         public async Task<IReadOnlyCollection<LuisApp>> GetAllAppsAsync()    
         {    
             var response = await Get($“/apps”);    
             var content = await response.Content.ReadAsStringAsync();    
             if (response.IsSuccessStatusCode)    
                 return JsonConvert.DeserializeObject<IReadOnlyCollection<LuisApp>>(content);    
             elseif (response.StatusCode != System.Net.HttpStatusCode.BadRequest)    
             {    
                 var exception = JsonConvert.DeserializeObject<ServiceException>(content);    
                 thrownew Exception($“{exception.Error.Code} – {exception.Error.Message}”);    
             }    
             returnnull;    
         }    

         /// <summary>  
         /// Gets the application info  
         /// </summary>  
         /// <param name=”id”>app id</param>  
         /// <returns>LUIS app</returns>  
         public async Task<LuisApp> GetAppByIdAsync(string id)    
         {    
             var response = await Get($“/apps/{id}”);    
             var content = await response.Content.ReadAsStringAsync();    
             if (response.IsSuccessStatusCode)    
                 return JsonConvert.DeserializeObject<LuisApp>(content);    
             elseif (response.StatusCode != System.Net.HttpStatusCode.BadRequest)    
             {    
                 var exception = JsonConvert.DeserializeObject<ServiceException>(content);    
                 thrownew Exception($“{exception.Error.Code} – {exception.Error.Message}”);    
             }    
             returnnull;    
         }    

         /// <summary>  
         /// Gets the application info  
         /// </summary>  
         /// <param name=”name”>app name</param>  
         /// <returns>LUIS app</returns>  
         public async Task<LuisApp> GetAppByNameAsync(string name)    
         {    
             var apps = await GetAllAppsAsync();    
             return apps.FirstOrDefault(app => app.Name.Equals(name));    
         }    

         /// <summary>  
         /// Creates a new LUIS app and returns the id  
         /// </summary>  
         /// <param name=”name”>app name</param>  
         /// <param name=”description”>app description</param>  
         /// <param name=”culture”>app culture: ‘en-us’, ‘es-es’, ‘pt-br’ and others</param>  
         /// <param name=”usageScenario”></param>  
         /// <param name=”domain”></param>  
         /// <param name=”initialVersionId”></param>  
         /// <returns>The ID of the created app</returns>  
         public async Task<string> AddAppAsync(string name, string description, string culture, string usageScenario, string domain, string initialVersionId)    
         {    
             var app = new
             {    
                 name = name,    
                 description = description,    
                 culture = culture,    
                 usageScenario = usageScenario,    
                 domain = domain,    
                 initialVersionId = initialVersionId    
             };    
             var response = await Post($“/apps”, app);    
             return JsonConvert.DeserializeObject<string>(response);    
         }    

         /// <summary>  
         /// Change the name and description of LUIS app  
         /// </summary>  
         /// <param name=”id”>app id</param>  
         /// <param name=”name”>new app name</param>  
         /// <param name=”description”>new app description</param>  
         /// <returns></returns>  
         public async Task RenameAppAsync(string id, string name, string description)    
          {    
              var app = new
              {    
                  name = name,    
                  description = description    
              };    
              await Put($“/apps/{id}”, app);    
          }    

          /// <summary>  
          /// Deletes an application  
          /// </summary>  
          /// <param name=”id”>app id</param>  
          /// <returns></returns>  
          public async Task DeleteAppAsync(string id)    
          {    
              await Delete($“/apps/{id}”);    
          }    

          #endregion  

          #region Intents  

          /// <summary>  
          /// Gets information about the intent models  
          /// </summary>  
          /// <param name=”appId”>app id</param>  
          /// <param name=”appVersionId”>app version</param>  
          /// <returns>A List of app intents</returns>  
          public async Task<IReadOnlyCollection<Intent>> GetAllIntentsAsync(string appId, string appVersionId)    
          {    
              var response = await Get($“/apps/{appId}/versions/{appVersionId}/intents”);    
              var content = await response.Content.ReadAsStringAsync();    
              if (response.IsSuccessStatusCode)    
                  return JsonConvert.DeserializeObject<IReadOnlyCollection<Intent>>(content);    
              elseif (response.StatusCode != System.Net.HttpStatusCode.BadRequest)    
              {    
                  var exception = JsonConvert.DeserializeObject<ServiceException>(content);    
                  thrownew Exception($“{ exception.Error.Code} – { exception.Error.Message}”);    
              }    
              returnnull;    
          }    

          /// <summary>  
          /// Gets information about the intent model  
          /// </summary>  
          /// <param name=”id”>intent id</param>  
          /// <param name=”appId”>app id</param>  
          /// <param name=”appVersionId”>app version</param>  
          /// <returns>app intent</returns>  
          public async Task<Intent> GetIntentByIdAsync(string id, string appId, string appVersionId)    
          {    
              var response = await Get($“/apps/{appId}/versions/{appVersionId}/intents/{id}”);    
              var content = await response.Content.ReadAsStringAsync();    
              if (response.IsSuccessStatusCode)    
                  return JsonConvert.DeserializeObject<Intent>(content);    
              elseif (response.StatusCode != System.Net.HttpStatusCode.BadRequest)    
              {    
                  var exception = JsonConvert.DeserializeObject<ServiceException>(content);    
                  thrownew Exception($“{ exception.Error.Code} – { exception.Error.Message}”);    
              }    
              returnnull;    
          }    

          /// <summary>  
          /// Gets information about the intent model  
          /// </summary>  
          /// <param name=”name”>intent name</param>  
          /// <param name=”appId”>app id</param>  
          /// <param name=”appVersionId”>app version</param>  
          /// <returns>app intent</returns>  
          public async Task<Intent> GetIntentByNameAsync(string name, string appId, string appVersionId)    
          {    
              var apps = await GetAllIntentsAsync(appId, appVersionId);    
              return apps.FirstOrDefault(intent => intent.Name.Equals(name));    
          }    

          /// <summary>  
          /// Creates a new app intent and returns the id  
          /// </summary>  
          /// <param name=”name”>intent name</param>  
          /// <param name=”appId”>app id</param>  
          /// <param name=”appVersionId”>app version</param>  
          /// <returns>The ID of the created intent</returns>  
          public async Task<string> AddIntentAsync(string name, string appId, string appVersionId)    
          {    
              var intent = new
              {    
                  name = name    
              };    
              var response = await Post($“/apps/{appId}/versions/{appVersionId}/intents”, intent);    
              return JsonConvert.DeserializeObject<string>(response);    
          }    

          /// <summary>  
          /// Change the name of app intent  
          /// </summary>  
          /// <param name=”id”>intent id</param>  
          /// <param name=”name”>new intent name</param>  
          /// <param name=”appId”>app id</param>  
          /// <param name=”appVersionId”>app version</param>  
          /// <returns></returns>  
          public async Task RenameIntentAsync(string id, string name, string appId, string appVersionId)    
          {    
              var intent = new
              {    
                  name = name    
              };    
              await Put($“/apps/{appId}/versions/{appVersionId}/intents/{id}”, intent);    
          }    

          /// <summary>  
          /// Deletes an intent classifier from the application  
          /// </summary>  
          /// <param name=”id”>intent id</param>  
          /// <param name=”appId”>app Id</param>  
          /// <param name=”appVersionId”>app version</param>  
          /// <returns></returns>  
          public async Task DeleteIntentAsync(string id, string appId, string appVersionId)    
          {    
              await Delete($“/apps/{appId}/versions/{appVersionId}/intents/{id}”);z    
          }    

          #endregion  

          #region Entities  

          /// <summary>  
          /// Gets information about the entity models  
          /// </summary>  
          /// <param name=”appId”>app id</param>  
          /// <param name=”appVersionId”>app version</param>  
          /// <returns>A List of app entities</returns>  
          public async Task<IReadOnlyCollection<Entity>> GetAllEntitiesAsync(string appId, string appVersionId)    
          {    
              var response = await Get($“/apps/{appId}/versions/{appVersionId}/entities”);    
              var content = await response.Content.ReadAsStringAsync();    
              if (response.IsSuccessStatusCode)    
                  return JsonConvert.DeserializeObject<IReadOnlyCollection<Entity>>(content);    
              elseif (response.StatusCode != System.Net.HttpStatusCode.BadRequest)    
              {    
                  var exception = JsonConvert.DeserializeObject<ServiceException>(content);    
                  thrownew Exception($“{ exception.Error.Code} – { exception.Error.Message}”);    
              }    
              returnnull;    
          }    

          /// <summary>  
          /// Gets information about the entity model  
          /// </summary>  
          /// <param name=”id”>entity id</param>  
          /// <param name=”appId”>app id</param>  
          /// <param name=”appVersionId”>app version</param>  
          /// <returns>app entity</returns>  
          public async Task<Entity> GetEntityByIdAsync(string id, string appId, string appVersionId)    
          {    
              var response = await Get($“/apps/{appId}/versions/{appVersionId}/entities/{id}”);    
              var content = await response.Content.ReadAsStringAsync();    
              if (response.IsSuccessStatusCode)    
                  return JsonConvert.DeserializeObject<Entity>(content);    
              elseif (response.StatusCode != System.Net.HttpStatusCode.BadRequest)    
              {    
                  var exception = JsonConvert.DeserializeObject<ServiceException>(content);    
                  thrownew Exception($“{ exception.Error.Code} – { exception.Error.Message}”);    
              }    
              returnnull;    
          }    

          /// <summary>  
          /// Gets information about the entity model  
          /// </summary>  
          /// <param name=”name”>entity name</param>  
          /// <param name=”appId”>app id</param>  
          /// <param name=”appVersionId”>app version</param>  
          /// <returns>app entity</returns>  
          public async Task<Entity> GetEntityByNameAsync(string name, string appId, string appVersionId)    
          {    
              var apps = await GetAllEntitiesAsync(appId, appVersionId);    
              return apps.FirstOrDefault(Entity => Entity.Name.Equals(name));    
          }    

          /// <summary>  
          /// Creates a new app entity and returns the id  
          /// </summary>  
          /// <param name=”name”>entity name</param>  
          /// <param name=”appId”>app id</param>  
          /// <param name=”appVersionId”>app version</param>  
          /// <returns>The ID of the created entity</returns>  
          public async Task<string> AddEntityAsync(string name, string appId, string appVersionId)    
          {    
              var Entity = new
              {    
                  name = name    
              };    
              var response = await Post($“/apps/{appId}/versions/{appVersionId}/entities”, Entity);    
              return JsonConvert.DeserializeObject<string>(response);    
          }    

          /// <summary>  
          /// Change the name of app entity  
          /// </summary>  
          /// <param name=”id”>entity id</param>  
          /// <param name=”name”>new intent name</param>  
          /// <param name=”appId”>app id</param>  
          /// <param name=”appVersionId”>app version</param>  
          /// <returns></returns>  
          public async Task RenameEntityAsync(string id, string name, string appId, string appVersionId)    
          {    
              var entity = new
              {    
                  name = name    
              };    
              await Put($“/apps/{appId}/versions/{appVersionId}/entities/{id}”, entity);    
          }    

          /// <summary>  
          /// Deletes an entity extractor from the application  
          /// </summary>  
          /// <param name=”id”>entity id</param>  
          /// <param name=”appId”>app Id</param>  
          /// <param name=”appVersionId”>app version</param>  
          /// <returns></returns>  
          public async Task DeleteEntityAsync(string id, string appId, string appVersionId)    
          {    
              await Delete($“/apps/{appId}/versions/{appVersionId}/entities/{id}”);    
          }    

          #endregion  

          #region examples  

          /// <summary>  
          /// Adds a labeled example to the application  
          /// </summary>  
          /// <param name=”appId”>app id</param>  
          /// <param name=”appVersionId”>app version</param>  
          /// <param name=”model”>object containing the example label</param>  
          /// <returns>A object of utterance created</returns>  
          public async Task<Utterance> AddExampleAsync(string appId, string appVersionId, Example model)    
          {    
              var response = await Post($“/apps/{appId}/versions/{appVersionId}/example”, model);    
              return JsonConvert.DeserializeObject<Utterance>(response);    
          }    

          #endregion  

          #region Train  

          /// <summary>  
          /// Sends a training request for a version of a specified LUIS app  
          /// </summary>  
          /// <param name=”appId”>app id</param>  
          /// <param name=”appVersionId”>app version</param>  
          /// <returns>A object of training request details</returns>  
          public async Task<TrainingDetails> TrainAsync(string appId, string appVersionId)    
          {    
              var response = await Post($“/apps/{appId}/versions/{appVersionId}/train”);    
              return JsonConvert.DeserializeObject<TrainingDetails>(response);    
          }    

          /// <summary>  
          /// Gets the training status of all models (intents and entities) for the specified LUIS app  
          /// </summary>  
          /// <param name=”appId”>app id</param>  
          /// <param name=”appVersionId”>app version</param>  
          /// <returns>A list of trainings status</returns>  
          public async Task<IEnumerable<Training>> GetTrainingStatusListAsync(string appId, string appVersionId)    
          {    
              var response = await Get($“/apps/{appId}/versions/{appVersionId}/train”);    
              var content = await response.Content.ReadAsStringAsync();    
              if (response.IsSuccessStatusCode)    
                  return JsonConvert.DeserializeObject<IEnumerable<Training>>(content);    
              else
              {    
                  var exception = JsonConvert.DeserializeObject<ServiceException>(content);    
                  thrownew Exception($“{ exception.Error.Code} – { exception.Error.Message}”);    
              }    
          }    

          #endregion  

          #region Publish  

          /// <summary>  
          /// Publishes a specific version of the application  
          /// </summary>  
          /// <param name=”appId”>app id</param>  
          /// <param name=”appVersionId”>app version</param>  
          /// <param name=”isStaging”></param>  
          /// <param name=”region”>If the app is created in “westeurope”, then the publish location is also “westeurope.” For all other app locations, the publish location is “westus”</param>  
          /// <returns>A object of publish details</returns>  
          public async Task<Publish> PublishAsync(string appId, string appVersionId, bool isStaging, string region)    
          {    
              var model = new
              {    
                  versionId = appVersionId,    
                  isStaging = isStaging.ToString(),    
                  region = region    
              };    
              var response = await Post($“/apps/{appId}/publish”, model);    
              return JsonConvert.DeserializeObject<Publish>(response);    
          }    

          #endregion  
      }    
  }