public async Task Serialize_WithErrorsAsync() { var command = new MockCommand(this.user, MockPayload.Instance); var result1 = command.CreateResult(); result1.Errors = new List <CommandError> { await CreateFlurlHttpExceptionAsync().ConfigureAwait(false), new NotSupportedException() }; var json1 = TeamCloudSerialize.SerializeObject(result1); Assert.NotEmpty(json1); Assert.Contains("$type", json1); var result2 = TeamCloudSerialize.DeserializeObject <ICommandResult>(json1); var json2 = TeamCloudSerialize.SerializeObject(result2); Assert.NotEmpty(json2); Assert.Contains("$type", json2); Assert.Equal(json1, json2); }
public void DeserializeRepository() { var repositoryReference = new RepositoryReference() { Url = "https://github.com/foo/bar.git", Provider = RepositoryProvider.GitHub, Type = RepositoryReferenceType.Unknown }; var projectTemplate = new ProjectTemplate() { Id = Guid.NewGuid().ToString(), Organization = Guid.NewGuid().ToString(), Repository = repositoryReference }; var componentPath = "/foo/bar/component.yaml"; var componentJson = GetComponentDefinitionAsJson("repository"); var componentTemplate = TeamCloudSerialize .DeserializeObject <ComponentTemplate>(componentJson, new ComponentTemplateConverter(projectTemplate, componentPath)); Assert.NotNull(componentTemplate); Assert.IsAssignableFrom <ComponentRepositoryTemplate>(componentTemplate); Assert.NotNull(componentTemplate.Configuration); Assert.IsAssignableFrom <ComponentRepositoryConfiguration>(componentTemplate.Configuration); }
internal async Task <ProjectTemplate> UpdateProjectTemplateAsync(ProjectTemplate projectTemplate) { if (projectTemplate is null) { throw new ArgumentNullException(nameof(projectTemplate)); } var repository = projectTemplate.Repository; if (!string.IsNullOrEmpty(repository.Token)) { client.Credentials = new Credentials(repository.Token); } var projectYamlFiles = await client.Repository.Content .GetAllContents(repository.Organization, repository.Repository, Constants.ProjectYaml) .ConfigureAwait(false); var projectYamlFile = projectYamlFiles.First(); var projectYaml = projectYamlFile.Content; var projectJson = new Deserializer().ToJson(projectYaml); projectTemplate = TeamCloudSerialize.DeserializeObject <ProjectTemplate>(projectJson, new ProjectTemplateConverter(projectTemplate, projectYamlFile.Url)); var result = await client.Git.Tree .GetRecursive(repository.Organization, repository.Repository, repository.Ref) .ConfigureAwait(false); projectTemplate.Description = await CheckAndPopulateFileContentAsync(repository, result.Tree, projectTemplate.Description) .ConfigureAwait(false); return(projectTemplate); }
public void DeserializeProject() { var repositoryReference = new RepositoryReference() { Url = "https://github.com/foo/bar.git", Provider = RepositoryProvider.GitHub, Type = RepositoryReferenceType.Unknown }; var projectTemplate = new ProjectTemplate() { Id = Guid.NewGuid().ToString(), Organization = Guid.NewGuid().ToString(), DisplayName = "Foo", Repository = repositoryReference }; var porjectPath = "/foo/bar/project.yaml"; var projectJson = GetProjectDefinitionAsJson("project"); var projectTemplate2 = TeamCloudSerialize .DeserializeObject <ProjectTemplate>(projectJson, new ProjectTemplateConverter(projectTemplate, porjectPath)); Assert.NotNull(projectTemplate2); Assert.IsAssignableFrom <ProjectTemplate>(projectTemplate2); }
protected ErrorResultException(SerializationInfo info, StreamingContext context) : base(info, context) { var errorResultJson = info.GetString(nameof(ErrorResult)); if (!string.IsNullOrWhiteSpace(errorResultJson)) { ErrorResult = TeamCloudSerialize.DeserializeObject(errorResultJson) as IErrorResult; } }
public void Serialize() { var command = new MockCommand(this.user, MockPayload.Instance); var json = TeamCloudSerialize.SerializeObject(command); Assert.NotEmpty(json); Assert.Contains("$type", json); var resultObj = TeamCloudSerialize.DeserializeObject <ICommand>(json); Assert.IsType <MockCommand>(resultObj); }
public void LinksMaterializedOnDeserializedInstances() { Assert.NotNull(ReferenceLink.BaseUrl); var mockOwnerJson = TeamCloudSerialize.SerializeObject(new MockOwner()); var mockOwner = TeamCloudSerialize.DeserializeObject <MockOwner>(mockOwnerJson); var mockOwnerId = mockOwner.Id; mockOwner.Id = Guid.NewGuid(); // this must not affect the self link Assert.StartsWith(ReferenceLink.BaseUrl, mockOwner.Links.Self.ToString()); Assert.EndsWith(mockOwnerId.ToString(), mockOwner.Links.Self.ToString()); }
public virtual object Clone(bool reset) { var json = TeamCloudSerialize .SerializeObject(this); var clone = (ContainerDocument)TeamCloudSerialize .DeserializeObject(json, GetType()); if (reset) { clone.Id = Guid.NewGuid().ToString(); } return(clone); }
public async Task Dequeue( [QueueTrigger(CommandHandler.ProcessorQueue)] QueueMessage commandMessage, [Queue(CommandHandler.ProcessorQueue)] IAsyncCollector <ICommand> commandQueue, [Queue(CommandHandler.MonitorQueue)] IAsyncCollector <string> commandMonitor, [DurableClient] IDurableClient durableClient, ILogger log) { if (commandMessage is null) { throw new ArgumentNullException(nameof(commandMessage)); } if (commandQueue is null) { throw new ArgumentNullException(nameof(commandQueue)); } if (commandMonitor is null) { throw new ArgumentNullException(nameof(commandMonitor)); } if (durableClient is null) { throw new ArgumentNullException(nameof(durableClient)); } if (log is null) { throw new ArgumentNullException(nameof(log)); } try { var command = TeamCloudSerialize.DeserializeObject <ICommand>(commandMessage.Body.ToString()); command.Validate(validatorProvider, throwOnValidationError: true); _ = await ProcessCommandAsync(durableClient, command, commandQueue, commandMonitor, log) .ConfigureAwait(false); } catch (Exception exc) { log.LogError(exc, $"Failed to process queued command: {exc.Message}"); throw; } }
private static async Task <ComponentTemplate> ResolveComponentTemplateAsync(ProjectTemplate projectTemplate, RepositoryReference repository, GitHttpClient client, GitTreeRef tree, GitTreeEntryRef treeItem) { var componentYamlFile = await client .GetItemAsync(project : repository.Project, repository.Repository, treeItem.RelativePath, download : true, versionDescriptor : repository.VersionDescriptor()) .ConfigureAwait(false); var componentYaml = componentYamlFile.Content; var componentJson = new Deserializer().ToJson(componentYaml); var componentTemplate = TeamCloudSerialize.DeserializeObject <ComponentTemplate>(componentJson, new ComponentTemplateConverter(projectTemplate, componentYamlFile.Path)); var folder = treeItem.RelativePath.Split(Constants.ComponentYaml).First().TrimEnd('/'); componentTemplate.Description = await CheckAndPopulateFileContentAsync(client, repository, tree.TreeEntries, componentTemplate.Description, folder) .ConfigureAwait(false); return(componentTemplate); }
private async Task <ComponentTemplate> ResolveComponentTemplateAsync(ProjectTemplate projectTemplate, RepositoryReference repository, TreeResponse tree, TreeItem treeItem) { var componentYamlFiles = await client.Repository.Content .GetAllContents(repository.Organization, repository.Repository, treeItem.Path) .ConfigureAwait(false); var componentYamlFile = componentYamlFiles.First(); var componentYaml = componentYamlFile.Content; var componentJson = new Deserializer().ToJson(componentYaml); var componentTemplate = TeamCloudSerialize.DeserializeObject <ComponentTemplate>(componentJson, new ComponentTemplateConverter(projectTemplate, treeItem.Url)); componentTemplate.Folder = Regex.Replace(treeItem.Path, $"/{Constants.ComponentYaml}$", string.Empty, RegexOptions.IgnoreCase); componentTemplate.Description = await CheckAndPopulateFileContentAsync(repository, tree.Tree, componentTemplate.Description, componentTemplate.Folder).ConfigureAwait(false); return(componentTemplate); }
public void DeSerialize_NameValueCollection() { var nvc = new NameValueCollection(); for (int i = 1; i <= 10; i++) nvc.Add("foo", $"bar{i}"); var json = TeamCloudSerialize.SerializeObject(nvc); for (int i = 1; i <= 10; i++) Assert.Contains($"bar{i}", json); var nvc2 = TeamCloudSerialize.DeserializeObject<NameValueCollection>(json); for (int i = 1; i <= 10; i++) Assert.Contains($"bar{i}", nvc2.GetValues("foo")); }
public async Task <T> SetSecretAsync <T>(string secretName, T secretValue) where T : class, new() { if (secretValue is null) { await SetSecretAsync(secretName, null) .ConfigureAwait(false); return(secretValue); } else { var secretJson = await SetSecretAsync(secretName, TeamCloudSerialize.SerializeObject(secretValue)) .ConfigureAwait(false); return(TeamCloudSerialize.DeserializeObject <T>(secretJson)); } }
static async Task <string> ReadContentAsync(HttpContent httpContent) { if ((httpContent?.Headers.ContentLength.GetValueOrDefault(0) ?? 0) == 0) { return(string.Empty); } var content = await httpContent .ReadAsStringAsync() .ConfigureAwait(false); //TODO: why ist this here needed if (httpContent.Headers.ContentType.MediaType.Equals("application/json", StringComparison.OrdinalIgnoreCase)) { var jsonContent = TeamCloudSerialize.DeserializeObject(content); return(TeamCloudSerialize.SerializeObject(jsonContent, Formatting.Indented)); } return(content); }
private void AssertException(Exception serializableException, bool serializableExpected = true) { Assert.Equal(serializableExpected, serializableException.IsSerializable(out _)); string serializableExceptionJson; try { serializableExceptionJson = TeamCloudSerialize.SerializeObject(serializableException, Formatting.Indented); } catch { serializableExceptionJson = default; } if (serializableExpected) { Assert.NotNull(serializableExceptionJson); } if (!string.IsNullOrEmpty(serializableExceptionJson)) { Exception deserializedException; try { deserializedException = (Exception)TeamCloudSerialize.DeserializeObject(serializableExceptionJson, serializableException.GetType()); } catch when(!serializableExpected) { deserializedException = default; } if (serializableExpected) { Assert.NotNull(deserializedException); } } }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { var componentJson = JObject.ReadFrom(reader) as JObject; foreach (var nameToken in componentJson.SelectTokens("$..name").Reverse().ToArray()) { // (nameToken.Parent.Parent as JObject)?.SetProperty("title", nameToken.ToString()); (nameToken.Parent.Parent as JObject)?.SetProperty("displayName", nameToken.ToString()); nameToken.Parent.Remove(); // get rid of the name token as we don't need it anymore } // augment the component json by some project template level data componentJson.SetProperty(nameof(ComponentTemplate.Id), repositoryLocation.ToGuid().ToString()); componentJson.SetProperty(nameof(ComponentTemplate.ParentId), projectTemplate.Id); componentJson.SetProperty(nameof(ComponentTemplate.Organization), projectTemplate.Organization); componentJson.SetProperty(nameof(ComponentTemplate.OrganizationName), projectTemplate.OrganizationName); componentJson.SetProperty(nameof(ComponentTemplate.Repository), repositoryReference); var inputJsonSchemaToken = GenerateInputJsonSchema(componentJson, serializer); componentJson.SetProperty(nameof(ComponentTemplate.InputJsonSchema), inputJsonSchemaToken); var permissionDictionaryToken = GeneratePermissionDictionary(componentJson, serializer); componentJson.SetProperty(nameof(ComponentTemplate.Permissions), permissionDictionaryToken); var componentType = Enum.Parse <ComponentType>(componentJson.GetValue("type", StringComparison.OrdinalIgnoreCase)?.ToString(), true) switch { ComponentType.Environment => typeof(ComponentEnvironmentTemplate), ComponentType.Repository => typeof(ComponentRepositoryTemplate), _ => typeof(ComponentTemplate) }; return(TeamCloudSerialize.DeserializeObject(componentJson.ToString(), componentType)); } }
public void Deserialize_Success(string json) { var data = TeamCloudSerialize.DeserializeObject <KubernetesData>(json); data.Validate(validatorProvider, throwOnValidationError: true, throwOnNoValidatorFound: true); }
async Task <IActionResult> IAdapterAuthorize.HandleAuthorizeAsync(DeploymentScope deploymentScope, HttpRequest request, IAuthorizationEndpoints authorizationEndpoints) { if (deploymentScope is null) { throw new ArgumentNullException(nameof(deploymentScope)); } if (request is null) { throw new ArgumentNullException(nameof(request)); } if (authorizationEndpoints is null) { throw new ArgumentNullException(nameof(authorizationEndpoints)); } var queryParams = Url.ParseQueryParams(request.QueryString.ToString()); var queryState = queryParams.GetValueOrDefault("state"); var queryCode = queryParams.GetValueOrDefault("code"); var queryError = queryParams.GetValueOrDefault("error"); var session = await SessionClient .GetAsync <GitHubSession>(deploymentScope) .ConfigureAwait(false); session ??= await SessionClient .SetAsync(new GitHubSession(deploymentScope)) .ConfigureAwait(false); var data = string.IsNullOrWhiteSpace(deploymentScope.InputData) ? default : TeamCloudSerialize.DeserializeObject <GitHubData>(deploymentScope.InputData); var token = await TokenClient .GetAsync <GitHubToken>(deploymentScope) .ConfigureAwait(false); if (string.IsNullOrEmpty(queryError) && Guid.TryParse(queryState, out var stateId)) { if (!stateId.ToString().Equals(session.SessionId, StringComparison.OrdinalIgnoreCase)) { return(new RedirectResult(authorizationEndpoints.AuthorizationUrl.SetQueryParam("error", "Session timed out.").ToString())); } else if (string.IsNullOrWhiteSpace(queryCode)) { return(new RedirectResult(authorizationEndpoints.AuthorizationUrl.SetQueryParam("error", "Missing GitHub handshake information.").ToString())); } token ??= new GitHubToken(deploymentScope); // Using Flurl as Octokit doesn't support this API yet // https://github.com/octokit/octokit.net/issues/2138 var url = $"https://api.github.com/app-manifests/{queryCode}/conversions"; var response = await url .WithHeader("User-Agent", GitHubConstants.ProductHeader.ToString()) .PostStringAsync(string.Empty) .ConfigureAwait(false); if (!response.IsSuccessStatusCode()) { return(new RedirectResult(authorizationEndpoints.AuthorizationUrl.SetQueryParam("error", $"Failed to get application token ({response.StatusCode} - {response.ResponseMessage.ReasonPhrase}).").ToString())); } var json = await response .GetStringAsync() .ConfigureAwait(false); TeamCloudSerialize.PopulateObject(json, token); if (string.IsNullOrEmpty(token.OwnerLogin)) { token.OwnerLogin = JToken.Parse(json) .SelectToken("owner.login") .ToString(); } token = await TokenClient .SetAsync(token, true) .ConfigureAwait(false); return(new ContentResult { StatusCode = (int)HttpStatusCode.OK, ContentType = "text/html", Content = Assembly.GetExecutingAssembly().GetManifestResourceTemplate($"{GetType().FullName}_Install.html", GetFormContext()) }); } else { return(new ContentResult { StatusCode = (int)HttpStatusCode.OK, ContentType = "text/html", Content = Assembly.GetExecutingAssembly().GetManifestResourceTemplate($"{GetType().FullName}_Register.html", GetFormContext()) }); } object GetFormContext() => new { deploymentScope = deploymentScope, authorizationEndpoints = authorizationEndpoints, token = token, data = data, session = session, error = queryError ?? string.Empty, succeeded = queryParams.Contains("succeeded") }; }
private KubernetesData GetKubernetesData(DeploymentScope deploymentScope) => TeamCloudSerialize.DeserializeObject <KubernetesData>(deploymentScope.InputData);