public override void HandleAutoTask()
{
LogManager.Instance.Write("Start CompanyOrder Handler ******************************************************");
using (var cache = new EntityCache <CompanyOrder, CHCContext>(p => p.Locked == true && p.IsBuildCompleted == false))
{
while (true)
{
LogManager.Instance.Write(cache.Results.Count().ToString());
var importExportService = new ImportExportService();
var companyOrderService = new CompanyOrderService(null, importExportService, null, null);
if (cache.Results.Count() > 0)
{
foreach (var order in cache.Results)
{
companyOrderService.ExportCompanyOrderForms(ConfigurationManager.AppSettings["CHCWebRootPath"], order);
using (var context = new CHCContext())
{
var entity = context.CompanyOrder.SingleOrDefault(e => e.Id == order.Id);
entity.Locked = true;
entity.IsBuildCompleted = true;
context.SaveChanges();
}
}
}
Thread.Sleep(5000);
}
}
}
/// <summary>
/// Import the workflow config from the json file
/// </summary>
public static void Config()
{
var service = new ImportExportService();
var model = ReadFromJsonFile <ImportExportModel>(@"Config.json");
service.Import(model);
}
/// <summary>
/// Expressions import call method
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void выраженияToolStripMenuItem_Click(object sender, EventArgs e)
{
ImportExportResult result = ImportExportService.importExpressions(dataGridView_expressions);
if (result.status.Equals(ImportExportResultStatus.Error))
{
richTextBox_log.AppendText(result.messageString + '\n');
MessageBox.Show(result.messageString, "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public AdminController(ProductCharacteristicService productCharacteristicService, ImageFileService fileService,
BrandService brandService, CategoryService categoryService, ProductService productService, ImportExportService importExportService)
{
_fileService = fileService;
_brandService = brandService;
_categoryService = categoryService;
_productService = productService;
_productCharacteristicService = productCharacteristicService;
_importExportService = importExportService;
}
/// <summary>
/// Results export call method
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void результатыОбработкиToolStripMenuItem_Click(object sender, EventArgs e)
{
ImportExportResult result = ImportExportService.exportResults(richTextBox_log);
switch (result.status)
{
case ImportExportResultStatus.Success:
MessageBox.Show(result.messageString, "Информация", MessageBoxButtons.OK, MessageBoxIcon.Information);
break;
case ImportExportResultStatus.Error:
MessageBox.Show(result.messageString, "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error);
break;
}
}
/// <summary>
/// Expressions export call method
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void выраженияToolStripMenuItem1_Click(object sender, EventArgs e)
{
ImportExportResult result = ImportExportService.exportExpressions(dataGridView_expressions);
switch (result.status)
{
case ImportExportResultStatus.Success:
MessageBox.Show(result.messageString, "Информация", MessageBoxButtons.OK, MessageBoxIcon.Information);
break;
case ImportExportResultStatus.Error:
MessageBox.Show(result.messageString, "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error);
break;
}
}
public void PredictMergedReferentials_Tests()
{
SampleData.ClearDatabaseThenImportDefaultProject();
// Exporter le projet
var service = new ImportExportService();
var mre = new System.Threading.ManualResetEvent(false);
Stream stream = null;
Exception e = null;
service.ExportProject(SampleData.GetProjectId(), d =>
{
stream = d;
mre.Set();
}, ex =>
{
e = ex;
mre.Set();
});
mre.WaitOne();
AssertExt.IsExceptionNull(e);
Assert.IsNotNull(stream);
stream.Position = 0;
byte[] importData;
using (var memoryStream = new MemoryStream()) { stream.CopyTo(memoryStream, StreamExtensions.BufferSize); importData = memoryStream.ToArray(); }
// PredictMergedReferentials
mre.Reset();
KProcess.Ksmed.Business.Dtos.Export.ProjectImport import = null;
service.PredictMergedReferentialsProject(importData, pi =>
{
import = pi;
mre.Set();
}, ex =>
{
e = ex;
mre.Set();
});
mre.WaitOne();
AssertExt.IsExceptionNull(e);
Assert.IsNotNull(import);
}
public void CanMapFromIni()
{
var data = LoadDataIni();
IDictionary map = data as IDictionary;
var io = new ImportExportService <Conference>();
var result = io.Load(map, "ini");
Assert.AreEqual(result.Item[0].Title, data.GetSection("post", 0).Get <string>("Title"));
Assert.AreEqual(result.Item[0].StartDate.Date, DateTime.Today.Date);
Assert.AreEqual(result.Item[0].StartTime, new TimeSpan(21, 30, 0));
Assert.AreEqual(result.Item[0].IsFree, true);
Assert.AreEqual(result.Item[0].MaxSeats, data.GetSection("post", 0).Get <int>("MaxSeats"));
Assert.AreEqual(result.Item[0].Cost, 250);
Assert.AreEqual(result.Item[0].Url, data.GetSection("post", 0).Get <string>("Url"));
Assert.AreEqual(result.Item[1].Title, data.GetSection("post", 1).Get <string>("Title"));
Assert.AreEqual(result.Item[1].StartDate.Date, DateTime.Today.AddDays(1).Date);
Assert.AreEqual(result.Item[1].StartTime, new TimeSpan(11, 30, 0));
Assert.AreEqual(result.Item[1].IsFree, false);
Assert.AreEqual(result.Item[1].MaxSeats, data.GetSection("post", 1).Get <int>("MaxSeats"));
Assert.AreEqual(result.Item[1].Cost, data.GetSection("post", 1).Get <double>("Cost"));
Assert.AreEqual(result.Item[1].Url, data.GetSection("post", 1).Get <string>("Url"));
}
public void CanMapFromCsv()
{
var csv = LoadDataCsv();
var io = new ImportExportService <Conference>();
CsvDoc data = new CsvDoc(csv, false);
var boolresult = io.LoadText(csv, "csv");
var result = boolresult.Item;
Assert.AreEqual(result[0].Title, data.Get <string>(0, "Title"));
Assert.AreEqual(result[0].StartDate.Date, DateTime.Today.Date);
Assert.AreEqual(result[0].StartTime, new TimeSpan(21, 30, 0));
Assert.AreEqual(result[0].IsFree, true);
Assert.AreEqual(result[0].MaxSeats, data.Get <int>(0, "MaxSeats"));
Assert.AreEqual(result[0].Cost, 250);
Assert.AreEqual(result[0].Url, data.Get <string>(0, "Url"));
Assert.AreEqual(result[1].Title, data.Get <string>(1, "Title"));
Assert.AreEqual(result[1].StartDate.Date, DateTime.Today.AddDays(4).Date);
Assert.AreEqual(result[1].StartTime, new TimeSpan(11, 30, 0));
Assert.AreEqual(result[1].IsFree, false);
Assert.AreEqual(result[1].MaxSeats, data.Get <int>(1, "MaxSeats"));
Assert.AreEqual(result[1].Cost, 251);
Assert.AreEqual(result[1].Url, data.Get <string>(1, "Url"));
}
public async Task ImportsAssignmentQuestions()
{
// Arrange
const string name = "assignment question";
var fileNames = new[] { "file1", "file2" };
var questionnaire = new Questionnaire
{
Revision = 1,
Name = name
};
var question1 = new AssignmentQuestion
{
Revision = 1,
Text = "AssignmentQuestion1",
Options = new List <AssignmentOption>
{
new AssignmentOption
{
Text = "AssignOpt1"
},
new AssignmentOption
{
Text = "AssignOpt2"
},
new AssignmentOption
{
Text = "AssignOpt3"
}
}
};
var q1Opts = question1.Options.ToList();
var q1Answers = (question1.Answers = new List <AssignmentAnswer>
{
new AssignmentAnswer
{
Text = "AssignAnswer1",
CorrectOption = question1.Options.First()
},
new AssignmentAnswer
{
Text = "AssignAnswer2",
CorrectOption = question1.Options.Skip(1).First()
},
new AssignmentAnswer
{
Text = "AssignAnswer3",
CorrectOption = question1.Options.Skip(2).First()
}
}).ToList();
var question2 = new AssignmentQuestion
{
Revision = 1,
Text = "AssignmentQuestion2",
Options = new List <AssignmentOption>
{
new AssignmentOption
{
Text = "AssignOpt21"
},
new AssignmentOption
{
Text = "AssignOpt23"
}
}
};
var q2Opts = question2.Options.ToList();
var q2Answers = (question2.Answers = new List <AssignmentAnswer>
{
new AssignmentAnswer
{
Text = "AssignAnswer21",
CorrectOption = question2.Options.Skip(1).First()
},
new AssignmentAnswer
{
Text = "AssignAnswer22",
CorrectOption = question2.Options.First()
}
}).ToList();
var question3 = new AssignmentQuestion
{
Revision = 1,
Text = "AssignmentQuestion2",
Options = new List <AssignmentOption>
{
new AssignmentOption
{
Text = "AssignOpt31"
},
new AssignmentOption
{
Text = "AssignOpt32"
},
new AssignmentOption
{
Text = "AssignOpt33"
}
}
};
var q3Opts = question3.Options.ToList();
var q3Answers = (question3.Answers = new List <AssignmentAnswer>
{
new AssignmentAnswer
{
Text = "AssignAnswer31",
CorrectOption = question3.Options.Skip(2).First()
},
new AssignmentAnswer
{
Text = "AssignAnswer32",
CorrectOption = question3.Options.First()
}
}).ToList();
var fileText1 = "0;\n" +
"Text;Opt1;Opt2;Opt3;;Assign1Text;Assign1Opt;Assign2Text;Assign2Opt;Assign3Text;Assign3Opt\n" +
$"\"{question1.Text}\";{q1Opts[0].Text};{q1Opts[1].Text};{q1Opts[2].Text};;{q1Answers[0].Text};1;{q1Answers[1].Text};2;{q1Answers[2].Text};3\n" +
$"\"{question2.Text}\";{q2Opts[0].Text};{q2Opts[1].Text};;;{q1Answers[0].Text};2;{q1Answers[1].Text};1;;";
var fileText2 = "0;\n" +
"Text;Opt1;Opt2;Opt3;;Assign1Text;Assign1Opt;Assign2Text;Assign2Opt;Assign3Text;Assign3Opt\n" +
$"{question3.Text};{q3Opts[0].Text};{q3Opts[1].Text};{q3Opts[2].Text};;{q3Answers[0].Text};3;{q3Answers[1].Text};1;;;\n" +
$"";
var expectedImportedQuestions = new Dictionary <string, List <string> >
{
[fileNames[0]] = new List <string>
{
question1.Text,
question2.Text
},
[fileNames[1]] = new List <string>
{
question3.Text
}
};
var questionsUow = A.Fake <IQuestionsUnitOfWork>();
var questionnairesUow = A.Fake <IQuestionnairesUnitOfWork>();
var file = A.Fake <IFile>();
A.CallTo(() => file.ReadAllText(A <string> .That.Matches(_ => _ == fileNames[0])))
.Returns(fileText1);
A.CallTo(() => file.ReadAllText(A <string> .That.Matches(_ => _ == fileNames[1])))
.Returns(fileText2);
var testee = new ImportExportService(questionnairesUow, questionsUow, file);
// Act
(Dictionary <string, List <string> > importedQuestions, List <string> erroredFiles) = await testee.Import(name, "", fileNames);
// Assert
importedQuestions.Should().BeEquivalentTo(expectedImportedQuestions);
erroredFiles.Should().BeNullOrEmpty();
A.CallTo(() => questionnairesUow.QuestionnairesRepo.Add(A <Questionnaire> .That.Matches(_ => this.matchEntity(_, questionnaire))))
.MustHaveHappened();
A.CallTo(() => questionsUow.AssignmentQuestionsRepo.Add(A <AssignmentQuestion> .That.Matches(_ => this.matchEntity(_, question1))))
.MustHaveHappened();
A.CallTo(() => questionsUow.AssignmentQuestionsRepo.Add(A <AssignmentQuestion> .That.Matches(_ => this.matchEntity(_, question2))))
.MustHaveHappened();
A.CallTo(() => questionsUow.AssignmentQuestionsRepo.Add(A <AssignmentQuestion> .That.Matches(_ => this.matchEntity(_, question3))))
.MustHaveHappened();
A.CallTo(() => questionnairesUow.Complete())
.MustHaveHappened();
A.CallTo(() => questionsUow.Complete())
.MustHaveHappened(Repeated.Exactly.Times(4));
}
public async Task ImportsTextQuestions()
{
// Arrange
const string name = "text question";
var fileNames = new[] { "file1", "file2" };
var questionnaire = new Questionnaire
{
Revision = 1,
Name = name
};
var question1 = new TextQuestion
{
Revision = 1,
Text = "TextQuestion1",
Answer = new TextAnswer
{
Text = "TextAnswer1"
}
};
var question2 = new TextQuestion
{
Revision = 1,
Text = "TextQuestion2",
Answer = new TextAnswer
{
Text = "TextAnswer2"
}
};
var question3 = new TextQuestion
{
Revision = 1,
Text = "TextQuestion3",
Answer = new TextAnswer
{
Text = "TextAnswer3"
}
};
var fileText1 = "2;\n" +
"Text;Antwort\n" +
$"\"{question1.Text}\";{question1.Answer.Text}\n" +
$"{question2.Text};{question2.Answer.Text}\n" +
$"{question3.Text};\"{question3.Answer.Text}\"";
var question4 = new TextQuestion
{
Revision = 1,
Text = "TextQuestion4",
Answer = new TextAnswer
{
Text = "TextAnswer4"
}
};
var fileText2 = "2\n" +
"Text;Antwort\n" +
$"{question4.Text};{question4.Answer.Text}\n";
var expectedImportedQuestions = new Dictionary <string, List <string> >
{
[fileNames[0]] = new List <string>
{
question1.Text,
question2.Text,
question3.Text
},
[fileNames[1]] = new List <string>
{
question4.Text
}
};
var questionsUow = A.Fake <IQuestionsUnitOfWork>();
var questionnairesUow = A.Fake <IQuestionnairesUnitOfWork>();
var file = A.Fake <IFile>();
A.CallTo(() => file.ReadAllText(A <string> .That.Matches(_ => _ == fileNames[0])))
.Returns(fileText1);
A.CallTo(() => file.ReadAllText(A <string> .That.Matches(_ => _ == fileNames[1])))
.Returns(fileText2);
var testee = new ImportExportService(questionnairesUow, questionsUow, file);
// Act
(Dictionary <string, List <string> > importedQuestions, List <string> erroredFiles) = await testee.Import(name, "", fileNames);
// Assert
importedQuestions.Should().BeEquivalentTo(expectedImportedQuestions);
erroredFiles.Should().BeNullOrEmpty();
A.CallTo(() => questionnairesUow.QuestionnairesRepo.Add(A <Questionnaire> .That.Matches(_ => this.matchEntity(_, questionnaire))))
.MustHaveHappened();
A.CallTo(() => questionsUow.TextQuestionsRepo.Add(A <TextQuestion> .That.Matches(_ => this.matchEntity(_, question1))))
.MustHaveHappened();
A.CallTo(() => questionsUow.TextQuestionsRepo.Add(A <TextQuestion> .That.Matches(_ => this.matchEntity(_, question2))))
.MustHaveHappened();
A.CallTo(() => questionsUow.TextQuestionsRepo.Add(A <TextQuestion> .That.Matches(_ => this.matchEntity(_, question3))))
.MustHaveHappened();
A.CallTo(() => questionsUow.TextQuestionsRepo.Add(A <TextQuestion> .That.Matches(_ => this.matchEntity(_, question4))))
.MustHaveHappened();
A.CallTo(() => questionnairesUow.Complete())
.MustHaveHappened();
A.CallTo(() => questionsUow.Complete())
.MustHaveHappened(Repeated.Exactly.Times(5));
}
public void ImportProjectServiceWithMigrationTest()
{
SampleData.ClearDatabaseThenImportDefaultProject();
var importData = PrepareImport();
var service = new ImportExportService();
var mre = new System.Threading.ManualResetEvent(false);
KProcess.Ksmed.Business.Dtos.Export.ProjectImport projectImport = null;
Exception e = null;
int newProjectId = -1;
service.PredictMergedReferentialsProject(importData, pi =>
{
projectImport = pi;
service.ImportProject(pi, false, TestContext.DeploymentDirectory, p =>
{
newProjectId = p.ProjectId;
mre.Set();
}, ex =>
{
e = ex;
mre.Set();
});
}, ex =>
{
e = ex;
mre.Set();
});
mre.WaitOne();
AssertExt.IsExceptionNull(e);
Assert.IsNotNull(projectImport);
Assert.IsTrue(projectImport.ExportedProject.Project.Label.EndsWith(" migré"));
// Récupérer le projet depuis la base et tester
var prepareService = new PrepareService();
mre.Reset();
ProjectsData data = null;
prepareService.GetProjects(d =>
{
data = d;
mre.Set();
}, ex =>
{
e = ex;
mre.Set();
});
mre.WaitOne();
AssertExt.IsExceptionNull(e);
var project = data.Projects.First(p => p.ProjectId == newProjectId);
Assert.IsTrue(project.Label.EndsWith(" migré"));
}
public ItemController()
{
_importExportService = new ExcelImportExportService();
}
/// <summary>
/// Exporte le projet spécifié.
/// </summary>
/// <param name="projectId">L'identifiant du projet.</param>
private void ExportProject(int projectId, bool merge)
{
var service = new ImportExportService();
string fileName = string.Format("out{0}.xml", fileNumber++);
KProcess.Ksmed.Business.Dtos.Export.ProjectExport oldProjectExport;
using (var context = KProcess.Ksmed.Data.ContextFactory.GetNewContext())
{
oldProjectExport = service.CreateProjectExport(context, projectId);
}
var mre = new System.Threading.ManualResetEvent(false);
Stream stream = null;
Exception e = null;
service.ExportProject(projectId, d =>
{
stream = d;
mre.Set();
}, ex =>
{
e = ex;
mre.Set();
});
mre.WaitOne();
AssertExt.IsExceptionNull(e);
Assert.IsNotNull(stream);
using (var reader = new StreamReader(stream))
{
string xml = reader.ReadToEnd();
File.WriteAllText(fileName, xml);
Assert.IsNotNull(xml);
}
stream.Close();
Initialization.SetCurrentUser("paula");
// Ouvrir le fichier
mre.Reset();
int newProjectId = -1;
service.PredictMergedReferentialsProject(File.ReadAllBytes(fileName), pi =>
{
service.ImportProject(pi, merge, TestContext.DeploymentDirectory, p =>
{
newProjectId = p.ProjectId;
mre.Set();
}, ex =>
{
e = ex;
mre.Set();
});
}, ex =>
{
e = ex;
mre.Set();
});
mre.WaitOne();
AssertExt.IsExceptionNull(e);
// Réexporter le projet
KProcess.Ksmed.Business.Dtos.Export.ProjectExport newProjectExport;
using (var context = KProcess.Ksmed.Data.ContextFactory.GetNewContext())
{
newProjectExport = service.CreateProjectExport(context, newProjectId);
}
// Comparer les valeurs
// Projet
AssertProject(oldProjectExport.Project, newProjectExport.Project);
// Vidéos
var oldVideos = oldProjectExport.Project.Videos.OrderBy(v => v.Name).ToArray();
var newVideos = newProjectExport.Project.Videos.OrderBy(v => v.Name).ToArray();
for (int i = 0; i < oldVideos.Length; i++)
{
AssertVideo(oldVideos[i], newVideos[i]);
}
// Scénarios
var oldScenarios = oldProjectExport.Project.Scenarios.OrderBy(s => s.Label).ToArray();
var newScenarios = newProjectExport.Project.Scenarios.OrderBy(s => s.Label).ToArray();
for (int i = 0; i < oldProjectExport.Project.Scenarios.Count; i++)
{
var oldScenario = oldScenarios[i];
var newScenario = newScenarios[i];
AssertScenario(oldScenario, newScenario);
var oldActions = oldScenario.Actions.OrderBy(a => WBSHelper.GetParts(a.WBS), new WBSHelper.WBSComparer()).ToArray();
var newActions = newScenario.Actions.OrderBy(a => WBSHelper.GetParts(a.WBS), new WBSHelper.WBSComparer()).ToArray();
// Actions
for (int j = 0; j < oldScenario.Actions.Count; j++)
{
var oldAction = oldActions[j];
var newAction = newActions[j];
AssertAction(oldAction, newAction);
// Actions réduites
AssertActionReduced(oldAction.Reduced, newAction.Reduced);
}
}
}
public async Task ImportsSimpleQuestions()
{
// Arrange
const string name = "name";
const string tags = "tags,tags";
var fileNames = new[] { "file1" };
var questionnaire = new Questionnaire
{
Revision = 1,
Name = name,
Tags = tags
};
var question1 = new SimpleQuestion
{
Revision = 1,
SimpleQuestionType = SimpleQuestionType.SingleChoice,
Text = "Text1",
Answers = new List <SimpleAnswer>
{
new SimpleAnswer
{
IsCorrect = true,
Text = "Answer1.1"
},
new SimpleAnswer
{
IsCorrect = false,
Text = "Answer1.2"
}
}
};
var answers1 = question1.Answers.ToList();
var question2 = new SimpleQuestion
{
Revision = 1,
SimpleQuestionType = SimpleQuestionType.TrueFalse,
Text = "Text2",
Answers = new List <SimpleAnswer>
{
new SimpleAnswer
{
IsCorrect = false,
Text = "Answer2.1"
},
new SimpleAnswer
{
IsCorrect = true,
Text = "Answer2.2"
},
new SimpleAnswer
{
IsCorrect = true,
Text = "Answer2.3"
}
}
};
var answers2 = question2.Answers.ToList();
var fileText = "1;;;;;;;\n" +
"Text;Typ;Text Antwort 1;Anwort korrekt?;Text Antwort 2;;;\n" +
$"\"{question1.Text}\";{(int)question1.SimpleQuestionType};{answers1[0].Text};{answers1[0].IsCorrect};{answers1[1].Text};{answers1[1].IsCorrect};;\r\n" +
$"{question2.Text};{(int)question2.SimpleQuestionType};\"{answers2[0].Text}\";{answers2[0].IsCorrect};{answers2[1].Text};{answers2[1].IsCorrect};{answers2[2].Text};{answers2[2].IsCorrect}\n";
var expectedImportedQuestions = new Dictionary <string, List <string> >
{
[fileNames[0]] = new List <string>
{
question1.Text,
question2.Text
}
};
var questionsUow = A.Fake <IQuestionsUnitOfWork>();
var questionnairesUow = A.Fake <IQuestionnairesUnitOfWork>();
var file = A.Fake <IFile>();
A.CallTo(() => file.ReadAllText(A <string> .That.Matches(_ => _ == fileNames[0])))
.Returns(fileText);
var testee = new ImportExportService(questionnairesUow, questionsUow, file);
// Act
(Dictionary <string, List <string> > importedQuestions, List <string> erroredFiles) = await testee.Import(name, tags, fileNames);
// Assert
importedQuestions.Should().BeEquivalentTo(expectedImportedQuestions);
erroredFiles.Should().BeNullOrEmpty();
A.CallTo(() => questionnairesUow.QuestionnairesRepo.Add(A <Questionnaire> .That.Matches(_ => this.matchEntity(_, questionnaire))))
.MustHaveHappened();
A.CallTo(() => questionsUow.SimpleQuestionsRepo.Add(A <SimpleQuestion> .That.Matches(_ => this.matchEntity(_, question1))))
.MustHaveHappened();
A.CallTo(() => questionsUow.SimpleQuestionsRepo.Add(A <SimpleQuestion> .That.Matches(_ => this.matchEntity(_, question2))))
.MustHaveHappened();
A.CallTo(() => questionnairesUow.Complete())
.MustHaveHappened();
A.CallTo(() => questionsUow.Complete())
.MustHaveHappened(Repeated.Exactly.Times(3));
}
public async Task ImportsTextQuestions_WhenOneFileIsNotFound()
{
// Arrange
const string name = "text question";
var fileNames = new[] { "file1", "invalidFile" };
var questionnaire = new Questionnaire
{
Revision = 1,
Name = name
};
var question1 = new TextQuestion
{
Revision = 1,
Text = "TextQuestion1",
Answer = new TextAnswer
{
Text = "TextAnswer1"
}
};
var fileText1 = "2\n" +
"Text;Antwort\n" +
$"{question1.Text};{question1.Answer.Text}\n";
var questionsUow = A.Fake <IQuestionsUnitOfWork>();
var questionnairesUow = A.Fake <IQuestionnairesUnitOfWork>();
var file = A.Fake <IFile>();
var expectedImportedQuestions = new Dictionary <string, List <string> >
{
[fileNames[0]] = new List <string>
{
question1.Text
}
};
A.CallTo(() => file.ReadAllText(A <string> .That.Matches(_ => _ == fileNames[0])))
.Returns(fileText1);
A.CallTo(() => file.ReadAllText(A <string> .That.Matches(_ => _ == fileNames[1])))
.Throws(() => new FileNotFoundException());
var testee = new ImportExportService(questionnairesUow, questionsUow, file);
// Act
(Dictionary <string, List <string> > importedQuestions, List <string> erroredFiles) = await testee.Import(name, "", fileNames);
// Assert
importedQuestions.Should().BeEquivalentTo(expectedImportedQuestions);
erroredFiles.Should().BeEquivalentTo(fileNames[1]);
A.CallTo(() => questionnairesUow.QuestionnairesRepo.Add(A <Questionnaire> .That.Matches(_ => this.matchEntity(_, questionnaire))))
.MustHaveHappened();
A.CallTo(() => questionsUow.TextQuestionsRepo.Add(A <TextQuestion> .That.Matches(_ => this.matchEntity(_, question1))))
.MustHaveHappened();
A.CallTo(() => questionnairesUow.Complete())
.MustHaveHappened();
A.CallTo(() => questionsUow.Complete())
.MustHaveHappened(Repeated.Exactly.Twice);
}
public CategoryController()
{
_importExportService = new ExcelImportExportService();
}
public OrderController()
{
_importExportService = new ExcelImportExportService();
}
public PropertyController()
{
_importExportService = new ExcelImportExportService();
}
/// <summary>
/// Exporte le projet spécifié.
/// </summary>
private void ExportVideoDecomposition(int projectId, int scenarioId, int videoId, int targetProjectId, bool merge)
{
var service = new ImportExportService();
string fileName = string.Format("out{0}.xml", fileNumber++);
KProcess.Ksmed.Business.Dtos.Export.VideoDecompositionExport oldVideoExport;
using (var context = KProcess.Ksmed.Data.ContextFactory.GetNewContext())
{
oldVideoExport = new VideoDecompositionExporter(context, projectId, scenarioId, videoId).CreateExport();
}
var mre = new System.Threading.ManualResetEvent(false);
Stream stream = null;
Exception e = null;
service.ExportVideoDecomposition(projectId, scenarioId, videoId, d =>
{
stream = d;
mre.Set();
}, ex =>
{
e = ex;
mre.Set();
});
mre.WaitOne();
AssertExt.IsExceptionNull(e);
Assert.IsNotNull(stream);
using (var reader = new StreamReader(stream))
{
string xml = reader.ReadToEnd();
File.WriteAllText(fileName, xml);
Assert.IsNotNull(xml);
}
stream.Close();
Initialization.SetCurrentUser("paula");
// Ouvrir le fichier
mre.Reset();
service.PredictMergedReferentialsVideoDecomposition(targetProjectId, File.OpenRead(fileName), vdi =>
{
service.ImportVideoDecomposition(vdi, merge, TestContext.DeploymentDirectory, targetProjectId, success =>
{
Assert.IsTrue(success);
mre.Set();
}, ex =>
{
e = ex;
mre.Set();
});
}, ex =>
{
e = ex;
mre.Set();
});
mre.WaitOne();
AssertExt.IsExceptionNull(e);
// Récupérer le numéro de scénario initial du projet
Scenario targetScenario;
int newVideoId;
using (var context = KProcess.Ksmed.Data.ContextFactory.GetNewContext())
{
targetScenario = context.Scenarios.Single(s => s.ProjectId == targetProjectId && s.StateCode == KnownScenarioStates.Draft && s.NatureCode == KnownScenarioNatures.Initial);
var oldVideoName = context.Videos.Single(v => v.VideoId == videoId).Name;
newVideoId = context.Videos.Where(v => v.ProjectId == targetProjectId && v.Name == oldVideoName)
.AsEnumerable().Last().VideoId;
}
//Réexporter la décompo
KProcess.Ksmed.Business.Dtos.Export.VideoDecompositionExport newVideoExport;
using (var context = KProcess.Ksmed.Data.ContextFactory.GetNewContext())
{
newVideoExport = new VideoDecompositionExporter(context, targetScenario.ProjectId, targetScenario.ScenarioId, newVideoId).CreateExport();
}
// Comparer les valeurs
// Vidéo
var oldVideo = oldVideoExport.Video;
var newVideo = newVideoExport.Video;
AssertVideo(oldVideo, newVideo);
// Référentiels
var p1RerentialsProject = ReferentialsHelper.GetAllReferentialsProject(oldVideoExport.Actions).ToArray();
var p1RerentialsStandard = ReferentialsHelper.GetAllReferentialsStandardUsed(oldVideoExport.Actions).ToArray();
var p2RerentialsProject = ReferentialsHelper.GetAllReferentialsProject(newVideoExport.Actions).ToArray();
var p2RerentialsStandard = ReferentialsHelper.GetAllReferentialsStandardUsed(newVideoExport.Actions).ToArray();
Assert.IsTrue(p1RerentialsProject.Length <= p2RerentialsProject.Length);
Assert.AreEqual(p1RerentialsProject.Length + p1RerentialsStandard.Length, p2RerentialsProject.Length);
Assert.AreEqual(0, p2RerentialsStandard.Length);
// Vérifier que toutes les actions de l'ancien export soient également maintenant dans le projet de destination
var oldActions = oldVideoExport.Actions.OrderBy(a => WBSHelper.GetParts(a.WBS), new WBSHelper.WBSComparer()).ToArray();
var newActions = newVideoExport.Actions.OrderBy(a => WBSHelper.GetParts(a.WBS), new WBSHelper.WBSComparer()).ToArray();
Assert.AreEqual(oldActions.Length, newActions.Length);
// Actions
for (int j = 0; j < oldActions.Length; j++)
{
var oldAction = oldActions[j];
var newAction = newActions[j];
AssertAction(oldAction, newAction);
// Actions réduites
AssertActionReduced(oldAction.Reduced, newAction.Reduced);
}
ServicesDiagnosticsDebug.CheckReferentialsState();
}
public SettingsPage()
{
InitializeComponent();
_importExportService = new ImportExportService();
}
