void SetupClient(IOctopusClient client) { client.Repository.LoadRootDocument().Returns(new RootResource() { Version = NotSupportedOctopusVersion }); }
public static List <ProjectTriggerResource> FindAllProjectTriggers(this IOctopusClient client, ProjectResource project) { var items = new List <ProjectTriggerResource>(); client.Paginate(project.Links["Triggers"], (ResourceCollection <ProjectTriggerResource> page) => { items.AddRange(page.Items); return(true); }); return(items); }
public OctopusRepository(IOctopusClient client, RepositoryScope repositoryScope = null) { Client = client; Scope = repositoryScope ?? RepositoryScope.Unspecified(); Accounts = new AccountRepository(this); ActionTemplates = new ActionTemplateRepository(this); Artifacts = new ArtifactRepository(this); Backups = new BackupRepository(this); BuiltInPackageRepository = new BuiltInPackageRepositoryRepository(this); CertificateConfiguration = new CertificateConfigurationRepository(this); Certificates = new CertificateRepository(this); Channels = new ChannelRepository(this); CommunityActionTemplates = new CommunityActionTemplateRepository(this); Configuration = new ConfigurationRepository(this); DashboardConfigurations = new DashboardConfigurationRepository(this); Dashboards = new DashboardRepository(this); Defects = new DefectsRepository(this); DeploymentProcesses = new DeploymentProcessRepository(this); Deployments = new DeploymentRepository(this); Environments = new EnvironmentRepository(this); Events = new EventRepository(this); FeaturesConfiguration = new FeaturesConfigurationRepository(this); Feeds = new FeedRepository(this); Interruptions = new InterruptionRepository(this); LibraryVariableSets = new LibraryVariableSetRepository(this); Lifecycles = new LifecyclesRepository(this); MachinePolicies = new MachinePolicyRepository(this); MachineRoles = new MachineRoleRepository(this); Machines = new MachineRepository(this); Migrations = new MigrationRepository(this); OctopusServerNodes = new OctopusServerNodeRepository(this); PerformanceConfiguration = new PerformanceConfigurationRepository(this); PackageMetadataRepository = new PackageMetadataRepository(this); ProjectGroups = new ProjectGroupRepository(this); Projects = new ProjectRepository(this); ProjectTriggers = new ProjectTriggerRepository(this); Proxies = new ProxyRepository(this); Releases = new ReleaseRepository(this); RetentionPolicies = new RetentionPolicyRepository(this); Schedulers = new SchedulerRepository(this); ServerStatus = new ServerStatusRepository(this); Spaces = new SpaceRepository(this); Subscriptions = new SubscriptionRepository(this); TagSets = new TagSetRepository(this); Tasks = new TaskRepository(this); Teams = new TeamsRepository(this); Tenants = new TenantRepository(this); TenantVariables = new TenantVariablesRepository(this); UserRoles = new UserRolesRepository(this); Users = new UserRepository(this); VariableSets = new VariableSetRepository(this); Workers = new WorkerRepository(this); WorkerPools = new WorkerPoolRepository(this); ScopedUserRoles = new ScopedUserRoleRepository(this); UserPermissions = new UserPermissionsRepository(this); UserInvites = new UserInvitesRepository(this); loadRootResource = new Lazy <RootResource>(LoadRootDocumentInner, true); loadSpaceRootResource = new Lazy <SpaceRootResource>(LoadSpaceRootDocumentInner, true); }
protected BasicRepository(IOctopusRepository repository, string collectionLinkName, Func <IOctopusRepository, string> getCollectionLinkName = null) { Repository = repository; client = repository.Client; CollectionLinkName = collectionLinkName; AdditionalQueryParameters = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase); this.getCollectionLinkName = getCollectionLinkName; }
static string DetermineCollectionLinkName(IOctopusClient client) { // For backwards compatibility. // In Octopus 3.11, what was Certificates was moved to CertificatesConfiguration, to make room for the certificates feature. // This allows pre-3.11 clients to still work. // The null check is just for tests. return(client.RootDocument == null || client.RootDocument.Links.ContainsKey("CertificateConfiguration") ? "CertificateConfiguration" : "Certificates"); }
/// <summary> /// Gathers the Interruptions tied to a Task /// </summary> /// <param name="client">The Repository this is tacked on to.</param> /// <param name="resourceId">The resource id to returns interruptions for.</param> /// <param name="pendingOnly">Returns only pending interruptions.</param> /// <returns>Enumerable of InterruptionResources.</returns> internal static IEnumerable <InterruptionResource> GetResourceInterruptions(this IOctopusClient client, string resourceId, bool pendingOnly) { var interruptions = new List <InterruptionResource>(); client.Paginate <InterruptionResource>(string.Format(ResourceStrings.InterruptionRegardingLink, client.RootDocument.Link(ResourceStrings.InterruptionLink), resourceId, pendingOnly.ToString()), new { }, page => { interruptions.AddRange(page.Items); return(true); }); return(interruptions); }
/// <summary> /// Gathers the Events tied to a resource for auditing. /// </summary> /// <param name="client">The Repository this is tacked on to.</param> /// <param name="resourceId">The resource id of the object for events returned.</param> /// <param name="eventCategory">The type of category of events returned [null returns all].</param> /// <returns>Enumerable of EventsResources.</returns> internal static IEnumerable <EventResource> GetResourceEvents(this IOctopusClient client, string resourceId, string eventCategory) { var events = new List <EventResource>(); client.Paginate <EventResource>(string.Format(ResourceStrings.EventRegardingLink, client.RootDocument.Link(ResourceStrings.EventLink), resourceId, eventCategory), new { }, page => { events.AddRange(page.Items); return(true); }); return(events); }
/// <summary> /// Gathers deployments based on release /// </summary> /// <param name="client">The Repository this is tacked on to.</param> /// <param name="release">The release to get deployments of.</param> /// <returns>Enumerable of Deployment Resources.</returns> internal static IEnumerable <DeploymentResource> GetReleaseDeployments(this IOctopusClient client, ReleaseResource release) { List <DeploymentResource> deployments = new List <DeploymentResource>(); client.Paginate <DeploymentResource>(release.Link(ResourceStrings.DeploymentLink), new { }, page => { deployments.AddRange(page.Items); return(true); }); return(deployments); }
/// <summary> /// Gathers the releases Tied to a channel. /// </summary> /// <param name="client">The Repository this is tacked on to.</param> /// <param name="channel">The channel to gather</param> /// <returns>Enumerable of Release Resources.</returns> internal static IEnumerable <ReleaseResource> GetChannelReleases(this IOctopusClient client, ChannelResource channel) { List <ReleaseResource> releases = new List <ReleaseResource>(); client.Paginate <ReleaseResource>(channel.Link(ResourceStrings.ReleaseLink), new { }, page => { releases.AddRange(page.Items); return(true); }); return(releases); }
/// <summary> /// Gets the Channels of the passed Project /// </summary> /// <param name="client">The Repository this is tacked on to.</param> /// <param name="project">The Project to get Channels of</param> /// <returns></returns> internal static IEnumerable <ChannelResource> GetProjectChannels(this IOctopusClient client, ProjectResource project) { List <ChannelResource> channels = new List <ChannelResource>(); client.Paginate <ChannelResource>(project.Link(ResourceStrings.ChannelLink), new { }, page => { channels.AddRange(page.Items); return(true); }); return(channels); }
/// <summary> /// Clones one project from another. /// </summary> /// <param name="client">The Repository this is tacked on to.</param> /// <param name="newProjectName">The new project's name.</param> /// <param name="newProjectDescription">The new project's description,</param> /// <param name="projectToClone">The project to clone from.</param> /// <param name="projectGroupIdForNewProject">The group the project will be placed into [null will copy the group from the projectToClone].</param> /// <param name="lifcycleId">The life cycle of the new project [null will copy the lifecycle from the projectToClone].</param> internal static void CloneProject(this IOctopusClient client, string newProjectName, string newProjectDescription, ProjectResource projectToClone, string projectGroupIdForNewProject, string lifcycleId) { var projectToCreate = new ProjectResource { Name = newProjectName, Description = newProjectDescription, ProjectGroupId = projectGroupIdForNewProject, LifecycleId = lifcycleId }; client.Post(string.Format(ResourceStrings.CloneCommandApiFormat, projectToClone.Id), projectToCreate); }
public OctopusRepository(IOctopusClient client) { this.Client = client; Accounts = new AccountRepository(client); ActionTemplates = new ActionTemplateRepository(client); Artifacts = new ArtifactRepository(client); Backups = new BackupRepository(client); BuiltInPackageRepository = new BuiltInPackageRepositoryRepository(client); CertificateConfiguration = new CertificateConfigurationRepository(client); Certificates = new CertificateRepository(client); Channels = new ChannelRepository(client); CommunityActionTemplates = new CommunityActionTemplateRepository(client); Configuration = new ConfigurationRepository(client); DashboardConfigurations = new DashboardConfigurationRepository(client); Dashboards = new DashboardRepository(client); Defects = new DefectsRepository(client); DeploymentProcesses = new DeploymentProcessRepository(client); Deployments = new DeploymentRepository(client); Environments = new EnvironmentRepository(client); Events = new EventRepository(client); FeaturesConfiguration = new FeaturesConfigurationRepository(client); Feeds = new FeedRepository(client); Interruptions = new InterruptionRepository(client); LibraryVariableSets = new LibraryVariableSetRepository(client); Lifecycles = new LifecyclesRepository(client); MachinePolicies = new MachinePolicyRepository(client); MachineRoles = new MachineRoleRepository(client); Machines = new MachineRepository(client); Migrations = new MigrationRepository(client); OctopusServerNodes = new OctopusServerNodeRepository(client); PerformanceConfiguration = new PerformanceConfigurationRepository(client); ProjectGroups = new ProjectGroupRepository(client); Projects = new ProjectRepository(client); ProjectTriggers = new ProjectTriggerRepository(client); Proxies = new ProxyRepository(client); Releases = new ReleaseRepository(client); RetentionPolicies = new RetentionPolicyRepository(client); Schedulers = new SchedulerRepository(client); ServerStatus = new ServerStatusRepository(client); Subscriptions = new SubscriptionRepository(client); TagSets = new TagSetRepository(client); Tasks = new TaskRepository(client); Teams = new TeamsRepository(client); Tenants = new TenantRepository(client); TenantVariables = new TenantVariablesRepository(client); UserRoles = new UserRolesRepository(client); Users = new UserRepository(client); VariableSets = new VariableSetRepository(client); Workers = new WorkerRepository(client); WorkerPools = new WorkerPoolRepository(client); }
/// <summary> /// Gathers the Users from a Team. /// </summary> /// <param name="client">The Repository this is tacked on to.</param> /// <param name="team">The team to return the user resources from.</param> /// <returns>Enumerable of UserResources.</returns> internal static IEnumerable <UserResource> GetTeamUsers(this IOctopusClient client, TeamResource team) { List <UserResource> users = new List <UserResource>(); foreach (var userId in team.MemberUserIds) { var user = client.Get <UserResource>(string.Format(ResourceStrings.TeamUserIdFormat, userId)); if (user != null) { users.Add(user); } } return(users); }
private void Assertion(IOctopusClient client) { var repository = new OctopusRepository(client); var nullPropertiesQ = from p in typeof(OctopusRepository).GetProperties() where !delayInitialisedProperties.Contains(p.Name) where p.GetMethod.Invoke(repository, new object[0]) == null select p.Name; var nullProperties = nullPropertiesQ.ToArray(); if (nullProperties.Any()) { Assert.Fail("The following properties are null after OctopusAsyncRepository instantiation: " + nullProperties.CommaSeperate()); } }
public OctopusRepository(IOctopusClient client) { this.Client = client; Feeds = new FeedRepository(client); Backups = new BackupRepository(client); Machines = new MachineRepository(client); MachineRoles = new MachineRoleRepository(client); MachinePolicies = new MachinePolicyRepository(client); Subscriptions = new SubscriptionRepository(client); Environments = new EnvironmentRepository(client); Events = new EventRepository(client); FeaturesConfiguration = new FeaturesConfigurationRepository(client); ProjectGroups = new ProjectGroupRepository(client); Projects = new ProjectRepository(client); Proxies = new ProxyRepository(client); Tasks = new TaskRepository(client); Users = new UserRepository(client); VariableSets = new VariableSetRepository(client); LibraryVariableSets = new LibraryVariableSetRepository(client); DeploymentProcesses = new DeploymentProcessRepository(client); Releases = new ReleaseRepository(client); Deployments = new DeploymentRepository(client); Certificates = new CertificateRepository(client); Dashboards = new DashboardRepository(client); DashboardConfigurations = new DashboardConfigurationRepository(client); Artifacts = new ArtifactRepository(client); Interruptions = new InterruptionRepository(client); ServerStatus = new ServerStatusRepository(client); UserRoles = new UserRolesRepository(client); Teams = new TeamsRepository(client); RetentionPolicies = new RetentionPolicyRepository(client); Accounts = new AccountRepository(client); Defects = new DefectsRepository(client); Lifecycles = new LifecyclesRepository(client); OctopusServerNodes = new OctopusServerNodeRepository(client); Channels = new ChannelRepository(client); ProjectTriggers = new ProjectTriggerRepository(client); Schedulers = new SchedulerRepository(client); Tenants = new TenantRepository(client); TagSets = new TagSetRepository(client); BuiltInPackageRepository = new BuiltInPackageRepositoryRepository(client); ActionTemplates = new ActionTemplateRepository(client); CommunityActionTemplates = new CommunityActionTemplateRepository(client); }
public void SetUp() { clientFactory = Substitute.For <IOctopusClientFactory>(); client = Substitute.For <IOctopusClient>(); clientFactory.CreateClient(Arg.Any <OctopusServerEndpoint>()).Returns(client); operation = new RegisterMachineOperation(clientFactory); serverEndpoint = new OctopusServerEndpoint("http://octopus", "ABC123"); environments = new ResourceCollection <EnvironmentResource>(new EnvironmentResource[0], LinkCollection.Self("/foo")); machines = new ResourceCollection <MachineResource>(new MachineResource[0], LinkCollection.Self("/foo")); client.RootDocument.Returns(new RootResource { Links = LinkCollection.Self("/api").Add("Environments", "/api/environments").Add("Machines", "/api/machines") }); client.When(x => x.Paginate(Arg.Any <string>(), Arg.Any <object>(), Arg.Any <Func <ResourceCollection <EnvironmentResource>, bool> >())) .Do(ci => ci.Arg <Func <ResourceCollection <EnvironmentResource>, bool> >()(environments)); client.When(x => x.Paginate(Arg.Any <string>(), Arg.Any <object>(), Arg.Any <Func <ResourceCollection <MachineResource>, bool> >())) .Do(ci => ci.Arg <Func <ResourceCollection <MachineResource>, bool> >()(machines)); client.List <MachineResource>(Arg.Any <string>(), Arg.Any <object>()).Returns(machines); }
public UserRepository(IOctopusClient client) : base(client, "Users") { invitations = new InvitationRepository(client); }
public WorkerRepository(IOctopusClient client) : base(client, "Workers") { }
public MachineRoleRepository(IOctopusClient client) { this.client = client; }
public OctopusServerNodeRepository(IOctopusClient client) : base(client, "OctopusServerNodes") { }
protected BasicRepository(IOctopusClient client, string collectionLinkName) { this.client = client; this.CollectionLinkName = collectionLinkName; }
public MachineRoleRepository(IOctopusClient client) { this.client = client; }
public ConfigurationRepository(IOctopusClient client) { this.client = client; this.collectionLinkName = "Configuration"; }
public TaskRepository(IOctopusClient client) : base(client, "Tasks") { }
public TenantVariablesRepository(IOctopusClient client) : base(client, "TenantVariables") { }
public DashboardConfigurationRepository(IOctopusClient client) { this.client = client; }
public SchedulerRepository(IOctopusClient client) { this.client = client; }
public FeaturesConfigurationRepository(IOctopusClient client) { this.client = client; }
public DashboardRepository(IOctopusClient client) { this.client = client; }
public ProjectGroupRepository(IOctopusClient client) : base(client, "ProjectGroups") { }
public BuiltInPackageRepositoryRepository(IOctopusClient client) { this.client = client; }
public AccountRepository(IOctopusClient client) : base(client, "Accounts") { }
public BuiltInPackageRepositoryRepository(IOctopusClient client) { this.client = client; }
public MachinePolicyRepository(IOctopusClient client) : base(client, "MachinePolicies") { }
public TenantRepository(IOctopusClient client) : base(client, "Tenants") { }
public ActionTemplateRepository(IOctopusClient client) { this.client = client; templatesPath = client.RootDocument.Link("ActionTemplates"); }
public DeploymentRepository(IOctopusClient client) : base(client, "Deployments") { }
public ProxyRepository(IOctopusClient client) : base(client, "Proxies") { }
public BackupRepository(IOctopusClient client) { this.client = client; }