JD2022-TU1/main/tools/qa/Coverity/CoverityJiraConnectorApp/CoverityWebService/CoverityWebServices.cs

using System;
using System.Collections.Generic;
using System.Linq;
using CoverityWebService.AdministrationService;
using CoverityWebService.ConfigurationService;
using CoverityWebService.DefectService;
using WebServices20.BindingExtenions;
using componentIdDataObj = CoverityWebService.ConfigurationService.componentIdDataObj;
using groupIdDataObj = CoverityWebService.ConfigurationService.groupIdDataObj;
using pageSpecDataObj = CoverityWebService.AdministrationService.pageSpecDataObj;

namespace CoverityWebService
{
    public class CoverityWebServices
    {
    protected readonly AdministrationServiceClient _adminclient;
    protected readonly DefectServiceClient _defectclient;
    protected readonly ConfigurationServiceClient _configclient;

    public CoverityWebServices(string username, string password, string url)
    {
        var binding = new ClearUsernameBinding();
        binding.SetMessageVersion(System.ServiceModel.Channels.MessageVersion.Soap11);

        _adminclient = new AdministrationServiceClient(binding, new System.ServiceModel.EndpointAddress(url + "/ws/v3/administrationservice"));

        _defectclient = new DefectServiceClient(binding, new System.ServiceModel.EndpointAddress(url + "/ws/v3/defectservice"));

        _configclient = new ConfigurationServiceClient(binding, new System.ServiceModel.EndpointAddress(url + "/ws/v3/configurationservice"));


        // ReSharper disable PossibleNullReferenceException
        _adminclient.ClientCredentials.UserName.UserName = username;
        _adminclient.ClientCredentials.UserName.Password = password;

        _defectclient.ClientCredentials.UserName.UserName = username;
        _defectclient.ClientCredentials.UserName.Password = password;


        _configclient.ClientCredentials.UserName.UserName = username;
        _configclient.ClientCredentials.UserName.Password = password;
        // ReSharper restore PossibleNullReferenceException
    }

    public IEnumerable<string> GetProjects()
    {
      var projects = _configclient.getProjects(new projectFilterSpecDataObj());
      return projects.Select(project => project.id.name).ToList();
    }

    public IEnumerable<KeyValuePair<string, IEnumerable<string>>> GetComponentMaps()
    {
      var componentmapfilter = new componentMapFilterSpecDataObj {namePattern = "*"};
      var componentmaps = _configclient.getComponentMaps(componentmapfilter);
      return componentmaps.Select(componentmap => new KeyValuePair<string, IEnumerable<string>>(componentmap.componentMapId.name, componentmap.components.Select(component => component.componentId.name))).ToList();
    }

    public IEnumerable<KeyValuePair<string, IEnumerable<string>>> GetUserGroups()
    {
      var groups = new List<KeyValuePair<string, IEnumerable<string>>>();
      var page = new pageSpecDataObj {pageSize = 100};
      foreach (var group in _adminclient.getAllGroups(page).groups.Where(group => group != null))
      {
        var users = _adminclient.getUsersForGroup(group.name);
        if (users == null)
          continue;
        groups.Add(new KeyValuePair<string, IEnumerable<string>>(group.name.name, users.Select(user => string.Format("{0} {1}", user.givenName, user.familyName)).ToList()));
      }
      return groups;
    }

    public void CreateComponentMap(string componentmap)
    {
      var componentmapfilter = new componentMapFilterSpecDataObj { namePattern = componentmap };
      var componentmaps = _configclient.getComponentMaps(componentmapfilter);
      if (componentmaps != null && componentmaps.Length > 0)
      {
        Console.Error.WriteLine(string.Format("Create componentmap: {0} already exists!", componentmap));
        return;
      }

      _configclient.createComponentMap(new componentMapSpecDataObj { componentMapName = componentmap });
      Console.WriteLine(string.Format("Componentmap: {0} created succesfully!", componentmap));
    }

    public void CreateComponent(string componentmap, string component, string pattern)
    {
      var componentmapfilter = new componentMapFilterSpecDataObj {namePattern = componentmap};
      var componentmaps = _configclient.getComponentMaps(componentmapfilter);
      if (componentmaps == null || componentmaps.Length != 1)
      {
        Console.Error.WriteLine(string.Format("Create component: can't find componentmap: {0}", componentmap));
        return;
      }

      component = string.Format("{0}.{1}", componentmap, component);

      // add component
      var components = componentmaps[0].components.ToList();
      if (components.Select(c => c.componentId.name).Where(c => c == component).Any())
      {
        Console.Error.WriteLine(string.Format("Create component: {0} already exists!", componentmap));
        return;
      }

      components.Add(new componentDataObj
                       {
                         componentId = new componentIdDataObj {name = component},
                         excludeComponent = false,
                         groupPermissions = new[] {new groupPermissionDataObj {groupId = new groupIdDataObj {name = "Users"}, accessAllowed = true}}
                       });

      // add file rules
      var componentmaprules = componentmaps[0].componentPathRules == null ? new List<componentPathRuleDataObj>() : componentmaps[0].componentPathRules.ToList();
      componentmaprules.Add(new componentPathRuleDataObj {componentId = new componentIdDataObj {name = component}, pathPattern = pattern});
      _configclient.updateComponentMap(componentmaps[0].componentMapId, new componentMapSpecDataObj
                                                                      {
                                                                        componentMapName = componentmap,
                                                                        components = components.ToArray(),
                                                                        componentPathRules = componentmaprules.ToArray(),
                                                                      });
      Console.WriteLine(string.Format("Component: {0} created succesfully!", component));
    }

    public void CreateUser(string url, string familyname, string givenname, string email)
    {
      var username = string.Format("{0}{1}", givenname, familyname.Substring(0, 2));
      var existinguser = _adminclient.getUser(username);
      if (existinguser != null)
      {
        Console.Error.WriteLine(string.Format("Create user: {0} already exists!", username));
        return;
      }

      var user = new userSpecDataObj
                {
                  familyName = familyname,
                  givenName = givenname,
                  email = email,
                  local = true,
                  username = username,
                  password = "coverity",
                  disabled = false,
                  locked = false,
                  groupNames = new[] {new AdministrationService.groupIdDataObj {name = "Users"} }
                };
      _adminclient.createUser(user);
      Console.WriteLine(string.Format("User: {0} created succesfully!", username));
      _adminclient.notify(new[] { username }, "New Account Created", string.Format("A new account has just been created for you. You can sign in at {0}, with the user name ({1}), and password (coverity).", url, username));
    }
  }
}