public RoutePlan GenerateRoute(RouteFilter requestModel)
{
var routePlan = _mapper.Map <RoutePlan>(requestModel);
const double hoursLimit = AvailableHoursPerDay * 0.8;
var startVisitPlaceDate = requestModel.StartDate;
while (requestModel.StartDate.Date <= requestModel.EndDate.Date)
{
var dayActivity = new DayActivity(requestModel.StartDate);
var hoursLeft = AvailableHoursPerDay;
var place = GetRandomPlace(requestModel.City, requestModel.PlaceTypes);
while (place.RecomendedTime.Hours <= hoursLeft)
{
place.SetVisitTime(startVisitPlaceDate);
dayActivity.Places.Add(place);
startVisitPlaceDate = place.EndDateTime;
if (hoursLeft <= hoursLimit)
{
dayActivity.Places.Add(place);
hoursLeft -= place.RecomendedTime.Hours;
}
place = GetPlaceNearby(place.Name, requestModel.PlaceTypes, startVisitPlaceDate);
}
routePlan.SchedulePerDay.Add(dayActivity);
}
return(routePlan);
}
public async Task <RouteFilter> CreateDefaultRouteFilter(string resourceGroupName, string filterName, string location,
NetworkManagementClient nrpClient, bool containsRule = false)
{
var filter = new RouteFilter()
{
Location = location,
Tags = { { "key", "value" } }
};
if (containsRule)
{
RouteFilterRule rule = new RouteFilterRule()
{
Name = "test",
Access = ExpressRouteTests.Filter_Access,
Communities = { ExpressRouteTests.Filter_Commmunity },
Location = location
};
filter.Rules.Add(rule);
}
// Put route filter
Operation <RouteFilter> filterOperation = await nrpClient.RouteFilters.StartCreateOrUpdateAsync(resourceGroupName, filterName, filter);
Response <RouteFilter> filterResponse = await WaitForCompletionAsync(filterOperation);
Assert.AreEqual("Succeeded", filterResponse.Value.ProvisioningState.ToString());
Response <RouteFilter> getFilterResponse = await nrpClient.RouteFilters.GetAsync(resourceGroupName, filterName);
return(getFilterResponse);
}
public async Task <Response <RouteFilter> > GetAsync(string resourceGroupName, string routeFilterName, string expand = null, CancellationToken cancellationToken = default)
{
if (resourceGroupName == null)
{
throw new ArgumentNullException(nameof(resourceGroupName));
}
if (routeFilterName == null)
{
throw new ArgumentNullException(nameof(routeFilterName));
}
using var message = CreateGetRequest(resourceGroupName, routeFilterName, expand);
await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
switch (message.Response.Status)
{
case 200:
{
RouteFilter value = default;
using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, cancellationToken).ConfigureAwait(false);
if (document.RootElement.ValueKind == JsonValueKind.Null)
{
value = null;
}
else
{
value = RouteFilter.DeserializeRouteFilter(document.RootElement);
}
return(Response.FromValue(value, message.Response));
}
public PSRouteFilter ToPsRouteFilter(RouteFilter routeFilter)
{
var psRouteFilter = Mapper.Map <PSRouteFilter>(routeFilter);
psRouteFilter.Tag = TagsConversionHelper.CreateTagHashtable(routeFilter.Tags);
return(psRouteFilter);
}
public PSRouteFilter ToPsRouteFilter(RouteFilter routeFilter)
{
var psRouteFilter = NetworkResourceManagerProfile.Mapper.Map <PSRouteFilter>(routeFilter);
psRouteFilter.Tag = TagsConversionHelper.CreateTagHashtable(routeFilter.Tags);
return(psRouteFilter);
}
public void the_new_route_should_be_returned()
{
var route = MailgunClientBuilder.GetClient().CreateRoute(1, "catch all that does nothing test" +
" for mailgun", RouteFilter.CatchAll(),
RouteAction.Stop());
route.Should().NotBeNull();
route.Id.Should().NotBeEmpty();
}
public void the_new_route_should_be_returned()
{
var route = MailgunClientBuilder.GetClient().CreateRoute(1, "catch all that does nothing test for mnailgun",
RouteFilter.CatchAll(),
RouteAction.InvokeWebHook(new Uri("http://foobar.com/messages")),
RouteAction.Stop());
route.Should().NotBeNull();
route.Id.Should().NotBeEmpty();
}
public void the_new_route_should_be_returned()
{
Action act = () => MailgunClientBuilder.GetClient().CreateRoute(
1,
"catch all that does nothing test for mnailgun",
RouteFilter.MatchRecipient("*@foobar.com"),
RouteAction.Stop());
act.Should().Throw <InvalidOperationException>()
.WithMessage("The 'match_reciptient' function is not recognized.");
}
public void the_new_route_should_be_deleted()
{
var client = MailgunClientBuilder.GetClient();
var route = client.CreateRoute(
1,
"catch all that does nothing test for mnailgun",
RouteFilter.CatchAll(),
RouteAction.Stop());
var result = client.DeleteRoute(route.Id);
result.Should().NotBeNull();
}
private async Task <RouteFilterRule> CreateDefaultRouteFilterRule(RouteFilter filter, string ruleName)
{
var rule = new RouteFilterRuleData()
{
Access = Access.Allow,
Communities = { Filter_Commmunity },
Location = filter.Data.Location
};
// Put route filter rule
Operation <RouteFilterRule> ruleOperation = InstrumentOperation(await filter.GetRouteFilterRules().CreateOrUpdateAsync(ruleName, rule));
Response <RouteFilterRule> ruleResponse = await ruleOperation.WaitForCompletionAsync();
return(ruleResponse);
}
public ActionResult Get([FromQuery] RouteFilter filter)
{
try {
if (ModelState.IsValid)
{
return(new JsonResult(new ApiResponse {
Success = true, Data = _service.GetBestRoute(filter.Origin, filter.Destination, filter.Criteria)
}));
}
var errors = ModelState.Keys
.SelectMany(key => ModelState[key].Errors.Select(x => new { Property = key, Error = x.ErrorMessage })).ToList();
return(new JsonResult(new ApiResponse {
Success = false, Data = errors
}));
} catch (Exception ex) {
return(new JsonResult(new ApiResponse {
Success = false, Data = ex.Message
}));
}
}
public static RouteFilter CreateDefaultRouteFilter(string resourceGroupName, string filterName, string location,
NetworkManagementClient nrpClient, bool containsRule = false)
{
var filter = new RouteFilter()
{
Location = location,
Tags = new Dictionary <string, string>()
{
{ "key", "value" }
}
};
if (containsRule)
{
var rule = new RouteFilterRule()
{
Name = "test",
Access = ExpressRouteTests.Filter_Access,
Communities = new List <string> {
ExpressRouteTests.Filter_Commmunity
},
Location = location
};
var rules = new List <RouteFilterRule>();
rules.Add(rule);
filter.Rules = rules;
}
// Put route filter
var filterResponse = nrpClient.RouteFilters.CreateOrUpdate(resourceGroupName, filterName, filter);
Assert.Equal("Succeeded", filterResponse.ProvisioningState);
var getFilterResponse = nrpClient.RouteFilters.Get(resourceGroupName, filterName);
return(getFilterResponse);
}
public Route CreateRoute(int priority, string description, RouteFilter expression, params RouteAction[] actions)
{
return(new CreateRouteCommand(this, priority, description, expression, actions).Invoke().Route);
}
public async Task RouteFilterApiTest()
{
Subscription subscription = await ArmClient.GetDefaultSubscriptionAsync();
var filterCollection = await GetCollection();
// Create route filter
string filterName = Recording.GenerateAssetName("filter");
string ruleName = Recording.GenerateAssetName("rule");
RouteFilter filter = await CreateDefaultRouteFilter(filterCollection,
filterName);
Assert.AreEqual("Succeeded", filter.Data.ProvisioningState.ToString());
Assert.AreEqual(filterName, filter.Data.Name);
Assert.IsEmpty(filter.Data.Rules);
var filters = await filterCollection.GetAllAsync().ToEnumerableAsync();
Has.One.Equals(filters);
Assert.AreEqual(filterName, filters[0].Data.Name);
Assert.IsEmpty(filters[0].Data.Rules);
var allFilters = await subscription.GetRouteFiltersAsync().ToEnumerableAsync();
// there could be other filters in the current subscription
Assert.True(allFilters.Any(f => filterName == f.Data.Name && f.Data.Rules.Count == 0));
// Crete route filter rule
RouteFilterRule filterRule = await CreateDefaultRouteFilterRule(filter, ruleName);
Assert.AreEqual("Succeeded", filterRule.Data.ProvisioningState.ToString());
Assert.AreEqual(ruleName, filterRule.Data.Name);
Response <RouteFilter> getFilterResponse = await filterCollection.GetAsync(filterName);
Assert.AreEqual(filterName, getFilterResponse.Value.Data.Name);
filter = await filterCollection.GetAsync(filterName);
Assert.AreEqual(filterName, filter.Data.Name);
Has.One.Equals(filter.Data.Rules);
Assert.AreEqual(ruleName, filter.Data.Rules[0].Name);
filterRule = await filter.GetRouteFilterRules().GetAsync(ruleName);
Assert.AreEqual(ruleName, filterRule.Data.Name);
// Update route filter
filterRule.Data.Access = Access.Deny;
filterRule = await filter.GetRouteFilterRules().CreateOrUpdate(ruleName, filterRule.Data).WaitForCompletionAsync();
Assert.AreEqual(ruleName, filterRule.Data.Name);
Assert.AreEqual(Access.Deny, filterRule.Data.Access);
// Add filter rule, this will fail due to the limitation of maximum 1 rule per filter
Assert.ThrowsAsync <RequestFailedException>(async() => await CreateDefaultRouteFilterRule(filter, Recording.GenerateAssetName("rule2")));
filter = await filterCollection.GetAsync(filterName);
Has.One.Equals(filter.Data.Rules);
Assert.AreEqual(ruleName, filter.Data.Rules[0].Name);
// Delete fileter rule
await filterRule.DeleteAsync();
var rules = await filter.GetRouteFilterRules().GetAllAsync().ToEnumerableAsync();
Assert.IsEmpty(rules);
// Delete filter
await filter.DeleteAsync();
allFilters = await subscription.GetRouteFiltersAsync().ToEnumerableAsync();
Assert.False(allFilters.Any(f => filter.Id == f.Id));
}
public void the_new_route_should_be_returned()
{
var route = MailgunClientBuilder.GetClient().CreateRoute(1, "catch all that does nothing test for mnailgun", RouteFilter.CatchAll(), RouteAction.Stop());
Assert.IsNotNull(route);
Assert.IsFalse(string.IsNullOrEmpty(route.Id));
}
public async Task <ExpressRouteCircuit> UpdateDefaultExpressRouteCircuitWithMicrosoftPeering(string resourceGroupName, string circuitName,
RouteFilter filter, NetworkManagementClient nrpClient)
{
ExpressRouteCircuitPeering peering = new ExpressRouteCircuitPeering()
{
Name = ExpressRoutePeeringType.MicrosoftPeering.ToString(),
PeeringType = ExpressRoutePeeringType.MicrosoftPeering,
PeerASN = Convert.ToInt32(ExpressRouteTests.MS_PeerASN),
PrimaryPeerAddressPrefix = ExpressRouteTests.MS_PrimaryPrefix,
SecondaryPeerAddressPrefix = ExpressRouteTests.MS_SecondaryPrefix,
VlanId = Convert.ToInt32(ExpressRouteTests.MS_VlanId),
MicrosoftPeeringConfig = new ExpressRouteCircuitPeeringConfig()
{
AdvertisedPublicPrefixes =
{
ExpressRouteTests.MS_PublicPrefix
},
LegacyMode = Convert.ToInt32(true)
},
RouteFilter = { Id = filter.Id }
};
Operation <ExpressRouteCircuitPeering> peerOperation = await nrpClient.ExpressRouteCircuitPeerings.StartCreateOrUpdateAsync(resourceGroupName, circuitName, ExpressRouteTests.Peering_Microsoft, peering);
Response <ExpressRouteCircuitPeering> peerResponse = await WaitForCompletionAsync(peerOperation);
Assert.AreEqual("Succeeded", peerResponse.Value.ProvisioningState.ToString());
Response <ExpressRouteCircuit> getCircuitResponse = await nrpClient.ExpressRouteCircuits.GetAsync(resourceGroupName, circuitName);
return(getCircuitResponse);
}
/// <summary>
/// Creates or updates a route filter in a specified resource group.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group.
/// </param>
/// <param name='routeFilterName'>
/// The name of the route filter.
/// </param>
/// <param name='routeFilterParameters'>
/// Parameters supplied to the create or update route filter operation.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <RouteFilter> BeginCreateOrUpdateAsync(this IRouteFiltersOperations operations, string resourceGroupName, string routeFilterName, RouteFilter routeFilterParameters, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.BeginCreateOrUpdateWithHttpMessagesAsync(resourceGroupName, routeFilterName, routeFilterParameters, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
/// <summary>
/// Creates or updates a route filter in a specified resource group.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group.
/// </param>
/// <param name='routeFilterName'>
/// The name of the route filter.
/// </param>
/// <param name='routeFilterParameters'>
/// Parameters supplied to the create or update route filter operation.
/// </param>
public static RouteFilter BeginCreateOrUpdate(this IRouteFiltersOperations operations, string resourceGroupName, string routeFilterName, RouteFilter routeFilterParameters)
{
return(operations.BeginCreateOrUpdateAsync(resourceGroupName, routeFilterName, routeFilterParameters).GetAwaiter().GetResult());
}
public virtual RouteFiltersCreateOrUpdateOperation StartCreateOrUpdate(string resourceGroupName, string routeFilterName, RouteFilter routeFilterParameters, CancellationToken cancellationToken = default)
{
if (resourceGroupName == null)
{
throw new ArgumentNullException(nameof(resourceGroupName));
}
if (routeFilterName == null)
{
throw new ArgumentNullException(nameof(routeFilterName));
}
if (routeFilterParameters == null)
{
throw new ArgumentNullException(nameof(routeFilterParameters));
}
using var scope = _clientDiagnostics.CreateScope("RouteFiltersClient.StartCreateOrUpdate");
scope.Start();
try
{
var originalResponse = RestClient.CreateOrUpdate(resourceGroupName, routeFilterName, routeFilterParameters, cancellationToken);
return(new RouteFiltersCreateOrUpdateOperation(_clientDiagnostics, _pipeline, RestClient.CreateCreateOrUpdateRequest(resourceGroupName, routeFilterName, routeFilterParameters).Request, originalResponse));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public static ExpressRouteCircuit UpdateDefaultExpressRouteCircuitWithMicrosoftPeering(string resourceGroupName, string circuitName, RouteFilter filter,
NetworkManagementClient nrpClient)
{
var peering = new ExpressRouteCircuitPeering()
{
Name = ExpressRoutePeeringType.MicrosoftPeering.ToString(),
PeeringType = ExpressRoutePeeringType.MicrosoftPeering,
PeerASN = Convert.ToInt32(ExpressRouteTests.MS_PeerASN),
PrimaryPeerAddressPrefix = ExpressRouteTests.MS_PrimaryPrefix,
SecondaryPeerAddressPrefix = ExpressRouteTests.MS_SecondaryPrefix,
VlanId = Convert.ToInt32(ExpressRouteTests.MS_VlanId),
MicrosoftPeeringConfig = new ExpressRouteCircuitPeeringConfig()
{
AdvertisedPublicPrefixes = new List <string>
{
ExpressRouteTests.MS_PublicPrefix
},
LegacyMode = Convert.ToInt32(true)
},
RouteFilter = { Id = filter.Id }
};
var peerResponse = nrpClient.ExpressRouteCircuitPeerings.CreateOrUpdate(resourceGroupName, circuitName,
ExpressRouteTests.Peering_Microsoft, peering);
Assert.Equal("Succeeded", peerResponse.ProvisioningState);
var getCircuitResponse = nrpClient.ExpressRouteCircuits.Get(resourceGroupName, circuitName);
return(getCircuitResponse);
}
public async Task <ExpressRouteCircuit> UpdateDefaultExpressRouteCircuitWithMicrosoftPeering(string resourceGroupName, string circuitName,
RouteFilter filter)
{
var peering = new ExpressRouteCircuitPeeringData()
{
Name = ExpressRoutePeeringType.MicrosoftPeering.ToString(),
PeeringType = ExpressRoutePeeringType.MicrosoftPeering,
PeerASN = Convert.ToInt32(ExpressRouteTests.MS_PeerASN),
PrimaryPeerAddressPrefix = ExpressRouteTests.MS_PrimaryPrefix,
SecondaryPeerAddressPrefix = ExpressRouteTests.MS_SecondaryPrefix,
VlanId = Convert.ToInt32(ExpressRouteTests.MS_VlanId),
MicrosoftPeeringConfig = new ExpressRouteCircuitPeeringConfig()
{
AdvertisedPublicPrefixes =
{
ExpressRouteTests.MS_PublicPrefix
},
LegacyMode = Convert.ToInt32(true)
},
RouteFilter = { Id = filter.Id }
};
Operation <ExpressRouteCircuitPeering> peerOperation = await GetResourceGroup(resourceGroupName).GetExpressRouteCircuits().Get(circuitName).Value.GetExpressRouteCircuitPeerings().CreateOrUpdateAsync(WaitUntil.Completed, ExpressRouteTests.Peering_Microsoft, peering);
Response <ExpressRouteCircuitPeering> peerResponse = await peerOperation.WaitForCompletionAsync();
Assert.AreEqual("Succeeded", peerResponse.Value.Data.ProvisioningState.ToString());
Response <ExpressRouteCircuit> getCircuitResponse = await GetResourceGroup(resourceGroupName).GetExpressRouteCircuits().GetAsync(circuitName);
return(getCircuitResponse);
}
