public Task <ProjectDetailResponseModel> GetMyProject(Guid projectUid, Guid?userUid = null, IHeaderDictionary customHeaders = null)
{
log.LogDebug($"{nameof(GetMyProject)} Mock: projectUid {projectUid} userUid {userUid}");
var customerUid = customHeaders?[HeaderConstants.X_VISION_LINK_CUSTOMER_UID];
var customerTrn = TRNHelper.MakeTRN((string.IsNullOrEmpty(customerUid) ? new Guid() : new Guid(customerUid)), TRNHelper.TRN_ACCOUNT);
var projectTrn = TRNHelper.MakeTRN(projectUid);
var projectDetailResponseModel = new ProjectDetailResponseModel()
{
AccountTRN = customerTrn,
ProjectTRN = projectTrn,
ProjectType = CwsProjectType.AcceptsTagFiles,
Status = ProjectStatus.Active,
UserProjectRole = UserProjectRoleEnum.Admin,
LastUpdate = DateTime.UtcNow.AddDays(-1),
ProjectSettings = new ProjectSettingsModel()
{
ProjectTRN = projectTrn,
TimeZone = "Pacific/Auckland",
Boundary = new ProjectBoundary()
{
type = "Polygon",
coordinates = new List <List <double[]> > {
new List <double[]> {
new[] { 150.3, 1.2 }, new[] { 150.4, 1.2 }, new[] { 150.4, 1.3 }, new[] { 150.4, 1.4 }, new[] { 150.3, 1.2 }
}
}
},
Config = new List <ProjectConfigurationModel>()
}
};
log.LogDebug($"{nameof(GetMyProject)} Mock: projectDetailResponseModel {JsonConvert.SerializeObject(projectDetailResponseModel)}");
return(Task.FromResult(projectDetailResponseModel));
}
public void GetDeviceBySerialNumberTest_UpperLower()
{
var serialNumber = (Guid.NewGuid().ToString()).ToLower();
const string expectedDeviceId = "trn::profilex:us-west-2:device:560c2a6c-6b7e-48d8-b1a5-e4009e2d4c97";
const string expectedDeviceType = "CB460";
const string expectedDeviceName = "The device Name";
var expectedSerialNumber = serialNumber.ToUpper();
var deviceResponseModel = new DeviceResponseModel()
{
TRN = expectedDeviceId, DeviceType = expectedDeviceType, DeviceName = expectedDeviceName, SerialNumber = expectedSerialNumber
};
var route = $"/devices/getDeviceWithSerialNumber";
var queryParameters = new List <KeyValuePair <string, string> > {
new KeyValuePair <string, string>("serialNumber", serialNumber.ToUpper())
};
var expectedUrl = $"{baseUrl}{route}?serialNumber={serialNumber.ToUpper()}";
mockServiceResolution.Setup(m => m.ResolveRemoteServiceEndpoint(
It.IsAny <string>(), It.IsAny <ApiType>(), It.IsAny <ApiVersion>(), route, queryParameters)).Returns(Task.FromResult(expectedUrl));
MockUtilities.TestRequestSendsCorrectJson("Get device by serial number", mockWebRequest, null, expectedUrl, HttpMethod.Get, deviceResponseModel, async() =>
{
var client = ServiceProvider.GetRequiredService <ICwsDeviceClient>();
var result = await client.GetDeviceBySerialNumber(serialNumber);
Assert.NotNull(result);
Assert.Equal(TRNHelper.ExtractGuidAsString(expectedDeviceId), result.Id);
Assert.Equal(expectedDeviceType, result.DeviceType);
Assert.Equal(expectedDeviceName, result.DeviceName);
Assert.Equal(expectedSerialNumber, result.SerialNumber);
return(true);
});
}
public ProjectListResponseModel GetProjectsForDevice(string deviceTrn)
{
var projectListResponseModel = new ProjectListResponseModel()
{
Projects = new List <ProjectResponseModel>
{
new ProjectResponseModel
{
AccountTRN = TRNHelper.MakeTRN(Guid.NewGuid().ToString(), TRNHelper.TRN_ACCOUNT),
ProjectTRN = TRNHelper.MakeTRN(Guid.NewGuid().ToString(), TRNHelper.TRN_PROJECT),
ProjectName = "this is a project",
Timezone = "Timbucktoo",
Boundary = new ProjectBoundary()
{
type = "Polygon", coordinates = new List <List <double[]> > {
new List <double[]> {
new double[] { 180, 90 }, new double[] { 180, 90 }
}
}
}
}
}
};
Logger.LogInformation($"{nameof(GetProjectsForDevice)}: deviceTrn {deviceTrn}. projectListResponseModel {JsonConvert.SerializeObject(projectListResponseModel)}");
return(projectListResponseModel);
}
public void GetDeviceByDeviceUidTest()
{
const string DeviceId = "trn::profilex:us-west-2:device:560c2a6c-6b7e-48d8-b1a5-e4009e2d4c97";
const string expectedDeviceId = DeviceId;
const string expectedDeviceType = "CB460";
const string expectedDeviceName = "The device Name";
const string expectedSerialNumber = "2002J032SW";
var deviceResponseModel = new DeviceResponseModel()
{
TRN = expectedDeviceId, DeviceType = expectedDeviceType, DeviceName = expectedDeviceName, SerialNumber = expectedSerialNumber
};
var route = $"/devices/{DeviceId}";
var expectedUrl = $"{baseUrl}{route}";
mockServiceResolution.Setup(m => m.ResolveRemoteServiceEndpoint(
It.IsAny <string>(), It.IsAny <ApiType>(), It.IsAny <ApiVersion>(), route, It.IsAny <IList <KeyValuePair <string, string> > >())).Returns(Task.FromResult(expectedUrl));
MockUtilities.TestRequestSendsCorrectJson("Get device by deviceUid", mockWebRequest, null, expectedUrl, HttpMethod.Get, deviceResponseModel, async() =>
{
var client = ServiceProvider.GetRequiredService <ICwsDeviceClient>();
var result = await client.GetDeviceByDeviceUid(TRNHelper.ExtractGuid(DeviceId).Value);
Assert.NotNull(result);
Assert.Equal(TRNHelper.ExtractGuidAsString(expectedDeviceId), result.Id);
Assert.Equal(expectedDeviceType, result.DeviceType);
Assert.Equal(expectedDeviceName, result.DeviceName);
Assert.Equal(expectedSerialNumber, result.SerialNumber);
return(true);
});
}
public void ValidateMapToCreate()
{
var boundaryString = "POLYGON((172.6 -43.5,172.6 -43.5003,172.603 -43.5003,172.603 -43.5,172.6 -43.5))";
var csContent = "MDBUTVNDIFYxMC03MCAgICAgICAwICAgMDkvMDEvMjAyMCAxNToxOTExMzExMQ0KMTBUTVVudGl0bGVkIEpvYiAgICAxMjIyMTINCjc4VE0xMQ0KRDVUTSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIA0KRDhUTSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgDQo2NFRNMzM2LjIwNjU1NTM3MTAwMDAtMTE1LjAyNjI2NzgxODAwMC4wMDAwMDAwMDAwMDAwMDExMTkuNzQ4NDM3ODk2OTAyMTkzLjk3OTQ3Njc1OTAwMC4wMDAwMDAwMDAwMDAwMDEuMDAwMDg2NzIzMDAwMDAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIA0KNjVUTTYzNzgxMzcuMDAwMDAxMDAyOTguMjU3MjIyOTMyODkwDQo0OVRNMzYzNzgxMzcuMDAwMDAwMDAyOTguMjU3MjIzNTYzMDAwMC4wMDAwMDAwMDAwMDAwMDAuMDAwMDAwMDAwMDAwMDAwLjAwMDAwMDAwMDAwMDAwMC4wMDAwMDAwMDAwMDAwMDAuMDAwMDAwMDAwMDAwMDAwLjAwMDAwMDAwMDAwMDAwMC4wMDAwMDAwMDAwMDAwMA0KNTBUTTExOTguNzk3MzM5MDkwNzAyNDkxLjQ4Mjg5MTU0MTgwMC4wMDI2NjA5MDkzMjE4MDAuMDAwMTM3MTYwMjc0MzAwLjAwMTkwNzk5NzAwMDAwMS4wMDAwMTMwMTMwMDAwMA0KQzhUTTRTQ1M5MDAgTG9jYWxpemF0aW9uICAgICAgICAgICAgIFNDUzkwMCBSZWNvcmQgICAgICAgICAgICAgICAgICAgRGF0dW0gZnJvbSBEYXRhIENvbGxlY3RvciAgICAgICANCg==";
var csContentBase64 = "TURCVVRWTkRJRll4TUMwM01DQWdJQ0FnSUNBd0lDQWdNRGt2TURFdk1qQXlNQ0F4TlRveE9URXhNekV4TVEwS01UQlVUVlZ1ZEdsMGJHVmtJRXB2WWlBZ0lDQXhNakl5TVRJTkNqYzRWRTB4TVEwS1JEVlVUU0FnSUNBZ0lDQWdJQ0FnSUNBZ0lDQWdJQ0FnSUNBZ0lDQWdJQ0FnSUNBZ0lDQWdJQ0FnSUNBZ0lDQWdJQ0FnSUNBZ0lDQWdJQ0FnSUNBZ0lDQWdJQ0FnSUNBZ0lDQWdJQ0FnSUNBZ0lDQWdJQ0FnSUNBZ0lDQWdJQ0FnSUNBZ0lBMEtSRGhVVFNBZ0lDQWdJQ0FnSUNBZ0lDQWdJQ0FnSUNBZ0lDQWdJQ0FnSUNBZ0lDQWdEUW8yTkZSTk16TTJMakl3TmpVMU5UTTNNVEF3TURBdE1URTFMakF5TmpJMk56Z3hPREF3TUM0d01EQXdNREF3TURBd01EQXdNREV4TVRrdU56UTRORE0zT0RrMk9UQXlNVGt6TGprM09UUTNOamMxT1RBd01DNHdNREF3TURBd01EQXdNREF3TURFdU1EQXdNRGcyTnpJek1EQXdNREFnSUNBZ0lDQWdJQ0FnSUNBZ0lDQWdJQ0FnSUNBZ0lDQWdJQ0FnSUNBZ0lBMEtOalZVVFRZek56Z3hNemN1TURBd01EQXhNREF5T1RndU1qVTNNakl5T1RNeU9Ea3dEUW8wT1ZSTk16WXpOemd4TXpjdU1EQXdNREF3TURBeU9UZ3VNalUzTWpJek5UWXpNREF3TUM0d01EQXdNREF3TURBd01EQXdNREF1TURBd01EQXdNREF3TURBd01EQXdMakF3TURBd01EQXdNREF3TURBd01DNHdNREF3TURBd01EQXdNREF3TURBdU1EQXdNREF3TURBd01EQXdNREF3TGpBd01EQXdNREF3TURBd01EQXdNQzR3TURBd01EQXdNREF3TURBd01BMEtOVEJVVFRFeE9UZ3VOemszTXpNNU1Ea3dOekF5TkRreExqUTRNamc1TVRVME1UZ3dNQzR3TURJMk5qQTVNRGt6TWpFNE1EQXVNREF3TVRNM01UWXdNamMwTXpBd0xqQXdNVGt3TnprNU56QXdNREF3TVM0d01EQXdNVE13TVRNd01EQXdNQTBLUXpoVVRUUlRRMU01TURBZ1RHOWpZV3hwZW1GMGFXOXVJQ0FnSUNBZ0lDQWdJQ0FnSUZORFV6a3dNQ0JTWldOdmNtUWdJQ0FnSUNBZ0lDQWdJQ0FnSUNBZ0lDQWdSR0YwZFcwZ1puSnZiU0JFWVhSaElFTnZiR3hsWTNSdmNpQWdJQ0FnSUNBTkNnPT0=";
var projectValidation = new ProjectValidation
{
CustomerUid = new Guid("372854b8-64f8-4fd0-885f-d663503ffbca"),
ProjectType = CwsProjectType.AcceptsTagFiles,
ProjectName = "Beside Dimensions JeanieTest1",
ProjectBoundaryWKT = boundaryString,
UpdateType = ProjectUpdateType.Created,
CoordinateSystemFileName = "myOne.dc",
CoordinateSystemFileContent = System.Text.Encoding.ASCII.GetBytes(csContent)
};
var createProjectRequestModel = AutoMapperUtility.Automapper.Map <CreateProjectRequestModel>(projectValidation);
Assert.Equal(TRNHelper.MakeTRN(projectValidation.CustomerUid, TRNHelper.TRN_ACCOUNT), createProjectRequestModel.TRN);
Assert.Equal(projectValidation.CustomerUid.ToString(), createProjectRequestModel.AccountId);
Assert.Equal(projectValidation.ProjectName, createProjectRequestModel.ProjectName);
Assert.Equal(projectValidation.ProjectType, createProjectRequestModel.ProjectType);
Assert.Null(createProjectRequestModel.Timezone);
Assert.Equal(GeometryConversion.MapProjectBoundary(projectValidation.ProjectBoundaryWKT).type, createProjectRequestModel.Boundary.type);
Assert.Equal(GeometryConversion.MapProjectBoundary(projectValidation.ProjectBoundaryWKT).coordinates.Count, createProjectRequestModel.Boundary.coordinates.Count);
Assert.Equal(GeometryConversion.MapProjectBoundary(projectValidation.ProjectBoundaryWKT).coordinates.ToArray(), createProjectRequestModel.Boundary.coordinates.ToArray());
Assert.Equal(projectValidation.CoordinateSystemFileName, createProjectRequestModel.CalibrationFileName);
Assert.Equal(csContentBase64, createProjectRequestModel.CalibrationFileBase64Content);
Assert.Equal(csContent, System.Text.Encoding.ASCII.GetString(Convert.FromBase64String(createProjectRequestModel.CalibrationFileBase64Content)));
}
public void UpdateProjectBoundaryTest()
{
var customerUid = new Guid("560c2a6c-6b7e-48d8-b1a5-e4009e2d4c97");
//var accountTrn = "trn::profilex:us-west-2:account:{customerUid}";
string projectUid = "560c2a6c-6b7e-48d8-b1a5-e4009e2d4c97";
string projectTrn = TRNHelper.MakeTRN(projectUid, TRNHelper.TRN_PROJECT);
var projectBoundary = new ProjectBoundary()
{
type = "Polygon",
coordinates = new List <List <double[]> > {
new List <double[]> {
new [] { 151.3, 1.2 }, new[] { 151.4, 1.2 }, new[] { 151.4, 1.3 }, new[] { 151.4, 1.4 }, new[] { 151.3, 1.2 }
}
}
};
string route = $"/projects/{projectTrn}/boundary";
var expectedUrl = $"{baseUrl}{route}";
mockServiceResolution.Setup(m => m.ResolveRemoteServiceEndpoint(
It.IsAny <string>(), It.IsAny <ApiType>(), It.IsAny <ApiVersion>(), route, It.IsAny <IList <KeyValuePair <string, string> > >())).Returns(Task.FromResult(expectedUrl));
MockUtilities.TestRequestSendsCorrectJson("Update a projects boundary", mockWebRequest, null, expectedUrl, HttpMethod.Post, projectBoundary, async() =>
{
var client = ServiceProvider.GetRequiredService <ICwsProjectClient>();
await client.UpdateProjectBoundary(new Guid(projectUid), projectBoundary);
return(true);
});
}
public CreateProjectResponseModel CreateProject([Mvc.FromBody] CreateProjectRequestModel createProjectRequestModel)
{
var newProjectUid = Guid.NewGuid();
var newProjectTrn = TRNHelper.MakeTRN(newProjectUid);
var projectDetailResponseModel = new ProjectDetailResponseModel()
{
AccountTRN = TRNHelper.MakeTRN(createProjectRequestModel.AccountId, TRNHelper.TRN_ACCOUNT),
ProjectTRN = newProjectTrn,
ProjectName = createProjectRequestModel.ProjectName,
ProjectType = CwsProjectType.AcceptsTagFiles,
Status = ProjectStatus.Active,
UserProjectRole = UserProjectRoleEnum.Admin,
LastUpdate = DateTime.UtcNow,
ProjectSettings = new ProjectSettingsModel()
{
ProjectTRN = newProjectTrn,
Boundary = createProjectRequestModel.Boundary,
Config = new List <ProjectConfigurationModel>(),
}
};
if (!_projects.ContainsKey(projectDetailResponseModel.AccountTRN))
{
_projects.Add(projectDetailResponseModel.AccountTRN, new Dictionary <string, ProjectDetailResponseModel>());
}
_projects[projectDetailResponseModel.AccountTRN].Add(newProjectTrn, projectDetailResponseModel);
var createProjectResponseModel = new CreateProjectResponseModel()
{
TRN = newProjectTrn
};
Logger.LogInformation($"{nameof(CreateProject)}: createProjectRequestModel {JsonConvert.SerializeObject(createProjectRequestModel)} createProjectResponseModel {JsonConvert.SerializeObject(createProjectResponseModel)}");
return(createProjectResponseModel);
}
public void MakeTRNFromGuidTest(string guidString, string TRNtype, string expectedUserTRN)
{
var guid = new Guid(guidString);
var convertedUserTRN = TRNHelper.MakeTRN(guid, TRNtype);
Assert.Equal(expectedUserTRN, convertedUserTRN);
}
public async Task <IActionResult> OnProjectAssociationChange([FromBody] List <string> trns)
{
Logger.LogInformation($"{nameof(OnProjectAssociationChange)} Associations Updated: {JsonConvert.SerializeObject(trns)}");
// We don't actually do anything with this data yet, other than clear cache
// Since we call out to CWS for data
var tasks = new Task[trns.Count];
for (var i = 0; i < trns.Count; i++)
{
var trn = trns[i];
var guid = TRNHelper.ExtractGuid(trn);
if (!guid.HasValue)
{
continue;
}
Logger.LogInformation($"Clearing cache related to TRN: {guid.Value}");
tasks[i] = NotificationHubClient.Notify(new ProjectChangedNotification(guid.Value));
}
await Task.WhenAll(tasks);
return(Ok());
}
public UnitTestsDIFixture()
{
AutoMapperUtility.AutomapperConfiguration.AssertConfigurationIsValid();
var loggerFactory = new LoggerFactory().AddSerilog(SerilogExtensions.Configure("VSS.Project.UnitTests.log"));
ServiceCollection = new ServiceCollection();
ServiceCollection.AddLogging();
ServiceCollection.AddSingleton(loggerFactory);
ServiceCollection
.AddTransient <IProjectRepository, ProjectRepository>()
.AddSingleton <IConfigurationStore, GenericConfiguration>()
.AddTransient <IServiceExceptionHandler, ServiceExceptionHandler>()
.AddTransient <IProductivity3dV1ProxyCoord, Productivity3dV1ProxyCoord>()
.AddTransient <IProductivity3dV2ProxyNotification, Productivity3dV2ProxyNotification>()
.AddTransient <IProductivity3dV2ProxyCompaction, Productivity3dV2ProxyCompaction>()
.AddTransient <IErrorCodesProvider, ProjectErrorCodesProvider>();
ServiceProvider = ServiceCollection.BuildServiceProvider();
ServiceExceptionHandler = ServiceProvider.GetRequiredService <IServiceExceptionHandler>();
_log = ServiceProvider.GetRequiredService <ILoggerFactory>().CreateLogger <T>();
_loggerFactory = ServiceProvider.GetRequiredService <ILoggerFactory>();
_customHeaders = new HeaderDictionary();
_configStore = ServiceProvider.GetRequiredService <IConfigurationStore>();
_userUid = Guid.NewGuid();
_customerUid = Guid.NewGuid();
_customerTrn = TRNHelper.MakeTRN(_customerUid, TRNHelper.TRN_ACCOUNT);
_projectUid = Guid.NewGuid();
_projectTrn = TRNHelper.MakeTRN(_projectUid);
_customHeaders.Add("X-VisionLink-CustomerUID", new StringValues(_customerUid.ToString()));
}
public void GetProjectConfiguration()
{
var projectUid = new Guid("560c2a6c-6b7e-48d8-b1a5-e4009e2d4c97");
var projectConfigurationModel = new ProjectConfigurationModel
{
FileName = "MyTestFilename.dc",
FileDownloadLink = "http//whatever",
FileType = ProjectConfigurationFileType.CALIBRATION.ToString(),
CreatedAt = DateTime.UtcNow.ToString(),
UpdatedAt = DateTime.UtcNow.ToString(),
Size = 66
};
string route = $"/projects/{TRNHelper.MakeTRN(projectUid)}/configuration/CALIBRATION";
var expectedUrl = $"{baseUrl}{route}";
mockServiceResolution.Setup(m => m.ResolveRemoteServiceEndpoint(
It.IsAny <string>(), It.IsAny <ApiType>(), It.IsAny <ApiVersion>(), route, It.IsAny <IList <KeyValuePair <string, string> > >())).Returns(Task.FromResult(expectedUrl));
MockUtilities.TestRequestSendsCorrectJson("Get a project calibration file", mockWebRequest, null, expectedUrl, HttpMethod.Get, projectConfigurationModel, async() =>
{
var client = ServiceProvider.GetRequiredService <ICwsProfileSettingsClient>();
var result = await client.GetProjectConfiguration(projectUid, ProjectConfigurationFileType.CALIBRATION);
Assert.NotNull(result);
Assert.Equal(projectConfigurationModel.FileName, result.FileName);
return(true);
});
}
public void UpdateProjectDetailsTest()
{
var customerUid = new Guid("560c2a6c-6b7e-48d8-b1a5-e4009e2d4c97");
//var accountTrn = "trn::profilex:us-west-2:account:{customerUid}";
string projectUid = "560c2a6c-6b7e-48d8-b1a5-e4009e2d4c97";
string projectTrn = TRNHelper.MakeTRN(projectUid, TRNHelper.TRN_PROJECT);
var updateProjectDetailsRequestModel = new UpdateProjectDetailsRequestModel
{
projectName = "my updated project"
};
string route = $"/projects/{projectTrn}";
var expectedUrl = $"{baseUrl}{route}";
mockServiceResolution.Setup(m => m.ResolveRemoteServiceEndpoint(
It.IsAny <string>(), It.IsAny <ApiType>(), It.IsAny <ApiVersion>(), route, It.IsAny <IList <KeyValuePair <string, string> > >())).Returns(Task.FromResult(expectedUrl));
MockUtilities.TestRequestSendsCorrectJson("Update a projects details", mockWebRequest, null, expectedUrl, HttpMethod.Post, updateProjectDetailsRequestModel, async() =>
{
var client = ServiceProvider.GetRequiredService <ICwsProjectClient>();
await client.UpdateProjectDetails(new Guid(projectUid), updateProjectDetailsRequestModel);
return(true);
});
}
public Task <ProjectListResponseModel> GetProjectsForDevice(Guid deviceUid, bool includeProjectSettings = true, IHeaderDictionary customHeaders = null)
{
log.LogDebug($"{nameof(GetProjectsForDevice)} Mock: deviceUid {deviceUid}");
var projectListResponseModel = new ProjectListResponseModel()
{
Projects = new List <ProjectResponseModel>()
{
new ProjectResponseModel()
{
AccountTRN = TRNHelper.MakeTRN(Guid.NewGuid().ToString(), TRNHelper.TRN_ACCOUNT),
ProjectTRN = TRNHelper.MakeTRN(Guid.NewGuid().ToString()),
ProjectName = "this is a project",
Timezone = "Timbucktoo",
Boundary = new ProjectBoundary()
{
type = "Polygon",
coordinates = new List <List <double[]> > {
new List <double[]> {
new[] { 150.3, 1.2 }, new[] { 150.4, 1.2 }, new[] { 150.4, 1.3 }, new[] { 150.4, 1.4 }, new[] { 150.3, 1.2 }
}
}
}
}
}
};
log.LogDebug($"{nameof(GetProjectsForDevice)} Mock: projectListResponseModel {JsonConvert.SerializeObject(projectListResponseModel)}");
return(Task.FromResult(projectListResponseModel));
}
public async Task GetDevice_NoAccountFound_UnhappyPath()
{
var cwsDevice = new DeviceResponseModel()
{
TRN = TRNHelper.MakeTRN(_deviceUid, TRNHelper.TRN_DEVICE),
DeviceName = _deviceName, SerialNumber = _serialNumber
};
var cwsDeviceClient = new Mock <ICwsDeviceClient>();
cwsDeviceClient.Setup(pr => pr.GetDeviceBySerialNumber(It.IsAny <string>(), _customHeaders))
.ReturnsAsync(cwsDevice);
cwsDeviceClient.Setup(pr => pr.GetAccountsForDevice(It.IsAny <Guid>(), _customHeaders))
.ReturnsAsync((DeviceAccountListResponseModel)null);
var getDeviceBySerialExecutor = RequestExecutorContainerFactory.Build <GetDeviceBySerialExecutor>
(_logger, _configStore, _serviceExceptionHandler,
headers: _customHeaders, cwsDeviceClient: cwsDeviceClient.Object);
var response = await getDeviceBySerialExecutor.ProcessAsync(new DeviceSerial(_serialNumber))
as DeviceDescriptorSingleResult;
Assert.NotNull(response);
Assert.Equal(102, response.Code);
Assert.Equal("Unable to locate any account for the device in cws", response.Message);
Assert.NotNull(response.DeviceDescriptor);
Assert.Equal(102, response.DeviceDescriptor.Code);
Assert.Null(response.DeviceDescriptor.CustomerUID);
Assert.Equal(_deviceUid, response.DeviceDescriptor.DeviceUID);
Assert.Equal(_deviceName, response.DeviceDescriptor.DeviceName);
Assert.Equal(_serialNumber, response.DeviceDescriptor.SerialNumber);
Assert.Equal("UNKNOWN", response.DeviceDescriptor.RelationStatus.ToString().ToUpper());
Assert.Equal("Unknown", response.DeviceDescriptor.TccDeviceStatus.ToString());
Assert.Null(response.DeviceDescriptor.ShortRaptorAssetId);
}
public async Task ProjectChangedExecutor_MetadataChanged_Project(NotificationType notificationType)
{
var projectUid = Guid.NewGuid();
var projectTrn = TRNHelper.MakeTRN(projectUid, TRNHelper.TRN_ACCOUNT);
var notificationHubClient = new Mock <INotificationHubClient>();
notificationHubClient.Setup(n => n.Notify(It.IsAny <Notification>())).Returns(Task.CompletedTask);
var request = new ProjectChangeNotificationDto
{
AccountTrn = null,
ProjectTrn = projectTrn,
NotificationType = notificationType,
CoordinateSystemFileName = null,
CoordinateSystemFileContent = null
};
var executor = RequestExecutorContainerFactory.Build <ProjectChangedExecutor>
(_loggerFactory, _configStore, ServiceExceptionHandler,
_customerUid.ToString(), _userUid.ToString(), null, _customHeaders, notificationHubClient: notificationHubClient.Object);
var result = await executor.ProcessAsync(request);
Assert.Equal(ContractExecutionStatesEnum.ExecutedSuccessfully, result.Code);
Assert.Equal(ContractExecutionResult.DefaultMessage, result.Message);
}
public List <DeviceLKSResponseModel> GetDevicesLKSForProject(
[FromQuery] string projectId,
[FromQuery] DateTime?lastReported)
{
Logger.LogInformation($"{nameof(GetDevicesLKSForProject)} projectId {projectId} lastReported {lastReported}");
var result = new List <DeviceLKSResponseModel>();
if (TRNHelper.ExtractGuid(projectId) == new Guid(ConstantsUtil.DIMENSIONS_PROJECT_UID))
{
result.Add(new DeviceLKSResponseModel()
{
DeviceTrn = TRNHelper.MakeTRN(ConstantsUtil.DIMENSIONS_SERIAL_DEVICEUID, TRNHelper.TRN_DEVICE),
AccountTrn = TRNHelper.MakeTRN(ConstantsUtil.DIMENSIONS_CUSTOMER_UID, TRNHelper.TRN_ACCOUNT),
AssetSerialNumber = ConstantsUtil.DIMENSIONS_SERIAL,
Latitude = 89.9, Longitude = 34.6,
AssetType = "Grader",
DeviceName = $"{CWSDeviceTypeEnum.EC520}-{ConstantsUtil.DIMENSIONS_SERIAL}",
ProjectName = "DimensionsProject",
LastReportedUtc = DateTime.UtcNow.AddDays(-1)
});
}
return(result);
}
public void CreateFileTest()
{
string projectUid = Guid.NewGuid().ToString();
var createFileRequestModel = new CreateFileRequestModel
{
FileName = "myFirstProject.dc"
};
var createFileResponseModel = new CreateFileResponseModel
{
FileSpaceId = Guid.NewGuid().ToString(),
UploadUrl = $"{createFileRequestModel.FileName} {projectUid}"
};
string route = $"/projects/{TRNHelper.MakeTRN(projectUid)}/file";
var expectedUrl = $"{baseUrl}{route}";
mockServiceResolution.Setup(m => m.ResolveRemoteServiceEndpoint(
It.IsAny <string>(), It.IsAny <ApiType>(), It.IsAny <ApiVersion>(), route, It.IsAny <IList <KeyValuePair <string, string> > >())).Returns(Task.FromResult(expectedUrl));
MockUtilities.TestRequestSendsCorrectJson("Create a file", mockWebRequest, null, expectedUrl, HttpMethod.Post, createFileResponseModel, async() =>
{
var client = ServiceProvider.GetRequiredService <ICwsDesignClient>();
var result = await client.CreateFile(new Guid(projectUid), createFileRequestModel);
Assert.NotNull(result);
Assert.Equal(createFileResponseModel.FileSpaceId, result.FileSpaceId);
return(true);
});
}
public void TestHasMoreMultipleQueries()
{
// Account List Response support 'HasMore'
// This will validate that the api call fetches more than one page
const string userId = "trn::profilex:us-west-2:user:d79a392d-6513-46c1-baa1-75c537cf0c32";
const string firstAccountTrn = "trn::profilex:us-west-2:account:560c2a6c-6b7e-48d8-b1a5-e4009e2d4c97";
const string secondAccountTrn = "trn::profilex:us-west-2:account:5DDA8405-E9E3-4E17-B096-C57D91FDAC37";
const string expectedName = "Berthoud";
const string route = "/users/me/accounts";
var firstResponse = new AccountListResponseModel
{
HasMore = true,
Accounts = new List <AccountResponseModel>()
{
new AccountResponseModel()
{
TRN = firstAccountTrn, Name = expectedName, DeviceCount = 10, UserCount = 5, ProjectCount = 0
}
}
};
var secondResponse = new AccountListResponseModel
{
HasMore = false,
Accounts = new List <AccountResponseModel>()
{
new AccountResponseModel()
{
TRN = secondAccountTrn, Name = expectedName, DeviceCount = 10, UserCount = 5, ProjectCount = 0
}
}
};
var expectedUrl = $"{baseUrl}{route}";
mockServiceResolution.Setup(m => m.ResolveRemoteServiceEndpoint(
It.IsAny <string>(), It.IsAny <ApiType>(), It.IsAny <ApiVersion>(), route, It.IsAny <IList <KeyValuePair <string, string> > >())).Returns(Task.FromResult(expectedUrl));
// Setup so that the second call returns the second model and any follow up calls throw an exception
mockWebRequest.SetupSequence(s => s.ExecuteRequest <AccountListResponseModel>(It.IsAny <string>(),
It.IsAny <Stream>(),
It.IsAny <IHeaderDictionary>(),
It.IsAny <HttpMethod>(),
It.IsAny <int?>(),
It.IsAny <int>(),
It.IsAny <bool>()))
.Returns(Task.FromResult(firstResponse))
.Returns(Task.FromResult(secondResponse))
.Throws <Exception>();
var client = ServiceProvider.GetRequiredService <ICwsAccountClient>();
var result = client.GetMyAccounts(TRNHelper.ExtractGuid(userId).Value).Result;
Assert.NotNull(result);
Assert.False(result.HasMore);
Assert.True(result.Accounts.Count == 2);
Assert.NotNull(result.Accounts.FirstOrDefault(a => a.TRN == firstResponse.Accounts[0].TRN));
Assert.NotNull(result.Accounts.FirstOrDefault(a => a.TRN == secondResponse.Accounts[0].TRN));
}
/// <summary>
/// Only 1 of each project calibrationtype is allowed, so this will delete that type
/// </summary>
public Task DeleteProjectConfiguration(Guid projectUid, ProjectConfigurationFileType projectConfigurationFileType, IHeaderDictionary customHeaders = null)
{
log.LogDebug($"{nameof(DeleteProjectConfiguration)}: projectUid {projectUid} projectConfigurationFileType {projectConfigurationFileType}");
var projectTrn = TRNHelper.MakeTRN(projectUid);
return(DeleteData($"/projects/{projectTrn}/configuration/{projectConfigurationFileType.ToString().ToUpper()}", null, customHeaders));
}
/// <summary>
/// Update a project boundary
/// </summary>
public async Task UpdateProjectBoundary(Guid projectUid, ProjectBoundary projectBoundary, IHeaderDictionary customHeaders = null)
{
log.LogDebug($"{nameof(UpdateProjectBoundary)}: projectUid {projectUid} projectBoundary {JsonConvert.SerializeObject(projectBoundary)}");
var projectTrn = TRNHelper.MakeTRN(projectUid);
await UpdateData($"/projects/{projectTrn}/boundary", projectBoundary, null, customHeaders);
}
/// <summary>
/// Update a project with core detail only (not calibration file and boundary)
/// </summary>
public async Task UpdateProjectDetails(Guid projectUid, UpdateProjectDetailsRequestModel updateProjectDetailsRequest, IHeaderDictionary customHeaders = null)
{
log.LogDebug($"{nameof(UpdateProjectDetails)}: projectUid {projectUid} updateProjectDetailsRequest {JsonConvert.SerializeObject(updateProjectDetailsRequest)}");
var projectTrn = TRNHelper.MakeTRN(projectUid);
await UpdateData($"/projects/{projectTrn}", updateProjectDetailsRequest, null, customHeaders);
}
/// <summary>
/// Gets projects using a user token.
/// The user must have access to this account.
/// Cache to include userUid as different users have access to a different project set
/// This ONLY works with a user token.
/// </summary>
private async Task <ProjectSummaryListResponseModel> GetProjectsForMyCustomer(Guid customerUid, Guid?userUid = null, bool includeSettings = true, CwsProjectType?type = null, ProjectStatus?status = null, IHeaderDictionary customHeaders = null)
{
log.LogDebug($"{nameof(GetProjectsForMyCustomer)}: customerUid {customerUid} userUid {userUid}");
var accountTrn = TRNHelper.MakeTRN(customerUid, TRNHelper.TRN_ACCOUNT);
ProjectSummaryListResponseModel projectSummaryListResponseModel;
try
{
// We need settings to get the boundary
var queryParams = new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>("includeSettings", includeSettings.ToString()),
};
// Do we need to filter for a specific type?
if (type != null)
{
queryParams.Add(new KeyValuePair <string, string>("projectType", ((int)type.Value).ToString()));
}
if (status != null)
{
var statusString = status.Value.GetEnumMemberValue(); // CWS Expects the EnumMember value (e.g ARCHIVED instead of 1)
queryParams.Add(new KeyValuePair <string, string>("status", statusString));
}
projectSummaryListResponseModel = await GetAllPagedData <ProjectSummaryListResponseModel, ProjectSummaryResponseModel>($"/accounts/{accountTrn}/projects", customerUid, userUid, queryParams, customHeaders);
// CWS doesn't return a project status - so set Archived if needed
if (status == ProjectStatus.Archived)
{
foreach (var project in projectSummaryListResponseModel.Projects)
{
project.Status = status.Value;
}
}
}
catch (HttpRequestException e)
{
/*
* todo what are possible exceptions?
* // account doesn't exist
* {
* "status": 403,
* "code": 9054,
* "message": "Forbidden",
* "moreInfo": "Please provide this id to support, while contacting, TraceId 5ebda82aec2fae46fed484afed7959f2",
* "timestamp": 1589487658105
* }
*/
log.LogError(e, $"{nameof(GetProjectsForMyCustomer)}: failed to get list of projects. ");
throw;
}
log.LogDebug($"{nameof(GetProjectsForMyCustomer)}: projectSummaryListResponseModel {JsonConvert.SerializeObject(projectSummaryListResponseModel)}");
return(projectSummaryListResponseModel);
}
/// <summary>
/// gets accounts related to a device
/// should only be 1 RelationStatus.Active
/// this is a temp requirement until CCSSSCON-28
/// </summary>
public async Task <DeviceAccountListResponseModel> GetAccountsForDevice(Guid deviceUid, IHeaderDictionary customHeaders = null)
{
log.LogDebug($"{nameof(GetAccountsForDevice)}: deviceUid {deviceUid}");
var deviceTrn = TRNHelper.MakeTRN(deviceUid, TRNHelper.TRN_DEVICE);
var deviceAccountListResponseModel = await GetAllPagedData <DeviceAccountListResponseModel, DeviceAccountResponseModel>($"/devices/{deviceTrn}/accounts", deviceUid, null, null, customHeaders);
log.LogDebug($"{nameof(GetAccountsForDevice)}: deviceAccountListResponseModel {JsonConvert.SerializeObject(deviceAccountListResponseModel)}");
return(deviceAccountListResponseModel);
}
public async Task ValidateProjectExecutor_UnknownUpdateType()
{
var request = new ProjectValidateDto {
AccountTrn = TRNHelper.MakeTRN(Guid.NewGuid(), TRNHelper.TRN_ACCOUNT)
};
var result = await CreateExecutor().ProcessAsync(MapProjectValidation(request));
result.ShouldBe(135, "Mismatched customerUid.");
}
/// <summary>
/// used by TFA ProjectIDExecutor, projectBoundariesAtDateExecutor
/// response fields: DeviceTRN, AccountTrn, DeviceType, deviceName, Status ("ACTIVE" etal?), serialNumber
/// </summary>
public async Task <DeviceResponseModel> GetDeviceByDeviceUid(Guid deviceUid, IHeaderDictionary customHeaders = null)
{
log.LogDebug($"{nameof(GetDeviceByDeviceUid)}: deviceUid {deviceUid}");
var deviceTrn = TRNHelper.MakeTRN(deviceUid, TRNHelper.TRN_DEVICE);
var deviceResponseModel = await GetData <DeviceResponseModel>($"/devices/{deviceTrn}", deviceUid, null, null, customHeaders);
log.LogDebug($"{nameof(GetDeviceByDeviceUid)}: deviceResponseModel {JsonConvert.SerializeObject(deviceResponseModel)}");
return(deviceResponseModel);
}
/// <summary>
/// user token
/// used by ProjectSvc v6 and v5TBC
/// </summary>
public async Task <CreateFileResponseModel> CreateFile(Guid projectUid, CreateFileRequestModel createFileRequest, IHeaderDictionary customHeaders = null)
{
log.LogDebug($"{nameof(CreateFile)}: createFileRequest {JsonConvert.SerializeObject(createFileRequest)}");
var projectTrn = TRNHelper.MakeTRN(projectUid);
var createFileResponse = await PostData <CreateFileRequestModel, CreateFileResponseModel>($"/projects/{projectTrn}/file", createFileRequest, null, customHeaders);
log.LogDebug($"{nameof(CreateFile)}: createFileResponse {JsonConvert.SerializeObject(createFileResponse)}");
return(createFileResponse);
}
///// <summary>
///// POST https://trimble.com/connectedsiteprofilesettings/1.0/projects/{projectId}/configuration/{fileType}
///// user token
///// used by ProjectSvc v6 and v5TBC
///// </summary>
public async Task <ProjectConfigurationModel> SaveProjectConfiguration(Guid projectUid, ProjectConfigurationFileType projectConfigurationFileType, ProjectConfigurationFileRequestModel projectConfigurationFileRequest, IHeaderDictionary customHeaders = null)
{
log.LogDebug($"{nameof(SaveProjectConfiguration)}: projectUid {projectUid} projectConfigurationFileType {projectConfigurationFileType} projectConfigurationFileRequest {JsonConvert.SerializeObject(projectConfigurationFileRequest)}");
var projectTrn = TRNHelper.MakeTRN(projectUid);
var projectConfigurationResponse = await PostData <ProjectConfigurationFileRequestModel, ProjectConfigurationModel>($"/projects/{projectTrn}/configuration/{projectConfigurationFileType.ToString().ToUpper()}", projectConfigurationFileRequest, null, customHeaders);
log.LogDebug($"{nameof(SaveProjectConfiguration)}: projectConfigurationResponse {JsonConvert.SerializeObject(projectConfigurationResponse)}");
return(projectConfigurationResponse);
}
/// <summary>
/// application token and user token
/// used by UI to determine functionality allowed by user token
/// used by TFA using an application token
/// </summary>
public async Task <DeviceLicenseResponseModel> GetDeviceLicenses(Guid customerUid, IHeaderDictionary customHeaders = null)
{
log.LogDebug($"{nameof(GetDeviceLicenses)}: customerUid {customerUid}");
var accountTrn = TRNHelper.MakeTRN(customerUid, TRNHelper.TRN_ACCOUNT);
var deviceLicenseResponseModel = await GetData <DeviceLicenseResponseModel>($"/accounts/{accountTrn}/devicelicense", customerUid, null, null, customHeaders);
log.LogDebug($"{nameof(GetDeviceLicenses)}: deviceLicenseResponseModel {JsonConvert.SerializeObject(deviceLicenseResponseModel)}");
return(deviceLicenseResponseModel);
}
///// <summary>
///// GET https://trimble.com/connectedsiteprofilesettings/1.0/projects/{projectId}/configuration/{fileType}
////// Only 1 of each project calibrationtype is allowed
///// user token
///// used by ProjectSvc v6 and v5TBC
///// </summary>
public async Task <ProjectConfigurationModel> GetProjectConfiguration(Guid projectUid, ProjectConfigurationFileType projectConfigurationFileType, IHeaderDictionary customHeaders = null)
{
log.LogDebug($"{nameof(GetProjectConfiguration)}: projectUid {projectUid} projectConfigurationFileType {projectConfigurationFileType}");
var projectTrn = TRNHelper.MakeTRN(projectUid);
var projectConfigurationModel =
await GetData <ProjectConfigurationModel>($"/projects/{projectTrn}/configuration/{projectConfigurationFileType.ToString().ToUpper()}", null, null, null, customHeaders);
log.LogDebug($"{nameof(GetProjectConfiguration)}: projectConfigurationModel {JsonConvert.SerializeObject(projectConfigurationModel)}");
return(projectConfigurationModel);
}
///// <summary>
///// GET https://trimble.com/connectedsiteprofilesettings/1.0/projects/{projectId}/configuration
////// Only 1 of each project calibrationtype is allowed
///// user token
///// used by ProjectSvc v6 and v5TBC
///// </summary>
public async Task <ProjectConfigurationFileListResponseModel> GetProjectConfigurations(Guid projectUid, IHeaderDictionary customHeaders = null)
{
log.LogDebug($"{nameof(GetProjectConfigurations)}: projectUid {projectUid}");
var projectTrn = TRNHelper.MakeTRN(projectUid);
var projectConfigurationFileListResponse =
await GetData <ProjectConfigurationFileListResponseModel>($"/projects/{projectTrn}/configuration", null, null, null, customHeaders);
log.LogDebug($"{nameof(GetProjectConfigurations)}: projectConfigurationFileListResponse {JsonConvert.SerializeObject(projectConfigurationFileListResponse)}");
return(projectConfigurationFileListResponse);
}
