public async Task ProcessCSETAssessmentImport(byte[] zipFileFromDatabase, int currentUserId)
{
using (CSET_Context context = new CSET_Context())
{
//* read from db and set as memory stream here.
using (Stream fs = new MemoryStream(zipFileFromDatabase))
{
ZipArchive zip = new ZipArchive(fs);
StreamReader r = new StreamReader(zip.GetEntry("model.json").Open());
string jsonObject = r.ReadToEnd();
// Apply any data updates to older versions
ImportUpgradeManager upgrader = new ImportUpgradeManager();
jsonObject = upgrader.Upgrade(jsonObject);
try
{
UploadAssessmentModel model = (UploadAssessmentModel)JsonConvert.DeserializeObject(jsonObject, new UploadAssessmentModel().GetType());
foreach (var doc in model.CustomStandardDocs)
{
var genFile = context.GEN_FILE.FirstOrDefault(s => s.File_Name == doc);
if (genFile == null)
{
StreamReader docReader = new StreamReader(zip.GetEntry(doc + ".json").Open());
var docModel = JsonConvert.DeserializeObject <ExternalDocument>(docReader.ReadToEnd());
genFile = docModel.ToGenFile();
var extension = Path.GetExtension(genFile.File_Name).Substring(1);
genFile.File_Type_ = context.FILE_TYPE.Where(s => s.File_Type1 == extension).FirstOrDefault();
try
{
context.FILE_REF_KEYS.Add(new FILE_REF_KEYS {
Doc_Num = genFile.Doc_Num
});
await context.SaveChangesAsync();
}
catch (Exception e)
{
throw e;
}
context.GEN_FILE.Add(genFile);
context.SaveChanges();
}
}
foreach (var standard in model.CustomStandards)
{
var sets = context.SETS.Where(s => s.Set_Name.Contains(standard)).ToList();
SETS set = null;
StreamReader setReader = new StreamReader(zip.GetEntry(standard + ".json").Open());
var setJson = setReader.ReadToEnd();
var setModel = JsonConvert.DeserializeObject <ExternalStandard>(setJson);
var originalSetName = setModel.ShortName;
foreach (var testSet in sets)
{
setModel.ShortName = testSet.Short_Name;
var testSetJson = JsonConvert.SerializeObject(testSet.ToExternalStandard(), Newtonsoft.Json.Formatting.Indented);
if (testSetJson == setJson)
{
set = testSet;
break;
}
else
{
setModel.ShortName = originalSetName;
}
}
if (set == null)
{
int incr = 1;
while (sets.Any(s => s.Short_Name == setModel.ShortName))
{
setModel.ShortName = originalSetName + " " + incr;
incr++;
}
var setResult = await setModel.ToSet();
if (setResult.IsSuccess)
{
context.SETS.Add(setResult.Result);
foreach (var question in setResult.Result.NEW_REQUIREMENT.SelectMany(s => s.NEW_QUESTIONs()).Where(s => s.Question_Id != 0).ToList())
{
context.Entry(question).State = EntityState.Unchanged;
}
try
{
await context.SaveChangesAsync();
}
catch (Exception e)
{
throw (e);
}
//Set the GUID at time of export so we are sure it's right!!!
model.jANSWER = model.jANSWER.Where(s => s.Is_Requirement).GroupJoin(setResult.Result.NEW_REQUIREMENT, s => s.Custom_Question_Guid, req => new Guid(new MD5CryptoServiceProvider().ComputeHash(Encoding.Default.GetBytes(originalSetName + "|||" + req.Requirement_Title + "|||" + req.Requirement_Text))).ToString(), (erea, s) =>
{
var req = s.FirstOrDefault();
if (req != null)
{
erea.Question_Or_Requirement_Id = req.Requirement_Id;
}
return(erea);
}).Concat(model.jANSWER.Where(s => !s.Is_Requirement).GroupJoin(setResult.Result.NEW_QUESTION, s => s.Custom_Question_Guid, req => new Guid(new MD5CryptoServiceProvider().ComputeHash(Encoding.Default.GetBytes(req.Simple_Question))).ToString(), (erer, s) =>
{
var req = s.FirstOrDefault();
if (req != null)
{
erer.Question_Or_Requirement_Id = req.Question_Id;
}
return(erer);
})).ToList();
}
}
foreach (var availableStandard in model.jAVAILABLE_STANDARDS.Where(s => s.Set_Name == Regex.Replace(originalSetName, @"\W", "_") && s.Selected))
{
availableStandard.Set_Name = Regex.Replace(setModel.ShortName, @"\W", "_");
}
}
string email = context.USERS.Where(x => x.UserId == currentUserId).First().PrimaryEmail;
Importer import = new Importer();
int newAssessmentId = import.RunImportManualPortion(model, currentUserId, email, context);
import.RunImportAutomatic(newAssessmentId, jsonObject);
// Save the diagram
var assessment = context.ASSESSMENTS.Where(x => x.Assessment_Id == newAssessmentId).FirstOrDefault();
if (!string.IsNullOrEmpty(assessment.Diagram_Markup))
{
var diagramManager = new DiagramManager(context);
var diagReq = new DiagramRequest()
{
DiagramXml = assessment.Diagram_Markup,
AnalyzeDiagram = false,
revision = false
};
var xDocDiagram = new XmlDocument();
xDocDiagram.LoadXml(assessment.Diagram_Markup);
diagramManager.SaveDiagram(newAssessmentId, xDocDiagram, diagReq);
}
// Clean up any imported standards that are unselected or deprecated
var unselectedStandards = context.AVAILABLE_STANDARDS.Where(x => x.Assessment_Id == newAssessmentId && !x.Selected).ToList();
context.AVAILABLE_STANDARDS.RemoveRange(unselectedStandards);
var deprecatedStandards = from av in context.AVAILABLE_STANDARDS
join set in context.SETS on av.Set_Name equals set.Set_Name
where set.Is_Deprecated
select av;
context.AVAILABLE_STANDARDS.RemoveRange(deprecatedStandards.ToList());
context.SaveChanges();
//NOTE THAT THIS ENTRY WILL ONLY COME FROM A OLD .cset file
//IMPORT
ZipArchiveEntry importLegacyDiagram = zip.GetEntry("Diagram.csetd");
if (importLegacyDiagram != null)
{
StreamReader ldr = new StreamReader(importLegacyDiagram.Open());
string oldXml = ldr.ReadToEnd();
DiagramManager dm = new DiagramManager(context);
dm.ImportOldCSETDFile(oldXml, newAssessmentId);
}
}
catch (Exception e)
{
throw e;
}
}
}
}
private UploadAssessmentModel CopyForExport(int assessmentId)
{
var assessmentDate = DateTime.MinValue;
var model = new UploadAssessmentModel();
foreach (var item in context.ASSESSMENTS.Where(x => x.Assessment_Id == assessmentId))
{
model.jASSESSMENTS.Add(TinyMapper.Map <ASSESSMENTS, jASSESSMENTS>(item));
assessmentDate = item.Assessment_Date;
}
foreach (var item in context.ASSESSMENT_CONTACTS.Where(x => x.Assessment_Id == assessmentId))
{
model.jASSESSMENT_CONTACTS.Add(TinyMapper.Map <ASSESSMENT_CONTACTS, jASSESSMENT_CONTACTS>(item));
}
foreach (var item in context.ANSWER
.Include(x => x.FINDING)
.ThenInclude(x => x.FINDING_CONTACT)
.Where(x => x.Assessment_Id == assessmentId))
{
model.jANSWER.Add(TinyMapper.Map <ANSWER, jANSWER>(item));
foreach (var f in item.FINDING)
{
model.jFINDING.Add(TinyMapper.Map <FINDING, jFINDING>(f));
foreach (var fc in f.FINDING_CONTACT)
{
model.jFINDING_CONTACT.Add(TinyMapper.Map <FINDING_CONTACT, jFINDING_CONTACT>(fc));
}
}
}
foreach (var item in context.ASSESSMENT_SELECTED_LEVELS.Where(x => x.Assessment_Id == assessmentId))
{
model.jASSESSMENT_SELECTED_LEVELS.Add(TinyMapper.Map <ASSESSMENT_SELECTED_LEVELS, jASSESSMENT_SELECTED_LEVELS>(item));
}
foreach (var item in context.AVAILABLE_STANDARDS.Where(x => x.Assessment_Id == assessmentId))
{
model.jAVAILABLE_STANDARDS.Add(TinyMapper.Map <AVAILABLE_STANDARDS, jAVAILABLE_STANDARDS>(item));
}
foreach (var item in context.CNSS_CIA_JUSTIFICATIONS.Where(x => x.Assessment_Id == assessmentId))
{
model.jCNSS_CIA_JUSTIFICATIONS.Add(TinyMapper.Map <CNSS_CIA_JUSTIFICATIONS, jCNSS_CIA_JUSTIFICATIONS>(item));
}
foreach (var item in context.CSET_VERSION)
{
model.jCSET_VERSION.Add(TinyMapper.Map <CSET_VERSION, jCSET_VERSION>(item));
}
foreach (var item in context.CUSTOM_BASE_STANDARDS)
{
model.jCUSTOM_BASE_STANDARDS.Add(TinyMapper.Map <CUSTOM_BASE_STANDARDS, jCUSTOM_BASE_STANDARDS>(item));
}
foreach (var item in context.CUSTOM_QUESTIONAIRES)
{
model.jCUSTOM_QUESTIONAIRES.Add(TinyMapper.Map <CUSTOM_QUESTIONAIRES, jCUSTOM_QUESTIONAIRES>(item));
}
foreach (var item in context.CUSTOM_QUESTIONAIRE_QUESTIONS)
{
model.jCUSTOM_QUESTIONAIRE_QUESTIONS.Add(TinyMapper.Map <CUSTOM_QUESTIONAIRE_QUESTIONS, jCUSTOM_QUESTIONAIRE_QUESTIONS>(item));
}
foreach (var item in context.DEMOGRAPHICS.Where(x => x.Assessment_Id == assessmentId))
{
model.jDEMOGRAPHICS.Add(TinyMapper.Map <DEMOGRAPHICS, jDEMOGRAPHICS>(item));
}
foreach (var item in context.DOCUMENT_FILE.Include(x => x.DOCUMENT_ANSWERS).ThenInclude(x => x.Answer_).Where(x => x.Assessment_Id == assessmentId))
{
model.jDOCUMENT_FILE.Add(TinyMapper.Map <DOCUMENT_FILE, jDOCUMENT_FILE>(item));
foreach (var a in item.ANSWERs())
{
model.jDOCUMENT_ANSWERS.Add(new jDOCUMENT_ANSWERS()
{
Answer_Id = a.Answer_Id,
Document_Id = item.Document_Id
});
}
}
foreach (var item in context.FRAMEWORK_TIER_TYPE_ANSWER.Where(x => x.Assessment_Id == assessmentId))
{
model.jFRAMEWORK_TIER_TYPE_ANSWER.Add(TinyMapper.Map <FRAMEWORK_TIER_TYPE_ANSWER, jFRAMEWORK_TIER_TYPE_ANSWER>(item));
}
foreach (var item in context.INFORMATION.Where(x => x.Id == assessmentId))
{
var oInfo = TinyMapper.Map <INFORMATION, jINFORMATION>(item);
oInfo.Assessment_Date = assessmentDate;
model.jINFORMATION.Add(oInfo);
}
foreach (var item in context.NIST_SAL_INFO_TYPES.Where(x => x.Selected == true && x.Assessment_Id == assessmentId))
{
model.jNIST_SAL_INFO_TYPES.Add(TinyMapper.Map <NIST_SAL_INFO_TYPES, jNIST_SAL_INFO_TYPES>(item));
}
foreach (var item in context.NIST_SAL_QUESTION_ANSWERS.Where(x => x.Assessment_Id == assessmentId))
{
model.jNIST_SAL_QUESTION_ANSWERS.Add(TinyMapper.Map <NIST_SAL_QUESTION_ANSWERS, jNIST_SAL_QUESTION_ANSWERS>(item));
}
var parameterslist = from a in context.ASSESSMENTS
join an in context.ANSWER on a.Assessment_Id equals an.Assessment_Id
join p in context.PARAMETER_VALUES on an.Answer_Id equals p.Answer_Id
where a.Assessment_Id == assessmentId
select p;
foreach (var item in parameterslist.Where(x => x.Parameter_Is_Default == false))
{
model.jPARAMETER_VALUES.Add(TinyMapper.Map <PARAMETER_VALUES, jPARAMETER_VALUES>(item));
}
foreach (var item in context.PARAMETER_ASSESSMENT.Where(x => x.Assessment_ID == assessmentId))
{
model.jPARAMETER_ASSESSMENTs.Add(TinyMapper.Map <PARAMETER_ASSESSMENT, jPARAMETER_ASSESSMENT>(item));
}
foreach (var item in context.STANDARD_SELECTION.Where(x => x.Assessment_Id == assessmentId))
{
model.jSTANDARD_SELECTION.Add(TinyMapper.Map <STANDARD_SELECTION, jSTANDARD_SELECTION>(item));
}
foreach (var item in context.GENERAL_SAL.Where(x => x.Assessment_Id == assessmentId))
{
model.jGENERAL_SAL.Add(TinyMapper.Map <GENERAL_SAL, jGENERAL_SAL>(item));
}
foreach (var item in context.SUB_CATEGORY_ANSWERS.Where(x => x.Assessement_Id == assessmentId))
{
model.jSUB_CATEGORY_ANSWERS.Add(TinyMapper.Map <SUB_CATEGORY_ANSWERS, jSUB_CATEGORY_ANSWERS>(item));
}
// NCUA data
foreach (var item in context.FINANCIAL_HOURS.Where(x => x.Assessment_Id == assessmentId))
{
model.jFINANCIAL_HOURS.Add(TinyMapper.Map <FINANCIAL_HOURS, jFINANCIAL_HOURS>(item));
}
foreach (var item in context.FINANCIAL_ASSESSMENT_VALUES.Where(x => x.Assessment_Id == assessmentId))
{
model.jFINANCIAL_ASSESSMENT_VALUES.Add(TinyMapper.Map <FINANCIAL_ASSESSMENT_VALUES, jFINANCIAL_ASSESSMENT_VALUES>(item));
}
foreach (var item in context.ASSESSMENTS_REQUIRED_DOCUMENTATION.Where(x => x.Assessment_Id == assessmentId))
{
model.jASSESSMENTS_REQUIRED_DOCUMENTATION.Add(TinyMapper.Map <ASSESSMENTS_REQUIRED_DOCUMENTATION, jASSESSMENTS_REQUIRED_DOCUMENTATION>(item));
}
foreach (var item in context.ASSESSMENT_IRP_HEADER.Where(x => x.ASSESSMENT_ID == assessmentId))
{
model.jASSESSMENT_IRP_HEADER.Add(TinyMapper.Map <ASSESSMENT_IRP_HEADER, jASSESSMENT_IRP_HEADER>(item));
}
foreach (var item in context.ASSESSMENT_IRP.Where(x => x.Assessment_Id == assessmentId))
{
model.jASSESSMENT_IRP.Add(TinyMapper.Map <ASSESSMENT_IRP, jASSESSMENT_IRP>(item));
}
foreach (var item in context.ASSESSMENT_DIAGRAM_COMPONENTS.Where(x => x.Assessment_Id == assessmentId))
{
model.jASSESSMENT_DIAGRAM_COMPONENTS.Add(TinyMapper.Map <ASSESSMENT_DIAGRAM_COMPONENTS, jASSESSMENT_DIAGRAM_COMPONENTS>(item));
}
foreach (var item in context.DIAGRAM_CONTAINER.Where(x => x.Assessment_Id == assessmentId))
{
model.jDIAGRAM_CONTAINER.Add(TinyMapper.Map <DIAGRAM_CONTAINER, jDIAGRAM_CONTAINER>(item));
}
foreach (var item in context.AVAILABLE_MATURITY_MODELS.Where(x => x.Assessment_Id == assessmentId))
{
model.jAVAILABLE_MATURITY_MODELS.Add(TinyMapper.Map <AVAILABLE_MATURITY_MODELS, jAVAILABLE_MATURITY_MODELS>(item));
}
return(model);
}
/// <summary>
/// Populates a few principal assessment tables.
/// </summary>
/// <param name="model"></param>
/// <param name="currentUserId"></param>
/// <param name="primaryEmail"></param>
/// <param name="db"></param>
/// <returns></returns>
public int RunImportManualPortion(UploadAssessmentModel model,
int currentUserId, string primaryEmail, CSET_Context db)
{
//create the new assessment
//copy each of the items to the table
//as the copy occurs change to the current assessment_id
//update the answer id's
Dictionary <int, DOCUMENT_FILE> oldIdToNewDocument = new Dictionary <int, DOCUMENT_FILE>();
AssessmentManager man = new AssessmentManager();
AssessmentDetail detail = man.CreateNewAssessmentForImport(currentUserId);
int _assessmentId = detail.Id;
Dictionary <int, int> oldAnswerId = new Dictionary <int, int>();
Dictionary <int, ANSWER> oldIdNewAnswer = new Dictionary <int, ANSWER>();
Dictionary <string, int> oldUserNewUser = db.USERS.ToDictionary(x => x.PrimaryEmail, y => y.UserId);
foreach (var a in model.jASSESSMENTS)
{
var item = db.ASSESSMENTS.Where(x => x.Assessment_Id == _assessmentId).FirstOrDefault();
if (item != null)
{
item.Diagram_Markup = a.Diagram_Markup;
item.Diagram_Image = a.Diagram_Image;
item.Assets = a.Assets;
item.Charter = a.Charter;
item.CreditUnionName = a.CreditUnionName;
item.IRPTotalOverride = a.IRPTotalOverride;
item.IRPTotalOverrideReason = a.IRPTotalOverrideReason;
item.MatDetail_targetBandOnly = a.MatDetail_targetBandOnly != null ? a.MatDetail_targetBandOnly : false;
db.SaveChanges();
}
}
foreach (var a in model.jINFORMATION)
{
var item = db.ASSESSMENTS.Where(x => x.Assessment_Id == _assessmentId).FirstOrDefault();
if (item != null)
{
item.Assessment_Date = a.Assessment_Date;
db.SaveChanges();
}
}
// go through the assessment contacts and:
// - if the contact does exist create it then add the id
// - if the contact does exist update the id
var dictAC = new Dictionary <int, int>();
foreach (var a in model.jASSESSMENT_CONTACTS)
{
// Don't create another primary contact, but map its ID
if (a.PrimaryEmail == primaryEmail)
{
var newPrimaryContact = db.ASSESSMENT_CONTACTS.Where(x => x.PrimaryEmail == primaryEmail && x.Assessment_Id == _assessmentId).FirstOrDefault();
dictAC.Add(a.Assessment_Contact_Id, newPrimaryContact.Assessment_Contact_Id);
continue;
}
var item = TinyMapper.Map <ASSESSMENT_CONTACTS>(a);
item.Assessment_Id = _assessmentId;
item.PrimaryEmail = a.PrimaryEmail;
if (oldUserNewUser.TryGetValue(a.PrimaryEmail, out int userid))
{
item.UserId = userid;
}
else
{
item.UserId = null;
}
db.ASSESSMENT_CONTACTS.Add(item);
db.SaveChanges();
int newId;
if (a.Assessment_Contact_Id != 0)
{
if (dictAC.TryGetValue(a.Assessment_Contact_Id, out newId))
{
dictAC.Add(newId, newId);
a.Assessment_Contact_Id = newId;
}
else
{
dictAC.Add(a.Assessment_Contact_Id, item.Assessment_Contact_Id);
}
}
}
// map the primary keys so that they can be passed to the generic import logic
this.mapIdentity.Add("ASSESSMENT_CONTACTS", dictAC);
//
foreach (var a in model.jUSER_DETAIL_INFORMATION)
{
if (db.USER_DETAIL_INFORMATION.Where(x => x.Id == a.Id).FirstOrDefault() == null)
{
var userInfo = TinyMapper.Map <USER_DETAIL_INFORMATION>(a);
userInfo.FirstName = String.IsNullOrWhiteSpace(a.FirstName) ? "First Name" : a.FirstName;
userInfo.LastName = String.IsNullOrWhiteSpace(a.LastName) ? "Last Name" : a.LastName;
db.USER_DETAIL_INFORMATION.Add(userInfo);
foreach (var b in a.jADDRESSes)
{
var item = TinyMapper.Map <ADDRESS>(b);
item.AddressType = "Imported";
db.ADDRESS.Add(item);
}
db.SaveChanges();
}
}
return(_assessmentId);
}
/**
* Go through the list of tables
* for each table select out the rows and
* copy them to the corresponding json object
* push it across the wire, fix it on the other side.
*/
public UploadAssessmentModel CopyForExport(int _assessmentId)
{
var assessmentDate = DateTime.MinValue;
UploadAssessmentModel model = new UploadAssessmentModel();
foreach (var item in db.ASSESSMENTS.Where(x => x.Assessment_Id == _assessmentId))
{
model.jASSESSMENTS.Add(TinyMapper.Map <jASSESSMENTS>(item));
assessmentDate = item.Assessment_Date;
}
foreach (var item in db.ASSESSMENT_CONTACTS.Where(x => x.Assessment_Id == _assessmentId))
{
model.jASSESSMENT_CONTACTS.Add(TinyMapper.Map <jASSESSMENT_CONTACTS>(item));
}
foreach (var c in db.ANSWER.Include("FINDING").Where(x => x.Assessment_Id == _assessmentId))
{
model.jANSWER.Add(TinyMapper.Map <jANSWER>(c));
foreach (var f in c.FINDING)
{
model.jFINDING.Add(TinyMapper.Map <jFINDING>(f));
foreach (var fc in f.FINDING_CONTACT)
{
model.jFINDING_CONTACT.Add(TinyMapper.Map <jFINDING_CONTACT>(c));
}
}
}
foreach (var c in db.ASSESSMENT_SELECTED_LEVELS.Where(x => x.Assessment_Id == _assessmentId))
{
model.jASSESSMENT_SELECTED_LEVELS.Add(TinyMapper.Map <jASSESSMENT_SELECTED_LEVELS>(c));
}
foreach (var c in db.AVAILABLE_STANDARDS.Where(x => x.Assessment_Id == _assessmentId))
{
model.jAVAILABLE_STANDARDS.Add(TinyMapper.Map <jAVAILABLE_STANDARDS>(c));
}
foreach (var c in db.CNSS_CIA_JUSTIFICATIONS.Where(x => x.Assessment_Id == _assessmentId))
{
model.jCNSS_CIA_JUSTIFICATIONS.Add(TinyMapper.Map <jCNSS_CIA_JUSTIFICATIONS>(c));
}
foreach (var c in db.CSET_VERSION)
{
model.jCSET_VERSION.Add(TinyMapper.Map <jCSET_VERSION>(c));
}
foreach (var c in db.CUSTOM_BASE_STANDARDS)
{
model.jCUSTOM_BASE_STANDARDS.Add(TinyMapper.Map <jCUSTOM_BASE_STANDARDS>(c));
}
foreach (var c in db.CUSTOM_QUESTIONAIRES)
{
model.jCUSTOM_QUESTIONAIRES.Add(TinyMapper.Map <jCUSTOM_QUESTIONAIRES>(c));
}
foreach (var c in db.CUSTOM_QUESTIONAIRE_QUESTIONS)
{
model.jCUSTOM_QUESTIONAIRE_QUESTIONS.Add(TinyMapper.Map <jCUSTOM_QUESTIONAIRE_QUESTIONS>(c));
}
foreach (var c in db.DEMOGRAPHICS.Where(x => x.Assessment_Id == _assessmentId))
{
model.jDEMOGRAPHICS.Add(TinyMapper.Map <jDEMOGRAPHICS>(c));
}
foreach (var c in db.DOCUMENT_FILE.Include(x => x.DOCUMENT_ANSWERS).ThenInclude(x => x.Answer_).Where(x => x.Assessment_Id == _assessmentId))
{
model.jDOCUMENT_FILE.Add(TinyMapper.Map <jDOCUMENT_FILE>(c));
foreach (var a in c.ANSWERs())
{
model.jDOCUMENT_ANSWERS.Add(new jDOCUMENT_ANSWERS()
{
Answer_Id = a.Answer_Id,
Document_Id = c.Document_Id
});
}
}
foreach (var c in db.FRAMEWORK_TIER_TYPE_ANSWER.Where(x => x.Assessment_Id == _assessmentId))
{
model.jFRAMEWORK_TIER_TYPE_ANSWER.Add(TinyMapper.Map <jFRAMEWORK_TIER_TYPE_ANSWER>(c));
}
foreach (var c in db.INFORMATION.Where(x => x.Id == _assessmentId))
{
var oInfo = TinyMapper.Map <jINFORMATION>(c);
oInfo.Assessment_Date = assessmentDate;
model.jINFORMATION.Add(oInfo);
}
foreach (var c in db.NIST_SAL_INFO_TYPES.Where(x => x.Selected == true && x.Assessment_Id == _assessmentId))
{
model.jNIST_SAL_INFO_TYPES.Add(TinyMapper.Map <jNIST_SAL_INFO_TYPES>(c));
}
foreach (var c in db.NIST_SAL_QUESTIONS)
{
model.jNIST_SAL_QUESTION_ANSWERS.Add(TinyMapper.Map <jNIST_SAL_QUESTION_ANSWERS>(c));
}
var parameterslist = from a in db.ASSESSMENTS
join an in db.ANSWER on a.Assessment_Id equals an.Assessment_Id
join p in db.PARAMETER_VALUES on an.Answer_Id equals p.Answer_Id
where a.Assessment_Id == _assessmentId
select p;
foreach (var c in parameterslist.Where(x => x.Parameter_Is_Default == false))
{
model.jPARAMETER_VALUES.Add(TinyMapper.Map <jPARAMETER_VALUES>(c));
}
foreach (var c in db.PARAMETER_ASSESSMENT.Where(x => x.Assessment_ID == _assessmentId))
{
model.jPARAMETER_ASSESSMENTs.Add(TinyMapper.Map <jPARAMETER_ASSESSMENT>(c));
}
foreach (var c in db.STANDARD_SELECTION.Where(x => x.Assessment_Id == _assessmentId))
{
model.jSTANDARD_SELECTION.Add(TinyMapper.Map <jSTANDARD_SELECTION>(c));
}
foreach (var c in db.GENERAL_SAL.Where(x => x.Assessment_Id == _assessmentId))
{
model.jGENERAL_SAL.Add(TinyMapper.Map <jGENERAL_SAL>(c));
}
foreach (var c in db.SUB_CATEGORY_ANSWERS.Where(x => x.Assessement_Id == _assessmentId))
{
model.jSUB_CATEGORY_ANSWERS.Add(TinyMapper.Map <jSUB_CATEGORY_ANSWERS>(c));
}
// NCUA data
foreach (var c in db.FINANCIAL_HOURS.Where(x => x.Assessment_Id == _assessmentId))
{
model.jFINANCIAL_HOURS.Add(TinyMapper.Map <jFINANCIAL_HOURS>(c));
}
foreach (var c in db.FINANCIAL_ASSESSMENT_VALUES.Where(x => x.Assessment_Id == _assessmentId))
{
model.jFINANCIAL_ASSESSMENT_VALUES.Add(TinyMapper.Map <jFINANCIAL_ASSESSMENT_VALUES>(c));
}
foreach (var c in db.ASSESSMENTS_REQUIRED_DOCUMENTATION.Where(x => x.Assessment_Id == _assessmentId))
{
model.jASSESSMENTS_REQUIRED_DOCUMENTATION.Add(TinyMapper.Map <jASSESSMENTS_REQUIRED_DOCUMENTATION>(c));
}
foreach (var c in db.ASSESSMENT_IRP_HEADER.Where(x => x.Assessment_Id == _assessmentId))
{
model.jASSESSMENT_IRP_HEADER.Add(TinyMapper.Map <jASSESSMENT_IRP_HEADER>(c));
}
foreach (var c in db.ASSESSMENT_IRP.Where(x => x.Assessment_Id == _assessmentId))
{
model.jASSESSMENT_IRP.Add(TinyMapper.Map <jASSESSMENT_IRP>(c));
}
return(model);
}
