/// <summary>
/// Gets a restructedUser
/// </summary>
/// <param name="offerName">The offer name.</param>
/// <param name="planName">The plan name.</param>
/// <param name="tenantId">The tenant id.</param>
/// <returns>The restrictedUser.</returns>
public async Task <RestrictedUser> GetAsync(string offerName, string planName, Guid tenantId)
{
_logger.LogInformation(LoggingUtils.ComposeGetSingleResourceMessage(typeof(RestrictedUser).Name, tenantId.ToString(), offerName: offerName, planName: planName));
// Check that a restrictedUser with the provided tenantId
var plan = await _planService.GetAsync(offerName, planName);
// Get all restrictedUsers with a FK to the plan
var restrictedUser = await _context.RestrictedUsers.SingleAsync(r => r.PlanId == plan.Id && r.TenantId == tenantId);
// Check that an restrictedUser with the provided id exists
if (restrictedUser is null)
{
throw new LunaNotFoundUserException(LoggingUtils.ComposeNotFoundErrorMessage(typeof(RestrictedUser).Name,
tenantId.ToString()));
}
_logger.LogInformation(LoggingUtils.ComposeReturnValueMessage(typeof(RestrictedUser).Name,
tenantId.ToString(),
JsonSerializer.Serialize(restrictedUser),
offerName: offerName,
planName: planName));
return(restrictedUser);
}
/// <summary>
/// Gets a plan by its id.
/// </summary>
/// <param name="planId">The plan id</param>
/// <returns>The plan.</returns>
public async Task <Plan> GetByIdAsync(long planId)
{
_logger.LogInformation(LoggingUtils.ComposeGetSingleResourceMessage(typeof(Plan).Name, planId.ToString()));
// Find the plan that matches the plan id provided
var plan = await _context.Plans
.SingleOrDefaultAsync(p => (p.Id == planId));
plan = await SetArmTemplateAndWebhookNames(plan);
_logger.LogInformation(LoggingUtils.ComposeReturnValueMessage(typeof(Plan).Name,
planId.ToString(),
JsonSerializer.Serialize(plan)));
return(plan);
}
/// <summary>
/// Gets an offer by name.
/// </summary>
/// <param name="offerName">The name of the offer to get.</param>
/// <returns>The offer.</returns>
public async Task <Offer> GetAsync(string offerName)
{
if (!await ExistsAsync(offerName))
{
throw new LunaNotFoundUserException(LoggingUtils.ComposeNotFoundErrorMessage(typeof(Offer).Name,
offerName));
}
_logger.LogInformation(LoggingUtils.ComposeGetSingleResourceMessage(typeof(Offer).Name, offerName));
// Get the offer that matches the provided offerName and that has not been deleted
var offer = await _context.Offers.SingleOrDefaultAsync(o => (o.OfferName == offerName) && (o.DeletedTime == null));
_logger.LogInformation(LoggingUtils.ComposeReturnValueMessage(typeof(Offer).Name,
offerName,
JsonSerializer.Serialize(offer)));
return(offer);
}
/// <summary>
/// Gets a customMeter.
/// </summary>
/// <param name="meterName">The name of the customMeter.</param>
/// <returns>The customMeter.</returns>
public async Task <CustomMeter> GetAsync(string meterName)
{
_logger.LogInformation(LoggingUtils.ComposeGetSingleResourceMessage(typeof(CustomMeter).Name, meterName));
if (!(await ExistsAsync(meterName)))
{
throw new LunaNotFoundUserException(LoggingUtils.ComposeNotFoundErrorMessage(typeof(CustomMeter).Name,
meterName));
}
// Get the customMeter that matches the provided meterName
var customMeter = await _context.CustomMeters.SingleOrDefaultAsync(c => c.MeterName == meterName);
_logger.LogInformation(LoggingUtils.ComposeReturnValueMessage(
typeof(CustomMeter).Name,
meterName,
JsonSerializer.Serialize(customMeter)));
return(customMeter);
}
public async Task <SubscriptionParameter> GetAsync(Guid subscriptionId, string name)
{
// Check that an armTemplateParameter with the provided name exists within the given offer
if (!(await ExistsAsync(subscriptionId, name)))
{
throw new LunaNotFoundUserException(LoggingUtils.ComposeNotFoundErrorMessage(typeof(SubscriptionParameter).Name,
name));
}
_logger.LogInformation(LoggingUtils.ComposeGetSingleResourceMessage(typeof(SubscriptionParameter).Name, name));
// Find the armTemplateParameter that matches the name provided
var parameter = await _context.SubscriptionParameters
.SingleOrDefaultAsync(p => (p.SubscriptionId == subscriptionId) && (p.Name == name));
_logger.LogInformation(LoggingUtils.ComposeReturnValueMessage(typeof(SubscriptionParameter).Name,
name,
JsonSerializer.Serialize(parameter),
subscriptionId: subscriptionId));
return(parameter);
}
/// <summary>
/// Gets a TelemetryDataConnector.
/// </summary>
/// <param name="name">The name of the TelemetryDataConnector.</param>
/// <returns>The TelemetryDataConnector.</returns>
public async Task <TelemetryDataConnector> GetAsync(string name)
{
_logger.LogInformation(LoggingUtils.ComposeGetSingleResourceMessage(typeof(TelemetryDataConnector).Name, name));
if (!(await ExistsAsync(name)))
{
throw new LunaNotFoundUserException(LoggingUtils.ComposeNotFoundErrorMessage(typeof(TelemetryDataConnector).Name,
name));
}
// Get the TelemetryDataConnector that matches the provided meterName
var connector = await _context.TelemetryDataConnectors.SingleOrDefaultAsync(c => c.Name == name);
_logger.LogInformation(LoggingUtils.ComposeReturnValueMessage(
typeof(TelemetryDataConnector).Name,
name,
JsonSerializer.Serialize(connector)));
return(connector);
}
/// <summary>
/// Gets a subscription by id.
/// </summary>
/// <param name="subscriptionId">The id of the subscription.</param>
/// <returns>The subscription.</returns>
public async Task <Subscription> GetAsync(Guid subscriptionId)
{
_logger.LogInformation(LoggingUtils.ComposeGetSingleResourceMessage(typeof(Subscription).Name, subscriptionId.ToString()));
// Find the subscription that matches the subscriptionId provided
var subscription = await _context.Subscriptions.FindAsync(subscriptionId);
// Check if subscription exists
if (subscription is null)
{
throw new LunaNotFoundUserException(LoggingUtils.ComposeNotFoundErrorMessage(typeof(Subscription).Name,
subscriptionId.ToString()));
}
subscription.OfferName = (await _context.Offers.FindAsync(subscription.OfferId)).OfferName;
subscription.PlanName = (await _context.Plans.FindAsync(subscription.PlanId)).PlanName;
_logger.LogInformation(LoggingUtils.ComposeReturnValueMessage(typeof(Subscription).Name,
subscriptionId.ToString(),
JsonSerializer.Serialize(subscription)));
return(subscription); //Task.FromResult(subscription);
}
/// <summary>
/// Gets an armTemplate within an offer.
/// </summary>
/// <param name="offerName">The name of the offer.</param>
/// <param name="templateName">The name of the armTemplate to get.</param>
/// <param name="useSaSKey">Specify if use SaS key in the uri</param>
/// <returns>The armTemplate.</returns>
public async Task <ArmTemplate> GetAsync(string offerName, string templateName, bool useSaSKey = true)
{
if (!await _offerService.ExistsAsync(offerName))
{
throw new LunaNotFoundUserException(LoggingUtils.ComposeNotFoundErrorMessage(typeof(Offer).Name,
offerName));
}
// Check that an armTemplate with the provided templateName exists within the given offer
if (!(await ExistsAsync(offerName, templateName)))
{
throw new LunaNotFoundUserException(LoggingUtils.ComposeNotFoundErrorMessage(typeof(ArmTemplate).Name,
templateName,
offerName: offerName));
}
_logger.LogInformation(LoggingUtils.ComposeGetSingleResourceMessage(typeof(ArmTemplate).Name, templateName, offerName: offerName));
// Get the offer associated with the offerName provided
var offer = await _offerService.GetAsync(offerName);
// Find the armTemplate that matches the templateName provided
var armTemplate = await _context.ArmTemplates
.SingleOrDefaultAsync(a => (a.OfferId == offer.Id) && (a.TemplateName == templateName));
_logger.LogInformation(LoggingUtils.ComposeReturnValueMessage(typeof(ArmTemplate).Name,
templateName,
JsonSerializer.Serialize(armTemplate),
offerName: offerName));
if (useSaSKey)
{
// Generate Sas key
armTemplate.TemplateFilePath = await _storageUtility.GetFileReferenceWithSasKeyAsync(armTemplate.TemplateFilePath);
}
_logger.LogInformation("Sas key generated.");
return(armTemplate);
}
/// <summary>
/// Gets a customMeterDimension by id.
/// </summary>
/// <param name="id">The id of the customMeterDimension.</param>
/// <returns>The customMeterDimension.</returns>
public async Task <CustomMeterDimension> GetAsync(long id)
{
_logger.LogInformation(LoggingUtils.ComposeGetSingleResourceMessage(typeof(CustomMeterDimension).Name, id.ToString()));
// Find the customMeterDimension that matches the id provided
var customMeterDimension = await _context.CustomMeterDimensions.FindAsync(id);
// Check that an customMeterDimension with the provided id exists
if (customMeterDimension is null)
{
throw new LunaNotFoundUserException(LoggingUtils.ComposeNotFoundErrorMessage(typeof(CustomMeterDimension).Name,
id.ToString()));
}
// Set the customMeterDimension's meterName
customMeterDimension.MeterName = (await _context.CustomMeters.FindAsync(customMeterDimension.MeterId)).MeterName;
_logger.LogInformation(LoggingUtils.ComposeReturnValueMessage(typeof(CustomMeterDimension).Name,
id.ToString(),
JsonSerializer.Serialize(customMeterDimension)));
return(customMeterDimension);
}
/// <summary>
/// Gets an armTemplateParameter within an offer.
/// </summary>
/// <param name="offerName">The name of the offer.</param>
/// <param name="name">The name of the armTemplateParameter to get.</param>
/// <returns>The armTemplateParameter object.</returns>
public async Task <ArmTemplateParameter> GetAsync(string offerName, string name)
{
// Check that an armTemplateParameter with the provided name exists within the given offer
if (!(await ExistsAsync(offerName, name)))
{
throw new LunaNotFoundUserException(LoggingUtils.ComposeNotFoundErrorMessage(typeof(ArmTemplateParameter).Name,
name, offerName: offerName));
}
// Get the offer associated with the offerName provided
var offer = await _offerService.GetAsync(offerName);
// Find the armTemplateParameter that matches the name provided
var armTemplateParameter = await _context.ArmTemplateParameters
.SingleOrDefaultAsync(a => (a.OfferId == offer.Id) && (a.Name == name));
_logger.LogInformation(LoggingUtils.ComposeReturnValueMessage(typeof(ArmTemplateParameter).Name,
name,
JsonSerializer.Serialize(armTemplateParameter),
offerName: offerName));
return(armTemplateParameter);
}
