Ejemplo n.º 1
0
        /// <summary>
        /// Handles the index text completed event for the Terminology Provider Client.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="IndexTextCompletedEventArgs"/> instance containing the event data.</param>
        private static void TerminologyProviderClientIndexTextCompleted(object sender, IndexTextCompletedEventArgs e)
        {
            SearchState searchState = null;

            if (e.Error == null && e.Result != null && (searchState = e.UserState as SearchState) != null)
            {
                bool containsSide = false;

                ObservableCollection <AdditionalTextBoxResult> additionalTextBoxResults = new ObservableCollection <AdditionalTextBoxResult>();

                foreach (IndexerResult indexerResult in e.Result)
                {
                    AdditionalTextBoxResult additionalTextBoxResult = new AdditionalTextBoxResult();

                    additionalTextBoxResult.SelectedItem = indexerResult.Concept;
                    additionalTextBoxResult.StartIndex   = indexerResult.StartIndex;
                    additionalTextBoxResult.Length       = indexerResult.EndIndex - indexerResult.StartIndex;
                    additionalTextBoxResult.IsSide       = TerminologyManager.IsConceptSide(indexerResult.Concept);

                    if (additionalTextBoxResult.IsSide)
                    {
                        containsSide = true;
                    }
                    else
                    {
                        ConceptItem foundConcept = null;

                        foreach (RefinableCharacteristic refinableCharacteristic in searchState.ConceptDetail.RefinableCharacteristics)
                        {
                            foundConcept = refinableCharacteristic.ValueConcepts.SingleOrDefault(p => p.SnomedConceptId == indexerResult.Concept.SnomedConceptId);

                            if (foundConcept != null)
                            {
                                break;
                            }
                        }

                        if (foundConcept == null)
                        {
                            continue;
                        }
                    }

                    additionalTextBoxResults.Add(additionalTextBoxResult);
                }

                if (!containsSide)
                {
                    TerminologyManager.RaiseAdditionalTextBoxCompleted(additionalTextBoxResults, searchState);
                }
                else
                {
                    TerminologyProviderClient terminologyProviderClient = new TerminologyProviderClient();

                    terminologyProviderClient.GetConceptDetailsCompleted += delegate(object newSender, GetConceptDetailsCompletedEventArgs newEventArgs)
                    {
                        searchState = newEventArgs.UserState as SearchState;
                    };

                    if (searchState.InputFieldResult != null)
                    {
                        searchState.AdditionalTextBoxResults = additionalTextBoxResults;

                        RefinableCharacteristic refChar = searchState.ConceptDetail.RefinableCharacteristics.SingleOrDefault(p => p.Name == "Finding site");

                        if (refChar == null)
                        {
                            TerminologyManager.RaiseAdditionalTextBoxCompleted(searchState.AdditionalTextBoxResults, searchState);
                        }
                        else
                        {
                            searchState.UserState                = UserState.SearchingFindingSites;
                            searchState.RemainingItemsToFind     = refChar.ValueConcepts.Count;
                            searchState.AdditionalTextBoxResults = additionalTextBoxResults;
                            searchState.RefinableCharacteristic  = refChar;

                            TerminologyManager.terminologyProviderClient.GetConceptDetailsAsync(refChar.ValueConcepts[0].SnomedConceptId, TerminologyManager.LocaleString, searchState);
                        }
                    }
                }
            }
            else
            {
                if (TerminologyManager.AdditionalTextBoxParseCompleted != null)
                {
                    if (searchState != null)
                    {
                        TerminologyManager.AdditionalTextBoxParseCompleted(null, new AdditionalTextBoxParseCompletedEventArgs(searchState.SearchTextOriginal, false, searchState.InputFieldResult.Concept.SnomedConceptId));
                    }
                    else
                    {
                        TerminologyManager.AdditionalTextBoxParseCompleted(null, new AdditionalTextBoxParseCompletedEventArgs(string.Empty, false, string.Empty));
                    }
                }
            }
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Handles the get concept details completed event for the Terminologies Provider Client.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="GetConceptDetailsCompletedEventArgs"/> instance containing the event data.</param>
        private static void TerminologyProviderClientGetConceptDetailsCompleted(object sender, GetConceptDetailsCompletedEventArgs e)
        {
            if (e.Error == null && e.Result != null)
            {
                if (e.UserState is SearchState)
                {
                    SearchState searchState = e.UserState as SearchState;

                    switch (searchState.UserState)
                    {
                    case UserState.EncodingMainConcept:
                        TerminologyManager.EncodeMainConcept(e.Result, searchState);
                        break;

                    case UserState.EncodingAdditionalConcept:
                        searchState.ConceptDetail = e.Result;
                        TerminologyManager.EncodeAdditionalConcept(searchState);
                        break;

                    case UserState.SearchingFindingSites:
                        RefinableCharacteristic lateralityRefChar = e.Result.RefinableCharacteristics.SingleOrDefault(p => p.Name == "Laterality");

                        searchState.RemainingItemsToFind--;

                        int index = searchState.RefinableCharacteristic.ValueConcepts.Count - searchState.RemainingItemsToFind;

                        if (lateralityRefChar == null)
                        {
                            if (searchState.RemainingItemsToFind > 0)
                            {
                                TerminologyManager.terminologyProviderClient.GetConceptDetailsAsync(searchState.RefinableCharacteristic.ValueConcepts[index].SnomedConceptId, TerminologyManager.LocaleString, searchState);
                            }
                            else
                            {
                                TerminologyManager.RaiseAdditionalTextBoxCompleted(searchState.AdditionalTextBoxResults, searchState);
                            }
                        }
                        else
                        {
                            searchState.LateralityFindingSites.Add(e.Result);

                            if (searchState.RemainingItemsToFind > 0)
                            {
                                TerminologyManager.terminologyProviderClient.GetConceptDetailsAsync(searchState.RefinableCharacteristic.ValueConcepts[index].SnomedConceptId, TerminologyManager.LocaleString, searchState);
                            }
                            else
                            {
                                TerminologyManager.RaiseAdditionalTextBoxCompleted(searchState.AdditionalTextBoxResults, searchState);
                            }
                        }

                        break;

                    default:
                        break;
                    }

                    switch (searchState.UserState)
                    {
                    case UserState.EncodingMainConcept:
                    case UserState.EncodingAdditionalConcept:
                        if (searchState.AdditionalTextBoxResults == null || searchState.AdditionalTextBoxResults.Count == 0)
                        {
                            if (TerminologyManager.EncodeConceptCompleted != null)
                            {
                                TerminologyManager.EncodeConceptCompleted(null, new EncodeConceptCompletedEventArgs(searchState.EncodedConcept));
                            }
                        }

                        break;
                    }
                }
            }
            else
            {
                if (TerminologyManager.EncodeConceptCompleted != null)
                {
                    TerminologyManager.EncodeConceptCompleted(null, new EncodeConceptCompletedEventArgs(false));
                }
            }
        }