public void TermController_GetTermsByVocabulary_Returns_Terms_On_Valid_VocabularyId() { // Arrange var mockDataService = new Mock <IDataService>(); mockDataService.Setup(ds => ds.GetTermsByVocabulary(Constants.TERM_ValidVocabulary1)).Returns(MockHelper.CreateValidTermsReader( Constants.TERM_ValidCountForVocabulary1, v => Constants.TERM_ValidVocabulary1, c => Constants.TERM_ValidContent1)); MockComponentProvider.CreateDataProvider().Setup(c => c.GetProviderPath()).Returns(string.Empty); var termController = new TermController(mockDataService.Object); // Act var terms = termController.GetTermsByVocabulary(Constants.TERM_ValidVocabulary1).ToList(); // Assert Assert.AreEqual(Constants.TERM_ValidCountForVocabulary1, terms.Count); for (int i = 0; i < Constants.TERM_ValidCountForVocabulary1; i++) { Assert.AreEqual(i + Constants.TERM_ValidTermId, terms[i].TermId); Assert.AreEqual(ContentTestHelper.GetTermName(i + Constants.TERM_ValidTermId), terms[i].Name); } }
public static void UpdateTerm(this IDivision division, IModelContext modelContext) { var termName = GetSafeTermName(division.ShortTitle, division.Title); try { var parentDivision = division.GetParentDivision(modelContext); if (division.DivisionTermID != null) { var termCtrl = new TermController(); var term = termCtrl.GetTerm(division.DivisionTermID.Value); if (term != null) { term.Name = termName; if (parentDivision != null) { term.ParentTermId = parentDivision.DivisionTermID; } termCtrl.UpdateTerm(term); } } } catch (Exception ex) { Exceptions.LogException(new Exception($"Error updating {termName} term.", ex)); } }
public VocabulariesController() { this._termController = new TermController(); this._vocabularyController = new VocabularyController(); this._validator = new Validator(new DataAnnotationsObjectValidator()); this._validator.Validators.Add(new VocabularyNameValidator(this._vocabularyController, this._termController)); }
public void SaveTerm(object sender, EventArgs e) { //First Bind the term so we can get the current values from the View View.BindTerm(View.Model.Term, View.Model.Terms, IsHeirarchical, true, IsEditEnabled); var result = Validator.ValidateObject(View.Model.Term); if (result.IsValid) { if (View.Model.Term.TermId == Null.NullInteger) { TermController.AddTerm(View.Model.Term); } else { TermController.UpdateTerm(View.Model.Term); } RefreshTerms(); } else { ShowMessage("TermValidationError", ModuleMessage.ModuleMessageType.RedError); } }
// TODO: Need separate methods to get and update public static string Update(DropDownList comboWorkingHours, string workingHours, bool addToVocabulary) { workingHours = workingHours.Trim(); var workingHoursNonEmpty = !string.IsNullOrWhiteSpace(workingHours); if (comboWorkingHours.SelectedIndex <= 0 || workingHoursNonEmpty) { // TODO: Shouldn't we try to add term after updating main item? if (addToVocabulary && workingHoursNonEmpty) { // try add new term to working hours vocabulary var vocCtrl = new VocabularyController(); var voc = vocCtrl.GetVocabularies().SingleOrDefault(v => v.Name == UniversityConfig.Instance.Vocabularies.WorkingHours); if (voc != null) { var termCtrl = new TermController(); termCtrl.AddTerm(new Term(workingHours, "", voc.VocabularyId)); vocCtrl.ClearVocabularyCache(); } } return(workingHours); } // else: get working hours from a combo return(comboWorkingHours.SelectedItem.Text); }
public async void GetById_ErrorMessage_Id() { Mock <ITermQueryService> termQueryService = new Mock <ITermQueryService>(); TermController controller = new TermController(termQueryService.Object); var exception = await Assert.ThrowsAsync <APIErrorException>(() => controller.GetById("Dictionary", AudienceType.Patient, "EN", 0L, new string[] {})); Assert.Equal("You must supply a valid dictionary, audience, language and id", exception.Message); }
public ContentImpl() { var dataService = new DataService(); _typeController = new ContentTypeController(dataService); _contentController = new ContentController(dataService); _termController = new TermController(dataService); }
private void RefreshTerms() { View.Model.Terms = TermController.GetTermsByVocabulary(VocabularyId).ToList(); View.BindTerms(View.Model.Terms, IsHeirarchical, true); View.Model.Term = null; View.ClearSelectedTerm(); View.ShowTermEditor(false); }
public static int?AddOrUpdateTerm(this IDivision division, IModelContext modelContext) { var vocabularyName = UniversityConfig.Instance.Vocabularies.OrgStructure; var vocabulary = new VocabularyController().GetVocabularies().FirstOrDefault(v => v.Name == vocabularyName); if (vocabulary == null) { Exceptions.LogException(new Exception($"Could not find the {vocabularyName} vocabulary.")); return(null); } var termName = GetSafeTermName(division.ShortTitle, division.Title); var termCtrl = new TermController(); var term = default(Term); if (division.DivisionTermID == null) { term = termCtrl.GetTermsByVocabulary(vocabulary.VocabularyId).FirstOrDefault(t => t.Name == termName); if (term != null) { Exceptions.LogException(new Exception($"Could not create term {termName} in the {vocabularyName} vocabulary as it already exists.")); return(null); } term = new Term(termName, string.Empty, vocabulary.VocabularyId); } else { term = termCtrl.GetTerm(division.DivisionTermID.Value); term.Name = termName; } var parentDivision = division.GetParentDivision(modelContext); if (parentDivision != null) { term.ParentTermId = parentDivision.DivisionTermID; } else { term.ParentTermId = null; } try { if (division.DivisionTermID == null) { return(termCtrl.AddTerm(term)); } termCtrl.UpdateTerm(term); return(term.TermId); } catch (Exception ex) { Exceptions.LogException(new Exception($"Error creating/updating {termName} term in the vocabulary {vocabularyName}.", ex)); } return(null); }
public void TermController_GetTermsByContent_Throws_On_Invalid_ContentItemId() { //Arrange var mockDataService = new Mock <IDataService>(); var termController = new TermController(mockDataService.Object); //Act, Arrange Assert.Throws <ArgumentOutOfRangeException>(() => termController.GetTermsByContent(Null.NullInteger)); }
public void TermController_GetTermsByVocabulary_Throws_On_Invalid_VocabularyName() { //Arrange var mockDataService = new Mock <IDataService>(); var termController = new TermController(mockDataService.Object); //Act, Arrange Assert.Throws <ArgumentException>(() => termController.GetTermsByVocabulary(Null.NullString)); }
public void TermController_RemoveTermsFromContent_Throws_On_Null_ContentItem() { //Arrange var mockDataService = new Mock <IDataService>(); var termController = new TermController(mockDataService.Object); //Act, Arrange Assert.Throws <ArgumentNullException>(() => termController.RemoveTermsFromContent(null)); }
public void TermController_AddTerm_Throws_On_Null_Term() { //Arrange var mockDataService = new Mock <IDataService>(); var termController = new TermController(mockDataService.Object); //Act, Arrange Assert.Throws <ArgumentNullException>(() => termController.AddTerm(null)); }
protected override void OnInit() { base.OnInit(); if (View.Model.Vocabulary == null) { View.Model.Vocabulary = VocabularyController.GetVocabularies().Where(v => v.VocabularyId == VocabularyId).SingleOrDefault(); View.Model.Terms = TermController.GetTermsByVocabulary(VocabularyId).ToList(); } }
public static void Init(PortalModuleBase module, DropDownList comboWorkingHours) { // fill working hours terms var termCtrl = new TermController(); var workingHours = termCtrl.GetTermsByVocabulary(UniversityConfig.Instance.Vocabularies.WorkingHours).ToList(); workingHours.Insert(0, new Term(Localization.GetString("NotSelected.Text", module.LocalResourceFile))); comboWorkingHours.DataSource = workingHours; comboWorkingHours.DataBind(); }
public static void DeleteTerm(int termId) { var termCtrl = new TermController(); var term = termCtrl.GetTerm(termId); if (term != null) { termCtrl.DeleteTerm(term); } }
public void TermController_AddTermToContent_Throws_On_Null_ContentItem() { //Arrange var mockDataService = new Mock <IDataService>(); var termController = new TermController(mockDataService.Object); Term term = ContentTestHelper.CreateValidSimpleTerm(Constants.VOCABULARY_ValidVocabularyId); //Act, Arrange Assert.Throws <ArgumentNullException>(() => termController.AddTermToContent(term, null)); }
public void TermController_AddTermToContent_Throws_On_Null_Term() { //Arrange var mockDataService = new Mock <IDataService>(); var termController = new TermController(mockDataService.Object); ContentItem content = ContentTestHelper.CreateValidContentItem(); //Act, Arrange Assert.Throws <ArgumentNullException>(() => termController.AddTermToContent(null, content)); }
public void TermController_AddTerm_Throws_On_Negative_VocabularyId() { //Arrange var mockDataService = new Mock <IDataService>(); var termController = new TermController(mockDataService.Object); Term term = ContentTestHelper.CreateValidSimpleTerm(Null.NullInteger); //Act, Arrange Assert.Throws <ArgumentOutOfRangeException>(() => termController.AddTerm(term)); }
public static ITermController GetTermController() { ITermController ctl = ComponentFactory.GetComponent <ITermController>(); if (ctl == null) { ctl = new TermController(); ComponentFactory.RegisterComponentInstance <ITermController>(ctl); } return(ctl); }
public void TermController_GetTermsByVocabulary_Throws_On_Invalid_VocabularyId() { //Arrange var mockDataService = new Mock <IDataService>(); MockComponentProvider.CreateDataProvider().Setup(c => c.GetProviderPath()).Returns(String.Empty); var termController = new TermController(mockDataService.Object); //Act, Arrange Assert.Throws <ArgumentOutOfRangeException>(() => termController.GetTermsByVocabulary(Null.NullInteger)); }
public string GetUrl(int termId, TermController termController) { var term = termController.GetTerm(termId); if (term != null) { return(GetUrl(term)); } return(string.Empty); }
public string GetUrl(int termId, TermController termController) { var division = GetDivisions() .FirstOrDefault(d => d.DivisionTermId == termId); if (division != null) { return(division.HomePage); } return(string.Empty); }
public void TermController_AddTerm_Throws_On_Invalid_Term() { //Arrange var mockDataService = new Mock <IDataService>(); var termController = new TermController(mockDataService.Object); Term term = ContentTestHelper.CreateValidSimpleTerm(Constants.VOCABULARY_ValidVocabularyId); term.Name = Constants.TERM_InValidName; //Act, Arrange Assert.Throws <ArgumentException>(() => termController.AddTerm(term)); }
public void TermController_DeleteTerm_Throws_On_Negative_TermId() { //Arrange var mockDataService = new Mock <IDataService>(); var termController = new TermController(mockDataService.Object); var term = ContentTestHelper.CreateValidSimpleTerm(Constants.VOCABULARY_ValidVocabularyId); term.TermId = Null.NullInteger; //Act, Arrange Assert.Throws <ArgumentOutOfRangeException>(() => termController.DeleteTerm(term)); }
public void TermController_AddTerm_Clears_Term_Cache_On_Valid_Term() { //Arrange var mockDataService = new Mock <IDataService>(); var termController = new TermController(mockDataService.Object); Term term = ContentTestHelper.CreateValidSimpleTerm(Constants.VOCABULARY_ValidVocabularyId); //Act termController.AddTerm(term); //Assert mockCache.Verify(cache => cache.Remove(String.Format(Constants.TERM_CacheKey, Constants.VOCABULARY_ValidVocabularyId))); }
public void TermController_AddTerm_Should_Call_DataService_AddHeirarchicalTerm_If_Term_Is_Heirarchical_Term() { //Arrange var mockDataService = new Mock <IDataService>(); var termController = new TermController(mockDataService.Object); Term term = ContentTestHelper.CreateValidHeirarchicalTerm(Constants.VOCABULARY_HierarchyVocabularyId, Constants.TERM_ValidParentTermId); // Act int termId = termController.AddTerm(term); // Assert mockDataService.Verify(ds => ds.AddHeirarchicalTerm(term, UserController.Instance.GetCurrentUserInfo().UserID)); }
public void TermController_RemoveTermsFromContent_Should_Call_DataService_If_Valid_Params() { //Arrange var mockDataService = new Mock <IDataService>(); var termController = new TermController(mockDataService.Object); ContentItem content = ContentTestHelper.CreateValidContentItem(); // Act termController.RemoveTermsFromContent(content); // Assert mockDataService.Verify(ds => ds.RemoveTermsFromContent(content)); }
public void TermController_GetTerm_Calls_DataService() { //Arrange var mockDataService = new Mock <IDataService>(); mockDataService.Setup(ds => ds.GetTerm(Constants.TERM_ValidTermId)).Returns(MockHelper.CreateValidTermReader()); var termController = new TermController(mockDataService.Object); //Act Term term = termController.GetTerm(Constants.TERM_ValidTermId); //Assert mockDataService.Verify(ds => ds.GetTerm(Constants.TERM_ValidTermId)); }
public static string GetUrl(int termId) { var termController = new TermController(); foreach (var provider in NewsConfig.Instance.GetTermUrlProviders()) { var url = provider.GetUrl(termId, termController); if (!string.IsNullOrEmpty(url)) { return(url); } } return(string.Empty); }