public async Task <IActionResult> Detail(string id)
{
Guid courseid = Guid.Empty;
if (Guid.TryParse(id, out courseid))
{
var response = await ApiRequestHelper.Get <Infrastructure.ApiResponse <EscolaDeVoce.Services.ViewModel.CourseViewModel> >(Helpers.EscolaDeVoceEndpoints.Courses.getDetails + "/" + courseid.ToString());
return(View(response.data));
}
return(View());
}
public void Should_return_user_exception_for_other_responses()
{
const string reason = "User not authorised";
SecureHttpRequest.Setup(x => x.GetAsync(It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync(ApiRequestHelper.CreateHttpResponseMessage(reason, HttpStatusCode.Unauthorized));
var response = Assert.ThrowsAsync <UserServiceException>(async() => await Service.GetGroupByIdAsync(GroupId));
response.Should().NotBeNull();
response.Message.Should().Be($"Failed to get group by id {GroupId}: {reason}");
response.Reason.Should().Be(reason);
}
public void Should_return_user_exception_for_other_responses()
{
const string message = "User not authorised";
SecureHttpRequest.Setup(x => x.GetAsync(It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync(ApiRequestHelper.CreateHttpResponseMessage(message, HttpStatusCode.Unauthorized));
var response = Assert.ThrowsAsync <UserServiceException>(async() => await Service.GetUserByFilterAsync(Filter));
response.Should().NotBeNull();
response.Message.Should().Be($"Failed to search user with filter test: {message}");
response.Reason.Should().Be(message);
}
public static async Task <ITunesTop> TopGenres(string key, int count)
{
try
{
var res = await ApiRequestHelper.HttpGet(string.Format(topUrl, CultureInfoHelper.CurrentRegionISO, count, key));
return(JsonConvert.DeserializeObject <ITunesTop>(res));
}
catch (System.Exception)
{
return(null);
}
}
public async Task <IActionResult> AddDictionaryItem([Bind("title,content,dictionaryType")] Services.ViewModel.DictionaryViewModel model)
{
Infrastructure.ApiResponse <bool> favoriteresponse = null;
model.userId = Guid.Parse(getClaimValue("Id"));
System.Net.Http.HttpMethod method = System.Net.Http.HttpMethod.Post;
favoriteresponse = await ApiRequestHelper.postPutRequest <Infrastructure.ApiResponse <bool> >(
Helpers.EscolaDeVoceEndpoints.Dictionary.get,
method,
JsonConvert.SerializeObject(model)
);
return(View());
}
public async Task <IEnumerable <JudiciaryPersonModel> > GetPeopleAsync(DateTime updatedSince, int page = 1, int perPage = 100)
{
var response = await _httpClient.GetAsync
(
$"{BaseUrl}/people?updated_since={updatedSince:yyyy-MM-dd}&page={page}&per_page={perPage}"
);
await ResponseHandler.HandleUnsuccessfulResponse(response);
var model = ApiRequestHelper.Deserialise <PeopleResults>(await response.Content.ReadAsStringAsync());
return(model.Results);
}
public async Task <IViewComponentResult> InvokeAsync()
{
try
{
var response = await ApiRequestHelper.Get <Infrastructure.ApiResponse <EscolaDeVoce.Services.ViewModel.PersonalityQuestionViewModel> >(Helpers.EscolaDeVoceEndpoints.Questions.getNextQuestion + "/" + getClaimValue("Id").ToString());
return(View(response.data));
}
catch (System.Exception)
{
}
return(View(new EscolaDeVoce.Services.ViewModel.PersonalityQuestionViewModel()));
}
public async Task <IActionResult> Detalhe(string id)
{
var response = await ApiRequestHelper.Get <Infrastructure.ApiResponse <EscolaDeVoce.Services.ViewModel.CourseViewModel> >(Helpers.EscolaDeVoceEndpoints.Courses.getdetail + "/" + id + "/" + getClaimValue("Id"));
if (response.data.userStarted)
{
var video = response.data.videos.FirstOrDefault();
return(RedirectToAction("Sala", new { id = response.data.Id, videoid = video.Id }));
}
else
{
return(View(response.data));
}
}
public async Task <IViewComponentResult> InvokeAsync(bool showEmbaixadorasButton)
{
ViewBag.showEmbaixadorasButton = showEmbaixadorasButton;
try
{
var response = await ApiRequestHelper.Get <Infrastructure.ApiResponse <List <EscolaDeVoce.Services.ViewModel.EspecialistViewModel> > >(Helpers.EscolaDeVoceEndpoints.Especialist.getEspecialists);
return(View(response.data));
}
catch (System.Exception)
{
}
return(View(new List <EscolaDeVoce.Services.ViewModel.EspecialistViewModel>()));
}
public async Task Should_get_Jwt_token_when_requested_with_correct_participant_id()
{
var responseMessage = await SendGetRequestAsync($"/participants/{Guid.NewGuid()}/jwtoken");
var receiveStream = await responseMessage.Content.ReadAsStreamAsync();
var readStream = new StreamReader(receiveStream, Encoding.UTF8);
var json = readStream.ReadToEnd();
var tokenResponse = ApiRequestHelper.Deserialise <TokenResponse>(json);
responseMessage.StatusCode.Should().Be(HttpStatusCode.OK);
tokenResponse.Should().NotBeNull();
tokenResponse.Token.Should().NotBeEmpty();
}
public void Should_throw_user_exception_on_other_responses()
{
var message = $"Failed to add user {user.Id} to group {group.Id}";
var reason = "Unathorized access";
SecureHttpRequest.Setup(x => x.PostAsync(It.IsAny <string>(), It.IsAny <StringContent>(), It.IsAny <string>()))
.ReturnsAsync(ApiRequestHelper.CreateHttpResponseMessage(reason, HttpStatusCode.Unauthorized));
var response = Assert.ThrowsAsync <UserServiceException>(async() => await Service.AddUserToGroupAsync(user, group));
response.Should().NotBeNull();
response.Message.Should().Be($"{message}: {reason}");
response.Reason.Should().Be(reason);
}
public async Task <IViewComponentResult> InvokeAsync()
{
try
{
var response = await ApiRequestHelper.Get <Infrastructure.ApiResponse <List <EscolaDeVoce.Services.ViewModel.SchoolViewModel> > >(Helpers.EscolaDeVoceEndpoints.School.get);
return(View(response.data));
}
catch (System.Exception)
{
}
return(View(new List <EscolaDeVoce.Services.ViewModel.SchoolViewModel>()));
}
public async Task <IViewComponentResult> InvokeAsync(Guid categoryid)
{
try
{
var response = await ApiRequestHelper.Get <Infrastructure.ApiResponse <List <EscolaDeVoce.Services.ViewModel.VideoViewModel> > >(Helpers.EscolaDeVoceEndpoints.Videos.getByCategory + categoryid.ToString());
return(View(response.data));
}
catch (System.Exception)
{
}
return(View(new List <EscolaDeVoce.Services.ViewModel.VideoViewModel>()));
}
public static async Task <OpenCageContract> OpenMapReGeoAsync(double latitude, double longitude)
{
var OpenStreetUrl = "http://api.opencagedata.com/geocode/v1/json?q={0}+{1}&key={2}&language=zh-cn";
var result = await ApiRequestHelper.RequestWithFormattedUrlAsync(OpenStreetUrl, new string[] { latitude.ToString("0.######"), longitude.ToString("0.######"), Key.OpenCage });
// json 生成类
if (result == null)
{
return(null);
}
var omapRes = JsonHelper.FromJson <OpenCageContract>(result);
return(omapRes);
}
public override async void ViewDestroy(bool viewFinishing = true)
{
base.ViewDestroy(viewFinishing);
if (_isPosted || !viewFinishing)
{
return;
}
foreach (var pictureViewModel in _post.PostPictures.Except(_originalPost.PostPictures))
{
await ApiRequestHelper.HandleApiResult(() =>
_pictureService.DeletePicture(
pictureViewModel.PictureUrl.Substring(pictureViewModel.PictureUrl.LastIndexOf("/") + 1)));
}
}
public async Task <ApiResult <ApplicationUserType> > Login()
{
return(await ApiRequestHelper.HandlApiRequest(async() =>
{
if (string.IsNullOrWhiteSpace(Settings.ApplicationData.RefreshToken))
{
return new ApiResult <ApplicationUserType>("loginRequired", false, ApplicationUserType.None);
}
var token = await _api.GetTokenByRefresh(new RefreshFlowRequest(Settings.ApplicationData.RefreshToken));
Settings.ApplicationData.AccessToken = token.AccessToken;
Settings.ApplicationData.TokenExpireTime = DateTimeOffset.Now.Subtract(new TimeSpan(0, 0, token.ExpiresIn));
var result = await GetCurrentApplicationUser();
return result;
}));
}
public async Task <IActionResult> Detail(string id)
{
if (id != null)
{
Guid categoryid = Guid.Empty;
if (Guid.TryParse(id, out categoryid))
{
var response = await ApiRequestHelper.Get <Infrastructure.ApiResponse <EscolaDeVoce.Services.ViewModel.CategoryViewModel> >(Helpers.EscolaDeVoceEndpoints.Category.getCategories + "/" + categoryid.ToString());
return(View(response.data));
}
}
return(View(new EscolaDeVoce.Services.ViewModel.CategoryViewModel()));
}
public static async Task <AmapContract> AmapReGeoAsync(double latitude, double longitude)
{
var requestUrl = "http://restapi.amap.com/v3/geocode/regeo?key={0}&location={1},{2}&radius=1000&extensions=all&batch=false&roadlevel=1";
// 高德经纬度颠倒
var result = await ApiRequestHelper.RequestWithFormattedUrlAsync(requestUrl, new string[] { Key.amap, longitude.ToString("0.######"), latitude.ToString("0.######") });
// json 生成类
if (result == null)
{
return(null);
}
var amapRes = JsonHelper.FromJson <AmapContract>(result);
return(amapRes);
}
public async Task <IViewComponentResult> InvokeAsync(string windowName, string buttonName)
{
ViewBag.windowName = windowName;
ViewBag.buttonName = buttonName;
try
{
var response = await ApiRequestHelper.Get <Infrastructure.ApiResponse <List <EscolaDeVoce.Services.ViewModel.CourseViewModel> > >(Helpers.EscolaDeVoceEndpoints.Courses.getCourses);
return(View(response.data));
}
catch (System.Exception)
{
}
return(View(new List <EscolaDeVoce.Services.ViewModel.CourseViewModel>()));
}
public async static Task <HeWeather.Location> ReGeobyIpAsync()
{
var ipUrl = "http://api.ip138.com/query/?token={0}";
var result = await ApiRequestHelper.RequestWithFormattedUrlAsync(ipUrl, new string[] { Key.ip138 });
if (result == null)
{
return(null);
}
var ipRes = JsonHelper.FromJson <IpContract>(result);
var city = await Request.RequestbyIpAsync(ipRes.ip);
var fetchresult = HeWeatherModel.Generate(city, DataSource.HeWeather);
return(fetchresult.Location);
}
public async Task Should_retrieve_the_client_config_settings()
{
var getResponse = await SendGetRequestAsync(_configSettingsEndpoints.GetConfigSettings);
var resonpseString = await getResponse.Content.ReadAsStringAsync();
getResponse.StatusCode.Should().Be(HttpStatusCode.OK, resonpseString);
var clientSettingsResponseModel = ApiRequestHelper.DeserialiseSnakeCaseJsonToResponse <ClientSettingsResponse>(resonpseString);
clientSettingsResponseModel.Should().NotBeNull();
clientSettingsResponseModel.ClientId.Should().NotBeNull();
clientSettingsResponseModel.TenantId.Should().NotBeNull();
clientSettingsResponseModel.RedirectUri.Should().NotBeNull();
clientSettingsResponseModel.TestUsernameStem.Should().NotBeNullOrEmpty();
clientSettingsResponseModel.TestUsernameStem.Length.Should().Be(26);
}
public async Task <IActionResult> Login([Bind("username,password")] Services.ViewModel.UserViewModel model)
{
Console.Write(model);
AuthenticationModel response = null;
System.Net.Http.HttpMethod method = System.Net.Http.HttpMethod.Post;
if (model.Id != Guid.Empty)
{
method = System.Net.Http.HttpMethod.Put;
}
response = await ApiRequestHelper.postPutEncodedRequest <AuthenticationModel>(
EscolaDeVoce.Backend.Helpers.EscolaDeVoceEndpoints.tokenUrl,
model.username,
model.password
);
if (response != null)
{
const string Issuer = "https://www.escoladevoce.com.br";
var claims = new List <Claim> {
new Claim(ClaimTypes.Name, "Charles", ClaimValueTypes.String, Issuer),
new Claim(ClaimTypes.Surname, "França", ClaimValueTypes.String, Issuer),
new Claim(ClaimTypes.Country, "BR", ClaimValueTypes.String, Issuer),
new Claim(ClaimTypes.Country, "BR", ClaimValueTypes.String, Issuer),
new Claim("TOKEN", response.access_token, ClaimValueTypes.String, Issuer),
new Claim("facebookid", "112345432145432", ClaimValueTypes.String, Issuer),
new Claim("id", Guid.NewGuid().ToString(), ClaimValueTypes.String)
};
var userIdentity = new ClaimsIdentity(claims, "Passport");
var userPrincipal = new ClaimsPrincipal(userIdentity);
await HttpContext.Authentication.SignInAsync("Cookie", userPrincipal,
new AuthenticationProperties
{
ExpiresUtc = DateTime.UtcNow.AddMinutes(20),
IsPersistent = true,
AllowRefresh = false
});
return(RedirectToAction("Index", "Project"));
}
Console.Write(response);
return(View());
}
public void CreateNewHearingRequest(TestContext testContext)
{
var requestBody = CreateHearingRequest.BuildRequest(testContext.TestUserSecrets.Individual, testContext.TestUserSecrets.Representative);
testContext.Request = testContext.Post("/hearings", requestBody);
testContext.Response = testContext.Client().Execute(testContext.Request);
testContext.Response.StatusCode.Should().Be(HttpStatusCode.Created);
var model = ApiRequestHelper.DeserialiseSnakeCaseJsonToResponse <HearingDetailsResponse>(testContext.Response.Content);
testContext.HearingId = model.Id.ToString();
var individual = model.Participants.Single(p => p.Username.Equals(testContext.TestUserSecrets.Individual));
testContext.IndividualParticipantId = individual.Id.ToString();
var representative = model.Participants.Single(p => p.Username.Equals(testContext.TestUserSecrets.Representative));
testContext.RepresentativeParticipantId = representative.Id.ToString();
}
public async Task <IActionResult> Detail([Bind("Id,name,image,free,description,duration,schoolId,categoriesId,views,order")] Services.ViewModel.CourseViewModel model, ICollection <IFormFile> files)
{
var uploads = Path.Combine(_environment.WebRootPath, "images/specialists");
if (files != null)
{
foreach (var file in files)
{
if (file.Length > 0)
{
var fileextension = Path.GetExtension(file.FileName);
var filename = Guid.NewGuid().ToString() + fileextension;
model.image = filename;
using (var fileStream = new FileStream(Path.Combine(uploads, filename), FileMode.Create))
{
await file.CopyToAsync(fileStream);
}
}
}
}
Infrastructure.ApiResponse <EscolaDeVoce.Services.ViewModel.CourseViewModel> response = null;
System.Net.Http.HttpMethod method = System.Net.Http.HttpMethod.Post;
string url = Helpers.EscolaDeVoceEndpoints.Courses.getCourses;
if (model.Id != Guid.Empty)
{
method = System.Net.Http.HttpMethod.Put;
url += "/" + model.Id.ToString();
}
response = await ApiRequestHelper.postPutRequest <Infrastructure.ApiResponse <EscolaDeVoce.Services.ViewModel.CourseViewModel> >(
url,
method,
JsonConvert.SerializeObject(model)
);
if (model.Id != Guid.Empty || (response.data != null && response.data.Id != Guid.Empty))
{
var Id = model.Id != Guid.Empty ? model.Id : response.data.Id;
return(RedirectToAction("Detail", new { id = Id.ToString() }));
}
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Detail([Bind("Id,name")] Services.ViewModel.ProjectViewModel model)
{
Infrastructure.ApiResponse <EscolaDeVoce.Services.ViewModel.ProjectViewModel> response = null;
System.Net.Http.HttpMethod method = System.Net.Http.HttpMethod.Post;
if (model.Id != Guid.Empty)
{
method = System.Net.Http.HttpMethod.Put;
}
response = await ApiRequestHelper.postPutRequest <Infrastructure.ApiResponse <EscolaDeVoce.Services.ViewModel.ProjectViewModel> >(
Helpers.EscolaDeVoceEndpoints.Project.getProjects + "/" + model.Id.ToString(),
method,
JsonConvert.SerializeObject(model)
);
return(View(response.data));
}
static void Main(string[] args)
{
ApiHelper.InitializeClient();
while (true)
{
Console.Clear();
Console.Write("Enter username: "******"Enter password: "******"\n\n\n");
string token = ApiResponseHelper.GetToken(loginResult);
JObject tokenResult = ApiRequestHelper.GetResultWithToken(token);
if (!ApiResponseHelper.IsRequestSucceeded(tokenResult))
{
Console.WriteLine("Token not valid.");
}
else
{
Console.WriteLine($"\n\n======================LOGIN SUCCEEDED======================\n\n");
Console.WriteLine($"Username : {username}");
Console.WriteLine($"\nMESSAGE : {ApiResponseHelper.GetMessage(tokenResult)}");
Console.WriteLine("\n\nPress ENTER to continue...");
}
}
else
{
Console.WriteLine("\n\nWrong username or password.");
Console.WriteLine("\nPress ENTER to try again...");
}
Console.ReadLine();
}
}
internal static async Task <ITunesSearchResult> Search(string keyword)
{
var parameter = HttpUtility.ParseQueryString("");
parameter["term"] = keyword;
parameter["country"] = CultureInfoHelper.CurrentRegionISO;
parameter["media"] = "podcast";
parameter["limit"] = "10";
try
{
var res = await ApiRequestHelper.HttpGet(queryUrl, parameter);
return(JsonConvert.DeserializeObject <ITunesSearchResult>(res));
}
catch (System.Exception)
{
return(null);
}
}
public static async Task <QQMusicSearchJson> SearchAsync(string keyword, int?page = 1, int?count = 10)
{
var queryString = HttpUtility.ParseQueryString(string.Empty);
queryString["format"] = "json";
queryString["aggr"] = "1";
queryString["lossless"] = "1";
queryString["cr"] = "1";
queryString["new_json"] = "1";
if (page.HasValue)
{
queryString["p"] = page.ToString();
}
else
{
queryString["p"] = "1";
}
if (count.HasValue)
{
queryString["n"] = count.ToString();
}
else
{
queryString["n"] = "10";
}
queryString["w"] = keyword;
var result = await ApiRequestHelper.HttpGet(url, queryString);
try
{
if (result != null)
{
return(JsonConvert.DeserializeObject <QQMusicSearchJson>(result));
}
return(null);
}
catch (JsonReaderException)
{
return(null);
}
}
public async Task Should_return_user_by_given_filter()
{
AzureAdGraphQueryResponse.Value.Add(new AzureAdGraphUserResponse()
{
ObjectId = "2"
});
SecureHttpRequest.Setup(x => x.GetAsync(It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync(ApiRequestHelper.CreateHttpResponseMessage(AzureAdGraphQueryResponse, HttpStatusCode.OK));
var response = await Service.GetUserByFilterAsync(Filter);
response.Should().NotBeNull();
response.Id.Should().Be(AzureAdGraphUserResponse.ObjectId);
response.DisplayName.Should().Be(AzureAdGraphUserResponse.DisplayName);
response.GivenName.Should().Be(AzureAdGraphUserResponse.GivenName);
response.Surname.Should().Be(AzureAdGraphUserResponse.Surname);
response.Mail.Should().BeNull();
response.UserPrincipalName.Should().Be(AzureAdGraphUserResponse.UserPrincipalName);
}
public async Task Refresh()
{
var resXML = await ApiRequestHelper.HttpGet(XMLUrl);
await ReadXML(resXML);
try
{
var folder = await ApplicationData.Current.LocalFolder.CreateFolderAsync("Podcasts", CreationCollisionOption.OpenIfExists);
var file = await folder.CreateFileAsync($"{XMLPath}.xml", CreationCollisionOption.OpenIfExists);
await FileIO.WriteTextAsync(file, resXML);
}
catch (Exception)
{
}
await SaveAsync();
}
