public static DefaultCategoryDataset createDatasetForCriterionEvaluationCompareBarChart(
List<Fragebogen> fragebogenList) {
DefaultCategoryDataset defaultcategorydataset = new DefaultCategoryDataset();
ArrayList<Bereich> bereiche =
EvaluationHelper.getBereicheFromEvaluationHelper(fragebogenList.get(0).getBewertungen());
for (Fragebogen f : fragebogenList) {
double[] values = new double[bereiche.size()];
int valCount = 0;
for (Bereich bereich : bereiche) {
valCount = 0;
for (Bewertung bewertung : f.getBewertungen()) {
if (bewertung.getItem() != null) {
if (bereich.equals(bewertung.getItem().getBereich())) {
if (!bewertung.getWert().isEmpty())
values[bereiche.indexOf(bereich)] += Double.parseDouble(bewertung.getWert());
valCount++;
}
}
}
if (valCount != 0) {
values[bereiche.indexOf(bereich)] /= valCount;
} else {
values[bereiche.indexOf(bereich)] = 0;
}
}
ArrayList<Handlungsfeld> hfList = new ArrayList<Handlungsfeld>();
for (Bereich bereich : bereiche) {
if (!hfList.contains(bereich.getHandlungsfeld())) {
hfList.add(bereich.getHandlungsfeld());
}
}
for (Handlungsfeld hf : hfList) {
double ret = 0;
int i = 0;
for (Bereich bereich : bereiche) {
if (bereich.getHandlungsfeld().equals(hf)) {
ret += values[bereiche.indexOf(bereich)];
i++;
}
}
if (i > 0) {
ret /= i;
} else {
ret = 0;
}
defaultcategorydataset.addValue(ret, f.getPerspektive().getName(), hf.getName());
}
}
return defaultcategorydataset;
}
@Test(expected = IllegalArgumentException.class)
public void deleteFragebogenExported() {
Fragebogen gb = new Fragebogen();
gb.setId(80);
Mockito.when(fragebogenDAO.findById(gb.getId())).thenReturn(gb);
gb.setExportiertQuestorPro(true);
model.deleteFragebogen(gb);
}
@Test
public void deleteFragebogen() {
Fragebogen gb = new Fragebogen();
gb.setId(81);
Mockito.when(fragebogenDAO.findById(gb.getId())).thenReturn(gb);
gb.setExportiertQuestorPro(null);
model.deleteFragebogen(gb);
gb.setExportiertQuestorPro(false);
Bewertung b = new Bewertung();
gb.setBewertungen(Arrays.asList(new Bewertung[] {b}));
Item i = new Item();
List<Fragebogen> fList = new ArrayList<>();
fList.add(gb);
i.setFrageboegen(fList);
gb.setItems(Arrays.asList(new Item[] {i}));
Frage_Fragebogen ff = new Frage_Fragebogen();
gb.setFrageFragebogen(Arrays.asList(new Frage_Fragebogen[] {ff}));
model.deleteFragebogen(gb);
}
public static DefaultCategoryDataset createDatasetForMultiperspektive(
List<Fragebogen> fragebogenList) {
DefaultCategoryDataset defaultcategorydataset = new DefaultCategoryDataset();
ArrayList<Bereich> bereiche =
EvaluationHelper.getBereicheFromEvaluationHelper(fragebogenList.get(0).getBewertungen());
for (Fragebogen f : fragebogenList) {
ObservableList<EvaluationHelper> ehList =
EvaluationHelper.createEvaluationHelperList(f.getBewertungen(), null);
for (EvaluationHelper eh : ehList) {
double avValue[] = new double[bereiche.size()];
int valCount = 0;
for (Bereich bereich : bereiche) {
valCount = 0;
for (Item item : eh.getItems()) {
if (bereich.equals(item.getBereich())) {
if (!eh.getItemWertung().get(valCount).isEmpty()) {
avValue[bereiche.indexOf(bereich)] +=
Double.parseDouble(eh.getItemWertung().get(valCount));
}
valCount++;
}
}
if (valCount != 0) {
avValue[bereiche.indexOf(bereich)] /= valCount;
} else {
avValue[bereiche.indexOf(bereich)] = 0;
}
}
for (int j = 0; j < avValue.length; j++) {
defaultcategorydataset.addValue(
avValue[j],
f.getPerspektive().getName() + " : " + eh.getRawId(),
bereiche.get(j).getName());
}
}
}
return defaultcategorydataset;
}
public static DefaultCategoryDataset getAverageDataSetForBereichCompare(
List<Fragebogen> fragebogenList) {
DefaultCategoryDataset defaultcategorydataset = new DefaultCategoryDataset();
double ret = 0;
ArrayList<Bereich> bereiche =
EvaluationHelper.getBereicheFromEvaluationHelper(fragebogenList.get(0).getBewertungen());
for (Fragebogen f : fragebogenList) {
double[] values = new double[bereiche.size()];
int valCount = 0;
for (Bereich bereich : bereiche) {
valCount = 0;
for (Bewertung bewertung : f.getBewertungen()) {
if (bewertung.getItem() != null) {
if (bereich.equals(bewertung.getItem().getBereich())) {
if (!bewertung.getWert().isEmpty())
values[bereiche.indexOf(bereich)] += Double.parseDouble(bewertung.getWert());
valCount++;
}
}
}
if (valCount != 0) {
values[bereiche.indexOf(bereich)] /= valCount;
} else {
values[bereiche.indexOf(bereich)] = 0;
}
}
for (Bereich bereich : bereiche) {
defaultcategorydataset.addValue(
values[bereiche.indexOf(bereich)], f.getPerspektive().getName(), bereich.getName());
}
}
return defaultcategorydataset;
}
public static DefaultCategoryDataset createDatasetForEvaluationItemCompare(
List<Fragebogen> fragebogenList) {
DefaultCategoryDataset defaultcategorydataset = new DefaultCategoryDataset();
ObservableList<EvaluationHelper> ehListinit =
EvaluationHelper.createEvaluationHelperList(fragebogenList.get(0).getBewertungen(), null);
List<Item> items = ehListinit.get(0).getItems();
for (Fragebogen f : fragebogenList) {
ObservableList<EvaluationHelper> ehList =
EvaluationHelper.createEvaluationHelperList(f.getBewertungen(), null);
for (Item item : items) {
double ret = 0;
int i = 0;
if (ehList.get(0).getItems().contains(item)) {
for (EvaluationHelper eh : ehList) {
String s = eh.getItemWertung().get(eh.getItems().indexOf(item));
if (s.isEmpty()) {
ret += 0;
} else {
ret += Double.parseDouble(eh.getItemWertung().get(eh.getItems().indexOf(item)));
i++;
}
}
}
if (i > 0) {
ret /= i;
}
defaultcategorydataset.addValue(ret, f.getPerspektive().getName(), item.getName());
}
}
return defaultcategorydataset;
}
@Test
public void testArchivToggle() {
Fragebogen fb = new Fragebogen();
fb.setId(30);
Mockito.when(fragebogenDAO.findById(fb.getId())).thenReturn(fb);
model.toggleArchiviert(fb);
Assert.assertTrue(!fb.getArchiviert());
model.toggleArchiviert(fb);
Assert.assertTrue(fb.getArchiviert());
model.toggleArchiviert(fb);
Assert.assertTrue(!fb.getArchiviert());
}
@BeforeClass
public static void setup() throws Exception {
fragebogenDAO = Mockito.mock(FragebogenDAO.class);
frageDAO = Mockito.mock(FrageDAO.class);
bewertungsDAO = Mockito.mock(BewertungDAO.class);
itemDAO = Mockito.mock(ItemDAO.class);
einstellungDAO = Mockito.mock(EinstellungDAO.class);
frageFragebogenDAO = Mockito.mock(Frage_FragebogenDAO.class);
fragebogen1 = new Fragebogen();
Eigenschaft e = new Eigenschaft();
e.setId(1);
e.setName("testEigenschaft");
Perspektive p = new Perspektive();
p.setId(1);
p.setName("testPerspektive");
Fach f = new Fach();
f.setId(1);
f.setName("test>Fach");
l = new Lehrveranstaltung();
l.setId(1);
l.setDozent("testDozent");
l.setJahr(new Date());
f.addLehrveranstaltung(l);
f.addLehrveranstaltung(l);
l.setSemester(SemesterType.SS);
fragebogen1.setEigenschaft(e);
fragebogen1.setPerspektive(p);
fragebogen1.setLehrveranstaltung(l);
Handlungsfeld h = new Handlungsfeld();
h.setId(1);
h.setName("testName");
h.setNotiz("testNotiz");
Bereich b = new Bereich();
b.setId(1);
b.setName("testBereich");
h.addBereich(b);
Item i1 = new Item();
i1.setId(1);
i1.setName("testItem1");
i1.setNotiz("testNotiz1");
b.addItem(i1);
i1.addEigenschaft(e);
i1.addPerspektive(p);
i1.addFragebogen(fragebogen1);
i1.setFrage("item1Frage");
Item i2 = new Item();
i2.setId(2);
i2.setName("testItem1");
i2.setNotiz("testNotiz1");
b.addItem(i2);
i2.addEigenschaft(e);
i2.addPerspektive(p);
i2.addFragebogen(fragebogen1);
i2.setFrage("item2Frage");
sDiscrete = new Skala();
sDiscrete.setId(1);
sDiscrete.setType(SkalaType.DISCRET);
sDiscrete.setMaxText("testMax");
sDiscrete.setMinText("testMin");
sDiscrete.setOptimum(4);
sDiscrete.setSchritte(4);
sDiscrete.setSchrittWeite(1);
fragebogen1.setSkala(sDiscrete);
sFree = new Skala();
sFree.setId(2);
sFree.setType(SkalaType.FREE);
sFree.setZeilen(4);
sMQ = new Skala();
sMQ.setId(3);
sMQ.setType(SkalaType.MC);
sMQ.setSchrittWeite(1);
sMQ.setAndereAntwort("tetDefaultAnswer");
sMQ.setVerweigerungsAntwort("testVerweigerungsAntwort");
sMQ.setAuswahl(Arrays.asList(new String[] {"test1", "test2"}));
f1 = new Frage();
f1.setId(1);
f1.setName("frage1");
f1.setSkala(sFree);
f1.setText("Was?");
Frage f2 = new Frage();
f2.setId(2);
f2.setName("frage2");
f2.setSkala(sMQ);
f2.setText("Wo?");
Frage_Fragebogen ff1 = new Frage_Fragebogen();
ff1.setFrage(f1);
ff1.setId(1);
ff1.setPosition(FragePosition.BOTTOM);
ff1.setFragebogen(fragebogen1);
Frage_Fragebogen ff2 = new Frage_Fragebogen();
ff2.setFrage(f2);
ff2.setId(2);
ff2.setPosition(FragePosition.TOP);
ff2.setFragebogen(fragebogen1);
fragebogen1.setId(1);
fragebogen1.setFrageFragebogen(Arrays.asList(new Frage_Fragebogen[] {ff1, ff2}));
Bewertung b1 = new Bewertung();
b1.setId(1);
b1.setFrage(f1);
b1.setQuelle("quelle");
b1.setWert("1");
b1.setZeilenid("test");
b1.setZeit("2014");
b1.setFragebogen(fragebogen1);
f1.setBewertungen(Arrays.asList(new Bewertung[] {b1}));
Bewertung b2 = new Bewertung();
b2.setId(2);
b2.setFrage(f2);
b2.setQuelle("quelle");
b2.setWert("2");
b2.setZeilenid("test");
b2.setZeit("2014");
b2.setFragebogen(fragebogen1);
f2.setBewertungen(Arrays.asList(new Bewertung[] {b2}));
Bewertung b3 = new Bewertung();
b3.setId(3);
b3.setItem(i1);
b3.setQuelle("quelle");
b3.setWert("3");
b3.setZeilenid("test");
b3.setZeit("2014");
b3.setFragebogen(fragebogen1);
i1.setBewertungen(Arrays.asList(new Bewertung[] {b3}));
Bewertung b4 = new Bewertung();
b4.setId(4);
b4.setItem(i2);
b4.setQuelle("quelle");
b4.setWert("3");
b4.setZeilenid("test");
b4.setZeit("2014");
b4.setFragebogen(fragebogen1);
i2.setBewertungen(Arrays.asList(new Bewertung[] {b4}));
Einstellung ei = new Einstellung();
ei.setId(1);
ei.setName(EinstellungenType.STANDORT);
ei.setWert("HSC");
Mockito.when(einstellungDAO.findByName(EinstellungenType.STANDORT)).thenReturn(ei);
fragebogen1.setBewertungen(Arrays.asList(new Bewertung[] {b1, b2, b3, b4}));
fragebogen1.setErstellungsDatum(new Date());
List<Item> items = new ArrayList<Item>();
items.add(i2);
items.add(i1);
fragebogen1.setItems(items);
fragebogen1.setName("testFragebogen");
Mockito.when(fragebogenDAO.findById(fragebogen1.getId())).thenReturn(fragebogen1);
setValueToField(fragebogenDAO, "fragebogenDAO", model);
setValueToField(frageDAO, "frageDAO", model);
setValueToField(bewertungsDAO, "bewertungsDAO", model);
setValueToField(itemDAO, "itemDAO", model);
setValueToField(einstellungDAO, "einstellungDAO", model);
setValueToField(frageFragebogenDAO, "frageFragebogenDAO", model);
}