/// <summary>
        /// Handles the Click event of the CheckBox control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="RoutedEventArgs"/> instance containing the event data.</param>
        private void CheckBox_Click(object sender, RoutedEventArgs e)
        {
            var toggleButton = ((FrameworkElement)sender);

            string toggleButtonName = ((FrameworkElement)sender).Name;

            string selectOption = toggleButtonName.Replace("ToggleButton", "");

            WellKnownTranscriptionQueueOption option = (WellKnownTranscriptionQueueOption)Enum.Parse(typeof(WellKnownTranscriptionQueueOption), selectOption, true);

            string selectedOption = option.ToString();

            ManageToggleButtons(option);

            if ((bool)(sender as ToggleButton).IsChecked)
            {
                if (selectedOption.Equals("All"))
                {
                    SearchList = new List <string>();
                }

                SearchList.Add(selectedOption);

                SearchRequest = new SearchRequest(SearchHelper.InitialCurrentPage, CurrentPageList);
            }
            else
            {
                if (SearchList.Contains(selectedOption))
                {
                    SearchList.Remove(selectedOption);
                }
            }

            PopulateList();
        }
        /// <summary>
        /// Manages the toggle buttons.
        /// </summary>
        /// <param name="option">The option.</param>
        private void ManageToggleButtons(WellKnownTranscriptionQueueOption option)
        {
            if (option == WellKnownTranscriptionQueueOption.All)
            {
                PriorityToggleButton.IsChecked    = false;
                TranscribedToggleButton.IsChecked = false;
                AuditCheckToggleButton.IsChecked  = false;
                FirstEditToggleButton.IsChecked   = false;
                SecondEditToggleButton.IsChecked  = false;
                DraftSentToggleButton.IsChecked   = false;
                CorrectionsToggleButton.IsChecked = false;
                FinalEditToggleButton.IsChecked   = false;
                SentOutToggleButton.IsChecked     = false;
            }
            else
            {
                if ((bool)AllToggleButton.IsChecked)
                {
                    AllToggleButton.IsChecked = false;
                }
                else if (!(bool)PriorityToggleButton.IsChecked &&
                         !(bool)TranscribedToggleButton.IsChecked &&
                         !(bool)AuditCheckToggleButton.IsChecked &&
                         !(bool)FirstEditToggleButton.IsChecked &&
                         !(bool)SecondEditToggleButton.IsChecked &&
                         !(bool)DraftSentToggleButton.IsChecked &&
                         !(bool)CorrectionsToggleButton.IsChecked &&
                         !(bool)FinalEditToggleButton.IsChecked &&
                         !(bool)SentOutToggleButton.IsChecked)
                {
                    AllToggleButton.IsChecked = true;

                    SearchList = new List <string>();
                }
            }
        }
Esempio n. 3
0
        /// <summary>
        /// The actual Work to be done.
        /// </summary>
        protected override void Execute()
        {
            List <TranscriptionModel> newlist = new List <TranscriptionModel>();

            Expression <Func <transcription, bool> > predicate = PredicateBuilder.True <transcription>();

            predicate = predicate.And(p => p.TranscriptStatus == false);

            if (Request.FilterKeyWords != null && Request.FilterKeyWords.Count > 0)
            {
                foreach (string keyword in Request.FilterKeyWords)
                {
                    WellKnownTranscriptionQueueOption option =
                        (WellKnownTranscriptionQueueOption)Enum.Parse(
                            typeof(WellKnownTranscriptionQueueOption), keyword, true);

                    switch (option)
                    {
                    case WellKnownTranscriptionQueueOption.All:
                        break;

                    case WellKnownTranscriptionQueueOption.Priority:
                        predicate = predicate.And(p => p.IsPriority == true);
                        break;

                    case WellKnownTranscriptionQueueOption.Transcribed:
                        predicate = predicate.And(p => !string.IsNullOrEmpty(p.TranscriberAssigned));
                        break;

                    case WellKnownTranscriptionQueueOption.AuditCheck:
                        predicate = predicate.And(p => !string.IsNullOrEmpty(p.AuditCheckCompleted));
                        break;

                    case WellKnownTranscriptionQueueOption.FirstEdit:
                        predicate = predicate.And(p => !string.IsNullOrEmpty(p.FirstEditCompleted));
                        break;

                    case WellKnownTranscriptionQueueOption.SecondEdit:
                        predicate = predicate.And(p => !string.IsNullOrEmpty(p.SecondEditCompleted));
                        break;

                    case WellKnownTranscriptionQueueOption.DraftSent:
                        predicate = predicate.And(p => !string.IsNullOrEmpty(p.DraftSentDate.ToString()));
                        break;

                    case WellKnownTranscriptionQueueOption.Corrections:
                        predicate = predicate.And(p => !string.IsNullOrEmpty(p.EditWithCorrectionCompleted));
                        break;

                    case WellKnownTranscriptionQueueOption.FinalEdit:
                        predicate = predicate.And(p => !string.IsNullOrEmpty(p.FinalEditCompleted));
                        break;

                    case WellKnownTranscriptionQueueOption.SentOut:
                        predicate = predicate.And(p => !string.IsNullOrEmpty(p.FinalSentDate.ToString()));
                        break;

                    default:
                        break;
                    }
                }
            }

            if (!string.IsNullOrEmpty(Request.SearchWord))
            {
                predicate = predicate.And(p => p.Interviewer.Contains(Request.SearchWord) ||
                                          p.AuditCheckCompleted.Contains(Request.SearchWord) ||
                                          p.AccessFileLocation.Contains(Request.SearchWord) ||
                                          p.CoverageSpatial.Contains(Request.SearchWord) ||
                                          p.CoverageTemporal.Contains(Request.SearchWord) ||
                                          p.Description.Contains(Request.SearchWord) ||
                                          p.EditWithCorrectionCompleted.Contains(Request.SearchWord) ||
                                          p.AudioEquipmentUsed.Contains(Request.SearchWord) ||
                                          p.VideoEquipmentUsed.Contains(Request.SearchWord) ||
                                          p.FileName.Contains(Request.SearchWord) ||
                                          p.FinalEditCompleted.Contains(Request.SearchWord) ||
                                          p.FirstEditCompleted.Contains(Request.SearchWord) ||
                                          p.Format.Contains(Request.SearchWord) ||
                                          p.Identifier.Contains(Request.SearchWord) ||
                                          p.InitialNote.Contains(Request.SearchWord) ||
                                          p.Interviewee.Contains(Request.SearchWord) ||
                                          p.InterviewerNote.Contains(Request.SearchWord) ||
                                          p.Keywords.Contains(Request.SearchWord) ||
                                          p.RestrictionNote.Contains(Request.SearchWord) ||
                                          p.Place.Contains(Request.SearchWord) ||
                                          p.ProjectCode.Contains(Request.SearchWord) ||
                                          p.Publisher.Contains(Request.SearchWord) ||
                                          p.ReasonForPriority.Contains(Request.SearchWord) ||
                                          p.RelationIsPartOf.Contains(Request.SearchWord) ||
                                          p.Rights.Contains(Request.SearchWord) ||
                                          p.ScopeAndContents.Contains(Request.SearchWord) ||
                                          p.SecondEditCompleted.Contains(Request.SearchWord) ||
                                          p.Rights.Contains(Request.SearchWord) ||
                                          p.Title.Contains(Request.SearchWord) ||
                                          p.Subject.Contains(Request.SearchWord) ||
                                          p.TranscriberAssigned.Contains(Request.SearchWord) ||
                                          p.TranscriptLocation.Contains(Request.SearchWord) ||
                                          p.Transcript.Contains(Request.SearchWord) ||
                                          p.TranscriptNote.Contains(Request.SearchWord) ||
                                          p.Type.Contains(Request.SearchWord)
                                          );
            }

            IPagedList <transcription> pagedTransactionList = TranscriptionRepository.FindBy(predicate).
                                                              OrderBy(t => t.Title).ToPagedList(Request.SearchRequest.CurrentPage,
                                                                                                Request.SearchRequest.ListLength);

            PaginationInfo page = page = new PaginationInfo()
            {
                CurrentPage = pagedTransactionList.PageNumber,

                TotalListLength = pagedTransactionList.TotalItemCount,

                TotalPages = pagedTransactionList.PageCount,

                ListLength = pagedTransactionList.PageSize
            };

            foreach (transcription item in pagedTransactionList.ToList())
            {
                newlist.Add(Util.ConvertToTranscriptionModel(item));
            }

            Response = new ResponseModel()
            {
                PaginationInfo     = page,
                Transcriptions     = newlist,
                IsOperationSuccess = true
            };
        }