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);
}
