//private static async Task<Site> CreateSite(ResourceGroup resourceGroup, Func<string> nameGenerator, string siteKind = null)
//{
// var site = new Site(resourceGroup.SubscriptionId, resourceGroup.ResourceGroupName, nameGenerator(), siteKind);
// await resourceGroup.LoadServerFarms(serverFarms: null);
// var serverFarm = new ServerFarm(resourceGroup.SubscriptionId, resourceGroup.ResourceGroupName,
// Constants.DefaultServerFarmName, resourceGroup.GeoRegion);
// if (resourceGroup.ServerFarms.Count() < 1) {
// var csmServerFarmResponse =
// await
// GetClient(resourceGroup.SubscriptionType).HttpInvoke(HttpMethod.Put, ArmUriTemplates.ServerFarmCreate.Bind(serverFarm),
// new
// {
// location = resourceGroup.GeoRegion,
// kind = "app",
// name = serverFarm.ServerFarmName,
// sku= serverFarm.Sku,
// properties = new
// {
// name = serverFarm.ServerFarmName,
// workerSizeId=0,
// numberOfWorkers= 0,
// geoRegion=resourceGroup.GeoRegion,
// kind="app"
// }
// });
// await csmServerFarmResponse.EnsureSuccessStatusCodeWithFullError();
// }
// var csmSiteResponse =
// await
// GetClient(resourceGroup.SubscriptionType).HttpInvoke(HttpMethod.Put, ArmUriTemplates.SiteCreate.Bind(site),
// new
// {
// properties =
// new
// {
// serverFarmId = serverFarm.CsmId
// },
// location = resourceGroup.GeoRegion,
// kind = "app",
// name = site.SiteName
// });
// await csmSiteResponse.EnsureSuccessStatusCodeWithFullError();
// var csmSite = await csmSiteResponse.Content.ReadAsAsync<CsmWrapper<CsmSite>>();
// return await Load(site, csmSite);
//}
private static async Task <Site> CreateLinuxSite(ResourceGroup resourceGroup, Func <string> nameGenerator, string siteKind = null)
{
var site = new Site(resourceGroup.SubscriptionId, resourceGroup.ResourceGroupName, nameGenerator(), siteKind);
var csmTemplateString = string.Empty;
var template = TemplatesManager.GetTemplates().FirstOrDefault(t => t.Name == Constants.NodejsWebAppLinuxTemplateName) as LinuxTemplate;
using (var reader = new StreamReader(template.CsmTemplateFilePath))
{
csmTemplateString = await reader.ReadToEndAsync();
}
csmTemplateString = csmTemplateString
.Replace("{{siteName}}", site.SiteName)
.Replace("{{aspName}}", site.SiteName + "-plan")
.Replace("{{vmLocation}}", resourceGroup.GeoRegion)
.Replace("{{serverFarmType}}", SimpleSettings.ServerFarmTypeContent);
var inProgressOperation = new InProgressOperation(resourceGroup, DeploymentType.CsmDeploy);
await inProgressOperation.CreateDeployment(JsonConvert.DeserializeObject <JToken>(csmTemplateString), block : true, subscriptionType : resourceGroup.SubscriptionType);
// Dont run this yet. Spot serverfarms clock will start
//await Util.DeployLinuxTemplateToSite(template, site);
if (!resourceGroup.Tags.ContainsKey(Constants.LinuxAppDeployed))
{
resourceGroup.Tags.Add(Constants.LinuxAppDeployed, "1");
await resourceGroup.Update();
}
await Load(site, null);
return(site);
}
public IEnumerable <BaseTemplate> Get()
{
var list = TemplatesManager.GetTemplates().ToList();
list.Add(WebsiteTemplate.EmptySiteTemplate);
return(list);
}
public IEnumerable <BaseTemplate> Get()
{
var list = TemplatesManager.GetTemplates().ToList();
list.ForEach(t =>
{
if (t.AppService == AppService.Logic)
{
t.Description = Resources.Server.Templates_PingSiteDescription;
}
else if (t.AppService == AppService.Mobile)
{
switch (t.Name)
{
case "Todo List":
t.Description = Resources.Server.Templates_TodoListDescription;
break;
case "Xamarin CRM":
t.Description = Resources.Server.Templates_XamarinCrmDescription;
break;
case "Field Engineer":
t.Description = Resources.Server.Templates_FieldEngineerDescription;
break;
}
}
});
list.Add(WebsiteTemplate.EmptySiteTemplate);
return(list);
}
protected void OpenTeamsTemplatesManager()
{
var tManager = new TemplatesManager <TeamTemplate, Player>(Core.TemplatesService.TeamTemplateProvider,
Core.TemplatesService.GetTemplateEditor <TeamTemplate, Player>());
tManager.TransientFor = mainWindow;
tManager.Show();
}
public void OpenTeamsTemplatesManager(ITeamTemplatesProvider teamProvider)
{
var tManager = new TemplatesManager <TeamTemplate, Player> (teamProvider,
new TeamTemplateEditorWidget(teamProvider));
tManager.TransientFor = mainWindow as Gtk.Window;
tManager.Show();
}
protected void OpenCategoriesTemplatesManager()
{
var tManager = new TemplatesManager <Categories, Category>(Core.TemplatesService.CategoriesTemplateProvider,
Core.TemplatesService.GetTemplateEditor <Categories, Category>());
tManager.TransientFor = mainWindow;
tManager.Show();
}
public void OpenCategoriesTemplatesManager(ITemplatesService ts)
{
var tManager = new TemplatesManager <Categories, Category> (ts.CategoriesTemplateProvider,
new CategoriesTemplateEditorWidget(ts));
tManager.TransientFor = mainWindow as Gtk.Window;
tManager.Show();
}
private void AddComboboxItems()
{
List <String> allTemplates = TemplatesManager.GetTemplates();
templateCombo.Items.Clear();
templateCombo.Text = "";
foreach (String template in allTemplates)
{
templateCombo.Items.Add(template);
}
templateCombo.Text = allTemplates[0];
}
public InitialSetupController(IAuthorizationService authorizationService,
TemplatesManager templatesManager,
RoleManager <IRole> roleManager,
IHtmlLocalizer <AdminController> htmlLocalizer,
ISession session,
INotifier notifier,
IStringLocalizer <TemplateController> stringLocalizer)
{
_notifier = notifier;
TH = htmlLocalizer;
_roleManager = roleManager;
_authorizationService = authorizationService;
_templatesManager = templatesManager;
T = stringLocalizer;
_session = session;
}
public TemplateEmailTask(
IWorkflowExpressionEvaluator expressionEvaluator,
ILiquidTemplateManager liquidTemplateManager,
IStringLocalizer<TemplateEmailTask> localizer,
ILogger<TemplateEmailTask> logger,
ISmtpService smtpService,
TemplatesManager templatesManager
)
{
_expressionEvaluator = expressionEvaluator;
_logger = logger;
_smtpService = smtpService;
_templatesManager = templatesManager;
T = localizer;
}
public TemplateController(
IAuthorizationService authorizationService,
TemplatesManager templatesManager,
IShapeFactory shapeFactory,
ISiteService siteService,
IStringLocalizer <TemplateController> stringLocalizer,
IHtmlLocalizer <TemplateController> htmlLocalizer,
INotifier notifier)
{
_authorizationService = authorizationService;
_templatesManager = templatesManager;
New = shapeFactory;
_siteService = siteService;
_notifier = notifier;
T = stringLocalizer;
H = htmlLocalizer;
}
public async Task Create_Success()
{
//Arrange
var templatesRepository = new Mock<ITemplatesRepository>();
var templatesManager = new TemplatesManager(templatesRepository.Object);
var expectedTemplate = new DefaultTemplate
{
Name = "test template",
Subject = "test subject",
HtmlBodyTemplate = "Hi, it's your email",
PlainBodyTemplate = "test plain",
Priority = Priority.Normal,
Tag = "tag test",
Language = CultureInfo.CurrentCulture,
FromAddress = "*****@*****.**"
};
Template actualTemplate = null;
//Expect
templatesRepository
.Setup(x => x.CreateAsync(It.IsNotNull<Template>()))
.Callback<Template>(template =>
{
actualTemplate = template;
})
.Returns(Task.CompletedTask);
//Act
await templatesManager.Create(expectedTemplate);
//Assert
Assert.IsNotNull(actualTemplate);
Assert.AreEqual(expectedTemplate.Name, actualTemplate.Name);
Assert.AreEqual(expectedTemplate.Subject, actualTemplate.Subject);
Assert.AreEqual(expectedTemplate.HtmlBodyTemplate, actualTemplate.HtmlBodyTemplate);
Assert.AreEqual(expectedTemplate.PlainBodyTemplate, actualTemplate.PlainBodyTemplate);
Assert.AreEqual(EmailMessagePriority.Normal, actualTemplate.Priority);
Assert.AreEqual(expectedTemplate.Tag, actualTemplate.Tag);
Assert.AreEqual(expectedTemplate.Language.Name, actualTemplate.Language);
Assert.AreEqual(expectedTemplate.FromAddress, actualTemplate.FromAddress);
//Verify
templatesRepository.VerifyAll();
}
public HttpResponseMessage GetARMTemplate(string templateName)
{
var list = TemplatesManager.GetTemplates().ToList();
var emptyTemplate = WebsiteTemplate.EmptySiteTemplate;
emptyTemplate.MSDeployPackageUrl = $"{SimpleSettings.ZippedRepoUrl}/Default/{Uri.EscapeDataString((emptyTemplate.Name))}.zip";
list.Add(emptyTemplate);
var template = list.FirstOrDefault((temp) => string.Equals(temp.Name, templateName, StringComparison.OrdinalIgnoreCase));
if (template != null)
{
var armTemplateJson = TemplatesManager.GetARMTemplate(template);
return(Request.CreateResponse(HttpStatusCode.OK, armTemplateJson, new MediaTypeHeaderValue("application/json")));
}
else
{
return(new HttpResponseMessage(HttpStatusCode.NotFound));
}
}
private static void ReplaceDocumentTypeCodes(Entity curEntity, Dictionary <string, EntityMetadata> entitiesMetaData)
{
var entityMetaData = TransformData.GetEntityMetaData(entitiesMetaData, curEntity.LogicalName);
// Entity type code issue is with Custom entity only!
if (entityMetaData.IsCustomEntity.Value)
{
TemplatesManager templatesManager = new TemplatesManager();
var associatedEntityName = curEntity.GetAttributeValue <string>(Constant.DocumentTemplate.AssociatedEntityTypeCode);
// string name = curEntity.GetAttributeValue<string>("name");
var associatedEntityMetaData = TransformData.GetEntityMetaData(entitiesMetaData, associatedEntityName);
// ObjectTypeCode is fixed for OOTB entities - so just fix for custom entities
if (associatedEntityMetaData.IsCustomEntity.Value)
{
int?newEtc = associatedEntityMetaData.ObjectTypeCode; //t emplatesManager.GetEntityTypeCode(OrganizationService, entityName);
templatesManager.ReRouteEtcViaOpenXml(curEntity, associatedEntityName, associatedEntityMetaData.ObjectTypeCode);
}
}
}
void Awake()
{
Instance = this;
}
public AllTemplatesDeploymentSource(TemplatesManager templatesManager)
{
_templatesManager = templatesManager;
}
public TemplateStep(TemplatesManager templatesManager)
{
_templatesManager = templatesManager;
}
private static async Task <Site> CreateVSCodeLinuxSite(ResourceGroup resourceGroup, Func <string> nameGenerator, string siteKind = null)
{
var jsonSettings = new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
};
var site = new Site(resourceGroup.SubscriptionId, resourceGroup.ResourceGroupName, nameGenerator(), siteKind);
var csmTemplateString = string.Empty;
var template = TemplatesManager.GetTemplates().FirstOrDefault(t => t.Name == resourceGroup.TemplateName) as VSCodeLinuxTemplate;
SimpleTrace.TraceInformation($"Deploying {template.Name} to {site.SiteName}->{resourceGroup.ResourceGroupName}->{resourceGroup.SubscriptionId}");
using (var reader = new StreamReader(template.CsmTemplateFilePath))
{
csmTemplateString = await reader.ReadToEndAsync();
}
csmTemplateString = csmTemplateString
.Replace("{{siteName}}", site.SiteName)
.Replace("{{aspName}}", site.SiteName + "-plan")
.Replace("{{vmLocation}}", resourceGroup.GeoRegion);
var inProgressOperation = new InProgressOperation(resourceGroup, DeploymentType.CsmDeploy);
var token = await inProgressOperation.CreateDeployment(JsonConvert.DeserializeObject <JToken>(csmTemplateString), block : true, subscriptionType : resourceGroup.SubscriptionType);
SimpleTrace.TraceInformation($"ARM Deployment result: {JsonConvert.SerializeObject(token)} to {site.SiteName}->{resourceGroup.ResourceGroupName}->{resourceGroup.SubscriptionId}");
await Load(site, null);
SimpleTrace.TraceInformation($"Site Loaded from ARM : {JsonConvert.SerializeObject(site)} to {site.SiteName}->{resourceGroup.ResourceGroupName}->{resourceGroup.SubscriptionId}");
await Util.UpdateVSCodeLinuxAppSettings(site);
SimpleTrace.TraceInformation($"Site AppSettings Updated: for {site.SiteName}->{resourceGroup.ResourceGroupName}->{resourceGroup.SubscriptionId}");
//await site.StopSite();
await Util.DeployVSCodeLinuxTemplateToSite(template, site, false);
//await site.StartSite();
var lsm = new LinuxSiteManager.Client.LinuxSiteManager(retryCount: 6);
Task checkSite = lsm.CheckSiteDeploymentStatusAsync(site.HttpUrl);
try
{
await checkSite;
}
catch (Exception ex)
{
//TODO: Alert on this specifically
var message = "New Site didnt come up after zip deploy: " + ex.Message + ex.StackTrace;
SimpleTrace.TraceError(message);
throw new ZipDeploymentFailedException(message);
}
SimpleTrace.TraceInformation($"Site Code Zip PUT and restart complete: {site.SiteName}->{resourceGroup.ResourceGroupName}->{resourceGroup.SubscriptionId}");
if (!resourceGroup.Tags.ContainsKey(Constants.TemplateName))
{
resourceGroup.Tags.Add(Constants.TemplateName, resourceGroup.TemplateName);
await resourceGroup.Update();
SimpleTrace.TraceInformation($"ResourceGroup Templates Tag Updated: for {site.SiteName}->{resourceGroup.ResourceGroupName}->{resourceGroup.SubscriptionId}");
}
return(site);
}
public ToolsWindowsTemplates()
{
InitializeComponent();
this.templatesMenager = null;
}
public MessageHelper()
{
template_manager = new TemplatesManager();
}
private void MainForm_Load(object sender, EventArgs e)
{
ProjectsManager.Initialize();
TemplatesManager.Initialize();
AddComboboxItems();
}
internal async Task CleanupSubscriptions()
{
try
{
_cleanupOperationsTriggered++;
var subscriptions = await CsmManager.GetSubscriptions();
Stopwatch sw = new Stopwatch();
sw.Start();
//Delete any duplicate resourcegroups in same subscription loaded in the same region
//or create any missing resourcegroups in a region
List <ResourceGroup> toDelete = new List <ResourceGroup>();
List <ResourceGroup> ready = new List <ResourceGroup>();
var deletedDuplicateRGs = 0;
var createdMissingRGs = 0;
var createdMissingTemplates = 0;
foreach (var subscription in subscriptions)
{
var sub = new Subscription(subscription);
await sub.Load();
//sub.ResourceGroups = (await LoadedResourceGroups()).Where(r => r.SubscriptionId == sub.SubscriptionId);
var trialsubresult = sub.GetSubscriptionStats();
toDelete.AddRange(trialsubresult.ToDelete);
ready.AddRange(trialsubresult.Ready);
}
var rand = new Random();
foreach (var resourceGroup in toDelete)
{
//RemoveFromFreeResourcesQueue(resourceGroup);
DeleteResourceGroupOperation(resourceGroup);
deletedDuplicateRGs++;
}
foreach (var template in TemplatesManager.GetTemplates().Where(a => a.QueueSizeToMaintain > 0))
{
var deployedTemplates = ready.Count(a => a.DeployedTemplateName == template.Name);
var delta = template.QueueSizeToMaintain - deployedTemplates;
SimpleTrace.TraceInformation($"Template {template.Name} has {deployedTemplates} RGs deployed and requires {template.QueueSizeToMaintain}");
for (int i = 1; i <= delta; i++)
{
SimpleTrace.TraceInformation($"Template {template.Name} creating {i} of {delta}");
CreateResourceGroupOperation(template.Config.Subscriptions.OrderBy(a => Guid.NewGuid()).First(), template.Config.Regions.OrderBy(a => Guid.NewGuid()).First(), template.Name);
createdMissingTemplates++;
}
for (int i = 1; i <= -delta; i++)
{
var resourceGroup = await StorageHelper.GetQueueMessage(template.QueueName);
if (resourceGroup != null)
{
SimpleTrace.TraceInformation($"Template {template.Name} deleting {i} of {-delta}->{resourceGroup.CsmId}");
//RemoveFromFreeResourcesQueue(resourceGroup);
DeleteResourceGroupOperation(resourceGroup);
}
}
}
AppInsights.TelemetryClient.TrackMetric("createdMissingTemplates", createdMissingTemplates);
AppInsights.TelemetryClient.TrackMetric("createdMissingRGs", createdMissingRGs);
AppInsights.TelemetryClient.TrackMetric("deletedDuplicateRGs", deletedDuplicateRGs);
AppInsights.TelemetryClient.TrackMetric("fullCleanupTime", sw.Elapsed.TotalSeconds);
sw.Stop();
}
catch (Exception e)
{
SimpleTrace.Diagnostics.Fatal(e, "CleanupSubscriptions error, Count {Count}", Interlocked.Increment(ref _maintainResourceGroupListErrorCount));
}
}
public ModuleMainForm()
{
string templateFolder;
InitializeComponent();
try
{
// init mode settings
Settings.Init();
Settings.Setting.LoadFromFile(Common.BuildPath(GenericTemplate.moduleParams.DataPath, GenericTemplate.constModuleDataFolder) + Settings.FILE_NAME);
// init and load tagsStorage object
TagsLoader tagsLoader = new TagsLoader(Common.BuildPath(GenericTemplate.moduleParams.DataPath, GenericTemplate.constModuleDataFolder) + GenericTemplate.constTagsXMLFileName);
this.tagsStorage = tagsLoader.LoadTags();
// WindwosTools controls
twtToolsWindowsTemplates = new ToolsWindowsTemplates();
twttoolsWindowsTags = new ToolsWindowsTags(this.tagsStorage);
twttoolsWindowsTags.AddControl(tbtemplateHeader);
twttoolsWindowsTags.AddControl(tbtemplateBody);
twttoolsWindowsTags.AddControl(tbtemplateFooter);
twttoolsWindowsTags.AddControl(tbTemplateVariables);
twttoolsWindowsTags.AddControl(tbTemplateComment);
twttoolsWindowsTags.AddControl(tbFileDestinationFolder);
twttoolsWindowsTags.AddControl(tbFileDestinationFile);
// general default settings
cbDataDestination.SelectedIndex = 0;
// set icon
this.Icon = global::UberTools.Modules.GenericTemplate.Properties.Resources.WindowsTable;
// create settings menager object and add all controls
templateFolder = Common.BuildPath(GenericTemplate.moduleParams.DataPath, GenericTemplate.constModuleDataFolder, GenericTemplate.constTemplateFolder);
settingsMenager = new SettingsMenager();
settingsMenager.Add(tbtemplateBody);
settingsMenager.Add(tbtemplateHeader);
settingsMenager.Add(tbtemplateFooter);
settingsMenager.Add(tbTemplateVariables);
settingsMenager.Add(tbTemplateComment);
settingsMenager.Add(tbFileDestinationFolder);
settingsMenager.Add(tbFileDestinationFile);
settingsMenager.Add(chbDestinationFileAppend);
settingsMenager.Add(cbDataDestination);
settingsMenager.Add(cbEncoding);
//// create settings menager version 2 object and add all controls
settingsMenager2 = new SettingsMenager2(GenericTemplate.constModuleName, "UberToolsModule", "1.0.0.0");
//settingsMenager2.Items.Add(new SettingsMenagerStructure2(tbtemplateBody, "tbtemplateBody", SettingsMenager2.Type.Textbox));
settingsMenager2.Refresh += new EventHandler(settingsMenager2_Refresh);
settingsMenager2.Update += new EventHandler(settingsMenager2_Update);
// new instance template menager
templatesMenager = new TemplatesManager(twtToolsWindowsTemplates.TreeViewControl, templateFolder, settingsMenager, settingsMenager2);
this.twtToolsWindowsTemplates.ImageListControl = this.ilGeneral;
templatesMenager.LoadAll();
// set templateMenager to templateControl
twtToolsWindowsTemplates.TemplatesMenager = templatesMenager;
this.twtToolsWindowsTemplates.ImageListControl = this.ilGeneral;
// Create new rowCollection object and bound it to container
rowCollectionMenager = new RowCollectionMenager(panel1, this.settingsMenager2);
foreach (EncodingMenager encoding in EncodingMenager.GetEnumerator())
{
cbEncoding.Items.Add(encoding);
}
cbEncoding.SelectedIndex = cbEncoding.Items.Count - 2;
// new instance of hoveringwindows
autoComplete = new AutoComplete(this, this.tagsStorage);
autoComplete.AddControl(tbtemplateHeader);
autoComplete.AddControl(tbtemplateBody);
autoComplete.AddControl(tbtemplateFooter);
autoComplete.AddControl(tbTemplateVariables);
autoComplete.AddControl(tbTemplateComment);
autoComplete.AddControl(tbFileDestinationFolder);
autoComplete.AddControl(tbFileDestinationFile);
//// syntax color init
//colorMenager = new ColorMenager_old();
//colorMenager.Controls.Add(tbTemplateVariables);
// SyntaxHighlightingMenager settings
syntaxHighlightingMenager = new SyntaxHighlightingMenager(tagsStorage);
syntaxHighlightingMenager.Controls.Add(tbTemplateVariables);
syntaxHighlightingMenager.Controls.Add(tbtemplateBody);
syntaxHighlightingMenager.Controls.Add(tbtemplateHeader);
syntaxHighlightingMenager.Controls.Add(tbtemplateFooter);
syntaxHighlightingMenager.Controls.Add(tbFileDestinationFolder);
syntaxHighlightingMenager.Controls.Add(tbFileDestinationFile);
// load last loadet template
if (Settings.Setting.LoadSetting(Settings.SettingName.ActiveTemplateName.ToString(), "") != "")
{
templatesMenager.Load(Settings.Setting.LoadSetting(Settings.SettingName.ActiveTemplateName.ToString(), ""));
}
}
catch (Exception ex)
{
ModuleLog.Write(ex, this, "ModuleMainForm", ModuleLog.LogType.ERROR);
}
}
public TemplateSelectorControl()
{
InitializeComponent();
TemplatesMan = new TemplatesManager();
}
public async Task Remove_Success()
{
//Arrange
var templatesRepository = new Mock<ITemplatesRepository>();
var templatesManager = new TemplatesManager(templatesRepository.Object);
var searchingName = "tests template 1";
var searchingLanguage = new CultureInfo("en");
var entities = new List<Template>
{
new Template
{
Name = searchingName,
Subject = "tests subject 1",
HtmlBodyTemplate = "Hi my friend :)",
PlainBodyTemplate = "test plain",
Priority = EmailMessagePriority.Normal,
Tag = "test tag",
Language = "es",
FromAddress = "*****@*****.**",
CreatedDateTime = DateTime.UtcNow
},
new Template
{
Name = searchingName,
Subject = "tests subject 2",
HtmlBodyTemplate = "Hi my friend :)",
PlainBodyTemplate = "test plain",
Priority = EmailMessagePriority.Normal,
Tag = "test tag)",
Language = searchingLanguage.Name,
FromAddress = "*****@*****.**",
CreatedDateTime = DateTime.UtcNow
}
};
Template removedTemplate = null;
//Expect
templatesRepository
.Setup(x => x.GetQuerable())
.Returns(new AsyncEnumerable<Template>(entities));
templatesRepository
.Setup(x => x.RemoveAsync(It.IsNotNull<Template>()))
.Callback<Template>(template =>
{
removedTemplate = template;
})
.Returns(Task.CompletedTask);
//Act
await templatesManager.Remove(searchingName, searchingLanguage);
//Assert
Assert.IsNotNull(removedTemplate);
Assert.AreEqual(searchingName, removedTemplate.Name);
Assert.AreEqual(searchingLanguage.Name, removedTemplate.Language);
Assert.AreEqual(entities[1].Subject, removedTemplate.Subject);
Assert.AreEqual(entities[1].HtmlBodyTemplate, removedTemplate.HtmlBodyTemplate);
Assert.AreEqual(entities[1].PlainBodyTemplate, removedTemplate.PlainBodyTemplate);
Assert.AreEqual(entities[1].Priority, removedTemplate.Priority);
Assert.AreEqual(entities[1].Tag, removedTemplate.Tag);
Assert.AreEqual(entities[1].FromAddress, removedTemplate.FromAddress);
Assert.AreEqual(entities[1].CreatedDateTime, removedTemplate.CreatedDateTime);
//Verify
templatesRepository.VerifyAll();
}
public async Task GetByName_FilterByDefaultLanguage_Success()
{
//Arrange
var templatesRepository = new Mock<ITemplatesRepository>();
var templatesManager = new TemplatesManager(templatesRepository.Object);
var searchingName = "tests template 1";
var entities = new List<Template>
{
new Template
{
Name = searchingName,
Subject = "tests subject 1",
HtmlBodyTemplate = "Hi my friend :)",
PlainBodyTemplate = "test plain",
Priority = EmailMessagePriority.Normal,
Tag = "test tag",
Language = "en",
FromAddress = "*****@*****.**",
CreatedDateTime = DateTime.UtcNow
},
new Template
{
Name = searchingName,
Subject = "tests subject 2",
HtmlBodyTemplate = "Hi my friend :)",
PlainBodyTemplate = "test plain",
Priority = EmailMessagePriority.Low,
Tag = "test tag from kirill)",
Language = "es",
FromAddress = "*****@*****.**",
CreatedDateTime = DateTime.UtcNow
},
new Template
{
Name = "tests template 2",
Subject = "tests subject 2",
HtmlBodyTemplate = "Hi my friend :)",
PlainBodyTemplate = "test plain",
Priority = EmailMessagePriority.High,
Tag = "test tag)",
Language = "ru",
FromAddress = "*****@*****.**",
CreatedDateTime = DateTime.UtcNow
}
};
//Expect
templatesRepository
.Setup(x => x.GetQuerable())
.Returns(new AsyncEnumerable<Template>(entities));
//Act
var filteredTemplate = await templatesManager.GetByName(searchingName);
//Assert
Assert.IsNotNull(filteredTemplate);
Assert.AreEqual(entities[0].Name, filteredTemplate.Name);
Assert.AreEqual(entities[0].Subject, filteredTemplate.Subject);
Assert.AreEqual(entities[0].HtmlBodyTemplate, filteredTemplate.HtmlBodyTemplate);
Assert.AreEqual(entities[0].PlainBodyTemplate, filteredTemplate.PlainBodyTemplate);
Assert.AreEqual(Priority.Normal, filteredTemplate.Priority);
Assert.AreEqual(entities[0].Tag, filteredTemplate.Tag);
Assert.AreEqual(entities[0].Language, filteredTemplate.Language.Name);
Assert.AreEqual(entities[0].FromAddress, filteredTemplate.FromAddress);
//Verify
templatesRepository.VerifyAll();
}
public IEnumerable <BaseTemplate> Get()
{
var list = TemplatesManager.GetTemplates().ToList();
return(list);
}
// ARM
public async Task <ResourceGroup> ActivateLogicApp(BaseTemplate template, TryWebsitesIdentity userIdentity, string anonymousUserName)
{
return(await ActivateResourceGroup(userIdentity, AppService.Logic, DeploymentType.CsmDeploy, async (resourceGroup, inProgressOperation) =>
{
SimpleTrace.TraceInformation("{0}; {1}; {2}; {3}; {4}",
AnalyticsEvents.OldUserCreatedSiteWithLanguageAndTemplateName, "Logic", template.Name, resourceGroup.ResourceUniqueId, AppService.Logic.ToString());
var logicApp = new LogicApp(resourceGroup.SubscriptionId, resourceGroup.ResourceGroupName, Guid.NewGuid().ToString().Replace("-", ""))
{
Location = resourceGroup.GeoRegion
};
var csmTemplateString = string.Empty;
using (var reader = new StreamReader(((SimpleWAWS.Models.LogicTemplate)(TemplatesManager.GetTemplates().FirstOrDefault((a) => a.AppService == AppService.Logic))).CsmTemplateFilePath))
{
csmTemplateString = await reader.ReadToEndAsync();
}
csmTemplateString = csmTemplateString.Replace("{{logicAppName}}", logicApp.LogicAppName);
//csmTemplateString = csmTemplateString.Replace("{{gatewayName}}", Guid.NewGuid().ToString().Replace("-", "")).Replace("{{logicAppName}}", logicApp.LogicAppName);
await inProgressOperation.CreateDeployment(JsonConvert.DeserializeObject <JToken>(csmTemplateString), block: true, subscriptionType: resourceGroup.SubscriptionType);
// After a deployment, we have no idea what changes happened in the resource group
// we should reload it.
// TODO: consider reloading the resourceGroup along with the deployment itself.
await resourceGroup.Load();
var rbacTask = resourceGroup.AddResourceGroupRbac(userIdentity.Puid, userIdentity.Email);
resourceGroup.IsRbacEnabled = await rbacTask;
return resourceGroup;
}));
}
public async Task <HttpResponseMessage> CreateResource(BaseTemplate template)
{
var tempTemplate = WebsiteTemplate.EmptySiteTemplate;
if (template == null)
{
template = WebsiteTemplate.EmptySiteTemplate;
}
else if (template.AppService.Equals(AppService.Function))
{
tempTemplate = FunctionTemplate.DefaultFunctionTemplate(template.Name);
}
else if (template.AppService.Equals(AppService.Containers))
{
var containersTemplate = ContainersTemplate.GetContainersTemplate(template.Name);
containersTemplate.DockerContainer = template.DockerContainer;
tempTemplate = containersTemplate;
}
else if (template.Name != null && !template.Name.Equals("Github Repo") && !template.AppService.Equals(AppService.Function))
{
var temp = TemplatesManager.GetTemplates()
.FirstOrDefault(t => t.Name == template.Name);
tempTemplate = WebsiteTemplate.DefaultTemplate(temp.Name, temp.AppService, temp.Language, temp.FileName, template.DockerContainer, temp.MSDeployPackageUrl);
}
else if (template.Name != null && template.Name.Equals("Github Repo"))
{
tempTemplate = new WebsiteTemplate
{
AppService = AppService.Web,
GithubRepo = template.GithubRepo,
Name = template.Name,
Language = "Github"
};
}
var identity = HttpContext.Current.User.Identity as TryWebsitesIdentity;
var anonymousUserName = SecurityManager.GetAnonymousUserName(new HttpContextWrapper(HttpContext.Current));
try
{
var resourceManager = await ResourcesManager.GetInstanceAsync();
if ((await resourceManager.GetResourceGroup(identity.Name)) != null)
{
SimpleTrace.Diagnostics.Fatal(AnalyticsEvents.MoreThanOneError, 1);
//This should use the server version of the error, but due to a string bug they are not the same.
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, Resources.Client.Information_YouCantHaveMoreThanOne));
}
ResourceGroup resourceGroup = null;
switch (tempTemplate.AppService)
{
case AppService.Linux:
resourceGroup = await resourceManager.ActivateLinuxResource(tempTemplate, identity, anonymousUserName);
break;
case AppService.VSCodeLinux:
resourceGroup = await resourceManager.ActivateVSCodeLinuxResource(tempTemplate, identity, anonymousUserName);
break;
case AppService.Web:
resourceGroup = await resourceManager.ActivateWebApp(tempTemplate, identity, anonymousUserName);
break;
case AppService.Api:
resourceGroup = await resourceManager.ActivateApiApp(tempTemplate, identity, anonymousUserName);
break;
case AppService.Logic:
if (identity.Issuer == "OrgId")
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, Resources.Server.Error_OrgIdNotSupported));
}
else if (identity.Issuer != "MSA")
{
return(SecurityManager.RedirectToAAD(tempTemplate.CreateQueryString()));
}
resourceGroup = await resourceManager.ActivateLogicApp(tempTemplate, identity, anonymousUserName);
break;
case AppService.Function:
resourceGroup = await resourceManager.ActivateFunctionApp(tempTemplate, identity, anonymousUserName);
break;
case AppService.Containers:
if (identity.Issuer == "OrgId")
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, Resources.Server.Error_OrgIdNotSupported));
}
else if (identity.Issuer != "MSA")
{
return(SecurityManager.RedirectToAAD(template.CreateQueryString()));
}
resourceGroup = await resourceManager.ActivateContainersResource(tempTemplate as ContainersTemplate, identity, anonymousUserName);
break;
case AppService.MonitoringTools:
if (identity.Issuer == "OrgId")
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, Resources.Server.Error_OrgIdNotSupported));
}
else if (identity.Issuer != "MSA")
{
return(SecurityManager.RedirectToAAD(template.CreateQueryString()));
}
resourceGroup = await resourceManager.ActivateMonitoringToolsApp(tempTemplate as MonitoringToolsTemplate, identity, anonymousUserName);
break;
}
return(Request.CreateResponse(HttpStatusCode.OK, resourceGroup == null ? null : GetUIResource(resourceGroup)));
}
catch (Exception ex)
{
var message = ex is NullReferenceException ? Resources.Server.Error_GeneralErrorMessage : ex.Message;
SimpleTrace.Diagnostics.Fatal(ex, AnalyticsEvents.UserGotError, message, Interlocked.Increment(ref _userGotErrorErrorCount));
return(Request.CreateErrorResponse(HttpStatusCode.ServiceUnavailable, message));
}
}
private static async Task <Site> CreateVSCodeLinuxSite(ResourceGroup resourceGroup, Func <string> nameGenerator, string siteKind = null)
{
var jsonSettings = new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
};
var site = new Site(resourceGroup.SubscriptionId, resourceGroup.ResourceGroupName, nameGenerator(), siteKind);
var csmTemplateString = string.Empty;
var template = TemplatesManager.GetTemplates().FirstOrDefault(t => t.Name == resourceGroup.TemplateName);
SimpleTrace.TraceInformation($"Deploying {template.Name} to {site.SiteName}->{resourceGroup.ResourceGroupName}->{resourceGroup.SubscriptionId}");
csmTemplateString = await GetConfig(template.ARMTemplateLink);
csmTemplateString = csmTemplateString
.Replace("{{appServiceName}}", site.SiteName)
.Replace("{{msdeployPackageUrl}}", template.MSDeployPackageUrl)
.Replace("{{serverFarmType}}", SimpleSettings.ServerFarmTypeContent)
.Replace("{{tryAppserviceUrl}}", SimpleSettings.TryAppServiceSite);
var inProgressOperation = new InProgressOperation(resourceGroup, DeploymentType.CsmDeploy);
var token = await inProgressOperation.CreateDeployment(JsonConvert.DeserializeObject <JToken>(csmTemplateString), block : true, subscriptionType : resourceGroup.SubscriptionType);
SimpleTrace.TraceInformation($"ARM Deployment result: {JsonConvert.SerializeObject(token)} to {site.SiteName}->{resourceGroup.ResourceGroupName}->{resourceGroup.SubscriptionId}");
var csmSiteResponse =
await
GetClient(resourceGroup.SubscriptionType).HttpInvoke(HttpMethod.Get, ArmUriTemplates.SiteCreate.Bind(site));
await csmSiteResponse.EnsureSuccessStatusCodeWithFullError();
var csmSite = await csmSiteResponse.Content.ReadAsAsync <CsmWrapper <CsmSite> >();
await Load(site, csmSite);
SimpleTrace.TraceInformation($"Site Loaded from ARM : {JsonConvert.SerializeObject(site)} to {site.SiteName}->{resourceGroup.ResourceGroupName}->{resourceGroup.SubscriptionId}");
var siteguid = await Util.UpdatePostDeployAppSettings(site);
SimpleTrace.TraceInformation($"Site AppSettings Updated: for {site.SiteName}->{resourceGroup.ResourceGroupName}->{resourceGroup.SubscriptionId}");
if (resourceGroup.AppService == AppService.VSCodeLinux)
{
await Task.Delay(30 * 1000);
try
{
var lsm = new LinuxSiteManager.Client.LinuxSiteManager(retryCount: 30);
await lsm.CheckSiteDeploymentStatusAsync(site.HttpUrl);
}
catch (Exception ex)
{
SimpleTrace.TraceError($"Unable to ping deployed site {site.HostName}. Continuing regardless {ex.Message}->{ex.StackTrace} ");
}
}
if (!resourceGroup.Tags.ContainsKey(Constants.TemplateName))
{
resourceGroup.Tags.Add(Constants.TemplateName, resourceGroup.TemplateName);
}
if (resourceGroup.SubscriptionType == SubscriptionType.AppService)
{
if (template != null && template.FileName != null)
{
var credentials = new NetworkCredential(site.PublishingUserName, site.PublishingPassword);
var vfsSCMManager = new RemoteVfsManager(site.ScmUrl + "vfs/", credentials, retryCount: 3);
Task scmRedirectUpload = vfsSCMManager.Put("site/applicationHost.xdt", Path.Combine(HostingEnvironment.MapPath(@"~/App_Data"), "applicationHost.xdt"));
var vfsManager = new RemoteVfsManager(site.ScmUrl + "vfs/", credentials, retryCount: 3);
await Task.WhenAll(scmRedirectUpload);
}
}
if (template.Name.Equals("WordPress", StringComparison.OrdinalIgnoreCase))
{
await site.UpdateConfig(new { properties = new { scmType = "LocalGit", httpLoggingEnabled = true, localMySqlEnabled = true } });
}
resourceGroup.Tags[Constants.TemplateName] = template.Name;
site.SubscriptionId = resourceGroup.SubscriptionId;
//site.AppSettings = new Dictionary<string, string>();
resourceGroup.Tags.Add(Constants.SiteGuid, siteguid);
await Task.WhenAll(resourceGroup.Update());
SimpleTrace.TraceInformation($"ResourceGroup Templates Tag Updated: with SiteGuid: {siteguid} for {site.SiteName} ->{resourceGroup.ResourceGroupName}->{resourceGroup.SubscriptionId}");
return(site);
}
