public void TestResultResponse101Ok()
{
var response = File.ReadAllText($"{exampleApiResponesPath}ResultTestResponse101.txt");
var result = ConverterResult.ConvertReceive(response);
Assert.IsNotNull(result);
Assert.AreEqual(101, result.StatusCode);
}
public void TestConvertRequest()
{
var response = File.ReadAllText($"{exampleApiResponesPath}RunTestResponse200.txt");
var result = ConverterResult.ConvertRequest(response);
Assert.IsNotNull(result);
Assert.AreEqual(200, result.StatusCode);
Assert.IsTrue(!string.IsNullOrEmpty(result.JsonUrl));
}
public void TestResultResponse200Ok()
{
var response = File.ReadAllText($"{exampleApiResponesPath}ResultTestResponse200.txt");
var result = ConverterResult.ConvertReceive(response);
Assert.IsNotNull(result);
Assert.AreEqual(200, result.StatusCode);
Assert.IsTrue(result is ResultTestReceiveExpandedModel);
Assert.AreEqual(3, ((ResultTestReceiveExpandedModel)result).Runs.Count);
}
private async Task <KeyValuePair <PageModel, string> > AddTest(PageModel page, Mobile mobile)
{
var resultTestRequest = ConverterResult.ConvertRequest(
await _pageTestApiService.SendTestAsync(page.Url, mobile,
NumberRunsTest));
_logger.Info("Test added correctly. " +
$"Response of server {resultTestRequest.StatusCode}" +
$" : {resultTestRequest.StatusText} {page.Name} v{page.Version} {mobile}");
var urlResult = resultTestRequest.JsonUrl;
return(new KeyValuePair <PageModel, string>(page, urlResult));
}
/* public CustomerConverterResult DeserializeCustomerFromJSONFile(string absoluteFolderPath, string fileName = "customer.json")
* {
* throw new NotImplementedException();
* }*/
// JSON - Text file lezen
// https://www.c-sharpcorner.com/UploadFile/mahesh/how-to-read-a-text-file-in-C-Sharp/
// StreamReader object gebruiker of File object gebruikt
// Wat is het verschil? ==>
// https://stackoverflow.com/questions/3545402/any-difference-between-file-readalltext-and-using-a-streamreader-to-read-file
/* public CustomerConverterResult DeserializeCustomerFromJSONFile(string absoluteFolderPath, string fileName = "customer.json")
* {
* var result = new CustomerConverterResult() { Status = ConverterStatus.Ok };
* var fullFilePath = Path.Combine(absoluteFolderPath, fileName);
* //controleer als de file bestaat binnen het opgegeven absolute folder pad.
* if (File.Exists(fullFilePath))
* {
* //using: disposal of the reader object, weggooien van het object na gebruik
* // ram vrijmaken
* using (var reader = new StreamReader(fullFilePath, System.Text.Encoding.UTF8))
* {
* // lezen van de inhoud van het json bestand in een string
* var jsonString = reader.ReadToEnd();
* reader.Close(); // sluit reader
* // Deserialisatie van de JSON Sting in het Customer object
* result.CustomerResult = System.Text.Json.JsonSerializer.Deserialize<Customer>(jsonString);
* }
* }
* else
* {
* result.Status = ConverterStatus.HasError;
* result.Error = new Exception($"Opgegeven file met naam { fileName } bestaat niet!");
* }
* return result;
* }*/
/* public CustomerConverterResult SerializeCustomerToJSONFile(string absoluteFolderPath, string fileName = "customer.json")
* {
* var result = new CustomerConverterResult() { Status = ConverterStatus.Ok };
* try
* {
* var fullFilePath = Path.Combine(absoluteFolderPath, fileName);
* // Bad practice: geen domain data in generieke libraries
* var customer = new Customer()
* {
* Name = "Decaestecker",
* Prename = "Roy",
* EmailAddress = "*****@*****.**",
* PhoneNumber = ""
* };
* // seralisatie van customer object naar een JSON string
* var jsonString = System.Text.Json.JsonSerializer.Serialize<Customer>(customer);
*
* // schrijf de jsonstring naar de file
* File.WriteAllText(fullFilePath, jsonString);
* }
* catch (Exception e)
* {
* result.Error = e;
* result.Status = ConverterStatus.HasError;
* }
* return result;
* } */
/// <summary>
/// Generieke method om een object te deserialiseren uit een JSON File
/// </summary>
/// <typeparam name="TOtds">Type van Object To DeSerialize</typeparam>
/// <param name="absoluteFolderPath"></param>
/// <param name="fileName"></param>
/// <returns></returns>
public ConverterResult <TOtds> DeserializeObjectFromJSONFile <TOtds>(string absoluteFolderPath, string fileName)
{
var result = new ConverterResult <TOtds>()
{
Status = ConverterStatus.Ok
};
var fullFilePath = Path.Combine(absoluteFolderPath, fileName);
if (File.Exists(fullFilePath))
{
string JSONString = File.ReadAllText(fullFilePath);
result.ReturnValue = System.Text.Json.JsonSerializer.Deserialize <TOtds>(JSONString);
}
else
{
result.Status = ConverterStatus.HasError;
result.Error = new Exception("File does not exist");
}
return(result);
}
/// <summary>
///
/// </summary>
/// <typeparam name="TOts">Type van Object To Serialize</typeparam>
/// <param name="absoluteFolderPath"></param>
/// <param name="fileName"></param>
/// <param name="objectToSerialize"></param>
/// <returns></returns>
public ConverterResult <TOts> SerializeObjectToJSONFile <TOts>(string absoluteFolderPath, string fileName, TOts objectToSerialize)
{
var result = new ConverterResult <TOts>()
{
Status = ConverterStatus.Ok
};
try
{
var fullFilePath = Path.Combine(absoluteFolderPath, fileName);
var jsonString = System.Text.Json.JsonSerializer.Serialize <TOts>(objectToSerialize);
File.WriteAllText(fullFilePath, jsonString);
}
catch (Exception e)
{
result.Error = e;
result.Status = ConverterStatus.HasError;
}
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="element"></param>
/// <param name="res"></param>
/// <param name="fileName"></param>
private void OverwriteAttachementValues(Element element, ConverterResult res, string fileName)
{
Config cfg = ConfigManager.GetConfigManager().ConnectorConfig;
element.ReplaceValues($"{cfg.StringIdentifier}.{cfg.BodyFieldName}", res.Body);
element.ReplaceValues($"{cfg.FacetIdentifier}.{cfg.ApplicationFieldName}", res.Application);
element.ReplaceValues($"{cfg.StringIdentifier}.{cfg.ApplicationFieldName}", res.Application);
element.ReplaceValues($"{cfg.FacetIdentifier}.{cfg.MimeTypeFieldName}", res.MimeType);
element.ReplaceValues($"{cfg.StringIdentifier}.{cfg.MimeTypeFieldName}", res.MimeType);
string attachementUrl = MetaReader.GetMetaReader().GetMetaUrl(element.Class, element.Id, fileName);
element.ReplaceValues($"{cfg.StringIdentifier}.{cfg.UrlFieldName}", attachementUrl);
string newId = $"{element.Id}_{fileName}";
element.ReplaceValues($"{cfg.StringIdentifier}.{cfg.UidFieldName}", newId);
element.Id = newId;
}
/// <summary>
///
/// </summary>
/// <param name="jsonString"></param>
/// <exception cref="Exception"></exception>
/// <returns></returns>
private ConverterResult ExtractValues(string jsonString)
{
JArray json;
try
{
json = JsonConvert.DeserializeObject <JArray>(jsonString);
}
catch (Exception e)
{
_log.Error(LocalizationService.FormatResourceString("ConverterServiceMessage01"), e);
throw;
}
Config config = ConfigManager.GetConfigManager().ConnectorConfig;
var fields = json[0][config.ConverterFieldsIdentifier];
if (fields == null)
{
var message = LocalizationService.FormatResourceString("ConverterServiceMessage03", config.ConverterFieldsIdentifier);
_log.Error(message);
throw new ArgumentNullException(message);
}
ConverterResult res = new ConverterResult();
string fieldName = $"{config.StringIdentifier}.{config.BodyFieldName}";
res.Body = Util.RemoveMarkup(GetConverterFieldValue(fields, fieldName));
fieldName = $"{config.StringIdentifier}.{config.MimeTypeFieldName}";
res.MimeType = GetConverterFieldValue(fields, fieldName);
fieldName = $"{config.StringIdentifier}.{config.ApplicationFieldName}";
string app = GetConverterFieldValue(fields, fieldName);
res.Application = config.ConverterApplicationMapping.ContainsKey(app) ?
config.ConverterApplicationMapping[app] : config.ConverterApplicationDefaultMapping;
return(res);
}
private async Task WaitForResult(IList <KeyValuePair <PageModel, string> > runnedTests)
{
foreach (var test in runnedTests)
{
do
{
try
{
var jsonResult = await _pageTestApiService.GetResultOfTestAsync(test.Value);
if (string.IsNullOrEmpty(jsonResult))
{
continue;
}
var testResult = ConverterResult.ConvertReceive(jsonResult);
//result ok
if (testResult is ResultTestReceiveExpandedModel)
{
_logger.Debug(testResult as ResultTestReceiveExpandedModel);
//save result
await _pageTestResultExporter.Save(testResult as ResultTestReceiveExpandedModel, test.Key);
break;
}
_logger.Info("Waiting from result test of server. " +
$"Response of server {testResult.StatusCode}" +
$" : {testResult.StatusText} {test.Key.Name} v{test.Key.Version}");
}
catch (Exception exception)
{
_logger.Error(exception.Message);
}
await Task.Delay(RefreshIntervalTime);
} while (true);
}
}
/// <summary>
///
/// </summary>
/// <param name="externalRequirement"></param>
/// <param name="setName"></param>
/// <param name="logger"></param>
/// <returns></returns>
public static NEW_REQUIREMENT SaveRequirement(this IExternalRequirement externalRequirement, string setName,
int sequence, ILogger logger)
{
var result = new ConverterResult <NEW_REQUIREMENT>(logger);
var newRequirement = result.Result;
//basic mappings
newRequirement.Supplemental_Info = externalRequirement.Supplemental;
newRequirement.Requirement_Text = externalRequirement.Text;
newRequirement.Requirement_Title = externalRequirement.Identifier;
newRequirement.Original_Set_Name = setName;
newRequirement.Weight = externalRequirement.Weight;
newRequirement.REQUIREMENT_LEVELS = new List <REQUIREMENT_LEVELS>();
newRequirement.REQUIREMENT_REFERENCES = new List <REQUIREMENT_REFERENCES>();
newRequirement.REQUIREMENT_SETS = new List <REQUIREMENT_SETS>()
{
new REQUIREMENT_SETS()
{
Set_Name = setName,
Requirement_Sequence = sequence
}
};
QUESTION_GROUP_HEADING questionGroupHeading = null;
UNIVERSAL_SUB_CATEGORY_HEADINGS uschPairing = null;
var db = new CSET_Context();
try
{
questionGroupHeading = db.QUESTION_GROUP_HEADING.FirstOrDefault(s => s.Question_Group_Heading1.Trim().ToLower() == externalRequirement.Heading.Trim().ToLower());
try
{
var subcatId = db.UNIVERSAL_SUB_CATEGORIES.FirstOrDefault(s => s.Universal_Sub_Category.Trim().ToLower() == externalRequirement.Subheading.Trim().ToLower())?.Universal_Sub_Category_Id ?? 0;
if (subcatId == 0)
{
var subcat = new UNIVERSAL_SUB_CATEGORIES()
{
Universal_Sub_Category = externalRequirement.Subheading
};
db.UNIVERSAL_SUB_CATEGORIES.Add(subcat);
db.SaveChanges();
subcatId = subcat.Universal_Sub_Category_Id;
}
try
{
uschPairing = db.UNIVERSAL_SUB_CATEGORY_HEADINGS.FirstOrDefault(s => (s.Universal_Sub_Category_Id == subcatId) && (s.Question_Group_Heading_Id == questionGroupHeading.Question_Group_Heading_Id));
if (uschPairing == null)
{
uschPairing = new UNIVERSAL_SUB_CATEGORY_HEADINGS()
{
Set_Name = "Standards",
Universal_Sub_Category_Id = subcatId,
Question_Group_Heading_Id = questionGroupHeading.Question_Group_Heading_Id
};
db.UNIVERSAL_SUB_CATEGORY_HEADINGS.Add(uschPairing);
db.SaveChanges();
}
}
catch (Exception exc)
{
var myExc = exc;
}
}
catch
{
}
}
catch
{
}
if (questionGroupHeading == null)
{
result.LogError(String.Format("Heading invalid for requirement {0} {1}. Please double check that the heading is spelled correctly.", externalRequirement.Identifier, externalRequirement.Text));
}
else
{
newRequirement.Question_Group_Heading_Id = questionGroupHeading.Question_Group_Heading_Id;
}
if (uschPairing == null)
{
result.LogError(String.Format("Subheading invalid for requirement {0} {1}. Please double check that the heading is spelled correctly.", externalRequirement.Identifier, externalRequirement.Text));
}
externalRequirement.Category = string.IsNullOrWhiteSpace(externalRequirement.Category) ? externalRequirement.Heading : externalRequirement.Category;
var category = db.STANDARD_CATEGORY.FirstOrDefault(s => s.Standard_Category1 == externalRequirement.Category);
if (category == null)
{
newRequirement.Standard_CategoryNavigation = new STANDARD_CATEGORY()
{
Standard_Category1 = externalRequirement.Category
};
}
else
{
newRequirement.Standard_Category = category.Standard_Category1;
}
newRequirement.Standard_Sub_Category = externalRequirement.Subheading;
// SAL
foreach (string sal in externalRequirement.SecurityAssuranceLevels)
{
var rl = new REQUIREMENT_LEVELS()
{
Standard_Level = sal,
Level_Type = "NST"
};
if (newRequirement.REQUIREMENT_LEVELS.Count(x => x.Standard_Level == rl.Standard_Level) == 0)
{
newRequirement.REQUIREMENT_LEVELS.Add(rl);
}
}
var importer = new DocumentImporter();
if (externalRequirement.References != null)
{
foreach (var reference in externalRequirement.References)
{
var reqReference = new REQUIREMENT_REFERENCES();
try
{
reqReference.Destination_String = reference.Destination;
reqReference.Page_Number = reference.PageNumber;
reqReference.Section_Ref = String.IsNullOrEmpty(reference.SectionReference) ? "" : reference.SectionReference;
reqReference.Gen_File_Id = importer.LookupGenFileId(reference.FileName);
}
catch
{
result.LogError(String.Format("Reference {0} could not be added for requirement {1} {2}.", externalRequirement.Source?.FileName, externalRequirement.Identifier, externalRequirement.Text));
}
if (reqReference.Gen_File_Id == 0)
{
result.LogError(String.Format("Reference {0} has not been loaded into CSET. Please add the file and try again.", externalRequirement.Source?.FileName, externalRequirement.Identifier, externalRequirement.Text));
}
else
{
newRequirement.REQUIREMENT_REFERENCES.Add(reqReference);
}
}
}
var reqSource = new REQUIREMENT_SOURCE_FILES();
try
{
if (externalRequirement.Source != null)
{
reqSource.Gen_File_Id = importer.LookupGenFileId(externalRequirement.Source.FileName);
reqSource.Page_Number = externalRequirement.Source.PageNumber;
reqSource.Destination_String = externalRequirement.Source.Destination;
reqSource.Section_Ref = String.IsNullOrEmpty(externalRequirement.Source.SectionReference) ? "" : externalRequirement.Source.SectionReference;
if (reqSource.Gen_File_Id == 0)
{
result.LogError(String.Format("Source {0} has not been loaded into CSET. Please add the file and try again.", externalRequirement.Source?.FileName, externalRequirement.Identifier, externalRequirement.Text));
}
else
{
newRequirement.REQUIREMENT_SOURCE_FILES.Add(reqSource);
}
}
}
catch
{
result.LogError(String.Format("Source {0} could not be added for requirement {1} {2}.", externalRequirement.Source?.FileName, externalRequirement.Identifier, externalRequirement.Text));
}
try
{
db.NEW_REQUIREMENT.Add(newRequirement);
db.SaveChanges();
}
catch (Exception exc)
{
// throw exc;
}
// Save any Questions associated with the Requirement
SaveQuestions(setName, externalRequirement, newRequirement,
questionGroupHeading, uschPairing,
db);
return(newRequirement);
}
