public Task <HttpResponseMessage> Import([FromBody] ExternalStandard externalStandard)
{
CsetLogManager.Instance.LogInfoMessage("SetsController.Import() - \n{0}", JsonConvert.SerializeObject(externalStandard));
var response = default(HttpResponseMessage);
try
{
if (ModelState.IsValid)
{
var id = BackgroundJob.Enqueue(() => HangfireExecutor.SaveImport(externalStandard, null));
response = Request.CreateResponse(new { id });
}
else
{
response = Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
}
catch (Exception ex)
{
response = Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex.Message);
}
return(Task.FromResult(response));
}
public static async Task SaveImport(ExternalStandard externalStandard, PerformContext context)
{
var logger = new HangfireLogger(context);
var result = await externalStandard.ToSet(logger);
if (result.IsSuccess)
{
try
{
using (var db = new CSET_Context())
{
db.SETS.Add(result.Result);
foreach (var question in result.Result.NEW_REQUIREMENT.SelectMany(s => s.NEW_QUESTIONs()).Where(s => s.Question_Id != 0).ToList())
{
db.Entry(question).State = EntityState.Unchanged;
}
await db.SaveChangesAsync();
}
}
//catch (DbEntityValidationException e)
//{
// foreach(var error in e.EntityValidationErrors)
// {
// foreach(var validationError in error.ValidationErrors)
// {
// result.LogError(validationError.ErrorMessage);
// }
// }
// throw new Exception(String.Join("\r\n", result.ErrorMessages));
//}
catch (SqlException e)
{
result.LogError(e.Message);
}
catch (Exception e)
{
logger.Log("An error was encountered when adding the module to the database. Please try again");
throw e;
}
}
else
{
throw new Exception(String.Join("\r\n", result.ErrorMessages));
}
}
/// <summary>
/// Import new standards into CSET
/// </summary>
public async Task <HttpResponseMessage> Post([FromBody] ExternalStandard externalStandard)
{
return(await Task.Run(() =>
{
try
{
if (ModelState.IsValid)
{
var id = BackgroundJob.Enqueue(() => HangfireExecutor.SaveImport(externalStandard, null));
return Request.CreateResponse(new { id });
}
else
{
return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
}
catch (Exception)
{
return Request.CreateResponse();
}
}));
}
public Task <HttpResponseMessage> Import([FromBody] ExternalStandard externalStandard)
{
var response = default(HttpResponseMessage);
try
{
if (ModelState.IsValid)
{
var id = BackgroundJob.Enqueue(() => HangfireExecutor.SaveImport(externalStandard, null));
response = Request.CreateResponse(new { id });
}
else
{
response = Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
}
catch (Exception ex)
{
response = Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex.Message);
}
return(Task.FromResult(response));
}
public static ExternalStandard ToExternalStandard(this SETS standard)
{
var externalStandard = new ExternalStandard();
externalStandard.ShortName = standard.Short_Name;
externalStandard.Name = standard.Full_Name;
externalStandard.Summary = standard.Standard_ToolTip;
externalStandard.Category = standard.Set_Category_.Set_Category_Name;
var requirements = new List <ExternalRequirement>();
//Caching for performance
using (var db = new CSET_Context())
{
//db.Configuration.ProxyCreationEnabled = false;
//db.Configuration.AutoDetectChangesEnabled = false;
//db.Configuration.LazyLoadingEnabled = false;
var reqs = standard.NEW_REQUIREMENT.ToList();
Dictionary <int, List <QuestionAndHeading> > reqQuestions = reqs.Select(s => new { s.Requirement_Id, Questions = s.NEW_QUESTIONs().Select(t =>
new QuestionAndHeading()
{
Simple_Question = t.Simple_Question, Heading_Pair_Id = t.Heading_Pair_Id
}) })
.ToDictionary(s => s.Requirement_Id, s => s.Questions.ToList());
var reqHeadingIds = reqs.Select(s => s.Question_Group_Heading_Id).ToList();
//var questionHeadings = from a in db.REQUIREMENT_QUESTIONS
// join b in db.new on a.Question_Id equals b.Question_Id
// join c in db.NEW_QUESTION_SETS on b.Question_Id equals c.Question_Id
// where c.Set_Name == standard.Set_Name
// select b.question_group_heading_id
var questionHeadings = reqQuestions.SelectMany(s => s.Value.Select(t => t.Heading_Pair_Id)).Distinct().ToList();
var reqHeadings = db.QUESTION_GROUP_HEADING.Where(s => reqHeadingIds.Contains(s.Question_Group_Heading_Id)).ToDictionary(s => s.Question_Group_Heading_Id, s => s.Question_Group_Heading1);
var headingPairs = db.UNIVERSAL_SUB_CATEGORY_HEADINGS.Where(s => questionHeadings.Contains(s.Heading_Pair_Id));
var subcategories = headingPairs.Join(db.UNIVERSAL_SUB_CATEGORIES, s => s.Universal_Sub_Category_Id, s => s.Universal_Sub_Category_Id, (s, t) => new { s.Heading_Pair_Id, category = t })
.ToDictionary(s => s.Heading_Pair_Id, s => s.category.Universal_Sub_Category);
var headings = headingPairs.Join(db.QUESTION_GROUP_HEADING, s => s.Question_Group_Heading_Id, s => s.Question_Group_Heading_Id, (s, t) => new { s.Heading_Pair_Id, category = t })
.ToDictionary(s => s.Heading_Pair_Id, s => s.category.Question_Group_Heading1);
var reqReferences = reqs.Select(s => new
{
s.Requirement_Id,
Resources = s.REQUIREMENT_REFERENCES.Select(t =>
new ExternalResource
{
Destination = t.Destination_String,
FileName = t.Gen_File_.File_Name,
PageNumber = t.Page_Number,
SectionReference = t.Section_Ref
})
}).ToDictionary(t => t.Requirement_Id, t => t.Resources);
var reqSource = reqs.Select(s => new
{
s.Requirement_Id,
Resource = s.REQUIREMENT_SOURCE_FILES.Select(t =>
new ExternalResource
{
Destination = t.Destination_String,
FileName = t.Gen_File_.File_Name,
PageNumber = t.Page_Number,
SectionReference = t.Section_Ref
}).FirstOrDefault()
}).ToDictionary(t => t.Requirement_Id, t => t.Resource);
var reqLevels = new Dictionary <int, int?>();
var tempLevels = reqs.Select(s => new { s.Requirement_Id, levels = s.REQUIREMENT_LEVELS.Select(t => t.Standard_Level) }).ToList();
if (tempLevels.Any())
{
reqLevels = tempLevels.ToDictionary(s => s.Requirement_Id, s => ((s.levels != null && s.levels.Any()) ? s.levels?.Min(t =>
{
SalValues val;
if (Enum.TryParse(t, out val))
{
return((int)val);
}
else
{
return(1);
}
}) : 1));
}
foreach (var requirement in reqs)
{
var externalRequirement = new ExternalRequirement()
{
Identifier = requirement.Requirement_Title,
Text = requirement.Requirement_Text,
Category = requirement.Standard_Category,
Weight = requirement.Weight,
Subcategory = requirement.Standard_Sub_Category,
Supplemental = requirement.Supplemental_Info
};
var headingPairId = reqQuestions[requirement.Requirement_Id].Select(s => s.Heading_Pair_Id).FirstOrDefault(s => s != 0);
// References
var references = externalRequirement.References;
reqReferences.TryGetValue(requirement.Requirement_Id, out references);
externalRequirement.References = references.ToList();
// Heading
string heading = null;
headings.TryGetValue(headingPairId, out heading);
if (String.IsNullOrEmpty(heading))
{
reqHeadings.TryGetValue(requirement.Question_Group_Heading_Id, out heading);
}
if (String.IsNullOrEmpty(heading))
{
throw new Exception("Heading is not valid");
}
externalRequirement.Heading = heading;
// Questions
List <QuestionAndHeading> questions = new List <QuestionAndHeading>();
reqQuestions.TryGetValue(requirement.Requirement_Id, out questions);
externalRequirement.Questions = new QuestionList();
foreach (QuestionAndHeading h in questions)
{
externalRequirement.Questions.Add(h.Simple_Question);
}
// Subheading
string subheading = null;
subcategories.TryGetValue(headingPairId, out subheading);
if (subheading == null)
{
subheading = heading;
}
externalRequirement.Subheading = subheading;
// Source
var source = externalRequirement.Source;
reqSource.TryGetValue(requirement.Requirement_Id, out source);
externalRequirement.Source = source;
// SAL
int?sal;
reqLevels.TryGetValue(requirement.Requirement_Id, out sal);
externalRequirement.SecurityAssuranceLevel = sal;
requirements.Add(externalRequirement);
}
externalStandard.Requirements = requirements;
}
return(externalStandard);
}
