/// <summary> /// Removes all entries from the webhookWebhookParameters table with a reference to the given webhookId. /// </summary> /// <param name="webhookId">The ID to filter by.</param> /// <returns></returns> public async Task DeleteWebhookJoinEntriesAsync(long webhookId) { List <WebhookWebhookParameter> webhookWebhookParameters = await _context.WebhookWebhookParameters.Where(x => x.WebhookId == webhookId).ToListAsync(); _context.WebhookWebhookParameters.RemoveRange(webhookWebhookParameters); await _context._SaveChangesAsync(); _logger.LogInformation(LoggingUtils.ComposeResourceDeletedMessage(typeof(WebhookWebhookParameter).Name, $"webhookId={webhookId}")); }
private async Task UpdateWebhookParameters(Offer offer, Webhook webhook, long webhookId) { List <WebhookParameter> incompleteParams = ParseWebhookParameters(webhook); List <WebhookWebhookParameter> joinEntries = await _webhookWebhookParameterService.GetAllJoinEntries(webhookId); Dictionary <string, WebhookParameter> paramsDb = new Dictionary <string, WebhookParameter>(); HashSet <string> usedParamNames = new HashSet <string>(); // Populate paramsDb so that it maps the WebhookParameter name to the WebhookParameter object foreach (WebhookWebhookParameter entry in joinEntries) { WebhookParameter webhookParameter = await _context.WebhookParameters.FindAsync(entry.WebhookParameterId); if (!paramsDb.ContainsKey(webhookParameter.Name)) { paramsDb.Add(webhookParameter.Name, webhookParameter); } } foreach (WebhookParameter incompleteParam in incompleteParams) { // Check if a param with the same name as the incompleteParam already exists if (!paramsDb.ContainsKey(incompleteParam.Name)) { // A param with the same name as the incompleteParam does not exist, so create it await _webhookParameterService.CreateAsync(offer.OfferName, webhookId, incompleteParam); } // Keep track of all the new parameters we are using in usedParamNames if (!usedParamNames.Contains(incompleteParam.Name)) { usedParamNames.Add(incompleteParam.Name); } } foreach (KeyValuePair <string, WebhookParameter> paramDb in paramsDb) { // Check if there is a param in the db that we are no longer using if (!usedParamNames.Contains(paramDb.Key)) { WebhookWebhookParameter webhookWebhookParameter = await _context.WebhookWebhookParameters.FindAsync(webhookId, paramDb.Value.Id); // Remove the join entry for any unused params _context.WebhookWebhookParameters.Remove(webhookWebhookParameter); await _context._SaveChangesAsync(); _logger.LogInformation(LoggingUtils.ComposeResourceDeletedMessage( nameof(WebhookWebhookParameter), $"(webhookId={webhookId}, webhookParameterId={webhookWebhookParameter.WebhookParameter})", offerName: offer.OfferName)); } } }
/// <summary> /// Deletes a subscriptionCustomMeterUsage. /// </summary> /// <param name="subscriptionId">The subscription id.</param> /// <param name="meterName">The name of the customMeter to delete.</param> /// <returns>The deleted subscriptionCustomMeterUsage.</returns> public async Task <SubscriptionCustomMeterUsage> DeleteAsync(Guid subscriptionId, string meterName) { _logger.LogInformation(LoggingUtils.ComposeDeleteResourceMessage(typeof(SubscriptionCustomMeterUsage).Name, meterName, subscriptionId: subscriptionId)); // Get the customMeter that matches the meterName provide var subscriptionCustomMeterUsage = await GetAsync(subscriptionId, meterName); // Update and save changes in db _context.SubscriptionCustomMeterUsages.Remove(subscriptionCustomMeterUsage); await _context._SaveChangesAsync(); _logger.LogInformation(LoggingUtils.ComposeResourceDeletedMessage(typeof(SubscriptionCustomMeterUsage).Name, meterName, subscriptionId: subscriptionId)); return(subscriptionCustomMeterUsage); }
/// <summary> /// Deletes an aadSecretTmp object within an offer. /// </summary> /// <param name="offerName">The name of the offer.</param> /// <param name="name">The name of the aadSecretTmp to delete.</param> /// <returns>The deleted aadSecretTmp object.</returns> public async Task <AadSecretTmp> DeleteAsync(string offerName, string name) { _logger.LogInformation(LoggingUtils.ComposeDeleteResourceMessage(typeof(AadSecretTmp).Name, name, offerName: offerName)); // Get the aadSecretTmp that matches the name provided var aadSecretTmp = await GetAsync(offerName, name); // Remove the aadSecretTmp from the db _context.AadSecretTmps.Remove(aadSecretTmp); await _context._SaveChangesAsync(); _logger.LogInformation(LoggingUtils.ComposeResourceDeletedMessage(typeof(AadSecretTmp).Name, name, offerName: offerName)); return(aadSecretTmp); }
/// <summary> /// Deletes a customMeterDimension. /// </summary> /// <param name="id">The id of the customMeterDimension to delete.</param> /// <returns>The deleted customMeterDimension.</returns> public async Task <CustomMeterDimension> DeleteAsync(long id) { _logger.LogInformation(LoggingUtils.ComposeDeleteResourceMessage(typeof(CustomMeterDimension).Name, id.ToString())); // Get the customMeterDimension that matches the id provided var customMeterDimension = await GetAsync(id); // Remove the customMeterDimension from the db _context.CustomMeterDimensions.Remove(customMeterDimension); await _context._SaveChangesAsync(); _logger.LogInformation(LoggingUtils.ComposeResourceDeletedMessage(typeof(CustomMeterDimension).Name, id.ToString())); return(customMeterDimension); }
/// <summary> /// Deletes a customMeter. /// </summary> /// <param name="meterName">The name of the customMeter to delete.</param> /// <returns>The deleted customMeter.</returns> public async Task <CustomMeter> DeleteAsync(string meterName) { _logger.LogInformation(LoggingUtils.ComposeDeleteResourceMessage(typeof(CustomMeter).Name, meterName)); // Get the customMeter that matches the meterName provide var customMeter = await GetAsync(meterName); // Update and save changes in db _context.CustomMeters.Remove(customMeter); await _context._SaveChangesAsync(); _logger.LogInformation(LoggingUtils.ComposeResourceDeletedMessage(typeof(CustomMeter).Name, meterName)); return(customMeter); }
/// <summary> /// Deletes a webhook within an offer. /// </summary> /// <param name="offerName">The name of the offer.</param> /// <param name="webhookName">The name of the webhook to delete.</param> /// <returns>The deleted webhook.</returns> public async Task <Webhook> DeleteAsync(string offerName, string webhookName) { _logger.LogInformation(LoggingUtils.ComposeDeleteResourceMessage(typeof(Webhook).Name, webhookName, offerName: offerName)); // Get the webhook that matches the webhook provided var webhook = await GetAsync(offerName, webhookName); // Remove the webhook from the db _context.Webhooks.Remove(webhook); await _context._SaveChangesAsync(); _logger.LogInformation(LoggingUtils.ComposeResourceDeletedMessage(nameof(Webhook), webhookName, offerName: offerName)); return(webhook); }
/// <summary> /// Deletes an offerParameter within an offer. /// </summary> /// <param name="offerName">The name of the offer.</param> /// <param name="parameterName">The name of the offerParameter to delete.</param> /// <returns>The deleted offerParameter.</returns> public async Task <OfferParameter> DeleteAsync(string offerName, string parameterName) { _logger.LogInformation(LoggingUtils.ComposeDeleteResourceMessage(typeof(OfferParameter).Name, parameterName, offerName: offerName)); // Get the offerParameter that matches the parameterName provided var offerParameter = await GetAsync(offerName, parameterName); // Remove the offerParameter from the db _context.OfferParameters.Remove(offerParameter); await _context._SaveChangesAsync(); _logger.LogInformation(LoggingUtils.ComposeResourceDeletedMessage(typeof(OfferParameter).Name, parameterName, offerName: offerName)); return(offerParameter); }
/// <summary> /// Removes any WebhookParameters from the db that are not associated with any Webhooks. /// </summary> /// <param name="offerName">The name of the offer.</param> /// <returns></returns> public async Task DeleteUnusedAsync(string offerName) { List <WebhookParameter> webhookParameters = await GetAllAsync(offerName); foreach (WebhookParameter webhookParameter in webhookParameters) { int usages = await _context.WebhookWebhookParameters.Where(x => x.WebhookParameterId == webhookParameter.Id).CountAsync(); if (usages == 0) { _context.WebhookParameters.Remove(webhookParameter); await _context._SaveChangesAsync(); _logger.LogInformation(LoggingUtils.ComposeResourceDeletedMessage(typeof(WebhookParameter).Name, webhookParameter.Name, offerName: offerName)); } } }
/// <summary> /// Deletes a restrictedUser. /// </summary> /// <param name="offerName">The offer name.</param> /// <param name="planName">The plan name.</param> /// <param name="tenantId">The tenant id.</param> /// <returns>The deleted restrictedUser.</returns> public async Task <RestrictedUser> DeleteAsync(string offerName, string planName, Guid tenantId) { _logger.LogInformation(LoggingUtils.ComposeDeleteResourceMessage(typeof(RestrictedUser).Name, tenantId.ToString(), offerName: offerName, planName: planName)); var plan = await _planService.GetAsync(offerName, planName); // Get all restrictedUsers with a FK to the plan var restrictedUser = await _context.RestrictedUsers.SingleOrDefaultAsync(r => r.PlanId == plan.Id && r.TenantId == tenantId); // Remove the restrictedUser from the db _context.RestrictedUsers.Remove(restrictedUser); await _context._SaveChangesAsync(); _logger.LogInformation(LoggingUtils.ComposeResourceDeletedMessage(typeof(RestrictedUser).Name, tenantId.ToString(), offerName: offerName, planName: planName)); return(restrictedUser); }
/// <summary> /// Deletes an IpConfig within an Offer and all of the IpBlocks and IpAddresses associated /// with it. The delete will only occur if all of the IpAddresses associated with the IpConfig /// are not being used. /// </summary> /// <param name="offerName">The name of the offer.</param> /// <param name="name">The name of the ipConfig to delete.</param> /// <returns>The deleted ipConfig.</returns> public async Task <IpConfig> DeleteAsync(string offerName, string name) { _logger.LogInformation(LoggingUtils.ComposeDeleteResourceMessage(typeof(IpConfig).Name, name, offerName: offerName)); // Get the ipConfig that matches the name provided var ipConfig = await GetAsync(offerName, name); // Get the ipBlocks associated with the ipConfig var ipBlocks = await _context.IpBlocks.Where(x => x.IpConfigId == ipConfig.Id).ToListAsync(); foreach (IpBlock block in ipBlocks) { // Check if there are any IpAddresses in use if (await _context.IpAddresses.AnyAsync(x => x.IpBlockId == block.Id && !x.IsAvailable)) { // TODO - at least one IpAddress is in use so the delete cannot be performed throw new NotSupportedException(); } } // Remove entities from db foreach (IpBlock block in ipBlocks) { // Get all IpAddresses in this IpBlock var ipAddresses = await _context.IpAddresses.Where(x => x.IpBlockId == block.Id).ToListAsync(); // Remove all IpAddresses in this IpBlock from the db _context.IpAddresses.RemoveRange(ipAddresses); await _context._SaveChangesAsync(); // Remove the IpBlock from the db _context.IpBlocks.Remove(block); await _context._SaveChangesAsync(); } // Remove the ipConfig from the db _context.IpConfigs.Remove(ipConfig); await _context._SaveChangesAsync(); _logger.LogInformation(LoggingUtils.ComposeResourceDeletedMessage(typeof(IpConfig).Name, name, offerName: offerName)); return(ipConfig); }
/// <summary> /// Deletes an offer. /// </summary> /// <param name="offerName">The name of the offer to delete.</param> /// <returns>The deleted offer.</returns> public async Task <Offer> DeleteAsync(string offerName) { _logger.LogInformation(LoggingUtils.ComposeDeleteResourceMessage(typeof(Offer).Name, offerName)); // Get the offer that matches the offerName provide var offer = await GetAsync(offerName); // Update the offer status offer.Status = nameof(OfferStatus.Deleted); // Update the offer deleted time (soft delete) offer.DeletedTime = DateTime.UtcNow; // Update and save changes in db _context.Offers.Update(offer); await _context._SaveChangesAsync(); _logger.LogInformation(LoggingUtils.ComposeResourceDeletedMessage(typeof(Offer).Name, offerName)); return(offer); }
/// <summary> /// Deletes a plan within an offer. /// </summary> /// <param name="offerName">The name of the offer.</param> /// <param name="planName">The name of the plan to delete.</param> /// <returns>The deleted plan.</returns> public async Task <Plan> DeleteAsync(string offerName, string planName) { _logger.LogInformation(LoggingUtils.ComposeDeleteResourceMessage(typeof(Plan).Name, planName, offerName: offerName)); // Get the plan that matches the planUniqueName provided var plan = await GetAsync(offerName, planName); // Remove restricted user for the plan foreach (var restrictedUser in plan.RestrictedUsers) { _context.RestrictedUsers.Remove(restrictedUser); } // Remove the plan from the db _context.Plans.Remove(plan); await _context._SaveChangesAsync(); _logger.LogInformation(LoggingUtils.ComposeResourceDeletedMessage(typeof(Plan).Name, planName, offerName: offerName)); return(plan); }
/// <summary> /// Deletes an armTemplate record within an offer and removes the armTemplate file from blob storage. /// </summary> /// <param name="offerName">The name of the offer.</param> /// <param name="templateName">The name of the armTempalte to delete.</param> /// <returns>The deleted armTemplate db record.</returns> public async Task <ArmTemplate> DeleteAsync(string offerName, string templateName) { _logger.LogInformation(LoggingUtils.ComposeDeleteResourceMessage(typeof(ArmTemplate).Name, templateName, offerName: offerName)); // Get the armTemplate that matches the templateName provided var armTemplate = await GetAsync(offerName, templateName, useSaSKey : false); // Remove the armTemplate file from blob storage await _storageUtility.DeleteFileAsync(new Uri(armTemplate.TemplateFilePath)); // Remove the join entry form the db await _armTemplateArmTemplateParameterService.DeleteArmTemplateJoinEntriesAsync(armTemplate.Id); // Remove the armTemplate from the db _context.ArmTemplates.Remove(armTemplate); await _context._SaveChangesAsync(); _logger.LogInformation(LoggingUtils.ComposeResourceDeletedMessage(typeof(ArmTemplate).Name, templateName, offerName: offerName)); return(armTemplate); }
/// <summary> /// Deletes a TelemetryDataConnector. /// </summary> /// <param name="name">The name of the TelemetryDataConnector to delete.</param> /// <returns>The deleted TelemetryDataConnector.</returns> public async Task <TelemetryDataConnector> DeleteAsync(string name) { _logger.LogInformation(LoggingUtils.ComposeDeleteResourceMessage(typeof(TelemetryDataConnector).Name, name)); if (!await ExistsAsync(name)) { throw new LunaConflictUserException(LoggingUtils.ComposeNotFoundErrorMessage(typeof(TelemetryDataConnector).Name, name)); } // Get the TelemetryDataConnector that matches the name provide var connector = await GetAsync(name); // Update and save changes in db _context.TelemetryDataConnectors.Remove(connector); await _context._SaveChangesAsync(); _logger.LogInformation(LoggingUtils.ComposeResourceDeletedMessage(typeof(TelemetryDataConnector).Name, name)); return(connector); }