public MainPageViewModel(INavigationService navigationService)
{
this.navigationService = navigationService;
LoginCommand = new DelegateCommand(async() =>
{
Message = "";
string url = "https://contososyncfusion.azurewebsites.net/api/Login";
HttpClient client = new HttpClient();
LoginQueryString loginQueryString = new LoginQueryString()
{
Account = Account,
Password = Password,
};
string postPayload = JsonConvert.SerializeObject(loginQueryString);
HttpResponseMessage response = await client
.PostAsync(url, new StringContent(postPayload, Encoding.UTF8, "application/json"));
if (response.IsSuccessStatusCode == false)
{
Message = "登入驗證發生錯誤";
}
else
{
String strResult = await response.Content.ReadAsStringAsync();
StandardResponse <LoginData> standardResponse =
JsonConvert.DeserializeObject <StandardResponse <LoginData> >
(strResult, new JsonSerializerSettings {
MetadataPropertyHandling = MetadataPropertyHandling.Ignore
});
if (standardResponse.Success == true)
{
Message = "登入驗證程序成功";
File.WriteAllText(dataFile, postPayload);
}
else
{
Message = standardResponse.ErrorMessage;
}
}
});
#if DEBUG
//Account = "admin";
//Password = "******";
#endif
}
public void RaceControllerGetBets()
{
var _raceDBTest = new Mock <IRaceDBConnector>();
var _logHelperTest = new Mock <ILogger>().Object;
AutoMapperConfig.Initialize();
_raceDBTest.Setup(race => race.GetBets()).Returns(10);
var _raceHelperTest = new RaceHelper(_raceDBTest.Object, _logHelperTest);
RaceController raceController = new RaceController(_raceHelperTest, _logHelperTest);
StandardResponse response = raceController.GetBets("Ashwini");
var helperResponse = (TotalBets)response.Response;
Assert.AreEqual(helperResponse.TotalAmount, 10);
}
public void RaceControllerGetCustomers()
{
var _raceDBTest = new Mock <IRaceDBConnector>();
var _logHelperTest = new Mock <ILogger>().Object;
AutoMapperConfig.Initialize();
_raceDBTest.Setup(race => race.GetCustomer()).Returns(new List <SP_GetCustomerDetails_Result>());
var _raceHelperTest = new RaceHelper(_raceDBTest.Object, _logHelperTest);
RaceController raceController = new RaceController(_raceHelperTest, _logHelperTest);
StandardResponse response = raceController.GetCustomers("Ashwini");
var helperResponse = (List <Customer>)response.Response;
Assert.AreEqual(helperResponse.Count, 0);
}
public async Task <ActionResult <StandardResponse> > ExisteTarjeta(string codigo)
{
Tarjeta tarjeta = await _context.Tarjeta.Where(b => b.Numero == codigo).FirstOrDefaultAsync();
if (tarjeta == null)
{
return(NotFound());
}
else
{
StandardResponse standardResponse = new StandardResponse();
standardResponse.Code = 200;
standardResponse.Message = "Codigo Exitoso";
return(Ok(standardResponse));
}
}
public async Task <ActionResult <StandardResponse> > ConsultaLuz(string codigo)
{
ServicioLuz servicioLuz = await _context.ServicioLuz.Where(b => b.Correlativo == codigo).FirstOrDefaultAsync();
if (servicioLuz == null)
{
return(NotFound());
}
else
{
StandardResponse standardResponse = new StandardResponse();
standardResponse.Code = 200;
standardResponse.Message = "Servicio Existe";
standardResponse.data = "Saldo:" + servicioLuz.Saldo + ",cuentaBancaria:" + servicioLuz.CuentaBancariaId;
return(Ok(standardResponse));
}
}
public async Task <ActionResult <StandardResponse> > ConsultaTel(string numero)
{
ServicioTelefono servicioTelefono = await _context.ServicioTelefono.Where(b => b.Telefono == numero).FirstOrDefaultAsync();
if (servicioTelefono == null)
{
return(NotFound());
}
else
{
StandardResponse standardResponse = new StandardResponse();
standardResponse.Code = 200;
standardResponse.Message = "Servicio Existe";
standardResponse.data = "Saldo:" + servicioTelefono.Saldo + ",cuentaBancaria:" + servicioTelefono.CuentaBancariaId;
return(Ok(standardResponse));
}
}
public async Task <IActionResult> SDUpdate(SDRequest sDRequest)
{
if (sDRequest == null)
{
return(BadRequest());
}
await LongTaskSim.WaitFive();
var result = new StandardResponse()
{
status = "updated",
reference = sDRequest.supp_dec_number,
process_message = "Success"
};
return(Ok(result));
}
public async Task <ActionResult <StandardResponse> > CodigoTarjeta(string codigo, string pin)
{
Tarjeta tarjeta = await _context.Tarjeta.Where(b => (b.Numero == codigo && b.Pin == pin)).FirstOrDefaultAsync();
if (tarjeta == null)
{
return(NotFound());
}
else
{
StandardResponse standardResponse = new StandardResponse();
standardResponse.Code = 200;
standardResponse.Message = "Pin Exitoso";
standardResponse.data = tarjeta.TarjetaId.ToString();
return(Ok(standardResponse));
}
}
public async Task Then_The_StandardsFunding_Items_Are_Imported_From_The_Client(
StandardResponse apiResponse,
[Frozen] Mock <IApiClient> apiClient,
[Frozen] Mock <IProviderCommitmentsDbContext> context,
ImportStandardsJob importStandardsJob
)
{
//Arrange
apiClient.Setup(x => x.Get <StandardResponse>(It.IsAny <GetStandardsRequest>())).ReturnsAsync(apiResponse);
var importedStandardFunding = new List <FundingPeriodItem>();
context.Setup(d => d.ExecuteSqlCommandAsync("EXEC ImportStandardsFunding @standardsFunding", It.IsAny <SqlParameter>()))
.Returns(Task.CompletedTask)
.Callback <string, object[]>((s, p) =>
{
var sqlParameter = (SqlParameter)p[0];
var dataTable = (DataTable)sqlParameter.Value;
importedStandardFunding.AddRange(dataTable.AsEnumerable().Select(r => new FundingPeriodItem
{
StandardId = (int)r[0],
FundingCap = (int)r[1],
EffectiveFrom = (DateTime?)r[2],
EffectiveTo = (DateTime?)r[3],
}));
});
//Act
await importStandardsJob.Import(null);
//Assert
var expectedItems = new List <FundingPeriodItem>();
foreach (var responseStandard in apiResponse.Standards)
{
var standardId = responseStandard.Id;
expectedItems.AddRange(responseStandard.FundingPeriods.Select(fundingPeriod => new FundingPeriodItem
{
StandardId = standardId,
EffectiveFrom = fundingPeriod.EffectiveFrom,
EffectiveTo = fundingPeriod.EffectiveTo,
FundingCap = fundingPeriod.FundingCap
}));
}
importedStandardFunding.Should().BeEquivalentTo(expectedItems);
}
protected override async Task <StandardResponseBase> GetResponseAsync(StandardRequestBase standardRequest)
{
var standardResponse = new StandardResponse
{
Premium = 8394.00m,
PremiumTRIA = 755.00m,
Limit = 2000000.00m,
SurplusLinesTax = 411.96m,
StampingFee = 12.74m,
AgencyFee = 100.00m,
Details = @"The tax calculation rates and percentages are for informational purposes only.
We are not responsible for accurate and timely tax filings unless otherwise mutually agreed
to in writing between both parties. Certain ploicies may be subject to an additional $250 inspection fee.",
};
return(await Task.FromResult(standardResponse));
}
/* AddLine API
* Simple Adding of a line with mandatory tags *
* ##Values in the method are hardcoded please modify accordingly to make it work###
*/
private static void callAddLine(AXLAPIService axlApiService)
{
AddLineReq addLineReq = new AddLineReq();
addLineReq.line = new XLine();
addLineReq.line.pattern = "9999";
addLineReq.line.description = "Adding a line from .NetClient";
addLineReq.line.usage = "Device";
XFkType xfktype = new XFkType();
//routepartion value
xfktype.Value = "";
addLineReq.line.routePartitionName = xfktype;
StandardResponse res2 = axlApiService.addLine(addLineReq);
Console.WriteLine("Successfully added an Line using of AddLineRequest" + res2.@return);
}
public async Task <StandardResponse> GetAnswer(ClaimsPrincipal identity, GetAnswerViewModel model, ModelStateDictionary modelState)
{
if (!modelState.IsValid)
{
return(modelState.StandardError());
}
using (var db = new ServiceDb())
{
using (var user = await _userService.Become(db, identity, null))
{
var answer = await _answerService.GetAnswer(db, user, model.Id);
return(StandardResponse.For(AnswerViewModel.From(answer)));
}
}
}
public static StandardResponse <T> GenerateStandardError <T>(this T self, string format, params object[] formatParameters)
{
var standardError = new StandardError();
if (!string.IsNullOrWhiteSpace(format))
{
standardError.Errors.Add(string.Format(format, formatParameters));
}
var response = new StandardResponse <T>
{
StandardError = standardError,
Response = self
};
return(response);
}
public async Task <StandardResponse> DeleteAnswer(ClaimsPrincipal identity, DeleteAnswerViewModel model, ModelStateDictionary modelState)
{
if (!modelState.IsValid)
{
return(modelState.StandardError());
}
using (var t = new ServiceDb().WithTransaction())
{
using (var user = await _userService.Become(t.Db, identity, null))
{
await _purgeService.PurgeExistingAnswer(t.Db, user, model.Id, new BackupConfig());
return(StandardResponse.ForSuccess());
}
}
}
public async Task <StandardResponse> FindAnswers(ClaimsPrincipal identity, SearchAnswersViewModel model, ModelStateDictionary modelState)
{
if (!modelState.IsValid)
{
return(modelState.StandardError());
}
using (var db = new ServiceDb())
{
using (var user = await _userService.Become(db, identity, null))
{
var matches = await _searchService.FindAnswersForQuestion(db, user, model.QuestionId, model.Offset, model.Limit);
return(StandardResponse.For(matches));
}
}
}
public async Task <StandardResponse> GetQuestionMetadata(ClaimsPrincipal identity, GetQuestionViewModel model, ModelStateDictionary modelState)
{
if (!modelState.IsValid)
{
return(modelState.StandardError());
}
using (var db = new ServiceDb())
{
using (var user = await _userService.Become(db, identity, null))
{
var meta = await _questionService.GetQuestionMetadata(db, user, model.Id);
return(StandardResponse.For(QuestionMetaViewModel.From(meta)));
}
}
}
public async Task <StandardResponse> FindQuestions(ClaimsPrincipal identity, PerformSearchViewModel model, ModelStateDictionary modelState)
{
if (!modelState.IsValid)
{
return(modelState.StandardError());
}
using (var db = new ServiceDb())
{
using (var user = await _userService.Become(db, identity, null))
{
var result = await _searchService.SearchForQuestions(db, user, model.Query, model.Offset, model.Limit);
return(StandardResponse.For(result));
}
}
}
public static StandardResponse <T> GenerateStandardError <T>(this T self, ICollection <string> errors)
{
var standardError = new StandardError();
if (errors != null && errors.Any())
{
standardError.Errors.AddRange(errors);
}
var response = new StandardResponse <T>
{
StandardError = standardError,
Response = self
};
return(response);
}
/* Add Phone API
* Associating a line with the phone.
* ( mandatory tags only used to add a phone)
* ##Values in the method are hardcoded please modify accordingly to make it work###
*/
private static void callAddPhone(AXLAPIService axlApiService)
{
AddPhoneReq addPhoneReq = new AddPhoneReq();
addPhoneReq.phone = new XPhone();
addPhoneReq.phone.name = "SEP170000100002";
addPhoneReq.phone.description = "Adding Phone thru .Net Client";
addPhoneReq.phone.product = "Cisco 7960";
addPhoneReq.phone.@class = "Phone";
addPhoneReq.phone.protocol = "SCCP";
addPhoneReq.phone.protocolSide = "User";
XFkType xfktype = new XFkType();
xfktype.Value = "Default";
addPhoneReq.phone.devicePoolName = xfktype;
xfktype = new XFkType();
xfktype.Value = "Standard Common Phone Profile";
addPhoneReq.phone.commonPhoneConfigName = xfktype;
xfktype = new XFkType();
xfktype.Value = "Hub_None";
addPhoneReq.phone.locationName = xfktype;
addPhoneReq.phone.useTrustedRelayPoint = "Default";
addPhoneReq.phone.lines = new XPhoneLines();
addPhoneReq.phone.lines.Items = new XPhoneLine[1];
XPhoneLine line = new XPhoneLine();
line.index = "5";
line.display = "Line1";
//existing directory number
line.dirn = new XDirn();
line.dirn.pattern = "11233";
xfktype = new XFkType();
xfktype.Value = "AXL-RP";
line.dirn.routePartitionName = xfktype;
addPhoneReq.phone.lines.Items.SetValue(line, 0);
StandardResponse res2 = axlApiService.addPhone(addPhoneReq);
Console.WriteLine("end of the addPhoneReq" + res2.@return);
}
public void Download_Error_JsonResponse()
{
var downloadUri = "http://www.sample.com";
var chunkSize = 100;
var error = new RequestError {
Code = 12345, Message = "Text", Errors = new[] { new SingleError {
Message = "Nested error"
} }
};
var response = new StandardResponse <object> {
Error = error
};
var responseText = new NewtonsoftJsonSerializer().Serialize(response);
var handler = new MultipleChunksMessageHandler {
ErrorResponse = responseText
};
handler.StatusCode = HttpStatusCode.BadRequest;
handler.ChunkSize = chunkSize;
// The media downloader adds the parameter...
handler.DownloadUri = new Uri(downloadUri + "?alt=media");
using (var service = CreateMockClientService(handler))
{
var downloader = new MediaDownloader(service);
downloader.ChunkSize = chunkSize;
IList <IDownloadProgress> progressList = new List <IDownloadProgress>();
downloader.ProgressChanged += (p) =>
{
progressList.Add(p);
};
var outputStream = new MemoryStream();
downloader.Download(downloadUri, outputStream);
var lastProgress = progressList.LastOrDefault();
Assert.That(lastProgress.Status, Is.EqualTo(DownloadStatus.Failed));
GoogleApiException exception = (GoogleApiException)lastProgress.Exception;
Assert.That(exception.HttpStatusCode, Is.EqualTo(handler.StatusCode));
// Just a smattering of checks - if these two pass, it's surely okay.
Assert.That(exception.Error.Code, Is.EqualTo(error.Code));
Assert.That(exception.Error.Errors[0].Message, Is.EqualTo(error.Errors[0].Message));
}
}
/*
* A simple AddEndUser request with only mandatory tags
* ##Values in the method are hardcoded please modify accordingly to make it work##
*/
private static void callAddEndUser(AXLAPIService axlApiService)
{
AddUserReq addUserReq = new AddUserReq();
addUserReq.user = new XUser();
addUserReq.user.userid = "DotNetuser";
addUserReq.user.lastName = "Visual Studio";
XFkType xfktype = new XFkType();
//presenceGroup Name value
xfktype.Value = "Standard Presence group";
//Or the UUID
//xfktype.uuid=""
addUserReq.user.presenceGroupName = xfktype;
StandardResponse res2 = axlApiService.addUser(addUserReq);
Console.WriteLine("Successfully added an User using AddEndUserRequest" + res2.@return);
}
private static bool GeneratePinProcessRun(IPinGeneratorService pinGenerator, ICustomerDetails customerDetails)
{
StandardResponse <string> response = pinGenerator.GeneratePin(customerDetails);
if (response.Success)
{
Console.WriteLine($"Successfully created pin: {response.Result}");
return(true);
}
Console.WriteLine("Pin failed to generate. Please see below for more details");
foreach (var errorMessage in response.ErrorMessages)
{
Console.WriteLine(errorMessage);
}
return(false);
}
/*Associating user to a group
*
* ##Values in the method are hardcoded please modify accordingly to make it work###
*/
private static void callAddUserGroup(AXLAPIService axlApiService)
{
AddUserGroupReq request = new AddUserGroupReq();
request.userGroup = new XUserGroup();
request.userGroup.name = "NET Group";
request.userGroup.members = new XUserGroupMembers();
XUserGroupMember xMember = new XUserGroupMember();
request.userGroup.members.member = new XUserGroupMember[1];
xMember.userId = "DotNetuser";
request.userGroup.members.member.SetValue(xMember, 0);
StandardResponse response = axlApiService.addUserGroup(request);
Console.WriteLine("Response of callAddUserGroup" + response.@return);
}
internal static async Task <bool> IsRetriableResponse(HttpResponseMessage response)
{
StandardResponse <object> errorResponse = null;
try
{
var str = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
errorResponse = NewtonsoftJsonSerializer.Instance.Deserialize <StandardResponse <object> >(str);
var errors = errorResponse.Error?.Errors;
// If we couldn't deserialize properly, or the result doesn't contain any reasons, we won't retry.
return(errors?.All(singleError => s_retriableErrors.Contains(singleError.Reason)) ?? false);
}
catch (Exception)
{
return(false);
}
}
public async Task <StandardResponse> Login(HttpContext httpContext, LoginViewModel model, ModelStateDictionary modelState)
{
if (!modelState.IsValid)
{
return(modelState.StandardError());
}
var authContext = new ServiceIdentityList.ServiceAuthContext();
var isValid = await TryAuthorize(model.Username, model.Password, httpContext, authContext);
if (!isValid)
{
throw new Exception($"Invalid login attempt for {model.Username}");
}
await _auth.SignInAsync(httpContext, model.Username, authContext.ClaimsForUser);
return(StandardResponse.ForSuccess());
}
public async Task <StandardResponse> DeleteTopic(ClaimsPrincipal identity, TopicDeleteViewModel model, ModelStateDictionary modelState)
{
if (!modelState.IsValid)
{
return(modelState.StandardError());
}
using (var db = new ServiceDb())
{
using (var user = await _userService.Become(db, identity))
{
await _topicService.DeleteTopic(db, user, model.TopicId, model.RowVersion);
await db.SaveChangesAsync();
return(StandardResponse.ForSuccess());
}
}
}
private string SerializeJson <T>(int idSource, Func <T, bool> predicate = null) where T : class, new()
{
if (predicate == null)
{
predicate = (x) => true;
}
List <T> ds = new List <T>();
if (_dataSource.ContainsKey(idSource))
{
ds = _dataSource[idSource].OfType <T>().Where(predicate).ToList();
}
var response = new StandardResponse <IEnumerable <T> >()
{
Data = ds
};
return(response.GetJson());
}
public async Task <StandardResponse> GetTopic(ClaimsPrincipal identity, TopicGetViewModel model, ModelStateDictionary modelState)
{
if (!modelState.IsValid)
{
return(modelState.StandardError());
}
using (var db = new ServiceDb())
{
using (var user = await _userService.Become(db, identity))
{
var result = !string.IsNullOrWhiteSpace(model.TopicName)
? await _topicService.RequireTopic(db, user, model.TopicName)
: await _topicService.GetTopic(db, user, model.TopicId);
return(StandardResponse.For(new TopicViewModel(result)));
}
}
}
/*API to addMembers in add operation
*
* Simple AddCallerFilterReq request with mandatory tags
* ##Values in the method are hardcoded please modify accordingly to make it work###
*/
private static void callAddCallerFilterReq(AXLAPIService axlApiService)
{
AddCallerFilterListReq ucflr = new AddCallerFilterListReq();
ucflr.callerFilterList = new XCallerFilterList();
ucflr.callerFilterList.name = "Sriram2";
ucflr.callerFilterList.description = "testing NET Application1";
ucflr.callerFilterList.isAllowedType = "true";
XCallerFilterListMember xmember1 = new XCallerFilterListMember();
ucflr.callerFilterList.members = new XCallerFilterListMembers();
ucflr.callerFilterList.members.member = new XCallerFilterListMember[1];
xmember1.callerFilterMask = "Directory Number";
xmember1.DnMask = "663636";
ucflr.callerFilterList.members.member.SetValue(xmember1, 0);
StandardResponse res2 = axlApiService.addCallerFilterList(ucflr);
Console.WriteLine("end of the callAddCallerFilterReq" + res2.@return);
}
/// <summary>
/// Async Method to consume the PetAPI
/// returns a list of PetOwners with their registered pets
/// </summary>
/// <returns>List<PetOwners></PetOwners></returns>
public async Task <StandardResponse <List <PetOwner> > > GetPetOwnersAsync()
{
var stdResponse = new StandardResponse <List <PetOwner> >();
try
{
var baseUrl = _repoConfig.Url;
_logger.LogDebug($"Path for the WebAPI is {baseUrl}");
//Set the baseUrl here to allow for changes in the middle of execution
_httpClient.BaseAddress = new Uri(baseUrl);
_httpClient.DefaultRequestHeaders.Accept.Clear();
_httpClient.DefaultRequestHeaders.Accept.Add(
new MediaTypeWithQualityHeaderValue("application/json"));
HttpResponseMessage response = await _httpClient.GetAsync(baseUrl);
_logger.LogDebug($"Http Response Code is {response.StatusCode}");
if (response.IsSuccessStatusCode)
{
var result = await response.Content.ReadAsStringAsync();
if (!result.IsNullOrEmpty())
{
//NOTE: Talk to business about considering caching of the results using Polly.Cache
var petOwnersList = JsonConvert.DeserializeObject <List <PetOwner> >(result);
_logger.LogDebug($"Http Request resulted with {petOwnersList.Count} owners");
stdResponse.Success = true;
stdResponse.Result = petOwnersList;
}
}
else
{
throw new Exception($"Error occured with response code - {response.StatusCode}");
}
}
catch (Exception ex)
{
stdResponse = StandardResponse <List <PetOwner> > .GenericError(ex.Message);
}
return(stdResponse);
}
/// <summary>
/// Run a simple HTTP server that listens for a few test URIs.
/// The server exits when a client requests "/Quit".
/// </summary>
/// <param name="prefix">Prefix at which the server should listen</param>
private async Task RunTestServer(string prefix)
{
using (var httpListener = new HttpListener())
{
httpListener.Prefixes.Add(prefix);
httpListener.Start();
while (httpListener.IsListening)
{
var context = await httpListener.GetContextAsync();
var requestUri = context.Request.Url;
var response = context.Response;
if (requestUri.AbsolutePath.EndsWith("/Quit"))
{
// Shut down the HTTP server.
response.Close();
httpListener.Stop();
continue;
}
// All downloader requests should include ?alt=media.
Assert.AreEqual("media", context.Request.QueryString["alt"]);
response.ContentType = "text/plain";
response.SendChunked = true; // Avoid having to set Content-Length.
Stream outStream = new MemoryStream();
if (requestUri.AbsolutePath.EndsWith("/EchoUrl"))
{
// Return the URL that we saw.
byte[] uriBytes = Encoding.UTF8.GetBytes(requestUri.AbsoluteUri);
outStream.Write(uriBytes, 0, uriBytes.Length);
}
else if (requestUri.AbsolutePath.EndsWith("/BadRequestJson"))
{
// Return 400 with a JSON-encoded error.
var apiResponse = new StandardResponse<object> { Error = BadRequestError };
var apiResponseText = new NewtonsoftJsonSerializer().Serialize(apiResponse);
byte[] apiResponseBytes = Encoding.UTF8.GetBytes(apiResponseText);
response.StatusCode = (int)HttpStatusCode.BadRequest;
outStream.Write(apiResponseBytes, 0, apiResponseBytes.Length);
}
else if (requestUri.AbsolutePath.EndsWith("/NotFoundPlainText"))
{
// Return 404 with a plaintext error.
response.StatusCode = (int)HttpStatusCode.NotFound;
byte[] errorBytes = Encoding.UTF8.GetBytes(NotFoundError);
outStream.Write(errorBytes, 0, errorBytes.Length);
}
else if (requestUri.AbsolutePath.EndsWith("/GzipContent"))
{
// Return gzip-compressed content.
using (var gzipStream = new GZipStream(outStream, CompressionMode.Compress, true))
{
gzipStream.Write(MediaContent, 0, MediaContent.Length);
}
response.AddHeader("Content-Encoding", "gzip");
}
else
{
// Return plaintext content.
outStream.Write(MediaContent, 0, MediaContent.Length);
}
outStream.Position = 0;
// Provide rudimentary, non-robust support for Range.
// MediaDownloader doesn't exercise this code anymore, but it was useful for
// testing previous implementations that did. It remains for posterity.
string rangeHeader = context.Request.Headers["Range"];
if (rangeHeader != null && response.StatusCode == (int)HttpStatusCode.OK)
{
var range = RangeHeaderValue.Parse(rangeHeader);
var firstRange = range.Ranges.First();
long from = firstRange.From ?? 0;
long to = Math.Min(outStream.Length - 1, firstRange.To ?? long.MaxValue);
var contentRangeHeader = new ContentRangeHeaderValue(from, to, outStream.Length);
response.AddHeader("Content-Range", contentRangeHeader.ToString());
outStream.Position = from;
outStream.SetLength(to + 1);
}
await outStream.CopyToAsync(response.OutputStream);
response.Close();
}
}
}
public void Download_Error_JsonResponse()
{
var downloadUri = "http://www.sample.com";
var chunkSize = 100;
var error = new RequestError { Code = 12345, Message = "Text", Errors = new[] { new SingleError { Message = "Nested error" } } };
var response = new StandardResponse<object> { Error = error };
var responseText = new NewtonsoftJsonSerializer().Serialize(response);
var handler = new MultipleChunksMessageHandler { ErrorResponse = responseText };
handler.StatusCode = HttpStatusCode.BadRequest;
handler.ChunkSize = chunkSize;
// The media downloader adds the parameter...
handler.DownloadUri = new Uri(downloadUri + "?alt=media");
using (var service = CreateMockClientService(handler))
{
var downloader = new MediaDownloader(service);
downloader.ChunkSize = chunkSize;
IList<IDownloadProgress> progressList = new List<IDownloadProgress>();
downloader.ProgressChanged += (p) =>
{
progressList.Add(p);
};
var outputStream = new MemoryStream();
downloader.Download(downloadUri, outputStream);
var lastProgress = progressList.LastOrDefault();
Assert.That(lastProgress.Status, Is.EqualTo(DownloadStatus.Failed));
GoogleApiException exception = (GoogleApiException) lastProgress.Exception;
Assert.That(exception.HttpStatusCode, Is.EqualTo(handler.StatusCode));
// Just a smattering of checks - if these two pass, it's surely okay.
Assert.That(exception.Error.Code, Is.EqualTo(error.Code));
Assert.That(exception.Error.Errors[0].Message, Is.EqualTo(error.Errors[0].Message));
}
}
