public void BuildRequirementInfoTab(RequirementInfoData requirementData, IStandardSpecficLevelRepository levelManager, CSET_Context controlContext)
{
ShowRequirementFrameworkTitle = true;
NEW_REQUIREMENT requirement = requirementData.Requirement;
Question_or_Requirement_Id = requirement.Requirement_Id;
this.SetsList = new List <string>(requirementData.Sets.Select(s => s.Value.Short_Name));
// Get related questions
var query = from rq in controlContext.REQUIREMENT_QUESTIONS
join q in controlContext.NEW_QUESTION on rq.Question_Id equals q.Question_Id
where rq.Requirement_Id == requirementData.RequirementID
select new RelatedQuestion
{
QuestionID = q.Question_Id,
QuestionText = q.Simple_Question
};
this.QuestionsList = query.ToList();
RequirementTabData tabData = new RequirementTabData();
tabData.RequirementID = requirement.Requirement_Id;
tabData.Text = FormatRequirementText(requirement.Requirement_Text);
tabData.SupplementalInfo = FormatSupplementalInfo(requirement.Supplemental_Info);
tabData.Set_Name = requirementData.SetName;
RequirementsData = tabData;
int requirement_id = requirement.Requirement_Id;
// var questions = requirement.NEW_QUESTION;
SETS set;
if (!requirementData.Sets.TryGetValue(requirementData.SetName, out set))
{
set = controlContext.SETS.Where(x => x.Set_Name == requirementData.SetName).FirstOrDefault();
}
String shortStandardName = set.Short_Name;
HeaderName = shortStandardName;
if (!IsComponent)
{
RequirementFrameworkTitle = requirement.Requirement_Title;
}
RelatedFrameworkCategory = requirement.Standard_Sub_Category;
if (requirementData.SetName == StandardManager.CNSSI_1253_DB || requirementData.SetName == StandardManager.CNSSI_ICS_PIT_DB ||
requirementData.SetName == StandardManager.CNSSI_ICS_V1_DB || requirementData.SetName == StandardManager.CNSSI_1253_V2_DB)
{
var levels = requirement.REQUIREMENT_LEVELS.Select(x => new
{
FullName = levelManager.GetFullName(levelManager.GetStandard(x.Standard_Level), levelManager.GetLevelOrder(x.Standard_Level)),
LevelOrder = levelManager.GetLevelOrder(x.Standard_Level),
LevelType = x.Level_Type
}).ToList();
Tuple <int, string> availableLevel = Tuple.Create(-1, "None");
Tuple <int, string> confidenceLevel = Tuple.Create(-1, "None");
Tuple <int, string> integretityLevel = Tuple.Create(-1, "None");
foreach (var item in levels)
{
if (item.LevelType == "A")
{
if (availableLevel.Item1 == -1)
{
availableLevel = Tuple.Create(item.LevelOrder, item.FullName);
}
else
{
if (availableLevel.Item1 > item.LevelOrder)
{
availableLevel = Tuple.Create(item.LevelOrder, item.FullName);
}
}
}
else if (item.LevelType == "C")
{
if (confidenceLevel.Item1 == -1)
{
confidenceLevel = Tuple.Create(item.LevelOrder, item.FullName);
}
else
{
if (confidenceLevel.Item1 > item.LevelOrder)
{
confidenceLevel = Tuple.Create(item.LevelOrder, item.FullName);
}
}
}
else if (item.LevelType == "I")
{
if (integretityLevel.Item1 == -1)
{
integretityLevel = Tuple.Create(item.LevelOrder, item.FullName);
}
else
{
if (integretityLevel.Item1 > item.LevelOrder)
{
integretityLevel = Tuple.Create(item.LevelOrder, item.FullName);
}
}
}
}
this.LevelName = "Availability: " + availableLevel.Item2 + "\n" +
"Confidentiality: " + confidenceLevel.Item2 + "\n" +
"Integrity:" + integretityLevel.Item2;
}
else
{
var parameters = requirementData.Requirement.REQUIREMENT_LEVELS.Select(s => new Tuple <string, int>(levelManager.GetStandard(s.Standard_Level), levelManager.GetLevelOrder(s.Standard_Level))).OrderBy(s => s.Item2).FirstOrDefault();
if (parameters != null)
{
this.LevelName = levelManager.GetFullName(parameters.Item1, parameters.Item2);
}
}
QuestionsVisible = true;
ShowRequirementStandards = true;
ShowSALLevel = true;
BuildDocuments(requirementData.RequirementID, controlContext);
}
public QuestionPoco(ANSWER answer, NEW_REQUIREMENT new_requirement, RequirementLevel requirementLevel)
: this(answer)
{
this.NEW_REQUIREMENT = new_requirement;
this.RequirementLevel = requirementLevel;
}
private NEW_QUESTION BuildFromNewQuestion(BaseQuestionInfoData infoData, SETS set, CSET_Context controlContext)
{
NEW_QUESTION question = infoData.Question;
NEW_REQUIREMENT requirement = null;
RequirementTabData tabData = new RequirementTabData();
string shortStandardName = set.Short_Name;
HeaderName = shortStandardName;
Question_or_Requirement_Id = infoData.QuestionID;
this.LevelName = (from a in controlContext.NEW_QUESTION_SETS.Where(t => t.Question_Id == infoData.QuestionID && t.Set_Name == infoData.Set.Set_Name)
join l in controlContext.NEW_QUESTION_LEVELS on a.New_Question_Set_Id equals l.New_Question_Set_Id
join u in controlContext.UNIVERSAL_SAL_LEVEL on l.Universal_Sal_Level equals u.Universal_Sal_Level1
orderby u.Sal_Level_Order
select u.Full_Name_Sal).FirstOrDefault();
// Gets requirements for the current standard (Set)
IEnumerable <NEW_REQUIREMENT> requires = null;
if (set.Is_Custom)
{
//Legacy only
var tempRequires = new List <NEW_REQUIREMENT>();
foreach (var setName in set.CUSTOM_STANDARD_BASE_STANDARDBase_StandardNavigation.Select(s => s.Base_Standard).ToList())
{
tempRequires = tempRequires.Concat(question.NEW_REQUIREMENTs().Where(t => t.REQUIREMENT_SETS.Select(s => s.Set_Name).Contains(setName)).ToList()).ToList();
}
requires = tempRequires;
}
if (requires == null || !requires.Any())
{
requires = from a in controlContext.NEW_REQUIREMENT
join b in controlContext.REQUIREMENT_QUESTIONS_SETS on a.Requirement_Id equals b.Requirement_Id
where b.Question_Id == infoData.QuestionID && b.Set_Name == set.Set_Name
select a;
}
requirement = requires.FirstOrDefault();
if (requirement != null)
{
tabData.Set_Name = set.Set_Name;
tabData.Text = FormatRequirementText(requirement.Requirement_Text);
tabData.RequirementID = requirement.Requirement_Id;
if (!IsComponent)
{
RequirementFrameworkTitle = requirement.Requirement_Title;
}
RelatedFrameworkCategory = requirement.Standard_Sub_Category;
if (RelatedFrameworkCategory == null)
{
var query = from qgh in controlContext.QUESTION_GROUP_HEADING
join usch in controlContext.UNIVERSAL_SUB_CATEGORY_HEADINGS on qgh.Question_Group_Heading_Id equals usch.Question_Group_Heading_Id
join q in controlContext.NEW_QUESTION on usch.Heading_Pair_Id equals q.Heading_Pair_Id
where q.Question_Id == question.Question_Id
select qgh.Question_Group_Heading1;
RelatedFrameworkCategory = query.FirstOrDefault();
}
tabData.SupplementalInfo = requires.FirstOrDefault(s => !String.IsNullOrEmpty(s.Supplemental_Info))?.Supplemental_Info;
tabData.SupplementalInfo = FormatSupplementalInfo(tabData.SupplementalInfo);
BuildDocuments(requirement.Requirement_Id, controlContext);
}
QuestionsVisible = false;
ShowRequirementStandards = false;
ShowSALLevel = true;
RequirementsData = tabData;
return(question);
}
/// <summary>
///
/// </summary>
public static void SaveQuestions(
string setName,
IExternalRequirement externalRequirement,
NEW_REQUIREMENT newRequirement,
QUESTION_GROUP_HEADING questionGroupHeading,
UNIVERSAL_SUB_CATEGORY_HEADINGS uschPairing,
CSET_Context db)
{
if (externalRequirement.Questions == null || externalRequirement.Questions.Count() == 0)
{
return;
// trying to manufacture a question where none was defined could get us into trouble
// externalRequirement.Questions = new QuestionList() { externalRequirement.Text };
}
var stdRefNum = 1;
foreach (var question in externalRequirement.Questions)
{
NEW_QUESTION newQuestion = null;
// Look for existing question by question text
newQuestion = db.NEW_QUESTION.FirstOrDefault(s => s.Simple_Question.ToLower().Trim() == question.ToLower().Trim());
if (newQuestion == null)
{
newQuestion = new NEW_QUESTION();
try
{
newQuestion.Original_Set_Name = setName;
newQuestion.Simple_Question = question;
newQuestion.Weight = externalRequirement.Weight;
newQuestion.Question_Group_Id = questionGroupHeading.Question_Group_Heading_Id;
newQuestion.Universal_Sal_Level = SalCompare.FindLowestSal(externalRequirement.SecurityAssuranceLevels);
newQuestion.Std_Ref = setName.Replace("_", "");
newQuestion.Std_Ref = newQuestion.Std_Ref.Substring(0, Math.Min(newQuestion.Std_Ref.Length, 50));
newQuestion.Std_Ref_Number = stdRefNum++;
newQuestion.Heading_Pair_Id = uschPairing.Heading_Pair_Id;
db.NEW_QUESTION.Add(newQuestion);
db.SaveChanges();
}
catch (Exception exc)
{
var a = exc;
// result.LogError(String.Format("Question {0} could not be added for requirement {1} {2}.", question, externalRequirement.Identifier, externalRequirement.Text));
}
}
var nqs = new NEW_QUESTION_SETS()
{
Question_Id = newQuestion.Question_Id,
Set_Name = setName
};
if (db.NEW_QUESTION_SETS.Count(x => x.Question_Id == nqs.Question_Id && x.Set_Name == nqs.Set_Name) == 0)
{
db.NEW_QUESTION_SETS.Add(nqs);
db.SaveChanges();
// attach question SAL levels
var nqlList = new List <NEW_QUESTION_LEVELS>();
foreach (string sal in externalRequirement.SecurityAssuranceLevels)
{
var nql = new NEW_QUESTION_LEVELS()
{
Universal_Sal_Level = sal.ToString(),
New_Question_Set_Id = nqs.New_Question_Set_Id
};
if (!nqlList.Exists(x =>
x.Universal_Sal_Level == nql.Universal_Sal_Level &&
x.New_Question_Set_Id == nqs.New_Question_Set_Id))
{
db.NEW_QUESTION_LEVELS.Add(nql);
nqlList.Add(nql);
}
}
}
try
{
var rqs = new REQUIREMENT_QUESTIONS_SETS()
{
Question_Id = newQuestion.Question_Id,
Set_Name = setName,
Requirement_Id = newRequirement.Requirement_Id
};
if (db.REQUIREMENT_QUESTIONS_SETS.Count(x =>
x.Question_Id == rqs.Question_Id &&
x.Set_Name == rqs.Set_Name) == 0)
{
db.REQUIREMENT_QUESTIONS_SETS.Add(rqs);
}
var rq = new REQUIREMENT_QUESTIONS()
{
Question_Id = newQuestion.Question_Id,
Requirement_Id = newRequirement.Requirement_Id
};
if (db.REQUIREMENT_QUESTIONS_SETS.Count(x => x.Question_Id == rq.Question_Id &&
x.Requirement_Id == rq.Requirement_Id) == 0)
{
db.REQUIREMENT_QUESTIONS.Add(rq);
}
db.SaveChanges();
}
catch (Exception exc)
{
throw new Exception("Error saving REQUIREMENT_QUESTIONS_SETS and REQUIREMENT_QUESTIONS");
}
}
}
