GetDmarcReadModelForDomainWhenDomainDoesntHaveDmarcAndOrgDomainIsNullReturnsOriginalReadModel()
{
int domainId = 1;
string readmodel = "{\"readModel\": \"Test\"}";
DomainRequest request = new DomainRequest {
Id = domainId
};
ValidationResult validationResult = new ValidationResult(new List <ValidationFailure>());
A.CallTo(() => _domainRequestValidator.ValidateAsync(request, CancellationToken.None))
.Returns(Task.FromResult(validationResult));
A.CallTo(() => _domainStatusDao.GetDmarcReadModel(request.Id)).Returns(Task.FromResult(readmodel));
IActionResult result = await _domainStatusController.GetDmarcReadModel(request);
ObjectResult objectResult = result as ObjectResult;
Assert.That(objectResult.Value, Is.TypeOf <string>());
string dmarcReadModelString = objectResult.Value as string;
Assert.That(dmarcReadModelString, Is.EqualTo(readmodel));
A.CallTo(() => _domainStatusDao.GetDmarcReadModel(A <int> ._)).MustHaveHappened(Repeated.Exactly.Once);
}
public void Initialize_DomainRequest_Should_Throw_Exception_For_Required_Params(string domainName, string smtpPassword)
{
Assert.Throws <ArgumentNullException>(() =>
{
var domainRequest = new DomainRequest(domainName, smtpPassword);
});
}
public IActionResult Domain(DomainRequest request)
{
ValidateEntity <DomainRequest>(request);
List <Entities.Domain> domains = Business.User.GetDomains(Context.Current.User.Username);
Entities.Domain domain = domains.Where(x => x.Id.ToString().ToLower() == request.Domain.ToLower() || x.Name.ToLower() == request.Domain.ToLower()).FirstOrDefault();
if (domain == null)
{
domain = NestSearch(domains, request.Domain);
if (domain == null)
{
throw new ApiNotFoundException(request.Domain);
}
}
Business.User.SetDomain(Context.Current.User.Id, domain.Id);
Context.Current.User.DomainId = domain.Id;
Context.Current.User.Domain = domain;
DomainResponse response = new DomainResponse()
{
User = Context.Current.User
};
HttpContext.Session.Set(Context.Current.User);
return(GetOutput(response));
}
public void Domain_Request_Should_Throw_Exception_When_Hostname_Incorrectly_Formatted(string domainName)
{
Assert.Throws <FormatException>(() =>
{
var domainRequest = new DomainRequest(domainName, "password");
});
}
public async Task <IActionResult> GetSpfReadModel(DomainRequest domainRequest)
{
ValidationResult validationResult = await _domainRequestValidator.ValidateAsync(domainRequest);
if (!validationResult.IsValid)
{
_log.LogWarning($"Bad request: {validationResult.GetErrorString()}");
return(BadRequest(new ErrorResponse(validationResult.GetErrorString())));
}
string spf = await _domainStatusDao.GetSpfReadModel(domainRequest.Id);
if (spf == null)
{
Domain.Domain domain = await _domainStatusDao.GetDomain(domainRequest.Id);
if (domain == null)
{
return(NotFound(new ErrorResponse($"No domain found for ID {domainRequest.Id}.")));
}
return(new ObjectResult(new { records = (List <string>)null, pending = true }));
}
return(new ObjectResult(spf));
}
public async Task GetDmarcReadModelDomainHasDmarcRecordDmarcRecordReturned()
{
int domainId = 1;
string readmodel = "{\"readModel\": \"Test\"}";
string domainName = "abc.xyz.com";
DomainRequest request = new DomainRequest {
Id = domainId
};
ValidationResult validationResult = new ValidationResult(new List <ValidationFailure>());
A.CallTo(() => _domainRequestValidator.ValidateAsync(request, CancellationToken.None)).Returns(Task.FromResult(validationResult));
DmarcReadModel dmarcReadModel = new DmarcReadModel(new Domain.Domain(domainId, domainName), true, readmodel);
A.CallTo(() => _domainStatusDao.GetDmarcReadModel(request.Id)).Returns(Task.FromResult(dmarcReadModel));
IActionResult result = await _domainStatusController.GetDmarcReadModel(request);
ObjectResult objectResult = result as ObjectResult;
Assert.That(objectResult.Value, Is.TypeOf <string>());
string dmarcReadModelString = objectResult.Value as string;
Assert.That(dmarcReadModelString, Is.EqualTo(readmodel));
A.CallTo(() => _domainStatusDao.GetDmarcReadModel(A <int> ._)).MustHaveHappened(Repeated.Exactly.Once);
A.CallTo(() => _organisationalDomainProvider.GetOrganisationalDomain(A <string> ._)).MustNotHaveHappened();
A.CallTo(() => _domainStatusDao.GetDmarcReadModel(A <string> ._)).MustNotHaveHappened();
}
public void DomainRequest_Should_Generate_NonEmpty_JsonObject(string domainName, string smtpPassword, SpamAction spamAction, bool wildcard, bool authority)
{
var domainRequest = new DomainRequest(domainName, smtpPassword, spamAction, wildcard, authority);
var json = domainRequest.ToJson();
Assert.NotEmpty(json);
}
protected override void HandleDomainRequest(PublicScheme aggregate, DomainRequest <PublicSchemeId> request, UserId userId, CancellationToken cancellationToken
)
{
aggregate.Should().BeSameAs(this.testScheme);
request.AggregateId.Should().BeSameAs(aggregate.Id);
this.handleDomainRequest_CallCount++;
}
public void DomainRequest_Should_Generate_NonEmpty_FormContent(string domainName, string smtpPassword, SpamAction spamAction, bool wildcard, bool authority)
{
var domainRequest = new DomainRequest(domainName, smtpPassword, spamAction, wildcard, authority);
var formContent = domainRequest.ToFormContent();
Assert.NotEmpty(formContent);
}
public DomainResponse FindUriInSearch(DomainRequest request)
{
if (request == null)
{
var message = "Missing Request object";
_log.Error(message);
throw new ArgumentNullException("request", message);
}
var responsePage = _requestHandler.GetSearchResponse(request.Keywords);
var anchorMatches = Regex.Matches(responsePage, @"(<a.*?>.*?</a>)", RegexOptions.Singleline);
var resultLinks = new List <string>();
foreach (Match anchorMatch in anchorMatches)
{
var matchValue = anchorMatch.Groups[1].Value;
if (matchValue.StartsWith(@"<a href=""/url"))
{
resultLinks.Add(matchValue);
}
}
var sb = new StringBuilder();
sb.Append($"URI: {request.ExpectedUri} \t Positions: ");
var response = new DomainResponse()
{
ExpectedUri = request.ExpectedUri,
MatchedPositions = new List <int>()
};
foreach (var result in resultLinks)
{
var resultIndex = resultLinks.IndexOf(result);
if (resultIndex > 100)
{
break;
}
if (result.Contains(request.ExpectedUri))
{
response.MatchedPositions.Add(resultIndex);
}
}
if (response.MatchedPositions != null && response.MatchedPositions.Count > 0)
{
_sqlRepository.InsertSearchResults(response.MatchedPositions.Count,
response.MatchedPositions.OrderByDescending(i => i).First());
}
response.SeoResults = _sqlRepository.RetrieveTopResults().ToList();
return(response);
}
public void Initialize_DomainRequest_Should_Have_Same_Values_As_When_Created(string domainName, string smtpPassword, SpamAction spamAction, bool wildcard, bool authority)
{
var domainRequest = new DomainRequest(domainName, smtpPassword, spamAction, wildcard, authority);
Assert.Equal(domainName, domainRequest.DomainName);
Assert.Equal(smtpPassword, domainRequest.SmtpPassword);
Assert.Equal(spamAction, domainRequest.SpamAction);
Assert.Equal(wildcard, domainRequest.Wildcard);
Assert.Equal(authority, domainRequest.ForceDKIMAuthority);
}
/// <summary>
/// Validate the Edit USer details
/// </summary>
/// <param name="request"></param>
public static void ValidateEditDomainRequest(DomainRequest request, List <string> ChangedProps)
{
var dbDomain = dbContext.Domains.FirstOrDefault(item => item.Id == request.DomainName);
if (dbDomain == null && ChangedProps.Contains("DomainName"))
{
var response = HttpUtilities.FrameHTTPResp(System.Net.HttpStatusCode.BadRequest, ErrorCodes.DOMAIN_MOD_NOT_ALLOWED);
throw new HttpResponseException(response);
}
}
public string Serialize(DomainRequest request, UserId userId)
{
return(JsonConvert.SerializeObject(new
{
CorrelationId = request.Id,
Type = request.GetType().Name,
Version = this.version.ToString(),
UserId = userId.Value,
Payload = request
}, serializerSettings));
}
public async Task <IActionResult> GetDmarcReadModel(DomainRequest domainRequest)
{
ValidationResult validationResult = await _domainRequestValidator.ValidateAsync(domainRequest);
if (!validationResult.IsValid)
{
_log.LogWarning($"Bad request: {validationResult.GetErrorString()}");
return(BadRequest(new ErrorResponse(validationResult.GetErrorString())));
}
DmarcReadModel dmarc = await _domainStatusDao.GetDmarcReadModel(domainRequest.Id);
if (dmarc == null)
{
Domain.Domain domain = await _domainStatusDao.GetDomain(domainRequest.Id);
if (domain == null)
{
return(NotFound(new ErrorResponse($"No domain found for ID {domainRequest.Id}.")));
}
return(new ObjectResult(new { records = (List <string>)null, pending = true }));
}
if (dmarc.HasDmarc)
{
return(new ObjectResult(dmarc.Model));
}
OrganisationalDomain organisationalDomain = await _organisationalDomainProvider.GetOrganisationalDomain(dmarc.Domain.Name);
if (organisationalDomain.IsOrgDomain || organisationalDomain.IsTld)
{
return(new ObjectResult(dmarc.Model));
}
DmarcReadModel organisationalDomainDmarcRecord =
await _domainStatusDao.GetDmarcReadModel(organisationalDomain.OrgDomain);
if (organisationalDomainDmarcRecord == null)
{
return(new ObjectResult(dmarc.Model));
}
JObject readModel = JObject.Parse(organisationalDomainDmarcRecord.Model);
readModel.AddFirst(new JProperty("inheritedFrom", JToken.FromObject(organisationalDomainDmarcRecord.Domain,
new JsonSerializer {
ContractResolver = new CamelCasePropertyNamesContractResolver()
})));
return(new ObjectResult(readModel.ToString()));
}
public async Task When_new_domain_is_created_list_should_return_it()
{
var domain = new DomainRequest(MockDomainName);
// Act
var result = await _dnSimpleClient.Domains.CreateDomainAsync(domain);
// Assert
result.Name.Should().Be(MockDomainName);
var list = await _dnSimpleClient.Domains.ListDomainsAsync();
list.Should().Contain(x => x.Name == MockDomainName);
}
public async Task <IActionResult> GetDomainTlsEvaluatorResults(DomainRequest domainRequest)
{
if (!ModelState.IsValid)
{
_log.LogWarning($"Bad request: {ModelState.GetErrorString()}");
return(BadRequest(new ErrorResponse(ModelState.GetErrorString())));
}
DomainTlsEvaluatorResults result = await _mxService.GetDomainTlsEvaluatorResults(domainRequest.Domain);
return(result == null
? NotFound(new ErrorResponse($"Domain {domainRequest.Domain} does not exist in Mail Check."))
: new ObjectResult(result));
}
public void ShouldReturnDnsIPAndPingData()
{
// Arrange
DomainRequest request = new DomainRequest
{
IpAddress = "172.217.160.142",
services = ServiceData.Geo
};
// Act
var response = _ipController.Post(request);
// Assert
response.ShouldNotBeNull();
}
public async Task QueueRequest(DomainRequest request, UserId userId)
{
var transRequestJson = this.requestSerializer.Serialize(request, userId);
var result = await this.producer.ProduceAsync(
this.queueConfig.TopicName,
request.AggregateId.ToString(),
transRequestJson);
if (result.Error.HasError)
{
this.logger.LogError($"Failed to queue request {request.Id}: {result.Error.Reason}");
throw new ApplicationException("Unable to accept a request due to the internal failure");
}
}
private List <MedicationMapData> InsertMedicationMappings(List <MedicationMapData> medmaps)
{
Mapper.CreateMap <MEMedicationMapping, DTO.MedicationMapData>()
.ForMember(d => d.Id, opt => opt.MapFrom(src => src.Id.ToString()))
.ForMember(dest => dest.RecordCreatedOn, opt => opt.MapFrom(src => src.RecordCreatedOn))
.ForMember(dest => dest.RecordCreatedBy, opt => opt.MapFrom(src => src.RecordCreatedBy.ToString()))
.ForMember(dest => dest.LastUpdatedOn, opt => opt.MapFrom(src => src.LastUpdatedOn))
.ForMember(dest => dest.UpdatedBy, opt => opt.MapFrom(src => src.UpdatedBy.ToString()));
var req = new DomainRequest {
Context = "NG", ContractNumber = "InHealth001"
};
var repo = MedicationRepositoryFactory.GetMedicationRepository(req, RepositoryType.MedicationMapping);
var MedMp = (List <MedicationMapData>)repo.InsertAll(medmaps.ToList <object>());
return(MedMp);
}
/// <summary>
/// Validation for the User Role Mapping
/// </summary>
public static void ValidateDomain(DomainRequest request)
{
var dbDomain = dbContext.Domains.FirstOrDefault(item => (item.DomainName == request.DomainName || item.OrgName == request.OrgName) && !item.Deleted);
if (dbDomain != null)
{
if (dbDomain.DomainName == request.DomainName)
{
var response = HttpUtilities.FrameHTTPResp(System.Net.HttpStatusCode.BadRequest, ErrorCodes.DOMAIN_EXISTS_ALREADY);
throw new HttpResponseException(response);
}
else
{
var response = HttpUtilities.FrameHTTPResp(System.Net.HttpStatusCode.BadRequest, ErrorCodes.ORG_EXISTS_ALREADY);
throw new HttpResponseException(response);
}
}
}
public void FindUriInSearch_Parse_Success()
{
_service = new SearchService(_searchRequestHandler);
var testRequest = new DomainRequest()
{
Keywords = "online title search",
ExpectedUri = "biggerpockets.com"
};
var response = _service.FindUriInSearch(testRequest);
_searchRequestHandler.Received(1).GetSearchResponse(testRequest.Keywords);
Assert.That(response.ExpectedUri, Is.EqualTo(testRequest.ExpectedUri));
Assert.That(response.MatchedPositions.Count, Is.EqualTo(1));
Assert.Pass();
}
public async Task GetDmarcReadModelForDomainWhenDomainDoesntHaveDmarcAndOrgDomainDoesReturnsOrgDomainResult()
{
int domainId = 1;
string readmodel = "{\"readModel\": \"Test\"}";
string orgDomainReadModel = "{\"readModel\": \"Test\"}";
string domainName = "abc.xyz.com";
string organisationalDomainName = "xyz.com";
DomainRequest request = new DomainRequest {
Id = domainId
};
ValidationResult validationResult = new ValidationResult(new List <ValidationFailure>());
A.CallTo(() => _domainRequestValidator.ValidateAsync(request, CancellationToken.None)).Returns(Task.FromResult(validationResult));
DmarcReadModel dmarcReadModel = new DmarcReadModel(new Domain.Domain(1, domainName), false, readmodel);
A.CallTo(() => _domainStatusDao.GetDmarcReadModel(request.Id)).Returns(Task.FromResult(dmarcReadModel));
OrganisationalDomain organisationalDomain = new OrganisationalDomain(organisationalDomainName, domainName);
A.CallTo(() => _organisationalDomainProvider.GetOrganisationalDomain(domainName)).Returns(Task.FromResult(organisationalDomain));
DmarcReadModel orgDomainDmarcReadModel = new DmarcReadModel(new Domain.Domain(1, domainName), false, orgDomainReadModel);
A.CallTo(() => _domainStatusDao.GetDmarcReadModel(A <string> ._)).Returns(Task.FromResult(orgDomainDmarcReadModel));
IActionResult result = await _domainStatusController.GetDmarcReadModel(request);
ObjectResult objectResult = result as ObjectResult;
Assert.That(objectResult.Value, Is.TypeOf <string>());
string dmarcReadModelString = objectResult.Value as string;
Assert.That(dmarcReadModelString, Does.Contain("\"readModel\": \"Test\""));
Assert.That(dmarcReadModelString, Does.Contain("inheritedFrom"));
A.CallTo(() => _domainStatusDao.GetDmarcReadModel(A <int> ._)).MustHaveHappened(Repeated.Exactly.Once);
A.CallTo(() => _organisationalDomainProvider.GetOrganisationalDomain(A <string> ._)).MustHaveHappened(Repeated.Exactly.Once);
A.CallTo(() => _domainStatusDao.GetDmarcReadModel(A <string> ._)).MustHaveHappened(Repeated.Exactly.Once);
}
public void Handle(ChallengeHandlingContext ctx)
{
AssertNotDisposed();
var dnsChallenge = (DnsChallenge)ctx.Challenge;
var domainDetails = GetDomainId(dnsChallenge);
var records = managedPath + domainDetails.DomainId + "/records";
CleanUp(dnsChallenge, domainDetails, records);
var recordNameToAdd = dnsChallenge.RecordName.Replace("." + domainDetails.DomainName, string.Empty);
var wr = CreateRequest(records);
wr.Method = "POST";
using (var request = new StreamWriter(wr.GetRequestStream()))
{
var requestObject = new DomainRequest()
{
name = recordNameToAdd,
value = dnsChallenge.RecordValue,
ttl = 600,
type = "TXT"
};
var json = JsonConvert.SerializeObject(requestObject);
request.Write(json);
}
using (var response = wr.GetResponse())
using (var content = new StreamReader(response.GetResponseStream()))
{
var resp = content.ReadToEnd();
var respObject = JsonConvert.DeserializeObject <DomainRequest>(resp);
if (string.IsNullOrEmpty(respObject.id))
{
//Failed
}
}
}
public async Task <IActionResult> GetDomain(DomainRequest domainRequest)
{
ValidationResult validationResult = await _domainRequestValidator.ValidateAsync(domainRequest);
if (!validationResult.IsValid)
{
_log.LogWarning($"Bad request: {validationResult.GetErrorString()}");
return(BadRequest(new ErrorResponse(validationResult.GetErrorString())));
}
Domain.Domain domain = await _domainStatusDao.GetDomain(domainRequest.Id);
if (domain == null)
{
_log.LogWarning($"Domain with id: { domainRequest.Id } not found");
return(NotFound(new ErrorResponse("Domain not found.", ErrorStatus.Information)));
}
return(new ObjectResult(domain));
}
public async Task <IActionResult> GetDomainTlsEvaluatorResults(DomainRequest domainRequest)
{
ValidationResult validationResult = await _domainRequestValidator.ValidateAsync(domainRequest);
if (!validationResult.IsValid)
{
_log.LogWarning($"Bad request: {validationResult.GetErrorString()}");
return(BadRequest(new ErrorResponse(validationResult.GetErrorString())));
}
DomainTlsEvaluatorResults domainTlsEvaluatorResults = await _domainStatusDao.GetDomainTlsEvaluatorResults(domainRequest.Id);
if (domainTlsEvaluatorResults == null)
{
_log.LogWarning($"Antispoofing for Domain with id: { domainRequest.Id } not found");
return(NotFound(new ErrorResponse($"No domain found for ID {domainRequest.Id}.")));
}
return(new ObjectResult(domainTlsEvaluatorResults));
}
public async Task <IHttpActionResult> PostDomain(DomainRequest item)
{
// Mapper.Reset();
try
{
ValidationUtilities.ValidateDomain(item);
string currentUserEmail = HttpUtilities.GetUserNameFromToken(this.Request);
Mapper.Initialize(cfg => cfg.CreateMap <DomainRequest, Domain>().ForMember(i => i.CreatedBy,
j => j.UseValue(currentUserEmail)));
var domain = Mapper.Map <DomainRequest, Domain>(item);
domain.Id = Guid.NewGuid().ToString();
Domain current = await InsertAsync(domain);
return(CreatedAtRoute("Tables", new { id = current.Id }, current));
}
catch (HttpResponseException ex)
{
LGSELogger.Error(ex);
throw ex;
}
}
public async Task <ActionResult <IpResponse> > Post([FromBody] DomainRequest domain)
{
List <ResultDetail> resultDetailList;
IpResponse ipResponse = new IpResponse();
ValidationResult validationResult = _ipRequestValidator.Validate(domain);
// Errors will never be null.
if (validationResult.Errors.Any())
{
resultDetailList = _errorMapper.Map(validationResult);
ipResponse = new IpResponse
{
Result = new Result
{
ResultCode = "Warning",
ResultDetailList = resultDetailList
}
};
return(StatusCode(400, ipResponse));
}
try
{
var geoUrl = _configuration.GetSection("ServicesUrl").GetSection("GeoUrl").Value;
switch (domain.services)
{
case ServiceData.Dns:
var dnsData = await _domainService.GetDnsDetails(domain.IpAddress);
ipResponse.DnsInfo = _idnsMapper.Map(dnsData);
break;
case ServiceData.Geo:
var geoData = await _domainService.GetGeoDetails(domain.IpAddress, geoUrl);
ipResponse.GeoData = _ipMapper.Map(geoData);
break;
case ServiceData.Ping:
var data = await _domainService.GetPingDetails(domain.IpAddress);
ipResponse.PingInfo = _ipingMapper.Map(data);
break;
case ServiceData.Rdap:
var rdapData = await _domainService.GetRdapDetails(domain.IpAddress);
ipResponse.RdapInfo = _irdapMapper.Map(rdapData);
break;
default:
ipResponse = await ExecuteAllServiceAsync(domain.IpAddress, geoUrl);
break;
}
}
catch (Exception exception)
{
if (exception?.InnerException?.Data?.Values.Count > 0)
{
var exceptionData = (List <Error>)(exception.InnerException.Data["Error"]);
resultDetailList = _errorMapper.Map(exceptionData);
}
else
{
ResultDetail resultDetail = new ResultDetail
{
Message = exception.Message
};
resultDetailList = new List <ResultDetail>
{
resultDetail
};
}
ipResponse = SetErrorResponseForPost(resultDetailList);
return(StatusCode(500, ipResponse));
}
return(ipResponse);
}
private async Task <DomainResult> CreateDomain(string domainName)
{
var domain = new DomainRequest(domainName);
return(await _dnSimpleClient.Domains.CreateDomainAsync(domain));
}