/// <summary>
/// Helper method that validates any type of resource details passed
/// </summary>
/// <param name="resourceDetails"></param>
private static void ValidateResourceDetails(ResourceDetails resourceDetails)
{
Assert.NotNull(resourceDetails);
switch (resourceDetails)
{
case AzureResourceDetails azureResourceDetails:
Assert.NotNull(azureResourceDetails);
Assert.NotNull(azureResourceDetails.Id);
break;
case OnPremiseSqlResourceDetails onPremiseSqlResourceDetails:
Assert.NotNull(onPremiseSqlResourceDetails);
Assert.NotNull(onPremiseSqlResourceDetails.MachineName);
Assert.NotNull(onPremiseSqlResourceDetails.SourceComputerId);
Assert.NotNull(onPremiseSqlResourceDetails.Vmuuid);
Assert.NotNull(onPremiseSqlResourceDetails.WorkspaceId);
Assert.NotNull(onPremiseSqlResourceDetails.DatabaseName);
Assert.NotNull(onPremiseSqlResourceDetails.ServerName);
break;
case OnPremiseResourceDetails onPremiseResourceDetails:
Assert.NotNull(onPremiseResourceDetails);
Assert.NotNull(onPremiseResourceDetails.MachineName);
Assert.NotNull(onPremiseResourceDetails.SourceComputerId);
Assert.NotNull(onPremiseResourceDetails.Vmuuid);
Assert.NotNull(onPremiseResourceDetails.WorkspaceId);
break;
default:
throw new Exception("Unsupported resource details");
}
}
public async Task GivenACompanyHouseSearchClient_WhenSearchingForAOfficer()
{
var fixture = new Fixture();
var items = fixture.Build <Item>()
.With(x => x.Kind, "searchresults#officer")
.CreateMany().ToArray();
_resourceDetails = fixture.Build <ResourceDetails>()
.With(x => x.Officers, items)
.Create();
var uri = new Uri("https://wibble.com/search/companies");
var resource = new OfficerSearchResourceBuilder()
.CreateResource(_resourceDetails);
HttpMessageHandler handler = new StubHttpMessageHandler(uri, resource);
var uriBuilder = new Mock <ISearchUriBuilder>();
uriBuilder.Setup(x => x.Build(It.IsAny <SearchRequest>()))
.Returns(uri);
var uriBuilderFactory = new Mock <ISearchUriBuilderFactory>();
uriBuilderFactory.Setup(x => x.Create <OfficerSearch>())
.Returns(uriBuilder.Object);
_client = new CompaniesHouseSearchClient(new HttpClient(handler), uriBuilderFactory.Object);
_result = await _client.SearchAsync <OfficerSearch>(new SearchRequest());
}
private RsaKeyParameters ReadPrivateKey(ResourceDetails privateKeyResourceDetails, char[] privateKeyPassphrase)
{
if (privateKeyResourceDetails == null || privateKeyResourceDetails.Uri == null)
{
return(null);
}
logger.Info("reading the private key");
var requestMsg = new HttpRequestMessage(HttpMethod.Get, privateKeyResourceDetails.Uri);
foreach (KeyValuePair <string, string> entry in privateKeyResourceDetails.Headers)
{
requestMsg.Headers.TryAddWithoutValidation(entry.Key, entry.Value);
}
var response = Client.SendAsync(requestMsg).Result;
if (response == null || !response.IsSuccessStatusCode)
{
logger.Debug("Received non successful response while trying to get the private key");
ResponseHelper.HandleNonSuccessfulResponse(response);
}
var stream = response.Content.ReadAsStreamAsync().Result;
string privateKeyPassphraseToUse = null;
if (privateKeyPassphrase != null && privateKeyPassphrase.Length > 0)
{
privateKeyPassphraseToUse = privateKeyPassphrase.ToString();
}
return(GetKey(stream, StringUtils.StringToSecureString(privateKeyPassphraseToUse)));
}
public async Task <IActionResult> PutResourceDetails(int id, ResourceDetails resourceDetails)
{
if (id != resourceDetails.ResID)
{
return(BadRequest());
}
_context.Entry(resourceDetails).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ResourceDetailsExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public Task <TResource> GetOrAdd(StringSegment databaseName, Task <TResource> task)
{
if (_caseSensitive.TryGetValue(databaseName, out Task <TResource> value))
{
return(value);
}
if (_caseInsensitive.TryGetValue(databaseName, out value))
{
return(value);
}
lock (this)
{
if (_caseInsensitive.TryGetValue(databaseName, out value))
{
return(value);
}
value = _caseInsensitive.GetOrAdd(databaseName, task);
if (value == task)
{
_resourceDetails[task] = new ResourceDetails
{
InCacheSince = DateTime.UtcNow
};
}
_caseSensitive[databaseName] = value;
_mappings[databaseName] = new ConcurrentSet <StringSegment>
{
databaseName
};
return(value);
}
}
public Task <TResource> Replace(string databaseName, Task <TResource> task)
{
lock (this)
{
Task <TResource> existingTask = null;
_caseInsensitive.AddOrUpdate(databaseName, segment => task, (key, existing) =>
{
existingTask = existing;
return(task);
});
ResourceDetails details = null;
if (existingTask != null)
{
_resourceDetails.TryRemove(existingTask, out details);
}
_resourceDetails[task] = details ?? new ResourceDetails {
InCacheSince = SystemTime.UtcNow
};
if (_mappings.TryGetValue(databaseName, out ConcurrentSet <StringSegment> mappings))
{
foreach (var mapping in mappings)
{
_caseSensitive.TryRemove(mapping, out Task <TResource> _);
}
}
return(existingTask);
}
}
public async Task <ActionResult <ResourceDetails> > PostResourceDetails(ResourceDetails resourceDetails)
{
_context.ResourceDetails.Add(resourceDetails);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetResourceDetails", new { id = resourceDetails.ResID }, resourceDetails));
}
public URLBasedX509CertificateSupplier(
ResourceDetails certificateResourceDetails,
ResourceDetails privateKeyResourceDetails,
char[] privateKeyPassphraseCharacters)
{
this.certificateDetails = certificateResourceDetails;
this.privateKeyDetails = privateKeyResourceDetails;
this.privateKeyPassphraseCharacters = privateKeyPassphraseCharacters;
}
public void HandlerCalledWithParams_GetsResourceDetails()
{
var details = new ResourceDetails();
_mockDiscoverer.Setup(x => x.GetResouceDetails("path")).Returns(details);
var response = _handler.Get("path");
Assert.That(response, Is.EqualTo(details));
}
public static PSSecurityResourceDetails ConvertToPSType(this ResourceDetails value)
{
if (value is AzureResourceDetails details)
{
return(new PSSecurityAzureResourceDetails()
{
Source = "Azure",
Id = details.Id
});
}
return(new PSSecurityResourceDetails()
{
Source = "Unknown"
});
}
public string CreateResource(ResourceDetails companySearch)
{
var resource =
$@"{{
""etag"": ""{companySearch.ETag}"",
""items"" : [
{string.Join(", ", _itemBlocks)}
],
""items_per_page"" : {companySearch.ItemsPerPage},
""kind"" : ""{companySearch.Kind}"",
""page_number"" : {companySearch.PageNumber},
""start_index"" : {companySearch.StartIndex},
""total_results"" : {companySearch.TotalResults}
}}";
return(resource);
}
public void GivenACompanyHouseSearchCompanyClient_WhenSearchingForACompany()
{
var fixture = new Fixture();
_resourceDetails = fixture.Create <ResourceDetails>();
_expectedCompanies = new List <CompanyDetails>
{
fixture.Build <CompanyDetails>().With(x => x.CompanyStatus, "active").With(x => x.CompanyType, "private-unlimited").With(x => x.Kind, "searchresults#company").Create(),
fixture.Build <CompanyDetails>().With(x => x.CompanyStatus, "dissolved").With(x => x.CompanyType, "private-unlimited").With(x => x.Kind, "searchresults#company").Create(),
fixture.Build <CompanyDetails>().With(x => x.CompanyStatus, "liquidation").With(x => x.CompanyType, "private-unlimited").With(x => x.Kind, "searchresults#company").Create(),
fixture.Build <CompanyDetails>().With(x => x.CompanyStatus, "receivership").With(x => x.CompanyType, "private-unlimited").With(x => x.Kind, "searchresults#company").Create(),
fixture.Build <CompanyDetails>().With(x => x.CompanyStatus, "administration").With(x => x.CompanyType, "private-unlimited").With(x => x.Kind, "searchresults#company").Create(),
fixture.Build <CompanyDetails>().With(x => x.CompanyStatus, "voluntary-arrangement").With(x => x.CompanyType, "private-unlimited").With(x => x.Kind, "searchresults#company").Create(),
fixture.Build <CompanyDetails>().With(x => x.CompanyStatus, "converted-closed").With(x => x.CompanyType, "private-unlimited").With(x => x.Kind, "searchresults#company").Create(),
fixture.Build <CompanyDetails>().With(x => x.CompanyStatus, "insolvency-proceedings").With(x => x.CompanyType, "private-unlimited").With(x => x.Kind, "searchresults#company").Create(),
fixture.Build <CompanyDetails>().With(x => x.CompanyStatus, "open").With(x => x.CompanyType, "private-unlimited").With(x => x.Kind, "searchresults#company").Create(),
fixture.Build <CompanyDetails>().With(x => x.CompanyStatus, "closed").With(x => x.CompanyType, "private-unlimited").With(x => x.Kind, "searchresults#company").Create(),
fixture.Build <CompanyDetails>().With(x => x.CompanyStatus, "closed-on").With(x => x.CompanyType, "private-unlimited").With(x => x.Kind, "searchresults#company").Create(),
//fixture.Build<CompanyDetails>().With(x => x.CompanyStatus, null).With(x => x.CompanyType, "private-unlimited").With(x => x.Kind, "searchresults#company").Create(),
};
var uri = new Uri("https://wibble.com/search/companies");
_companyWithUnknownDateOfCessation = fixture.Build <CompanyDetails>().With(x => x.CompanyStatus, "insolvency-proceedings").With(x => x.CompanyType, "private-unlimited").With(x => x.Kind, "searchresults#company").Create();
var resource = new CompanySearchResourceBuilder()
.AddCompanies(_expectedCompanies)
.AddCompanyWithUnknownDateOfCessation(_companyWithUnknownDateOfCessation)
.CreateResource(_resourceDetails);
HttpMessageHandler handler = new StubHttpMessageHandler(uri, resource);
var uriBuilder = new Mock <ISearchUriBuilder>();
uriBuilder.Setup(x => x.Build(It.IsAny <SearchRequest>()))
.Returns(uri);
var uriBuilderFactory = new Mock <ISearchUriBuilderFactory>();
uriBuilderFactory.Setup(x => x.Create <CompanySearch>())
.Returns(uriBuilder.Object);
_client = new CompaniesHouseSearchClient(new HttpClient(handler), uriBuilderFactory.Object);
_result = _client.SearchAsync <CompanySearch>(new SearchRequest()).Result;
}
private static ResourceDetails GetReourceDetails(ResourceManagementClient client, string resourceId, TraceWriter log)
{
var details = new ResourceDetails();
var bits = resourceId.Split('/');
details.ResourceGroupName = bits[4];
string providerName = bits[6];
var resourceTypeName = bits[7];
var resourceName = bits[8];
var resourceProvider = client.Providers.Get(providerName);
var resourceProviderType = resourceProvider.Provider.ResourceTypes.Where(pt => pt.Name.ToLower() == resourceTypeName.ToLower()).Single();
var latestApi = resourceProviderType.ApiVersions.First();
details.ResourceIdentity = new ResourceIdentity(resourceName, providerName + "/" + resourceTypeName, latestApi);
return(details);
}
public ActionResult ResourceDetails(int id)
{
var RDetails = new ResourceDetails();
_resources = dbOperations.GetResources();
_employees = dbOperations.GetEmployees();
_projects = dbOperations.GetProjects();
RDetails.reservations = dbOperations.GetResourcesReservation(id);
RDetails.resource = _resources.Find(s => s.ResourceId == id);
RDetails.employees = new List <EMPLOYEES>();
RDetails.projects = new List <PROJECTS>();
foreach (var reservation in RDetails.reservations)
{
RDetails.employees.Add(_employees.Where(s => s.EmployeeId == reservation.EmployeeId).FirstOrDefault());
RDetails.projects.Add(_projects.Where(s => s.ProjectCode == reservation.ProjectCode).FirstOrDefault());
}
return(View(RDetails));
}
/// <summary>
/// Validate the object.
/// </summary>
/// <exception cref="ValidationException">
/// Thrown if validation fails
/// </exception>
public virtual void Validate()
{
if (ResourceDetails == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "ResourceDetails");
}
if (ResourceDetails != null)
{
ResourceDetails.Validate();
}
if (PendingFields != null)
{
foreach (var element in PendingFields)
{
if (element != null)
{
element.Validate();
}
}
}
}
private X509Certificate2 ReadRawCertificate(ResourceDetails certificateDetails)
{
logger.Info("reading the raw certificate");
var requestMsg = new HttpRequestMessage(HttpMethod.Get, certificateDetails.Uri);
foreach (KeyValuePair <string, string> entry in certificateDetails.Headers)
{
requestMsg.Headers.TryAddWithoutValidation(entry.Key, entry.Value);
}
var response = Client.SendAsync(requestMsg).Result;
if (response == null || !response.IsSuccessStatusCode)
{
logger.Debug("Received non successful response while trying to get the raw certificate");
ResponseHelper.HandleNonSuccessfulResponse(response);
}
var certificateString = response.Content.ReadAsStringAsync().Result;
var certificateBytes = Encoding.UTF8.GetBytes(certificateString);
return(new X509Certificate2(certificateBytes));
}
public bool TryGetValue(StringSegment resourceName, out Task <TResource> resourceTask, out ResourceDetails details)
{
details = null;
if (TryGetValue(resourceName, out resourceTask) == false)
{
return(false);
}
return(_resourceDetails.TryGetValue(resourceTask, out details));
}
public ResourceDetails GetResouceDetails(string groupPath)
{
var swaggerSpec = new ResourceDetails
{
swaggerVersion = "1.2",
apiVersion = Assembly.GetCallingAssembly().GetName().Version.ToString(),
apis = new List <ApiDetails>(),
resourcePath = "/",
basePath = "/"
};
var groupOperations =
Operations().Where(x => x.Group.Path.Equals(groupPath, StringComparison.InvariantCultureIgnoreCase));
var typeMapper = new TypeMapper();
foreach (var operationMetadata in groupOperations)
{
var mappedReturnType = typeMapper.Register(operationMetadata.ReturnType);
var op = new Operation
{
uri = operationMetadata.Uri.Uri,
method = operationMetadata.HttpVerb,
nickname = operationMetadata.Nickname ?? "",
notes = operationMetadata.Notes ?? "",
type = mappedReturnType.Type,
items = mappedReturnType.Items,
summary = operationMetadata.Summary ?? "",
parameters = new List <Parameter>(),
responseMessages = new List <Responsemessage>()
};
foreach (var header in SwaggerGenerator.Configuration.Headers)
{
op.parameters.Add(new Parameter
{
paramType = "header",
name = header.Name,
required = true,
description = header.SuggestedValue,
type = "string",
minimum = 1,
maximum = 1
});
}
foreach (var param in operationMetadata.InputParameters)
{
var swagParam = typeMapper.Map(param);
swagParam.paramType = param.LocationType.ToString().ToLower();
op.parameters.Add(swagParam);
}
foreach (var code in operationMetadata.ResponseCodes)
{
op.responseMessages.Add(new Responsemessage {
code = code.StatusCode, message = code.Description
});
}
swaggerSpec.apis.Add(new ApiDetails
{
description = operationMetadata.Summary,
path = operationMetadata.UriParser.Path,
operations = new List <Operation> {
op
}
});
}
foreach (var item in typeMapper.Models)
{
swaggerSpec.models.Add(item.id, item);
}
return(swaggerSpec);
}
