public async Task <GlossaryTermResults> getAll(string dictionary, AudienceType audience, string language, int size = 10, int from = 0, string[] requestedFields = null) { if (String.IsNullOrWhiteSpace(dictionary) || String.IsNullOrWhiteSpace(language) || !Enum.IsDefined(typeof(AudienceType), audience)) { throw new APIErrorException(400, "You must specify a dictionary, audience, and language."); } if (language.ToLower() != "en" && language.ToLower() != "es") { throw new APIErrorException(404, "Unsupported Language. Please try either 'en' or 'es'"); } if (size <= 0) { size = 20; } if (from < 0) { from = 0; } if (requestedFields == null || requestedFields.Length == 0) { requestedFields = new string[] { "TermName", "Pronunciation", "Definition" } } ; GlossaryTermResults res = await _termsQueryService.getAll(dictionary, audience, language, size, from, requestedFields); return(res); }
public Audience(AudienceType type, String value) { switch (type) { case AudienceType.Android: AndroidDeviceId = value; break; case AudienceType.Ios: IosDeviceId = value; break; case AudienceType.Windows: WindowsId = value; break; case AudienceType.WindowsPhone: WindowsPhoneId = value; break; case AudienceType.Blackberry: BlackberryId = value; break; case AudienceType.Segment: SegmentId = value; break; case AudienceType.Alias: Alias = value; break; case AudienceType.Tag: Tag = value; break; } }
/// <summary> /// Infrastructure method for retrieving the "dictionary" parameter, returning appropriate Audience-aware /// default values if dictionary is not otherwise set. /// </summary> /// <returns>The value of the "dictionary" parameter.</returns> protected DictionaryType GetDictionaryWithDefaults() { String rawValue = GetOptionalParameter("dictionary"); rawValue = Strings.Clean(rawValue, "Unknown"); DictionaryType val = ConvertEnum <DictionaryType> .Convert(rawValue, DictionaryType.Unknown); if (val == DictionaryType.Unknown) { // is dictionary is unknown, check Audience and set default value String audienceValue = GetOptionalParameter("audience"); audienceValue = Strings.Clean(audienceValue, "Unknown"); AudienceType audience = ConvertEnum <AudienceType> .Convert(audienceValue, AudienceType.Unknown); switch (audience) { case AudienceType.HealthProfessional: val = DictionaryType.NotSet; break; default: val = DictionaryType.term; break; } } return(val); }
public async void Count_QueryValues(string dictionary, AudienceType audience, string language) { Mock <ITermsQueryService> querySvc = new Mock <ITermsQueryService>(); TermsController controller = new TermsController(NullLogger <TermsController> .Instance, querySvc.Object); // Set up the mock query service to handle the GetCount() call. // The return value is unimportant for this test. querySvc.Setup( mock => mock.GetCount( It.IsAny <string>(), It.IsAny <AudienceType>(), It.IsAny <string>() ) ) .Returns(Task.FromResult(default(long))); long result = await controller.GetCount(dictionary, audience, language); // Verify that the service layer is called: // a) with the expected values. // b) exactly once. querySvc.Verify( svc => svc.GetCount(dictionary, audience, language), Times.Once ); }
public async Task <GlossaryTermResults> Expand(string dictionary, AudienceType audience, string language, string character, [FromQuery] int size = 100, [FromQuery] int from = 0, [FromQuery] bool includeAdditionalInfo = false) { if (String.IsNullOrWhiteSpace(dictionary) || String.IsNullOrWhiteSpace(language) || !Enum.IsDefined(typeof(AudienceType), audience)) { throw new APIErrorException(400, "You must supply a valid dictionary, audience and language"); } if (language.ToLower() != "en" && language.ToLower() != "es") { throw new APIErrorException(400, "Unsupported Language. Please try either 'en' or 'es'"); } if (size <= 0) { size = 100; } if (from < 0) { from = 0; } GlossaryTermResults res = await _termsQueryService.Expand(dictionary, audience, language, character, size, from, includeAdditionalInfo); return(res); }
/// <summary> /// Performs a query for items from the DictionaryEntryMetadata list that are valid in the database.. /// </summary> /// <param name="entriesList">A list of DictionaryEntryMetadata items, whose existence in the DB will be checked.</param> /// <returns>A list of DictionaryEntryMetadata items.</returns> public List <DictionaryEntryMetadata> DoDictionaryEntriesExist(List <DictionaryEntryMetadata> entriesList) { // In the initial implementation, the audience is implied by the particular dictionary being used. foreach (DictionaryEntryMetadata entry in entriesList) { AudienceType audience = GetDefaultAudienceFromDictionaryType(entry.Dictionary); entry.Audience = audience; } // Query that returns which DictionaryEntryMetadata items in the given list are valid in the database DictionaryQuery query = new DictionaryQuery(); DataTable results = query.DoDictionaryEntriesExist(entriesList); List <DictionaryEntryMetadata> validEntries = new List <DictionaryEntryMetadata>(); // Converts the datatable of entries into a list of DictionaryEntryMetadata items foreach (DataRow row in results.Rows) { DictionaryEntryMetadata entry = new DictionaryEntryMetadata(); entry.CDRID = row.Field <int>("CDRID"); entry.Dictionary = (DictionaryType)System.Enum.Parse(typeof(DictionaryType), row.Field <string>("Dictionary")); entry.Language = (Language)System.Enum.Parse(typeof(Language), row.Field <string>("Language")); entry.Audience = (AudienceType)System.Enum.Parse(typeof(AudienceType), row.Field <string>("Audience")); validEntries.Add(entry); } return(validEntries); }
/// <summary> /// Perform a search for terms with names or aliases that start with searchText, sorted by the matched term name or alias. /// </summary> /// <param name="searchText">text to search for.</param> /// <param name="includeTypes">A filter for the types of name aliases to include. Multiple values are separated by the pipe character (|). /// If no filter is supplied, the result </param> /// <param name="offset">Offset into the list of matches for the first result to return.</param> /// <param name="numResults">The maximum number of results to return. Must be at least 10.</param> /// <param name="dictionary">The dictionary to retreive the Term from. /// Valid values are /// Term - Dictionary of Cancer Terms /// drug - Drug Dictionary /// genetic - Dictionary of Genetics Terms /// </param> /// <param name="language">The Term's desired language. /// Supported values are: /// en - English /// es - Spanish /// </param> /// <param name="version">String identifying which vereion of the JSON structure to retrieve.</param> /// <returns>An object structure containing the results of the search and various metadata.</returns> public SearchReturn Expand(String searchText, String includeTypes, int offset, int numResults, DictionaryType dictionary, Language language, String version) { log.Debug("Enter ValidateSearchSuggest()."); // Sanity check for the offset and numResults if (offset < 0) { offset = 0; } if (numResults < 10) { numResults = 200; } // In the initial implementation, the audience is implied by the particular dictionary being used. AudienceType audience = GetDefaultAudienceFromDictionaryType(dictionary); // Convert delimited list to an array of distinct values. String[] includeFilter = Strings.ToListOfTrimmedStrings(includeTypes, LIST_DELIMITER); DictionaryQuery query = new DictionaryQuery(); SearchResults results = query.Expand(searchText, includeFilter, offset, numResults, dictionary, language, audience, version); return(BuildSearchResultsStructure(results, language, audience, offset)); }
public async Task <Suggestion[]> GetSuggestions(string dictionary, AudienceType audience, string language, string query, [FromQuery] bool contains = false, [FromQuery] int size = 20, [FromQuery] int from = 0) { if (String.IsNullOrWhiteSpace(dictionary) || String.IsNullOrWhiteSpace(language) || !Enum.IsDefined(typeof(AudienceType), audience)) { throw new APIErrorException(400, "You must supply a valid dictionary, audience and language."); } if (language.ToLower() != "en" && language.ToLower() != "es") { throw new APIErrorException(404, "Unsupported Language. Valid values are 'en' and 'es'."); } if (size <= 0) { size = 20; } if (from < 0) { from = 0; } return(await _autosuggestQueryService.GetSuggestions(dictionary, audience, language, query, contains, size, from)); }
/// <summary> /// Get Term details based on the input values /// <param name="dictionary">The value for dictionary.</param> /// <param name="audience">Patient or Healthcare provider</param> /// <param name="language">The language in which the details needs to be fetched</param> /// <param name="id">The Id for the term</param> /// <returns>An object of GlossaryTerm</returns> /// </summary> public async Task <GlossaryTerm> GetById(string dictionary, AudienceType audience, string language, long id) { IGetResponse <GlossaryTerm> response = null; try { string idValue = $"{id}_{dictionary?.ToLower()}_{language?.ToLower()}_{audience.ToString().ToLower()}"; response = await _elasticClient.GetAsync <GlossaryTerm>(new DocumentPath <GlossaryTerm>(idValue), g => g.Index( this._apiOptions.AliasName ).Type("terms")); } catch (Exception ex) { String msg = $"Could not search dictionary '{dictionary}', audience '{audience}', language '{language}' and id '{id}."; _logger.LogError($"Error searching index: '{this._apiOptions.AliasName}'."); _logger.LogError(ex, msg); throw new APIErrorException(500, msg); } if (!response.IsValid) { String msg = $"Invalid response when searching for dictionary '{dictionary}', audience '{audience}', language '{language}' and id '{id}."; _logger.LogError(msg); throw new APIErrorException(500, msg); } if (null == response.Source) { string msg = $"No match for dictionary '{dictionary}', audience '{audience}', language '{language}' and id '{id}."; _logger.LogDebug(msg); throw new APIErrorException(404, msg); } return(response.Source); }
public async void Verify_Argument_passing(string dictionary, AudienceType audience, string language, string queryText, MatchType matchType) { const int expecedSizeRequest = 20; Mock <IAutosuggestQueryService> querySvc = new Mock <IAutosuggestQueryService>(); AutosuggestController controller = new AutosuggestController(querySvc.Object); // Set up the mock query service to return an empty array. querySvc.Setup( autoSuggestQSvc => autoSuggestQSvc.GetSuggestions( It.IsAny <string>(), It.IsAny <AudienceType>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <MatchType>(), It.IsAny <int>() ) ) .Returns(Task.FromResult(new Suggestion[] { })); Suggestion[] result = await controller.GetSuggestions(dictionary, audience, language, queryText, matchType); // Verify that the service layer is called: // a) with the exact values passed to the controller. // b) exactly once. querySvc.Verify( svc => svc.GetSuggestions(dictionary, audience, language, queryText, matchType, expecedSizeRequest), Times.Once ); Assert.Empty(result); }
/// <summary> /// Translates values of type NCI.Web.Dictionary.AudienceType. /// to values of the type NCI.Services.Dictionary.AudienceType. /// </summary> /// <param name="dictionary">The NCI.Web.Dictionary.AudienceType value to be translated.</param> /// <returns>A value of type NCI.Services.Dictionary.AudienceType.</returns> public static svcAudienceType Translate(AudienceType xlate) { svcAudienceType audience; switch (xlate) { case AudienceType.Unknown: audience = svcAudienceType.Unknown; break; case AudienceType.HealthProfessional: audience = svcAudienceType.HealthProfessional; break; case AudienceType.Patient: audience = svcAudienceType.Patient; break; break; default: throw new ArgumentException(String.Format("Uknown type '{0}'.", xlate)); } return(audience); }
/// <summary> /// Infrastructure method for retrieving the "audience" parameter, returning appropriate Dictionary-aware /// default values if audience is not otherwise set. /// </summary> /// <returns>The value of the "audience" parameter.</returns> protected AudienceType GetAudienceWithDefaults() { String rawValue = GetOptionalParameter("audience"); rawValue = Strings.Clean(rawValue, "Unknown"); AudienceType val = ConvertEnum <AudienceType> .Convert(rawValue, AudienceType.Unknown); if (val == AudienceType.Unknown) { // is dictionary is unknown, check Audience and set default value String dictionaryValue = GetOptionalParameter("dictionary"); dictionaryValue = Strings.Clean(dictionaryValue, "Unknown"); DictionaryType dictionary = ConvertEnum <DictionaryType> .Convert(dictionaryValue, DictionaryType.Unknown); switch (dictionary) { case DictionaryType.NotSet: case DictionaryType.genetic: val = AudienceType.HealthProfessional; break; default: val = AudienceType.Patient; break; } } return(val); }
public async Task <GlossaryTermResults> GetAll(string dictionary, AudienceType audience, string language, int size = 100, int from = 0, bool includeAdditionalInfo = false) { if (String.IsNullOrWhiteSpace(dictionary) || String.IsNullOrWhiteSpace(language) || !Enum.IsDefined(typeof(AudienceType), audience)) { throw new APIErrorException(400, "You must supply a valid dictionary, audience and language."); } if (language.ToLower() != "en" && language.ToLower() != "es") { throw new APIErrorException(400, "Unsupported Language. Valid values are 'en' and 'es'."); } if (size <= 0) { size = 100; } if (from < 0) { from = 0; } GlossaryTermResults res = await _termsQueryService.GetAll(dictionary, audience, language, size, from, includeAdditionalInfo); return(res); }
public async Task <GlossaryTermResults> Search(string dictionary, AudienceType audience, string language, string query, [FromQuery] MatchType matchType = MatchType.Begins, [FromQuery] int size = 100, [FromQuery] int from = 0, [FromQuery] bool includeAdditionalInfo = false) { if (String.IsNullOrWhiteSpace(dictionary) || String.IsNullOrWhiteSpace(language) || !Enum.IsDefined(typeof(AudienceType), audience)) { throw new APIErrorException(400, "You must supply a valid dictionary, audience and language."); } if (language.ToLower() != "en" && language.ToLower() != "es") { throw new APIErrorException(400, "Unsupported Language. Valid values are 'en' and 'es'."); } if (!Enum.IsDefined(typeof(MatchType), matchType)) { throw new APIErrorException(400, "Invalid value for the 'matchType' parameter."); } if (size <= 0) { size = 100; } if (from < 0) { from = 0; } // query uses a catch-all route, make sure it's been decoded. query = WebUtility.UrlDecode(query); GlossaryTermResults res = await _termsQueryService.Search(dictionary, audience, language, query, matchType, size, from, includeAdditionalInfo); return(res); }
public async Task <Suggestion[]> GetSuggestions(string dictionary, AudienceType audience, string language, string searchText, [FromQuery] MatchType matchType = MatchType.Begins, [FromQuery] int size = 20) { if (String.IsNullOrWhiteSpace(dictionary) || String.IsNullOrWhiteSpace(language) || !Enum.IsDefined(typeof(AudienceType), audience)) { throw new APIErrorException(400, "You must supply a valid dictionary, audience and language."); } if (!Enum.IsDefined(typeof(MatchType), matchType)) { throw new APIErrorException(400, "The 'matchType' parameter must be either 'Begins' or 'Contains'."); } if (language.ToLower() != "en" && language.ToLower() != "es") { throw new APIErrorException(400, "Unsupported Language. Valid values are 'en' and 'es'."); } if (size <= 0) { size = 20; } // searchText uses a catch-all route, make sure it's been decoded. searchText = WebUtility.UrlDecode(searchText); return(await _autosuggestQueryService.GetSuggestions(dictionary, audience, language, searchText, matchType, size)); }
/// <summary> /// Get Term deatils based on the input values /// <param name="dictionary">The value for dictionary.</param> /// <param name="audience">Patient or Healthcare provider</param> /// <param name="language">The language in which the details needs to be fetched</param> /// <param name="id">The Id for the term</param> /// <param name="requestedFields"> The list of fields that needs to be sent in the response</param> /// <returns>An object of GlossaryTerm</returns> /// </summary> public async Task <GlossaryTerm> GetById(string dictionary, AudienceType audience, string language, long id, string[] requestedFields) { IGetResponse <GlossaryTerm> response = null; try { string idValue = id + "_" + dictionary + "_" + language + "_" + audience.ToString().ToLower(); response = await _elasticClient.GetAsync <GlossaryTerm>(new DocumentPath <GlossaryTerm>(idValue), g => g.Index( this._apiOptions.AliasName ).Type("terms")); } catch (Exception ex) { String msg = String.Format("Could not search dictionary '{0}', audience '{1}', language '{2}' and id '{3}.", dictionary, audience, language, id); _logger.LogError(msg, ex); throw new APIErrorException(500, msg); } if (!response.IsValid) { String msg = String.Format("Invalid response when searching for dictionary '{0}', audience '{1}', language '{2}' and id '{3}.", dictionary, audience, language, id); _logger.LogError(msg); throw new APIErrorException(500, msg); } if (null == response.Source) { string msg = String.Format("Empty response when searching for dictionary '{0}', audience '{1}', language '{2}' and id '{3}.", dictionary, audience, language, id); _logger.LogError(msg); throw new APIErrorException(200, msg); } return(response.Source); }
/// <summary> /// Calls the database to retrieve a single dictionary term based on its specific Term ID. /// Similar, but not identical, to GetTerm(). Instead of retrieving the term for a specific /// dictionary, the term is fetched for a preferred audience. If no records are available for that audience, /// then any other avaiable records are returned instead. /// </summary> /// <param name="termId">The ID of the Term to be retrieved</param> /// <param name="language">The Term's desired language. /// Supported values are: /// en - English /// es - Spanish /// </param> /// <param name="preferredAudience">Preferred target audieince for the definition.</param> /// <param name="version">String identifying which vereion of the API to match.</param> /// <returns></returns> public DataTable GetTermForAudience(int termId, Language language, AudienceType preferredAudience, String version) { log.DebugFormat("Enter GetTermForAudience( {0}, {1}, {2}, {3} ).", termId, language, preferredAudience, version); DataTable results = null; SqlParameter[] parameters = new SqlParameter[] { new SqlParameter("@TermID", SqlDbType.Int) { Value = termId }, new SqlParameter("@Language", SqlDbType.NVarChar) { Value = language.ToString() }, new SqlParameter("@PreferredAudience", SqlDbType.NVarChar) { Value = preferredAudience.ToString() }, new SqlParameter("@ApiVers", SqlDbType.NVarChar) { Value = version }, }; using (SqlConnection conn = SqlHelper.CreateConnection(DBConnectionString)) { results = SqlHelper.ExecuteDatatable(conn, CommandType.StoredProcedure, SP_GET_DICTIONARY_TERM_FOR_AUDIENCE, parameters); } return(results); }
/// <summary> /// Retrieves a portion of the overall set of glossary terms for a given combination of dictionary, audience, and language. /// </summary> /// <param name="dictionary">The specific dictionary to retrieve from.</param> /// <param name="audience">The target audience.</param> /// <param name="language">Language (English - en; Spanish - es).</param> /// <param name="size">The number of records to retrieve.</param> /// <param name="from">The offset into the overall set to use for the first record.</param> /// <param name="requestedFields">The fields to retrieve. If not specified, defaults to TermName, Pronunciation, and Definition.</param> /// <returns>A GlossaryTermResults object containing the desired records.</returns> public async Task <GlossaryTermResults> getAll(string dictionary, AudienceType audience, string language, int size, int from, string[] requestedFields) { // Dummy return for now. GlossaryTermResults results = new GlossaryTermResults() { Meta = new ResultsMetadata() { TotalResults = 200, From = 20 }, Links = new Metalink() { Self = new System.Uri("https://www.cancer.gov") }, Results = new GlossaryTerm[] { new GlossaryTerm() { TermId = 43966, Language = "en", Dictionary = "Cancer.gov", Audience = AudienceType.HealthProfessional, TermName = "stage II cutaneous T-cell lymphoma", PrettyUrlName = "stage-ii-cutaneous-t-cell-lymphoma", Pronunciation = new Pronunciation() { Key = "kyoo-TAY-nee-us T-sel lim-FOH-muh", Audio = "https://www.cancer.gov/PublishedContent/Media/CDR/media/703959.mp3" }, Definition = new Definition() { Html = "Stage II cutaneous T-cell lymphoma may be either of the following: (1) stage IIA, in which the skin has red, dry, scaly patches but no tumors, and lymph nodes are enlarged but do not contain cancer cells; (2) stage IIB, in which tumors are found on the skin, and lymph nodes are enlarged but do not contain cancer cells.", Text = "Stage II cutaneous T-cell lymphoma may be either of the following: (1) stage IIA, in which the skin has red, dry, scaly patches but no tumors, and lymph nodes are enlarged but do not contain cancer cells; (2) stage IIB, in which tumors are found on the skin, and lymph nodes are enlarged but do not contain cancer cells." } }, new GlossaryTerm() { TermId = 43971, Language = "en", Dictionary = "Cancer.gov", Audience = AudienceType.Patient, TermName = "bcl-2 antisense oligodeoxynucleotide G3139", PrettyUrlName = "bcl-2-antisense-oligodeoxynucleotide-g3139", Pronunciation = new Pronunciation() { Key = "AN-tee-sents AH-lih-goh-dee-OK-see-NOO-klee-oh-tide", Audio = "https://www.cancer.gov/PublishedContent/Media/CDR/media/703968mp3" }, Definition = new Definition() { Html = "A substance being studied in the treatment of cancer. It may kill cancer cells by blocking the production of a protein that makes cancer cells live longer and by making them more sensitive to anticancer drugs. It is a type of antisense oligodeoxyribonucleotide. Also called augmerosen, Genasense, and oblimersen sodium.", Text = "A substance being studied in the treatment of cancer. It may kill cancer cells by blocking the production of a protein that makes cancer cells live longer and by making them more sensitive to anticancer drugs. It is a type of antisense oligodeoxyribonucleotide. Also called augmerosen, Genasense, and oblimersen sodium." } } } }; return(results); }
private void MainDataGridView_CellDoubleClick(object sender, DataGridViewCellEventArgs e) { AudienceType audiencetype = (AudienceType)MainDataGridView.Rows[e.RowIndex].DataBoundItem; Teacher teacher = audiencetype.Teacher; Corps corps = audiencetype.Corps; ShowAddAudience(audiencetype, teacher, corps); }
/// <summary> /// Initialization. Use Invoker.Create() with method set to ApiMethodType.GetTerm /// to instanatiate an GetTermInvoker object. /// </summary> /// <param name="request">The current request object.</param> public GetTermInvoker(HttpRequest request) : base(request) { TermID = GetTermID(); Dictionary = GetDictionaryWithDefaults(); Language = GetLanguage(); AudienceType = GetAudienceWithDefaults(); }
private void AddAudienceToolStripMenuItem_Click(object sender, EventArgs e) { AudienceType audience = new AudienceType(); Teacher teacher = new Teacher(); Corps corps = new Corps(); ShowAddAudience(audience, teacher, corps); }
public async Task <GlossaryTerm> GetById(string dictionary, AudienceType audience, string language, long id, bool useFallback = false) { if (String.IsNullOrWhiteSpace(dictionary) || String.IsNullOrWhiteSpace(language) || id <= 0) { throw new APIErrorException(400, "You must supply a valid dictionary, audience, language and id"); } // Lowercase the dictionary argument for use in fallback option checks and ES query dictionary = dictionary.ToLower(); if (language.ToLower() != "en" && language.ToLower() != "es") { throw new APIErrorException(400, "Unsupported Language. Please try either 'en' or 'es'"); } if (useFallback == false) { return(await _termsQueryService.GetById(dictionary, audience, language, id)); } // Implement fallback logic. // Depending on the given Dictionary and Audience inputs, loop through the fallback logic options until a term is found. // If the given fallback combination does not exist, then throw an error. // If none of the options return a term, then throw an error. else { // Set order of fallback options based on current audience. var fallbackOptions = audience == AudienceType.Patient ? _fallbackOptionsPatient : _fallbackOptionsHP; Tuple <string, AudienceType> requestedOptions = new Tuple <string, AudienceType>(dictionary, audience); LinkedListNode <Tuple <string, AudienceType> > start = fallbackOptions.Find(requestedOptions); if (start == null) { string msg = $"Could not find initial fallback combination with dictionary '{dictionary}' and audience '{audience}'."; _logger.LogError(msg); throw new APIErrorException(404, msg); } LinkedListNode <Tuple <string, AudienceType> > current = start; do { try { return(await _termsQueryService.GetById(current.Value.Item1, current.Value.Item2, language, id)); } catch (Exception ex) { // Swallow this Exception and move to the next combination. string msg = $"Could not find fallback term with ID '{id}', dictionary '{current.Value.Item1}', audience '{current.Value.Item2}', and language '{language}'."; _logger.LogDebug(ex, msg); } current = current.Next == null ? fallbackOptions.First : current.Next; } while (current != start); string message = $"Could not find fallback term with ID '{id}' for any combination of dictionary and audience."; _logger.LogError(message); throw new APIErrorException(404, message); } }
public async Task <long> GetCount(string dictionary, AudienceType audience, string language) { if (String.IsNullOrWhiteSpace(dictionary) || String.IsNullOrWhiteSpace(language) || !Enum.IsDefined(typeof(AudienceType), audience)) { throw new APIErrorException(400, "You must supply a valid dictionary, audience and language."); } return(await _termsQueryService.GetCount(dictionary, audience, language)); }
public ActionResult Edit([Bind(Include = "AudienceTypeID,TypeOfAudience")] AudienceType audienceType) { if (ModelState.IsValid) { db.Entry(audienceType).State = EntityState.Modified; db.SaveChanges(); return(RedirectToAction("Index")); } return(View(audienceType)); }
/// <summary> /// Search for Terms based on the search criteria. /// <param name="dictionary">The value for dictionary.</param> /// <param name="audience">Patient or Healthcare provider</param> /// <param name="language">The language in which the details needs to be fetched</param> /// <param name="query">The search query</param> /// <param name="matchType">Defines if the search should begin with or contain the key word</param> /// <param name="size">Defines the size of the search</param> /// <param name="from">Defines the Offset for search</param> /// <param name="requestedFields"> The list of fields that needs to be sent in the response</param> /// <returns>A list of GlossaryTerm</returns> /// </summary> public async Task <List <GlossaryTerm> > Search(string dictionary, AudienceType audience, string language, string query, string matchType, int size, int from, string[] requestedFields) { // Temporary Solution till we have Elastic Search List <GlossaryTerm> glossaryTermList = new List <GlossaryTerm>(); glossaryTermList.Add(GenerateSampleTerm(requestedFields)); glossaryTermList.Add(GenerateSampleTerm(requestedFields)); return(glossaryTermList); }
/// <summary> /// Lightweight method to search for terms matching searchText. This method is intended for use with autosuggest /// and returns a maximum of 10 results /// </summary> /// <param name="searchText">text to search for.</param> /// <param name="searchType">The type of search to perform. /// Valid values are: /// Begins - Search for terms beginning with searchText. /// Contains - Search for terms containing searchText. /// Magic - Search for terms beginning with searchText, followed by those containing searchText. /// </param> /// <param name="numResults">Maximum number of results to return.</param> /// <param name="dictionary">The dictionary to retreive the Term from. /// Valid values are /// Term - Dictionary of Cancer Terms /// drug - Drug Dictionary /// genetic - Dictionary of Genetics Terms /// </param> /// <param name="language">The Term's desired language. /// Supported values are: /// en - English /// es - Spanish /// </param> /// <param name="version">String identifying which vereion of the JSON structure to retrieve.</param> /// <returns></returns> public SuggestReturn SearchSuggest(String searchText, SearchType searchType, int numResults, DictionaryType dictionary, Language language, String version) { log.DebugFormat("Enter ValidateSearchSuggest( {0}, {1}, {2}, {3}, {4}, {5}).", searchText, searchType, numResults, dictionary, language, version); // Sanity check for numResults if (numResults < 10) { numResults = 10; } // In the initial implementation, the audience is implied by the particular dictionary being used. AudienceType audience = GetDefaultAudienceFromDictionaryType(dictionary); DictionaryQuery query = new DictionaryQuery(); SuggestionResults results = query.SearchSuggest(searchText, searchType, numResults, dictionary, language, audience, version); List <String> messages = new List <string>(); int resultCount = results.MatchCount; // Report the count in a human-readable format. String message = String.Format("Found {0} results.", resultCount); log.Debug(message); messages.Add(message); // Retrieve results. We already know the number of results, so let's preset the // list to the size we know we're going to need. List <DictionarySuggestion> foundTerms = new List <DictionarySuggestion>(resultCount); foreach (DataRow row in results.Data.Rows) { int ID = row.Field <int>("TermID"); string term = row.Field <String>("TermName"); DictionarySuggestion suggestion = new DictionarySuggestion(ID, term); foundTerms.Add(suggestion); } // Populate return metadata structure SuggestReturnMeta meta = new SuggestReturnMeta() { ResultCount = resultCount, Messages = messages.ToArray() }; // Combine meta and results to create the final return object. SuggestReturn suggestReturn = new SuggestReturn() { Result = foundTerms.ToArray(), Meta = meta }; return(suggestReturn); }
public ActionResult Create([Bind(Include = "AudienceTypeID,TypeOfAudience")] AudienceType audienceType) { if (ModelState.IsValid) { db.AudienceTypes.Add(audienceType); db.SaveChanges(); return(RedirectToAction("Index")); } return(View(audienceType)); }
protected void Page_Load(object sender, EventArgs e) { string input_term; if (PageAssemblyContext.Current.DisplayVersion == DisplayVersions.Web) { urlArgs = Request.Url.Query.Substring(1); input_term = Strings.Clean(Request.Params["term"]); CdrID = Strings.IfNull(Strings.Clean(Request.Params["id"]), Strings.Clean(Request.Params["cdrid"])); AudienceType audience = GetAudienceType(Strings.Clean(Request.Params["version"])); DictionaryType dictionary = GetDictionaryType(Strings.Clean(Request.Params["dictionary"])); //load the definition DictionaryAppManager _dictionaryAppManager = new DictionaryAppManager(); DictionaryTerm dataItem = null; if (!string.IsNullOrEmpty(CdrID)) { CdrID = Regex.Replace(CdrID, "^CDR0+", "", RegexOptions.Compiled); // call appropriate method if dictionary type is known // the language is set to English = en by default if (dictionary == DictionaryType.Unknown) { dataItem = _dictionaryAppManager.GetTermForAudience(Convert.ToInt32(CdrID), dictionaryLanguage, "v1", audience); } else { dataItem = _dictionaryAppManager.GetTerm(Convert.ToInt32(CdrID), dictionary, dictionaryLanguage, "v1", audience); } } if (dataItem != null && dataItem.Term != null) { ActivateDefinitionView(dataItem); } else { phDefinition.Visible = false; phNoResult.Visible = true; } // Web Analytics ************************************************* WebAnalyticsPageLoad webAnalyticsPageLoad = new WebAnalyticsPageLoad(); webAnalyticsPageLoad.SetChannel("Dictionary of Cancer Terms"); webAnalyticsPageLoad.SetLanguage("en"); webAnalyticsPageLoad.AddEvent(WebAnalyticsOptions.Events.event11); // Dictionary Term view (event11) litOmniturePageLoad.Text = webAnalyticsPageLoad.Tag(); // Load page load script // End Web Analytics ********************************************* } }
public Audience(AudienceType type, string value, bool isChannel = false) { switch (type) { case AudienceType.Android: if (isChannel) { AndroidChannel = value; } else { AndroidDeviceId = value; } break; case AudienceType.Ios: if (isChannel) { IosChannel = value; } else { IosDeviceId = value; } break; case AudienceType.Windows: WindowsId = value; break; case AudienceType.WindowsPhone: WindowsPhoneId = value; break; case AudienceType.Blackberry: BlackberryId = value; break; case AudienceType.Segment: SegmentId = value; break; case AudienceType.Alias: Alias = value; break; case AudienceType.Tag: Tag = value; break; } }
// GET: AudienceTypes/Delete/5 public ActionResult Delete(int?id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } AudienceType audienceType = db.AudienceTypes.Find(id); if (audienceType == null) { return(HttpNotFound()); } return(View(audienceType)); }
/// <summary> /// Retrieves a single dictionary Term based on its specific Term ID. /// </summary> /// <param name="termId">The ID of the Term to be retrieved</param> /// <param name="dictionary">The dictionary to retreive the Term from. /// Valid values are /// Term - Dictionary of Cancer Terms /// drug - Drug Dictionary /// genetic - Dictionary of Genetics Terms /// </param> /// <param name="language">The Term's desired language. /// Supported values are: /// en - English /// es - Spanish /// </param> /// <returns></returns> public TermReturn GetTerm(int termId, DictionaryType dictionary, Language language) { log.DebugFormat("Enter GetTerm( {0}, {1}, {2}).", termId, dictionary, language); AudienceType audience = AudienceType.Patient; // determine what audience to use based on the dictionary DictionaryManager dictionaryManager = new DictionaryManager(); audience = dictionaryManager.GetDefaultAudienceFromDictionaryType(dictionary); // route to GetTerm with all arguments return(GetTerm(termId, dictionary, language, audience)); }
public Audience(AudienceType type, string value, bool isChannel = false) { switch (type) { case AudienceType.Android: if (isChannel) AndroidChannel = value; else AndroidDeviceId = value; break; case AudienceType.Ios: if (isChannel) IosChannel = value; else IosDeviceId = value; break; case AudienceType.Windows: WindowsId = value; break; case AudienceType.WindowsPhone: WindowsPhoneId = value; break; case AudienceType.Blackberry: BlackberryId = value; break; case AudienceType.Segment: SegmentId = value; break; case AudienceType.Alias: Alias = value; break; case AudienceType.Tag: Tag = value; break; } }
private AudienceTarget(AudienceType audienceType, HashSet<string> values) { this.audienceType = audienceType; this.valueBuilder = values; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Sets the "Broad Type", the audience for which the resource being archived is /// primarily intended. This is set automatically as a side-effect of setting the /// stage or type. /// </summary> /// ------------------------------------------------------------------------------------ public void SetAudience(AudienceType audienceType) { if (IsMetadataPropertySet(MetadataProperties.Audience)) { if (_metsAudienceType != audienceType) throw new InvalidOperationException(string.Format("Audience has already been set and cannot be changed to a different value.")); return; // Already added } MarkMetadataPropertyAsSet(MetadataProperties.Audience); _metsAudienceType = audienceType; string audience; switch (audienceType) { case AudienceType.Vernacular: audience = kAudienceVernacular; break; case AudienceType.Training: audience = kAudienceTraining; break; case AudienceType.Internal: audience = kAudienceInternal; break; case AudienceType.Wider: audience = kAudienceWide; break; default: throw new NotImplementedException("Need to add appropriate METS constant for audience type " + audienceType); } _metsPairs.Add(JSONUtils.MakeKeyValuePair(kAudience, audience)); }
public void SetAudience(AudienceType audienceType, String value) { Audience = new Audience(audienceType, value); }