/// <summary>
///
/// </summary>
/// <param name="changePass"></param>
/// <returns></returns>
public async Task<bool> ChangePassword(ChangePassword changePass)
{
try
{
var user = db.USERS.Where(x => x.PrimaryEmail == changePass.PrimaryEmail).FirstOrDefault();
var info = db.USER_DETAIL_INFORMATION.Where(x => x.PrimaryEmail == user.PrimaryEmail).FirstOrDefault();
//if(!PasswordHash.ValidatePassword(changePass.CurrentPassword, user.Password, user.Salt))
//{
// return false;
//}
string hash;
string salt;
PasswordHash.HashPassword(changePass.NewPassword, out hash, out salt);
user.Password = hash;
user.Salt = salt;
user.PasswordResetRequired = false;
await db.SaveChangesAsync();
return true;
}
catch (Exception e)
{
return false;
}
}
public async Task <IHttpActionResult> GetType([FromUri] String newType)
{
try
{
int asssessmentId = Auth.AssessmentForUser();
STANDARD_SELECTION sTANDARD_SELECTION = await db.STANDARD_SELECTION.FindAsync(asssessmentId);
if (sTANDARD_SELECTION != null)
{
sTANDARD_SELECTION.Last_Sal_Determination_Type = newType;
await db.SaveChangesAsync();
}
return(Ok());
}
catch (Exception e)
{
return((IHttpActionResult)CSETWeb_Api.Helpers.ElmahWrapper.LogAndReportException(e, Request, HttpContext.Current));
}
}
public async Task <IHttpActionResult> DeleteGENERAL_SAL(int id)
{
GENERAL_SAL gENERAL_SAL = await db.GENERAL_SAL.FindAsync(id);
if (gENERAL_SAL == null)
{
return(NotFound());
}
db.GENERAL_SAL.Remove(gENERAL_SAL);
await db.SaveChangesAsync();
return(Ok(gENERAL_SAL));
}
/// <summary>
/// Sets the contact's 'invited' flag to 'true', if the contact exists on the Assessment.
/// </summary>
/// <param name="email"></param>
/// <param name="assessmentId"></param>
public void MarkContactInvited(int userId, int assessmentId)
{
using (var db = new CSET_Context())
{
var assessmentContact = db.ASSESSMENT_CONTACTS.Where(ac => ac.UserId == userId && ac.Assessment_Id == assessmentId)
.FirstOrDefault();
if (assessmentContact != null)
{
assessmentContact.Invited = true;
db.ASSESSMENT_CONTACTS.AddOrUpdate(assessmentContact, x => x.Assessment_Contact_Id);
db.SaveChangesAsync();
}
}
}
public async Task <HttpResponseMessage> PostChangePassword([FromBody] ChangePassword changePass)
{
try
{
if (!ModelState.IsValid)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "Invalid Model State"));
}
if (!emailvalidator.IsMatch(changePass.PrimaryEmail.Trim()))
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "Invalid PrimaryEmail"));
}
Login login = new Login()
{
Email = changePass.PrimaryEmail,
Password = changePass.CurrentPassword
};
LoginResponse resp = UserAuthentication.Authenticate(login);
if (resp == null)
{
return(Request.CreateResponse(HttpStatusCode.Conflict, "Current password is invalid. Try again or request a new temporary password."));
}
UserAccountSecurityManager resetter = new UserAccountSecurityManager();
bool rval = await resetter.ChangePassword(changePass);
if (rval)
{
resp.PasswordResetRequired = false;
await db.SaveChangesAsync();
return(Request.CreateResponse(HttpStatusCode.OK, "Created Successfully"));
}
else
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, "Unknown error"));
}
}
catch (CSETApplicationException ce)
{
return(Request.CreateResponse(HttpStatusCode.Conflict, ce.Message));
}
catch (Exception e)
{
return(CSETWeb_Api.Helpers.ElmahWrapper.LogAndReportException(e, Request, HttpContext.Current));
}
}
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));
}
}
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
{
}
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(), 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, context);
//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;
}
}
}
}
public async Task <HttpResponseMessage> Post()
{
try
{
// Check if the request contains multipart/form-data.
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
var provider = new InMemoryMultipartFormDataStreamProvider();
await Request.Content.ReadAsMultipartAsync <InMemoryMultipartFormDataStreamProvider>(provider);
//access form data
var formData = provider.FormData;
var file = provider.Files.First();
var serializer = new JavaScriptSerializer();
var expando = new ExpandoObject();
foreach (var item in formData.AllKeys)
{
((IDictionary <string, object>)expando)[item] = formData[item];
}
var formDocument = serializer.ConvertToType <ExternalDocument>(expando);
formDocument.Data = await file.ReadAsByteArrayAsync();
formDocument.FileSize = file.Headers.ContentLength;
formDocument.FileName = UnquoteToken(file.Headers.ContentDisposition.FileName);
var genFile = formDocument.ToGenFile();
var extension = Path.GetExtension(genFile.File_Name).Substring(1);
var response = Request.CreateResponse(HttpStatusCode.OK);
using (CSET_Context db = new CSET_Context())
{
var existingFiles = db.GEN_FILE.Where(s => s.File_Name == genFile.File_Name && (s.Is_Uploaded ?? false)).ToList();
if (existingFiles.Any(s => s.Doc_Num == genFile.Doc_Num))
{
var existingFile = existingFiles.FirstOrDefault(s => s.Doc_Num == genFile.Doc_Num);
existingFile.Data = genFile.Data;
await db.SaveChangesAsync();
return(response);
}
else if (existingFiles.Any())
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, new Exception("Document could not be added. Please change the file name and try again")));
}
genFile.File_Type_ = db.FILE_TYPE.Where(s => s.File_Type1 == extension).FirstOrDefault();
try
{
db.FILE_REF_KEYS.Add(new FILE_REF_KEYS {
Doc_Num = genFile.Doc_Num
});
await db.SaveChangesAsync();
}
catch
{
}
db.GEN_FILE.Add(genFile);
await db.SaveChangesAsync();
}
return(response);
}
catch (Exception e)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e));
}
}
public static async Task <ConverterResult <NEW_REQUIREMENT> > ToRequirement(this IExternalRequirement externalRequirement, string setName, 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
}
};
//newRequirement.NEW_QUESTION = new List<NEW_QUESTION>();
QUESTION_GROUP_HEADING questionGroupHeading = null;
UNIVERSAL_SUB_CATEGORY_HEADINGS subcategory = null;
using (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);
await db.SaveChangesAsync();
subcatId = subcat.Universal_Sub_Category_Id;
}
try
{
subcategory = db.UNIVERSAL_SUB_CATEGORY_HEADINGS.FirstOrDefault(s => (s.Universal_Sub_Category_Id == subcatId) && (s.Question_Group_Heading_Id == questionGroupHeading.Question_Group_Heading_Id));
if (subcategory == null)
{
subcategory = new UNIVERSAL_SUB_CATEGORY_HEADINGS()
{
Universal_Sub_Category_Id = subcatId, Question_Group_Heading_Id = questionGroupHeading.Question_Group_Heading_Id
};
db.UNIVERSAL_SUB_CATEGORY_HEADINGS.Add(subcategory);
await db.SaveChangesAsync();
}
}
catch
{
}
}
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 (subcategory == 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;
using (var db = new CSET_Context())
{
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;
}
}
foreach (var sal in Enum.GetValues(typeof(SalValues)).Cast <SalValues>().ToList())
{
try
{
if ((int)sal >= (externalRequirement.SecurityAssuranceLevel ?? 0))
{
var rl = new REQUIREMENT_LEVELS()
{
Standard_Level = sal.ToString(),
Level_Type = "NST"
};
newRequirement.REQUIREMENT_LEVELS.Add(rl);
}
}
catch
{
result.LogError(String.Format("An error occurred while adding SALs for requirement {0} {1}.", externalRequirement.Identifier, externalRequirement.Text));
}
}
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));
}
if (externalRequirement.Questions == null || externalRequirement.Questions.Count() == 0)
{
externalRequirement.Questions = new QuestionList()
{
externalRequirement.Text
};
}
foreach (var question in externalRequirement.Questions)
{
NEW_QUESTION newQuestion = null;
var set = new NEW_QUESTION_SETS()
{
Set_Name = setName, NEW_QUESTION_LEVELS = new List <NEW_QUESTION_LEVELS>()
};
using (var db = new CSET_Context())
{
newQuestion = db.NEW_QUESTION.FirstOrDefault(s => s.Simple_Question.ToLower().Trim() == question.ToLower().Trim());
if (newQuestion != null)
{
db.Entry(newQuestion).State = EntityState.Detached;
}
}
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 = ((SalValues)(externalRequirement.SecurityAssuranceLevel ?? (int)SalValues.L)).ToString();
newQuestion.Std_Ref = setName.Replace("_", "");
newQuestion.Std_Ref = newQuestion.Std_Ref.Substring(0, Math.Min(newQuestion.Std_Ref.Length, 50));
newQuestion.Heading_Pair_Id = subcategory.Heading_Pair_Id;
}
catch
{
result.LogError(String.Format("Question {0} could not be added for requirement {1} {2}.", question, externalRequirement.Identifier, externalRequirement.Text));
}
}
foreach (var sal in Enum.GetValues(typeof(SalValues)).Cast <SalValues>().ToList())
{
try
{
if ((int)sal >= (externalRequirement.SecurityAssuranceLevel ?? 0))
{
var rl = new NEW_QUESTION_LEVELS()
{
Universal_Sal_Level = sal.ToString(),
};
set.NEW_QUESTION_LEVELS.Add(rl);
}
}
catch
{
result.LogError(String.Format("An error occurred while adding SALs for requirement {1} {2}.", externalRequirement.Source?.FileName, externalRequirement.Identifier, externalRequirement.Text));
}
}
newQuestion.NEW_QUESTION_SETS = new List <NEW_QUESTION_SETS>();
newQuestion.REQUIREMENT_QUESTIONS_SETS = new List <REQUIREMENT_QUESTIONS_SETS>();
newQuestion.NEW_QUESTION_SETS.Add(set);
newQuestion.REQUIREMENT_QUESTIONS_SETS.Add(new REQUIREMENT_QUESTIONS_SETS {
Set_Name = setName, Requirement_ = newRequirement
});
using (CSET_Context db = new CSET_Context())
{
db.NEW_QUESTION.Add(newQuestion);
}
}
return(result);
}
public async Task ProcessCSETAssessmentImport(byte[] zipFileFromDatabase, int currentUserId)
{
using (CSET_Context web = 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);
UploadAssessmentModel model = (UploadAssessmentModel)JsonConvert.DeserializeObject(jsonObject, new UploadAssessmentModel().GetType());
foreach (var doc in model.CustomStandardDocs)
{
var genFile = web.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_ = web.FILE_TYPE.Where(s => s.File_Type1 == extension).FirstOrDefault();
try
{
web.FILE_REF_KEYS.Add(new FILE_REF_KEYS {
Doc_Num = genFile.Doc_Num
});
await web.SaveChangesAsync();
}
catch
{
}
web.GEN_FILE.Add(genFile);
web.SaveChanges();
}
}
foreach (var standard in model.CustomStandards)
{
var sets = web.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(), 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)
{
web.SETS.Add(setResult.Result);
foreach (var question in setResult.Result.NEW_REQUIREMENT.SelectMany(s => s.NEW_QUESTIONs()).Where(s => s.Question_Id != 0).ToList())
{
web.Entry(question).State = EntityState.Unchanged;
}
try
{
await web.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 = web.USERS.Where(x => x.UserId == currentUserId).First().PrimaryEmail;
Importer import = new Importer();
Tuple <int, Dictionary <int, DOCUMENT_FILE> > t = import.RunImport(model, currentUserId, email, web);
Dictionary <int, DOCUMENT_FILE> oldIdToNewDocument = t.Item2;
foreach (jDOCUMENT_FILE d in model.jDOCUMENT_FILE)
{
DOCUMENT_FILE docDB = oldIdToNewDocument[d.Document_Id];
string newPath = Path.GetFileName(d.Path);// getPath(d.Path);
ZipArchiveEntry entry = zip.GetEntry(newPath);
if (entry == null)
{
entry = zip.GetEntry(d.Path);
}
if (entry != null)
{
SaveFileToDB(entry, docDB);
}
web.SaveChanges();
}
}
}
}
