public void CreateRelease()
{
ReleaseModel releaseModel = new ReleaseModel();
ReleaseStatusModel releaseStatusModel = new ReleaseStatusModel();
String releaseName = Request.Params["releaseName"];
String month = Request.Params["month"];
String year = Request.Params["year"];
String appName = Request.Params["applicationName"];
int day = Convert.ToInt32(Request.Params["day"]);
String releaseStatus = Request.Params["releaseStatus"];
String Impacts = Request.Params["Impacts"];
String TFS_Url = Request.Params["TFS_Url"];
if (releaseName != null && month != null && year != null && appName != null)
{
releaseModel.Release_Name = releaseName;
releaseModel.Application_Id = Convert.ToInt32(appName);
Releases releases = new Releases();
releaseStatusModel.Month = month;
releaseStatusModel.Year = year;
releaseStatusModel.day = day;
releaseStatusModel.Release_Status = releaseStatus;
releaseStatusModel.Impacts = Impacts;
releaseStatusModel.TFS_Url = TFS_Url;
releases.createRelease(releaseModel, releaseStatusModel);
Response.Write(releaseName + month + year + appName);
}
}
public DeployedRelease(ReleaseModel release, DeploymentModel deployment)
{
ReleaseId = release.Id;
DeploymentId = deployment.Id;
Version = release.Version;
Created = release.Created;
DeployedAt = deployment.DeployedAt;
}
public static SquirrelMacResponse ToSquirrelMac(this ReleaseModel release)
=> new SquirrelMacResponse
{
Date = release.Date,
DownloadFolderUri = new Uri(release.UpdateDownloadUrl, UriKind.Absolute),
Name = release.Version,
Notes = release.Notes
};
public void TagNameNoNull()
{
var releaseModel = new ReleaseModel {
TagName = null
};
Assert.AreEqual(string.Empty, releaseModel.TagName);
}
public ActionResult UpdateRelease([Bind(Include = "TransID,CurrentRelease")] ReleaseModel rm)
{
if (ModelState.IsValid)
{
db.Entry(rm).State = EntityState.Modified;
db.SaveChanges();
}
return(View("UpdateReleaseSuccess"));
}
//public JsonResult GetRelease(int releaseId)
//{
// ReleaseModel releaseModel = new ReleaseModel();
// Releases releases = new Releases();
// return Json(releases.getReleaseModel(releaseModel));
//}
public void DeleteRelease(int releaseId)
{
ReleaseModel releaseModel = new ReleaseModel();
releaseModel.Release_Id = releaseId;
Releases releases = new Releases();
releases.deleteRelease(releaseModel);
}
private void GatherDefects(ReleaseModel release) //todo refactor...
{
if (release.Id == null)
{
return;
}
DefectGeneratedInput = "";
if (_currentDefects != null)
{
_currentDefects.Clear();
}
var a = _releaseDefectResults.Data.Where(x => x.Release.Id != null && x.Release.Id == release.Id);
foreach (var defect in a)
{
if ((_applicationType == "developer" && defect.WorkflowStep.Name != "Development Complete") || (_applicationType == "tester" &&
(defect.WorkflowStep.Name != "Failed Testing" && defect.WorkflowStep.Name != "Passed Testing")))
{
continue;
}
var priority = defect.Priority.Name;
if (priority != null && priority.Split('-').Length > 1)
{
priority = " - " + priority.Split('-')[1];
}
else
{
priority = "";
}
var extra = "";
switch (defect.WorkflowStep.Name)
{
case "Passed Testing":
extra = "<strong style='color:green;'>Passed Testing: </strong>";
break;
case "Failed Testing":
extra = "<strong style='color:red;'>Failed Testing: </strong>";
break;
}
if (_currentDefects != null)
{
_currentDefects.Add(new ReleaseDefectModel {
Content = extra + defect.Number + priority + " - " + defect.Name
});
}
DefectGeneratedInput += defect.WorkflowStep.Name + ": " + defect.Number + priority + " - " + defect.Name + "\n";
}
}
public void UpdateRelease(String releaseName, String month, int year, int applicationId, int releaseId)
{
ReleaseModel releaseModel = new ReleaseModel();
releaseModel.Application_Id = applicationId;
releaseModel.Release_Name = releaseName;
releaseModel.Release_Id = releaseId;
Releases releases = new Releases();
releases.updateRelease(releaseModel);
}
public ActionResult UpdateRelease()
{
ReleaseModel rm = db.CurrentRelease.First();
if (rm == null)
{
return(HttpNotFound());
}
return(View(rm));
}
public PluginViewModel(
EPlugin plugin,
Package package,
ReleaseModel releaseModel,
ITaskService taskService,
string installPath)
{
_taskService = taskService;
Plugin = plugin;
InstallPath = installPath;
ReleaseModel = releaseModel;
Package = package;
Name = package.Name;
Description = package.Description;
InstallCommand = ReactiveCommand.Create(InstallAsync,
this.WhenAnyValue(x => x.IsBusy, x => x.ReleaseModel,
(busy, model) => !busy && model != null));
OpenCommand = ReactiveCommand.Create(OpenAsync);
RemoveCommand = ReactiveCommand.Create(RemoveAsync);
this.WhenAnyValue(x => x.Status).Subscribe(status =>
{
switch (status)
{
case EPluginStatus.NotInstalled:
IsOpenEnabled = false;
IsNotInstalled = true;
Label = "Install";
break;
case EPluginStatus.Outdated:
IsOpenEnabled = true;
IsNotInstalled = false;
Label = "Update";
break;
case EPluginStatus.Latest:
IsOpenEnabled = true;
IsNotInstalled = false;
Label = "Repair";
break;
default:
break;
}
});
}
public static string ToSquirrelWindows(this ReleaseModel release)
{
var match = Regex.Match(release.ReleasesContent, ReleaseEntryPattern);
if (match?.Success != true)
{
throw new ArgumentException("Invalid release content", nameof(release));
}
string hash = match.Groups["Hash"].Value,
size = match.Groups["Size"].Value;
return(string.Concat(hash, " ", release.UpdateDownloadUrl, " ", size));
}
public async Task <ActionResult <ReleaseModel> > PostReleaseModel(ReleaseModel releaseModel)
{
ReleaseModel newRelease = new ReleaseModel()
{
Name = releaseModel.Name,
Project = _context.Projects.FirstOrDefault(x => x.Id == releaseModel.Project.Id),
AddedDate = DateTime.Today,
DeadlineDate = releaseModel.DeadlineDate
};
try
{
_context.Releases.Add(newRelease);
var result = await _context.SaveChangesAsync();
return(Ok(result));
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <List <DeploymentModel> > GetAllDeploymentsForReleaseAsync(InstanceModel instanceModel, SpaceModel space, ProjectModel project, ReleaseModel release, Dictionary <string, EnvironmentModel> environmentDictionary, Dictionary <string, TenantModel> tenantDictionary)
{
var startIndex = -10;
var returnList = new List <DeploymentModel>();
var continueQuery = true;
var client = new RestClient(instanceModel.Url);
while (continueQuery)
{
startIndex += 10;
var request = new RestRequest($"api/{space.OctopusId}/releases/{release.OctopusId}/deployments");
request.AddQueryParameter("skip", startIndex.ToString());
request.AddQueryParameter("task", "10");
request.AddHeader("X-Octopus-ApiKey", instanceModel.ApiKey);
var response = await client.ExecuteGetAsync(request);
var pagedModel = JsonConvert.DeserializeObject <PagedOctopusModel <DeploymentOctopusModel> >(response.Content);
foreach (var item in pagedModel.Items)
{
var deploymentRequest = new RestRequest(item.Links.Task);
deploymentRequest.AddHeader("X-Octopus-ApiKey", instanceModel.ApiKey);
var deploymentResponse = await client.ExecuteGetAsync(deploymentRequest);
var deploymentTaskModel = JsonConvert.DeserializeObject <DeploymentOctopusTaskModel>(deploymentResponse.Content);
returnList.Add(_modelConverter.ConvertFromOctopusToDeploymentModel(item, deploymentTaskModel, release.Id, environmentDictionary, tenantDictionary));
}
continueQuery = returnList.Count < pagedModel.TotalResults && pagedModel.Items.Count > 0;
}
return(returnList);
}
public async Task <DeploymentModel> GetSpecificDeployment(InstanceModel instanceModel, SpaceModel space, ReleaseModel release, string deploymentId, Dictionary <string, EnvironmentModel> environmentDictionary, Dictionary <string, TenantModel> tenantDictionary)
{
var client = new RestClient(instanceModel.Url);
var request = new RestRequest($"api/{space.OctopusId}/deployments/{deploymentId}");
request.AddHeader("X-Octopus-ApiKey", instanceModel.ApiKey);
var response = await client.ExecuteGetAsync(request);
if (response.StatusCode == HttpStatusCode.OK)
{
var octopusModel = JsonConvert.DeserializeObject <DeploymentOctopusModel>(response.Content);
var deploymentRequest = new RestRequest(octopusModel.Links.Task);
deploymentRequest.AddHeader("X-Octopus-ApiKey", instanceModel.ApiKey);
var deploymentResponse = await client.ExecuteGetAsync(deploymentRequest);
var deploymentTaskModel = JsonConvert.DeserializeObject <DeploymentOctopusTaskModel>(deploymentResponse.Content);
return(_modelConverter.ConvertFromOctopusToDeploymentModel(octopusModel, deploymentTaskModel, release.Id, environmentDictionary, tenantDictionary));
}
return(null);
}
public IEnumerable <ReleaseModel> Get(long seq)
{
var model = new ReleaseModel();
return(model.GetReleaseUserAccessListByUserSeq(seq));
}
public ReleaseModel GetReleaseDetails(long seq)
{
var model = new ReleaseModel();
return(model.GetReleaseDetailsBySeq(seq));
}
public Task <ReleaseModel> Update(int projectId, int id, ReleaseModel model)
{
model.ProjectId = projectId;
model.Id = id;
return(_repository.UpdateAsync(model));
}
public Task <ReleaseModel> Insert(int projectId, ReleaseModel model)
{
model.ProjectId = projectId;
return(_repository.InsertAsync(model));
}
/// <summary>
/// Adds a release/deployment to a project/environment specific ReleaseRetentionResult object
/// </summary>
/// <param name="results">The results to append to</param>
/// <param name="project">The deployment project</param>
/// <param name="environment">The deployment environment</param>
/// <param name="release">The release being deployed</param>
/// <param name="deployment">The deployment event</param>
/// <param name="limit">An optional number of recent releases to return per project/environment</param>
protected void RetainRelease(Dictionary <string, ReleaseRetentionResult> results, ProjectModel project, EnvironmentModel environment, ReleaseModel release, DeploymentModel deployment, int?limit = null)
{
string projectEnvironmentKey = release.ProjectId + deployment.EnvironmentId;
if (results.TryGetValue(projectEnvironmentKey, out var resultSet))
{
if (limit != null && resultSet.Releases.Count == limit)
{
_logger.LogInformation($"Discarding release {release.Id} as last release deployment {deployment.Id} occurs after the most recent {limit} deployed releases.");
return;
}
// Add this release deployment to the set for the project/environment
resultSet.Releases.Add(new DeployedRelease(release, deployment));
_logger.LogInformation($"Keeping release {release.Id} as deployment {deployment.Id} is a recent deployment for this project/environment configuration ({resultSet.Releases.Count}/{limit}).");
}
else
{
// Add a new project/env type
resultSet = new ReleaseRetentionResult(project, environment);
resultSet.Releases.Add(new DeployedRelease(release, deployment));
results.Add(projectEnvironmentKey, resultSet);
_logger.LogInformation($"Keeping release {release.Id} as deployment {deployment.Id} is the most recent deployment for this project/environment configuration (1/{limit}).");
}
}
private async Task ProcessDeploymentsForProjectsRelease(SyncJobCompositeModel syncJobCompositeModel, SpaceModel space, ProjectModel project, ReleaseModel releaseModel)
{
await LogInformation($"Getting all the deployments for {syncJobCompositeModel.InstanceModel.Name}:{space.Name}:{project.Name}:{releaseModel.Version}", syncJobCompositeModel);
var octopusList = await _octopusRepository.GetAllDeploymentsForReleaseAsync(syncJobCompositeModel.InstanceModel, space, project, releaseModel, syncJobCompositeModel.EnvironmentDictionary, syncJobCompositeModel.TenantDictionary);
await LogInformation($"{octopusList.Count} deployments(s) found in {syncJobCompositeModel.InstanceModel.Name}:{space.Name}:{project.Name}:{releaseModel.Version}", syncJobCompositeModel);
foreach (var item in octopusList)
{
await LogInformation($"Checking to see if deployment {item.OctopusId}:{item.Name} already exists", syncJobCompositeModel);
var itemModel = await _deploymentRepository.GetByOctopusIdAsync(item.OctopusId, releaseModel.Id);
await LogInformation($"{(itemModel != null ? "Deployment already exists, updating" : "Unable to find deployment, creating")}", syncJobCompositeModel);
item.Id = itemModel?.Id ?? 0;
await LogInformation($"Saving deployment {item.OctopusId}:{item.Name} to the database", syncJobCompositeModel);
var modelToTrack = item.Id > 0 ? await _deploymentRepository.UpdateAsync(item) : await _deploymentRepository.InsertAsync(item);
}
}