public DeploymentView(DeploymentViewModel viewModel)
{
// Inicializa los componentes
InitializeComponent();
// Inicializa la vista de datos
grdData.DataContext = ViewModel = viewModel;
FormView = new BaseFormView(ViewModel);
}
public DeploymentView(DeploymentViewModel viewModel)
{
InitializeComponent();
DataContext = ViewModel = viewModel;
ViewModel.Close += (sender, eventArgs) =>
{
DialogResult = eventArgs.IsAccepted;
Close();
};
}
public async Task ClickDeploy()
{
await Create();
var navMock = new Mock <INavigationWindow>();
var dvm = new DeploymentViewModel(navMock.Object, sut, Mock.Of <IHasPassword>());
sut.Deploy((i, j) => dvm, navMock.Object, Mock.Of <IHasPassword>());
navMock.Verify(i => i.NavigateTo(dvm), Times.Once);
}
private void CheckEditConflicts(DeploymentViewModel deployment)
{
bool conflictAlreadyLinkedGitAndFtp = _unitOfWork.Deployments.Count(x =>
x.GitUrl == deployment.GitUrl &&
x.GitBranch == deployment.GitBranch &&
x.FtpHostname == deployment.FtpHostname &&
x.FtpRootDirectory == deployment.FtpRootDirectory) > 1;
if (conflictAlreadyLinkedGitAndFtp)
{
throw new Exception("Git and FTP host already linked.");
}
}
public DeploymentViewModelTest()
{
rvm.Setup(i => i.ProjectFile()).Returns(projectFile.Object);
projectFile.SetupGet(i => i.Directory).Returns(projectDir.Object);
projectFile.SetupGet(i => i.Path).Returns(@"C:\dir\Target.csproj");
projectDir.Setup(i => i.File("web.config")).Returns(configFile.Object);
publishFile.SetupGet(i => i.Name).Returns("PubFile.pubxml");
configFile.Setup(i => i.CreateWrite(FileAttributes.Normal)).ReturnsAsync(configStream);
proxy.SetupGet(i => i.HasExited).Returns(true);
rvm.SetupGet(i => i.WebConfig).Returns("New Web Config");
rvm.Setup(i => i.PublishFile()).Returns(publishFile.Object);
runner.Setup(i => i.Run("dotnet", It.IsAny <string>())).Returns(proxy.Object);
sut = new DeploymentViewModel(nav.Object, rvm.Object, password.Object);
}
public IActionResult Edit(DeploymentViewModel deployment)
{
try
{
if (!ModelState.IsValid)
{
return(View());
}
_handler.UpdateDeployment(deployment);
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
// throw;
return(View("Error", new ErrorViewModel()
{
Exception = ex
}));
}
}
public void UpdateDeployment(DeploymentViewModel deployment)
{
var dep = _unitOfWork.Deployments.Get(deployment.Guid) ??
throw new Exception($"Deployment with guid: {deployment.Guid} not found");
CheckEditConflicts(deployment);
dep.FtpHostname = deployment.FtpHostname;
dep.FtpPort = deployment.FtpPort;
dep.FtpUsername = deployment.FtpUsername;
dep.FtpPassword = deployment.FtpPassword;
dep.FtpRootDirectory = deployment.FtpRootDirectory;
dep.GitBranch = deployment.GitBranch;
dep.GitUrl = deployment.GitUrl;
dep.Logs.Add(new DeploymentLog()
{
Description = "Changed",
Status = ResultStatus.Successful,
DateTime = DateTime.Now,
EventType = "edit",
ResultMessage = string.Empty
});
_unitOfWork.Complete();
_communicator.Bus.Publish(new IntegrationUpdateEvent()
{
FtpHostname = dep.FtpHostname,
FtpPassword = dep.FtpPassword,
FtpPort = dep.FtpPort,
FtpUsername = dep.FtpUsername,
GitBranch = dep.GitBranch,
GitUrl = dep.GitUrl,
IntegrationGuid = dep.Guid,
FtpRootDirectory = dep.FtpRootDirectory
});
}
public async Task <RedirectToRouteResult> Deploy()
{
try
{
Log.Info("Read parameters from request data.");
var templateIdStr = Request.Form["TemplateId"];
int templateId;
if (!int.TryParse(templateIdStr, out templateId))
{
throw new ServiceCatalogException("Couldn't read template ID from request.");
}
Log.Info($"Template ID: {templateId}");
var subscriptionId = Request.Form["SelectedSubscriptionId"];
var location = WebConfigurationManager.AppSettings[ConfigurationConstants.DefaultLocation];
var context = new WebAppContext();
var template = context.TemplateJsons.FirstOrDefault(tj => tj.TemplateId == templateId);
if (template == null)
{
throw new ServiceCatalogException("Couldn't locate template with specified template ID.");
}
Log.Info("Parse parameters from request data");
var paramsDict = new Dictionary <string, string>();
var tagsDict = new Dictionary <string, string>()
{
{ "Deploy", "ServiceCatalog" },
};
FillParametersAndTagsDictionaries(template.TemplateJson, ref paramsDict, ref tagsDict);
Log.Info($"Is Manage Template: {template.IsManageTemplate}");
var jobId = Guid.NewGuid().ToString();
if (template.IsManageTemplate)
{
Log.Info($"Job Id: {jobId}");
paramsDict["jobid"] = jobId;
}
var deploymentsId = Guid.NewGuid();
Log.Info("Start deployments - {0}", deploymentsId);
var resourceGroupName = template.IsManageTemplate
? "automation-account-resource-group"
: Request.Form["SelectedResourceGroupName"];
if (string.IsNullOrWhiteSpace(subscriptionId) || string.IsNullOrWhiteSpace(resourceGroupName))
{
throw new ServiceCatalogException("You should specify both Subscription and Resource Group.");
}
Log.Info($"Subscription ID: {subscriptionId}");
Log.Info($"Resource group name: {resourceGroupName}");
var resourceGroup = await GetOrCreateResourceGroup(resourceGroupName, subscriptionId, location, tagsDict);
var parametersObj = TemplateHelper.PrepareTemplateParametersWithValues(template.TemplateJson, paramsDict);
Log.Info($"Parameters: {parametersObj}");
var deployment = new Deployment
{
Properties = new DeploymentProperties
{
Mode = DeploymentMode.Incremental,
Template = JObject.Parse(template.TemplateJson),
Parameters = parametersObj,
DebugSetting = new DebugSetting()
{
DetailLevel = "requestContent, responseContent"
}
}
};
var deploymentId = Guid.NewGuid().ToString();
var subscriptions = await new SubscriptionController().GetSubscriptions();
var subscription = subscriptions.FirstOrDefault(s => s.SubscriptionId == subscriptionId);
if (template.IsManageTemplate)
{
using (WebAppContext webAppContext = new WebAppContext())
{
Job job = new Job()
{
Id = jobId,
Owner = System.Web.HttpContext.Current.User.Identity.Name
};
webAppContext.Jobs.Add(job);
webAppContext.SaveChanges();
}
}
else
{
using (WebAppContext webAppContext = new WebAppContext())
{
DeploymentViewModel deploymentViewModel = new DeploymentViewModel()
{
DeploymentName = deploymentId,
TemplateVersion = template.TemplateJsonVersion,
Owner = System.Web.HttpContext.Current.User.Identity.Name,
TemplateName = template.TemplateName,
Timestamp = DateTime.Now,
SubscriptionId = subscription?.SubscriptionId,
SubscriptionName = subscription?.DisplayName
};
webAppContext.Deployments.Add(deploymentViewModel);
webAppContext.SaveChanges();
}
}
// Preparing endpoint URL for deployment
var endpointUrl = string.Format(UriConstants.CreateDeploymentsUri, subscriptionId, resourceGroup.Name, deploymentId);
Log.Info($"Sending request to API: {endpointUrl}");
// Start deployment call async
var client = new RestApiClient();
var result = await client.CallPutAsync <Deployment, Deployment>(deployment, endpointUrl, await ServicePrincipal.GetAccessToken());
Log.Info(TemplateHelper.ToJson($"Request result: {TemplateHelper.ToJson(result)}"));
ViewBag.AsyncOperationUrl = result.AsyncOperationUrl;
ViewBag.OperationResultUrl = endpointUrl;
ViewBag.FileLogName = $"{DateTime.Today:yyyy-MM-dd}.log";
return(template.IsManageTemplate
? RedirectToAction("RunBooksView", "RunBooks")
: RedirectToAction("DeploymentsView", "Deployments"));
}
catch (Exception exception)
{
ViewBag.ErrorMessage = "Error";
ViewBag.ErrorDetails = exception.Message;
Log.Error(exception);
return(RedirectToAction("DeploymentsView", "Deployments"));
}
}
// GET: Deployments
public async Task <ActionResult> DeploymentsView()
{
try
{
// Get all subscriptions for this tenant
var subscriptions = await new SubscriptionController().GetSubscriptions();
var subscriptionId = subscriptions.FirstOrDefault()?.SubscriptionId;
var token = await ServicePrincipal.GetAccessToken();
var client = new RestApiClient();
// Get all resource groups
var resourceGroupUri = string.Format(UriConstants.GetAllResourceGroupsUri, Url.Encode(subscriptionId), "");
var resourceGroups = await client.CallGetListAsync <ResourceGroup>(resourceGroupUri, token);
// Get all deployments
var deployments = new List <DeploymentExtended>();
foreach (var resourceGroup in resourceGroups.Result)
{
var deploymentsUri = string.Format(UriConstants.GetDeploymentsByResourceGroup, subscriptionId, resourceGroup.Name);
client = new RestApiClient();
var result = await client.CallGetListAsync <DeploymentExtended>(deploymentsUri, token);
var deployment = result.Result;
deployments.AddRange(deployment);
}
var email = ClaimsPrincipal.Current.FindFirst("http://schemas.xmlsoap.org/ws/2005/05/identity/claims/name").Value;
var resultDeployments = new List <DeploymentViewModel>();
using (WebAppContext context = new WebAppContext())
{
var localDeployments = await context.Deployments.ToListAsync();
foreach (var localDeployment in localDeployments)
{
foreach (var deployment in deployments)
{
if (localDeployment.DeploymentName != deployment?.Name)
{
continue;
}
if (UserRoleHelper.IsAdmin(email) || email == localDeployment.Owner)
{
var newDeployment = new DeploymentViewModel()
{
TemplateName = localDeployment.TemplateName,
DeploymentId = localDeployment.DeploymentId,
DeploymentName = localDeployment.DeploymentName,
SubscriptionId = localDeployment.SubscriptionId,
SubscriptionName = localDeployment.SubscriptionName,
Owner = localDeployment.Owner,
TemplateVersion = localDeployment.TemplateVersion,
Timestamp = localDeployment.Timestamp,
ProvisioningState = deployment?.Properties?.ProvisioningState,
Outputs = deployment?.Properties?.Outputs?.ToString()
};
resultDeployments.Add(newDeployment);
}
}
}
}
var deploymentsList = resultDeployments.OrderByDescending(d => d.Timestamp).ToList();
ViewBag.FileLogName = $"{DateTime.Today:yyyy-MM-dd}.log";
return(View(deploymentsList));
}
catch (Exception ex)
{
ViewBag.ErrorMessage = "Error";
ViewBag.ErrorDetails = ex.Message;
return(View("Error"));
}
}
/// <summary>
/// Abre la ventana de edición de un elemento de distribución
/// </summary>
public void OpenDeploymentView(DeploymentViewModel viewModel)
{
HostPluginsController.LayoutController.ShowDocument("Deployment_" + viewModel.Deployment.GlobalId, viewModel.Name,
new Views.Deployments.DeploymentView(viewModel));
}
