public async Task CanUpdateCategory()
{
var count = categories.Count;
var id = categories[count - 1].Id ?? null;
var category = new CategoryDto()
{
Title = "Updated Title", Description = "Updated Description"
};
var response = await client.PutAsync(@$ "/api/categories/{id}", HttpClientUtils.CreateContent(category));
Assert.AreEqual(HttpStatusCode.NoContent, response.StatusCode);
response = await client.GetAsync(@$ "/api/categories/{id}");
var updatedCategory = await response.Content.ReadFromJsonAsync <CategoryDto>();
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.AreEqual("Updated Title", updatedCategory.Title);
Assert.AreEqual("Updated Description", updatedCategory.Description);
}
public async Task It_supports_odata_attribute_routing()
{
using (WebApp.Start(HttpClientUtils.BaseAddress, appBuilder => Configuration(appBuilder, typeof(AccountsController)))) {
// Arrange
var httpClient = HttpClientUtils.GetHttpClient(HttpClientUtils.BaseAddress);
// Act
var swaggerDocument = await httpClient.GetJsonAsync <SwaggerDocument>("swagger/docs/v1");
// Assert
PathItem pathItem;
swaggerDocument.paths.TryGetValue("/odata/Accounts({accountId})/PayinPIs({paymentInstrumentId})", out pathItem);
pathItem.Should().NotBeNull();
pathItem.get.Should().NotBeNull();
pathItem.get.produces.Should().NotBeNull();
pathItem.get.produces.Count.Should().Be(1);
pathItem.get.produces.First().Should().Be("application/json");
await ValidationUtils.ValidateSwaggerJson();
}
}
public R Post <T, R>(string aiRessource, T aiRequestBody)
{
R obj = default(R);
using (MemoryStream ms = new MemoryStream())
{
SerializationContainer.JsonSerializer.WriteObject(ms, aiRequestBody); byte[] requestInJson = ms.ToArray();
HttpCompletionOption option = HttpCompletionOption.ResponseContentRead;
HttpRequestMessage request = AddBasicAuthentication(HttpClientUtils.CreateBlankRequestMessage(HttpMethod.Post, aiRessource).AddContentToRequest(aiRequestBody));
Task <HttpResponseMessage> response = _httpClient.SendAsync(request, option);
HttpResponseMessage message = response.Result;
string contentForDebug = message.Content.ReadAsStringAsync().Result;//Save content temporarly for messaging-process.
message.EnsureSuccessStatusCode();
if (message.Content != null)
{
var result = message.Content.ReadAsStreamAsync();
obj = SerializationContainer.JsonSerializer.ReadObject <R>(result.Result);
}
}
return(obj);
}
private async void IsUpdate(bool isIos, string version, bool expected)
{
string content = GetTestJson(JSON_VERSION1);
var jsonContent = new StringContent(
content,
Encoding.UTF8,
"application/json"
);
var client = HttpClientUtils.CreateHttpClient(HttpStatusCode.OK, jsonContent);
_mockClientService.Setup(x => x.Create()).Returns(client);
_mockEssentialsService.Setup(x => x.IsIos).Returns(isIos);
_mockEssentialsService.Setup(x => x.AppVersion).Returns(version);
ICheckVersionService service = CreateService();
bool isUpdated = await service.IsUpdateVersionExistAsync();
Assert.Equal(expected, isUpdated);
}
public async Task GetExposureConfigurationTest_updated_but_not_cache_expired()
{
var date = Date;
string testJson1 = GetTestJson(JSON_EXPOSURE_CONFIGURATION1);
using (var writer = File.CreateText(CURRENT_EXPOSURE_CONFIGURATION_FILE_PATH))
{
await writer.WriteAsync(testJson1);
}
ExposureConfiguration result1 = JsonConvert.DeserializeObject <ExposureConfiguration>(testJson1);
string testJson2 = GetTestJson(JSON_EXPOSURE_CONFIGURATION2);
var jsonContent = new StringContent(
testJson2,
Encoding.UTF8,
"application/json"
);
var client = HttpClientUtils.CreateHttpClient(HttpStatusCode.OK, jsonContent);
mockClientService.Setup(x => x.Create()).Returns(client);
mockLocalPathService.Setup(x => x.ExposureConfigurationDirPath).Returns("./");
mockLocalPathService.Setup(x => x.CurrentExposureConfigurationPath).Returns(CURRENT_EXPOSURE_CONFIGURATION_FILE_PATH);
mockServerConfigurationRepository.Setup(x => x.ExposureConfigurationUrl).Returns("https://example.com/exposure_configuration.json");
mockDateTimeUtility.Setup(x => x.UtcNow).Returns(date);
mockPreferencesService.Setup(x => x.GetValue(PreferenceKey.ExposureConfigurationDownloadedEpoch, It.IsAny <long>())).Returns(date.ToUnixEpoch());
mockPreferencesService.Setup(x => x.GetValue(PreferenceKey.IsDiagnosisKeysDataMappingConfigurationUpdated, false)).Returns(false);
var unitUnderTest = CreateRepository();
var result2 = await unitUnderTest.GetExposureConfigurationAsync();
mockPreferencesService.Verify(s => s.SetValue(PreferenceKey.ExposureConfigurationDownloadedEpoch, date.ToUnixEpoch()), Times.Never());
mockPreferencesService.Verify(s => s.SetValue(PreferenceKey.ExposureConfigurationAppliedEpoch, date.ToUnixEpoch()), Times.Never());
mockPreferencesService.Verify(s => s.SetValue(PreferenceKey.IsDiagnosisKeysDataMappingConfigurationUpdated, true), Times.Never());
Assert.Equal(result1, result2);
}
public async Task GetExposureRiskConfigurationTest_not_updated()
{
string currentConfigurationJson = GetTestJson(JSON_EXPOSURE_RISK_CONFIGURATION1);
File.WriteAllText(CURRENT_EXPOSURE_RISK_CONFIGURATION_FILE_PATH, currentConfigurationJson);
V1ExposureRiskCalculationConfiguration currentConfiguration
= JsonConvert.DeserializeObject <V1ExposureRiskCalculationConfiguration>(currentConfigurationJson);
string newConfigurationJson = GetTestJson(JSON_EXPOSURE_RISK_CONFIGURATION2);
V1ExposureRiskCalculationConfiguration newConfiguration
= JsonConvert.DeserializeObject <V1ExposureRiskCalculationConfiguration>(newConfigurationJson);
var jsonContent = new StringContent(
newConfigurationJson,
Encoding.UTF8,
"application/json"
);
var client = HttpClientUtils.CreateHttpClient(HttpStatusCode.OK, jsonContent);
mockClientService.Setup(x => x.Create()).Returns(client);
mockLocalPathService.Setup(x => x.ExposureConfigurationDirPath).Returns("./");
mockLocalPathService.Setup(x => x.CurrentExposureRiskCalculationConfigurationPath).Returns(CURRENT_EXPOSURE_RISK_CONFIGURATION_FILE_PATH);
mockServerConfigurationRepository.Setup(x => x.ExposureRiskCalculationConfigurationUrl).Returns("https://example.com/exposure_risk_configuration.json");
var unitUnderTest = CreateRepository();
var result = await unitUnderTest.GetExposureRiskCalculationConfigurationAsync(preferCache : false);
result = await unitUnderTest.GetExposureRiskCalculationConfigurationAsync(preferCache : false);
mockServerConfigurationRepository.Verify(s => s.LoadAsync(), Times.Exactly(2));
mockLoggerService.Verify(x => x.Info("ExposureRiskCalculationConfiguration have not been changed.", It.IsAny <string>(), It.IsAny <string>(), It.IsAny <int>()), Times.Once);
Assert.NotNull(result);
Assert.NotEqual(result, currentConfiguration);
Assert.Equal(result, newConfiguration);
}
public async Task GetExposureConfigurationTest_firsttime()
{
var date = Date;
string content = GetTestJson(JSON_EXPOSURE_CONFIGURATION1);
var jsonContent = new StringContent(
content,
Encoding.UTF8,
"application/json"
);
var client = HttpClientUtils.CreateHttpClient(HttpStatusCode.OK, jsonContent);
mockClientService.Setup(x => x.Create()).Returns(client);
mockLocalPathService.Setup(x => x.ExposureConfigurationDirPath).Returns("./");
mockLocalPathService.Setup(x => x.CurrentExposureConfigurationPath).Returns(CURRENT_EXPOSURE_CONFIGURATION_FILE_PATH);
mockServerConfigurationRepository.Setup(x => x.ExposureConfigurationUrl).Returns("https://example.com/exposure_configuration.json");
mockDateTimeUtility.Setup(x => x.UtcNow).Returns(date);
var unitUnderTest = CreateRepository();
var result = await unitUnderTest.GetExposureConfigurationAsync();
mockServerConfigurationRepository.Verify(s => s.LoadAsync(), Times.Once());
mockPreferencesService.Verify(s => s.SetValue(PreferenceKey.ExposureConfigurationDownloadedEpoch, date.ToUnixEpoch()), Times.AtLeastOnce());
mockPreferencesService.Verify(s => s.SetValue(PreferenceKey.IsDiagnosisKeysDataMappingConfigurationUpdated, true), Times.AtLeastOnce());
Assert.NotNull(result);
Assert.NotNull(result.GoogleExposureConfig);
Assert.NotNull(result.AppleExposureConfigV1);
// Google ExposureWindow mode
Assert.NotNull(result.GoogleDailySummariesConfig);
Assert.NotNull(result.GoogleDiagnosisKeysDataMappingConfig);
// Apple ENv2
Assert.NotNull(result.AppleExposureConfigV2);
}
private async Task RefreshToken()
{
Logger.LogInformation("Refresh token");
var res = await _httpClient.PostAsync(TokenAuthUrl,
HttpClientUtils.BuildFormParams(
new KeyValuePair <string, string>("grant_type", "refresh_token"),
new KeyValuePair <string, string>("refresh_token", _spotifyVault.AccessToken.RefreshToken),
new KeyValuePair <string, string>("client_id", Config.ClientSecret.ClientId),
new KeyValuePair <string, string>("client_secret", Config.ClientSecret.ClientSecret)));
var st = await res.Content.ReadAsStringAsync();
var newToken = st.FromJson <OAuthTokenResult>();
_spotifyVault.AccessToken.AccessToken = newToken.AccessToken;
_spotifyVault.AccessToken.ExpireOn = DateTime.Now.AddSeconds(newToken.ExpiresIn);
SaveVault(_spotifyVault);
Logger.LogInformation($"Token refresh expire on: {_spotifyVault.AccessToken.ExpireOn}");
InitSpotifyClient();
}
public async Task Initialize()
{
factory = new CustomWebApplicationFactory <Startup>();
client = factory.CreateClient(new WebApplicationFactoryClientOptions
{
BaseAddress = new Uri(BaseURL)
});
var loginRequest = new Login.Request()
{
Email = UserEmail, Password = Password
};
var response = await client.PostAsync("/api/auth/login", HttpClientUtils.CreateContent(loginRequest));
var data = await response.Content.ReadFromJsonAsync <AuthData>();
clientUser = factory.CreateClient(new WebApplicationFactoryClientOptions
{
BaseAddress = new Uri(BaseURL)
});
clientUser.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", data.Token);
}
public async Task <ObservableCollection <FamousPerson> > FindAllAsync()
{
#region 测试
using (var httpClient = new HttpClient())
{
try
{
var response = await httpClient.GetAsync(FIND_URL);
if (response.IsSuccessStatusCode)
{
var result = await response.Content.ReadAsAsync <ObservableCollection <Fhr.ModernHistory.Models.FamousPerson> >();
var result2 = await response.Content.ReadAsAsync <ObservableCollection <FamousPerson> >();
}
else
{
var apiErrorModel = await response.Content.ReadAsAsync <ApiErrorModel>();
throw new ApiErrorException(apiErrorModel);
}
}
catch (Exception e)
{
var apiErrorModel = new ApiErrorModel()
{
StatusCode = HttpStatusCode.NotFound,
Message = "网络连接错误",
Code = 3
};
throw new ApiErrorException(apiErrorModel);
}
}
#endregion
return(await HttpClientUtils.GetAsync <ObservableCollection <FamousPerson> >(FIND_URL));
}
public async Task <PersonEventRelation> SaveAsync(PersonEventRelation personEventRelation)
{
return(await HttpClientUtils.PostJsonAsync <PersonEventRelation, PersonEventRelation>(SAVE_URL, personEventRelation));
}
public async Task UpdateAsync(PersonEventRelation personEventRelation)
{
var address = string.Format("{0}/{1}", UPDATE_URL, personEventRelation.PersonEventRelationId);
await HttpClientUtils.PostJsonNoReturnAsync <PersonEventRelation>(address, personEventRelation);
}
public async Task <ObservableCollection <PersonEventRelation> > FindAllAsync()
{
return(await HttpClientUtils.GetAsync <ObservableCollection <PersonEventRelation> >(FIND_URL));
}
public async Task PullMaterialAsync(string accessTokenOrAppId, MaterialType materialType, int groupId)
{
var count = await MediaApi.GetMediaCountAsync(accessTokenOrAppId);
if (materialType == MaterialType.Message)
{
if (count.news_count > 0)
{
var newsList = await MediaApi.GetNewsMediaListAsync(accessTokenOrAppId, 0, count.news_count);
newsList.item.Reverse();
foreach (var message in newsList.item)
{
if (await _materialMessageRepository.IsExistsAsync(message.media_id))
{
continue;
}
//var news = await MediaApi.GetForeverNewsAsync(accessTokenOrAppId, message.media_id);
var messageItems = new List <MaterialMessageItem>();
foreach (var item in message.content.news_item)
{
var imageUrl = string.Empty;
if (!string.IsNullOrEmpty(item.thumb_media_id) && !string.IsNullOrEmpty(item.thumb_url))
{
await using var ms = new MemoryStream();
await MediaApi.GetForeverMediaAsync(accessTokenOrAppId, item.thumb_media_id, ms);
ms.Seek(0, SeekOrigin.Begin);
var extName = "png";
if (StringUtils.Contains(item.thumb_url, "wx_fmt="))
{
extName = item.thumb_url.Substring(item.thumb_url.LastIndexOf("=", StringComparison.Ordinal) + 1);
}
var materialFileName = PathUtils.GetMaterialFileNameByExtName(extName);
var virtualDirectoryPath = PathUtils.GetMaterialVirtualDirectoryPath(UploadType.Image);
var directoryPath = PathUtils.Combine(_settingsManager.WebRootPath, virtualDirectoryPath);
var filePath = PathUtils.Combine(directoryPath, materialFileName);
await FileUtils.WriteStreamAsync(filePath, ms);
imageUrl = PageUtils.Combine(virtualDirectoryPath, materialFileName);
}
else if (!string.IsNullOrEmpty(item.thumb_url))
{
var extName = "png";
if (StringUtils.Contains(item.thumb_url, "wx_fmt="))
{
extName = item.thumb_url.Substring(item.thumb_url.LastIndexOf("=", StringComparison.Ordinal) + 1);
}
var materialFileName = PathUtils.GetMaterialFileNameByExtName(extName);
var virtualDirectoryPath = PathUtils.GetMaterialVirtualDirectoryPath(UploadType.Image);
var directoryPath = PathUtils.Combine(_settingsManager.WebRootPath, virtualDirectoryPath);
var filePath = PathUtils.Combine(directoryPath, materialFileName);
await HttpClientUtils.DownloadAsync(item.thumb_url, filePath);
imageUrl = PageUtils.Combine(virtualDirectoryPath, materialFileName);
}
var commentType = CommentType.Block;
if (item.need_open_comment == 1)
{
commentType = item.only_fans_can_comment == 1 ? CommentType.OnlyFans : CommentType.Everyone;
}
messageItems.Add(new MaterialMessageItem
{
MessageId = 0,
MaterialType = MaterialType.Article,
MaterialId = 0,
Taxis = 0,
ThumbMediaId = item.thumb_media_id,
Author = item.author,
Title = item.title,
ContentSourceUrl = item.content_source_url,
Content = await SaveImagesAsync(item.content),
Digest = item.digest,
ShowCoverPic = item.show_cover_pic == "1",
ThumbUrl = imageUrl,
Url = item.url,
CommentType = commentType
});
}
await _materialMessageRepository.InsertAsync(groupId, message.media_id, messageItems);
}
}
}
else if (materialType == MaterialType.Image)
{
if (count.image_count > 0)
{
var list = await MediaApi.GetOthersMediaListAsync(accessTokenOrAppId, UploadMediaFileType.image, 0, count.image_count);
foreach (var image in list.item)
{
if (await _materialImageRepository.IsExistsAsync(image.media_id))
{
continue;
}
await using var ms = new MemoryStream();
await MediaApi.GetForeverMediaAsync(accessTokenOrAppId, image.media_id, ms);
ms.Seek(0, SeekOrigin.Begin);
var extName = image.url.Substring(image.url.LastIndexOf("=", StringComparison.Ordinal) + 1);
var materialFileName = PathUtils.GetMaterialFileNameByExtName(extName);
var virtualDirectoryPath = PathUtils.GetMaterialVirtualDirectoryPath(UploadType.Image);
var directoryPath = PathUtils.Combine(_settingsManager.WebRootPath, virtualDirectoryPath);
var filePath = PathUtils.Combine(directoryPath, materialFileName);
await FileUtils.WriteStreamAsync(filePath, ms);
var material = new MaterialImage
{
GroupId = groupId,
Title = image.name,
Url = PageUtils.Combine(virtualDirectoryPath, materialFileName),
MediaId = image.media_id
};
await _materialImageRepository.InsertAsync(material);
}
}
}
else if (materialType == MaterialType.Audio)
{
if (count.voice_count > 0)
{
var list = await MediaApi.GetOthersMediaListAsync(accessTokenOrAppId, UploadMediaFileType.voice, 0, count.voice_count);
foreach (var voice in list.item)
{
if (await _materialAudioRepository.IsExistsAsync(voice.media_id))
{
continue;
}
await using var ms = new MemoryStream();
await MediaApi.GetForeverMediaAsync(accessTokenOrAppId, voice.media_id, ms);
ms.Seek(0, SeekOrigin.Begin);
var extName = voice.url.Substring(voice.url.LastIndexOf("=", StringComparison.Ordinal) + 1);
var materialFileName = PathUtils.GetMaterialFileNameByExtName(extName);
var virtualDirectoryPath = PathUtils.GetMaterialVirtualDirectoryPath(UploadType.Audio);
var directoryPath = PathUtils.Combine(_settingsManager.WebRootPath, virtualDirectoryPath);
var filePath = PathUtils.Combine(directoryPath, materialFileName);
await FileUtils.WriteStreamAsync(filePath, ms);
var audio = new MaterialAudio
{
GroupId = groupId,
Title = voice.name,
FileType = extName.ToUpper().Replace(".", string.Empty),
Url = PageUtils.Combine(virtualDirectoryPath, materialFileName),
MediaId = voice.media_id
};
await _materialAudioRepository.InsertAsync(audio);
}
}
}
else if (materialType == MaterialType.Video)
{
if (count.video_count > 0)
{
var list = await MediaApi.GetOthersMediaListAsync(accessTokenOrAppId, UploadMediaFileType.video, 0, count.video_count);
foreach (var video in list.item)
{
if (await _materialVideoRepository.IsExistsAsync(video.media_id))
{
continue;
}
await using var ms = new MemoryStream();
await MediaApi.GetForeverMediaAsync(accessTokenOrAppId, video.media_id, ms);
ms.Seek(0, SeekOrigin.Begin);
var extName = "mp4";
if (!string.IsNullOrEmpty(video.url))
{
extName = video.url.Substring(video.url.LastIndexOf("=", StringComparison.Ordinal) + 1);
}
var materialFileName = PathUtils.GetMaterialFileNameByExtName(extName);
var virtualDirectoryPath = PathUtils.GetMaterialVirtualDirectoryPath(UploadType.Video);
var directoryPath = PathUtils.Combine(_settingsManager.WebRootPath, virtualDirectoryPath);
var filePath = PathUtils.Combine(directoryPath, materialFileName);
await FileUtils.WriteStreamAsync(filePath, ms);
var material = new MaterialVideo
{
GroupId = groupId,
Title = video.name,
FileType = extName.ToUpper().Replace(".", string.Empty),
Url = PageUtils.Combine(virtualDirectoryPath, materialFileName),
MediaId = video.media_id
};
await _materialVideoRepository.InsertAsync(material);
}
}
}
}
private T RunRequest <T, Model>(string api, HttpMethodType method, HttpContent content = null) where T : IResponseBase <Model> where Model : class
{
var result = Activator.CreateInstance <T>();
try
{
using (var client = new HttpClient())
{
client.SetBasicAuthentication(GetAPIKey(_site), DEFAULT_PASSWORD);
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var uri = new UriBuilder(new Uri(new Uri(GetEndpoint(_site)), api));
HttpResponseMessage httpResponse;
switch (method)
{
case HttpMethodType.Get:
httpResponse = client.GetAsync(uri.Uri).Result;
break;
case HttpMethodType.Post:
if (content != null)
{
httpResponse = client.PostAsync(uri.Uri, content).Result;
}
else
{
//todo: create ChargifyException
throw new Exception("POST HTTP Content header is missing.");
}
break;
case HttpMethodType.Put:
if (content != null)
{
httpResponse = client.PutAsync(uri.Uri, content).Result;
}
else
{
//todo: create ChargifyException
throw new Exception("PUT HTTP Content header is missing.");
}
break;
case HttpMethodType.Delete:
httpResponse = client.DeleteAsync(uri.Uri).Result;
break;
default:
//todo: create ChargifyException
throw new Exception("Invalid Http method");
}
var response = HttpClientUtils.ParseResponse <Model>(httpResponse);
result.IsError = response.IsError;
result.Message = response.Message;
result.Model = response.Model;
}
}
catch (Exception ex)
{
//todo: logger
result.IsError = true;
result.Message = ex.Message;
throw;
}
return(result);
}
/// <summary>
/// 等待JenkinsBuildTask并返回任务结果
/// </summary>
/// <param name="appName">应用名称</param>
/// <param name="environment">所属环境</param>
/// <param name="logDirName">日志输出文件夹名</param>
/// <returns>Tuple bool--是否编译成功, string--成功则为任务id 则是异常信息或空, string--编译的SVN的版本 </returns>
private static Tuple <bool, string, string> WaitJkbtAndGetResult(string appName, string environment,
string logDirName)
{
var jkbtId = "";
try
{
//第一步：检查Jenkins的任务队列是否有等待执行的任务，没人排队任务则继续第二步
var jenkinsQueueUrl = GetJenkinsConfig("JenkinsQueueApiUrl", "");
LogInfoWriter.GetInstance(logDirName).Info($"start check jenkins build task queue is empty, JenkinsQueueApiUrl:{jenkinsQueueUrl}");
var isJkQueueEmpty = ExecExtensions.RetryUntilTrueWithTimeout(() =>
{
var queueInfo = HttpClientUtils.GetJson(jenkinsQueueUrl);
var queueInfoJObj = JObject.Parse(queueInfo);
Console.WriteLine("jenkins build task queue is not empty");
return(!queueInfoJObj["items"].Values <JObject>().Any());
}, ConfigManager.GetConfigObject("JenkinsQueueCheckTimeout", 5) * OneMinute);
if (!isJkQueueEmpty)
{
throw new Exception("wait jenkins build task finish error; ErrorMsg:check wether jenkins build task queue is empty timout");
}
LogInfoWriter.GetInstance(logDirName).Info("check jenkins build task queue is empty end");
//第二步：获取Jenkins的编译任务Id
var getJkbtNumberUrl = GetJenkinsConfig("JenkinsGetBuildTaskIdApiUrl", "");
getJkbtNumberUrl = String.Format(getJkbtNumberUrl, appName, environment);
LogInfoWriter.GetInstance(logDirName).Info($"start get jenkins build task id, JenkinsGetBuildTaskIdApiUrl:{getJkbtNumberUrl}");
var jkbtNumberInfo = HttpClientUtils.Get(getJkbtNumberUrl);
jkbtId = GetJenkinsXmlValue(jkbtNumberInfo);
if (String.IsNullOrWhiteSpace(jkbtId))
{
throw new Exception("get jenkins build task id error,the jenkins build task id is null or empty!");
}
LogInfoWriter.GetInstance(logDirName).Info($"get jenkins build task id:{jkbtId} end");
//第三步：根据Jenkins的编译任务Id获取其执行结果
var getJkbtResultUrl = GetJenkinsConfig("JenkinsGetBuildTaskResultApiUrl", "");
getJkbtResultUrl = String.Format(getJkbtResultUrl, appName, environment, jkbtId);
LogInfoWriter.GetInstance(logDirName).Info($"start get jenkins build task:{jkbtId} result, JenkinsGetBuildTaskResultApiUrl:{getJkbtResultUrl}");
var isJkbtFinish = ExecExtensions.RetryUntilTrueWithTimeout(() =>
{
if (String.Equals(JkbtResultSuccess, HttpClientUtils.Get(getJkbtResultUrl),
StringComparison.OrdinalIgnoreCase))
{
return(ExecExtensions.ResultType.Success);
}
if (String.Equals(JkbtResultFailure, HttpClientUtils.Get(getJkbtResultUrl),
StringComparison.OrdinalIgnoreCase))
{
return(ExecExtensions.ResultType.Failure);
}
return(ExecExtensions.ResultType.Continue);
}, ConfigManager.GetConfigObject("JenkinsGetBuildTaskResultTimeout", 10) * OneMinute);
LogInfoWriter.GetInstance(logDirName).Info($"get jenkins build task:{jkbtId} result end");
//第四步：根据Jenkins编译任务结果返回最终结果
switch (isJkbtFinish)
{
case ExecExtensions.ResultType.Success:
var getJkbtSvnNumberUrl = GetJenkinsConfig("JenkinsGetBuildTaskSvnNumberUrl", "");
getJkbtSvnNumberUrl = String.Format(getJkbtSvnNumberUrl, appName, environment, jkbtId);
LogInfoWriter.GetInstance(logDirName).Info($"start get jenkins build task:{jkbtId} svn number,JenkinsGetBuildTaskSvnNumberUrl:{getJkbtSvnNumberUrl}");
var jkbtSvnNumberInfo = HttpClientUtils.Get(getJkbtSvnNumberUrl);
var jkbtSvnNumber = GetJenkinsXmlValue(jkbtSvnNumberInfo);
if (String.IsNullOrWhiteSpace(jkbtSvnNumber))
{
throw new Exception("$the jenkins build task:{jkbtId} svn number is null or empty!");
}
return(Tuple.Create(true, jkbtId, jkbtSvnNumber));
case ExecExtensions.ResultType.Failure:
return(Tuple.Create(false, jkbtId, "jenkins build task failure"));
case ExecExtensions.ResultType.Timeout:
return(Tuple.Create(false, jkbtId, "jenkins build task timeout"));
}
}
catch (Exception ex)
{
return(Tuple.Create(false, jkbtId, ex.ToString()));
}
return(Tuple.Create(false, jkbtId, "unknow error"));
}
public async Task <ObservableCollection <FamousPersonType> > FindAllAsync()
{
return(await HttpClientUtils.GetAsync <ObservableCollection <FamousPersonType> >(FIND_URL));
}
public async Task DeleteAsync(int id)
{
var address = string.Format("{0}/{1}", DELETE_URL, id);
await HttpClientUtils.PostAsync(address);
}
public async Task UpdateAsync(FamousPerson famousePerson)
{
var address = string.Format("{0}/{1}", UPDATE_URL, famousePerson.FamousPersonId);
await HttpClientUtils.PostJsonNoReturnAsync <FamousPerson>(address, famousePerson);
}
public async Task <Image> DownLoadEventImgAsync(int eventId)
{
string address = string.Format("{0}\\{1}", WEBAPI_BASE_EVENT_PICURE, eventId);
return(await HttpClientUtils.DownLoadImage(address));
}
public async Task <Image> DownLoadPersonImgAsync(int personId)
{
string address = string.Format("{0}\\{1}", WEBAPI_BASE_PERSON_PICURE, personId);
return(await HttpClientUtils.DownLoadImage(address));
}
public async Task <ObservableCollection <HistoryEvent> > SearchAsync(EventSearchModel searchModel)
{
return(await HttpClientUtils.PostJsonAsync <EventSearchModel, ObservableCollection <HistoryEvent> >(SEARCH_URL, searchModel));
}
public async Task UploadPersonImgAsync(int personId, string pictureName)
{
var address = string.Format("{0}/{1}/", UPLOAD_PERSON_IMG_URL, personId);
await HttpClientUtils.UploadFileAsync(address, pictureName);
}
/// <summary>
/// 提交内容到远程服务器, 并返回回应的内容
/// </summary>
protected Task <string> HttpInvokeAsync(HttpMethod method, string endpoint, object body)
{
var host = Parameters["Host"];
return(HttpClientUtils.HttpInvokeAsync(host, method, endpoint, body));
}
public async Task <FamousPerson> FindByIdAsync(int id)
{
var address = string.Format("{0}/{1}", FIND_URL, id);
return(await HttpClientUtils.GetAsync <FamousPerson>(address));
}
public async Task UploadEventImgAsync(int eventId, string pictureName)
{
var address = string.Format("{0}/{1}/", UPLOAD_EVENT_IMG_URL, eventId);
await HttpClientUtils.UploadFileAsync(address, pictureName);
}
public async Task <FamousPerson> SaveAsync(FamousPerson famousePerson)
{
return(await HttpClientUtils.PostJsonAsync <FamousPerson, FamousPerson>(SAVE_URL, famousePerson));
}
public async Task <ObservableCollection <HistoryEventType> > FindAllAsync()
{
return(await HttpClientUtils.GetAsync <ObservableCollection <HistoryEventType> >(FIND_URL));
}
public async Task <ObservableCollection <FamousPerson> > SearchAsync(PersonSearchModel searchModel)
{
return(await HttpClientUtils.PostJsonAsync <PersonSearchModel, ObservableCollection <FamousPerson> >(SEARCH_URL, searchModel));
}
public async Task <HistoryEventType> FindByIdAsync(int id)
{
var address = string.Format("{0}/{1}", FIND_URL, id);
return(await HttpClientUtils.GetAsync <HistoryEventType>(address));
}
