//Call IPService
//Call GeoService with _ipaddress.IP
//Call NWSEndpointService with _usergeo.latitude.ToString(), _usergeo.longitude.ToString();
//Call ForecastService with _nwsemodel.Properties.forecast
public async Task <ForecastModel> GetWeatherAsync()
{
ForecastModel _forecast = new ForecastModel();
ForecastService _forecastservice = new ForecastService();
NWSEndpointModel _nwsemodel = new NWSEndpointModel();
NWSEndpointService _nwseservice = new NWSEndpointService();
IPAddressModel _ipaddress = new IPAddressModel();
IPService _ipservice = new IPService();
UserGeolocationModel _usergeo = new UserGeolocationModel();
GeoService _geoservice = new GeoService();
//Call IPService
//Call GeoService with _ipaddress.IP
//Call NWSEndpointService with _usergeo.latitude.ToString(), _usergeo.longitude.ToString();
//Call ForecastService with _nwsemodel.Properties.forecast
_ipaddress = await _ipservice.GetIPAsync();
_usergeo = await _geoservice.GetLocationAsync(_ipaddress.IP);
_nwsemodel = await _nwseservice.GetAPIEndpointAsync(_usergeo.latitude.ToString(), _usergeo.longitude.ToString());
_forecast = await _forecastservice.GetForecastAsync(_nwsemodel.properties.forecast);
return(_forecast);
}
public async Task <IActionResult> PreviewPeer(string url, IPAddressModel Addr, int?port)
{
if (!string.IsNullOrWhiteSpace(url))
{
var addresses = await Dns.GetHostAddressesAsync(new Uri(url).Authority);
if (addresses.Length > 0)
{
Addr = await _auth.GetOrRememberIP(addresses[0]);
}
else
{
return(BadRequest());
}
}
var peer = await(await _peers.Open(Addr, port)).Get(new ActivityStreamFilter("outbox"));
if (peer is Peer truePeer)
{
return(await ViewPeer(truePeer));
}
else
{
return(NotFound());
}
}
public async Task SetLimitForIP(IPAddressModel ip, string property, int?limit)
{
if (limit.HasValue)
{
await _redis.FieldSet <ActorRateLimitModel>(ip, property, limit.Value.ToString(), "limit");
}
else
{
await _redis.FieldDelete <ActorRateLimitModel>(property, ip, "limit");
}
}
public async Task <bool> TryIP(IPAddressModel ip, string property)
{
var rate = await GetRateForIP(ip, property);
var limit = await GetRateForIP(ip, property);
if (rate < limit)
{
await IncrementRateForIp(ip, property);
return(true);
}
else
{
return(false);
}
}
public async Task <IActivityStreamRepository> Open(IPAddressModel address, int?port = null)
{
if (address is SavedIPAddressModel savedAddress)
{
return(await Open(savedAddress, port));
}
else
{
var ip = await _auth.GetOrRememberIP(address.ToIp());
if (ip != null)
{
return(await Open(ip, port.Value));
}
return(null);
}
}
public HttpResponseMessage Get(string passport)
{
string flushUrl = string.Format(requestUrl, Application.AccessToken.GetAccessToken());
string data = HttpHelper.HttpGetData(flushUrl);
IPAddressModel ipAddressMessage = JsonConvert.DeserializeObject <IPAddressModel>(data);
if (ipAddressMessage.ip_list == null || ipAddressMessage.ip_list.Length < 1)
{
FailedResultModel errorMessage = JsonConvert.DeserializeObject <FailedResultModel>(data);
string error = Application.ErrorMessage.TranslateErrorCode(errorMessage.errcode);
return(new HttpResponseMessage {
Content = new StringContent(error + System.Environment.NewLine + errorMessage.errmsg, Encoding.GetEncoding("UTF-8"), "text/plain")
});
}
return(new HttpResponseMessage {
Content = new StringContent(string.Join(",", ipAddressMessage.ip_list), Encoding.GetEncoding("UTF-8"), "text/plain")
});
}
public async Task <IActionResult> TrustPeer(IPAddressModel Addr, int?port)
{
ViewData["Controller"] = "Admin";
ViewData["Action"] = nameof(PreviewPeer);
var peerClient = await _peers.Open(Addr, port);
var peer = await peerClient.Get(new ActivityStreamFilter("outbox"));
if (peer != null && peer is Peer truePeer)
{
await _peers.AddPeer(truePeer);
if (ModelState.IsValid)
{
return(RedirectToAction(nameof(Peer), new { address = Addr.Address, port = port }));
}
}
return(View(new PinkUmbrella.ViewModels.Peer.PeerViewModel()
{
MyProfile = await GetCurrentUserAsync(),
//Peer = peer?.Get(),
}));
}
public void setIPAddress(IPAddressModel iPAddress)
{
this.iPAddress = iPAddress;
}
public async Task <int> GetLimitForIP(IPAddressModel ip, string property)
{
return(int.Parse((await _redis.FieldGet <ActorRateLimitModel>(ip, property, "limit")) ?? "0"));
}
public async Task <ActorRateLimitModel> GetAllRatesForIP(IPAddressModel ip)
{
var res = await _redis.Get <ActorRateLimitModel>(ip, "rate");
return(res ?? Zero);
}
public async Task <ActorRateLimitModel> GetAllLimitsForIP(IPAddressModel ip)
{
var res = await _redis.Get <ActorRateLimitModel>(ip, "limit");
return(res ?? DefaultSingleUserLimit);
}
public Task IncrementRateForIp(IPAddressModel ip, string property) => _redis.Increment <ActorRateLimitModel>(property, ip, "rate");
private string PeerDirectory(IPAddressModel address, int?port) => $"Peers/{address}-{port}";
