/// <summary>s
/// Builds info tab information for a maturity question.
/// References are hooked up differently than to questions and requirements.
/// </summary>
/// <param name="info"></param>
/// <param name="controlContext"></param>
public void BuildMaturityInfoTab(MaturityQuestionInfoData info, CSET_Context controlContext)
{
try
{
ShowRequirementFrameworkTitle = false;
RequirementFrameworkTitle = info.MaturityQuestion.Question_Title;
RelatedFrameworkCategory = info.MaturityQuestion.Category;
ShowRequirementStandards = true;
var l = controlContext.MATURITY_LEVELS.Where(x => x.Level == info.MaturityQuestion.Maturity_Level).FirstOrDefault();
if (l != null)
{
levelName = l.Level_Name;
}
IsMaturity = true;
RequirementTabData tabData = new RequirementTabData();
tabData.SupplementalInfo = info.MaturityQuestion.Supplemental_Info;
tabData.SupplementalInfo = FormatSupplementalInfo(tabData.SupplementalInfo);
RequirementsData = tabData;
BuildDocumentsForMaturityQuestion(info.QuestionID, controlContext);
}
catch (Exception ex)
{
//CSETLogger.Fatal("Failed to get maturity information tab data.", ex);
}
}
public void BuildComponentInfoTab(ComponentQuestionInfoData info, CSET_Context controlContext)
{
try
{
IsComponent = true;
ShowRequirementFrameworkTitle = false;
this.RequirementFrameworkTitle = "Components";
NEW_QUESTION question = BuildFromNewQuestion(info, info.Set, controlContext);
ComponentVisibility = true;
// Build multiServiceComponent types list if any
ComponentTypes.Clear();
int salLevel = controlContext.UNIVERSAL_SAL_LEVEL.Where(x => x.Universal_Sal_Level1 == question.Universal_Sal_Level).First().Sal_Level_Order;
List <ComponentOverrideLinkInfo> tmpList = new List <ComponentOverrideLinkInfo>();
foreach (COMPONENT_QUESTIONS componentType in controlContext.COMPONENT_QUESTIONS.Where(x => x.Question_Id == info.QuestionID))
{
bool enabled = info.HasComponentsForTypeAtSal(componentType.Component_Symbol_Id, salLevel);
COMPONENT_SYMBOLS componentTypeData = info.DictionaryComponentInfo[componentType.Component_Symbol_Id];
tmpList.Add(new ComponentOverrideLinkInfo()
{
Component_Symbol_Id = componentTypeData.Component_Symbol_Id,
Symbol_Name = componentTypeData.Symbol_Name,
Enabled = enabled
});
}
ComponentTypes = tmpList.OrderByDescending(x => x.Enabled).ThenBy(x => x.Symbol_Name).ToList();
var reqid = controlContext.REQUIREMENT_QUESTIONS.Where(x => x.Question_Id == info.QuestionID).First().Requirement_Id;
BuildDocuments(reqid, controlContext);
var requirement = controlContext.NEW_REQUIREMENT.Where(x => x.Requirement_Id == reqid).Select(t => new
{
Question_or_Requirement_Id = t.Requirement_Id,
Text = FormatRequirementText(t.Requirement_Text),
SupplementalInfo = FormatSupplementalInfo(t.Supplemental_Info)
}).FirstOrDefault();
if (requirement != null)
{
RequirementsData = new RequirementTabData()
{
RequirementID = requirement.Question_or_Requirement_Id,
Text = requirement.Text,
SupplementalInfo = FormatSupplementalInfo(requirement.SupplementalInfo),
};
QuestionsVisible = false;
ShowSALLevel = true;
}
}
catch (Exception ex)
{
//CSETLogger.Fatal("Failed to get component information tab data.", ex);
}
}
public void BuildFrameworkInfoTab(FrameworkInfoData frameworkData, CSET_Context controlContext)
{
QuestionsList = new List <RelatedQuestion>();
IsCustomQuestion = frameworkData.IsCustomQuestion;
References = frameworkData.References;
if (!IsComponent)
{
RequirementFrameworkTitle = frameworkData.Title;
}
RelatedFrameworkCategory = frameworkData.Category;
ShowRequirementFrameworkTitle = true;
String shortStandardName = controlContext.SETS.Where(x => x.Set_Name == frameworkData.SetName).FirstOrDefault().Short_Name;
HeaderName = shortStandardName;
if (String.IsNullOrWhiteSpace(References))
{
References = "None";
}
Question_or_Requirement_Id = frameworkData.RequirementID;
RequirementTabData tabData = new RequirementTabData();
if (frameworkData.IsCustomQuestion)
{
tabData.Text = frameworkData.Question;
tabData.SupplementalInfo = FormatSupplementalInfo(frameworkData.SupplementalInfo);
if (String.IsNullOrWhiteSpace(tabData.SupplementalInfo))
{
tabData.SupplementalInfo = "None";
}
QuestionsVisible = false;
ShowRequirementStandards = false;
ShowSALLevel = false;
}
else
{
var requirement = controlContext.NEW_REQUIREMENT.Where(x => x.Requirement_Id == frameworkData.RequirementID).Select(t => new
{
Question_or_Requirement_Id = t.Requirement_Id,
Text = FormatRequirementText(t.Requirement_Text),
SupplementalInfo = FormatSupplementalInfo(t.Supplemental_Info),
Questions = t.NEW_QUESTIONs().Select(s => new RelatedQuestion
{
QuestionID = s.Question_Id,
QuestionText = s.Simple_Question
}),
LevelName = t.REQUIREMENT_LEVELS.Select(s => s.Standard_LevelNavigation).OrderBy(s => s.Level_Order).Select(s => s.Full_Name).FirstOrDefault()
}).FirstOrDefault();
if (requirement != null)
{
QuestionsList = requirement.Questions.ToList();
this.LevelName = requirement.LevelName;
tabData.RequirementID = requirement.Question_or_Requirement_Id;
tabData.Text = requirement.Text;
tabData.SupplementalInfo = FormatSupplementalInfo(requirement.SupplementalInfo);
QuestionsVisible = false;
ShowSALLevel = true;
BuildDocuments(frameworkData.RequirementID, controlContext);
SetFrameworkQuestions(frameworkData.RequirementID, controlContext);
}
}
RequirementsData = tabData;
}
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);
}
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);
}
