public void DataService_AddHeirarchicalTerm_Adds_First_Record_On_Valid_Term() { //Arrange int rowCount = DataUtil.GetRecordCount(DataTestHelper.ConnectionString, ContentDataTestHelper.TermsTableName); DataUtil.AddDatabaseObject(virtualScriptFilePath, addHeirarchicalTerm); Term term = new Term(4) { Name = "Test Term", ParentTermId = null /*No Parent*/, Weight = 0, Description = "Test Term" }; DataService ds = new DataService(); //Act int newTermId = ds.AddHeirarchicalTerm(term, Constants.USER_ValidId); //Assert DatabaseAssert.RecordCountIsEqual(DataTestHelper.ConnectionString, ContentDataTestHelper.TermsTableName, rowCount + 1); DatabaseAssert.RecordLastAddedIdEquals(DataTestHelper.ConnectionString, ContentDataTestHelper.TermsTableName, "TermID", newTermId); //Assert that new term is correct as first record in Vocabulary TestTerm(newTermId, 1, 2); }
public void BindTerm(Term term, IEnumerable<Term> terms, bool isHeirarchical, bool loadFromControl, bool editEnabled) { //nameValidator.Text = Services.Localization.Localization.GetString("TermName.Required", SharedResourceFile); if (loadFromControl) { term.Name = nameTextBox.Text; term.Description = descriptionTextBox.Text; if (isHeirarchical && !string.IsNullOrEmpty(parentTermCombo.SelectedValue)) { term.ParentTermId = Int32.Parse(parentTermCombo.SelectedValue); } } else { nameTextBox.Text = term.Name; descriptionTextBox.Text = term.Description; //Remove this term (and its descendants) from the collection, so we don't get wierd heirarchies var termsList = (from t in terms where !(t.Left >= term.Left && t.Right <= term.Right) select t).ToList(); parentTermCombo.DataSource = termsList; parentTermCombo.DataBind(); if (term.ParentTermId.HasValue && parentTermCombo.FindItemByValue(term.ParentTermId.ToString()) != null) { parentTermCombo.FindItemByValue(term.ParentTermId.ToString()).Selected = true; } divParentTerm.Visible = isHeirarchical && termsList.Count > 0; nameTextBox.Enabled = editEnabled; descriptionTextBox.Enabled = editEnabled; parentTermCombo.Enabled = editEnabled; } }
internal static Term CreateValidSimpleTerm(int vocabularyId) { Term term = new Term(vocabularyId) { Name = Constants.TERM_ValidName, Description = Constants.TERM_ValidName, Weight = Constants.TERM_ValidWeight }; return term; }
internal static Term CreateValidHeirarchicalTerm(int vocabularyId, int parentId) { Term term = new Term(vocabularyId) { Name = Constants.TERM_ValidName, Description = Constants.TERM_ValidName, Weight = Constants.TERM_ValidWeight, ParentTermId = parentId }; return term; }
public void BindTerm(Term term, IEnumerable<Term> terms, bool isHeirarchical, bool loadFromControl, bool editEnabled) { //nameValidator.Text = Services.Localization.Localization.GetString("TermName.Required", SharedResourceFile); if (loadFromControl) { term.Name = nameTextBox.Text; term.Description = descriptionTextBox.Text; if (isHeirarchical && !string.IsNullOrEmpty(parentTermCombo.SelectedValue)) { term.ParentTermId = Int32.Parse(parentTermCombo.SelectedValue); } } else { nameTextBox.Text = term.Name; nameTextBox.Attributes.Add("data-termid", term.TermId.ToString()); nameTextBox.Attributes.Add("data-vocabularyid", term.VocabularyId.ToString()); descriptionTextBox.Text = term.Description; //Remove this term (and its descendants) from the collection, so we don't get wierd heirarchies var termsList = (from t in terms where !(t.Left >= term.Left && t.Right <= term.Right) select t).ToList(); parentTermCombo.Items.Clear(); foreach (var t in termsList) { var item = new DnnComboBoxItem(t.Name, t.TermId.ToString()); if (term.ParentTermId.HasValue && term.ParentTermId == t.TermId) { item.Selected = true; } parentTermCombo.Items.Add(item); } divParentTerm.Visible = isHeirarchical && termsList.Count > 0; nameTextBox.Enabled = editEnabled; descriptionTextBox.Enabled = editEnabled; parentTermCombo.Enabled = editEnabled; } }
/// <summary> /// Adds the heirarchical term. /// </summary> /// <param name="term">The term.</param> /// <param name="createdByUserId">The created by user id.</param> /// <returns>term id.</returns> public int AddHeirarchicalTerm(Term term, int createdByUserId) { return _provider.ExecuteScalar<int>("AddHeirarchicalTerm", term.VocabularyId, term.ParentTermId, term.Name, term.Description, term.Weight, createdByUserId); }
private void LoadCategoryList() { ITermController termController = Util.GetTermController(); var terms = termController.GetTermsByVocabulary("Module_Categories").OrderBy(t => t.Weight).Where(t => t.Name != "< None >").ToList(); var allTerm = new Term("All", Localization.GetString("AllCategories", LocalResourceFile)); terms.Add(allTerm); CategoryList.DataSource = terms; CategoryList.DataBind(); if (!IsPostBack) { CategoryList.Select("All", false); } }
private void SaveTags() { string tags = new PortalSecurity().InputFilter(_Tags, PortalSecurity.FilterFlag.NoMarkup | PortalSecurity.FilterFlag.NoScripting); tags = HttpContext.Current.Server.HtmlEncode(tags); if (!string.IsNullOrEmpty(tags)) { foreach (string t in tags.Split(',')) { if (!string.IsNullOrEmpty(t)) { string tagName = t.Trim(' '); Term existingTerm = (from term in ContentItem.Terms.AsQueryable() where term.Name.Equals(tagName, StringComparison.CurrentCultureIgnoreCase) select term).SingleOrDefault(); if (existingTerm == null) { //Not tagged TermController termController = new TermController(); Term term = (from te in termController.GetTermsByVocabulary(TagVocabulary.VocabularyId) where te.Name.Equals(tagName, StringComparison.CurrentCultureIgnoreCase) select te). SingleOrDefault(); if (term == null) { //Add term term = new Term(TagVocabulary.VocabularyId); term.Name = tagName; termController.AddTerm(term); } //Add term to content ContentItem.Terms.Add(term); termController.AddTermToContent(term, ContentItem); } } } } IsEditMode = false; //Raise the Tags Updated Event OnTagsUpdate(EventArgs.Empty); }
private void RenderTerm(HtmlTextWriter writer, Term term, bool renderSeparator) { writer.AddAttribute(HtmlTextWriterAttribute.Href, string.Format(NavigateUrlFormatString, term.Name)); writer.AddAttribute(HtmlTextWriterAttribute.Title, term.Name); writer.AddAttribute(HtmlTextWriterAttribute.Rel, "tag"); writer.RenderBeginTag(HtmlTextWriterTag.A); writer.Write(term.Name); writer.RenderEndTag(); if (renderSeparator) { writer.Write(Separator); } }
public void DataService_UpdateHeirarchicalTerm_Updates_Record_But_Does_Not_Modify_Other_Terms_If_ParentID_Does_Not_Change() { //Arrange int rowCount = DataUtil.GetRecordCount(DataTestHelper.ConnectionString, ContentDataTestHelper.TermsTableName); DataUtil.AddDatabaseObject(virtualScriptFilePath, updateHeirarchicalTerm); Term term = new Term(4) { TermId = 17, Name = "Test Update", ParentTermId = null, Weight = 0, Description = "Updated" }; DataService ds = new DataService(); //Act ds.UpdateHeirarchicalTerm(term, Constants.USER_ValidId); //Assert DatabaseAssert.RecordCountIsEqual(DataTestHelper.ConnectionString, ContentDataTestHelper.TermsTableName, rowCount); //Assert that electronics terms are untouched //Televisions, Id = 1, Left=12, Right=17 TestTerm(1, 12, 17); //Flash, Id = 9, Left=8, Right=9 TestTerm(9, 8, 9); //Electronics, Id = 12, Left=1, Right=18 TestTerm(12, 1, 18); }
/// <summary> /// Updates the simple term. /// </summary> /// <param name="term">The term.</param> /// <param name="lastModifiedByUserId">The last modified by user id.</param> public void UpdateSimpleTerm(Term term, int lastModifiedByUserId) { _provider.ExecuteNonQuery("UpdateSimpleTerm", term.TermId, term.VocabularyId, term.Name, term.Description, term.Weight, lastModifiedByUserId); }
/// <summary> /// Deletes the simple term. /// </summary> /// <param name="term">The term.</param> public void DeleteSimpleTerm(Term term) { _provider.ExecuteNonQuery("DeleteSimpleTerm", term.TermId); }
public IQueryable<ContentItem> GetContentItemsByTerm(Term term) { return GetContentItemsByTerm(term.Name); }
public TermsEventArgs(Term selectedTerm) { _SelectedTerm = selectedTerm; }
public static void AddModuleCategory(string category) { var termController = Util.GetTermController(); var term = (from Term t in termController.GetTermsByVocabulary("Module_Categories") where t.Name == category select t) .FirstOrDefault(); if (term == null) { var vocabularyController = Util.GetVocabularyController(); var vocabulary = (from v in vocabularyController.GetVocabularies() where v.Name == "Module_Categories" select v) .FirstOrDefault(); if (vocabulary != null) { term = new Term(vocabulary.VocabularyId) { Name = category }; termController.AddTerm(term); } } }
/// <summary> /// Updates the term. /// </summary> /// <param name="term">The term.</param> /// <exception cref="System.ArgumentNullException">term is null.</exception> /// <exception cref="System.ArgumentOutOfRangeException">term.TermId is less than 0.</exception> /// <exception cref="System.ArgumentOutOfRangeException">term.VocabularyId is less than 0.</exception> /// <exception cref="System.ArgumentException">term.Name is empty.</exception> public void UpdateTerm(Term term) { //Argument Contract Requires.NotNull("term", term); Requires.PropertyNotNegative("term", "TermId", term.TermId); Requires.PropertyNotNegative("term", "Vocabulary.VocabularyId", term.VocabularyId); Requires.PropertyNotNullOrEmpty("term", "Name", term.Name); if ((term.IsHeirarchical)) { _DataService.UpdateHeirarchicalTerm(term, UserController.Instance.GetCurrentUserInfo().UserID); } else { _DataService.UpdateSimpleTerm(term, UserController.Instance.GetCurrentUserInfo().UserID); } //Clear Cache DataCache.RemoveCache(string.Format(_CacheKey, term.VocabularyId)); }
public void DataService_AddHeirarchicalTerm_Does_Not_Modify_Terms_From_Other_Vocabularies() { //Arrange int rowCount = DataUtil.GetRecordCount(DataTestHelper.ConnectionString, ContentDataTestHelper.TermsTableName); DataUtil.AddDatabaseObject(virtualScriptFilePath, addHeirarchicalTerm); Term term = new Term(4) { Name = "Test Term", ParentTermId = null /*No Parent*/, Weight = 0, Description = "Test Term" }; DataService ds = new DataService(); //Act int newTermId = ds.AddHeirarchicalTerm(term, Constants.USER_ValidId); //Assert that electronics terms are untouched //Televisions, Id = 1, Left=12, Right=17 TestTerm(1, 12, 17); //Flash, Id = 9, Left=8, Right=9 TestTerm(9, 8, 9); //Electronics, Id = 12, Left=1, Right=18 TestTerm(12, 1, 18); }
public void DataService_DeleteHeirarchicalTerm_Does_Not_Modify_Terms_From_Other_Vocabularies() { //Arrange DataUtil.AddDatabaseObject(virtualScriptFilePath, deleteHeirarchicalTerm); Term term = new Term(3) { TermId = 16, Name = "Test Delete", ParentTermId = null, Weight = 0, Description = "Test Delete" }; DataService ds = new DataService(); //Act ds.DeleteHeirarchicalTerm(term); //Assert that electronics terms are untouched //Televisions, Id = 1, Left=12, Right=17 TestTerm(1, 12, 17); //Flash, Id = 9, Left=8, Right=9 TestTerm(9, 8, 9); //Electronics, Id = 12, Left=1, Right=18 TestTerm(12, 1, 18); }
/// <summary> /// Adds the simple term. /// </summary> /// <param name="term">The term.</param> /// <param name="createdByUserId">The created by user id.</param> /// <returns>term id.</returns> public int AddSimpleTerm(Term term, int createdByUserId) { return _provider.ExecuteScalar<int>("AddSimpleTerm", term.VocabularyId, term.Name, term.Description, term.Weight, createdByUserId); }
public void DataService_DeleteHeirarchicalTerm_Delete_Record_On_Valid_Term() { //Arrange int rowCount = DataUtil.GetRecordCount(DataTestHelper.ConnectionString, ContentDataTestHelper.TermsTableName); DataUtil.AddDatabaseObject(virtualScriptFilePath, deleteHeirarchicalTerm); int termId = 7; Term term = new Term(2) { TermId = 7, Name = "CD Players", ParentTermId = 2 /*Portable Electronics*/, Weight = 0, Description = "CD Players" }; DataService ds = new DataService(); //Act ds.DeleteHeirarchicalTerm(term); //Assert DatabaseAssert.RecordCountIsEqual(DataTestHelper.ConnectionString, ContentDataTestHelper.TermsTableName, rowCount - 1); DatabaseAssert.RecordDoesNotExist(DataTestHelper.ConnectionString, ContentDataTestHelper.TermsTableName, keyField, termId.ToString()); //Assert that existing terms are correct //Televisions, Id = 1, Left=12, Right=17 - should be Left=10, Right=15 TestTerm(1, 10, 15); //2-Way, Id = 8, Left=3, Right=4 - should be Left=3, Right=4 TestTerm(8, 3, 4); //Electronics, Id = 12, Left=1, Right=18 - should be Left=1, Right=16 TestTerm(12, 1, 16); }
public void AddTermToContent(Term term, ContentItem contentItem) { _provider.ExecuteNonQuery("AddTermToContent", term.TermId, contentItem.ContentItemId); }
public void TermController_DeleteTerm_Clears_Term_Cache_On_Valid_Term() { //Arrange Mock<IDataService> mockDataService = new Mock<IDataService>(); TermController termController = new TermController(mockDataService.Object); Term term = new Term(Constants.VOCABULARY_ValidVocabularyId) {TermId = Constants.TERM_DeleteTermId}; //Act termController.DeleteTerm(term); //Assert mockCache.Verify( cache => cache.Remove(String.Format(Constants.TERM_CacheKey, Constants.VOCABULARY_ValidVocabularyId))); }
/// <summary> /// Deletes the heirarchical term. /// </summary> /// <param name="term">The term.</param> public void DeleteHeirarchicalTerm(Term term) { _provider.ExecuteNonQuery("DeleteHeirarchicalTerm", term.TermId); }
public void DataService_AddHeirarchicalTerm_Inserts_Record_In_Alpha_Order_On_Valid_Term() { //Arrange int rowCount = DataUtil.GetRecordCount(DataTestHelper.ConnectionString, ContentDataTestHelper.TermsTableName); DataUtil.AddDatabaseObject(virtualScriptFilePath, addHeirarchicalTerm); Term term = new Term(2) { Name = "Plasma", ParentTermId = 1 /*Televisions*/, Weight = 0, Description = "Plasma" }; DataService ds = new DataService(); //Act int newTermId = ds.AddHeirarchicalTerm(term, Constants.USER_ValidId); //Assert DatabaseAssert.RecordCountIsEqual(DataTestHelper.ConnectionString, ContentDataTestHelper.TermsTableName, rowCount + 1); DatabaseAssert.RecordLastAddedIdEquals(DataTestHelper.ConnectionString, ContentDataTestHelper.TermsTableName, "TermID", newTermId); //Assert that new term is correct as middle child of televisions TestTerm(newTermId, 15, 16); //Assert that existing terms are correct //Televisions, Id = 1, Left=12, Right=17 - should be Left=12, Right=19 TestTerm(1, 12, 19); //Flash, Id = 9, Left=8, Right=9 - should be Left=8, Right=9 TestTerm(9, 8, 9); //Electronics, Id = 12, Left=1, Right=18 - should be Left=1, Right=20 TestTerm(12, 1, 20); }
/// <summary> /// Adds the content of the term to. /// </summary> /// <param name="term">The term.</param> /// <param name="contentItem">The content item.</param> /// <exception cref="System.ArgumentNullException">term is null.</exception> /// <exception cref="System.ArgumentNullException">content item is null.</exception> public void AddTermToContent(Term term, ContentItem contentItem) { //Argument Contract Requires.NotNull("term", term); Requires.NotNull("contentItem", contentItem); _DataService.AddTermToContent(term, contentItem); }
public void DataService_UpdateHeirarchicalTerm_Updates_Records_On_Change_Parent_To_Sibling_Of_Parent() { //Arrange int rowCount = DataUtil.GetRecordCount(DataTestHelper.ConnectionString, ContentDataTestHelper.TermsTableName); DataUtil.AddDatabaseObject(virtualScriptFilePath, updateHeirarchicalTerm); Term term = new Term(2) { TermId = 6, Name = "MP3 Players", ParentTermId = 12 /*Electronics*/, Weight = 0, Description = "MP3 Players" }; DataService ds = new DataService(); //Act ds.UpdateHeirarchicalTerm(term, Constants.USER_ValidId); //Assert DatabaseAssert.RecordCountIsEqual(DataTestHelper.ConnectionString, ContentDataTestHelper.TermsTableName, rowCount); //Assert that existing terms are correct //Televisions, Id = 1, Left=12, Right=17 - should be Left=12, Right=17 TestTerm(1, 12, 17); //2-Way, Id = 8, Left=3, Right=4 - should be Left=7, Right=8 TestTerm(8, 7, 8); //Electronics, Id = 12, Left=1, Right=18 - should be Left=1, Right=18 TestTerm(12, 1, 18); //MP3 Players, Id = 6, Left=7, Right=10 - should be Left=2, Right=5 TestTerm(6, 2, 5); //Flash Players, Id = 9, Left=8, Right=9 - should be Left=3, Right=4 TestTerm(9, 3, 4); }
/// <summary> /// Deletes the term. /// </summary> /// <param name="term">The term.</param> /// <exception cref="System.ArgumentNullException">term is null.</exception> /// <exception cref="System.ArgumentOutOfRangeException">term.TermId is less than 0.</exception> public void DeleteTerm(Term term) { //Argument Contract Requires.NotNull("term", term); Requires.PropertyNotNegative("term", "TermId", term.TermId); if ((term.IsHeirarchical)) { _DataService.DeleteHeirarchicalTerm(term); } else { _DataService.DeleteSimpleTerm(term); } //Clear Cache DataCache.RemoveCache(string.Format(_CacheKey, term.VocabularyId)); }
/// <summary> /// Adds the term. /// </summary> /// <param name="term">The term.</param> /// <returns>term id.</returns> /// <exception cref="System.ArgumentNullException">term is null.</exception> /// <exception cref="System.ArgumentOutOfRangeException">term.VocabularyId is less than 0.</exception> /// <exception cref="System.ArgumentException">term.Name is empty.</exception> public int AddTerm(Term term) { //Argument Contract Requires.NotNull("term", term); Requires.PropertyNotNegative("term", "VocabularyId", term.VocabularyId); Requires.PropertyNotNullOrEmpty("term", "Name", term.Name); if ((term.IsHeirarchical)) { term.TermId = _DataService.AddHeirarchicalTerm(term, UserController.GetCurrentUserInfo().UserID); } else { term.TermId = _DataService.AddSimpleTerm(term, UserController.GetCurrentUserInfo().UserID); } //Clear Cache DataCache.RemoveCache(string.Format(_CacheKey, term.VocabularyId)); return term.TermId; }
private static void ImportDocumentLibraryCategoryAssoc(ContentType fileContentType) { DataProvider dataProvider = DataProvider.Instance(); IDataReader dr; try { dr = dataProvider.ExecuteReader("ImportDocumentLibraryCategoryAssoc"); var termController = new TermController(); var vocabulary = new VocabularyController().GetVocabularies().Single(v => v.Name == "Tags"); var terms = termController.GetTermsByVocabulary(vocabulary.VocabularyId); while (dr.Read()) { var file = FileManager.Instance.GetFile((int)dr["FileId"]); ContentItem attachContentItem; if (file.ContentItemID == Null.NullInteger) { attachContentItem = CreateFileContentItem(); file.ContentItemID = attachContentItem.ContentItemId; FileManager.Instance.UpdateFile(file); } else { attachContentItem = Util.GetContentController().GetContentItem(file.ContentItemID); } var term = terms.SingleOrDefault(t => t.Name == dr["CategoryName"].ToString()); if (term == null) { term = new Term(dr["CategoryName"].ToString(), null, vocabulary.VocabularyId); termController.AddTerm(term); } termController.AddTermToContent(term, attachContentItem); } } catch (Exception ex) { Logger.Error(ex); } }
public void DataService_AddHeirarchicalTerm_Inserts_Record_As_First_Child_On_Valid_Term() { //Arrange int rowCount = DataUtil.GetRecordCount(DataTestHelper.ConnectionString, ContentDataTestHelper.TermsTableName); DataUtil.AddDatabaseObject(virtualScriptFilePath, addHeirarchicalTerm); Term term = new Term(2) { Name = "Game Console", ParentTermId = 12 /*Electronics*/, Weight = 0, Description = "Game Consoles like X-Box 360" }; DataService ds = new DataService(); //Act int newTermId = ds.AddHeirarchicalTerm(term, Constants.USER_ValidId); //Assert DatabaseAssert.RecordCountIsEqual(DataTestHelper.ConnectionString, ContentDataTestHelper.TermsTableName, rowCount + 1); DatabaseAssert.RecordLastAddedIdEquals(DataTestHelper.ConnectionString, ContentDataTestHelper.TermsTableName, "TermID", newTermId); //Assert that new term is correct as first child of electronics TestTerm(newTermId, 2, 3); //Assert that existing terms are correct //Televisions, Id = 1, Left=12, Right=17 - should be Left=14, Right=19 TestTerm(1, 14, 19); //Flash, Id = 9, Left=8, Right=9 - should be Left=10, Right=11 TestTerm(9, 10, 11); //Electronics, Id = 12, Left=1, Right=18 - should be Left=1, Right=20 TestTerm(12, 1, 20); }