Пример #1
0
        public void Handle(NewRevisionDetectedLocalMessage localMessage)
        {
            string key;

            if (_revisionStorage.SaveRevisionInfo(localMessage.Revision, out key))
            {
                _logger.InfoFormat("Importing revision. Revision ID: {0}", localMessage.Revision.Id.Value);

                var dto = new RevisionDTO
                {
                    SourceControlID = localMessage.Revision.Id.Value,
                    Description     = localMessage.Revision.Comment,
                    CommitDate      = localMessage.Revision.Time,
                    AuthorID        =
                        _userMapper.IsAuthorMapped(localMessage.Revision)
                                                                        ? (int?)_userMapper.GetAuthorBy(localMessage.Revision).Id
                                                                        : null
                };

                Data.RevisionEntries = localMessage.Revision.Entries;
                Data.SourceControlID = localMessage.Revision.Id.Value;
                Data.RevisionKey     = key;

                Send(new CreateEntityCommand <RevisionDTO>(dto));
            }
            else
            {
                //_logger.InfoFormat("Revision has already been imported. Aborting revision import. Revision ID: {0}", localMessage.Revision.Id.Value);
                MarkAsComplete();
            }
        }
Пример #2
0
        public void Handle(BugUpdatedMessage message)
        {
            //TODO: take into account: when set the second developer in TP this developer assigned in Bugzilla

            if (!message.ChangedFields.Contains(BugField.EntityStateID))
            {
                return;
            }

            var bugzillaBug = _bugzillaInfoStorageRepository.GetBugzillaBug(message.Dto.ID);

            if (bugzillaBug == null)
            {
                return;
            }

            var status = _entityStateConverter.GetMappedBugzillaStatus(message.Dto);

            if (status == null)
            {
                return;
            }

            try
            {
                _log.InfoFormat("Updating bug status in Bugzilla. TargetProcess Bug ID: {0}; Bugzilla Bug ID: {1}", message.Dto.ID, bugzillaBug.Id);
                _bugzillaService.Execute(_actionFactory.GetChangeStatusAction(message.Dto, bugzillaBug.Id, status));
                _log.InfoFormat("Bug status in Bugzilla updated. TargetProcess Bug ID: {0}; Bugzilla Bug ID: {1}", message.Dto.ID, bugzillaBug.Id);
            }
            catch (Exception e)
            {
                _log.Error(e.Message, e);
            }
        }
        protected void HandleInternal(WorkItemInfo itemInfo)
        {
            Data.WorkItem = itemInfo;
            TDto entityDto = CreateEntityDTO(itemInfo);

            if (itemInfo.Action == WorkItemAction.Create)
            {
                Logger.InfoFormat("Creating {0}: {1}", itemInfo.WorkItemType, itemInfo.ToString());

                SendCreateCommand(entityDto);
            }
            else if (itemInfo.Action == WorkItemAction.Update)
            {
                Logger.InfoFormat("Updating {0}: {1}", itemInfo.WorkItemType, itemInfo.ToString());

                if (itemInfo.TpEntityId == null)
                {
                    var workItemField = itemInfo.FieldsValues.FirstOrDefault(x => x.Name == "Title");

                    Logger.WarnFormat(
                        "Relation for Work Item '{0} {1}' not found in profile storage.",
                        itemInfo.WorkItemId.Id,
                        workItemField == null ? string.Empty : workItemField.Value);

                    DoNotContinueDispatchingCurrentMessageToHandlers();
                    MarkAsComplete();

                    return;
                }

                entityDto.ID = int.Parse(itemInfo.TpEntityId.Id);
                SendUpdateCommand(entityDto, itemInfo);
            }
        }
Пример #4
0
        public void Handle(ImportBugToTargetProcessCommand <BugzillaBug> message)
        {
            Data.ThirdPartyBug = message.ThirdPartyBug;

            var tpBug = ConvertToTpBug(message);

            var storedBug = _bugzillaInfoStorageRepository.GetTargetProcessBugId(message.ThirdPartyBug.bug_id);

            if (storedBug == null)
            {
                _logger.InfoFormat("Importing bug. {0}", message.ThirdPartyBug.ToString());
                Send(new CreateBugCommand(tpBug.BugDto));
                Data.CreatingBug = true;
            }
            else
            {
                _logger.InfoFormat("Updating bug. {0}", message.ThirdPartyBug.ToString());
                tpBug.BugDto.ID = storedBug.Value;
                Send(new UpdateBugCommand(tpBug.BugDto)
                {
                    ChangedFields = tpBug.ChangedFields.ToArray()
                });
                // We will not receive BugUpdatedMessage if no fields were changed. So we should process related entities immediately.
                SendLocal(new ExistingBugImportedToTargetProcessMessage <BugzillaBug> {
                    TpBugId = tpBug.BugDto.ID, ThirdPartyBug = Data.ThirdPartyBug
                });

                _bugzillaInfoStorageRepository.SaveBugzillaBugInfo(tpBug.BugDto.ID, new BugzillaBugInfo(message.ThirdPartyBug)
                {
                    TpId = tpBug.BugDto.ID
                });
            }
        }
        public bool RebuildIfNeeded(bool shouldRebuildIfNoProfile = false)
        {
            if (IsRebuildInProgress())
            {
                return(false);
            }
            if (shouldRebuildIfNoProfile && _profileCollection.Empty())
            {
                _logger.InfoFormat("Going to start rebuild becuase of no profile");
                DoRebuild();
                return(true);
            }
            var shouldRebuildIfNoActualVersionForAnyFile = _documentIndexProvider.DocumentIndexTypes.Any(type =>
            {
                var versions = type.GetVersions(_pluginContext.AccountName, _documentIndexSetup);
                return(versions.Except(new[] { type.Version }).Any());
            });
            var shouldRebuildIfNoFile = _documentIndexProvider.DocumentIndexTypes.All(type => type.GetVersions(_pluginContext.AccountName, _documentIndexSetup).Empty());

            if (shouldRebuildIfNoActualVersionForAnyFile || shouldRebuildIfNoFile)
            {
                _logger.InfoFormat("Going to start rebuild becuase of {0}", shouldRebuildIfNoActualVersionForAnyFile ? "no actual version of index file" : "no actual versions of index files");
                DoRebuild();
                return(true);
            }
            return(false);
        }
        protected void SetFieldFromMapping(string value, ConvertedBug convertedBug)
        {
            var mappedValue = Map[value];

            if (mappedValue.Id != 0)
            {
                SetValue(convertedBug, mappedValue.Id);
                convertedBug.ChangedFields.Add(BugField);
                _logger.InfoFormat("{0} mapped. Bug: {1}; Value: {2}", BugFieldName, convertedBug.BugDto.Name, value);
            }
        }
Пример #7
0
 private void AssignUserToBug(int?tpBugId, int?tpUserId, MappingLookup role)
 {
     if (role != null && tpUserId.HasValue)
     {
         _logger.InfoFormat("Assigning user. TargetProcess Bug ID: {0}; User ID: {1}; Role: {2}", tpBugId, tpUserId, role.Name);
         Data.ActionsInProgress++;
         Send(new CreateTeamCommand(new TeamDTO
         {
             AssignableID = tpBugId.GetValueOrDefault(),
             UserID       = tpUserId,
             RoleID       = role.Id
         }));
     }
 }
Пример #8
0
        public void Handle(AssignRevisionToEntityAction message)
        {
            Data.RevisionDto = message.Dto;

            var dto = new RevisionAssignableDTO
            {
                AssignableID = message.EntityId,
                RevisionID   = message.Dto.ID
            };

            Data.EntityId = message.EntityId;

            _logger.InfoFormat("Assigning revision to entity. Revision ID: {0}; Assignable ID: {1}", message.Dto.SourceControlID, message.EntityId);

            Send(new CreateEntityCommand <DataTransferObject>(dto));
        }
Пример #9
0
        private void ProcessNewlyChanges(DateTime?lastSyncDate)
        {
            var lastSyncronizationDate = LastSyncDates.FirstOrDefault();

            if (lastSyncDate == null || lastSyncronizationDate == null || !lastSyncronizationDate.GetValue().HasValue ||
                lastSyncronizationDate.GetValue().Value.AddMinutes(_storageRepository.GetProfile <BugzillaProfile>().SynchronizationInterval) < DateTime.Now)
            {
                var dateValue = GetSyncDate(lastSyncDate);

                var synchronizationTime = DateTime.Now;

                int[] changedIds;

                if (TryGetChangedIds(dateValue, out changedIds))
                {
                    if (changedIds.Length > 0)
                    {
                        _logger.InfoFormat("{0} changed bugs found", changedIds.Length);
                    }

                    LastSyncDates.ReplaceWith(new BugTracking.ImportToTp.LastSyncDate(synchronizationTime));
                    ProcessChangedBugIds(changedIds);
                }
                else
                {
                    FailedSyncDates.ReplaceWith(new FailedSyncDate(dateValue));
                }
            }
        }
 private void PushAttachmentsToTp(int?tpBugId, BugzillaBug bug, List <LocalStoredAttachment> attachments)
 {
     _logger.InfoFormat("Processing attachments. Bug: {0}", bug.ToString());
     _localBus.SendLocal(new PushAttachmentsToTpCommandInternal
     {
         LocalStoredAttachments = attachments.ToArray(),
         GeneralId = tpBugId
     });
 }
        public void Handle(NewRevisionRangeDetectedLocalMessage message)
        {
            _logger.Info("Retrieving new revisions");
            var revisions = _versionControlSystem.GetRevisions(message.Range);

            _logger.Info("Filtering out non-assignable revisions");
            revisions = revisions.Where(ContainsEntityId).ToArray();

            _logger.InfoFormat("Revisions retrieved. Revision IDs: {0}", string.Join(", ", revisions.Select(x => x.Id.Value).ToArray()));

            SendLocal(revisions);
        }
Пример #12
0
        private string OnExecute(string args)
        {
            var profile = _storageRepository.GetProfile <TestRunImportPluginProfile>();

            _log.InfoFormat("Started synchronizing at {0}", DateTime.Now);

            if (!string.IsNullOrEmpty(args) && profile.FrameworkType == FrameworkTypes.FrameworkTypes.Selenium)
            {
                using (var reader = new StringReader(args))
                {
                    try
                    {
                        var result = _resultsReaderFactory.GetResolver(profile, reader).GetTestRunImportResults();
                        _log.InfoFormat("{0} items for import detected in resutls source", result.Count == 0 ? "No" : result.Count.ToString());
                        if (result.Count > 0)
                        {
                            _localBus.SendLocal(new TestRunImportResultDetectedLocalMessage
                            {
                                TestRunImportInfo =
                                    new TestRunImportInfo {
                                    TestRunImportResults = result.ToArray()
                                }
                            });
                        }
                    }
                    catch (ApplicationException)
                    {
                        throw;
                    }
                    catch (Exception ex)
                    {
                        throw new ApplicationException(
                                  string.Format("Could not read file \"{0}\": {1}", profile.ResultsFilePath, ex.Message), ex);
                    }
                }
            }
            //return new PluginCommandResponseMessage { ResponseData = string.Empty, PluginCommandStatus = PluginCommandStatus.Succeed };
            return(string.Empty);
        }
        public void Handle(RevisionCreatedLocalMessage message)
        {
            _logger.InfoFormat("Parsing comment. Revision ID: {0}", message.Dto.SourceControlID);

            var commentParser     = new CommentParser();
            var actions           = commentParser.ParseAssignToEntityAction(message.Dto);
            var actionParamFiller = new ActionParameterFillerVisitor(message.Dto);

            foreach (var action in actions)
            {
                action.Execute(actionParamFiller, x => _bus.SendLocal(action), _logger);
            }
        }
        private void AssignUser(TeamDTO team, string userEmail, Action sucess)
        {
            if (!NeedToProcess(team) || AnotherRole(team))
            {
                return;
            }

            var bugzillaBug = _bugzillaInfoStorageRepository.GetBugzillaBug(team.AssignableID);

            _logger.InfoFormat("Changing bug assignment in Bugzilla. TargetProcess Bug ID: {0}; Email: {1}", bugzillaBug.TpId, userEmail);

            try
            {
                _service.Execute(_actionFactory.GetAssigneeAction(bugzillaBug.Id, userEmail));
                sucess();
            }
            catch (Exception ex)
            {
                _logger.Error(ex.Message, ex);
            }

            _logger.InfoFormat("Bug assignment changed in Bugzilla. TargetProcess Bug ID: {0}; Email: {1}", bugzillaBug.TpId, userEmail);
        }
Пример #15
0
        public void Handle(CommentCreatedMessage message)
        {
            if (!NeedToProcess(message.Dto))
            {
                return;
            }

            _logger.InfoFormat("Importing comment to Bugzilla. TargetProcess Bug ID: {0}", message.Dto.GeneralID);

            try
            {
                var offset = _bugzillaService.GetTimeOffset();

                _bugzillaService.Execute(_actionFactory.GetCommentAction(message.Dto, offset));
                _storage.Get <CommentDTO>(message.Dto.GeneralID.ToString()).Add(message.Dto);
            }
            catch (Exception ex)
            {
                _logger.Error(ex.Message, ex);
            }

            _logger.InfoFormat("Comment imported to Bugzilla. TargetProcess Bug ID: {0}", message.Dto.GeneralID);
        }
        public void Handle(EmailUidsRetrievedMessage message)
        {
            try
            {
                _log.InfoFormat("Downloading {0} messages from email server...", message.Uids.Count());
                _client.Connect();
                _client.Login();

                var count = 0;
                while (ReadNextEmailMessage(message.Uids))
                {
                    count++;
                }
                _log.InfoFormat("Downloaded messages={0}", count);
            }
            catch (Exception ex)
            {
                _client.Disconnect();
                _log.Error(String.Format("Error downloading messages."), ex);
                var skippedUids = message.Uids.Where(x => !_processedUids.Contains(x));
                _messageUidRepository.Remove(skippedUids.ToArray());
            }
        }
Пример #17
0
        public void Handle(ImportBugsChunk message)
        {
            bugCollection bugs;

            _logger.Info("Retrieving changed bugs");
            if (TryGetChangedBugsChunk(message.ThirdPartyBugsIds, out bugs))
            {
                _logger.InfoFormat("Bugs retrieved. Bugzilla Bug IDs: {0}", string.Join(", ", message.ThirdPartyBugsIds.Select(x => x.ToString()).ToArray()));
                CreateBugsInTargetProcess(bugs);
            }
            else
            {
                FailedChunks.Add(new FailedChunk(message.ThirdPartyBugsIds));
            }
        }
Пример #18
0
        public void Handle(ExistingBugImportedToTargetProcessMessage <BugzillaBug> message)
        {
            var newComments =
                message.ThirdPartyBug.comments
                .Where(comment => !CommentExists(message, comment))
                .Reverse()
                .ToList();

            if (newComments.Any())
            {
                _logger.InfoFormat("Importing {1} comment(s) for bug. {0}", message.ThirdPartyBug.ToString(), newComments.Count);
            }

            CreateComments(newComments, message.TpBugId);
        }
        public static RevisionInfo[] ArrayOfSvnRevisionToArrayOfRevisionInfo(Collection <SvnLogEventArgs> svnRevisions,
                                                                             IVersionControlSystem versionControlSystem)
        {
            var tpRevisionInfo = new List <RevisionInfo>(svnRevisions.Count);

            _log.InfoFormat("Process svn revisions...");
            foreach (var svnRevision in svnRevisions)
            {
                _log.InfoFormat("Do processing of revision {0}", svnRevision.Revision);

                if (svnRevision.Revision == 0 ||
                    svnRevision.ChangedPaths == null ||
                    svnRevision.ChangedPaths.Count == 0)
                {
                    continue;
                }

                _log.Info("Adding revisions infos");

                var info = SvnRevisionToRevisionInfo(svnRevision, versionControlSystem);
                tpRevisionInfo.Add(info);
            }
            return(tpRevisionInfo.ToArray());
        }
 protected override void Log(IActivityLogger logger)
 {
     logger.InfoFormat("Posting comment. Entity ID: {0}; Comment: {1}; Author: {2}", EntityId, Comment, UserId);
 }
		protected override void Log(IActivityLogger logger)
		{
			logger.InfoFormat("Changing entity state. Entity ID: {0}; Entity State: {1}; Comment: {2}; Default comment: {3}", EntityId, Status, Comment, DefaultComment);
		}
Пример #22
0
 protected override void Log(IActivityLogger logger)
 {
     logger.InfoFormat("Posting time. Entity ID: {0}; User ID: {3}; Time spent: {1:0.00}; Time left: {2:0.00}", EntityId, TimeSpent, TimeLeft, UserId);
 }
		public void Handle(TickMessage message)
		{
			var profile = _storageRepository.GetProfile<TestRunImportPluginProfile>();
			if (profile.FrameworkType == FrameworkTypes.FrameworkTypes.Selenium && profile.PostResultsToRemoteUrl)
			{
				return;
			}

			try
			{
				_log.InfoFormat("Started synchronizing at {0}", DateTime.Now);

				var lastModifyResults = _storageRepository.Get<LastModifyResult>();
				var lastModifyResult = lastModifyResults.Empty() ? new LastModifyResult() : lastModifyResults.Single();

				var jenkinsHudsonLastCompletedBuildNumber = profile.FrameworkType == FrameworkTypes.FrameworkTypes.JenkinsHudson ?
					GetJenkinsHudsonLastCompletedBuildNumber(profile) : null;

				if (profile.FrameworkType == FrameworkTypes.FrameworkTypes.JenkinsHudson &&
						(jenkinsHudsonLastCompletedBuildNumber == null || string.CompareOrdinal(lastModifyResult.ETagHeader, jenkinsHudsonLastCompletedBuildNumber) == 0))
				{
					_log.Info("No new modification of results source detected");
					return;
				}

				var uri = profile.FrameworkType == FrameworkTypes.FrameworkTypes.JenkinsHudson
										? new Uri(string.Format("{0}/lastCompletedBuild/testReport/api/xml", profile.ResultsFilePath.TrimEnd(new[] { '/', '\\' })))
										: new Uri(profile.ResultsFilePath);
				var factoryResult = _streamFactory.OpenStreamIfModified(uri, lastModifyResult, profile.PassiveMode);

				_log.InfoFormat("{0} modification of results source detected", factoryResult == null ? "No new" : "New");

				if (factoryResult != null)
				{
					if (profile.FrameworkType == FrameworkTypes.FrameworkTypes.JenkinsHudson)
					{
						factoryResult.LastModifyResult.ETagHeader = jenkinsHudsonLastCompletedBuildNumber;
					}

					lastModifyResults.Clear();
					lastModifyResults.Add(factoryResult.LastModifyResult);

					using (factoryResult.Stream)
					{
						using (var reader = new StreamReader(factoryResult.Stream))
						{
							try
							{
								var result = _resultsReaderFactory.GetResolver(profile, reader).GetTestRunImportResults();
								_log.InfoFormat("{0} items for import detected in resutls source", result.Count == 0 ? "No" : result.Count.ToString(CultureInfo.InvariantCulture));
								if (result.Count > 0)
								{
									_localBus.SendLocal(new TestRunImportResultDetectedLocalMessage
																				{
																					TestRunImportInfo =
																						new TestRunImportInfo { TestRunImportResults = result.ToArray() }
																				});
								}
							}
							catch (ApplicationException)
							{
								throw;
							}
							catch (XmlException ex)
							{
								throw new ApplicationException("Error parsing results XML file", ex);
							}
							catch (Exception ex)
							{
								throw new ApplicationException("Error importing results XML file", ex);
							}
						}
					}
				}
			}
			catch (UriFormatException ex)
			{
				_log.Error(ex.Message);
				throw new ApplicationException(string.Format("Specified path has invalid format. {0}", ex.Message), ex);
			}
			catch (ApplicationException ex)
			{
				_log.Error(ex.Message);
				throw;
			}
			catch (Exception ex)
			{
				_log.ErrorFormat("Could not read file \"{0}\": {1}", profile.ResultsFilePath, ex.Message);
				throw new ApplicationException(
					string.Format("Could not read file \"{0}\": {1}", profile.ResultsFilePath, ex.Message), ex);
			}
		}
Пример #24
0
 protected override void Log(IActivityLogger logger)
 {
     logger.InfoFormat("Changing entity state. Entity ID: {0}; Entity State: {1}; Comment: {2}; Default comment: {3}", EntityId, Status, Comment, DefaultComment);
 }
		protected override void Log(IActivityLogger logger)
		{
			logger.InfoFormat("Posting time. Entity ID: {0}; User ID: {3}; Time spent: {1:0.00}; Time left: {2:0.00}", EntityId, TimeSpent, TimeLeft, UserId);
		}
		protected override void Log(IActivityLogger logger)
		{
			logger.InfoFormat("Posting comment. Entity ID: {0}; Comment: {1}; Author: {2}", EntityId, Comment, UserId);
		}