public async Task <Contentful.Core.Models.Entry <dynamic> > GetItemFromMgmtAPI(string id) { // note: consider moving mgmt actions into a new repository so we can // avoid giving all requests the mgmt keys & to avoid XxxFromMgmtXxx style _logger.LogTrace($"GetItemFromMgmtAPI({id})"); if (string.IsNullOrWhiteSpace(id)) { throw new ArgumentException("Missing required parameter", nameof(id)); } var managementClient = new ContentfulManagementClient(_httpClient, _options); Contentful.Core.Models.Entry <dynamic> mgmtEntry = null; try { mgmtEntry = await managementClient.GetEntry(id); } catch (Contentful.Core.Errors.ContentfulException ex) { var msg = "Error getting entry from mgmt api: " + ex; _logger.LogError(msg); throw new ContentException(msg, ex); } catch (Exception ex) { var msg = "Unable to get entry from mgmt api: " + ex; _logger.LogError(msg); throw new ProcessException(msg, ex); } return(mgmtEntry); }
public async Task <Entry <dynamic> > UpdateEntry(dynamic entry) { _logger.LogTrace($"ContentfulContentRepository.UpdateEntry({entry})"); if (entry == null) { throw new ArgumentException("Missing required parameter", nameof(entry)); } try { var managementClient = new ContentfulManagementClient(_httpClient, _options); return(await managementClient.CreateOrUpdateEntry(entry, null, null, entry.SystemProperties.Version)); } catch (Contentful.Core.Errors.ContentfulException ex) { var msg = "Error updating entry: " + ex; _logger.LogError(msg); throw new ContentException(msg, ex); } catch (Exception ex) { var msg = "Unable to update entry: " + ex; _logger.LogError(msg); throw new ProcessException(msg, ex); } }
public async Task <Contentful.Core.Models.Management.Snapshot> GetLastSnapshot(string id) { _logger.LogTrace($"ContentfulContentRepository.GetLastSnapshot({id})"); if (string.IsNullOrWhiteSpace(id)) { throw new ArgumentException("Missing required parameter", nameof(id)); } try { var managementClient = new ContentfulManagementClient(_httpClient, _options); var snapshots = await managementClient.GetAllSnapshotsForEntry(id); return(snapshots.FirstOrDefault()); } catch (Contentful.Core.Errors.ContentfulException ex) { var msg = "Error creating environment: " + ex; _logger.LogError(msg); throw new ContentException(msg, ex); } catch (Exception ex) { var msg = "Unable to create environment: " + ex; _logger.LogError(msg); throw new ProcessException(msg, ex); } }
public async Task <Contentful.Core.Models.Management.ContentfulEnvironment> CreateEnvironment(string id, string name) { _logger.LogTrace($"ContentfulContentRepository.CreateEnvironment({id}, {name})"); if (string.IsNullOrWhiteSpace(name)) { throw new ArgumentException("Missing required parameter", nameof(name)); } try { var managementClient = new ContentfulManagementClient(_httpClient, _options); var env = await managementClient.CreateOrUpdateEnvironment(id, name); return(env); } catch (Contentful.Core.Errors.ContentfulException ex) { var msg = "Error creating environment: " + ex; _logger.LogError(msg); throw new ContentException(msg, ex); } catch (Exception ex) { var msg = "Unable to create environment: " + ex; _logger.LogError(msg); throw new ProcessException(msg, ex); } }
public async Task <ActionResult> UserAdd(string username, string password, Array City) { HttpClient httpClient = new HttpClient(); var client = new ContentfulManagementClient(httpClient, "CFPAT-0188062dc4d4c5bdc61c744ffae9f600e56164b944e1a6c8d422ad1a0257525d", "bda2gc49gm0w"); var entry = new Entry <dynamic>(); entry.SystemProperties = new SystemProperties(); entry.SystemProperties.Id = Guid.NewGuid().ToString(); entry.Fields = new { username = new Dictionary <string, string>() { { "en-US", username } }, password = new Dictionary <string, string>() { { "en-US", password } }, allCity = new Dictionary <string, Array>() { { "en-US", City } } }; await client.CreateOrUpdateEntry(entry, contentTypeId : "users"); await client.PublishEntry(entry.SystemProperties.Id, 1); return(View("Index")); }
public Client(string AuthToken, string Space) { this.AuthToken = AuthToken; this.Space = Space; var httpClient = new HttpClient(); _apiClient = new ContentfulManagementClient(httpClient, AuthToken, Space); }
public async Task <IEnumerable <VisualSpace> > GetSpaces(string key) { var ctfClient = new ContentfulManagementClient(_httpClient, new ContentfulOptions { ManagementApiKey = key }); var ctfSpaces = await ctfClient.GetSpaces(); return(ctfSpaces.Select(VisualSpaceFactory.CreateSpace)); }
public async Task <IEnumerable <VisualTypeGroup> > GetTypes(string key, string spaceId, string groupNameSeparator) { var ctfClient = new ContentfulManagementClient(_httpClient, new ContentfulOptions { ManagementApiKey = key, SpaceId = spaceId }); var ctfTypes = (await ctfClient.GetContentTypes()).OrderBy(c => c.Name).ToList(); return(GroupTypes(ctfTypes.Select(VisualTypeFactory.CreateType), groupNameSeparator)); }
/// <summary> /// Publishes the content items referenced by the project. /// </summary> /// <param name="slug">The slug identifying the project</param> /// <returns></returns> public async Task <List <string> > PublishProject(string slug) { _logger.LogTrace($"ContentfulContentRepository.PublishProject({slug})"); if (string.IsNullOrWhiteSpace(slug)) { throw new ArgumentException("Missing required parameter", nameof(slug)); } try { var cful = new ContentfulClient(_httpClient, _options); var managementClient = new ContentfulManagementClient(_httpClient, _options); var facetQuery = new QueryBuilder <Project>() .ContentTypeIs("project") .FieldEquals("fields.slug", slug) .Include(8); _logger.LogInformation($"executing CMS call with query: {facetQuery.Build()}"); // Retrieve the entire content tree by starting at the project and pulling includes // an arbitrary depth of 8 var entrySet = await cful.GetEntries(facetQuery); // todo: determine if our process will already have the actual project published or not. // var projectId = entrySet.Items.FirstOrDefault().Sys.Id; var includedEntryIds = entrySet.IncludedEntries.Select(x => x.SystemProperties.Id); // todo: publish assets, too. // var includedAssetIds = entrySet.IncludedAssets.Select(x => x.SystemProperties.Id); foreach (var entry in entrySet.IncludedEntries) { var id = entry.SystemProperties.Id; // Retrieve the item from mgmt API. Version is not included from delivery API so we get it again. var mgmtEntry = await managementClient.GetEntry(id); var latestVersion = mgmtEntry.SystemProperties.Version.GetValueOrDefault(); var result = await managementClient.PublishEntry(id, latestVersion); } return(null); } catch (Contentful.Core.Errors.ContentfulException ex) { var msg = "Error retrieving content: " + ex; _logger.LogError(msg); throw new ContentException(msg, ex); } catch (Exception ex) { var msg = "Unable to retrieve content: " + ex; _logger.LogError(msg); throw new ProcessException(msg, ex); } }
public override async Task <User> GetUser(string key) { var ctfClient = new ContentfulManagementClient(_httpClient, new ContentfulOptions { ManagementApiKey = key }); var ctfUser = await ctfClient.GetCurrentUser(); return(new User { Name = ctfUser.FirstName, Token = key }); }
/// <summary> /// Creates a number of content types in Contentful. /// </summary> /// <param name="contentTypes">The content types to create.</param> /// <param name="configuration">The configuration for the creation process.</param> /// <param name="client">The optional client to use for creation.</param> /// <returns>A list of created or updated content types.</returns> public static async Task <List <ContentType> > CreateContentTypes(IEnumerable <ContentTypeInformation> contentTypes, ContentfulCodeFirstConfiguration configuration, IContentfulManagementClient client = null) { var managementClient = client; if (managementClient == null) { var httpClient = new HttpClient(); managementClient = new ContentfulManagementClient(httpClient, configuration.ApiKey, configuration.SpaceId); } var createdTypes = new List <ContentType>(); var existingContentTypes = (await managementClient.GetContentTypes()).ToList(); if (configuration.ForceUpdateContentTypes == false) { //remove any pre-existing content types from the list to be created. contentTypes = contentTypes.Where(c => !existingContentTypes.Any(x => x.SystemProperties.Id == c.ContentType.SystemProperties.Id)); } foreach (var contentTypeInfo in contentTypes) { //make sure to add correct version for existing content types contentTypeInfo.ContentType.SystemProperties.Version = existingContentTypes.FirstOrDefault(c => c.SystemProperties.Id == contentTypeInfo.ContentType.SystemProperties.Id)?.SystemProperties.Version; var createdContentType = await managementClient.CreateOrUpdateContentType(contentTypeInfo.ContentType, version : contentTypeInfo.ContentType.SystemProperties.Version); if (configuration.PublishAutomatically) { createdContentType = await managementClient.ActivateContentType(createdContentType.SystemProperties.Id, createdContentType.SystemProperties.Version ?? 1); } createdTypes.Add(createdContentType); if (contentTypeInfo.InterfaceControls != null && contentTypeInfo.InterfaceControls.Any()) { var currentInterface = await managementClient.GetEditorInterface(createdContentType.SystemProperties.Id); foreach (var control in contentTypeInfo.InterfaceControls) { var index = currentInterface.Controls.FindIndex(c => c.FieldId == control.FieldId); currentInterface.Controls[index] = control; } await managementClient.UpdateEditorInterface(currentInterface, createdContentType.SystemProperties.Id, currentInterface.SystemProperties.Version.Value); } } return(createdTypes); }
/// <summary> /// Publishes the content item with the provided ID /// </summary> /// <param name="id">The id identifying the item</param> /// <returns></returns> public async Task <int> PublishItem(string id) { _logger.LogTrace($"PublishItem({id})"); if (string.IsNullOrWhiteSpace(id)) { throw new ArgumentException("Missing required parameter", nameof(id)); } var managementClient = new ContentfulManagementClient(_httpClient, _options); var mgmtEntry = await GetItemFromMgmtAPI(id); try { var latestVersion = mgmtEntry.SystemProperties.Version.GetValueOrDefault(); var publishedVersion = mgmtEntry.SystemProperties.PublishedVersion.GetValueOrDefault(); // note: this is intended to reduce re-pubishing already published items but // a bug in contentful ALWAYS increments the latest version, no matter what. // Leaving for future, but should probably ask contentful about it. if (publishedVersion < latestVersion) { var result = await managementClient.PublishEntry(id, latestVersion); return(result.SystemProperties.PublishedVersion.GetValueOrDefault()); } return(publishedVersion); } catch (Contentful.Core.Errors.ContentfulException ex) { var msg = "Error publishing entry: " + ex; _logger.LogError(msg); throw new ContentException(msg, ex); } catch (Exception ex) { var msg = "Unable to publishing entry: " + ex; _logger.LogError(msg); throw new ProcessException(msg, ex); } }
public static async Task Create() { try { var httpClient = new HttpClient(); var client = new ContentfulManagementClient(httpClient, "<content_management_api_key>", "<space_id>"); var extension = await client.GetExtension("<extension_id>"); extension.SystemProperties.Version = extension.SystemProperties.Version + 1; extension.Parameters = new UiExtensionParametersLists { InstanceParameters = new List <UiExtensionParameters> { new UiExtensionParameters { // Update these fields as required Id = "sections", Name = "Section names", Type = "Symbol", Required = false, Description = "Define the sections that will be re-ordered. The list is separated by commas." } } }; extension.SystemProperties.Id = null; extension.Src = "https://www.google.com"; extension.SrcDoc = null; // You will need to over-ride the srcdoc after you run this await client.CreateExtension(extension); } catch (Exception e) { Console.WriteLine(e.Message); } }
public async Task <int> OnExecute(CommandLineApplication app, IConsole console) { var http = new HttpClient(); var client = new ContentfulManagementClient(http, new ContentfulOptions { ManagementApiKey = ManagementToken, SpaceId = SpaceId, Environment = Environment }); try { _contentTypes = await client.GetContentTypes(); } catch (ContentfulException ce) { Console.ForegroundColor = ConsoleColor.Red; Console.Error.WriteLine("There was an error communicating with the Contentful API: " + ce.Message); Console.Error.WriteLine($"Request ID: {ce.RequestId}"); Console.Error.WriteLine("" + ce.ErrorDetails?.Errors); Console.Error.WriteLine("Please verify that your api key and access token are correct"); Console.ResetColor(); return(Program.ERROR); } Console.WriteLine($"Found {_contentTypes.Count()} content types."); var path = ""; if (string.IsNullOrEmpty(Path)) { path = Directory.GetCurrentDirectory(); Console.WriteLine($"No path specified, creating files in current working directory {path}"); } else { Console.WriteLine($"Path specified. Files will be created at {Path}"); path = Path; } var dir = new DirectoryInfo(path); if (dir.Exists == false) { Console.WriteLine($"Path {path} does not exist and will be created."); dir.Create(); } foreach (var contentType in _contentTypes) { var safeFileName = GetSafeFilename(contentType.SystemProperties.Id); var file = new FileInfo($"{dir.FullName}{System.IO.Path.DirectorySeparatorChar}{safeFileName}.cs"); if (file.Exists && !Force) { Console.ForegroundColor = ConsoleColor.Yellow; var prompt = Prompt.GetYesNo($"The folder already contains a file with the name {file.Name}. Do you want to overwrite it?", true); Console.ResetColor(); if (prompt == false) { Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine($"Skipping {file.Name}"); Console.ResetColor(); } } using (var sw = file.CreateText()) { var sb = new StringBuilder(); sb.AppendLine(_templateStart); sb.AppendLine($"namespace {Namespace}"); //start namespace sb.AppendLine("{"); sb.AppendLine($" public class {FormatClassName(contentType.SystemProperties.Id)}"); //start class sb.AppendLine(" {"); sb.AppendLine(" public SystemProperties Sys { get; set; }"); foreach (var field in contentType.Fields) { sb.AppendLine($" public {GetDataTypeForField(field)} {FirstLetterToUpperCase(field.Id)} {{ get; set; }}"); } //end class sb.AppendLine(" }"); //end namespace sb.AppendLine("}"); sw.WriteLine(sb.ToString()); } } Console.ForegroundColor = ConsoleColor.Green; Console.WriteLine($"Files successfully created!"); Console.ResetColor(); return(Program.OK); }
public IContentfulManagementClient GetManagementClient(ContentfulConfig config) { var client = new ContentfulManagementClient(_httpClient, config.ManagementKey, config.SpaceKey); return(client); }