private BugzillaProfile Parse(XmlDocument document)
        {
            var result = new BugzillaProfile();
            var root   = document.SelectSingleNode("./{0}".Fmt(LegacyBugzillaProfileFields.XmlRoot));

            result.Url           = GetValueByName(root, LegacyBugzillaProfileFields.Url);
            result.Login         = GetValueByName(root, LegacyBugzillaProfileFields.Login);
            result.Password      = GetValueByName(root, LegacyBugzillaProfileFields.Password);
            result.Project       = Int32.Parse(GetValueByName(root, LegacyBugzillaProfileFields.Project), CultureInfo.InvariantCulture);
            result.SavedSearches = GetValueByName(root, LegacyBugzillaProfileFields.Queries);

            var mapping = GetValueByName(root, LegacyBugzillaProfileFields.Maps);
            var parser  = new LegacyMappingParser();

            if (!string.IsNullOrEmpty(mapping))
            {
                parser.Maps = mapping;

                MapUsers(result, parser);
                MapPriorities(result, parser);
                MapSeverities(result, parser);
                MapEntityState(result, parser);
                MapRoles(result, root);
            }

            return(result);
        }
 private void AddRole(BugzillaProfile result, MappingElement role)
 {
     if (role != null)
     {
         result.RolesMapping.Add(role);
     }
 }
 public void ShouldRemoveWhitespacesFromQueryField()
 {
     var profile = new BugzillaProfile
                   	{
                   		SavedSearches = " query1, query2 "
                   	};
     profile.SavedSearches.Should(Be.EqualTo("query1,query2"));
 }
 public void ShouldRemoveWhitespacesFromUrlField()
 {
     var profile = new BugzillaProfile
                   	{
                   		Url = " http://url "
                   	};
     profile.Url.Should(Be.EqualTo("http://url"));
 }
        public void ShouldRemoveWhitespacesFromUrlField()
        {
            var profile = new BugzillaProfile
            {
                Url = " http://url "
            };

            profile.Url.Should(Be.EqualTo("http://url"));
        }
        public void ShouldRemoveWhitespacesFromQueryField()
        {
            var profile = new BugzillaProfile
            {
                SavedSearches = " query1, query2 "
            };

            profile.SavedSearches.Should(Be.EqualTo("query1,query2"));
        }
        private void MapRoles(BugzillaProfile result, XmlNode root)
        {
            var assigneeRole = CreateRole(DefaultRoles.Assignee, LegacyBugzillaProfileFields.AssigneeRole, root);

            AddRole(result, assigneeRole);

            var reporterRole = CreateRole(DefaultRoles.Reporter, LegacyBugzillaProfileFields.ReporterRole, root);

            AddRole(result, reporterRole);
        }
        private void MapEntityState(BugzillaProfile result, LegacyMappingParser parser)
        {
            var project = _context.Projects.Single(p => p.ProjectID == result.Project);
            var process = _context.Processes.SingleOrDefault(p => p.ProcessID == project.ProcessID);

            foreach (string state in parser.EntityStates.Keys)
            {
                Func <EntityState, string> comparator = x => x.Name;
                var tpState = GetEntityStateBy(process, BugzillaConstants.BugEntityTypeId, parser.EntityStates[state], comparator);

                if (tpState != null)
                {
                    result.StatesMapping.Add(new MappingElement {
                        Key = state, Value = Create(tpState)
                    });
                }
            }
        }
Example #9
0
        public BugzillaProperties GetBugzillaProperties(BugzillaProfile profile, PluginProfileErrorCollection errors)
        {
            profile.ValidateCredentials(errors);

            if (!errors.Any())
            {
                try
                {
                    _logger.Info("Checking connection");
                    var bugzillaProperties = new BugzillaService().CheckConnection(profile);
                    _logger.Info("Connection success");
                    return(new BugzillaProperties(bugzillaProperties));
                }
                catch (BugzillaPluginProfileException e)
                {
                    e.ErrorCollection.ForEach(errors.Add);
                    _logger.WarnFormat("Connection failed: {0}", e);
                }
            }

            return(null);
        }
        private void MapUsers(BugzillaProfile result, LegacyMappingParser parser)
        {
            foreach (string user in parser.Users.Keys)
            {
                var tpUser = GetUserForProjectBy(result.Project, parser.Users[user], x => x.Login);
                if (tpUser != null)
                {
                    result.UserMapping.Add(new MappingElement {
                        Key = user, Value = Create(tpUser)
                    });
                    continue;
                }

                tpUser = GetUserForProjectBy(result.Project, parser.Users[user], x => x.Email);
                if (tpUser != null)
                {
                    result.UserMapping.Add(new MappingElement {
                        Key = user, Value = Create(tpUser)
                    });
                }
            }
        }
		public BugzillaProperties GetBugzillaProperties(BugzillaProfile profile, PluginProfileErrorCollection errors)
		{
			profile.ValidateCredentials(errors);

			if (!errors.Any())
			{
				try
				{
					_logger.Info("Checking connection");
					var bugzillaProperties = new BugzillaService().CheckConnection(profile);
					_logger.Info("Connection success");
					return new BugzillaProperties(bugzillaProperties);
				}
				catch (BugzillaPluginProfileException e)
				{
					e.ErrorCollection.ForEach(errors.Add);
					_logger.WarnFormat("Connection failed: {0}", e);
				}
			}

			return null;
		}
Example #12
0
        private void SetDefaultRolesMapping(BugzillaProfile profile)
        {
            var roles    = Roles;
            var assignee = roles.Where(x => x.Name == "Developer").Single();
            var reporter = roles.Where(x => x.Name == "QA Engineer").Single();

            profile.RolesMapping = new MappingContainer
            {
                new MappingElement
                {
                    Key   = DefaultRoles.Assignee,
                    Value = new MappingLookup {
                        Id = assignee.ID.Value, Name = assignee.Name
                    }
                },
                new MappingElement
                {
                    Key   = DefaultRoles.Reporter,
                    Value = new MappingLookup {
                        Id = reporter.ID.Value, Name = reporter.Name
                    }
                }
            };
        }
 public void GivenProfile()
 {
     _settings = BugzillaContext.GetBugzillaProfile(1);
 }
Example #14
0
 public void AddProfileWithDefaultRolesMapping(int projectId, BugzillaProfile profile)
 {
     AddProfileWithDefaultRolesMapping("TestProfile", projectId, profile);
 }
Example #15
0
 protected Validator(BugzillaProfile profile)
 {
     _profile = profile;
 }
Example #16
0
 public void AddProfileWithDefaultRolesMapping(string profileName, int projectId, BugzillaProfile profile)
 {
     SetDefaultRolesMapping(profile);
     TransportMock.AddProfile(profileName, profile);
 }
 public void GivenProfile()
 {
     _settings = BugzillaContext.GetBugzillaProfile(1);
 }
		protected Validator(BugzillaProfile profile)
		{
			_profile = profile;
		}