public override void ExecuteApiManagementCmdlet()
{
var actionDescription = string.Format(CultureInfo.CurrentCulture, Resources.OperationRemoveDescription, OperationId, ApiId);
var actionWarning = string.Format(CultureInfo.CurrentCulture, Resources.OperationRemoveWarning, OperationId, ApiId);
// Do nothing if force is not specified and user cancelled the operation
if (!ShouldProcess(
actionDescription,
actionWarning,
Resources.ShouldProcessCaption))
{
return;
}
// determine the apiId
string apiId = ApiId;
if (!string.IsNullOrEmpty(ApiRevision))
{
apiId = ApiId.ApiRevisionIdentifier(ApiRevision);
}
Client.OperationRemove(Context, apiId, OperationId);
if (PassThru.IsPresent)
{
WriteObject(true);
}
}
public override void ExecuteApiManagementCmdlet()
{
if (ParameterSetName.Equals(AllApis))
{
WriteObject(Client.ApiList(Context), true);
}
else if (ParameterSetName.Equals(FindById))
{
string id = ApiId;
if (ApiRevision != null)
{
id = ApiId.ApiRevisionIdentifier(ApiRevision);
}
WriteObject(Client.ApiById(Context.ResourceGroupName, Context.ServiceName, id));
}
else if (ParameterSetName.Equals(FindByName))
{
WriteObject(Client.ApiByName(Context, Name), true);
}
else if (ParameterSetName.Equals(FindByProductId))
{
WriteObject(Client.ApiByProductId(Context, ProductId), true);
}
else if (ParameterSetName.Equals(FindByGatewayId))
{
WriteObject(Client.ApiByGatewayId(Context, GatewayId), true);
}
}
public override void ExecuteApiManagementCmdlet()
{
string operationId = OperationId ?? Guid.NewGuid().ToString("N");
string apiId = ApiId;
if (!string.IsNullOrEmpty(ApiRevision))
{
apiId = ApiId.ApiRevisionIdentifier(ApiRevision);
}
var newOperation = Client.OperationCreate(
Context,
ApiId,
operationId,
Name,
Method,
UrlTemplate,
Description,
TemplateParameters,
Request,
Responses);
WriteObject(newOperation);
}
public override void ExecuteApiManagementCmdlet()
{
string apiId = ApiId;
if (!string.IsNullOrEmpty(ApiId))
{
if (!string.IsNullOrEmpty(ApiRevision))
{
apiId = ApiId.ApiRevisionIdentifier(ApiRevision);
}
}
else
{
apiId = Guid.NewGuid().ToString("N");
}
if (ParameterSetName.Equals(FromLocalFile))
{
FileInfo localFile = new FileInfo(this.GetUnresolvedProviderPathFromPSPath(this.SpecificationPath));
if (!localFile.Exists)
{
throw new FileNotFoundException(string.Format(CultureInfo.CurrentCulture, Resources.SourceFileNotFound, this.SpecificationPath));
}
Client.ApiImportFromFile(
Context,
apiId,
SpecificationFormat,
localFile.FullName,
Path,
WsdlServiceName,
WsdlEndpointName,
ApiType,
Protocol,
ServiceUrl);
}
else if (ParameterSetName.Equals(FromUrl))
{
Client.ApiImportFromUrl(
Context,
apiId,
SpecificationFormat,
SpecificationUrl,
Path,
WsdlServiceName,
WsdlEndpointName,
ApiType,
Protocol,
ServiceUrl);
}
else
{
throw new InvalidOperationException(string.Format("ParameterSetName '{0}' not supported", ParameterSetName));
}
var api = Client.ApiById(Context.ResourceGroupName, Context.ServiceName, apiId);
WriteObject(api);
}
public void SplitCurrentCsv(string telemetryCsv)
{
string[] splitCsv = telemetryCsv.Split('|');
string[] splitApiIdAndCacheInfo = splitCsv[1].Split(',');
ApiId.Add(splitApiIdAndCacheInfo[0]);
Enum.TryParse(splitApiIdAndCacheInfo[1], out CacheInfoTelemetry cacheInfoTelemetry);
ForceRefresh = CacheInfoTelemetry.ForceRefresh == cacheInfoTelemetry;
}
public void SplitCurrentCsv(string telemetryCsv)
{
string[] splitCsv = telemetryCsv.Split('|');
string[] splitApiIdAndForceRefresh = splitCsv[1].Split(',');
ApiId.Add(splitApiIdAndForceRefresh[0]);
string forceRefresh = splitApiIdAndForceRefresh[splitApiIdAndForceRefresh.Length - 1];
ForceRefresh = forceRefresh;
}
public override byte[] ToBytes()
{
return(TLUtils.Combine(
TLUtils.SignatureToBytes(Signature),
Flags.ToBytes(),
PhoneNumber.ToBytes(),
ToBytes(CurrentNumber, Flags, (int)SendCode.AllowFlashcall),
ApiId.ToBytes(),
ApiHash.ToBytes()));
}
public override byte[] ToBytes()
{
return(TLUtils.Combine(
TLUtils.SignatureToBytes(Signature),
PhoneNumber.ToBytes(),
BitConverter.GetBytes((int)SmsType),
ApiId.ToBytes(),
ApiHash.ToBytes(),
LangCode.ToBytes()));
}
private static XBeeResponse GetResponse(ApiId apiId)
{
if (!_responseHandler.Contains(apiId))
{
throw new XBeeException("No response contructor exists for apiId " + apiId);
}
var responseCtor = (ConstructorInfo)_responseHandler[apiId];
return((XBeeResponse)responseCtor.Invoke(null));
}
public override void ExecuteApiManagementCmdlet()
{
string apiId = ApiId;
if (!string.IsNullOrEmpty(ApiRevision))
{
apiId = ApiId.ApiRevisionIdentifier(ApiRevision);
}
var result = Client.ApiExportToFile(Context, apiId, SpecificationFormat, SaveAs);
if (ParameterSetName.Equals(ExportContentToPipeline))
{
string resultStr;
using (var memoryStream = new MemoryStream(result))
using (var streamReader = new StreamReader(memoryStream, Encoding.UTF8))
{
resultStr = streamReader.ReadToEnd();
}
WriteObject(resultStr);
}
else if (ParameterSetName.Equals(ExportToFile))
{
var actionDescription = string.Format(CultureInfo.CurrentCulture, Resources.ApiExportDescription, apiId, SaveAs);
var actionWarning = string.Format(CultureInfo.CurrentCulture, Resources.ApiExportWarning, SaveAs);
// Do nothing if force is not specified and user cancelled the operation
if (!ShouldProcess(apiId,
actionDescription) || (File.Exists(SaveAs) &&
!Force.IsPresent && !ShouldContinue(actionWarning, Resources.ShouldProcessCaption)))
{
if (PassThru)
{
WriteObject(false.ToString().ToLower());
}
return;
}
using (var file = File.OpenWrite(SaveAs))
{
file.Write(result, 0, result.Length);
file.Flush();
}
if (PassThru)
{
WriteObject(true.ToString().ToLower());
}
}
}
public override void ExecuteApiManagementCmdlet()
{
string apiId = ApiId;
if (!string.IsNullOrEmpty(ApiId))
{
if (!string.IsNullOrEmpty(ApiRevision))
{
apiId = ApiId.ApiRevisionIdentifier(ApiRevision);
}
}
else
{
apiId = Guid.NewGuid().ToString("N");
}
if (ParameterSetName.Equals(FromLocalFile))
{
Client.ApiImportFromFile(
Context,
apiId,
SpecificationFormat,
SpecificationPath,
Path,
WsdlServiceName,
WsdlEndpointName,
ApiType);
}
else if (ParameterSetName.Equals(FromUrl))
{
Client.ApiImportFromUrl(
Context,
apiId,
SpecificationFormat,
SpecificationUrl,
Path,
WsdlServiceName,
WsdlEndpointName,
ApiType);
}
else
{
throw new InvalidOperationException(string.Format("ParameterSetName '{0}' not supported", ParameterSetName));
}
var api = Client.ApiById(Context.ResourceGroupName, Context.ServiceName, apiId);
WriteObject(api);
}
public override void ExecuteApiManagementCmdlet()
{
// determine the apiId
string apiId = ApiId;
if (!string.IsNullOrEmpty(ApiRevision))
{
apiId = ApiId.ApiRevisionIdentifier(ApiRevision);
}
Client.OperationSet(Context, ApiId, OperationId, Name, Method, UrlTemplate, Description, TemplateParameters, Request, Responses);
if (PassThru.IsPresent)
{
var api = Client.OperationById(Context, ApiId, OperationId);
WriteObject(api);
}
}
public override void ExecuteApiManagementCmdlet()
{
string apiId = ApiId;
if (!string.IsNullOrEmpty(ApiRevision))
{
apiId = ApiId.ApiRevisionIdentifier(ApiRevision);
}
if (ParameterSetName.Equals(AllApiOperations))
{
WriteObject(Client.OperationList(Context, apiId), true);
}
else if (ParameterSetName.Equals(FindById))
{
WriteObject(Client.OperationById(Context, apiId, OperationId));
}
else
{
throw new InvalidOperationException(string.Format("Parameter set name '{0}' is not supported.", ParameterSetName));
}
}
// POST: api/Restaurant/5/reject
public async Task <IHttpActionResult> Reject(ApiId reviewId)
{
await _reviews.Reject(reviewId);
return(Ok());
}
// POST: api/Restaurant/5/approve
public async Task <IHttpActionResult> Approve(ApiId reviewId)
{
await _reviews.Approve(reviewId);
return(Ok());
}
// Use this for initialization
void Start()
{
apiid = GetComponent <ApiId>();
}
// GET: api/Reviews/5
public async Task <IHttpActionResult> GetRestaurantReviews(ApiId restaurantId)
{
var reviews = await _reviews.GetRestaurantReviews(restaurantId);
return(Ok(reviews));
}
// PUT: api/Restaurant/5/approve
public async Task <IHttpActionResult> Approve(ApiId restaurantId)
{
await _restaurants.Approve(restaurantId);
return(Ok());
}
public override void ExecuteApiManagementCmdlet()
{
string policyContent;
string apiId;
switch (ParameterSetName)
{
case TenantLevel:
policyContent = Client.PolicyGetTenantLevel(Context);
break;
case ProductLevel:
policyContent = Client.PolicyGetProductLevel(Context, ProductId);
break;
case ApiLevel:
apiId = ApiId;
if (!string.IsNullOrEmpty(ApiRevision))
{
apiId = ApiId.ApiRevisionIdentifier(ApiRevision);
}
policyContent = Client.PolicyGetApiLevel(Context, apiId);
break;
case OperationLevel:
if (string.IsNullOrWhiteSpace(ApiId))
{
throw new PSArgumentNullException("ApiId");
}
apiId = ApiId;
if (!string.IsNullOrEmpty(ApiRevision))
{
apiId = ApiId.ApiRevisionIdentifier(ApiRevision);
}
policyContent = Client.PolicyGetOperationLevel(Context, apiId, OperationId);
break;
default:
throw new InvalidOperationException(string.Format("Parameter set name '{0}' is not supported.", ParameterSetName));
}
if (policyContent == null)
{
return;
}
if (!string.IsNullOrEmpty(SaveAs))
{
var actionDescription = string.Format(CultureInfo.CurrentCulture, Resources.SavePolicyDescription, ParameterSetName, SaveAs);
var actionWarning = string.Format(CultureInfo.CurrentCulture, Resources.SavePolicyWarning, SaveAs);
// Do nothing if force is not specified and user cancelled the operation
if (!ShouldProcess(ApiId, actionDescription) || (File.Exists(SaveAs) &&
!Force.IsPresent &&
!ShouldContinue(
actionWarning,
Resources.ShouldProcessCaption)))
{
return;
}
File.WriteAllText(SaveAs, policyContent);
}
else
{
WriteObject(policyContent);
}
}
public override void ExecuteApiManagementCmdlet()
{
string policyContent;
string contentFormat = Utils.GetPolicyContentFormat(Format, !string.IsNullOrEmpty(PolicyUrl));
if (!string.IsNullOrWhiteSpace(Policy))
{
policyContent = Policy;
}
else if (!string.IsNullOrEmpty(PolicyFilePath))
{
policyContent = File.ReadAllText(PolicyFilePath);
}
else if (!string.IsNullOrEmpty(PolicyUrl))
{
policyContent = PolicyUrl;
}
else
{
throw new PSInvalidOperationException("Either -Policy or -PolicyFilePath or -PolicyUrl should be specified.");
}
string apiId;
switch (ParameterSetName)
{
case TenantLevel:
Client.PolicySetTenantLevel(Context, policyContent, contentFormat);
break;
case ProductLevel:
Client.PolicySetProductLevel(Context, policyContent, ProductId, contentFormat);
break;
case ApiLevel:
apiId = ApiId;
if (!string.IsNullOrEmpty(ApiRevision))
{
apiId = ApiId.ApiRevisionIdentifier(ApiRevision);
}
Client.PolicySetApiLevel(Context, policyContent, apiId, contentFormat);
break;
case OperationLevel:
if (string.IsNullOrWhiteSpace(ApiId))
{
throw new PSArgumentNullException("ApiId");
}
apiId = ApiId;
if (!string.IsNullOrEmpty(ApiRevision))
{
apiId = ApiId.ApiRevisionIdentifier(ApiRevision);
}
Client.PolicySetOperationLevel(Context, policyContent, apiId, OperationId, contentFormat);
break;
default:
throw new InvalidOperationException(string.Format("Parameter set name '{0}' is not supported.", ParameterSetName));
}
if (PassThru)
{
WriteObject(true);
}
}
// PUT: api/Restaurant/5/approve
public async Task <IHttpActionResult> Reject(ApiId restaurantId)
{
await _restaurants.Reject(restaurantId);
return(Ok());
}
// PUT: api/Restaurant/5
public async Task <IHttpActionResult> Put(ApiId restaurantId, [FromBody] RestaurantBindingModel restaurant)
{
var created = await _restaurants.Update(restaurantId, restaurant);
return(Ok(created));
}
// POST: api/Reviews
public async Task <IHttpActionResult> Post(ApiId restaurantId, [FromBody] ReviewBindingModel review)
{
var created = await _reviews.Create(restaurantId, review);
return(Created("api/reviews/" + created.Id, created));
}
private static XBeeResponse GetResponse(ApiId apiId)
{
if (!_responseHandler.Contains(apiId))
throw new XBeeException("No response contructor exists for apiId " + apiId);
var responseCtor = (ConstructorInfo) _responseHandler[apiId];
return (XBeeResponse) responseCtor.Invoke(null);
}
// PUT: api/Reviews/5
public async Task <IHttpActionResult> Put(ApiId reviewId, [FromBody] ReviewBindingModel review)
{
var result = await _reviews.Update(reviewId, review);
return(Ok(result));
}
// GET: api/Restaurant/5
public async Task <IHttpActionResult> Get(ApiId restaurantId)
{
var restaurant = await _restaurants.GetRestaurant(restaurantId);
return(Ok(restaurant));
}
// DELETE: api/Restaurant/5
public async Task <IHttpActionResult> Delete(ApiId reviewId)
{
await _reviews.Remove(reviewId);
return(StatusCode(HttpStatusCode.Gone));
}
// GET: api/Reviews/5
public async Task <IHttpActionResult> GetReview(ApiId reviewId)
{
var review = await _reviews.GetReview(reviewId);
return(Ok(review));
}
public IHttpActionResult Get(ApiId id)
{
return(Ok(id.Value)); // returns long value
}
