public async Task TestUpdateAssignmentFailsWith400OnMissingClient()
{
// arrange
var assignmentController = GetAssignmentController();
var nonExistantClientId = "ffff0000ffff0000ffff0000ffff0000";
var client = new Client {
Id = Guid.NewGuid().ToString("n"), Name = "John", LastName = "Carmack"
};
var provider = new Provider {
Id = Guid.NewGuid().ToString("n"), Name = "bTow"
};
var worker = new ProviderWorker {
Id = Guid.NewGuid().ToString("n"), Name = "Andrew", LastName = "Garfield"
};
var assignment =
new Assignment
{
Id = Guid.NewGuid().ToString("n"),
Status = AssignmentStatus.Created,
StatusReason = AssignmentStatusReason.New,
CreationDateTime = DateTimeOffset.Now,
InitialLocation = new GeoJson2DGeographicCoordinates(-58.375979, -34.605062),
ClientId = client.Id,
WorkerId = worker.Id,
ProviderId = provider.Id
};
var updateAssignmentVM =
new UpdateAssignmentBindingModel
{
Status = AssignmentStatus.InProgress,
StatusReason = AssignmentStatusReason.WorkerEnRoute,
UpdateDateTime = DateTimeOffset.Now,
InitialLocation = new GeoLocation {
Latitude = -34.605062, Longitude = -58.375979
},
ClientId = nonExistantClientId,
WorkerId = worker.Id,
ProviderId = provider.Id
};
_testDataStore.EnsureClientDoesNotExist(nonExistantClientId);
_testDataStore.EnsureClient(client);
_testDataStore.EnsureProvider(provider);
_testDataStore.EnsureWorker(worker);
_testDataStore.EnsureAssignment(assignment);
// act
var actualResult = await assignmentController.UpdateAssignment(assignment.Id, updateAssignmentVM);
// assert
var actualUpdateAssignmentResult = actualResult as BadRequestObjectResult;
Assert.True(actualUpdateAssignmentResult != null, "actualUpdateAssignmentResult should be of type BadRequestObjectResult");
Assert.Equal(400, actualUpdateAssignmentResult.StatusCode);
Assert.NotNull(actualUpdateAssignmentResult.Value);
}
public async Task <IActionResult> NewWorker(string providerId, [FromBody] ProviderWorkerBindingModel bindingModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrors()));
}
var(imageBucket, outcomeAction, error) =
await _imageBucketRepository.NewImageBucket(
new ImageBucket
{
StoreBucket = new ImageBucketKey {
Store = Constants.WORKER_IMAGES_STORE
},
ImageList = new List <string>()
});
if (outcomeAction != RepositoryOutcomeAction.OkCreated)
{
return(this.StatusCode(500, error));
}
var providerWorker = new ProviderWorker
{
Name = bindingModel.Name,
LastName = bindingModel.LastName,
Email = bindingModel.Email,
PhoneNumber = bindingModel.PhoneNumber,
ProviderWorkerImageBucketKey = imageBucket.StoreBucket
};
(providerWorker, outcomeAction, error) = await _providerWorkerRepository.NewAsync(providerId, providerWorker);
try
{
var userRegistration = await _userService.RegisterUserAsync(
new UserRegistration
{
ProviderId = providerId,
WorkerId = providerWorker.Id,
FirstName = bindingModel.Name,
LastName = bindingModel.LastName,
Email = bindingModel.Email,
Password = bindingModel.Password,
});
}
catch (ApiException ex)
{
return(BadRequest(ex.ApiError));
}
var location = this.Url.BuildGetProviderWorkerUrl(providerId, providerWorker?.Id);
return(this.FromRepositoryOutcome(outcomeAction, error, MapToProviderWorkerViewModel(providerWorker), location));
}
public async Task NewAsyncShouldThrowArgumentNullExceptionOnNullProviderId()
{
// arrange
var providerWorkerRepository = new ProviderWorkerRepository(_mongoDatabase);
var providerWorker = new ProviderWorker();
// act (deferred)
var testCode = (Func <Task>)(async() => await providerWorkerRepository.NewAsync(null, providerWorker));
// assert
await Assert.ThrowsAsync <ArgumentNullException>(testCode);
}
public async Task TesNewAsyncCreatesProviderWorkerResult()
{
// arrange
var providerId = Guid.NewGuid().ToString("n");
var provider = new Provider
{
Id = providerId,
City = "Springfield",
State = "Illinois",
Name = "TowNow!",
Email = "*****@*****.**",
ZipCode = "2342",
ProviderImageBucketKey = new ImageBucketKey {
Store = "some-store", Bucket = Guid.NewGuid().ToString("n")
},
Address = "742 Evergreen Terrace",
};
var providerWorker = new ProviderWorker
{
ProviderId = providerId,
Name = "Homer",
LastName = "Simpson",
};
_dataStore.EnsureProvider(provider);
// act
var(providerWorkerResult, outcomeAction, error) = await _providerWorkerRepository.NewAsync(providerId, providerWorker);
// assert
Assert.NotNull(providerWorkerResult);
Assert.Equal(RepositoryOutcomeAction.OkCreated, outcomeAction);
Assert.Null(error);
// here we check that what was returned is the same as we sent.
Assert.NotNull(providerWorkerResult.Id);
Assert.Equal(providerWorker.ProviderId, providerWorkerResult.ProviderId);
Assert.Equal(providerWorker.LastKnownLocation, providerWorkerResult.LastKnownLocation);
Assert.Equal(providerWorker.LastName, providerWorkerResult.LastName);
Assert.Equal(providerWorker.Name, providerWorkerResult.Name);
Assert.Equal(providerWorker.PhoneNumber, providerWorkerResult.PhoneNumber);
Assert.Equal(providerWorker.Status, providerWorkerResult.Status);
Assert.True(
_dataStore
.TestProviderWorker(_ =>
_.Id == providerWorker.Id &&
_.ProviderId == providerWorker.ProviderId &&
_.LastKnownLocation == providerWorker.LastKnownLocation &&
_.LastName == providerWorker.LastName &&
_.Name == providerWorker.Name &&
_.PhoneNumber == providerWorker.PhoneNumber &&
_.Status == providerWorker.Status));
}
private ProviderWorkerViewModel MapToProviderWorkerViewModel(ProviderWorker providerWorker) =>
providerWorker != null
? new ProviderWorkerViewModel
{
Id = providerWorker.Id,
ProviderId = providerWorker.ProviderId,
Name = providerWorker.Name,
LastName = providerWorker.LastName,
Email = providerWorker.Email,
LastKnownLocation = providerWorker.LastKnownLocation,
PhoneNumber = providerWorker.PhoneNumber,
Status = providerWorker.Status,
ProfilePictureUrl = Url.BuildGetImageUrl(providerWorker?.ProviderWorkerImageBucketKey?.Store, providerWorker?.ProviderWorkerImageBucketKey?.Bucket, "profilepicture"),
DeviceId = providerWorker.DeviceId
}
: null;
public async Task TestGetByIdAsyncCanRetrieveProviderWorker()
{
// arrange
var providerId = Guid.NewGuid().ToString("n");
var id = Guid.NewGuid().ToString("n");
var provider = new Provider
{
Id = providerId,
City = "Springfield",
State = "Illinois",
Name = "TowNow!",
Email = "*****@*****.**",
ZipCode = "2342",
ProviderImageBucketKey = new ImageBucketKey {
Store = "some-store", Bucket = Guid.NewGuid().ToString("n")
},
Address = "742 Evergreen Terrace",
};
var providerWorker = new ProviderWorker
{
Id = id,
ProviderId = providerId,
Name = "Homer",
LastName = "Simpson"
};
_dataStore.EnsureProvider(provider);
_dataStore.EnsureProviderWorker(providerWorker);
// act
var(providerWorkerResult, outcomeAction, error) = await _providerWorkerRepository.GetByIdAsync(providerId, id);
// assert
Assert.NotNull(providerWorkerResult);
Assert.Equal(RepositoryOutcomeAction.OkNone, outcomeAction);
Assert.Null(error);
Assert.Equal(providerWorker.Id, providerWorkerResult.Id);
Assert.Equal(providerWorker.ProviderId, providerWorkerResult.ProviderId);
Assert.Equal(providerWorker.LastKnownLocation, providerWorkerResult.LastKnownLocation);
Assert.Equal(providerWorker.LastName, providerWorkerResult.LastName);
Assert.Equal(providerWorker.Name, providerWorkerResult.Name);
Assert.Equal(providerWorker.PhoneNumber, providerWorkerResult.PhoneNumber);
Assert.Equal(providerWorker.Status, providerWorkerResult.Status);
}
public async Task TestGetAssignmentSucceedsWith200OnExistentDocument()
{
// arrange
var assignmentController = GetAssignmentController();
var client = new Client {
Id = Guid.NewGuid().ToString("n"), Name = "John", LastName = "Carmack"
};
var provider = new Provider {
Id = Guid.NewGuid().ToString("n"), Name = "bTow"
};
var worker = new ProviderWorker {
Id = Guid.NewGuid().ToString("n"), Name = "Andrew", LastName = "Garfield"
};
var assignment =
new Assignment
{
Id = Guid.NewGuid().ToString("n"),
ClientId = client.Id,
WorkerId = worker.Id,
ProviderId = provider.Id,
Status = AssignmentStatus.Created,
StatusReason = AssignmentStatusReason.New,
CreationDateTime = DateTimeOffset.Now
};
_testDataStore.EnsureClient(client);
_testDataStore.EnsureProvider(provider);
_testDataStore.EnsureWorker(worker);
_testDataStore.EnsureAssignment(assignment);
// act
var actualResult = await assignmentController.GetAssignment(assignment.Id);
// assert
var actualAssignmentResult = actualResult as OkObjectResult;
var actualAssignment = actualAssignmentResult.Value as AssignmentViewModel;
Assert.True(actualAssignmentResult != null, "actualAssignmentResult should be of type OkObjectResult");
Assert.True(actualAssignment != null, "actualAssignment should be of Type Assignment");
Assert.Equal(200, actualAssignmentResult.StatusCode);
Assert.Equal(assignment.Id, actualAssignment.Id);
}
public async Task TestNewAssignmentSucceedsWith201()
{
// arrange
var assignmentController = GetAssignmentController();
var client = new Client {
Id = Guid.NewGuid().ToString("n"), Name = "John", LastName = "Carmack"
};
var provider = new Provider {
Id = Guid.NewGuid().ToString("n"), Name = "bTow"
};
var worker = new ProviderWorker {
Id = Guid.NewGuid().ToString("n"), Name = "Andrew", LastName = "Garfield"
};
var assignmentVM =
new NewAssignmentBindingModel
{
InitialLocation = new GeoLocation {
Latitude = -34.605062, Longitude = -58.375979
},
ClientId = client.Id,
WorkerId = worker.Id,
ProviderId = provider.Id,
Status = AssignmentStatus.Created,
StatusReason = AssignmentStatusReason.New,
CreationDateTime = DateTimeOffset.Now
};
_testDataStore.EnsureClient(client);
_testDataStore.EnsureProvider(provider);
_testDataStore.EnsureWorker(worker);
// act
var actualResult = await assignmentController.NewAssignment(assignmentVM);
// assert
var actualNewAssignmentResult = actualResult as CreatedResult;
Assert.True(actualNewAssignmentResult != null, "actualNewAssignmentResult should be of type CreatedResult");
Assert.Equal(201, actualNewAssignmentResult.StatusCode);
Assert.Matches("^.*/assignment/.*$", actualNewAssignmentResult.Location);
}
public async Task <ProviderWorkerDisplayModel> UpdateBySlug(string slug, ProviderWorkerUpdateModel model)
{
if (!await _providerRepository.IsWorkerInRoleBySlug(slug, _userId, ProviderWorkerRole.USER_MANAGER))
{
throw new AccessDeniedException("", typeof(AppUser));
}
var shortUser = await _appUserRepository.GetShortById(model.UserId);
if (shortUser == null)
{
throw new EntityNotFoundException(model.UserId, typeof(AppUser));
}
if (shortUser.Status == UserStatus.Blocked)
{
throw new MRException(-1, "User is blocked");
}
ProviderWorker entity = _mapper.Map <ProviderWorker>(model);
entity.UserEmail = shortUser.Email;
if (!await _providerRepository.IsWorkerExistsBySlug(slug, model.UserId))
{
await _providerRepository.InsertWorkersBySlug(slug, entity);
}
else
{
await _providerRepository.UpdateWorkerBySlug(slug, model.UserId, model.Roles);
}
if (!await _appUserManager.IsInRoleAsync(shortUser, AppUserRoleList.MANAGER))
{
await _appUserManager.AddToRoleAsync(shortUser, AppUserRoleList.MANAGER);
}
return(_mapper.Map <ProviderWorkerDisplayModel>(entity).ApplyUser(shortUser));
}
public async Task TesNewAsyncFailsToCreateProviderWorkerWhenProviderDoesNotExist()
{
// arrange
var providerId = "0000ffff0000ffff0000ffff0000ffff";
var providerWorker = new ProviderWorker
{
ProviderId = providerId,
Name = "Homer",
LastName = "Simpson"
};
_dataStore.EnsureProviderDoesNotExist(providerId);
// act
var(providerWorkerResult, outcomeAction, error) = await _providerWorkerRepository.NewAsync(providerId, providerWorker);
// assert
Assert.Null(providerWorkerResult);
Assert.Equal(RepositoryOutcomeAction.ValidationErrorNone, outcomeAction);
Assert.NotNull(error);
}
public async Task TestPatchLastKnownLocationAsyncReturnsNullOnNonExistantProvider()
{
// arrange
var providerId = Guid.NewGuid().ToString("n");
var id = "0000ffff0000ffff0000ffff0000ffff";
var provider = new Provider
{
Id = providerId,
City = "Springfield",
State = "Illinois",
Name = "TowNow!",
Email = "*****@*****.**",
ZipCode = "2342",
ProviderImageBucketKey = new ImageBucketKey {
Store = "some-store", Bucket = Guid.NewGuid().ToString("n")
},
Address = "742 Evergreen Terrace",
};
var providerWorker = new ProviderWorker
{
Id = id,
ProviderId = providerId,
Name = "Homer",
LastName = "Simpson"
};
_dataStore.EnsureProvider(provider);
_dataStore.EnsureProviderWorkerDoesNotExist(providerId, id);
// act
var(updateProviderWorkerResult, outcomeAction, error) = await _providerWorkerRepository.PatchLastKnownLocationAsync(providerId, providerWorker);
// assert
Assert.Null(updateProviderWorkerResult);
Assert.Equal(RepositoryOutcomeAction.NotFoundNone, outcomeAction);
Assert.Null(error);
}
public async Task TestPatchLastKnownLocationAsyncFailsToUpdateProviderWorkerWhenProviderDoesNotExist()
{
// arrange
var providerId = "0000ffff0000ffff0000ffff0000ffff";
var id = Guid.NewGuid().ToString("n");
var providerWorker = new ProviderWorker
{
Id = id,
ProviderId = providerId,
Name = "Homer",
LastName = "Simpson"
};
_dataStore.EnsureProviderDoesNotExist(providerId);
// act
var(updateProviderWorkerResult, outcomeAction, error) = await _providerWorkerRepository.PatchLastKnownLocationAsync(providerId, providerWorker);
// assert
Assert.Null(updateProviderWorkerResult);
Assert.Equal(RepositoryOutcomeAction.ValidationErrorNone, outcomeAction);
Assert.NotNull(error);
}
public async Task TestPatchAsyncPatchesProviderWorker(JsonPatchDocument <ProviderWorker> providerWorkerPatch)
{
// arrange
var providerId = Guid.NewGuid().ToString("n");
var id = Guid.NewGuid().ToString("n");
var provider = new Provider
{
Id = providerId,
City = "Springfield",
State = "Illinois",
Name = "TowNow!",
Email = "*****@*****.**",
ZipCode = "2342",
ProviderImageBucketKey = new ImageBucketKey {
Store = "some-store", Bucket = Guid.NewGuid().ToString("n")
},
Address = "742 Evergreen Terrace",
};
var providerWorker = new ProviderWorker
{
Id = id,
ProviderId = providerId,
Name = "Homer",
LastName = "Simpson",
LastKnownLocation = new GeoLocation {
Longitude = -67, Latitude = 32
},
Status = ProviderWorkerStatus.Idle,
};
var expectedProviderWorker = new ProviderWorker
{
Id = providerWorker.Id,
ProviderId = providerWorker.ProviderId,
Name = providerWorker.Name,
LastName = providerWorker.LastName,
LastKnownLocation = providerWorker.LastKnownLocation,
Status = providerWorker.Status
};
providerWorkerPatch.ApplyTo(expectedProviderWorker);
_dataStore.EnsureProvider(provider);
_dataStore.EnsureProviderWorker(providerWorker);
// act
var(patchedProviderWorkerResult, outcomeAction, error) = await _providerWorkerRepository.PatchAsync(providerId, id, providerWorkerPatch);
// assert
Assert.NotNull(patchedProviderWorkerResult);
Assert.Equal(RepositoryOutcomeAction.OkUpdated, outcomeAction);
Assert.Null(error);
Assert.Equal(expectedProviderWorker.Id, patchedProviderWorkerResult.Id);
Assert.Equal(expectedProviderWorker.ProviderId, patchedProviderWorkerResult.ProviderId);
Assert.Equal(expectedProviderWorker.LastKnownLocation, patchedProviderWorkerResult.LastKnownLocation);
Assert.Equal(expectedProviderWorker.LastName, patchedProviderWorkerResult.LastName);
Assert.Equal(expectedProviderWorker.Name, patchedProviderWorkerResult.Name);
Assert.Equal(expectedProviderWorker.PhoneNumber, patchedProviderWorkerResult.PhoneNumber);
Assert.Equal(expectedProviderWorker.Status, patchedProviderWorkerResult.Status);
Assert.Equal(expectedProviderWorker.ProviderWorkerImageBucketKey?.Store, patchedProviderWorkerResult.ProviderWorkerImageBucketKey?.Store);
Assert.Equal(expectedProviderWorker.ProviderWorkerImageBucketKey?.Bucket, patchedProviderWorkerResult.ProviderWorkerImageBucketKey?.Bucket);
Assert.True(
_dataStore
.TestProviderWorker(_ =>
_.Id == expectedProviderWorker.Id &&
_.ProviderId == expectedProviderWorker.ProviderId &&
(
(
_.LastKnownLocation != null &&
expectedProviderWorker.LastKnownLocation != null &&
_.LastKnownLocation.Latitude == expectedProviderWorker.LastKnownLocation.Latitude &&
_.LastKnownLocation.Longitude == expectedProviderWorker.LastKnownLocation.Longitude) ||
(_.LastKnownLocation == null && expectedProviderWorker.LastKnownLocation == null)
) &&
_.LastName == expectedProviderWorker.LastName &&
_.Name == expectedProviderWorker.Name &&
_.PhoneNumber == expectedProviderWorker.PhoneNumber &&
_.Status == expectedProviderWorker.Status));
}
public async Task TestPatchLastKnownLocationAsyncPatchesProviderWorker()
{
// arrange
var providerId = Guid.NewGuid().ToString("n");
var id = Guid.NewGuid().ToString("n");
var provider = new Provider
{
Id = providerId,
City = "Springfield",
State = "Illinois",
Name = "TowNow!",
Email = "*****@*****.**",
ZipCode = "2342",
ProviderImageBucketKey = new ImageBucketKey {
Store = "some-store", Bucket = Guid.NewGuid().ToString("n")
},
Address = "742 Evergreen Terrace",
};
var providerWorker = new ProviderWorker
{
Id = id,
ProviderId = providerId,
Name = "Homer",
LastName = "Simpson",
LastKnownLocation = new GeoLocation {
Longitude = -67, Latitude = 32
}
};
var updatedProviderWorker = new ProviderWorker
{
Id = id,
ProviderId = providerId,
Name = "Bart",
LastName = "Simpson",
LastKnownLocation = new GeoLocation {
Longitude = -68, Latitude = 31
}
};
_dataStore.EnsureProvider(provider);
_dataStore.EnsureProviderWorker(providerWorker);
// act
var(providerWorkerResult, outcomeAction, error) = await _providerWorkerRepository.PatchLastKnownLocationAsync(providerId, updatedProviderWorker);
// assert
Assert.NotNull(providerWorkerResult);
Assert.Equal(RepositoryOutcomeAction.OkUpdated, outcomeAction);
Assert.Null(error);
Assert.Equal(providerWorker.Id, providerWorkerResult.Id);
Assert.Equal(providerWorker.ProviderId, providerWorkerResult.ProviderId);
// we must test that only LastKnownLocation has changed
Assert.Equal(updatedProviderWorker.LastKnownLocation, providerWorkerResult.LastKnownLocation);
Assert.Equal(providerWorker.LastName, providerWorkerResult.LastName);
Assert.Equal(providerWorker.Name, providerWorkerResult.Name);
Assert.Equal(providerWorker.PhoneNumber, providerWorkerResult.PhoneNumber);
Assert.Equal(providerWorker.Status, providerWorkerResult.Status);
Assert.Equal(providerWorker.ProviderWorkerImageBucketKey?.Store, providerWorkerResult.ProviderWorkerImageBucketKey?.Store);
Assert.Equal(providerWorker.ProviderWorkerImageBucketKey?.Bucket, providerWorkerResult.ProviderWorkerImageBucketKey?.Bucket);
Assert.True(
_dataStore
.TestProviderWorker(_ =>
_.Id == providerWorker.Id &&
_.ProviderId == providerWorker.ProviderId &&
_.LastKnownLocation == updatedProviderWorker.LastKnownLocation &&
_.LastName == providerWorker.LastName &&
_.Name == providerWorker.Name &&
_.PhoneNumber == providerWorker.PhoneNumber &&
_.Status == providerWorker.Status));
}
public async Task <(ProviderWorker providerWorker, RepositoryOutcomeAction outcomeAction, object error)> NewAsync(string providerId, ProviderWorker providerWorker, CancellationToken cancellationToken = default(CancellationToken))
{
if (providerId == null)
{
throw new ArgumentNullException(nameof(providerId));
}
if (providerWorker == null)
{
throw new ArgumentNullException(nameof(providerWorker));
}
var providerExists = await(await _mongoDatabase.Providers().FindAsync(_ => _.Id == providerId, cancellationToken: cancellationToken)).AnyAsync(cancellationToken);
if (!providerExists)
{
return(null, RepositoryOutcomeAction.ValidationErrorNone, new { cause = "Missing Provider", data = providerId });
}
providerWorker.Id = Guid.NewGuid().ToString("n");
providerWorker.ProviderId = providerId;
await _mongoDatabase
.Workers()
.InsertOneAsync(providerWorker, cancellationToken: cancellationToken);
return(providerWorker, RepositoryOutcomeAction.OkCreated, null);
}
public async Task <ProviderWorkerDisplayModel> CreateBySlug(string slug, ProviderWorkerCreateModel model)
{
if (!await _providerRepository.IsWorkerInRoleBySlug(slug, _userId, ProviderWorkerRole.USER_MANAGER))
{
throw new AccessDeniedException(slug, typeof(ProviderWorker));
}
model.Email = model.Email.ToLower();
ProviderWorker worker = null;
var existsUser = await _appUserRepository.FindByEmailAsync(model.Email, new System.Threading.CancellationToken());
if (existsUser == null)
{
existsUser = new AppUser
{
CreateTime = DateTime.UtcNow,
State = MREntityState.Active,
Status = UserStatus.Invited,
Tels = new List <MRUserTel>(),
UserName = model.Email,
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
UpdateTime = DateTime.UtcNow,
};
existsUser = await _appUserRepository.Insert(existsUser);
await _appUserManager.AddToRolesAsync(existsUser, new List <string>()
{
AppUserRoleList.MANAGER,
AppUserRoleList.USER
});
var providerShort = await _providerRepository.GetShortBySlug(slug);
var invite = await _userInviteRepository.Insert(new UserInvite
{
Code = UserInviteCodeGenerator.Generate(),
IsByIdentity = false,
ProviderId = providerShort.Id,
ProviderName = providerShort.Name,
State = MREntityState.Active,
UserId = existsUser.Id
});
_logger.LogInformation("Created new user {0} from provider {1}", existsUser.Email, providerShort.Slug);
// TODO add invite user email
}
else
{
if (await _providerRepository.IsWorkerExistsBySlug(slug, existsUser.Id))
{
throw new EntityExistsException("Id", existsUser.Id, typeof(AppUser));
}
if (!await _appUserManager.IsInRoleAsync(existsUser, AppUserRoleList.MANAGER))
{
await _appUserManager.AddToRoleAsync(existsUser, AppUserRoleList.MANAGER);
}
// TODO add welcome to provider user email
}
worker = new ProviderWorker
{
Roles = model.Roles,
UserEmail = model.Email,
UserId = existsUser.Id
};
await _providerRepository.InsertWorkersBySlug(slug, worker);
_logger.LogInformation("Added new worker {0} to provider {1} by user {2}", worker.UserEmail, slug, _userEmail);
return(_mapper.Map <ProviderWorkerDisplayModel>(worker).ApplyUser(existsUser));
}
public async Task <bool> InsertWorkersBySlug(string slug, ProviderWorker worker) => await InsertWorkersBySlug(slug, new List <ProviderWorker>() { worker });
public async Task <(ProviderWorker providerWorker, RepositoryOutcomeAction outcomeAction, object error)> PatchAllButProviderWorkerImageStoreAsync(string providerId, ProviderWorker providerWorker, CancellationToken cancellationToken = default(CancellationToken))
{
if (providerId == null)
{
throw new ArgumentNullException(nameof(providerId));
}
if (providerWorker == null)
{
throw new ArgumentNullException(nameof(providerWorker));
}
var providerExists = await(await _mongoDatabase.Providers().FindAsync(_ => _.Id == providerId, cancellationToken: cancellationToken)).AnyAsync(cancellationToken);
if (!providerExists)
{
return(null, RepositoryOutcomeAction.ValidationErrorNone, new { cause = "Missing Provider", data = providerId });
}
providerWorker.ProviderId = providerId;
var result =
await _mongoDatabase.Workers()
.FindOneAndUpdateAsync(
new FilterDefinitionBuilder <ProviderWorker>()
.And(
new FilterDefinitionBuilder <ProviderWorker>().Eq(_ => _.ProviderId, providerWorker.ProviderId),
new FilterDefinitionBuilder <ProviderWorker>().Eq(_ => _.Id, providerWorker.Id)),
new UpdateDefinitionBuilder <ProviderWorker>()
.Set(_ => _.DeviceId, providerWorker.DeviceId)
.Set(_ => _.Email, providerWorker.Email)
.Set(_ => _.Name, providerWorker.Name)
.Set(_ => _.LastName, providerWorker.LastName)
.Set(_ => _.LastKnownLocation, providerWorker.LastKnownLocation)
.Set(_ => _.PhoneNumber, providerWorker.PhoneNumber)
.Set(_ => _.Status, providerWorker.Status),
new FindOneAndUpdateOptions <ProviderWorker>()
{
ReturnDocument = ReturnDocument.After
},
cancellationToken);
var outcomeAction = result != null ? RepositoryOutcomeAction.OkUpdated : RepositoryOutcomeAction.NotFoundNone;
return(result, outcomeAction, null);
}
public void EnsureWorker(ProviderWorker worker)
{
_mongoDatabase.Workers().InsertOne(worker);
}
public async Task <(ProviderWorker providerWorker, RepositoryOutcomeAction outcomeAction, object error)> UpdateAsync(string providerId, ProviderWorker providerWorker, CancellationToken cancellationToken = default(CancellationToken))
{
if (providerId == null)
{
throw new ArgumentNullException(nameof(providerId));
}
if (providerWorker == null)
{
throw new ArgumentNullException(nameof(providerWorker));
}
var providerExists = await(await _mongoDatabase.Providers().FindAsync(_ => _.Id == providerId, cancellationToken: cancellationToken)).AnyAsync(cancellationToken);
if (!providerExists)
{
return(null, RepositoryOutcomeAction.ValidationErrorNone, new { cause = "Missing Provider", data = providerId });
}
providerWorker.ProviderId = providerId;
var result = await _mongoDatabase
.Workers()
.ReplaceOneAsync(_ => _.Id == providerWorker.Id, providerWorker, cancellationToken: cancellationToken);
return
(result.MatchedCount == 1 && result.MatchedCount == result.ModifiedCount
? (providerWorker, RepositoryOutcomeAction.OkUpdated, null)
: ((ProviderWorker)null, RepositoryOutcomeAction.NotFoundNone, (object)null));
}