private static Dictionary <string, ContentItemModel> Initialize()
        {
            var predefinedDictionary =
                predefined.ToDictionary(item => item.Link, item => item, StringComparer.OrdinalIgnoreCase);
            string        path = Path.Combine(Directory.GetCurrentDirectory(), "ClientApp", "build", "static", "images");
            DirectoryInfo dir  = new DirectoryInfo(path);

            if (dir.Exists == false)
            {
                dir.Create();
            }

            foreach (FileInfo file in dir.EnumerateFiles())
            {
                string link = GetLinkFromFileName(file.Name);
                predefinedDictionary[link] = new ContentItemModel
                {
                    Id   = Guid.NewGuid().ToString(),
                    Link = link,
                    Type = "image"
                };
            }

            return(predefinedDictionary);
        }
        public async Task <bool> FindAndUpdateAsync(ContentItemModel contentItemModel, Uri url)
        {
            _ = contentItemModel ?? throw new ArgumentNullException(nameof(contentItemModel));

            var cmsApiModel = await cmsApiService.GetContentItemAsync <T>(url).ConfigureAwait(false);

            if (cmsApiModel != null)
            {
                switch (contentItemModel.ContentType.ToLower())
                {
                case Constants.ContentTypeHtml:
                    if (cmsApiModel is CmsApiHtmlModel cmsApiHtmlModel)
                    {
                        contentItemModel.Title    = cmsApiHtmlModel.Title;
                        contentItemModel.Content  = cmsApiHtmlModel.Content;
                        contentItemModel.HtmlBody = cmsApiHtmlModel.HtmlBody;
                    }

                    break;

                case Constants.ContentTypeHtmlShared:
                    if (cmsApiModel is CmsApiHtmlSharedModel cmsApiHtmlSharedModel)
                    {
                        contentItemModel.Title    = cmsApiHtmlSharedModel.Title;
                        contentItemModel.Content  = cmsApiHtmlSharedModel.Content;
                        contentItemModel.HtmlBody = cmsApiHtmlSharedModel.HtmlBody;
                    }

                    break;

                case Constants.ContentTypeSharedContent:
                    if (cmsApiModel is CmsApiSharedContentModel cmsApiSharedContentModel)
                    {
                        contentItemModel.Title    = cmsApiSharedContentModel.Title;
                        contentItemModel.Content  = cmsApiSharedContentModel.Content;
                        contentItemModel.HtmlBody = cmsApiSharedContentModel.HtmlBody;
                    }

                    break;

                case Constants.ContentTypeForm:
                    if (cmsApiModel is CmsApiFormModel cmsApiFormModel)
                    {
                        contentItemModel.Action = cmsApiFormModel.Action;
                        contentItemModel.EnableAntiForgeryToken = cmsApiFormModel.EnableAntiForgeryToken;
                        contentItemModel.Method  = cmsApiFormModel.Method;
                        contentItemModel.EncType = cmsApiFormModel.EncType;
                    }

                    break;
                }

                contentItemModel.LastCached = DateTime.UtcNow;

                return(true);
            }

            return(false);
        }
        public ActionResult Create()
        {
            ContentItemModel itemModel = new ContentItemModel()
            {
                IsActive = true,
                Mode = ViewModelMode.Creation
            };

            return base.View("CreateOrUpdate", itemModel);
        }
        // pass in a list of strings representing an item's filter properties
        // return true if the checkbox matching those filter properties is checked
        // return false is none of the checkboxes for that item's properties are checked
        public bool FilterContent(ContentItemModel item)
        {
            if (!item.FilterProperties.ContainsKey(ID))
            {
                return(false);
            }

            return(Options
                   .Where(o => item.FilterProperties[ID].Contains(o.Filter, StringComparer.OrdinalIgnoreCase))
                   .Any(o => o.IsChecked));
        }
示例#5
0
        protected static ContentItemModel BuildValidContentItemModel(Guid contentItemId, string?contentType = null)
        {
            var model = new ContentItemModel()
            {
                ItemId       = contentItemId,
                LastReviewed = DateTime.Now,
                ContentType  = contentType,
            };

            return(model);
        }
示例#6
0
        private async Task <ContentItemModel> CreateUserItem(string name, string id)
        {
            var item = new ContentItemCreateModel
            {
                Name       = name,
                Type       = ContentTypeIdentifier.ByCodename("user"),
                ExternalId = id
            };

            ContentItemModel responseItem = await managementClient.CreateContentItemAsync(item);

            return(responseItem);
        }
        public ContentItem CreateContentItem(ContentItemModel itemModel)
        {
            var catalog = DomainRepositories.Catalog.FindByCode("c.languages");

            var ci = new ContentItem()
            {
                Description = itemModel.Description,
                Keywords = itemModel.Keywords,
                IsActive = itemModel.IsActive,
                Name = itemModel.Name,
                Language = catalog.GetLineByCode(itemModel.Language),
            };
            ci.AddLogCreation();

            return ci;
        }
        public ActionResult Create(ContentItemModel itemModel, FormCollection collection)
        {
            if (base.ModelState.IsValid)
            {
                var contentItem = this.contentModelsService.CreateContentItem(itemModel);
                bool result = this.contentItemRepository.Save(contentItem);
                if (result)
                {
                    this.contentBonusService.CalculateTotalPoints(DomainSessionContext.Instance.CurrentUser);

                    string id = contentItem.Id.ToString();
                    return base.RedirectToAction(ControllerAssistant.GetActionName(() => this.CreatePart(id)), ControllerAssistant.BuildRouteValues(id));
                }
            }

            return base.View("CreateOrUpdate", itemModel);
        }
示例#9
0
        public async Task <bool> FindAndUpdateAsync(ContentItemModel contentItemModel, Uri url)
        {
            _ = contentItemModel ?? throw new ArgumentNullException(nameof(contentItemModel));

            var cmsApiHtmlModel = await cmsApiService.GetContentItemAsync <T>(url).ConfigureAwait(false);

            if (cmsApiHtmlModel != null)
            {
                contentItemModel.Title      = cmsApiHtmlModel.Title;
                contentItemModel.Content    = cmsApiHtmlModel.Content;
                contentItemModel.HtmlBody   = cmsApiHtmlModel.HtmlBody;
                contentItemModel.LastCached = DateTime.UtcNow;

                return(true);
            }

            return(false);
        }
示例#10
0
        public void Add(Dictionary <string, object> body)
        {
            string url = body["url"].ToString();

            if (Items.ContainsKey(url))
            {
                return;
            }

            Uri uri = new Uri(url);
            ContentItemModel itemModel = new ContentItemModel
            {
                Id   = Guid.NewGuid().ToString(),
                Link = url,
            };
            string host = uri.Host.Replace("www.", "").Replace("clips.", "");
            string itemType;

            switch (host)
            {
            case "youtube.com":
                itemType = "youtube";
                break;

            case "coub.com":
                itemType = "coub";
                break;

            case "tiktok.com":
                itemType = "tiktok";
                break;

            case "twitch.tv":
                itemType = "twitch";
                break;

            default:
                itemType = "unsupported";
                break;
            }

            itemModel.Type        = itemType;
            Items[itemModel.Link] = itemModel;
        }
        public void WebhooksServiceRemoveContentItemTestsReturnsSuccess()
        {
            // Arrange
            var contentItemId            = Guid.NewGuid();
            var expectedContentItemModel = new ContentItemModel
            {
                ItemId = contentItemId,
            };
            var items   = BuildContentItemSet();
            var service = BuildWebhookContentProcessor();

            items.First().ContentItems.First().ContentItems !.Add(expectedContentItemModel);

            // Act
            var result = service.RemoveContentItem(contentItemId, items);

            // Assert
            Assert.True(result);
        }
示例#12
0
        internal async Task <(ContentItemVariantModel <ConversationModel> variant, bool success)> SyncSingle(Conversation intercomConversation, ContentItemVariantModel <ConversationModel> conversationVariant, List <ContentItemVariantModel <UserModel> > conversationUserVariants)
        {
            currentConversationId    = intercomConversation.id;
            currentConversationUsers = new List <UserModel>()
            {
            };
            currentConversationUsers.AddRange(conversationUserVariants.Select(x => x.Elements));

            ContentItemModel conversationItem = null;
            Guid             itemIdentifier   = Guid.Empty;

            // If conversation doesn't exist, create item for it
            if (conversationVariant == null)
            {
                try
                {
                    logger.Debug("Creating item for conversation: " + currentConversationId);
                    conversationItem = await CreateConversationItem(currentConversationId);

                    itemIdentifier = conversationItem.Id;
                }
                catch (ContentManagementException e)
                {
                    logger.Error(e, "Unable to create item for conversation: " + currentConversationId);
                    return(null, false);
                }
            }
            else
            {
                itemIdentifier = conversationVariant.Item.Id;
            }

            // Fill model with data
            var model = CreateConversationModel(intercomConversation);

            logger.Debug("Creating item variant for conversation: " + currentConversationId);
            var variant = await UpsertConversationVariant(model, ContentItemIdentifier.ById(itemIdentifier));

            var publishConversation = await PublishItemVariant(itemIdentifier.ToString());

            return(variant, true);
        }
示例#13
0
        public async Task ContentItemUpdaterFindAndUpdateAsyncForFormReturnsSuccess()
        {
            // Arrange
            const bool expectedResult       = true;
            var        dummyCmsApiFormModel = A.Dummy <CmsApiFormModel>();
            var        contentItemModel     = new ContentItemModel {
                ContentType = Constants.ContentTypeForm
            };
            var url     = new Uri("https://www.somewhere.com", UriKind.Absolute);
            var service = new MarkupContentItemUpdater <CmsApiFormModel>(fakeCmsApiService);

            A.CallTo(() => fakeCmsApiService.GetContentItemAsync <CmsApiFormModel>(A <Uri> .Ignored)).Returns(dummyCmsApiFormModel);

            // Act
            var result = await service.FindAndUpdateAsync(contentItemModel, url).ConfigureAwait(false);

            // Assert
            A.CallTo(() => fakeCmsApiService.GetContentItemAsync <CmsApiFormModel>(A <Uri> .Ignored)).MustHaveHappenedOnceExactly();

            Assert.Equal(expectedResult, result !);
        }
示例#14
0
        public void AddImage([FromForm] IFormFile file)
        {
            string path = Path.Combine(Directory.GetCurrentDirectory(), "ClientApp", "build", "images", file.FileName);

            if (System.IO.File.Exists(path))
            {
                return;
            }

            FileStream createStream = System.IO.File.Create(path);

            file.CopyTo(createStream);
            createStream.Close();

            ContentItemModel itemModel = new ContentItemModel
            {
                Id   = Guid.NewGuid().ToString(),
                Link = $"https://{this.Request.Host.Value}/images/{file.FileName}",
                Type = "image"
            };

            Items[itemModel.Link] = itemModel;
        }
        public ContentItemModel GetContentItemModel(ContentItem contentItem, bool filterActiveOnly)
        {
            var model = new ContentItemModel();
            model.Initialize(contentItem, filterActiveOnly);

            return model;
        }
示例#16
0
        internal static async Task <ContentItemVariantModel> PrepareTestVariant(ContentManagementClient client, string languageCodename, object elements, ContentItemModel item)
        {
            var addedItemIdentifier                = ContentItemIdentifier.ByCodename(item.CodeName);
            var addedLanguageIdentifier            = LanguageIdentifier.ByCodename(languageCodename);
            var addedContentItemLanguageIdentifier = new ContentItemVariantIdentifier(addedItemIdentifier, addedLanguageIdentifier);
            var variantUpdateModel = new ContentItemVariantUpsertModel()
            {
                Elements = elements
            };

            return(await client.UpsertContentItemVariantAsync(addedContentItemLanguageIdentifier, variantUpdateModel));
        }
示例#17
0
        /// <summary>
        /// </summary>
        /// <param name="elements">The Elements property of the content item to be updated</param>
        /// <param name="codename">If set, the item with the specified code name will be upserted</param>
        static void UpsertSingleItem(Dictionary <string, object> elements, string codename, ContentType type, bool update)
        {
            ContentItemModel contentItem  = null;
            ContentItem      existingItem = null;
            Guid             itemid;

            // Try to get existing content item for updating
            if (update && existingItem == null)
            {
                existingItem = GetExistingContentItem(codename, type.System.Codename);
            }

            // If not updating, create content item first
            if (!update)
            {
                contentItem = CreateNewContentItem(codename, type.System.Codename);
                if (contentItem.Id != null)
                {
                    itemid = contentItem.Id;
                }
                else
                {
                    throw new Exception("Error creating new item.");
                }
            }
            else
            {
                // We are updating existing
                if (existingItem != null)
                {
                    itemid = new Guid(existingItem.System.Id);
                }
                else
                {
                    // Existing item wasn't found, create it
                    contentItem = CreateNewContentItem(codename, type.System.Codename);
                    if (contentItem.Id != null)
                    {
                        itemid = contentItem.Id;
                    }
                    else
                    {
                        throw new Exception("Error creating new item.");
                    }
                }
            }

            // After item is created (or skipped for updateExisting), upsert content
            try
            {
                // Get item variant to upsert
                ContentItemIdentifier        itemIdentifier     = ContentItemIdentifier.ById(itemid);
                LanguageIdentifier           languageIdentifier = LanguageIdentifier.ById(new Guid("00000000-0000-0000-0000-000000000000"));
                ContentItemVariantIdentifier identifier         = new ContentItemVariantIdentifier(itemIdentifier, languageIdentifier);

                elements = ValidateContentTypeFields(elements, type);

                // Set target element value
                ContentItemVariantUpsertModel model = new ContentItemVariantUpsertModel()
                {
                    Elements = elements
                };

                // Upsert item
                var upsertTask = clientCM.UpsertContentItemVariantAsync(identifier, model);
                var response   = upsertTask.GetAwaiter().GetResult();
            }
            catch (ContentManagementException e)
            {
                if (e.Message.ToLower().Contains("cannot update published"))
                {
                    throw new Exception("This tool cannot currently update published content. If you wish to update a published item, you will first need to unpublish it within Kentico Kontent.");
                }
            }
        }
示例#18
0
    /// <summary>
    /// Updates the given content item.
    /// </summary>
    /// <param name="client">Content management client instance.</param>
    /// <param name="identifier">Identifies which content item will be updated. </param>
    /// <param name="contentItem">Specifies data for updated content item.</param>
    /// <returns>The <see cref="ContentItemModel"/> instance that represents updated content item.</returns>
    public async static Task <ContentItemModel> UpsertContentItemAsync(this IManagementClient client, Reference identifier, ContentItemModel contentItem)
    {
        if (identifier == null)
        {
            throw new ArgumentNullException(nameof(identifier));
        }

        if (contentItem == null)
        {
            throw new ArgumentNullException(nameof(contentItem));
        }

        var contentItemUpdateModel = new ContentItemUpsertModel
        {
            Name             = contentItem.Name,
            Codename         = contentItem.Codename,
            Collection       = contentItem.Collection,
            ExternalId       = contentItem.ExternalId,
            SitemapLocations = contentItem.SitemapLocations,
            Type             = contentItem.Type
        };

        return(await client.UpsertContentItemAsync(identifier, contentItemUpdateModel));
    }
 public ContentItemViewModel(ContentItemModel model, SelectionModel <ContentItemModel> selection)
 {
     _Model     = model;
     _Selection = selection;
 }
示例#20
0
        private ContentPageModel LoadSpellInfo(string dataDir, Index_Json index)
        {
            var spells = JsonConvert.DeserializeObject <Spells_Json>(
                ReadFileFromIndex(Path.Combine(dataDir, index.spells)));
            var components = JsonConvert.DeserializeObject <Components_Json>(
                ReadFileFromIndex(Path.Combine(dataDir, index.spellComponents)));
            var classSpells = JsonConvert.DeserializeObject <ClassSpellListCollection_Json>(
                ReadFileFromIndex(Path.Combine(dataDir, index.classSpells)));

            ContentPageModel cpm = new ContentPageModel(_Compendium)
            {
                Header = "Spells"
            };

            cpm.AddFilterGroup("level", "Filter by Level");
            cpm.AddFilterGroup("class", "Filter by Class");
            cpm.AddFilterGroup("school", "Filter by School");
            cpm.AddFilterGroup("components", "Filter by Components");
            cpm.AddFilterGroup("other", "Other Filters");

            // Create all spells (and initialize with basic filter properties)
            foreach (var spell in spells.spells)
            {
                ContentItemModel spellModel = new ContentItemModel()
                {
                    Name     = spell.name,
                    ID       = spell.id,
                    Markdown = GetSpellMarkdownFromJson(spell)
                };

                spellModel.AddFilterProperty("level", spell.level.ToString());

                spellModel.AddFilterProperty("school", spell.school);
                // If the current spell's school is not in the filter list, add it
                if (!cpm.FilterGroups.Any(g => string.Equals(g.Header, spell.school)))
                {
                    cpm.AddOptionToFilterGroup("school", spell.school, spell.school.ToLower().Replace(' ', '_'));
                }

                foreach (var comp in spell.components)
                {
                    spellModel.AddFilterProperty("components", comp);
                }

                // ADD SINGLE TRUE/FALSE FILTER PROPERTIES
                //spellModel.AddFilterProperty("ritual", spell.isRitual ? "true" : "false");
                //spellModel.AddFilterProperty("concentration", spell.concentration ? "true" : "false");

                cpm.AddContentItem(spellModel);
            }

            // Add class filter properties for all spells
            foreach (var charClass in classSpells.classes)
            {
                AddClassFiltersToSpell(cpm, charClass);
            }

            // Add filter options to the filter groups
            cpm.AddOptionToFilterGroup("level", "Cantrips", "0");
            cpm.AddOptionToFilterGroup("level", "1st-level", "1");
            cpm.AddOptionToFilterGroup("level", "2nd-level", "2");
            cpm.AddOptionToFilterGroup("level", "3rd-level", "3");
            cpm.AddOptionToFilterGroup("level", "4th-level", "4");
            cpm.AddOptionToFilterGroup("level", "5th-level", "5");
            cpm.AddOptionToFilterGroup("level", "6th-level", "6");
            cpm.AddOptionToFilterGroup("level", "7th-level", "7");
            cpm.AddOptionToFilterGroup("level", "8th-level", "8");
            cpm.AddOptionToFilterGroup("level", "9th-level", "9");

            foreach (var comp in components.components)
            {
                cpm.AddOptionToFilterGroup("components", comp.name, comp.initial);
            }

            cpm.AddOptionToFilterGroup("other", "Show only ritual spells", "ritual");
            cpm.AddOptionToFilterGroup("other", "Show only concentration spells", "conc");

            return(cpm);
        }
        public void UpdateContentItem(ContentItem contentItem, ContentItemModel contentModel)
        {
            contentItem.Name = contentModel.Name;
            contentItem.Description = contentModel.Description;
            contentItem.Keywords = contentModel.Keywords;
            contentItem.IsActive = contentModel.IsActive;

            contentItem.AddLog("Update content", string.Empty);
        }
示例#22
0
        /// <summary>
        /// Updates the given content item.
        /// </summary>
        /// <param name="client">Content management client instance.</param>
        /// <param name="identifier">Identifies which content item will be updated. </param>
        /// <param name="contentItem">Specifies data for updated content item.</param>
        /// <returns>The <see cref="ContentItemModel"/> instance that represents updated content item.</returns>
        public static async Task <ContentItemModel> UpdateContentItemAsync(this ContentManagementClient client, ContentItemIdentifier identifier, ContentItemModel contentItem)
        {
            if (identifier == null)
            {
                throw new ArgumentNullException(nameof(identifier));
            }

            if (contentItem == null)
            {
                throw new ArgumentNullException(nameof(contentItem));
            }

            var contentItemUpdateModel = new ContentItemUpdateModel(contentItem);

            return(await client.UpdateContentItemAsync(identifier, contentItemUpdateModel));
        }
        public ActionResult Edit(string id, ContentItemModel contentModel, FormCollection collection)
        {
            if (base.ModelState.IsValid)
            {
                var contentItem = this.contentItemRepository.GetById(new Guid(id));
                if (contentItem != null)
                {
                    this.contentModelsService.UpdateContentItem(contentItem, contentModel);
                    this.contentBonusService.CalculateTotalPoints(DomainSessionContext.Instance.CurrentUser);

                    return base.RedirectToAction(ControllerAssistant.GetActionName(() => this.Details(id)), new { id = id });
                }
            }

            return base.View("CreateOrUpdate", contentModel);
        }