public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
var freq = BackupRestoreUtils.StringToFrequencyUnit(FrequencyUnit);
BackupSchedule schedule = new BackupSchedule(
FrequencyInterval, freq,
KeepAtLeastOneBackup.IsPresent,
RetentionPeriodInDays, StartTime);
BackupRequest request = new BackupRequest()
{
Enabled = true,
StorageAccountUrl = this.StorageAccountUrl,
BackupSchedule = schedule,
Databases = this.Databases,
};
WebsitesClient.UpdateWebAppBackupConfiguration(ResourceGroupName, Name, Slot, request);
var config = new AzureWebAppBackupConfiguration()
{
Name = this.Name,
ResourceGroupName = this.ResourceGroupName,
StorageAccountUrl = this.StorageAccountUrl,
FrequencyInterval = this.FrequencyInterval,
FrequencyUnit = this.FrequencyUnit,
RetentionPeriodInDays = this.RetentionPeriodInDays,
StartTime = this.StartTime,
KeepAtLeastOneBackup = this.KeepAtLeastOneBackup.IsPresent,
Databases = this.Databases,
Enabled = true
};
WriteObject(config);
}
public override async Task <BackupResponse> Backup(Backup backup, BackupRequest request)
{
var service = new Service(backup.ServiceId);
var server = new Server(service.ServerId);
var fileSystemService = server.FileSystemService;
var backupLocation = FileSystem.CombinePath(server.OperatingSystem,
Configuration.LocalDirectory.ReplaceVariables(service));
var originalPath = FileSystem.FixAbsoluteFilePath(
FileSystem.CombinePath(server.OperatingSystem, service.RootDirectory, request.Path,
Compress(backup, request)), server.OperatingSystem);
var newPath = FileSystem.CombinePath(server.OperatingSystem, backupLocation, backup.ZipFullName);
var fileSize = fileSystemService.GetFileSize(originalPath);
BackupManagerController.ThrowExceedQuota(backup, request, fileSize);
backup.FileSize = fileSize;
if (!fileSystemService.DirectoryExists(Path.GetDirectoryName(backupLocation)))
{
fileSystemService.CreateDirectory(Path.GetDirectoryName(backupLocation));
}
fileSystemService.CopyFile(originalPath, newPath);
fileSystemService.DeleteFile(originalPath);
return(new BackupResponse(true));
}
public override async Task <BackupResponse> Backup(Backup backup, BackupRequest request)
{
var bucket = $"backups-service-{backup.ServiceId}";
var service = new Service(backup.ServiceId);
var server = new Server(service.ServerId);
var fileSystemService = server.FileSystemService;
var combinePath = FileSystem.FixAbsoluteFilePath(
FileSystem.CombinePath(server.OperatingSystem, service.RootDirectory, request.Path,
Compress(backup, request)), server.OperatingSystem);
var fileSize = fileSystemService.GetFileSize(combinePath);
BackupManagerController.ThrowExceedQuota(backup, request, fileSize);
backup.FileSize = fileSize;
if (!await MinioClient.BucketExistsAsync(bucket))
{
await MinioClient.MakeBucketAsync(bucket, _region);
}
var contents = fileSystemService.ReadBinary(combinePath);
Stream stream = new MemoryStream(contents);
await MinioClient.PutObjectAsync(bucket, backup.ZipFullName, stream, stream.Length, "application/zip");
return(new BackupResponse(true));
}
public static string BuildBackupCancellEmail(BackupRequest backupRequest)
{
StringBuilder sb = new StringBuilder();
try
{
using (MTCDBEntities db = new MTCDBEntities())
{
sb.Append(EmailBody(backupRequest));
var primaryContractor = GetContractorById(backupRequest.ContractorId);
sb.Append("<h3>2. The requestor " + primaryContractor.ContractCompanyName + " has cancelled the Back-up Request.</h3>");
sb.Append("<tr>");
sb.Append("<td><br/></td>");
sb.Append("</tr>");
sb.Append("<tr>");
sb.Append("<td colspan='2'><h3>Please log on to the LATATrax to respond. <a href='" + GetWebUri() + "/BackupTrucks/ResponseBackup' target='_blank'>Back-up Response</a>.</h3></td>");
sb.Append("</tr>");
sb.Append("<tr>");
sb.Append("<td><br/></td>");
sb.Append("</tr>");
sb.Append(EmailFooter());
}
}
catch
{
}
return(sb.ToString());
}
public ActionResult ScheduleBackupRequest()
{
if (ModelState.IsValid)
{
var request = new BackupRequest(BackupType.Full, BackupSchedule.OnDemand);
Context.AddBackupRequest(request);
Context.SaveChanges();
}
return PartialView("_AddBackupRequest");
}
public override Task <BackupResponse> Backup(BackupRequest request, ServerCallContext context)
{
var result = _indexService.Backup(new Indexing.IndexingActivityStatus
{
LastActivityId = request.Status.LastActivityId,
Gaps = request.Status.Gaps.ToArray()
}, request.Target);
return(Task.FromResult(new BackupResponse
{
Response = JsonConvert.SerializeObject(result)
}));
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
BackupRequest request = new BackupRequest()
{
StorageAccountUrl = this.StorageAccountUrl,
BackupName = this.BackupName,
Databases = this.Databases
};
var backup = WebsitesClient.BackupSite(ResourceGroupName, Name, Slot, request);
WriteObject(BackupRestoreUtils.BackupItemToAppBackup(backup, ResourceGroupName, Name, Slot));
}
public virtual string Compress(Backup backup, BackupRequest request)
{
var service = new Service(backup.ServiceId);
var server = new Server(service.ServerId);
var fileSystemService = server.FileSystemService;
var baseDir = FileSystem.CombinePath(server.OperatingSystem, service.RootDirectory, request.Path);
var toCompress = request.Directories.Select(x => x.Name).ToList();
toCompress.AddRange(request.Files.Select(x => x.Name + x.Extension));
return(fileSystemService.CompressFiles(baseDir, toCompress.ToArray(),
ObjectXml.ObjectToXml(GenerateVirtualDirectorySecurity(service)), 5000000000));
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
BackupRequest request = new BackupRequest()
{
// Location is required by Resource (base class of BackupRequest)
// to not be null, but is not actually significant for the request.
Location = "",
StorageAccountUrl = this.StorageAccountUrl,
BackupRequestName = this.BackupName,
Databases = this.Databases
};
var backup = WebsitesClient.BackupSite(ResourceGroupName, Name, Slot, request);
WriteObject(BackupRestoreUtils.BackupItemToAppBackup(backup, ResourceGroupName, Name, Slot));
}
public static void ThrowExceedQuota(Backup backup, BackupRequest request, long fileSize)
{
var service = new Service(backup.ServiceId);
var t = GetBackupsQuotaUsed(service, backup.Provider);
var t2 = GetBackupsQuota(service, backup.Provider);
var newSize = t + fileSize;
Console.WriteLine(t);
Console.WriteLine(t2);
Console.WriteLine(newSize);
Console.WriteLine(newSize > t2);
if (newSize > t2)
{
throw new QuotaException(backup, request);
}
}
public BackupItem GetSiteBackupStatusSecrets(string resourceGroupName, string webSiteName, string slotName,
string backupId, BackupRequest request = null)
{
string qualifiedSiteName;
var useSlot = CmdletHelpers.ShouldUseDeploymentSlot(webSiteName, slotName, out qualifiedSiteName);
if (useSlot)
{
return(WrappedWebsitesClient.WebApps().GetSiteBackupStatusSecretsSlot(resourceGroupName, webSiteName,
backupId, request, slotName));
}
else
{
return(WrappedWebsitesClient.WebApps().GetSiteBackupStatusSecrets(resourceGroupName, webSiteName, backupId, request));
}
}
public BackupRequest UpdateWebAppBackupConfiguration(string resourceGroupName, string webSiteName,
string slotName, BackupRequest newSchedule)
{
string qualifiedSiteName;
var useSlot = CmdletHelpers.ShouldUseDeploymentSlot(webSiteName, slotName, out qualifiedSiteName);
if (useSlot)
{
return(WrappedWebsitesClient.Sites.UpdateSiteBackupConfigurationSlot(resourceGroupName,
webSiteName, newSchedule, slotName));
}
else
{
return(WrappedWebsitesClient.Sites.UpdateSiteBackupConfiguration(resourceGroupName, webSiteName, newSchedule));
}
}
public void BackupSite()
{
var response = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(HttpPayload.BackupSite)
};
var handler = new RecordedDelegatingHandler(response)
{
StatusCodeToReturn = HttpStatusCode.OK
};
var client = GetWebSiteManagementClient(handler);
BackupRequest backupRequest = new BackupRequest()
{
Name = "abc.zip",
Databases = new List <DatabaseBackupSetting>(),
StorageAccountUrl = "https://username.blob.core.windows.net/backup/?sv=2012-02-12"
};
backupRequest.Databases.Add(new DatabaseBackupSetting()
{
ConnectionString = "Server=someserver;Database=somedatabase;Uid=someusername;Pwd=somepassword;",
DatabaseType = "MySql",
Name = "db1"
});
var backupResponse = client.WebSites.Backup("space1", "baysite", backupRequest);
Assert.Equal(HttpStatusCode.OK, backupResponse.StatusCode);
var backupResult = backupResponse.BackupItem;
Assert.Equal(backupResult.Status, BackupItemStatus.Created);
Assert.Equal(1, backupResult.Databases.Count);
Assert.Equal("abc.zip", backupResult.BlobName);
Assert.Equal("abc.zip", backupResult.Name);
Assert.Equal(0, backupResult.SizeInBytes);
Assert.False(backupResult.Scheduled);
Assert.True(backupResult.StorageAccountUrl.StartsWith("https://"));
Assert.Equal("MySql", backupResult.Databases[0].DatabaseType);
Assert.Equal("db1", backupResult.Databases[0].Name);
Assert.True(!string.IsNullOrEmpty(backupResult.Databases[0].ConnectionString));
}
public BackupItem BackupSite(string resourceGroupName, string webSiteName, string slotName,
BackupRequest request)
{
string qualifiedSiteName;
var useSlot = CmdletHelpers.ShouldUseDeploymentSlot(webSiteName, slotName, out qualifiedSiteName);
if (useSlot)
{
var backup = WrappedWebsitesClient.WebApps().BackupSiteSlot(resourceGroupName, webSiteName, request, slotName);
return(backup);
}
else
{
var backup = WrappedWebsitesClient.WebApps().BackupSite(resourceGroupName, webSiteName, request);
return(backup);
}
}
public virtual Response <SiteSlotBackupResource> GetBackupStatusSecretsSlot(BackupRequest request, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(request, nameof(request));
using var scope = _siteSlotBackupWebAppsClientDiagnostics.CreateScope("SiteSlotBackupResource.GetBackupStatusSecretsSlot");
scope.Start();
try
{
var response = _siteSlotBackupWebAppsRestClient.ListBackupStatusSecretsSlot(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Parent.Name, Id.Parent.Name, Id.Name, request, cancellationToken);
return(Response.FromValue(new SiteSlotBackupResource(Client, response.Value), response.GetRawResponse()));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public static string BuildBackupResponseSubject(BackupRequest backupRequest, BackupResponse backupResponse)
{
string retValue = string.Empty;
if (backupResponse.BackupResponseStatus == BackupResponseStatus.Accepted)
{
retValue = "Back-up Request (" + backupRequest.RequestNumber + ") statisfied";
}
else if (backupResponse.BackupResponseStatus == BackupResponseStatus.Qualified)
{
retValue = "Back-up Request (" + backupRequest.RequestNumber + ") NOT statisfied";
}
else if (backupResponse.BackupResponseStatus == BackupResponseStatus.Declined)
{
retValue = "Back-up Request (" + backupRequest.RequestNumber + ") declined";
}
return(retValue);
}
public virtual Response <SiteBackup> GetBackupStatusSecrets(BackupRequest request, CancellationToken cancellationToken = default)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
using var scope = _clientDiagnostics.CreateScope("SiteBackup.GetBackupStatusSecrets");
scope.Start();
try
{
var response = _webAppsRestClient.ListBackupStatusSecrets(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Name, Id.Name, request, cancellationToken);
return(Response.FromValue(new SiteBackup(this, response.Value), response.GetRawResponse()));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async Task <ActionResult> Backup(int id, BackupRequest backupRequest)
{
this.EnforceFeaturePermission("FileManager");
var service = Service.GetSelectedService();
if (!backupRequest.Directories.Any() && !backupRequest.Files.Any())
{
return(this.SendError("Please choose at least <strong>1</strong> file or directory to backup."));
}
try
{
var backup = await Models.Objects.Backup.CreateAsync(service, backupRequest);
backup.Save();
return(this.SendSuccess($"Backed up <strong>{backupRequest.Name}</strong>"));
}
catch (Exception e)
{
return(this.SendException(e, "Failed to backup: " + e.Message));
}
}
public override async Task <BackupResponse> Backup(Backup backup, BackupRequest request)
{
var service = new Service(backup.ServiceId);
var server = new Server(service.ServerId);
var fileSystemService = server.FileSystemService;
var combinePath = FileSystem.FixAbsoluteFilePath(
FileSystem.CombinePath(server.OperatingSystem, service.RootDirectory, request.Path,
Compress(backup, request)), server.OperatingSystem);
var fileSize = fileSystemService.GetFileSize(combinePath);
BackupManagerController.ThrowExceedQuota(backup, request, fileSize);
backup.FileSize = fileSize;
var contents = fileSystemService.ReadBinary(combinePath);
fileSystemService.DeleteFile(combinePath);
var fileLocation = $"/TCAdminBackupManager/{service.UserId}/{backup.ZipFullName}";
var ftpStatus = FtpClient.Upload(contents, fileLocation, createRemoteDir: true,
existsMode: FtpRemoteExists.Overwrite);
return(new BackupResponse(ftpStatus == FtpStatus.Success));
}
// Backup & download (dump file)
public async Task <HttpResult> Post(BackupRequest request)
{
if (!pool.ContainsKey(request.Id))
{
throw HttpError.NotFound($"Deployment {request.Id} not found");
}
var keyedInstance = pool.Single(p => p.Key == request.Id);
if (!request.ObtainLastBackup)
{
using (var cancellableRequest = Request.CreateCancellableRequest())
{
await keyedInstance.Value.Backup(
cancellableRequest.Token);
}
}
return(new HttpResult(
new FileInfo(keyedInstance.Value.Deployment.LastBackupFile),
"application/octet-stream",
true));
}
public static string BuildBackupRequestEmail(BackupRequest backupRequest)
{
StringBuilder sb = new StringBuilder();
try
{
using (MTCDBEntities db = new MTCDBEntities())
{
sb.Append(EmailBody(backupRequest));
sb.Append("<table>");
using (MTCDbContext dc = new MTCDbContext())
{
var backupProviders = dc.BackupProviders.ToList();
var ba = dc.BackupAssignments.FirstOrDefault(p => p.BeatId == backupRequest.BeatId);
var primaryContractorId = backupProviders.FirstOrDefault(c => c.BackupBeatId == ba.PrimaryBackupBeatId).ContractorId;
var primaryContractor = GetContractorById(primaryContractorId);
var secondaryContractorId = backupProviders.FirstOrDefault(c => c.BackupBeatId == ba.SecondaryBackupBeatId).ContractorId;
var secondaryContractor = GetContractorById(secondaryContractorId);
var tertiaryContractorId = backupProviders.FirstOrDefault(c => c.BackupBeatId == ba.TertiaryBackupBeatId).ContractorId;
var tertiaryContractor = GetContractorById(tertiaryContractorId);
if (backupRequest.CurrentBackupContractorAssignmentLevel == BackupAssignmentLevel.Secondary)
{
sb.Append("<h3>2. Back-up Contractor responses:</h3>");
sb.Append("<tr>");
sb.Append("<td>The primary back-up contractor " + primaryContractor.ContractCompanyName + " has either declined or only partially accepted the back-up request.</td>");
sb.Append("</tr>");
}
else if (backupRequest.CurrentBackupContractorAssignmentLevel == BackupAssignmentLevel.Tertiary)
{
sb.Append("<h3>2. Back-up Contractor responses:</h3>");
sb.Append("<tr>");
sb.Append("<td>The primary back-up contractor " + primaryContractor.ContractCompanyName + " has either declined or only partially accepted the back-up request.</td>");
sb.Append("</tr>");
sb.Append("<tr>");
sb.Append("<td>The secondary back-up contractor " + secondaryContractor.ContractCompanyName + " has either declined or only partially accepted the back-up request.</td>");
sb.Append("</tr>");
}
else if (backupRequest.CurrentBackupContractorAssignmentLevel == BackupAssignmentLevel.AllBackupOperators)
{
sb.Append("<h3>2. Back-up Contractor responses:</h3>");
sb.Append("<tr>");
sb.Append("<td>The primary back-up contractor " + primaryContractor.ContractCompanyName + " has either declined or only partially accepted the back-up request.</td>");
sb.Append("</tr>");
sb.Append("<tr>");
sb.Append("<td>The secondary back-up contractor " + secondaryContractor.ContractCompanyName + " has either declined or only partially accepted the back-up request.</td>");
sb.Append("</tr>");
sb.Append("<tr>");
sb.Append("<td>The tertiary back-up contractor " + tertiaryContractor.ContractCompanyName + " has either declined or only partially accepted the back-up request.</td>");
sb.Append("</tr>");
}
}
}
sb.Append("<tr>");
sb.Append("<td><br/></td>");
sb.Append("</tr>");
sb.Append("<tr>");
sb.Append("<td colspan='2'><h3>Please log on to the LATATrax to respond. <a href='" + GetWebUri() + "/BackupTrucks/ResponseBackup' target='_blank'>Back-up Response</a>.</h3></td>");
sb.Append("</tr>");
sb.Append("<tr>");
sb.Append("<td><br/></td>");
sb.Append("</tr>");
sb.Append("</table>");
sb.Append(EmailFooter());
}
catch
{
}
return(sb.ToString());
}
public void Setup()
{
_backupRequest = A.Fake<BackupRequest>();
_backupValidator = A.Fake<BackupValidator>();
}
public ValidatedBackupProcess(BackupRequest backupRequest, BackupValidator backupValidator)
{
_backupRequest = backupRequest;
_backupValidator = backupValidator;
}
public static AzureWebAppBackupConfiguration BackupRequestToAppBackupConfiguration(BackupRequest configuration, string resourceGroupName, string name, string slot)
{
if (configuration == null)
{
return(new AzureWebAppBackupConfiguration());
}
BackupSchedule schedule = configuration.BackupSchedule;
DatabaseBackupSetting[] databases = null;
bool?enabled = configuration.Enabled;
if (configuration.Databases != null)
{
databases = configuration.Databases.ToArray();
}
int? frequencyInterval = null;
string frequencyUnit = null;
int? retentionPeriodInDays = null;
DateTime?startTime = null;
bool? keepAtLeastOneBackup = null;
if (schedule != null)
{
frequencyInterval = schedule.FrequencyInterval;
if (schedule.FrequencyUnit != null)
{
frequencyUnit = schedule.FrequencyUnit.ToString();
}
retentionPeriodInDays = schedule.RetentionPeriodInDays;
startTime = schedule.StartTime;
keepAtLeastOneBackup = schedule.KeepAtLeastOneBackup;
}
return(new AzureWebAppBackupConfiguration()
{
Name = name,
ResourceGroupName = resourceGroupName,
StorageAccountUrl = configuration.StorageAccountUrl,
FrequencyInterval = frequencyInterval,
FrequencyUnit = frequencyUnit,
RetentionPeriodInDays = retentionPeriodInDays,
StartTime = startTime,
Databases = databases,
KeepAtLeastOneBackup = keepAtLeastOneBackup,
Enabled = enabled
});
}
public static BackupRequest AddBackupRequest(this IDatabaseContext context, BackupRequest request)
{
return context.BackupRequests.Add(request);
}
public async Task<Stream> BackupAsync(BackupRequest request)
{
return await client.PostAsync(request);
}
public Stream Backup(BackupRequest request)
{
return client.Post(request);
}
public ActionResult RequestBackup(BackupRequest model, List <BackupRequestShiftAndDate> BackupDatesAndShifts)
{
var retvalue = true;
using (var db = new MTCDbContext())
{
var currentMonth = DateTime.Today.ToString("MM");
model.RequestNumber = currentMonth + (db.BackupRequests.Count(p => p.RequestNumber.StartsWith(currentMonth)) + 1).ToString().PadLeft(2, "0"[0]);
model.CreatedOn = DateTime.Now;
model.LastExpiredOn = DateTime.Now;
model.CreatedBy = HttpContext.User.Identity.Name;
model.ModifiedOn = DateTime.Now;
model.ModifiedBy = HttpContext.User.Identity.Name;
model.IsCancelled = false;
if (BackupDatesAndShifts != null)
{
foreach (var item in BackupDatesAndShifts)
{
db.BackupRequestShiftsAndDates.Add(item);
}
}
Contractor toContractor = null;
var backupProviders = db.BackupProviders.ToList();
var ba = db.BackupAssignments.FirstOrDefault(p => p.BeatId == model.BeatId);
var assignmentLevel = BackupAssignmentLevel.Primary;
if (model.SelectedBackupContractorId == Guid.Empty)
{
//no prior arrangements have been made. Get the primary back-up for this contractorId and beatId combination.
if (ba != null)
{
var baProvider = backupProviders.FirstOrDefault(p => p.BackupBeatId == ba.PrimaryBackupBeatId);
if (baProvider != null)
{
model.SelectedBackupContractorId = baProvider.ContractorId;
}
model.SelectedBackupContractorAssignmentLevel = assignmentLevel;
toContractor = EmailManager.GetContractorById(model.SelectedBackupContractorId);
}
}
else
{
toContractor = EmailManager.GetContractorById(model.SelectedBackupContractorId);
assignmentLevel = model.SelectedBackupContractorAssignmentLevel;
}
model.CurrentBackupContractorId = model.SelectedBackupContractorId;
model.CurrentBackupContractorAssignmentLevel = model.SelectedBackupContractorAssignmentLevel;
db.BackupRequests.Add(model);
db.SaveChanges();
var requestingContractor = EmailManager.GetContractorById(model.ContractorId);
var toRecipients = new List <MTCEmailRecipient>();
var ccRecipients = new List <MTCEmailRecipient>();
toRecipients.Add(new MTCEmailRecipient
{
Email = toContractor?.Email,
Name = toContractor?.ContractCompanyName
});
ccRecipients.Add(new MTCEmailRecipient
{
Email = Utilities.GetApplicationSettingValue("MTCContactEmail"),
Name = Utilities.GetApplicationSettingValue("MTCContactName")
});
ccRecipients.Add(new MTCEmailRecipient
{
Email = requestingContractor.Email,
Name = requestingContractor.ContractCompanyName
});
var body = EmailManager.BuildBackupRequestEmail(model);
EmailManager.SendEmail(toRecipients, EmailManager.BuildBackupRequestSubject(model.RequestNumber, assignmentLevel), body, ccRecipients);
}
return(Json(retvalue, JsonRequestBehavior.AllowGet));
}
public void SendBackupFile(BackupRequest request)
{
this.Retry((Action)(() => this._service.SendBackupFile(request)), this.RetryInterval, this.RetryCount);
}
public void ListBackupsAndScheduledBackupRoundTrip()
{
using (var context = MockContext.Start(this.GetType().FullName))
{
var webSitesClient = this.GetWebSiteManagementClient(context);
var resourcesClient = this.GetResourceManagementClient(context);
string farmName = TestUtilities.GenerateName("csmsf");
string resourceGroupName = TestUtilities.GenerateName("csmrg");
string locationName = "West US";
string siteName = TestUtilities.GenerateName("csmws");
resourcesClient.ResourceGroups.CreateOrUpdate(resourceGroupName,
new ResourceGroup
{
Location = locationName
});
webSitesClient.ServerFarms.CreateOrUpdateServerFarm(resourceGroupName, farmName, new ServerFarmWithRichSku
{
ServerFarmWithRichSkuName = farmName,
Location = locationName,
Sku = new SkuDescription
{
Name = "F1",
Tier = "Free",
Capacity = 1
}
});
var serverfarmId = ResourceGroupHelper.GetServerFarmId(webSitesClient.SubscriptionId, resourceGroupName, farmName);
webSitesClient.Sites.CreateOrUpdateSite(resourceGroupName, siteName, new Site
{
SiteName = siteName,
Location = locationName,
ServerFarmId = serverfarmId
});
var backupResponse = webSitesClient.Sites.ListSiteBackups(resourceGroupName, siteName);
Assert.Equal(0, backupResponse.Value.Count); // , "Backup list should be empty"
// the following URL just have a proper format, but it is not valid - for an API test it is not needed to be valid,
// since we are just testing a roundtrip here
// [SuppressMessage("Microsoft.Security", "CS002:SecretInNextLine")]
string storageUrl = "https://nonexistingusername3567.blob.core.windows.net/backup/?sv=2012-02-12&st=2013-12-05T19%3A30%3A45Z&se=2017-12-04T19%3A30%3A45Z&sr=c&sp=rwdl&sig=3BY5sbzQ2NeKvdaelzxc8inxJgE1mGq2a%2BaqUeFGJYo%3D";
var sr = new BackupRequest()
{
Enabled = false,
BackupSchedule = new BackupSchedule()
{
FrequencyInterval = 17,
FrequencyUnit = FrequencyUnit.Day,
KeepAtLeastOneBackup = true,
RetentionPeriodInDays = 26,
StartTime = DateTime.Now.AddDays(5)
},
BackupRequestName = "abc",
StorageAccountUrl = storageUrl
};
webSitesClient.Sites.UpdateSiteBackupConfiguration(resourceGroupName, siteName, sr);
var backupConfiguration = webSitesClient.Sites.GetSiteBackupConfiguration(resourceGroupName, siteName);
Assert.Equal(sr.Enabled, backupConfiguration.Enabled);
Assert.Equal(sr.BackupSchedule.FrequencyInterval, backupConfiguration.BackupSchedule.FrequencyInterval);
Assert.Equal(sr.BackupSchedule.FrequencyUnit, backupConfiguration.BackupSchedule.FrequencyUnit);
Assert.Equal(sr.BackupSchedule.KeepAtLeastOneBackup, backupConfiguration.BackupSchedule.KeepAtLeastOneBackup);
Assert.Equal(sr.Name, backupConfiguration.BackupRequestName);
webSitesClient.Sites.DeleteSite(resourceGroupName, siteName, deleteAllSlots: true.ToString(), deleteMetrics: true.ToString());
webSitesClient.ServerFarms.DeleteServerFarm(resourceGroupName, farmName);
var serverFarmResponse = webSitesClient.ServerFarms.GetServerFarms(resourceGroupName);
Assert.Equal(0, serverFarmResponse.Value.Count);
}
}
public static Backup Create(Service service, BackupRequest request)
{
return(CreateAsync(service, request).ConfigureAwait(false).GetAwaiter().GetResult());
}
private static string EmailBody(BackupRequest backupRequest)
{
StringBuilder sb = new StringBuilder();
try
{
int _urgentBackupRequestResponseTimeInMinutes = 0;
int _standardBackupRequestResponseTimeInMinutes = 0;
BackupReason backupReason = null;
List <BackupRequestShiftAndDate> backupRequestShiftsAndDates = new List <BackupRequestShiftAndDate>();
using (MTCDbContext db = new MTCDbContext())
{
_urgentBackupRequestResponseTimeInMinutes = Convert.ToInt32(Utilities.GetApplicationSettingValue("UrgentBackupRequestResponseTimeInMinutes"));
_standardBackupRequestResponseTimeInMinutes = Convert.ToInt32(Utilities.GetApplicationSettingValue("StandardBackupRequestResponseTimeInMinutes"));
backupReason = db.BackupReasons.Find(backupRequest.BackupReasonId);
backupRequestShiftsAndDates = db.BackupRequestShiftsAndDates.Where(p => p.BackupRequestId == backupRequest.Id).ToList();
}
string requestPriority = "Standard (You have up to " + _standardBackupRequestResponseTimeInMinutes / 60 + " hours to respond)";
if (backupRequest.RequestIsUrgent)
{
requestPriority = "Urgent (You have up to " + _urgentBackupRequestResponseTimeInMinutes + " minutes to respond)";
}
sb.Append("<h3>1. The following Back-up Truck Service Request has been entered into LATATrax.</h3>");
sb.Append("<table>");
sb.Append("<tr>");
sb.Append("<td>Request #</td>");
sb.Append("<td>" + backupRequest.RequestNumber + "</td>");
sb.Append("</tr>");
sb.Append("<tr>");
sb.Append("<td>Request Priority</td>");
sb.Append("<td>" + requestPriority + "</td>");
sb.Append("</tr>");
using (var de = new MTCDBEntities())
{
sb.Append("<tr>");
sb.Append("<td>Requesting Contractor:</td>");
var contractor = de.Contractors.FirstOrDefault(p => p.ContractorID == backupRequest.ContractorId);
if (contractor != null)
{
sb.Append("<td>" + contractor.ContractCompanyName + "</td>");
}
sb.Append("</tr>");
sb.Append("<tr>");
sb.Append("<td>Beat needing Back-up:</td>");
var beat = de.BeatDatas.FirstOrDefault(p => p.ID == backupRequest.BeatId);
if (beat != null)
{
sb.Append("<td>" + beat.BeatName + "</td>");
}
sb.Append("</tr>");
}
sb.Append("<tr>");
sb.Append("<td>Dates and Shifts Back-up Needed:</td>");
sb.Append("<td>");
foreach (var b in backupRequestShiftsAndDates)
{
var shifts = "";
if (b.AMRequested)
{
shifts = " AM ";
}
if (b.MIDRequested)
{
shifts += " MID ";
}
if (b.PMRequested)
{
shifts += " PM ";
}
sb.Append("<span><b>" + b.BackupDate.ToString("MM/dd/yyyy") + "</b> " + shifts + "</span><br />");
}
sb.Append("</td>");
sb.Append("</tr>");
sb.Append("<tr>");
sb.Append("<td>Back-up Reason Code:</td>");
if (backupReason != null)
{
sb.Append("<td>" + backupReason.ReasonCode + " - " + backupReason.Reason + "</td>");
}
sb.Append("</tr>");
sb.Append("<tr>");
sb.Append("<td>Requestor's Comments:</td>");
sb.Append("<td>" + backupRequest.Comments + "</td>");
sb.Append("</tr>");
sb.Append("<tr>");
sb.Append("<td><br/></td>");
sb.Append("</tr>");
sb.Append("</table>");
}
catch
{
}
return(sb.ToString());
}
public static async System.Threading.Tasks.Task <Backup> CreateAsync(Service service, BackupRequest request)
{
var backup = new Backup
{
ServiceId = service.ServiceId,
OwnerId = service.UserId,
Name = request.Name,
ProviderId = request.ProviderId,
Guid = System.Guid.NewGuid().ToString("D"),
Request = request
};
backup.GenerateKey();
var provider = backup.Provider.Create <BackupSolution>();
await provider.Backup(backup, request);
return(backup);
}
public static string BuildBackupResponseEmail(BackupRequest backupRequest, BackupResponse backupResponse)
{
StringBuilder sb = new StringBuilder();
try
{
using (MTCDBEntities db = new MTCDBEntities())
{
sb.Append(EmailBody(backupRequest));
sb.Append("<table>");
sb.Append("<tr>");
sb.Append("<td colspan='2'><br/></td>");
sb.Append("</tr>");
sb.Append("<tr>");
sb.Append("<td>Responder's Comments:</td>");
sb.Append("<td>" + backupResponse.Comments + "</td>");
sb.Append("</tr>");
sb.Append("<tr>");
sb.Append("<td colspan='2'><br/></td>");
sb.Append("</tr>");
using (MTCDbContext dc = new MTCDbContext())
{
if (backupResponse.BackupResponseStatus == BackupResponseStatus.Accepted)
{
sb.Append("<tr>");
sb.Append("<td colspan='2'><h3>2. The Back-up Request will be satisfied by the following Back-up Contractors.</h3></td>");
sb.Append("</tr>");
var respondingContractor = GetContractorById(backupResponse.ContractorId);
sb.Append("<tr>");
sb.Append("<td colspan='2'>" + respondingContractor.ContractCompanyName + "</td>");
sb.Append("</tr>");
}
else if (backupResponse.BackupResponseStatus == BackupResponseStatus.Qualified)
{
sb.Append("<tr>");
sb.Append("<td colspan='2'><h3>2. The Back-up Request will be partially satisfied by the following Back-up Contractors.</h3></td>");
sb.Append("</tr>");
var respondingContractor = GetContractorById(backupResponse.ContractorId);
sb.Append("<tr>");
sb.Append("<td colspan='2'>" + respondingContractor.ContractCompanyName + "</td>");
sb.Append("</tr>");
sb.Append("<tr>");
sb.Append("<td colspan='2'><br/></td>");
sb.Append("</tr>");
sb.Append("<tr>");
sb.Append(
"<td colspan='2'>Some or all of the Back-up Request has not been satisfied by any Back-up Contractor. The back-up Request has been referred to MTC for resolution.</td>");
sb.Append("</tr>");
}
else if (backupResponse.BackupResponseStatus == BackupResponseStatus.Declined)
{
var declinationReason = dc.BackupDeclinationReasons.Find(backupResponse.BackupDeclinationReasonId);
if (declinationReason != null)
{
sb.Append("<tr>");
sb.Append("<td>Declination Reason:</td>");
sb.Append("<td>" + declinationReason.ReasonCode + " - " + declinationReason.Reason + "</td>");
sb.Append("</tr>");
}
}
}
sb.Append("<tr>");
sb.Append("<td><br/></td>");
sb.Append("</tr>");
sb.Append("<tr>");
sb.Append("<td colspan='2'><h3>Please log on to the LATATrax to respond. <a href='" + GetWebUri() + "/BackupTrucks/ResponseBackup' target='_blank'>Back-up Response</a>.</h3></td>");
sb.Append("</tr>");
sb.Append("<tr>");
sb.Append("<td><br/></td>");
sb.Append("</tr>");
sb.Append("</table>");
sb.Append(EmailFooter());
}
}
catch
{
}
return(sb.ToString());
}
