/// <summary>
/// Creates a dashboard.
/// </summary>
/// <param name="dto">Data Transfer Object (DTO) used to create an entity.</param>
/// <returns>
/// An asynchronous task result containing information needed to create an API response message.
/// If successful, the task result contains the DTO associated with the entity created.
/// </returns>
public override async Task <CommandResult <DashboardQueryDto, Guid> > Create(DashboardBaseDto dto)
{
var userId = Thread.CurrentPrincipal == null ? null : Thread.CurrentPrincipal.GetUserIdFromPrincipal();
if (userId == null)
{
return(Command.Error <DashboardQueryDto>(GeneralErrorCodes.TokenInvalid("UserId")));
}
var userIdGuid = Guid.Parse(userId);
var validationResponse = ValidatorCreate.Validate(dto);
if (dto == null)
{
return(Command.Error <DashboardQueryDto>(validationResponse));
}
if (dto.Id != Guid.Empty)
{
validationResponse.FFErrors.Add(ValidationErrorCode.PropertyIsInvalid("Id"));
}
var userTenants = _context.GetTenantsForUser(userIdGuid);
if (dto.TenantId != Guid.Empty && !userTenants.Any(x => x.Id == dto.TenantId))
{
validationResponse.FFErrors.Add(ValidationErrorCode.ForeignKeyValueDoesNotExist("TenantId"));
}
if (_context.Dashboards.Any(x => x.OwnerUserId == userIdGuid && x.Name == dto.Name))
{
validationResponse.FFErrors.Add(EntityErrorCode.EntityAlreadyExists);
}
var userDashboardOptions = _context.GetDashboardOptionsForUser(userIdGuid);
if (dto.DashboardOptionId != Guid.Empty && !userDashboardOptions.Any(x => x.Id == dto.DashboardOptionId))
{
validationResponse.FFErrors.Add(ValidationErrorCode.ForeignKeyValueDoesNotExist("DashboardOptionId"));
}
if (validationResponse.IsInvalid)
{
return(Command.Error <DashboardQueryDto>(validationResponse));
}
var newEntity = new Dashboard();
_mapper.Map(dto, newEntity);
newEntity.Id = Guid.NewGuid();
newEntity.SetAuditFieldsOnCreate(userId);
newEntity.OwnerUserId = userIdGuid;
_context.Dashboards.Add(newEntity);
await _context.SaveChangesAsync().ConfigureAwait(false);
return(Command.Created(_mapper.Map(newEntity, new DashboardQueryDto()), newEntity.Id));
}
/// <summary>
/// Updates a dashboard option using a <see cref="Delta"/> object.
/// </summary>
/// <param name="id">ID of the entity to be updated.</param>
/// <param name="delta">
/// Delta containing a list of entity properties. Web Api does the magic of converting the JSON to
/// a delta.
/// </param>
/// <returns>
/// An asynchronous task result containing information needed to create an API response message.
/// </returns>
public override async Task <CommandResult <DashboardOptionBaseDto, Guid> > Update(Guid id, Delta <DashboardOptionBaseDto> delta)
{
var userId = Thread.CurrentPrincipal == null ? null : Thread.CurrentPrincipal.GetUserIdFromPrincipal();
if (userId == null)
{
return(Command.Error <DashboardOptionBaseDto>(GeneralErrorCodes.TokenInvalid("UserId")));
}
if (delta == null)
{
return(Command.Error <DashboardOptionBaseDto>(EntityErrorCode.EntityFormatIsInvalid));
}
var userDashboardOptions = _context.GetDashboardOptionsForUser(Guid.Parse(userId));
var entity = userDashboardOptions.SingleOrDefault(x => x.Id == id);
if (entity == null)
{
return(Command.Error <DashboardOptionBaseDto>(EntityErrorCode.EntityNotFound));
}
var dto = _mapper.Map(entity, new DashboardOptionBaseDto());
delta.Patch(dto);
var validationResponse = ValidatorUpdate.Validate(dto);
var userTenants = _context.GetTenantsForUser(Guid.Parse(userId));
if (dto.TenantId != Guid.Empty && !userTenants.Any(x => x.Id == dto.TenantId))
{
validationResponse.FFErrors.Add(ValidationErrorCode.ForeignKeyValueDoesNotExist("TenantId"));
}
else if (_context.DashboardOptions.Any(x => x.Id != id && x.TenantId == dto.TenantId))
{
validationResponse.FFErrors.Add(EntityErrorCode.EntityAlreadyExists);
}
// Including the original Id in the Patch request will not return an error but attempting to change the Id is not allowed.
if (dto.Id != id)
{
validationResponse.FFErrors.Add(ValidationErrorCode.EntityIDUpdateNotAllowed("Id"));
}
if (validationResponse.IsInvalid)
{
return(Command.Error <DashboardOptionBaseDto>(validationResponse));
}
_context.DashboardOptions.Attach(entity);
_mapper.Map(dto, entity);
entity.SetAuditFieldsOnUpdate(userId);
await _context.SaveChangesAsync().ConfigureAwait(false);
return(Command.NoContent <DashboardOptionBaseDto>());
}
/// <summary>
/// Updates a Location Log Entry using a <see cref="Delta"/> object.
/// </summary>
/// <param name="id">ID of the Location Log Entry to be updated.</param>
/// <param name="delta">
/// Delta containing a list of Location Log Entry properties. Web Api does the magic of converting the JSON to
/// a delta.
/// </param>
/// <returns>
/// An asynchronous task result containing information needed to create an API response message.
/// </returns>
public override async Task <CommandResult <LocationLogEntryBaseDto, Guid> > Update(Guid id, Delta <LocationLogEntryBaseDto> delta)
{
// User ID should always be available, but if not ...
var userId = GetCurrentUser();
if (!userId.HasValue)
{
return(Command.Error <LocationLogEntryBaseDto>(GeneralErrorCodes.TokenInvalid("UserId")));
}
if (delta == null)
{
return(Command.Error <LocationLogEntryBaseDto>(EntityErrorCode.EntityFormatIsInvalid));
}
var locationLogEntry = await _context.GetLocationLogEntriesForUser(userId.Value)
.SingleOrDefaultAsync(l => l.Id == id)
.ConfigureAwait(false);
if (locationLogEntry == null)
{
return(Command.Error <LocationLogEntryBaseDto>(EntityErrorCode.EntityNotFound));
}
var dto = _mapper.Map(locationLogEntry, new LocationLogEntryQueryDto());
delta.Patch(dto);
var validationResponse = ValidatorUpdate.Validate(dto);
// Including the original ID in the Patch request will not return an error but attempting to change the Id is not allowed.
if (dto.Id != id)
{
validationResponse.FFErrors.Add(ValidationErrorCode.EntityIDUpdateNotAllowed("Id"));
}
var locationExists = await DoesLocationExist(dto.LocationId);
if (!locationExists)
{
validationResponse.FFErrors.Add(ValidationErrorCode.ForeignKeyValueDoesNotExist(nameof(LocationLogEntry.LocationId)));
}
if (validationResponse.IsInvalid)
{
return(Command.Error <LocationLogEntryBaseDto>(validationResponse));
}
_context.LocationLogEntries.Attach(locationLogEntry);
_mapper.Map(dto, locationLogEntry);
locationLogEntry.SetAuditFieldsOnUpdate(userId.Value);
await _context.SaveChangesAsync().ConfigureAwait(false);
return(Command.NoContent <LocationLogEntryBaseDto>());
}
/// <summary>
/// Creates a Location Log Entry.
/// </summary>
/// <param name="dto">Data Transfer Object (DTO) used to create a Location Log Entry.</param>
/// <returns>
/// An asynchronous task result containing information needed to create an API response message.
/// If successful, the task result contains the DTO associated with the Location Log Entry.
/// </returns>
public override async Task <CommandResult <LocationLogEntryQueryDto, Guid> > Create(LocationLogEntryBaseDto dto)
{
// User ID should always be available, but if not ...
var userId = GetCurrentUser();
if (!userId.HasValue)
{
return(Command.Error <LocationLogEntryQueryDto>(GeneralErrorCodes.TokenInvalid("UserId")));
}
var validationResponse = ValidatorCreate.Validate(dto);
if (dto == null)
{
return(Command.Error <LocationLogEntryQueryDto>(validationResponse));
}
if (dto.Id != Guid.Empty)
{
validationResponse.FFErrors.Add(ValidationErrorCode.PropertyIsInvalid(nameof(LocationLogEntry.Id)));
}
var locationExists = await DoesLocationExist(dto.LocationId);
if (!locationExists)
{
validationResponse.FFErrors.Add(ValidationErrorCode.ForeignKeyValueDoesNotExist(nameof(LocationLogEntry.LocationId)));
}
if (validationResponse.IsInvalid)
{
return(Command.Error <LocationLogEntryQueryDto>(validationResponse));
}
var locationLogEntry = new LocationLogEntry
{
Id = Guid.NewGuid()
};
_mapper.Map(dto, locationLogEntry);
locationLogEntry.SetAuditFieldsOnCreate(userId.Value);
_context.LocationLogEntries.Add(locationLogEntry);
await _context.SaveChangesAsync().ConfigureAwait(false);
return(Command.Created(_mapper.Map(locationLogEntry, new LocationLogEntryQueryDto()), locationLogEntry.Id));
}
public async Task When_Create_LocationTypeIdNoExist_Should_Fail()
{
var dto = new LocationBaseDto
{
Name = "New Location",
LocationTypeId = Guid.NewGuid()
};
var commandResult = await _facade.Create(dto);
Assert.That(commandResult.StatusCode, Is.EqualTo(FacadeStatusCode.BadRequest));
Assert.That(commandResult.GeneratedId, Is.EqualTo(Guid.Empty));
Assert.That(commandResult.ErrorCodes.Count, Is.EqualTo(1));
Assert.That(commandResult.ErrorCodes[0].Code, Is.EqualTo(ValidationErrorCode.ForeignKeyValueDoesNotExist("LocationTypeId").Code));
Assert.That(commandResult.ErrorCodes[0].Description, Is.EqualTo(ValidationErrorCode.ForeignKeyValueDoesNotExist("LocationTypeId").Description));
}
public async Task When_Create_ParentIdNoExist_Should_Fail()
{
var distributionType = _mockContext.Object.LocationTypes.Single(x => x.I18NKeyName == "Distribution");
var dto = new LocationBaseDto
{
Name = "New Location",
LocationTypeId = distributionType.Id,
ParentId = Guid.NewGuid()
};
var commandResult = await _facade.Create(dto);
Assert.That(commandResult.StatusCode, Is.EqualTo(FacadeStatusCode.BadRequest));
Assert.That(commandResult.GeneratedId, Is.EqualTo(Guid.Empty));
Assert.That(commandResult.ErrorCodes.Count, Is.EqualTo(1));
Assert.That(commandResult.ErrorCodes[0].Code, Is.EqualTo(ValidationErrorCode.ForeignKeyValueDoesNotExist("ParentId").Code));
Assert.That(commandResult.ErrorCodes[0].Description, Is.EqualTo(ValidationErrorCode.ForeignKeyValueDoesNotExist("ParentId").Description));
}
/// <summary>
/// Updates a location using a <see cref="Delta"/> object.
/// </summary>
/// <param name="id">ID of the location to be updated.</param>
/// <param name="delta">
/// Delta containing a list of location properties. Web Api does the magic of converting the JSON to
/// a delta.
/// </param>
/// <returns>
/// An asynchronous task result containing information needed to create an API response message.
/// </returns>
public override async Task <CommandResult <LocationBaseDto, Guid> > Update(Guid id, Delta <LocationBaseDto> delta)
{
// Thread.CurrentPrincipal is not available in the constrtor. Do not try and move this
var uid = GetCurrentUser();
// User ID should always be available, but if not ...
if (!uid.HasValue)
{
return(Command.Error <LocationBaseDto>(GeneralErrorCodes.TokenInvalid("UserId")));
}
if (delta == null)
{
return(Command.Error <LocationBaseDto>(EntityErrorCode.EntityFormatIsInvalid));
}
var location = await _context.GetLocationsForUser(uid.Value)
.SingleOrDefaultAsync(l => l.Id == id)
.ConfigureAwait(false);
if (location == null)
{
return(Command.Error <LocationBaseDto>(EntityErrorCode.EntityNotFound));
}
var locationDto = _mapper.Map(location, new LocationBaseDto());
delta.Patch(locationDto);
var validationResponse = ValidatorUpdate.Validate(locationDto);
if (locationDto.ParentId.HasValue)
{
var existingTask = _context.Locations.AnyAsync(l => l.Id == locationDto.ParentId.Value);
if (!existingTask.Result)
{
validationResponse.FFErrors.Add(ValidationErrorCode.ForeignKeyValueDoesNotExist(nameof(Location.ParentId)));
}
else
{
// Check for circular references
if (await LocationValidator.IsCircularReference(_context.Locations, locationDto, id))
{
validationResponse.FFErrors.Add(ValidationErrorCode.CircularReferenceNotAllowed(nameof(Location.ParentId)));
}
}
}
// Check that Location Type exists
if (locationDto.LocationTypeId != Guid.Empty && !_context.LocationTypes.Any(lt => lt.Id == locationDto.LocationTypeId))
{
validationResponse.FFErrors.Add(ValidationErrorCode.ForeignKeyValueDoesNotExist(nameof(Location.LocationTypeId)));
}
// Including the original Id in the Patch request will not return an error but attempting to change the Id is not allowed.
if (locationDto.Id != id)
{
validationResponse.FFErrors.Add(ValidationErrorCode.EntityIDUpdateNotAllowed("Id"));
}
// Check that unique fields are still unique
if (_context.Locations.Any(l => l.Id != id && l.Name == locationDto.Name))
{
validationResponse.FFErrors.Add(ValidationErrorCode.EntityPropertyDuplicateNotAllowed(nameof(Location.Name)));
}
if (validationResponse.IsInvalid)
{
return(Command.Error <LocationBaseDto>(validationResponse));
}
_context.Locations.Attach(location);
_mapper.Map(locationDto, location);
location.SetAuditFieldsOnUpdate(uid.Value);
await _context.SaveChangesAsync().ConfigureAwait(false);
return(Command.NoContent <LocationBaseDto>());
}
/// <summary>
/// Creates a location.
/// </summary>
/// <param name="dto">Data Transfer Object (DTO) used to create a location.</param>
/// <returns>
/// An asynchronous task result containing information needed to create an API response message.
/// If successful, the task result contains the DTO associated with the location.
/// </returns>
/// <remarks>
/// Note that there is no checking for a circular reference for creating a location. This is
/// because the created item does not have children. So, there cannot be a circular reference.
/// </remarks>
public override async Task <CommandResult <LocationQueryDto, Guid> > Create(LocationBaseDto dto)
{
// Thread.CurrentPrincipal is not available in the constructor. Do not try to move this.
var uid = GetCurrentUser();
// User ID should always be available, but if not ...
if (!uid.HasValue)
{
return(Command.Error <LocationQueryDto>(GeneralErrorCodes.TokenInvalid("UserId")));
}
var user = await _context.Users
.Include(x => x.Tenants.Select(y => y.ProductOfferings))
.FirstOrDefaultAsync(u => u.Id == uid.Value);
if (user == null)
{
return(Command.Error <LocationQueryDto>(GeneralErrorCodes.TokenInvalid("UserId")));
}
var validationResponse = ValidatorCreate.Validate(dto);
if (dto == null)
{
return(Command.Error <LocationQueryDto>(validationResponse));
}
if (dto.Id != Guid.Empty)
{
validationResponse.FFErrors.Add(ValidationErrorCode.PropertyIsInvalid(nameof(Location.Id)));
}
var existing = await _context.Locations.AnyAsync(l => l.Name == dto.Name).ConfigureAwait(false);
if (existing)
{
validationResponse.FFErrors.Add(EntityErrorCode.EntityAlreadyExists);
}
if (dto.ParentId.HasValue)
{
existing = await _context.Locations.AnyAsync(l => l.Id == dto.ParentId.Value).ConfigureAwait(false);
if (!existing)
{
validationResponse.FFErrors.Add(ValidationErrorCode.ForeignKeyValueDoesNotExist(nameof(Location.ParentId)));
}
}
if (dto.LocationTypeId != Guid.Empty && !_context.LocationTypes.Any(lt => lt.Id == dto.LocationTypeId))
{
validationResponse.FFErrors.Add(ValidationErrorCode.ForeignKeyValueDoesNotExist(nameof(Location.LocationTypeId)));
}
if (validationResponse.IsInvalid)
{
return(Command.Error <LocationQueryDto>(validationResponse));
}
var location = new Location
{
Id = Guid.NewGuid()
};
_mapper.Map(dto, location);
location.CreatedById = uid.Value;
location.CreatedOn = DateTime.UtcNow;
location.SetAuditFieldsOnUpdate(uid.Value);
_context.Locations.Add(location);
// Add the Location to the Product Offering / Tenant / Location List
if (user.Tenants.Count > 0)
{
// Only care about the first tenant in the list. In the future, the list of tenants
// will contain only one element and may be replaced by a scalar.
var tenant = user.Tenants.ElementAt(0);
// Add a Product Offering / Tenant / Location for the Collect PO
// TODO: This is going to break if we change the name of the productOffering
var productOffering = tenant.ProductOfferings.FirstOrDefault(x => x.Name == "Collect");
if (productOffering == null)
{
return(Command.Error <LocationQueryDto>(EntityErrorCode.ReferencedEntityNotFound));
}
var productOfferingTenantLocation = new ProductOfferingTenantLocation
{
ProductOfferingId = productOffering.Id,
TenantId = tenant.Id,
LocationId = location.Id
};
_context.ProductOfferingTenantLocations.Add(productOfferingTenantLocation);
}
await _context.SaveChangesAsync().ConfigureAwait(false);
return(Command.Created(_mapper.Map(location, new LocationQueryDto()), location.Id));
}
public override async Task <CommandResult <InAppMessageBaseDto, Guid> > Update(Guid id, Delta <InAppMessageBaseDto> delta)
{
// Check user has proper access to update the message
var uid = GetCurrentUser();
if (!uid.HasValue)
{
return(Command.Error <InAppMessageBaseDto>(GeneralErrorCodes.TokenInvalid("UserId")));
}
if (delta == null)
{
return(Command.Error <InAppMessageBaseDto>(EntityErrorCode.EntityFormatIsInvalid));
}
var entity = _context.InAppMessages.SingleOrDefault(msg => msg.Id == id);
if (entity == null)
{
return(Command.Error <InAppMessageBaseDto>(EntityErrorCode.EntityNotFound));
}
// Check if the calling User shares a Tenant with the UserId passed in
var tenants = _context.GetTenantsForUser(uid.Value);
var shareTenant = tenants.Any(t => t.Users.Any(u => u.Id == entity.UserId));
if (!shareTenant)
{
return(Command.Error <InAppMessageBaseDto>(ValidationErrorCode.ForeignKeyValueDoesNotExist("UserId")));
}
var dto = _mapper.Map(entity, new InAppMessageBaseDto());
delta.Patch(dto);
var validationResponse = ValidatorUpdate.Validate(dto);
// Including the original Id in the Patch request will not return an error but attempting to change the Id is not allowed.
if (dto.Id != id)
{
validationResponse.FFErrors.Add(ValidationErrorCode.EntityIDUpdateNotAllowed("Id"));
}
if (validationResponse.IsInvalid)
{
return(Command.Error <InAppMessageBaseDto>(validationResponse));
}
// Apply the update
_context.InAppMessages.Attach(entity);
//if the entity's IsRead flag get set to true from false, then set the DateRead to now
if (dto.IsRead == true == !entity.IsRead)
{
entity.DateRead = DateTime.UtcNow;
}
else if (dto.IsRead == false == !entity.IsRead)
{
entity.DateRead = null;
}
_mapper.Map(dto, entity);
entity.SetAuditFieldsOnUpdate(uid.Value);
await _context.SaveChangesAsync().ConfigureAwait(false);
return(Command.NoContent <InAppMessageBaseDto>());
}
/// <summary>
/// Accepts a single xls file that contains operation configuration.
/// </summary>
/// <param name="fileMetadata">Metadata associated with the file upload request.</param>
/// <param name="authenticationHeader">Authentication header for the request.</param>
/// <param name="requestTenantId">The selected Tenant Id from the request import the Operation Config to</param>
/// <returns>A task that returns the result of the upload option.</returns>
public async Task <CommandResultNoDto> Upload(FileUploadMetadataDto fileMetadata, string authenticationHeader, Guid requestTenantId)
{
var errors = new List <FFErrorCode>();
var odataHelper = new Core.Api.OData.ODataHelper();
var userId = Thread.CurrentPrincipal == null ? null : Thread.CurrentPrincipal.GetUserIdFromPrincipal();
if (userId == null)
{
errors.Add(GeneralErrorCodes.TokenInvalid("UserId"));
}
if (errors.Count > 0)
{
return(NoDtoHelpers.CreateCommandResult(errors));
}
// ReSharper disable once AssignNullToNotNullAttribute
var userIdGuid = Guid.Parse(userId);
// Check that the Tenant Id in the request body is in the user's claim tenants
var tenants = odataHelper.GetTenantIds(Thread.CurrentPrincipal) as List <Guid>;
// Check user has no tenants in their claim or if the tenantid in the request body is not in the claim
if (tenants == null || tenants.All(x => x != requestTenantId))
{
errors.Add(ValidationErrorCode.ForeignKeyValueDoesNotExist("TenantId"));
}
if (errors.Count > 0)
{
return(NoDtoHelpers.CreateCommandResult(errors));
}
// Store file in blob storage.
var result = await _blobManager.StoreAsync(_blobStorageConnectionString, _blobStorageContainerName, fileMetadata.SavedFileName);
// Add file metadata to documentDB to later be retrieved by request
// An Id property is created by documentDB and in populated in the result object
await _documentDb.CreateItemAsync(
new UploadTransaction
{
OriginalFileName = fileMetadata.OriginalFileName,
TenantIds = tenants,
UploadTransactionType = fileMetadata.TransactionType,
UserId = userIdGuid,
UtcTimestamp = DateTime.UtcNow
});
var queueMessage = new BlobQueueMessage
{
BlobName = result.BlobName,
BlobSize = result.BlobSize,
BlobUrl = result.BlobUrl,
BlobTransactionType = fileMetadata.TransactionType,
UserId = userIdGuid,
AuthenticationHeader = authenticationHeader,
// TenantId should be checked by the blob processor that it matches the tenant in the Operation Config to be processed
TenantId = requestTenantId
};
var msg = JsonConvert.SerializeObject(queueMessage);
// Add message to queue.
await _queueManager.AddAsync(_blobStorageConnectionString, _queueStorageContainerName, msg);
return(NoDtoHelpers.CreateCommandResult(errors));
}
/// <summary>
/// Deletes the requested operation if the operation has no measurements associated to it's locations.
/// </summary>
/// <param name="operationId">Guid identitifer of the operation to delete</param>
/// <returns>Task that returns the request result.</returns>
public async Task <CommandResultNoDto> Delete(Guid?operationId)
{
var errors = new List <FFErrorCode>();
var userId = Thread.CurrentPrincipal == null ? null : Thread.CurrentPrincipal.GetUserIdFromPrincipal();
if (string.IsNullOrEmpty(userId))
{
errors.Add(GeneralErrorCodes.TokenInvalid("UserId"));
}
if (!operationId.HasValue || operationId == Guid.Empty)
{
errors.Add(ValidationErrorCode.PropertyRequired("OperationId"));
}
if (errors.Count > 0)
{
return(NoDtoHelpers.CreateCommandResult(errors));
}
var userIdGuid = Guid.Parse(userId);
List <Location> locations = new List <Location>();
List <LocationParameterLimit> locationParameterLimits = new List <LocationParameterLimit>();
List <LocationParameter> locationParameters = new List <LocationParameter>();
List <LocationLogEntry> locationLocationLogEntries = new List <LocationLogEntry>();
// Check that the Location exists and if it's an operation
if (!_context.Locations.Any(x => x.Id == operationId.Value && x.LocationType.LocationTypeGroup.Id == Data.Constants.LocationTypeGroups.Operation.Id))
{
errors.Add(EntityErrorCode.EntityNotFound);
}
else
{
// Check if user is in the proper tenant.
if (!_context.Locations.Single(x => x.Id == operationId.Value)
.ProductOfferingTenantLocations.Any(x => x.Tenant.Users.Any(u => u.Id == userIdGuid)))
{
errors.Add(ValidationErrorCode.ForeignKeyValueDoesNotExist("TenantId"));
}
// Check that the operation has no measurements or notes and can be deleted
// NOTE : This method will not scale beyond more than 4 or 5 levels max
var operation = _context.Locations.Include("Locations").Single(x => x.Id == operationId.Value);
locations.Add(operation);
var systems = operation.Locations;
locations.AddRange(systems);
foreach (var system in systems)
{
locations.AddRange(_context.Locations.Where(x => x.ParentId == system.Id).ToList());
}
var locationIds = locations.Select(l => l.Id);
locationParameters =
_context.LocationParameters.Where(x => locationIds.Contains(x.LocationId)).ToList();
var locationParamIds = locationParameters.Select(lp => lp.Id);
locationParameterLimits =
_context.LocationParameterLimits.Where(
x => locationParamIds.Contains(x.LocationParameterId)).ToList();
var hasLocationLocationLogEntries =
_context.LocationLogEntries.Any(x => locationIds.Contains(x.LocationId));
var hasMeasurements = _context.Measurements.Any(x => locationParamIds.Contains(x.LocationParameterId));
var hasParameterNotes =
_context.LocationParameterNotes.Any(
x => locationParamIds.Contains(x.LocationParameterId));
var hasMeasurementTransactions =
_context.MeasurementTransactions.Any(x => locationIds.Contains(x.LocationId));
if (hasParameterNotes || hasMeasurements || hasLocationLocationLogEntries || hasMeasurementTransactions)
{
errors.Add(EntityErrorCode.EntityCouldNotBeDeleted);
}
}
if (errors.Count > 0)
{
return(NoDtoHelpers.CreateCommandResult(errors));
}
_context.LocationParameterLimits.RemoveRange(locationParameterLimits);
_context.LocationParameters.RemoveRange(locationParameters);
_context.Locations.RemoveRange(locations);
_context.LocationLogEntries.RemoveRange(locationLocationLogEntries);
await _context.SaveChangesAsync().ConfigureAwait(false);
var commandResult = NoDtoHelpers.CreateCommandResult(errors);
// CreateCommandResult will either return BadRequest(400) or Ok(200)
// Overriding the Status code to return a 204 on a successful delete
commandResult.StatusCode = FacadeStatusCode.NoContent;
return(commandResult);
}
/// <summary>
/// Creates an operation configuration file and saves it to blob storage. When
/// the file is ready to be downloaded, a signalr notification is sent to the user who made the
/// requst.
/// </summary>
/// <param name="tenantId">Identifies the tenant that the operation belongs to.</param>
/// <param name="operationId">Identifies the operation to create the configuration for or
/// null to create a configuration file template with no operation related data.</param>
/// <param name="authenticationHeader">Authentication header for the request.</param>
/// <returns>A task that returns the result of the request.</returns>
public async Task <CommandResultNoDto> Get(Guid tenantId, Guid?operationId, string authenticationHeader)
{
var errors = new List <FFErrorCode>();
var userId = Thread.CurrentPrincipal == null ? null : Thread.CurrentPrincipal.GetUserIdFromPrincipal();
if (userId == null)
{
errors.Add(GeneralErrorCodes.TokenInvalid("UserId"));
}
if (errors.Count > 0)
{
return(NoDtoHelpers.CreateCommandResult(errors));
}
// ReSharper disable once AssignNullToNotNullAttribute
var userIdGuid = Guid.Parse(userId);
// Check that the user has access to the requested tenant.
var odataHelper = new Core.Api.OData.ODataHelper();
var tenants = odataHelper.GetTenantIds(Thread.CurrentPrincipal) as List <Guid>;
if (tenants == null || tenants.All(x => x != tenantId))
{
errors.Add(ValidationErrorCode.ForeignKeyValueDoesNotExist("TenantId"));
}
if (operationId != null)
{
var operation = await _context.Locations.FirstOrDefaultAsync(x => x.Id == operationId).ConfigureAwait(false);
if (operation == null)
{
errors.Add(ValidationErrorCode.ForeignKeyValueDoesNotExist("OperationId"));
}
else if (operation.ProductOfferingTenantLocations.All(x => x.TenantId != tenantId))
{
errors.Add(ValidationErrorCode.ForeignKeyValueDoesNotExist("TenantId"));
}
}
if (errors.Count > 0)
{
return(NoDtoHelpers.CreateCommandResult(errors));
}
var transactionType = operationId == null
? UploadTransactionTypes.ExportOperationTemplate : UploadTransactionTypes.ExportOperationConfig;
var queueMessage = new BlobQueueMessage
{
BlobTransactionType = transactionType,
UserId = userIdGuid,
TenantId = tenantId,
OperationId = operationId,
AuthenticationHeader = authenticationHeader
};
// Add message to queue.
await _queueManager.AddAsync(_blobStorageConnectionString, _queueStorageContainerName, JsonConvert.SerializeObject(queueMessage));
return(NoDtoHelpers.CreateCommandResult(errors));
}
