コード例 #1
0
        /// <summary>
        /// add notes to InnerItem from CaseCommunicationViewModel
        /// </summary>
        private void GetNotesToCaseFromCaseCommunications(ICustomerRepository repository)
        {
            var adaptor = new CommunicationAdaptor();
            if (CaseCommunications != null && CaseCommunications.Items != null)
            {
                var result = new List<Note>();

                result = result.Union(CaseCommunications.Items
                                                        .Where(n => n.Type == CommunicationItemType.Note)
                                                        .Where(
                                                            n =>
                                                            n.State !=
                                                            CommunicationItemState.Deleted)
                                                        .Select(
                                                            n =>
                                                            adaptor.NoteCommunicationViewModel2Note(
                                                                n as CommunicationItemNoteViewModel))).ToList();

                foreach (var note in result)
                {
                    var noteForUpdate = CaseNotes.SingleOrDefault(caseNote => caseNote.NoteId == note.NoteId);
                    if (noteForUpdate == null)
                    {
                        note.CaseId = InnerItem.CaseId;
                        CaseNotes.Add(note);
                        repository.Add(note);
                    }
                }

                //if messsage was writed in textbox, but Enter was not pressed
                //then create new noteItem and save it;
                if (!string.IsNullOrEmpty(CaseCommunications.NewBody))
                {
                    var activeCommand = CaseCommunications.ToolBarCommmands.SingleOrDefault(c => c.IsActive);

                    if ((CommunicationItemType)activeCommand.CommandParametr == CommunicationItemType.Note)
                    {
                        var note = new Note
                            {
                                AuthorName = _authorName,
                                Body = CaseCommunications.NewBody,
                                Title = InnerItem.Title,
                                Created = (DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local)).ToUniversalTime(),
                                CaseId = InnerItem.CaseId
                            };
                        note.LastModified = note.Created;
                        CaseNotes.Add(note);
                        repository.Add(note);
                    }

                    OnUIThread(() =>
                    {
                        if (activeCommand != null)
                        {
                            activeCommand.Command.Execute(CaseCommunications.NewBody);
                        }
                    });
                }
            }
        }
コード例 #2
0
        private Task<List<CommunicationItemViewModel>> RefreshCaseCommunicationItemsAsync(CommunicationAdaptor adaptor)
        {
            Task<List<CommunicationItemViewModel>> taskResult = Task.Run(() =>
                {
                    var result = new List<CommunicationItemViewModel>();

                    // Append publicReplyItems
                    if (CaseCommunicationItems.Count > 0)
                    {
                        result = result.Union(CaseCommunicationItems
                                                       .Where(item => item is PublicReplyItem)
                                                       .Select(
                                                           item =>
                                                           adaptor.PublicReply2PublicReplyViewModel(
                                                               item.DeepClone(
                                                                   _entityFactory as IKnownSerializationTypes)
                                                               as PublicReplyItem)))
                                       .ToList();
                    }
                    // Append Notes
                    if (CaseNotes.Count > 0)
                    {
                        result =
                            result.Union(
                                CaseNotes.Select(
                                    n =>
                                    adaptor.Note2NoteCommunicationViewModel(
                                        n.DeepClone(_entityFactory as IKnownSerializationTypes)))).ToList();
                    }

                    return result;
                });

            return taskResult;
        }
コード例 #3
0
        /// <summary>
        /// Add communication item to CurrentCase
        /// </summary>
        /// <returns></returns>
        private void GetCommunicationItemsFromCaseCommunications(ICustomerRepository repository)
        {
            var adaptor = new CommunicationAdaptor();

            if (CaseCommunications != null && CaseCommunications.Items != null)
            {
                var result = new List<CommunicationItem>();

                result = result.Union(CaseCommunications.Items
                                                        .Where(item => item.Type == CommunicationItemType.PublicReply)
                                                        .Where(item => item.State != CommunicationItemState.Deleted)
                                                        .Select(
                                                            item =>
                                                            adaptor.PublicReplyViewModel2PublicReplyItem(
                                                                item as CommunicationItemPublicReplyViewModel))).ToList();

                foreach (var item in result)
                {
                    var itemForUpdate =
                        CaseCommunicationItems.SingleOrDefault(
                            comItem => comItem.CommunicationItemId == item.CommunicationItemId);
                    if (itemForUpdate == null)
                    {
                        item.CaseId = InnerItem.CaseId;
                        CaseCommunicationItems.Add(item);
                        repository.Add(item);
                    }
                }

                //if messsage was writed in textbox, but Enter was not pressed
                //then create new publicReplyItem and save it;
                if (!string.IsNullOrEmpty(CaseCommunications.NewBody))
                {
                    var activeCommand = CaseCommunications.ToolBarCommmands.SingleOrDefault(c => c.IsActive);

                    if ((CommunicationItemType)activeCommand.CommandParametr == CommunicationItemType.PublicReply)
                    {
                        PublicReplyItem publicReplyItem = new PublicReplyItem();
                        publicReplyItem.AuthorName = _authorName;
                        publicReplyItem.Body = CaseCommunications.NewBody;
                        publicReplyItem.Title = InnerItem.Title;
                        publicReplyItem.Created =
                            (DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local)).ToUniversalTime();
                        publicReplyItem.LastModified = publicReplyItem.Created;
                        publicReplyItem.CaseId = InnerItem.CaseId;
                        CaseCommunicationItems.Add(publicReplyItem);
                        repository.Add(publicReplyItem);
                    }

                    OnUIThread(() =>
                        {
                            if (activeCommand != null)
                            {
                                activeCommand.Command.Execute(CaseCommunications.NewBody);
                            }
                        });
                }
            }
        }
コード例 #4
0
        /// <summary>
        /// refresh case communication Items (Public Reply)
        /// refresh case communication Items (Notes)
        /// </summary>
        private async void RefreshCaseCommunicationItems()
        {
            var adaptor = new CommunicationAdaptor();

            try
            {
                CaseCommunications.IsInitialized = false;
                var communicationItems = await RefreshCaseCommunicationItemsAsync(adaptor);

                OnUIThread(() =>
                    {
                        CaseCommunications.AppendCommunucationItems(communicationItems);
                        CaseCommunications.IsInitialized = true;
                        IsModified = false;
                    });

            }
            catch (Exception ex)
            {
                ShowErrorDialog(ex, string.Format("An error occurred when trying to refresh case notes: {0}".Localize(), ex.InnerException.Message));
            }
        }
コード例 #5
0
        private Task<List<CommunicationItemViewModel>> RefreshCustomerNotesItemAsync(CommunicationAdaptor adaptor)
        {
            Task<List<CommunicationItemViewModel>> taskResult = Task.Run(() =>
                {
                    var result = new List<CommunicationItemViewModel>();
                    if (CurrentCustomer != null && ContactNotes.Count > 0)
                    {
                        result =
                            result.Union(
                                ContactNotes.Select(
                                    n =>
                                    adaptor.Note2NoteCommunicationViewModel(
                                        n.DeepClone(_entityFactory as IKnownSerializationTypes)))).ToList();
                    }
                    return result;
                });

            return taskResult;
        }
コード例 #6
0
        /// <summary>
        /// refresh customer notes
        /// </summary>
        private async void RefreshCustomerNotesItems()
        {
            var adaptor = new CommunicationAdaptor();

            try
            {
                CustomerNotes.IsInitialized = false;
                var notes = await RefreshCustomerNotesItemAsync(adaptor);
                OnUIThread(() =>
                {
                    CustomerNotes.AppendCommunucationItems(notes);
                    CustomerNotes.IsInitialized = true;
                    ShowLoadingAnimation = false;
                    IsModified = false;
                });

            }
            catch (Exception ex)
            {
                ShowErrorDialog(ex, string.Format("An error occurred when trying to refresh contact notes: {0}".Localize(), ex.InnerException.Message));
            }
        }
コード例 #7
0
		private void CommitSelectedKnowledgeGroupArticles()
		{
			var adaptor = new CommunicationAdaptor();
			var selectedGroupId = (_selectedKnowledgeGroup as KnowledgeGroupViewModel) != null ? (_selectedKnowledgeGroup as KnowledgeGroupViewModel).OriginalItem.KnowledgeBaseGroupId : null;
			var communicationControl = KnowledgeArticleCommunicationControl as KnowledgeArticleCommunicationControlViewModel;
			var itemsForDelete = communicationControl.GetItemsByState(CommunicationItemState.Deleted);
			var itemsForAppend = communicationControl.GetItemsByState(CommunicationItemState.Appended);
			var itemsForModify = communicationControl.GetItemsByState(CommunicationItemState.Modified);

			Task.Factory.StartNew(() =>
			{
				var repository = _repositoryFactory.GetRepositoryInstance();
				ShowLoadingAnimation = true;
				// delete
				if (itemsForDelete != null && itemsForDelete.Count() > 0)
				{
					foreach (CommunicationItemViewModel item in itemsForDelete)
					{
						KnowledgeBaseArticle original = adaptor.KnowledgeBaseArticleCommunicationViewModel2KnowledgeBaseArticle(item as CommunicationItemKnowledgeBaseArticleViewModel);
						//SyncAttach(original, null);
						repository.Attach(original);
						repository.Remove(original);
					}
				}
				// append
				if (itemsForAppend != null && itemsForAppend.Count() > 0 && selectedGroupId != null)
				{
					foreach (CommunicationItemViewModel item in itemsForAppend)
					{
						KnowledgeBaseArticle article = adaptor.KnowledgeBaseArticleCommunicationViewModel2KnowledgeBaseArticle(item as CommunicationItemKnowledgeBaseArticleViewModel);
						article.GroupId = selectedGroupId;
						//SyncAttach(null, article);
						repository.Add(article);
					}
				}
				// modify
				if (itemsForModify != null && itemsForModify.Count() > 0)
				{
					foreach (CommunicationItemViewModel item in itemsForModify)
					{
						var article = adaptor.KnowledgeBaseArticleCommunicationViewModel2KnowledgeBaseArticle(item as CommunicationItemKnowledgeBaseArticleViewModel);
						article.GroupId = selectedGroupId;
						var original = repository.KnowledgeBaseArticles.Where(x => x.KnowledgeBaseArticleId == article.KnowledgeBaseArticleId).SingleOrDefault();
						//SyncAttach(original, article);
						repository.Attach(original);
						OnUIThread(()=>original.InjectFrom(article));
					}
				}
				int i = repository.UnitOfWork.Commit();
			})
		   .ContinueWith(t =>
		   {
			   ShowLoadingAnimation = false;
		   });
		}
コード例 #8
0
		/// <summary>
		/// refresh articles for selected KnowledgeBaseGroup
		/// </summary>
		private void RefreshSelectedKnowledgeGroupArticles()
		{
			var adaptor = new CommunicationAdaptor();

			Task.Factory.StartNew(() =>
			{
				KnowledgeArticleCommunicationControl.IsInitialized = false;
				List<CommunicationItemViewModel> result = null;
				var selectedKnowledgeGroup = SelectedKnowledgeGroup as KnowledgeGroupViewModel;
				var articles = GetKnowledgeBaseArticles(selectedKnowledgeGroup);
				if (articles != null && articles.Count() > 0)
				{
					result = new List<CommunicationItemViewModel>();
					foreach (var i in articles)
					{
						result.Add(adaptor.KnowledgeBaseArticle2KnowledgeBaseArticleCommunicationViewModel(i));
					}
					//result = articles.Select(n => (adaptor.KnowledgeBaseArticle2KnowledgeBaseArticleCommunicationViewModel(n) as CommunicationItemViewModel)).OfType<CommunicationItemViewModel>().ToList();
				}
				return result;
			}).ContinueWith(t =>
			{
				OnUIThread(() =>
				{
					if (t.Exception == null)
					{
						KnowledgeArticleCommunicationControl.ClearAllCommunicationItems();
						KnowledgeArticleCommunicationControl.AppendCommunucationItems(t.Result);
					}
					KnowledgeArticleCommunicationControl.IsInitialized = true;
				});
			});
		}