Ejemplo n.º 1
0
  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;
  }
Ejemplo n.º 2
0
  public static DefaultCategoryDataset getDatasetForCriterionBarChart(
      double[] avValueBereich, ArrayList<Bereich> bereiche) {
    DefaultCategoryDataset defaultcategorydataset = new DefaultCategoryDataset();
    double[] values = CalculationHelper.getAverageDataForCriterion(avValueBereich, bereiche);
    ArrayList<Handlungsfeld> hfList = new ArrayList<Handlungsfeld>();
    for (Bereich bereich : bereiche) {
      if (hfList.isEmpty() || !hfList.contains(bereich.getHandlungsfeld())) {
        hfList.add(bereich.getHandlungsfeld());
      }
    }
    for (Handlungsfeld hf : hfList) {
      defaultcategorydataset.addValue(
          values[hfList.indexOf(hf)],
          SeCatResourceBundle.getInstance().getString("scene.chart.all.averagevalues"),
          hf.getName());
    }

    return defaultcategorydataset;
  }
Ejemplo n.º 3
0
  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;
  }
Ejemplo n.º 4
0
  public static DefaultCategoryDataset createDatasetForStudentBereich(
      EvaluationHelper eh,
      Fragebogen fragebogen,
      ArrayList<Bereich> bereiche,
      double[] avValueBereich) {

    DefaultCategoryDataset defaultcategorydataset = new DefaultCategoryDataset();

    for (int i = 0; i < bereiche.size(); i++) {
      defaultcategorydataset.addValue(
          avValueBereich[i],
          SeCatResourceBundle.getInstance().getString("scene.chart.all.averagevalues"),
          bereiche.get(i).getName());
    }

    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;
      }
    }
    for (int j = 0; j < avValue.length; j++) {
      defaultcategorydataset.addValue(avValue[j], eh.getRawId(), bereiche.get(j).getName());
    }

    return defaultcategorydataset;
  }
Ejemplo n.º 5
0
  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;
  }
Ejemplo n.º 6
0
  @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);
  }