public async Task <Deployment> CreateDeploymentTask(ProjectDeployment project, string environmentId, string releaseId)
        {
            var user = await client.Repository.Users.GetCurrent();

            var deployment = new DeploymentResource
            {
                ChannelId      = project.ChannelId,
                Comments       = "Initiated by OctoPlus",
                Created        = DateTimeOffset.UtcNow,
                EnvironmentId  = environmentId,
                LastModifiedBy = user.Username,
                LastModifiedOn = DateTimeOffset.UtcNow,
                Name           = project.ProjectName + ":" + project.Packages?.First().PackageName,
                ProjectId      = project.ProjectId,
                ReleaseId      = releaseId,
            };

            if (project.RequiredVariables != null)
            {
                foreach (var variable in project.RequiredVariables)
                {
                    deployment.FormValues.Add(variable.Id, variable.Value);
                }
            }
            var deployResult = await client.Repository.Deployments.Create(deployment);

            return(new Deployment {
                TaskId = deployResult.TaskId
            });
        }
Exemple #2
0
        private async Task <bool> IsDeploymentRequired(EnvironmentDeployment job, ProjectDeployment project)
        {
            var needsDeploy    = false;
            var currentRelease = (await this.helper.GetReleasedVersion(project.ProjectId, job.EnvironmentId)).Release;

            if (currentRelease != null && !string.IsNullOrEmpty(currentRelease.Id))
            {
                // Check if we have any packages that are different versions. If they're the same, we don't need to deploy.
                foreach (var package in project.Packages)
                {
                    if (!currentRelease.SelectedPackages.Any(pack => pack.StepName == package.StepName && package.PackageName == pack.Version))
                    {
                        needsDeploy = true;
                    }
                }
            }
            return(needsDeploy);
        }
        public async Task <Release> CreateRelease(ProjectDeployment project, bool ignoreChannelRules = false)
        {
            var user = await client.Repository.Users.GetCurrent();

            var split       = project.Packages.First().PackageName.Split('.');
            var releaseName = project.ReleaseVersion ?? split[0] + "." + split[1] + ".i";

            if (project.ReleaseVersion == null && !string.IsNullOrEmpty(project.ChannelName))
            {
                releaseName += "-" + project.ChannelName;
            }
            var release = new ReleaseResource
            {
                Assembled      = DateTimeOffset.UtcNow,
                ChannelId      = project.ChannelId,
                LastModifiedBy = user.Username,
                LastModifiedOn = DateTimeOffset.UtcNow,
                ProjectId      = project.ProjectId,
                ReleaseNotes   = project.ReleaseMessage ?? string.Empty,
                Version        = releaseName,
            };

            foreach (var package in project.Packages)
            {
                release.SelectedPackages.Add(new SelectedPackage {
                    Version = package.PackageName, ActionName = package.StepName
                });
            }
            var result =
                await
                client.Repository.Releases.Create(release, ignoreChannelRules : ignoreChannelRules);

            return(new Release {
                Version = result.Version,
                Id = result.Id,
                ReleaseNotes = result.ReleaseNotes
            });
        }