#################################
# KRATEK OPIS STRUKTURE POROČIL #
#################################
# Poročilo je sestavljeno na podlagi R kode (izračuni) in latex kode (.tex, struktura poročil) 
# Vhodne datoteke se nahajajo v mapi "temp", kjer sta dve ločeni datoteki s podatki za +
# ANKETO PRED IZPITOM in ANKETO PO IZPITU
# V mapi se nahajajo tudi šifranti (ki služijo opredelitvi izvajalcev fakultete, predmetov, +
# načina študija, študijskih programov), itd: +
# Podrobno preberi: http://ul.1ka.si/index.php?fl=2&lact=1&bid=40&parent=3
# V poročilu so ocenjene, obarvane in v tabelah predstavljene vrednosti komponent za izvajalca, +
# vrednosti komponent predmetov PRED izpitom in vrednosti komponent PO izpitu.
# Komponente za izvajalca so: Kakovost, Pripravljenost, Razumljivost, Zanimivost, Kritičnost, Korektnost
# Komponente predmeta (ANKETA PRED): Zadovoljstvo, Usklajenost, Samostojnost, Literatura, Obveščenost, Info. na spletu, Preverjanje
# Komponente predmeta (ANKETA PO):Vsebine, naloge, Ocenjevanje, Kompetence, Ustreznost Kreditnih točk
########
# skripta: koda.r je osnova (ki jo vedno najprej poženemo) in je namenjena opredelitvi +
# spremenljivk, vektorjev, podatkovnih okvirjev in izračunu povprečij, kvantilnih rangov, +
# obarvanju, itd. 
# Obarvanja povprečij komponent in kvantilnih rangov opredelimo v skkripti funkcije.R
# Skripto tabelaBy.r pa uporabimo samo pri izpisu PDF za izvajalca. Pri izpisu za programe, fakulteto tega ne uporabljamo.
# Ko smo pognali skrpto kodo.r, lahko generiramo poročilo za izvajalce, tako da poženemo +
# skirpto koda-izvajalec_predmet.r. 
# Skripta koda-fakulteta.r služi generiranju poročila za fakulteto.
# Skripta koda-programi pa generira poročila za študijske programe.
########
# Glavo dokumenta, obarvanje vrednosti, širino tabel, rotiranje stolpcev,  +
# nove strani, poglavja, kazalo itd. generiramo s pomočjo latex kode, ki je +
# prenesena v R.
# V mapi latexkosi so denifirane tex. datoteke, ki so namenjene generiranju  +
# glave (prva stran, kazalo) in noge (zaključek) poročila
### Poročilo za izvajalca: glavno dokumenta definira tex datoteka a-glava.tex, +
# ki jo preberemo v skripti koda-izvajalec_predmet.r
### Poročilo za fakulteto: glavo dokumenta definira tex datoteka 
# a-glava-program.tex (glej skripto koda-fakulteta.r)
### Excel datoteka "navodila" je narejena s strani programerja in +
# služi opredelitvi anketnih vprašanj za izvajalca, ter predmete (ANKETA PRED IN PO IZPITU) +
# oz. komponent, po katerih računamo povprečja, kvantilne range, itd.
# Vsebuje tudi mejne vrednosti posameznih obarvanj (stolpec: pobarvanka), zaokroževanje +
# izračunanih povprečij v tabelah na eno decimalko (stolpec: decimalke), itd.

## //KRATEK OPIS STRUKTURE POROČIL// ##


## 1KA strežnik ##
# Del, ki ga potrebuje Peter, da generira ustrezno poročilo za posamezno fakulteto na strežniku
# Tega ne poganjamo
#params <- commandArgs(trailingOnly = TRUE)
#ID <- params[1]
## //1KA strežnik// ##


# Potrebne knjižnice #
libraries <- c('tools', 'psych', 'Hmisc', 'reports', 'fmsb','car','Cairo','openxlsx','qpcR')
lapply(libraries, FUN = function(y) {
  do.call('require', list(y))})
# //Potrebne knjižnice// #


# Naložimo dodatne funkcije (obarvanje povprečja + generiranje tabel v poglavju Analiza predmeta po programih in letnikih:
# glej poročilo za izvajalca ) 
# Če želimo spremeniti barvo, moramo novo barvo defnirati v skripti funkcije.r in v tex. datotekah (npr za izvajalca: a-glava.tex)
# !preveri! #
source('Evalvacija/R/funkcije/funkcije.r') # Barvanje povprečnih ocnen komponent, kvantilnig rangov, rotiranje imena stolpcev v tabelah, itd.
source('Evalvacija/R/funkcije/tabelaBy.r') # Generiranje nekaterih tabel (Glej poročilo za izvajalca: Analiza predmeta po programih in letnikih)

options(nwarnings = 10000)
# ignore these warnings:
# "[DATA NOT ENOUGH] at 3 NA" <- fmsb::radarchart ne more naredit radar grafa predmeta ker ni vsaj 3 vrednosti za ocene komponent predmeta
# "In FUN(newX[, i], ...) : no non-missing arguments to min; returning Inf/-Inf" <- ne more izračunat min in max ker je n=0


# Ustvarimo mapo, kjer se bodo shranjevale slike (grafi, histogrami, barploti)
dir.create('Evalvacija/results/part-izvajalec-slike', showWarnings = FALSE) # Slike za izvajalca 
dir.create('Evalvacija/results/part-predmet-slike', showWarnings = FALSE) # Slike za predmet

# Opredelimo ID fakultete, ki skrbi za to da se v poročilu (kjer je dogovorjeno) izpiše kratice fakultete,
# ime fakultete ter izriše logo fakultete. 
# (glej poročilo za izvajalca, ki ga generira R. skripta koda-izvajalec_predmet)
# ID skrbi tudi, da preberemo ustrezne CSV datoteke za ustrezno Fakulteto.
ID <- 3000023 # Ko se koda prenese na strežnik ID zakomentiramo, saj ga Peter ne Potrebuje
fakulteta <- ""
ime.fakultete <- ""
if (ID == 3000001) { # here
  fakulteta <- "PEF" # Purpose: Read CSV file which has "PEF" in the end of the file.
  studijska.praksa <- "Prakse PEF" # V primeru ko/če ima izvajalec študijsko prasko, se v izpisu za izvajalca ustvari poglavje: ŠTUDIJSKA PRAKSA, kjer se pri izrisu barplotov, namesto izpisa "Povprečje PEF", izpiše: "Prakse PEF" 
  ime.fakultete <- "Pedagoška fakulteta" # na prvi strani PDF poročila pod sliko
  logo <- "logo_PEF" # na prvi strani PDF poročila doda usterzno sliko fakultete (logo uporabimo pri generiranju poročil glej koda-izvajalec_predmet.r)
} else if (ID == 3000004){
  fakulteta <- "FU" # Purpose: Read CSV file which has "FU" in the end of the file.
  studijska.praksa <- "Prakse FU"
  ime.fakultete <- "Fakulteta za upravo"
  logo <- "logo_FU" # Logoi se nahajajo : latexkosi/logo/
} else if (ID == 3000006){
  fakulteta <- "FSD"
  studijska.praksa <- "Prakse FSD"
  ime.fakultete <- "Fakulteta za socialno delo"
  logo <- "logo_FSD"
} else if (ID == 3000009){
  fakulteta <- "FPP"
  studijska.praksa <- "Prakse FPP"
  ime.fakultete <- "Fakulteta za pomorstvo in promet"
  logo <- "logo_FPP"
} else if (ID == 3000011){
  fakulteta <- "ZF"
  studijska.praksa <- "Prakse ZF"
  ime.fakultete <- "Zdravstvena fakulteta"
  logo <- "logo_ZF"
} else if (ID == 3000018){
  fakulteta <- "FF"
  studijska.praksa <- "Prakse FF"
  ime.fakultete <- "Filozofska fakulteta"
  logo <- "logo_FF"
} else if (ID == 3000019){
  fakulteta <- "EF"
  studijska.praksa <- "Prakse EF"
  ime.fakultete <- "Ekonomska fakulteta"
  logo <- "logo_EF"
} else if (ID == 3000020){
  fakulteta <- "PF"
  studijska.praksa <- "Prakse PF"
  ime.fakultete <-"Pravna fakulteta"
  logo <- "logo_PF"
} else if (ID == 3000021){
  fakulteta <- "FDV"
  studijska.praksa <- "Prakse FDV"
  ime.fakultete <- "Fakulteta za družbene vede"
  logo <- "logo_FDV"
} else if (ID == 3000022){
  fakulteta <- "FSSS"
  studijska.praksa <- "Prakse FSSS"
  ime.fakultete <- "Fakulteta za šport"
  logo <- "logo_FSSS"
} else if (ID == 3000023){
  fakulteta <- "FS"
  studijska.praksa <- "Prakse FSTR"
  ime.fakultete <- "Fakulteta za strojništvo"
  logo <- "logo_FSTR"
} else if (ID == 3000025){
  fakulteta <- "FA"
  studijska.praksa <- "Prakse FA"
  ime.fakultete <- "Fakulteta za arhitekturo"
  logo <- "logo_FA"
} else if (ID == 3000026){
  fakulteta <- "FGG"
  studijska.praksa <- "Prakse FGG"
  ime.fakultete <- "Fakulteta za gradbeništvo in geodezijo"
  logo <- "logo_FGG"
} else if (ID == 3000027){
  fakulteta <- "FMF"
  studijska.praksa <- "Prakse FMF"
  ime.fakultete <- "Fakulteta za matematiko in fiziko"
  logo <- "logo_FMF"
} else if (ID == 3000029){
  fakulteta <- "NTF"
  studijska.praksa <- "Prakse NTF"
  ime.fakultete <- "Naravoslovnotehniška fakulteta"
  logo <- "logo_NTF"
} else if (ID == 3000030){
  fakulteta <- "FKKT"
  studijska.praksa <- "Prakse FKKT"
  ime.fakultete <- "Fakulteta za kemijo in kemijsko tehnologijo"
  logo <- "logo_FKKT"
} else if (ID == 3000031){
  fakulteta <- "FFA"
  studijska.praksa <- "Prakse FFARM"
  ime.fakultete <- "Fakulteta za farmacijo"
  logo <- "logo_FFARM"
} else if (ID == 3000037){
  fakulteta <- "VF"
  studijska.praksa <- "Prakse VF"
  ime.fakultete <- "Veterinarska fakulteta"
  logo <- "logo_VF"
} else if (ID == 3000041){
  fakulteta <- "MF"
  studijska.praksa <- "Prakse MF"
  ime.fakultete <- "Medicinska fakulteta"
  logo <- "logo_MF"
} else if (ID == 3000042){
  fakulteta <- "ALUO"
  studijska.praksa <- "Prakse ALUO"
  ime.fakultete <- "Akademija za likovno umetnost in oblikovanje"
  logo <- "logo_ALU"
} else if (ID == 3000043){
  fakulteta <- "AG"
  studijska.praksa <- "Prakse AG"
  ime.fakultete <- "Akademija za glasbo"
  logo <- "logo_AG"
} else if (ID == 3000044){
  fakulteta <- "AGRFT"
  studijska.praksa <- "Prakse AGRFT"
  ime.fakultete <- "Akademija za gledališče, radio, film in televizijo"
  logo <- "logo_AGRFT"
} else if (ID == 3000050){
  fakulteta <- "TEOF"
  studijska.praksa <- "Prakse TEOF"
  ime.fakultete <- "Teološka fakulteta"
  logo <- "logo_TEOF"
} else if (ID == 3000063){
  fakulteta <- "FRI"
  studijska.praksa <- "Prakse FRI"
  ime.fakultete <- "Fakulteta za računalništvo in informatiko"
  logo <- "logo_FRI"
} else if (ID == 3000064){
  fakulteta <- "FE"
  studijska.praksa <- "Prakse FE"
  ime.fakultete <- "Fakulteta za elektrotehniko"
  logo <- "logo_FE"
} else if (ID == 3000071){
  fakulteta <- "BF"
  studijska.praksa <- "Prakse BF"
  ime.fakultete <- "Biotehniška fakulteta"
  logo <- "logo_BF"
} else {
  fakulteta  <- ""
  studijska.praksa <- ""
  ime.fakultete <- ""
}
## //Opredelimo ID// ##


## //Preberemo vhodne datoteke// ##

# Preberemo vhodne datoteke glede na ID, ki so ga opredelili ##
# V navodilih so opredeljene komponente in definirana imena vprašanj +
# ankete 1KA za izvajalca (npr. IZPOUC1) in za predmet (npr. IZPREDa)
# Vrstice predstavljajo komponente za izvajalca in za predmete. 
# Definirana so tudi imena komponent, ki jih zapišemo v latex tabelah +
# (stolpec: ime.kratko) ter celotna imena komponent oz. anketnih vprašanj
# (glej stolpec: ime.dolgo)
# V navodilih so opredeljene spremenljivke, ki se nanašajo na spremenljivke v bazi (anketa pred in anketa po izpitu) ter
# dodana nova imena teh spremenljivk, ki smo jih generirali sami zaradi lažjega in hitrejšega pisanja nadalnje kode 
# (klicanje teh spremenljivk, ki se računajo)
navodila <- openxlsx::read.xlsx(xlsxFile = "Evalvacija/temp/navodila.xlsx", colNames = TRUE, rowNames = TRUE) # Glej excel navodila!

#Podatki za: Anketa PRED izpitom
data_pred_izpitom <- read.csv2(paste0("Evalvacija/temp/anketa_pred_izp_", fakulteta, ".csv"), sep=";", header = T, fill = T, stringsAsFactors = FALSE)
if (data_pred_izpitom[1,1] == "Ustreznost") {data_pred_izpitom <- data_pred_izpitom[2:nrow(data_pred_izpitom), ]}

# Ker je v šifrantu šifra študenta z velikimi črkami, v csv datotekah (anketa PRED in PO) pa z malimi, to ustrezno preoblikujemo (da se ujema)
# large font
#data_pred_izpitom$sifstud <- toupper(data_pred_izpitom$sifstud)
# Umetno generiramo šifre študentov, zato da lahko navidezno zrdužimo podatke pred izpitom in po izpitu
#!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# V letu 2017 je prišlo do spremembe v šifrantih, in sicer v obeh bazah odgovorov študentov
# 1KA (anketa pred izpitom in anketa PO izpitu) ne sem biti več ŠIFER ŠTUDENTOV, ki pa je v
# prejšnjih leti bila. Ker smo dve ločeni bazi (anketa pred in po izpitu)
# združevali na podlagi šifre študentov to več ni mogoče. Zato imamo dve rešitvi:
# 1) Celotno kodo preuredimo tako, da bomo podatke vlekli iz dveh različnih baz (data_pred_izpitom, data_po_izpitu)
# 2) Umetno geneiramo šifre študentov le zato, da bazi lahko združimo in ni potrebno preurejati kode na novo. 
# Zaradi velikeha prihranka časa smo izbrali drugo možnost!!!!!!!!!!!
# Umetno generirani ID študentov so uporabljeni le zaradi združevanja baz, in se jih ne upošteva nikjer drugje (npr računanje povprečij)
# Združimo torej zato, da ni potrebno razbijati in na novo urejati cele kode
# Sami generiramo id študentov, ki se bodo začeli z A1 in končali z An (odbisno od števila vrstic)
data_pred_izpitom$sifstud <- sort(sample(paste0("A", seq(1:nrow(data_pred_izpitom))), replace = FALSE), decreasing = TRUE)

# Sortiramo po velikosti oz. A1, A2, A3,.....
data_pred_izpitom$sifstud <- data_pred_izpitom$sifstud[order(gsub("([A-Z]+)([0-9]+)", "\\1", data_pred_izpitom$sifstud), 
                                                             as.numeric(gsub("([A-Z]+)([0-9]+)", "\\2", data_pred_izpitom$sifstud )))]
# Podatki za: Anketa PO izpitu
data_po_izpitu <- read.csv2(paste0("Evalvacija/temp/anketa_po_izpitu_", fakulteta, ".csv"), sep = ";", header = T, fill = T, stringsAsFactors = FALSE)
if (data_po_izpitu[1,1]=="Ustreznost") {data_po_izpitu <- data_po_izpitu[2:nrow(data_po_izpitu), ]}

# large font
#data_po_izpitu$sifstud <- toupper(data_po_izpitu$sifstud)

# Enako naredimo še za anketo PO izpitu
data_po_izpitu$sifstud <- sort(sample(paste0("A", seq(1:nrow(data_po_izpitu))), replace = FALSE), decreasing = FALSE)

# Sortiramo po velikosti oz. A1, A2, A3,.....
data_po_izpitu$sifstud  <- data_po_izpitu$sifstud [order(gsub("([A-Z]+)([0-9]+)", "\\1", data_po_izpitu$sifstud ), 
                                                         as.numeric(gsub("([A-Z]+)([0-9]+)", "\\2", data_po_izpitu$sifstud)))]
# Šifrant X1
# my_data <- read.delim("FGG.txt", sep="#" , header=F, stringsAsFactors = FALSE)
# my_data <- my_data[,2:ncol(my_data)]
# colnames(my_data) <- c("IDP",	"PREDMET",	"IDPEDAGOGA",	"NAZIV PEDAGOGA",	"NACIN_STUDIJA",	
#                        "SEMESTER_IZV",	"ST_KT",	"ST_STUD",	"NOSILEC", "STOPNJA", "PRAKSA", "IZVEDBA")
# 
# my_data["IZVEDBA"] <- NULL
# my_data["ST_STUD"] <- NULL
# my_data$IDP <- ifelse(my_data$NACIN_STUDIJA == 1, paste0(my_data$IDP,"_1"), paste0(my_data$IDP,"_2"))
# 
# my_data$IDP <- as.character(my_data$IDP)
# 
# sifrant <- read.csv2("sifrant_FGG.csv", sep = ";", header = T, fill = T, stringsAsFactors = FALSE)
# sifrant["IZVEDBA"] <- NULL
# 
# sifrantFDV <- merge(my_data, sifrant[c("IDP","IDPEDAGOGA","ST_STUD")], by = c("IDP","IDPEDAGOGA"), all = TRUE, sort = FALSE) 
# 
# sifrantFDV <- sifrantFDV[c("IDP",	"PREDMET", "IDPEDAGOGA", "NAZIV PEDAGOGA",	"NACIN_STUDIJA",	
#                            "SEMESTER_IZV",	"ST_KT",	"ST_STUD",	"STOPNJA",	"NOSILEC",	"PRAKSA")]
# 
# sifrantFDV <- subset(sifrantFDV, !is.na(PREDMET))
# 
# 
# write.csv2(sifrantFDV, "sifrant_FGG.csv", row.names = FALSE)

sifrant <- read.csv2(paste0("Evalvacija/temp/sifrant_", fakulteta, ".csv"), sep = ";", header = T, fill = T, stringsAsFactors = FALSE)

# 7.10.2017 nov sifrant X1, ki se bo uporabil za anlize. 
# za anlize se ne sme uporabiti novega stevila studentov, ker ni realno -
# tako da lahko se uporabi posodobljene podatke za pedagoge, stevilo studentov pa staro, 
# kot je bilo v prejsnjem sifrantu. 
# Zato moramo število študentov novega šifranta združiti, a ker so lahko nekateri pedagogi v novem
# šufrantu dodani bo to pominlo da bodo imeli pri ŠT študenov vrednost NA. Zato v kolikor ima 
St.stud.NA.<- list()
for (i in sifrant$IDP) {
  St.stud.NA.[[i]] <- subset(sifrant, IDP==i)
  if(any(duplicated(St.stud.NA.[[i]]$IDP))){
    if(!all(is.na(St.stud.NA.[[i]]$ST_STUD))){
      St.stud.NA.[[i]]$ST_STUD <- as.numeric(St.stud.NA.[[i]]$ST_STUD)
      St.stud.NA.[[i]]$ST_STUD <- max(St.stud.NA.[[i]]$ST_STUD, na.rm=T)
    }
  }
}
sifrant <-  do.call(rbind, lapply(St.stud.NA., data.frame, stringsAsFactors=FALSE))


# Šifrant X2
studenti <- read.csv2(paste0("Evalvacija/temp/studenti_", fakulteta, ".csv"), sep = ";", header = T, fill = T, stringsAsFactors = FALSE)
# // !!!!!!! // #
# Remove duplicated rows (remove diplucated students) from data frame študenti.
# Delamo samo takrat ko generiramo poročila za: Izvajalca, fakulteto in predmet!! 
# Ko generiramo poročila za posamezne PROGRAME, KATEDRE tega ne uporabimo!
# Podvojeni študenti so zaradi nekaterih fakultet, kjer so dvopredmetni programi 
# (npr. Filozofska fakulteta, Teološka fakulteta, itd.).
studenti <- studenti[!duplicated(studenti$ID_studenta_.MD5.), ]
# // !!!!!!! // #

# Šifrant X3
programi.imena <- read.csv2(paste0("Evalvacija/temp/programi_", fakulteta, ".csv"), fill = TRUE, sep = ";",header = T, stringsAsFactors = FALSE)
# Encoding(programi.imena$Naziv ) <- "UTF-8" # Če so pokvarjeni ČŽŠ-ji zaradi napačnega encodinga v šifrantih to ustrezno popravimo
# Ločimo univerzitetne in visokošolske programe z vrsto študija, ker so drugače podvojena imena (npr. Družboslovna informatika (uni))
programi.imena$Naziv <- paste0(programi.imena$Naziv, " (",programi.imena$Vrsta,")") # Imenu programa prilepimo vrsto študija  (npr. uni ali vs)

## //Preberemo vhodne datoteke// ##


# Naložimo dodatna navodila, ki imajo več nalog: (glej skripto navodila_dodatno-UTF-8.r)
source('Evalvacija/R/navodila_dodatno-UTF-8.r')


#-------------------------- MOREBITNE NESKLADNOSTI Z 1KA BAZO IN ŠIFRANTOM X1 -----------------------------#
# Preverimo ali so v bazi kakšni odgovori tistih izvajalcev, ki manjkajo v šifrantu X1. Npr izvajalec ima
# v bazi (anketa PRED izpitom) odgovore za predmet, ki v šifrantu X1 ni naveden oz. manjka
# Slednje lahko pivede do erorjev pri generiranju PDF poročil in časovne zamude, kar želimo preprečiti
library(tidyverse)
# ANKETA PRED
podatki.1KA.baza.PRED <- data_pred_izpitom %>% 
  gather(contains("sifizv"), 
         key = "sifizv", 
         value = "ID"
  ) %>% 
  select_("predmet","sifpredm","ID") %>% 
  unique()

# Kateri izvajalci so v 1KA bazi (imajo odgovore) a niso v šifrantu X1
output.pred <- anti_join(podatki.1KA.baza.PRED, sifrant , by = c("sifpredm" ="IDP","ID"="IDPEDAGOGA"))
# Izločimo vse manjkajoče oz. nevsebinske vrednosti respondenta (-1, -2, -5, itd)
output.pred <- output.pred[! output.pred$ID %in% junk.komentar, ]


# PREVERI #
if (nrow(output.pred) >= 1) { # Če je output.pred < 1 to pomeni, da sta bazi 1KA odgovorov (anketa PRED) in šifrant X1 skladni zato lahko nadaljujemo z izračuni
  cat("V bazi 1KA (anketa PRED izpitom) se nahaja izvajalec z ID-jem",paste(output.pred$ID, collapse =  ' , '), "ki ga v šifrantu X1 ni!!!!!")
   warning("Izvajalci ki so v 1KA bazi, manjkajo v šifrantu X1")
}
# PREVERI #

#------------------------- //MOREBITNE NESKLADNOSTI Z 1KA BAZO IN ŠIFRANTOM X1// ---------------------------#


#--------------------------------------- AGREGAT SUMARNIH PREDMETOV -----------------------------------------#
if (ID == 3000043){ # Če je ID == Fakulteta za Glasbo združimo določene predmete iz šifranta x7 v meta predmet
source('Evalvacija/R/metapredmeti.r') 
}
#------------------------------------ //AGREGAT SUMARNIH PREDMETOV// ----------------------------------------#


# Urejanje 
sifrant$PREDMET <- trim(sifrant$PREDMET) # remove extra spaces # trim funkcija je definirana v funkcije.r
sifrant$PREDMET <- sub("^\\.", "", sifrant$PREDMET) # remove dots in front of course names (FDV!)
sifrant$NAZIV.PEDAGOGA <- trim(sifrant$NAZIV.PEDAGOGA) # remove extra spaces


# preverba če ni kakšna šifra predmeta * šifra izvajalca v šifrantu podvojena
# npr. izvajalec je imel napačno šifro in dve izvedbi (redna/izredna) nista imeli različnih šifer
podvojeniID <- table(paste(sifrant$IDP, sifrant$IDPEDAGOGA, sep = '*'))
if (max(podvojeniID) > 1) {
  sumljivci <- paste(names(podvojeniID[which(podvojeniID > 1)]), collapse = '\n')
  warning("All course*lecturer ID's in sifrant should be unique!!\nThese are not:\n", sumljivci)
}

# V excel datoteki navodila poiščemo vzorec "izvajalec" in zajamemo vse vrstice, 
# kjer se pojavlja. Enako naredimo še za predmet in študenta.
# saj gre za komponente, po katerih računamo povprečja, kvantile za izvajalce ali predmete. 
# Kaj komponente? Glej excel datoteko navodila
navI <- navodila[grepl(pattern='izvajalec.*', rownames(navodila)), ]
navP <- navodila[grepl(pattern='predmet.*', rownames(navodila)), ]
navS <- navodila[grepl(pattern='student.*', rownames(navodila)), ]

lokacije.izvajalci <- navI[, grepl(pattern='izvajalec.\\d', colnames(navodila))]
lokacije.predmet <- navP[, 'lokacije.predmet', drop = FALSE] # drop = False, ker želimo ohraniti podatkovni okvir 
lokacije.student <- navS[, 'lokacije.student', drop = FALSE]


## ZDRUŽEVANJE SPREMENLJIVK V VARS.IZVAJALEC in VARS.PREDMET ##
# Spremenljivke oz komponente po katerih računamo posamezna povprečja bi se dalo tudi neposredno računati z 
# navajanjem imen posameznih sprmenljivk v bazih anketa pred in anketa po izpitu. Npr namesto izvajalec ocena kakovost 
# bi generirali vector s spremenljivko IZMNE1a. Ta spremenljivka je tako poimenovana v bazi.
# Združimo spremenljivke oz komponente za izvajalca v EXCEL DATOTEKI NAVODILA #
# Združimo zato, da ni potrebno navajati (npr. računanje) imen posameznih spremenljivk, ki se nahajajo v anketi pred in po.
# Komponente, ki se bodo računale oz. stolpce združimo v list, katerega nato kličemo pri računanju in pri generiranju tabel
vars.izvajalec <- list(
  cont = list(vars = rownames(navI)[navI$tip == 'CONT' & !is.na(navI$tip)]),  # "CONT" pomeni, da gre za zaprto vprašanje
  text = list(vars = rownames(navI)[navI$tip == 'TEXT' & !is.na(navI$tip)]))  # "TEXT" pomeni, da gre za odprto vprašanje (glej npr 26 vrstico v excel datoteki navodila)

vars.izvajalec$cont$ime.kratko[vars.izvajalec$cont$vars] <- navI[vars.izvajalec$cont$vars, 'ime.kratko'] # ime.kratko (glej navodila) in tabele pri poročilu izvajalca. Npr ime.kratko se pojavlja v Tabeli 1.1: Poročilo izvajalca 
vars.izvajalec$text$ime.kratko[vars.izvajalec$text$vars] <- navI[vars.izvajalec$text$vars, 'ime.kratko']
vars.izvajalec$cont$ime.dolgo[vars.izvajalec$cont$vars] <- navI[vars.izvajalec$cont$vars, 'ime.dolgo'] # Celoten tekst zaprtih vprašanj za tabele (glej izpis izvajalca)
vars.izvajalec$text$ime.dolgo[vars.izvajalec$text$vars] <- navI[vars.izvajalec$text$vars, 'ime.dolgo'] # Celoten tekst odprtih vprašanj za tabele (glej izpis izvajalca)
vars.izvajalec$cont$pobarvanka[vars.izvajalec$cont$vars] <- navI[vars.izvajalec$cont$vars, 'pobarvanka'] # V excel datoteki opredelimo
# meje barvanja za posamezno komponento (glej stolpec pobarvanka). 
# Te meje potem zapišemo v funkcijo s katero barvamo povprečja (glej skripto funkcije.r)
vars.izvajalec$cont$decimalke[vars.izvajalec$cont$vars] <- navI[vars.izvajalec$cont$vars, 'decimalke.tabele'] # zaokroževanje obarvanih vrednosti na 1 decimalko (glej funkcije.r)


# Združimo spremenljivke oz komponente za PREDMETE (PRED IN PO) v EXCEL DATOTEKI navodila#
# Stolpce oz spremenljivke, ki se računajo združimo v list
vars.predmet <- list(
  cont=list(vars=c(rownames(navP)[navP$tip == 'CONT' & !is.na(navP$tip) & navP$cont.pred.po.izpitu == "PRED"], # Komponente PRED izpitom 
                   rownames(navP)[navP$tip == 'CONT' & !is.na(navP$tip) & navP$cont.pred.po.izpitu == "PO"],   # Komponente PO izpitu
                   rownames(navP)[navP$tip == 'CONT' & !is.na(navP$tip) & navP$cont.pred.po.izpitu == "PRAKSA"])), # Komponente, ki vsebujejo oceno za študijsko prakso
  text=list(vars=rownames(navP)[navP$tip == 'TEXT' & !is.na(navP$tip)]),
  krediti=list(vars=rownames(navP["predmet.ocena.krediti", ])),
  kompetence1=list(vars=rownames(navP["predmet.ocena.kompetence1", ])))

# Ločimo kompponente po katerih računamo povprečja za predmete, 
# in sicer komponente PRED IZPITOM, komponente PO IZPITU IN komponente za študijsko PRAKSO (zaradi računanja vrednosti in izpisa poročil)
vars.predmet$cont$pred <- rownames(navP)[navP$tip == 'CONT' & !is.na(navP$tip) & navP$cont.pred.po.izpitu == "PRED"] 
vars.predmet$cont$po <- rownames(navP)[navP$tip == 'CONT' & !is.na(navP$tip) & navP$cont.pred.po.izpitu == "PO"]
vars.predmet$cont$praksa   <- rownames(navP)[navP$tip == 'CONT' & !is.na(navP$tip) & navP$cont.pred.po.izpitu == "PRAKSA"]

vars.predmet$cont$ime.kratko[vars.predmet$cont$vars] <- navP[vars.predmet$cont$vars, 'ime.kratko']
vars.predmet$text$ime.kratko[vars.predmet$text$vars] <- navP[vars.predmet$text$vars, 'ime.kratko']
vars.predmet$krediti$ime.kratko[vars.predmet$krediti$vars] <- navP[vars.predmet$krediti$vars, 'ime.kratko']
vars.predmet$kompetence1$ime.kratko[vars.predmet$kompetence1$vars] <- navP[vars.predmet$kompetence1$vars, 'ime.kratko']
vars.predmet$cont$ime.dolgo[vars.predmet$cont$vars] <- navP[vars.predmet$cont$vars, 'ime.dolgo']
vars.predmet$text$ime.dolgo[vars.predmet$text$vars] <- navP[vars.predmet$text$vars, 'ime.dolgo']
vars.predmet$krediti$ime.dolgo[vars.predmet$krediti$vars] <- navP[vars.predmet$krediti$vars, 'ime.dolgo']
vars.predmet$kompetence1$ime.dolgo[vars.predmet$kompetence1$vars] <- navP[vars.predmet$kompetence1$vars, 'ime.dolgo']

# Labele za komponenti Porabljeno število ur in za kompetence (glej poročilo za izvajalca, poglavje: Število porabljenih ur (anketa PO izpitu))
# Labele: "1 - Veliko manj"   "2 - Nekoliko manj" "3 - Predvideno"    "4 - Nekoliko več"  "5 - Veliko več"  
vars.predmet$krediti$labele[vars.predmet$krediti$vars] <- strsplit(navP["predmet.ocena.krediti","labele"], split = ",")
vars.predmet$kompetence1$labele[vars.predmet$kompetence1$vars] <- strsplit(navP["predmet.ocena.kompetence1","labele"], split = ",")

# we don't use whole wording for graph labels
# Labele (graf) za komponento "Ustreznost KT" oz Število porabljenih ur (anketa PO izpitu) <- glej poročilo za izvajalca slika:
# Frekvenčna porazdelitev za število porabljenih ur (anketa PO izpitu)
vars.predmet$krediti$labele.graf <- vars.predmet$krediti$labele[vars.predmet$krediti$vars]
vars.predmet$krediti$labele.graf[[vars.predmet$krediti$vars]][c(2,4)] <- c("2", "4")

# Labele za komponento "kompetence" <-glej poročilo za izvajalca
vars.predmet$kompetence1$labele.graf <- vars.predmet$kompetence1$labele[vars.predmet$kompetence1$vars]
vars.predmet$kompetence1$labele.graf[[vars.predmet$kompetence1$vars]][c(2,4)] <- c("2", "4")

# "3,4,Inf,Inf" So meje barvanja, ki smo jih določili v excel datoteki navodila, in sicer stolpec "pobarvanka"
# za 3,4,Inf,Inf -> manj kot 3 je bold redeče, 3 ali več in manj kot 4 je samo rdeče, Inf, Inf pomeni da ni zgornje meje za barvanja.
# Katera barva pripada posamezni vrednosti v tabelah definiramo v skripti funkcije.r
vars.predmet$cont$pobarvanka[vars.predmet$cont$vars] <- navP[vars.predmet$cont$vars, 'pobarvanka']
vars.predmet$krediti$pobarvanka[vars.predmet$krediti$vars] <- navP[vars.predmet$krediti$vars, 'pobarvanka']
vars.predmet$kompetence1$pobarvanka[vars.predmet$kompetence1$vars] <- navP[vars.predmet$kompetence1$vars, 'pobarvanka']

# Vse vrednosti bodo v tabelah zaokrožene na eno decimalno mesto. Temu služi stolpec "decimalke.tabele" v excel datoteki navodila
vars.predmet$cont$decimalke[vars.predmet$cont$vars] <- navP[vars.predmet$cont$vars, 'decimalke.tabele']
vars.predmet$krediti$decimalke[vars.predmet$krediti$vars] <- navP[vars.predmet$krediti$vars, 'decimalke.tabele']
vars.predmet$kompetence1$decimalke[vars.predmet$kompetence1$vars] <- navP[vars.predmet$kompetence1$vars, 'decimalke.tabele']
####################

# Kot smo že omenili želimo združiti bazi, kar naredimo na podlagi šifer predmetov in šifer študentov, ki smo
# jih za leto 2016/2017 simulirali. 
# merging data from before and after exam databases - each student must have only 1 row for each course
data <- merge(data_pred_izpitom, data_po_izpitu, by = c(navodila["student.sifra","lokacije.student"],
                                                        navodila["predmet.sifra","lokacije.predmet"]), all = TRUE)

#######################################################################################
# premetavanje
#######################################################################################

######################
# PODATKI ZA IZVAJALCE (premetavanje po anketah -> po izvajalcih)
#####################
# Število izvajalcev v bazi
lokacije.izvajalci.names <- names(data)[grepl( "izvajalec." , names(data))]
lokacije.izvajalci <- lokacije.izvajalci[,1:length(lokacije.izvajalci.names)]
data.izvajalci <- NULL
for (i in names(lokacije.izvajalci)){ # lokacije.izvajalci in lokacije.predmet <- v excel datoteki Navodila
  data.temp <- data[c(lokacije.predmet[, 1], as.vector(lokacije.izvajalci[[i]]),"idprog.x","letnik.x","program.x","lurker.x")] # spremenljivke ki smo jih določili glede na predavatelje v csv uvoženi tabeli
  names(data.temp) <- c(rownames(lokacije.predmet), rownames(lokacije.izvajalci), "ID_vrsta_studija","Letnik","Naziv","lurker")
  data.temp <- subset(data.temp, izvajalec.sifra > 0) # samo kjer je naveden izvajalec
  if (is.null(data.izvajalci)) {
    data.izvajalci <- data.temp
  } else {
    data.izvajalci <- rbind(data.izvajalci,data.temp)
  }
}

# Izločimo vse manjkajoče vrednosti
# setting missing values and keeping some (defined in navodila.xlsx in column missing.table) for frequency tables
someMissVars <- rownames(navodila[!is.na(navodila$missings.table), ])
data.izvajalci.someMiss <- data.izvajalci[c("predmet.sifra","izvajalec.sifra",someMissVars)]
for (var in c(vars.predmet$cont$vars,vars.predmet$text$vars,vars.predmet$krediti$vars,
              vars.predmet$kompetence1$vars,vars.izvajalec$cont$vars,vars.izvajalec$text$vars)) {
  miss <- unlist(strsplit(navodila[var,]$missings, ","))
  data.izvajalci[, var][data.izvajalci[, var] %in% miss] <- NA
  if (var %in% c(vars.predmet$cont$vars,vars.predmet$krediti$vars,
                 vars.predmet$kompetence1$vars,vars.izvajalec$cont$vars)) {
    data.izvajalci[, var] <- as.numeric(data.izvajalci[, var])
  }
  if (var %in% someMissVars) {
    someMissVals <- matrix(unlist(strsplit(unlist(strsplit(navodila[var,]$missings.table, ",")), "=")), ncol = 2, byrow = TRUE)
    miss <- miss[!(miss %in% someMissVals[, 1])]
    data.izvajalci.someMiss[, var][data.izvajalci.someMiss[, var] %in% miss] <- NA
    for (missVar in 1:nrow(someMissVals)) {
      data.izvajalci.someMiss[, var][data.izvajalci.someMiss[, var] == someMissVals[missVar,1] &
                                       !is.na(data.izvajalci.someMiss[, var])] <- someMissVals[missVar,2]
    }
  }
}
# all values with some miss for tables
# Glej tabelo Povprečja in deleži kategorij odgovorov za komponente pedagoškega dela izvajalca pri predmetu (anketa PRED izpitom)"
izvajalec.someMiss <- sort(unique(as.vector(as.matrix(data.izvajalci.someMiss[,vars.izvajalec$cont$vars]))))

# Check if values are missing. We need column_name for table making
# V poročilu za izvajalca glej podpoglavje: Frekvenčna porazdelitev ocen komponent pedagoškega dela izvajalca 
# V primeru, da kakšna vrednost manjka jo ustvarimo, sicer ko poženemo koda-izvajalec_predmet ne generira tabel
column_name <- c("1","2","3","4","5","Ne želim odgovoriti","Nimam dovolj informacij")

if (length(which(izvajalec.someMiss %in% column_name)) < 7) {
  # Če so kakšne manjkajoče vrednosti, ki se dodajajo v tabele kot imena stolpcev za izvajalca
  Missing <- setdiff(column_name, izvajalec.someMiss)  # Find names of missing columns
  izvajalec.someMiss <- c(Missing,izvajalec.someMiss)
  izvajalec.someMiss <- sort(izvajalec.someMiss)
}
# //column_name// #


data.izvajalci <- data.izvajalci[order(data.izvajalci$izvajalec.sifra, data.izvajalci$predmet.sifra), ]
# Število vseh odgovorov. To so odgovori na predmet in izvajalca
# '-1' neodgovorjeno vprašanje, '-2' preskok zaradi pogoja (IF)
data.izvajalci$veljavna.vsiodgovori <- data.izvajalci$predmet.izpolnjeval.pred == -1 & (data.izvajalci$izvajalec.jepouceval == 1 | data.izvajalci$izvajalec.jepouceval == 2 | data.izvajalci$izvajalec.jepouceval == -2)
# Število odgovorov izvajalca
# ali je anketa veljavna za izvajalca; ali je student ni izpolnjeval (je pa začel anketo)
data.izvajalci$veljavna <- data.izvajalci$predmet.izpolnjeval.pred == -1 & (data.izvajalci$izvajalec.jepouceval == 1 | data.izvajalci$izvajalec.jepouceval == -2)
data.izvajalci$zavrnjena <- (!data.izvajalci$veljavna & !is.na(data.izvajalci$predmet.izpolnjeval.pred) & !is.na(data.izvajalci$izvajalec.jepouceval) & !(data.izvajalci$izvajalec.jepouceval == 2))
data.izvajalci$nipouceval <- data.izvajalci$izvajalec.jepouceval == 2 # Če je študent v anketi pred izpitom odgovoril, da ga izvajalec pri tem predmetu ni poučeval
# adding student data (year and programme)
data.izvajalci <- merge(data.izvajalci, programi.imena[,c("ID", "Naziv")], by.x = "ID_vrsta_studija", by.y = "ID", all.x = TRUE, sort = FALSE)
names(data.izvajalci)[match(c("ID_vrsta_studija","Letnik","Naziv.y"), names(data.izvajalci))] <- c("student.program.sifra","student.letnik","student.program.ime")


# if (ID == "3000025") {
# sifre <- c("317_1","317_2","326_1","337_1","436_1","472_1","335_1","345_1","354_1")
# 
# r <- with(data.izvajalci, which(data.izvajalci$predmet.sifra %in% sifre & data.izvajalci$izvajalec.jepouceval !="1"), arr.ind=TRUE)
# 
# newd <- data.izvajalci[-r, ]
# 
# data.izvajalci <- newd
# }

#####################
# PODATKI ZA PREDMETE
#####################
data.predmeti <- data[c(lokacije.predmet[, 1], lokacije.student[, 1],"idprog.x","letnik.x","program.x", "lurker.x")] # Združimo spremenljivke v lokacije.predmet[, 1] in šifro študentov 
names(data.predmeti) <- c(rownames(lokacije.predmet), rownames(lokacije.student),"ID_vrsta_studija","Letnik","Naziv","lurker")
someMissVars <- rownames(navP[!is.na(navP$missings.table), ])
data.predmeti.someMiss <- data.predmeti[c("predmet.sifra", someMissVars)]
# setting missing values and keeping some (defined in navodila.xlsx in column missing.table) for frequency tables
for (var in c(vars.predmet$cont$vars,vars.predmet$text$vars,vars.predmet$krediti$vars,vars.predmet$kompetence1$vars)) {
  miss <- unlist(strsplit(navodila[var,]$missings, ","))
  data.predmeti[, var][data.predmeti[, var] %in% miss] <- NA
  if (var %in% c(vars.predmet$cont$vars,vars.predmet$krediti$vars,vars.predmet$kompetence1$vars)) {
    data.predmeti[, var] <- as.numeric(data.predmeti[, var])
  }
  if (var %in% someMissVars) {
    someMissVals <- matrix(unlist(strsplit(unlist(strsplit(navodila[var,]$missings.table, ",")), "=")), ncol = 2, byrow = TRUE)
    miss <- miss[!(miss %in% someMissVals[, 1])]
    data.predmeti.someMiss[, var][data.predmeti.someMiss[, var] %in% miss] <- NA
    for (missVar in 1:nrow(someMissVals)) {
      data.predmeti.someMiss[, var][data.predmeti.someMiss[, var] == someMissVals[missVar, 1] & 
                                      !is.na(data.predmeti.someMiss[, var])] <- someMissVals[missVar, 2]
    }
  }
}
# all values with some miss for tables
predmet.someMiss <- sort(unique(as.vector(as.matrix(data.predmeti.someMiss[, vars.predmet$cont$vars]))))
if(any(predmet.someMiss=="")) {
  predmet.someMiss <- predmet.someMiss[predmet.someMiss != ""]
  
}

# data.predmeti$predmet.sifra <- as.numeric(data.predmeti$predmet.sifra)
data.predmeti <- data.predmeti[order(data.predmeti$predmet.sifra),]
# ali je anketa veljavna za predmet; ali je student ni izpolnjeval (je pa začel anketo)
# '-1' neodgovorjeno vprašanje
data.predmeti$veljavna <-  data.predmeti$predmet.izpolnjeval.pred == -1 & !is.na(data.predmeti$predmet.izpolnjeval.pred)
data.predmeti$veljavna_po_izpitu <- data.predmeti$predmet.izpolnjeval.po == -1 & !is.na(data.predmeti$predmet.izpolnjeval.po)
data.predmeti$zavrnjena <- (!data.predmeti$veljavna & !is.na(data.predmeti$predmet.izpolnjeval.pred))
data.predmeti$zavrnjena_po_izpitu <- (!data.predmeti$veljavna_po_izpitu & !is.na(data.predmeti$predmet.izpolnjeval.po))
# adding student data (year and programme)
data.predmeti <- merge(data.predmeti, programi.imena[,c("ID", "Naziv")], by.x="ID_vrsta_studija", by.y="ID", all.x=TRUE, sort=FALSE)
names(data.predmeti)[match(c("ID_vrsta_studija","Letnik","Naziv.y"), names(data.predmeti))] <- c("student.program.sifra","student.letnik","student.program.ime")

# ali so v bazi kakšni predmeti ki jih ni v šifrantu
test2 <- unique(data.predmeti$predmet.sifra)[!(unique(data.predmeti$predmet.sifra) %in% unique(sifrant$IDP))]
if (length(test2) > 0) {
  test2 <- paste(test2, collapse='\n')
  warning('V šifrantu ni predmetov, ki pa so v bazi:\n', test2)
}

# zapis obeh baz na katerih se dela naprej
#write.csv2(data.izvajalci, paste0("results/data.izvajalci_", fakulteta, ".csv"))
# #write.csv2(data.predmeti, paste0("results/data.predmeti_", fakulteta, ".csv"))

# Če je output.pred > 1 to pomeni, da sta bazi 1KA odgovorov (anketa PRED) in šifrant X1 neskladni
if (nrow(output.pred) > 0) {
 # data.izvajalci <- data.izvajalci[!(data.izvajalci$predmet.sifra %in% output.pred$sifpredm & 
 #                                      data.izvajalci$izvajalec.sifra %in% output.pred$ID), ]
 data.izvajalci <-  data.izvajalci[! paste(data.izvajalci$predmet.sifra, data.izvajalci$izvajalec.sifra) %in%
                                    paste(output.pred$sifpredm, output.pred$ID), ]
}

#######################################################################################
# izračuni opisnih statistik
#######################################################################################

###############
## IZVAJALCI ##
###############
# povprečja
izvMean <- aggregate(data.izvajalci[vars.izvajalec$cont$vars],by = data.izvajalci[c("predmet.sifra","izvajalec.sifra")], FUN = mean, na.rm = TRUE)
colnames(izvMean)[3:ncol(izvMean)] <- paste0(vars.izvajalec$cont$vars,"_mean")

# mediane
izvMedian <- aggregate(data.izvajalci[vars.izvajalec$cont$vars], by = data.izvajalci[c("predmet.sifra","izvajalec.sifra")], FUN = median, na.rm = TRUE)
colnames(izvMedian)[3:ncol(izvMedian)] <- paste0(vars.izvajalec$cont$vars,"_median")

# sd
izvSd <- aggregate(data.izvajalci[vars.izvajalec$cont$vars],by = data.izvajalci[c("predmet.sifra","izvajalec.sifra")], FUN = sd, na.rm = TRUE)
colnames(izvSd)[3:ncol(izvSd)] <- paste0(vars.izvajalec$cont$vars,"_sd")

# min
izvMin <- aggregate(data.izvajalci[vars.izvajalec$cont$vars],by = data.izvajalci[c("predmet.sifra","izvajalec.sifra")], FUN = min, na.rm = TRUE)
colnames(izvMin)[3:ncol(izvMin)] <- paste0(vars.izvajalec$cont$vars,"_min")
izvMin[izvMin==Inf] <- NA

# max
izvMax <- aggregate(data.izvajalci[vars.izvajalec$cont$vars],by = data.izvajalci[c("predmet.sifra","izvajalec.sifra")], FUN = max, na.rm = TRUE)
colnames(izvMax)[3:ncol(izvMax)] <- paste0(vars.izvajalec$cont$vars,"_max")
izvMax[izvMax==-Inf] <- NA

# N posamezne spremenljivke
izvN <- aggregate(data.izvajalci[vars.izvajalec$cont$vars], by = data.izvajalci[c("predmet.sifra","izvajalec.sifra")], FUN=function(x) sum(!is.na(x)))
colnames(izvN)[3:ncol(izvN)] <- paste0(vars.izvajalec$cont$vars,"_N")

# N anket
izvNanket <- aggregate(data.izvajalci$veljavna,by=data.izvajalci[c("predmet.sifra","izvajalec.sifra")], FUN = sum)
colnames(izvNanket)[3] <- "N_anket"

# N vseh odgovorov
izvNanketvsiodgovori <- aggregate(data.izvajalci$veljavna.vsiodgovori,by=data.izvajalci[c("predmet.sifra","izvajalec.sifra")], FUN = sum)
colnames(izvNanketvsiodgovori)[3] <- "N_anketSkupaj"

# N zavrnjenih anket
izvNzavrnjenih <- aggregate(data.izvajalci$zavrnjena,by = data.izvajalci[c("predmet.sifra","izvajalec.sifra")], FUN = sum)
colnames(izvNzavrnjenih)[3] <- "N_zavrnjenih"


# N Lurkerjev PRED izpitom
data.izvajalci$lurker[data.izvajalci$lurker==0] <- NA
izvNLurkerji <- aggregate(as.numeric(data.izvajalci$lurker), by = data.izvajalci[c("predmet.sifra","izvajalec.sifra")],FUN=function(x) sum(!is.na(x)))
colnames(izvNLurkerji)[3] <- "N_lurkerjev_ivz"

# N anket: Izvajalec ni poučeval
izvNipouceval <-  aggregate(data.izvajalci$nipouceval,by=data.izvajalci[c("predmet.sifra","izvajalec.sifra")], FUN = sum)
colnames(izvNipouceval)[3] <- "Ni_pouceval"

# Prvi kvartil Q1
izvQ1 <- aggregate(data.izvajalci[vars.izvajalec$cont$vars], by = data.izvajalci[c("predmet.sifra","izvajalec.sifra")],  FUN = quantile, probs  = c(0.25),na.rm=T)
colnames(izvQ1)[3:ncol(izvQ1)] <- paste0(vars.izvajalec$cont$vars,"_Q1")

# Tretji kvartil
izvQ3 <- aggregate(data.izvajalci[vars.izvajalec$cont$vars], by = data.izvajalci[c("predmet.sifra","izvajalec.sifra")],  FUN = quantile, probs  = c(0.75),na.rm=T)
colnames(izvQ3)[3:ncol(izvQ3)] <- paste0(vars.izvajalec$cont$vars,"_Q3")

# Prvi decil
izvD1 <- aggregate(data.izvajalci[vars.izvajalec$cont$vars], by = data.izvajalci[c("predmet.sifra","izvajalec.sifra")],  FUN = quantile, probs  = c(0.1), type=5,na.rm=T)
colnames(izvD1)[3:ncol(izvD1)] <- paste0(vars.izvajalec$cont$vars,"_D1")

# Deveti decil
izvD9 <- aggregate(data.izvajalci[vars.izvajalec$cont$vars], by = data.izvajalci[c("predmet.sifra","izvajalec.sifra")],  FUN = quantile, probs  = c(0.9), type=5,na.rm=T)
colnames(izvD9)[3:ncol(izvD9)] <- paste0(vars.izvajalec$cont$vars,"_D9")

# Zdužimo opisne statistike izvajalcev
povprecja.izvajalci <- merge(izvMean, izvSd, by = c("izvajalec.sifra", "predmet.sifra"), all = TRUE, sort = FALSE)
povprecja.izvajalci <- merge(povprecja.izvajalci, izvMin,by = c("izvajalec.sifra", "predmet.sifra"), all = TRUE, sort = FALSE)
povprecja.izvajalci <- merge(povprecja.izvajalci, izvMax, by = c("izvajalec.sifra", "predmet.sifra"), all = TRUE, sort = FALSE)
povprecja.izvajalci <- merge(povprecja.izvajalci, izvN, by = c("izvajalec.sifra", "predmet.sifra"), all = TRUE, sort = FALSE)
povprecja.izvajalci <- merge(povprecja.izvajalci, izvNanket,  by = c("izvajalec.sifra", "predmet.sifra"), all = TRUE, sort = FALSE)
povprecja.izvajalci <- merge(povprecja.izvajalci, izvNanketvsiodgovori,  by = c("izvajalec.sifra", "predmet.sifra"), all = TRUE, sort = FALSE)
povprecja.izvajalci <- merge(povprecja.izvajalci, izvNzavrnjenih, by = c("izvajalec.sifra", "predmet.sifra"), all = TRUE, sort = FALSE)
povprecja.izvajalci <- merge(povprecja.izvajalci, izvNipouceval, by = c("izvajalec.sifra", "predmet.sifra"), all = TRUE, sort = FALSE)
povprecja.izvajalci <- merge(povprecja.izvajalci, izvQ1,  by = c("izvajalec.sifra", "predmet.sifra"), all = TRUE, sort = FALSE)
povprecja.izvajalci <- merge(povprecja.izvajalci, izvQ3,  by = c("izvajalec.sifra", "predmet.sifra"), all = TRUE, sort = FALSE)
povprecja.izvajalci <- merge(povprecja.izvajalci, izvMedian ,  by = c("izvajalec.sifra", "predmet.sifra"), all = TRUE, sort = FALSE)
povprecja.izvajalci <- merge(povprecja.izvajalci, izvD1, by = c("izvajalec.sifra", "predmet.sifra"), all = TRUE, sort = FALSE)
povprecja.izvajalci <- merge(povprecja.izvajalci, izvD9,  by = c("izvajalec.sifra", "predmet.sifra"), all = TRUE, sort = FALSE)
povprecja.izvajalci <- merge(povprecja.izvajalci, izvNLurkerji,  by = c("izvajalec.sifra", "predmet.sifra"), all = TRUE, sort = FALSE)


# združit s šifrantom
povprecja.izvajalci <- merge(povprecja.izvajalci, sifrant, 
                             by.x = c("izvajalec.sifra", "predmet.sifra"), 
                             by.y = c("IDPEDAGOGA", "IDP"), all.x = TRUE, sort = FALSE)

# write.csv2(povprecja.izvajalci, paste0("results/povprecja.izvajalci_", fakulteta, ".csv"))


# zakrivanje vrednosti kjer ni dovolj enot
premalo <- povprecja.izvajalci[paste0(vars.izvajalec$cont$vars,"_N")] < minEnot
povprecja.izvajalci[paste0(vars.izvajalec$cont$vars,"_mean")][premalo] <- NA
povprecja.izvajalci[paste0(vars.izvajalec$cont$vars,"_sd")][premalo] <- NA
povprecja.izvajalci[paste0(vars.izvajalec$cont$vars,"_min")][premalo] <- NA
povprecja.izvajalci[paste0(vars.izvajalec$cont$vars,"_max")][premalo] <- NA


# Kjer je negativno število pomeni, da gre za več vpisanih študentov, kot jih je v bazi oz spremenljivki ST_STUD
povprecja.izvajalci$ST_STUD <- ifelse(povprecja.izvajalci$ST_STUD < as.numeric(povprecja.izvajalci$N_anket) + as.numeric(povprecja.izvajalci$N_zavrnjenih),
                                      as.numeric(povprecja.izvajalci$N_anket) + as.numeric(povprecja.izvajalci$N_zavrnjenih),povprecja.izvajalci$ST_STUD)

# povprečje vseh komponent izvajalca
povprecja.izvajalci$izvajalec.ocena.SKUPAJ <- rowMeans(povprecja.izvajalci[paste0(vars.izvajalec$cont$vars,"_mean")], na.rm = T)

# % sodelujocih
povprecja.izvajalci$sodelujocih.pct <- povprecja.izvajalci$N_anket / as.numeric(povprecja.izvajalci$ST_STUD) * 100

# % zavrnjenih
povprecja.izvajalci$zavrnjenih.pct <- povprecja.izvajalci$N_zavrnjenih / as.numeric(povprecja.izvajalci$ST_STUD) * 100

# % Ni pouceval
povprecja.izvajalci$nipouceval.pct <- povprecja.izvajalci$Ni_pouceval / as.numeric(povprecja.izvajalci$ST_STUD) * 100

## N in % neodzivnih
#intersect(as, povprecja.izvajalci$ST_STUD)
povprecja.izvajalci$N_neodzivnih <- as.numeric(povprecja.izvajalci$ST_STUD) - povprecja.izvajalci$N_anketSkupaj - povprecja.izvajalci$N_zavrnjenih
povprecja.izvajalci$neodzivnih.pct  <- povprecja.izvajalci$N_neodzivnih / as.numeric(povprecja.izvajalci$ST_STUD) * 100
## //IZVAJALCI// ##

##############
## PREDMETI ##
##############
# povprečja
predMean <- aggregate(data.predmeti[c(vars.predmet$cont$vars,vars.predmet$krediti$vars,vars.predmet$kompetence1$vars)], by = data.predmeti["predmet.sifra"], FUN = mean, na.rm = TRUE)
colnames(predMean)[2:ncol(predMean)] <- paste0(c(vars.predmet$cont$vars,vars.predmet$krediti$vars,vars.predmet$kompetence1$vars),"_mean")

# Mediane
predMedian <- aggregate(data.predmeti[c(vars.predmet$cont$vars,vars.predmet$krediti$vars,vars.predmet$kompetence1$vars)], by = data.predmeti["predmet.sifra"], FUN = median, na.rm = TRUE)
colnames(predMedian)[2:ncol(predMedian)] <- paste0(c(vars.predmet$cont$vars,vars.predmet$krediti$vars,vars.predmet$kompetence1$vars),"_median")

# sd
predSd <- aggregate(data.predmeti[c(vars.predmet$cont$vars,vars.predmet$krediti$vars,vars.predmet$kompetence1$vars)],   by = data.predmeti["predmet.sifra"], FUN = sd, na.rm = TRUE)
colnames(predSd)[2:ncol(predSd)] <- paste0(c(vars.predmet$cont$vars,vars.predmet$krediti$vars,vars.predmet$kompetence1$vars),"_sd")

# min
predMin <- aggregate(data.predmeti[c(vars.predmet$cont$vars,vars.predmet$krediti$vars)], by = data.predmeti["predmet.sifra"], FUN = min, na.rm = TRUE)
colnames(predMin)[2:ncol(predMin)] <- paste0(c(vars.predmet$cont$vars,vars.predmet$krediti$vars),"_min")
predMin[predMin==Inf] <- NA

# max
predMax <- aggregate(data.predmeti[c(vars.predmet$cont$vars,vars.predmet$krediti$vars)], by = data.predmeti["predmet.sifra"], FUN = max, na.rm = TRUE)
colnames(predMax)[2:ncol(predMax)] <- paste0(c(vars.predmet$cont$vars,vars.predmet$krediti$vars),"_max")
predMax[predMax==-Inf] <- NA

# N posamezne spremenljivke
predN <- aggregate(data.predmeti[c(vars.predmet$cont$vars,vars.predmet$krediti$vars,vars.predmet$kompetence1$vars)], by = data.predmeti["predmet.sifra"], FUN=function(x) sum(!is.na(x)))
colnames(predN)[2:ncol(predN)] <- paste0(c(vars.predmet$cont$vars,vars.predmet$krediti$vars,vars.predmet$kompetence1$vars),"_N")

# N answering before and after exam
predNanket <- aggregate(data.predmeti$veljavna, by = data.predmeti["predmet.sifra"], FUN = sum)
colnames(predNanket)[2] <- "N_anket"
predNanket_po_izpitu <- aggregate(data.predmeti$veljavna_po_izpitu, by = data.predmeti["predmet.sifra"], FUN = sum)
colnames(predNanket_po_izpitu)[2] <- "N_anket_po_izpitu"

# N didn't want to answer before and after exam
predNzavrnjenih <- aggregate(data.predmeti$zavrnjena, by = data.predmeti["predmet.sifra"], FUN = sum)
colnames(predNzavrnjenih)[2] <- "N_zavrnjenih"

# N Lurkerjev PRED izpitom
data.predmeti$lurker[data.predmeti$lurker==0] <- NA
predNLurkerji <- aggregate(as.numeric(data.predmeti$lurker), by = data.predmeti["predmet.sifra"],FUN=function(x) sum(!is.na(x)))
colnames(predNLurkerji)[2] <- "N_lurkerjev_pred"


predNzavrnjenih_po_izpitu <- aggregate(data.predmeti$zavrnjena_po_izpitu, by = data.predmeti["predmet.sifra"], FUN = sum)
colnames(predNzavrnjenih_po_izpitu)[2] <- "N_zavrnjenih_po_izpitu"

# razporejanje ocen za kreditne točke (n & %)  # Ustreznost KT
krediti_razporejanje_n <- table(data.predmeti$predmet.sifra, data.predmeti$predmet.ocena.krediti)
krediti_razporejanje_pct <- prop.table(krediti_razporejanje_n, 1) * 100
if (!is.null(dimnames(krediti_razporejanje_n)[[2]])) {
  colnames(krediti_razporejanje_n) <- paste0("krediti_razporejanje_n_", colnames(krediti_razporejanje_n))
  colnames(krediti_razporejanje_pct) <- paste0("krediti_razporejanje_pct_", colnames(krediti_razporejanje_pct))
  krediti_razporejanje_n <- cbind(as.data.frame.matrix(krediti_razporejanje_n), predmet.sifra=rownames(krediti_razporejanje_n))
  krediti_razporejanje_pct <- cbind(as.data.frame.matrix(krediti_razporejanje_pct), predmet.sifra=rownames(krediti_razporejanje_pct))
} else {krediti_razporejanje_n <- NULL
krediti_razporejanje_pct <- NULL}

# razporejanje ocen za kompetence1 (n & %)
kompetence1_razporejanje_n <- table(data.predmeti$predmet.sifra, data.predmeti$predmet.ocena.kompetence1)
kompetence1_razporejanje_pct <- prop.table(kompetence1_razporejanje_n, 1) * 100
if (!is.null(dimnames(kompetence1_razporejanje_n)[[2]])) {
  colnames(kompetence1_razporejanje_n) <- paste0("kompetence1_razporejanje_n_", colnames(kompetence1_razporejanje_n))
  colnames(kompetence1_razporejanje_pct) <- paste0("kompetence1_razporejanje_pct_", colnames(kompetence1_razporejanje_pct))
  kompetence1_razporejanje_n <- cbind(as.data.frame.matrix(kompetence1_razporejanje_n), predmet.sifra=rownames(kompetence1_razporejanje_n))
  kompetence1_razporejanje_pct <- cbind(as.data.frame.matrix(kompetence1_razporejanje_pct), predmet.sifra=rownames(kompetence1_razporejanje_pct))
} else {kompetence1_razporejanje_n <- NULL
kompetence1_razporejanje_pct <-  NULL}


# Prvi kvartil
predQ1 <- aggregate(data.predmeti[c(vars.predmet$cont$vars,vars.predmet$krediti$vars,vars.predmet$kompetence1$vars)], 
                    by = data.predmeti["predmet.sifra"], FUN = quantile, probs  = c(0.25),na.rm=T)
colnames(predQ1)[2:ncol(predQ1)] <- paste0(c(vars.predmet$cont$vars,vars.predmet$krediti$vars,vars.predmet$kompetence1$vars),"_Q1")

# Tretji kvartil
predQ3 <- aggregate(data.predmeti[c(vars.predmet$cont$vars,vars.predmet$krediti$vars,vars.predmet$kompetence1$vars)], 
                    by = data.predmeti["predmet.sifra"], FUN = quantile, probs  = c(0.75),na.rm=T)
colnames(predQ3)[2:ncol(predQ3)] <- paste0(c(vars.predmet$cont$vars,vars.predmet$krediti$vars,vars.predmet$kompetence1$vars),"_Q3")

# Prvi decil
predD1 <- aggregate(data.predmeti[c(vars.predmet$cont$vars,vars.predmet$krediti$vars,vars.predmet$kompetence1$vars)], 
                    by = data.predmeti["predmet.sifra"], FUN = quantile, probs  = c(0.1), type=5,na.rm=T)
colnames(predD1)[2:ncol(predD1)] <- paste0(c(vars.predmet$cont$vars,vars.predmet$krediti$vars,vars.predmet$kompetence1$vars),"_D1")

# Deveti decil
predD9 <- aggregate(data.predmeti[c(vars.predmet$cont$vars,vars.predmet$krediti$vars,vars.predmet$kompetence1$vars)], 
                    by = data.predmeti["predmet.sifra"], FUN = quantile, probs  = c(0.9), type=5,na.rm=T)
colnames(predD9)[2:ncol(predD9)] <- paste0(c(vars.predmet$cont$vars,vars.predmet$krediti$vars,vars.predmet$kompetence1$vars),"_D9")


# Združimo izračunane statistike za predmete
povprecja.predmeti <- merge(predMean, predSd, by="predmet.sifra", all = TRUE, sort = FALSE)
povprecja.predmeti <- merge(povprecja.predmeti, predMin, by = "predmet.sifra", all = TRUE, sort = FALSE)
povprecja.predmeti <- merge(povprecja.predmeti, predMax, by = "predmet.sifra", all = TRUE, sort = FALSE)
povprecja.predmeti <- merge(povprecja.predmeti, predN, by = "predmet.sifra", all = TRUE, sort = FALSE)
povprecja.predmeti <- merge(povprecja.predmeti, predQ1, by = "predmet.sifra", all = TRUE, sort = FALSE)
povprecja.predmeti <- merge(povprecja.predmeti, predQ3, by = "predmet.sifra", all = TRUE, sort = FALSE)
povprecja.predmeti <- merge(povprecja.predmeti, predMedian, by = "predmet.sifra", all = TRUE, sort = FALSE)
povprecja.predmeti <- merge(povprecja.predmeti, predD1, by = "predmet.sifra", all = TRUE, sort = FALSE)
povprecja.predmeti <- merge(povprecja.predmeti, predD9, by = "predmet.sifra", all = TRUE, sort = FALSE)
povprecja.predmeti <- merge(povprecja.predmeti, predNLurkerji, by = "predmet.sifra", all = TRUE, sort = FALSE)




# Če spremenljivka krediti_razporejanje_n ni NULL, jo združimo v popvrecja.predmeti sicer ne.
if (!is.null(krediti_razporejanje_n)) {
  povprecja.predmeti <- merge(povprecja.predmeti, krediti_razporejanje_n, by = "predmet.sifra", all = TRUE, sort = FALSE)
  povprecja.predmeti <- merge(povprecja.predmeti, krediti_razporejanje_pct, by = "predmet.sifra", all = TRUE, sort = FALSE)
}
if (!is.null(kompetence1_razporejanje_n)) {
  povprecja.predmeti <- merge(povprecja.predmeti, kompetence1_razporejanje_n, by = "predmet.sifra", all = TRUE, sort = FALSE)
  povprecja.predmeti <- merge(povprecja.predmeti, kompetence1_razporejanje_pct, by = "predmet.sifra", all = TRUE, sort = FALSE)
}

povprecja.predmeti <- merge(povprecja.predmeti, predNanket, by = "predmet.sifra", all = TRUE, sort = FALSE)
povprecja.predmeti <- merge(povprecja.predmeti, predNanket_po_izpitu, by = "predmet.sifra", all = TRUE, sort = FALSE)
povprecja.predmeti <- merge(povprecja.predmeti, predNzavrnjenih, by = "predmet.sifra", all = TRUE, sort = FALSE)
povprecja.predmeti <- merge(povprecja.predmeti, predNzavrnjenih_po_izpitu, by = "predmet.sifra", all = TRUE, sort = FALSE)

# združit s šifrantom
povprecja.predmeti <- merge(povprecja.predmeti, unique(sifrant[!(colnames(sifrant) %in% c("IDPEDAGOGA", "NAZIV.PEDAGOGA", "ST_KT", "ST_UR", "NOSILEC"))]), 
                            by.x = "predmet.sifra", by.y = "IDP", all.x = TRUE, sort = FALSE)


# write.csv2(povprecja.predmeti, paste0("results/povprecja.predmeti_", fakulteta, ".csv"))

# zakrivanje vrednosti kjer ni dovolj enot
premalo <- povprecja.predmeti[paste0(vars.predmet$cont$vars,"_N")] < minEnot
povprecja.predmeti[paste0(vars.predmet$cont$vars,"_mean")][premalo] <- NA
povprecja.predmeti[paste0(vars.predmet$cont$vars,"_sd")][premalo] <- NA
povprecja.predmeti[paste0(vars.predmet$cont$vars,"_min")][premalo] <- NA
povprecja.predmeti[paste0(vars.predmet$cont$vars,"_max")][premalo] <- NA
# še za kredite
premalo <- povprecja.predmeti[paste0("predmet.ocena.krediti_N")] < minEnot
povprecja.predmeti["predmet.ocena.krediti_mean"][premalo] <- NA


# Če so manjkajoče vrednosti (1:5) in eden izmed stolpcev od 1:5 manjka, poglej kateri manjka ga definiraj in mu pripiši vrednost 0.
# Manjkajoče vrednosti nastanejo, ker gre za vprašanje na lestvici od 1:5, in npr. vrednost 1 ni označil nihče 
# Definirane stolpce od 1:5 potrebujemo pri poročilu za izvajalca, in sicer pri generiranju tabel: poročilo za izvajalca
# Glej npr tabelo: Frekvenčna porazdelitev za število porabljenih ur* (anketa PO izpitu)
if (any(paste0("krediti_razporejanje_n_", 1:5) %in% colnames(povprecja.predmeti)==FALSE)) {
  # povprecja.predmeti = data.frame
  missing <- paste0("krediti_razporejanje_n_",1:5)[paste0("krediti_razporejanje_n_", 1:5) %in% colnames(povprecja.predmeti) == FALSE]
  res <- list()
  for(i in missing){
    povprecja.predmeti[[i]] <- rep(0, nrow(povprecja.predmeti))
  }
}

# Če je število odogovorov manjše od 4, mu pripišemo NA
povprecja.predmeti[paste0("krediti_razporejanje_n_", 1:5)][cbind(premalo,premalo,premalo,premalo,premalo)] <- NA

# Če so manjkajoče vrednosti in eden izmed stolpcev od 1:5 manjka, poglej kateri manjka in ga definiraj
if (any(paste0("krediti_razporejanje_pct_", 1:5) %in% colnames(povprecja.predmeti)==FALSE)) {
  # x = data.frame
  missing <- paste0("krediti_razporejanje_pct_",1:5)[paste0("krediti_razporejanje_pct_", 1:5) %in% colnames(povprecja.predmeti) == FALSE]
  res <- list()
  for(i in missing){
    povprecja.predmeti[[i]] <- rep(0,nrow(povprecja.predmeti))
  }
}
povprecja.predmeti[paste0("krediti_razporejanje_pct_", 1:5)][cbind(premalo,premalo,premalo,premalo,premalo)] <- NA

# In za kompetence
premalo <- povprecja.predmeti[paste0("predmet.ocena.kompetence1_N")] < minEnot
povprecja.predmeti["predmet.ocena.kompetence1_mean"][premalo] <- NA


if (any(paste0("kompetence1_razporejanje_n_", 1:5) %in% colnames(povprecja.predmeti)==FALSE)) {
  # x = data.frame
  missing <- paste0("kompetence1_razporejanje_n_",1:5)[paste0("kompetence1_razporejanje_n_", 1:5) %in% colnames(povprecja.predmeti) == FALSE]
  res <- list()
  for(i in missing){
    povprecja.predmeti[[i]] <- rep(0,nrow(povprecja.predmeti))
  }
}
povprecja.predmeti[paste0("kompetence1_razporejanje_n_", 1:5)][cbind(premalo,premalo,premalo,premalo,premalo)] <- NA


# Če so manjkajoče vrednosti in eden izmed stolpcev od 1:5 manjka, poglej kateri manjka in ga definiraj
if (any(paste0("kompetence1_razporejanje_pct_", 1:5) %in% colnames(povprecja.predmeti)==FALSE)) {
  # x = data.frame
  missing <- paste0("kompetence1_razporejanje_pct_",1:5)[paste0("kompetence1_razporejanje_pct_", 1:5) %in% colnames(povprecja.predmeti) == FALSE]
  res <- list()
  for(i in missing){
    povprecja.predmeti[[i]] <- rep(0,nrow(povprecja.predmeti))
  }
}
povprecja.predmeti[paste0("kompetence1_razporejanje_pct_", 1:5)][cbind(premalo,premalo,premalo,premalo,premalo)] <- NA

# average of components - all, before, after exam
povprecja.predmeti$predmet.ocena.SKUPAJ <- rowMeans(povprecja.predmeti[paste0(vars.predmet$cont$vars,"_mean")], na.rm = T)
povprecja.predmeti$predmet.ocena.SKUPAJ.pred <- rowMeans(povprecja.predmeti[paste0(vars.predmet$cont$pred,"_mean")], na.rm = T)
# Ker je v NAKETI PO IPZITU komponenta "kompetence" merjena na drugačni lestvici od komponent:Vsebine, Naloge, Ocenjevanje, je ne upoštevamo
# Pri izračunu skupnega povprečja in zato je skupno povprečje sestavljeno iz vseh spremenljivk - 1 oz. vars.predmet$cont$po[-1]
povprecja.predmeti$predmet.ocena.SKUPAJ.po <- rowMeans(povprecja.predmeti[paste0(vars.predmet$cont$po[-1],"_mean")], na.rm = T)
povprecja.predmeti$predmet.ocena.SKUPAJ.praksa <- rowMeans(povprecja.predmeti[paste0(vars.predmet$cont$praksa,"_mean")], na.rm = T)

# Število študentov pri posameznem predmetu: Spremenimo iz character v numeric
povprecja.predmeti$ST_STUD <- as.numeric(povprecja.predmeti$ST_STUD)

# Kjer je negativno število pomeni, da gre za več vpisanih študentov, kot jih je v bazi oz spremenljivki ST_STUD
povprecja.predmeti$ST_STUD <- ifelse(povprecja.predmeti$ST_STUD < as.numeric(povprecja.predmeti$N_anket) + as.numeric(povprecja.predmeti$N_zavrnjenih),
                                     as.numeric(povprecja.predmeti$N_anket) + as.numeric(povprecja.predmeti$N_zavrnjenih), povprecja.predmeti$ST_STUD)

# % odgovora
povprecja.predmeti$sodelujocih.pct <- povprecja.predmeti$N_anket / povprecja.predmeti$ST_STUD * 100
povprecja.predmeti$sodelujocih.pct_po_izpitu <- povprecja.predmeti$N_anket_po_izpitu / povprecja.predmeti$ST_STUD * 100
# % zavrnjenih
povprecja.predmeti$zavrnjenih.pct <- povprecja.predmeti$N_zavrnjenih / povprecja.predmeti$ST_STUD * 100
povprecja.predmeti$zavrnjenih.pct_po_izpitu <- povprecja.predmeti$N_zavrnjenih_po_izpitu / povprecja.predmeti$ST_STUD * 100
# N in % neodzivnih (ni pristopilo k anketi)
povprecja.predmeti$N_neodzivnih <- povprecja.predmeti$ST_STUD - povprecja.predmeti$N_anket - povprecja.predmeti$N_zavrnjenih
povprecja.predmeti$neodzivnih.pct <- povprecja.predmeti$N_neodzivnih / povprecja.predmeti$ST_STUD * 100
# Po izpitu
povprecja.predmeti$N_neodzivnih_po_izpitu <- povprecja.predmeti$ST_STUD - povprecja.predmeti$N_anket_po_izpitu - povprecja.predmeti$N_zavrnjenih_po_izpitu
povprecja.predmeti$neodzivnih.pct_po_izpitu <- povprecja.predmeti$N_neodzivnih_po_izpitu / povprecja.predmeti$ST_STUD * 100
## //average of components - all, before, after exam// ##

# preurejeno ime predmeta
povprecja.predmeti$ime.predmeta <- povprecja.predmeti$PREDMET

# IZREDNi ŠTUDIJ
izredni <- povprecja.predmeti$NACIN=="2" # če je izredni predmet mora biti to v oklepaju
izredni <-  izredni[!is.na(izredni) ]
povprecja.predmeti$ime.predmeta[izredni] <- paste(povprecja.predmeti$ime.predmeta[izredni], "(izredna izvedba)")
# //IZREDNi ŠTUDIJ// #

# nova imena predmetov še k povprečjem izvajalcev[]
povprecja.izvajalci <- merge(povprecja.izvajalci, povprecja.predmeti[,c("predmet.sifra","ime.predmeta")], by = "predmet.sifra", sort = FALSE)

########################
## ŠTUDIJSKI PROGRAMI ##
########################
# število ocen po programih (za poročila in povprečja po programih)
programi <- unique(data.predmeti[c("student.program.sifra", "student.program.ime")])
programi <- subset(programi, !is.na(student.program.sifra))
programi <- subset(programi, student.program.ime != "NA")
programi <- programi[order(programi$student.program.ime), ]

## izvajalec: Študijski program ##
povprecja.izvajalci[paste0("program_studenta_", programi$student.program.sifra)] <- 0
data.izv.temp <- subset(data.izvajalci, veljavna)
programi.studentov <- as.data.frame.matrix(table(paste(data.izv.temp$izvajalec.sifra, data.izv.temp$predmet.sifra, sep = "_"), data.izv.temp$student.program.sifra))
names(programi.studentov) <- paste0("program_studenta_", names(programi.studentov))
povprecja.izvajalci[match(rownames(programi.studentov), paste(povprecja.izvajalci$izvajalec.sifra, povprecja.izvajalci$predmet.sifra, sep = "_")), names(programi.studentov)] <- programi.studentov

## predmet: Študijski program ##
povprecja.predmeti[paste0("program_studenta_", programi$student.program.sifra)] <- 0
data.prog.temp <- subset(data.predmeti, veljavna)
programi.studentov <- as.data.frame.matrix(table(data.prog.temp$predmet.sifra, data.prog.temp$student.program.sifra))
names(programi.studentov) <- paste0("program_studenta_", names(programi.studentov))
povprecja.predmeti[match(rownames(programi.studentov), povprecja.predmeti$predmet.sifra), names(programi.studentov)] <- programi.studentov

# sort by name
povprecja.izvajalci <- povprecja.izvajalci[order(povprecja.izvajalci$NAZIV.PEDAGOGA, povprecja.izvajalci$PREDMET), ]
povprecja.predmeti <- povprecja.predmeti[order(povprecja.predmeti$PREDMET),]

# Uporabimo, ko delamo izpis za TRENDE ali za HABILITACIJSKO KOMISIJO
#write.csv2(povprecja.izvajalci, paste0("results/povprecja.izvajalci-minEnot_", fakulteta, ".csv")
#write.csv2(povprecja.predmeti, paste0("results/povprecja.predmeti-minEnot_", fakulteta, ".csv")

# are there any courses with too many answers in the database according to sifrant.xlsx
premalo_vpisanih <- povprecja.predmeti$N_neodzivnih < 0
premalo_vpisanih <- !is.na(premalo_vpisanih)
if (any(premalo_vpisanih)) {
  warning(c("Some courses have more students in the database than number of students that are attending the course according to sifrant.xlsx",
            paste("\n",povprecja.predmeti$predmet.sifra[premalo_vpisanih], povprecja.predmeti$PREDMET[premalo_vpisanih],paste0("(",abs(povprecja.predmeti$N_neodzivnih[premalo_vpisanih]), " more students)"))))
}

# skupna povprečja izvajalcev (povprečja ocen pri vseh predmetih)
povprecja.izvajalci.skupaj <- aggregate(povprecja.izvajalci[, c("ST_STUD","N_anket","N_anketSkupaj","sodelujocih.pct","zavrnjenih.pct","neodzivnih.pct","nipouceval.pct", paste0(vars.izvajalec$cont$vars,"_mean"),"izvajalec.ocena.SKUPAJ")],
                                        by = povprecja.izvajalci[,"izvajalec.sifra", drop = FALSE], 
                                        FUN = mean, na.rm = TRUE)

# number of evaluations from different programmes
vsota.ocen.programov <- aggregate(povprecja.izvajalci[paste0("program_studenta_", programi$student.program.sifra)], 
                                  by = povprecja.izvajalci[, "izvajalec.sifra", drop = FALSE], FUN = sum, na.rm = TRUE)
povprecja.izvajalci.skupaj <- merge(povprecja.izvajalci.skupaj, vsota.ocen.programov, by = "izvajalec.sifra", all.x = TRUE)

# number of courses with at least minimun nuber of answers
st.ocen <- aggregate(list(st.ocen=povprecja.izvajalci$N_anket >= minEnot), 
                     by = povprecja.izvajalci[, "izvajalec.sifra", drop = FALSE], FUN = sum, na.rm = TRUE)
povprecja.izvajalci.skupaj <- merge(povprecja.izvajalci.skupaj, st.ocen, by = "izvajalec.sifra", all.x = TRUE)

# še imena izvajalcev
povprecja.izvajalci.skupaj <- merge(povprecja.izvajalci.skupaj, unique(povprecja.izvajalci[,c("izvajalec.sifra","NAZIV.PEDAGOGA")]), 
                                    by = "izvajalec.sifra", all.x = TRUE)

# da izračunamo povprečja vseh predmetov določenega izvajalca rabimo ocene predmetov po izvajalcih (podvojene vrstice z različnimi šiframi izvajalcev)
povprecja.predmeti.vsi.izvajalci <- merge(povprecja.izvajalci[,c("izvajalec.sifra","predmet.sifra")], povprecja.predmeti, 
                                          by = "predmet.sifra", all.x = TRUE, sort = FALSE)
povprecja.predmetov.izvajalca.skupaj <- aggregate(povprecja.predmeti.vsi.izvajalci[, c("ST_STUD","N_anket","N_anket_po_izpitu",
                                                                                       "sodelujocih.pct","sodelujocih.pct_po_izpitu",
                                                                                       "zavrnjenih.pct","zavrnjenih.pct_po_izpitu",
                                                                                       "neodzivnih.pct","neodzivnih.pct_po_izpitu",
                                                                                       paste0(vars.predmet$cont$vars,"_mean"),
                                                                                       "predmet.ocena.SKUPAJ","predmet.ocena.SKUPAJ.pred",
                                                                                       "predmet.ocena.SKUPAJ.po","predmet.ocena.SKUPAJ.praksa",
                                                                                       "predmet.ocena.krediti_mean",
                                                                                       "predmet.ocena.kompetence1_mean")],
                                                  by = povprecja.predmeti.vsi.izvajalci[,"izvajalec.sifra", drop = FALSE], 
                                                  FUN = mean,  na.rm = TRUE)
# še imena izvajalcev
povprecja.predmetov.izvajalca.skupaj <- merge(povprecja.predmetov.izvajalca.skupaj, 
                                              unique(povprecja.izvajalci[,c("izvajalec.sifra","NAZIV.PEDAGOGA")]), 
                                              by = "izvajalec.sifra", all.x = TRUE)

# povprečja vseh izvajalecv pri vsakem predmetu
povprecja.predmet.izvajalci.skupaj <- aggregate(povprecja.izvajalci[, c("ST_STUD","N_anket","N_anketSkupaj","sodelujocih.pct","zavrnjenih.pct",
                                                                        "neodzivnih.pct",paste0(vars.izvajalec$cont$vars,"_mean"),
                                                                        "izvajalec.ocena.SKUPAJ")],
                                                by = povprecja.izvajalci[,"predmet.sifra",drop = FALSE],
                                                FUN = mean, na.rm = TRUE)
# še imena predmetov
povprecja.predmet.izvajalci.skupaj <- merge(povprecja.predmet.izvajalci.skupaj, povprecja.predmeti[,c("predmet.sifra","ime.predmeta")],
                                            by = "predmet.sifra", all.x = TRUE)

# sort
povprecja.izvajalci.skupaj <- povprecja.izvajalci.skupaj[order(povprecja.izvajalci.skupaj$NAZIV.PEDAGOGA),]
povprecja.predmetov.izvajalca.skupaj <- povprecja.predmetov.izvajalca.skupaj[order(povprecja.predmetov.izvajalca.skupaj$NAZIV.PEDAGOGA),]
povprecja.predmet.izvajalci.skupaj <- povprecja.predmet.izvajalci.skupaj[order(povprecja.predmet.izvajalci.skupaj$ime.predmeta),]

#write.csv2(povprecja.izvajalci.skupaj, file='results/povprecja.izvajalci.skupaj-minEnot.csv')
#write.csv2(povprecja.predmetov.izvajalca.skupaj, file='results/povprecja.predmetov.izvajalca.skupaj-minEnot.csv')
#write.csv2(povprecja.predmet.izvajalci.skupaj, file='results/povprecja.predmet.izvajalci.skupaj-minEnot.csv')


#################
##  Quantiles  ##
#################
# for every lecturer/course
# S funkcijo kvantRang in kvantRang1 izračunamo in barvamo kvantilne range, ki se pokažejo v posameznih tabelah (glej skirpto funkcije.r)
# Kvantilni rangi za izvajalce pri predmetih (IPP)
kvantili.izvajalci <- povprecja.izvajalci[c("izvajalec.sifra","NAZIV.PEDAGOGA","predmet.sifra","ime.predmeta","ST_STUD","N_anket",
                                            "sodelujocih.pct",paste0(vars.izvajalec$cont$vars,"_mean"),"izvajalec.ocena.SKUPAJ")]
for (var in c(paste0(vars.izvajalec$cont$vars,"_mean"),"izvajalec.ocena.SKUPAJ")) {
  kvantili.izvajalci[[var]] <- kvantRang(kvantili.izvajalci[[var]]) 
  
}

for (var in c("ST_STUD","N_anket","sodelujocih.pct")) {
  kvantili.izvajalci[[var]] <- kvantRang1(kvantili.izvajalci[[var]]) 
  
}
# //Kvantilni rangi za izvajalce pri predmetih (IPP)// #


# Kvantilni rangi za predmet: komponente ankete PRED in PO izpitu
kvantili.predmeti <- povprecja.predmeti[c("predmet.sifra","ime.predmeta","ST_STUD","N_anket","N_anket_po_izpitu","sodelujocih.pct",
                                          "sodelujocih.pct_po_izpitu",paste0(vars.predmet$cont$vars,"_mean"),"predmet.ocena.SKUPAJ",
                                          "predmet.ocena.SKUPAJ.pred","predmet.ocena.SKUPAJ.po","predmet.ocena.SKUPAJ.praksa",
                                          "predmet.ocena.krediti_mean","predmet.ocena.kompetence1_mean")]
for (var in c(paste0(vars.predmet$cont$vars,"_mean"),"predmet.ocena.SKUPAJ","predmet.ocena.SKUPAJ.pred","predmet.ocena.SKUPAJ.po",
              "predmet.ocena.SKUPAJ.praksa")) {
  kvantili.predmeti[[var]] <- kvantRang(kvantili.predmeti[[var]])
}

for (var in c("ST_STUD","N_anket","N_anket_po_izpitu","sodelujocih.pct","sodelujocih.pct_po_izpitu")) {
  kvantili.predmeti[[var]] <- kvantRang1(kvantili.predmeti[[var]])
  
}

for (var in c("predmet.ocena.krediti_mean","predmet.ocena.kompetence1_mean")) {
  kvantili.predmeti[[var]] <- kvantRang2(kvantili.predmeti[[var]])
  
}
# //Kvantilni rangi za predmet: komponente ankete PRED in PO izpitu// #

## lecturer averages ##
kvantili.izvajalci.skupaj <- povprecja.izvajalci.skupaj[c("izvajalec.sifra","NAZIV.PEDAGOGA","ST_STUD","N_anket",
                                                          "sodelujocih.pct",paste0(vars.izvajalec$cont$vars,"_mean"),
                                                          "izvajalec.ocena.SKUPAJ")]
for (var in c(paste0(vars.izvajalec$cont$vars,"_mean"),"izvajalec.ocena.SKUPAJ")) {
  kvantili.izvajalci.skupaj[[var]] <- kvantRang(kvantili.izvajalci.skupaj[[var]])
}

for (var in c("ST_STUD","N_anket","sodelujocih.pct")) {
  kvantili.izvajalci.skupaj[[var]] <- kvantRang1(kvantili.izvajalci.skupaj[[var]])
  
}

kvantili.predmetov.izvajalca.skupaj <- povprecja.predmetov.izvajalca.skupaj[c("izvajalec.sifra","NAZIV.PEDAGOGA","ST_STUD",
                                                                              "N_anket","N_anket_po_izpitu","sodelujocih.pct",
                                                                              "sodelujocih.pct_po_izpitu",paste0(vars.predmet$cont$vars,"_mean"),
                                                                              "predmet.ocena.SKUPAJ","predmet.ocena.SKUPAJ.pred",
                                                                              "predmet.ocena.SKUPAJ.po","predmet.ocena.SKUPAJ.praksa",
                                                                              "predmet.ocena.krediti_mean","predmet.ocena.kompetence1_mean")]
for (var in c(paste0(vars.predmet$cont$vars,"_mean"),"predmet.ocena.SKUPAJ","predmet.ocena.SKUPAJ.pred",
              "predmet.ocena.SKUPAJ.po","predmet.ocena.SKUPAJ.praksa","predmet.ocena.krediti_mean",
              "predmet.ocena.kompetence1_mean")) {
  kvantili.predmetov.izvajalca.skupaj[[var]] <- kvantRang(kvantili.predmetov.izvajalca.skupaj[[var]])
}

for (var in c("ST_STUD","N_anket","N_anket_po_izpitu","sodelujocih.pct","sodelujocih.pct_po_izpitu")) {
  kvantili.predmetov.izvajalca.skupaj[[var]] <- kvantRang1(kvantili.predmetov.izvajalca.skupaj[[var]])
  
}

## for table names (izpis izvajalca, programov, fakultete) ##
kvantili.izvajalci.st <- sum(kvantili.izvajalci$izvajalec.ocena.SKUPAJ != ".") # Število vseh ocenjenih izvajalcev fakultete

# Glej npr izpis izvajalca, Tabela 1.1 (vrstico Povprečje FDV), 
# kjer se izpiše število predmetov v anketi PRED izpitom
kvantili.predmeti.st.pred <- sum(kvantili.predmeti$predmet.ocena.SKUPAJ.pred != ".") # Število vseh ocenjenih predmetov: anketa PRED
kvantili.predmeti.st.po <- sum(kvantili.predmeti$predmet.ocena.SKUPAJ.po != ".") # Število vseh ocenjenih predmetov: anketa PO

kvantili.izvajalci.skupaj.st <- sum(kvantili.izvajalci.skupaj$izvajalec.ocena.SKUPAJ != ".") # Število vseh ocenjenih IPP (izvajalcev pri)
kvantili.predmetov.izvajalca.skupaj.st.pred <- sum(kvantili.predmetov.izvajalca.skupaj$predmet.ocena.SKUPAJ.pred != ".")
kvantili.predmetov.izvajalca.skupaj.st.po  <- sum(kvantili.predmetov.izvajalca.skupaj$predmet.ocena.SKUPAJ.po != ".")

kvantili.ustreznotsKT <- sum(kvantili.predmeti$predmet.ocena.krediti_mean != ".") # Število vseh ocen za ustreznost KT (anketa PO)
kvantili.zadovoljstvo <- sum(kvantili.predmeti$predmet.ocena.zadovoljstvo_mean != ".") # Število vseh ocen za ustreznost KT (anketa PO)
## //Quantiles// ##


########################
##  FACULTY AVERAGES  ##
########################
# Povprečje izvajalcev
vars.izvajalec$cont$meansFDV[c(vars.izvajalec$cont$vars,"povprecje.ocen")] <- colMeans(povprecja.izvajalci[c(paste0(vars.izvajalec$cont$vars, "_mean"),"izvajalec.ocena.SKUPAJ")], na.rm = TRUE)

# Povprečje predmetov (anketa PRED izpitom, anketa PO izpitu, študijska praksa)
vars.predmet$cont$meansFDV[c(vars.predmet$cont$vars,"povprecje.ocen","povprecje.ocen.pred","povprecje.ocen.po","povprecje.ocen.praksa")] <- colMeans(povprecja.predmeti[c(paste0(vars.predmet$cont$vars, "_mean"),"predmet.ocena.SKUPAJ",
                                                                                                                                                                          "predmet.ocena.SKUPAJ.pred","predmet.ocena.SKUPAJ.po","predmet.ocena.SKUPAJ.praksa")], na.rm=TRUE)
# Povprečje študijskih praks
vars.predmet$cont$FDVpraksa[c(vars.predmet$cont$praksa,"povprecje.ocen.praksa")] <- colMeans(povprecja.predmeti[c(paste0(vars.predmet$cont$praksa, "_mean"),"predmet.ocena.SKUPAJ.praksa")], na.rm = TRUE)

# Povprečje Ustreznost KT
vars.predmet$krediti$meansFDV[c("predmet.ocena.krediti")] <- colMeans(povprecja.predmeti["predmet.ocena.krediti_mean"], na.rm = TRUE)

# Standardni odklon za ustreznost KT
vars.predmet$krediti$meansFDV1[c("predmet.ocena.krediti.sd")] <- colMeans(povprecja.predmeti["predmet.ocena.krediti_sd"], na.rm = TRUE)
vars.predmet$krediti$pctsFDV[paste0("krediti_razporejanje_pct_", 1:5)] <- colMeans(povprecja.predmeti[paste0("krediti_razporejanje_pct_", 1:5)], na.rm = TRUE)

# Povprečje kompetence
vars.predmet$kompetence1$meansFDV[c("predmet.ocena.kompetence1")] <- colMeans(povprecja.predmeti["predmet.ocena.kompetence1_mean"], na.rm = TRUE)

# Standardni odklon za kompetence
vars.predmet$kompetence1$meansFDV1[c("predmet.ocena.kompetence1.sd")] <- colMeans(povprecja.predmeti["predmet.ocena.kompetence1_sd"], na.rm = TRUE)
vars.predmet$kompetence1$pctsFDV[paste0("kompetence1_razporejanje_pct_", 1:5)] <- colMeans(povprecja.predmeti[paste0("kompetence1_razporejanje_pct_", 1:5)], na.rm = TRUE)

# response
povprecja.izvajalci[,41] <- as.numeric(povprecja.izvajalci[,41])

#######################################################
# Skupna Povprečja IZVAJLCEV fakultete glede na STOPNJO
#######################################################
FDVizvajalci <- rbind(skupaj = colMeans(povprecja.izvajalci[c("ST_STUD","N_anket","N_anketSkupaj","sodelujocih.pct","zavrnjenih.pct","neodzivnih.pct","nipouceval.pct")], na.rm = T),
                      "1" = colMeans(povprecja.izvajalci[povprecja.izvajalci$STOPNJA == 1, c("ST_STUD","N_anket","N_anketSkupaj","sodelujocih.pct","zavrnjenih.pct","neodzivnih.pct","nipouceval.pct")], na.rm = T),
                      "2"=colMeans(povprecja.izvajalci[povprecja.izvajalci$STOPNJA == 2,  c("ST_STUD","N_anket","N_anketSkupaj","sodelujocih.pct","zavrnjenih.pct","neodzivnih.pct","nipouceval.pct")], na.rm = T))

######################################################################################
# Skupna Povprečja PREDMETOV fakultete glede na STOPNJO in glede na SEMESTER IZVAJANJA
######################################################################################
FDVpredmeti <- rbind(skupaj=colMeans(povprecja.predmeti[c("ST_STUD","N_anket","N_anket_po_izpitu",
                                                          "sodelujocih.pct","sodelujocih.pct_po_izpitu",
                                                          "zavrnjenih.pct","zavrnjenih.pct_po_izpitu",
                                                          "neodzivnih.pct","neodzivnih.pct_po_izpitu")], na.rm = T),
                     "1"=colMeans(povprecja.predmeti[povprecja.predmeti$STOPNJA == 1, 
                                                     c("ST_STUD","N_anket","N_anket_po_izpitu","sodelujocih.pct",
                                                       "sodelujocih.pct_po_izpitu","zavrnjenih.pct","zavrnjenih.pct_po_izpitu",
                                                       "neodzivnih.pct","neodzivnih.pct_po_izpitu")], na.rm = T),
                     "2"=colMeans(povprecja.predmeti[povprecja.predmeti$STOPNJA == 2, 
                                                     c("ST_STUD","N_anket","N_anket_po_izpitu",
                                                       "sodelujocih.pct","sodelujocih.pct_po_izpitu",
                                                       "zavrnjenih.pct","zavrnjenih.pct_po_izpitu",
                                                       "neodzivnih.pct","neodzivnih.pct_po_izpitu")], na.rm = T),
                     "prvi_semester" = colMeans(subset(povprecja.predmeti, SEMESTER_IZV %in% prvi_semester)
                                                [c("ST_STUD","N_anket","N_anket_po_izpitu","sodelujocih.pct",
                                                   "sodelujocih.pct_po_izpitu","zavrnjenih.pct","zavrnjenih.pct_po_izpitu",
                                                   "neodzivnih.pct","neodzivnih.pct_po_izpitu")], na.rm = T),
                     "drugi_semester" = colMeans(subset(povprecja.predmeti, SEMESTER_IZV %in% drugi_semester)
                                                 [c("ST_STUD","N_anket","N_anket_po_izpitu","sodelujocih.pct",
                                                    "sodelujocih.pct_po_izpitu","zavrnjenih.pct","zavrnjenih.pct_po_izpitu",
                                                    "neodzivnih.pct","neodzivnih.pct_po_izpitu")], na.rm = T))
## //FACULTY AVERAGES// ##


#####################################
# POVPREČJA PO ŠTUDIJSKIH PROGRAMIH 
#####################################
# Skupne ocene predmetov po posameznih študijskih programih
progMeanPredm <- aggregate(data.predmeti[c(vars.predmet$cont$vars,vars.predmet$krediti$vars,vars.predmet$kompetence1$vars)],
                           by = data.predmeti["student.program.sifra"], FUN = mean, na.rm = TRUE)
progMeanPredm$predmet.ocena.SKUPAJ <- rowMeans(progMeanPredm[vars.predmet$cont$vars], na.rm = TRUE)
progMeanPredm$predmet.ocena.SKUPAJ.pred <- rowMeans(progMeanPredm[vars.predmet$cont$pred], na.rm = TRUE)
progMeanPredm$predmet.ocena.SKUPAJ.po <- rowMeans(progMeanPredm[vars.predmet$cont$po[-1]], na.rm = TRUE)
progMeanPredm$predmet.ocena.SKUPAJ.praksa <- rowMeans(progMeanPredm[vars.predmet$cont$praksa], na.rm = TRUE)

# Skupna povprečja izvajalcav po posameznih študijskih programih
progMeanIzv <- aggregate(data.izvajalci[vars.izvajalec$cont$vars], 
                         by=data.izvajalci["student.program.sifra"], FUN = mean, na.rm = TRUE)
progMeanIzv <- cbind(progMeanIzv, izvajalec.ocena.SKUPAJ=rowMeans(progMeanIzv[vars.izvajalec$cont$vars]))

#izračun povprečij izvajalcev za študijske programe in insert v poročila za fakulteto
progMeanIzv.fak <- aggregate(data.izvajalci[vars.izvajalec$cont$vars], by = data.izvajalci[c("student.program.sifra","student.program.ime")], 
                             FUN = mean,na.rm = TRUE)
progMeanIzv.fak1 <- cbind(progMeanIzv.fak, izvajalec.ocena.SKUPAJ = rowMeans(progMeanIzv.fak[vars.izvajalec$cont$vars], na.rm = TRUE))
# Število odogovorov (število anket) pri posameznem študijskem programu
st.odgovorov.fak1 <- aggregate(data.izvajalci$veljavna,  by = data.izvajalci[c("student.program.sifra","student.program.ime")], FUN = sum)
colnames(st.odgovorov.fak1)[3] <- "N_anket" # Poimenujemo stolpec 

progMeanIzv.fak1 <- merge(progMeanIzv.fak1, st.odgovorov.fak1, by = c("student.program.sifra","student.program.ime"),
                          all = TRUE, sort = FALSE)
## //povprečja programov// ##


## PODATKI ZA TABELE, KI SE DODAJO K "ANALIZI IZVAJALCA PRI PREDMETU PO PROGRAMIH IN LETNIKIH" ##
test1 <- aggregate(data.izvajalci[vars.izvajalec$cont$vars],
                   by = data.izvajalci[c("student.program.ime")], FUN = mean, na.rm = TRUE)
test2 <- cbind(test1, izvajalec.ocena.SKUPAJ=rowMeans(test1[vars.izvajalec$cont$vars], na.rm = TRUE))


#Zaokroži vrednosti za izpis programov pri IZVAJALCU  
round_df <- function(x, digits) {
  # round all numeric variables
  # x: data frame 
  # digits: number of digits to round
  numeric_columns <- sapply(x, class) == 'numeric'
  x[numeric_columns] <-  round(x[numeric_columns], digits)
  x
}
test2 <- round_df(test2, 1)
## //PODATKI ZA TABELE// ##


## PODATKI ZA TABELE, KI SE DODAJO K "Analiza predmeta po programih in letnikih" ##
vars.predmet$cont$vars1 <- vars.predmet$cont$vars[-c(12,13,14,15,16,17,18,19,20)]
vars.predmet.vars <- vars.predmet$cont$vars1[-c(8,9,10,11)]
test.pred <- aggregate(data.predmeti[vars.predmet.vars],
                       by = data.predmeti[c("student.program.ime")], FUN = mean, na.rm = TRUE)
test.pred <- cbind(test.pred, predmet.ocena.SKUPAJ = rowMeans(test.pred[vars.predmet.vars], na.rm = TRUE))

#Zaokroži vrednosti za izpis programov pri PREDMETU
test.pred <- round_df(test.pred, 1)
## // PODATKI ZA TABELE// ##


# ZARADI UMETNO GENERIRANIH ŠIFER IZVAJALCEV SE ZA ANKETO PO ZA ŠTUDIJSKE PROGRAME NISO PRAVILNO IZPISALA POVPREČJA IN ŠTEVILO ODGOVOROV
# Zato smo komponente za anketo PO izpitu analizirali iz prvotne baze (anketa po izpitu) namesto iz baze "data.predmeti"
# Tako smo bazo data_po_izpitu uporabili le v primerih, ko se povprečja navezujejo na študijske programe za anketo PO IZPITU
data.predmet.po <- data_po_izpitu

# Opredelimo imena spremenljivk oz komponent v ankeit PO izpitu
lokacije.predmet.po <- lokacije.predmet[c(1:1,3:3,13:nrow(lokacije.predmet)), 1, drop = FALSE]


## PODATKI ZA PREDMETE PO IZPITU ##
# Ponovimo, kar smo naredili že na začetku a tokrat le na podatkih PO izpitu.
data.predmeti.PO <- data.predmet.po[c(lokacije.predmet.po[, 1], "idprog","letnik","program", "lurker")] # Združimo spremenljivke v lokacije.predmet[, 1] in šifro študentov 
names(data.predmeti.PO) <- c(rownames(lokacije.predmet.po), "ID_vrsta_studija","Letnik","Naziv","lurker")
someMissVars.PO <- rownames(navP[!is.na(navP$missings.table), ])
someMissVars.PO <- someMissVars.PO[8:20] # 8:20 so spremenljivke (komponente), ki se nanašajo na anketo po izpitu
data.predmeti.PO.someMiss <- data.predmeti.PO[c("predmet.sifra", someMissVars.PO)]
# setting missing values and keeping some (defined in navodila.xlsx in column missing.table) for frequency tables
for (var in c(vars.predmet$cont$vars[8:20],
              vars.predmet$krediti$vars,vars.predmet$kompetence1$vars)) {
  miss <- unlist(strsplit(navodila[var,]$missings, ","))
  data.predmeti.PO[, var][data.predmeti.PO[, var] %in% miss] <- NA
  if (var %in% c(vars.predmet$cont$vars[8:20],vars.predmet$krediti$vars,vars.predmet$kompetence1$vars)) {
    data.predmeti.PO[, var] <- as.numeric(data.predmeti.PO[, var])
  }
  if (var %in% someMissVars.PO) {
    someMissVals <- 
      matrix(unlist(strsplit(unlist(strsplit(navodila[var,]$missings.table, ",")), "=")), ncol = 2, byrow = TRUE)
    miss <- miss[!(miss %in% someMissVals[, 1])]
    data.predmeti.PO.someMiss[, var][data.predmeti.PO.someMiss[, var] %in% miss] <- NA
    for (missVar in 1:nrow(someMissVals)) {
      data.predmeti.PO.someMiss[, var][data.predmeti.PO.someMiss[, var] == someMissVals[missVar, 1] & 
                                         !is.na(data.predmeti.PO.someMiss[, var])] <- someMissVals[missVar, 2]
    }
  }
}
# all values with some miss for tables
predmet.someMiss.PO <- sort(unique(as.vector(as.matrix(data.predmeti.PO.someMiss[, vars.predmet$cont$vars[8:20]]))))
if(any(predmet.someMiss.PO=="")) {
  predmet.someMiss.PO <- predmet.someMiss.PO[predmet.someMiss.PO != ""]
  
}

data.predmeti.PO <- data.predmeti.PO[order(data.predmeti.PO$predmet.sifra),]
# ali je anketa veljavna za predmet; ali je student ni izpolnjeval (je pa začel anketo)
data.predmeti.PO$veljavna_po_izpitu <- data.predmeti.PO$predmet.izpolnjeval.po == -1 & !is.na(data.predmeti.PO$predmet.izpolnjeval.po)
data.predmeti.PO$zavrnjena_po_izpitu <- (!data.predmeti.PO$veljavna_po_izpitu & !is.na(data.predmeti.PO$predmet.izpolnjeval.po))
# adding student data (year and programme)
data.predmeti.PO <- merge(data.predmeti.PO, programi.imena[,c("ID", "Naziv")], by.x="ID_vrsta_studija", by.y="ID", all.x=TRUE, sort=FALSE)
names(data.predmeti.PO)[match(c("ID_vrsta_studija","Letnik","Naziv.y"), names(data.predmeti.PO))] <- c("student.program.sifra","student.letnik","student.program.ime")

##############
## PREDMETI ##
##############
# Izreačunamo povprečja predmetov še za anketo PO izpitu
# povprečja
predMean <- aggregate(data.predmeti.PO[c(vars.predmet$cont$vars[8:20],vars.predmet$krediti$vars,vars.predmet$kompetence1$vars)], by = data.predmeti.PO["predmet.sifra"], FUN = mean, na.rm = TRUE)
colnames(predMean)[2:ncol(predMean)] <- paste0(c(vars.predmet$cont$vars[8:20],vars.predmet$krediti$vars,vars.predmet$kompetence1$vars),"_mean")

# Mediane
predMedian <- aggregate(data.predmeti.PO[c(vars.predmet$cont$vars[8:20],vars.predmet$krediti$vars,vars.predmet$kompetence1$vars)], by = data.predmeti.PO["predmet.sifra"], FUN = median, na.rm = TRUE)
colnames(predMedian)[2:ncol(predMedian)] <- paste0(c(vars.predmet$cont$vars[8:20],vars.predmet$krediti$vars,vars.predmet$kompetence1$vars),"_median")

# sd
predSd <-  aggregate(data.predmeti.PO[c(vars.predmet$cont$vars[8:20],vars.predmet$krediti$vars,vars.predmet$kompetence1$vars)],   by = data.predmeti.PO["predmet.sifra"], FUN = sd, na.rm = TRUE)
colnames(predSd)[2:ncol(predSd)] <- paste0(c(vars.predmet$cont$vars[8:20],vars.predmet$krediti$vars,vars.predmet$kompetence1$vars),"_sd")

# min
predMin <- aggregate(data.predmeti.PO[c(vars.predmet$cont$vars[8:20],vars.predmet$krediti$vars)], by = data.predmeti.PO["predmet.sifra"], FUN = min, na.rm = TRUE)
colnames(predMin)[2:ncol(predMin)] <- paste0(c(vars.predmet$cont$vars[8:20],vars.predmet$krediti$vars),"_min")
predMin[predMin==Inf] <- NA

# max
predMax <- aggregate(data.predmeti.PO[c(vars.predmet$cont$vars[8:20],vars.predmet$krediti$vars)],
                     by = data.predmeti.PO["predmet.sifra"], FUN = max, na.rm = TRUE)
colnames(predMax)[2:ncol(predMax)] <- paste0(c(vars.predmet$cont$vars[8:20],vars.predmet$krediti$vars),"_max")
predMax[predMax==-Inf] <- NA

# N posamezne spremenljivke
predN <- aggregate(data.predmeti.PO[c(vars.predmet$cont$vars[8:20],vars.predmet$krediti$vars,vars.predmet$kompetence1$vars)],
                   by = data.predmeti.PO["predmet.sifra"], FUN=function(x) sum(!is.na(x)))
colnames(predN)[2:ncol(predN)] <- paste0(c(vars.predmet$cont$vars[8:20],vars.predmet$krediti$vars,vars.predmet$kompetence1$vars),"_N")

# N answering before and after exam
predNanket <- aggregate(data.predmeti.PO$veljavna, by = data.predmeti.PO["predmet.sifra"], FUN = sum)
colnames(predNanket)[2] <- "N_anket"
predNanket_po_izpitu <- aggregate(data.predmeti.PO$veljavna_po_izpitu, by = data.predmeti.PO["predmet.sifra"], FUN = sum)
colnames(predNanket_po_izpitu)[2] <- "N_anket_po_izpitu"

# N didn't want to answer before and after exam
predNzavrnjenih <- aggregate(data.predmeti.PO$zavrnjena, by = data.predmeti.PO["predmet.sifra"], FUN = sum)
colnames(predNzavrnjenih)[2] <- "N_zavrnjenih"
predNzavrnjenih_po_izpitu <- aggregate(data.predmeti.PO$zavrnjena_po_izpitu, by = data.predmeti.PO["predmet.sifra"], FUN = sum)
colnames(predNzavrnjenih_po_izpitu)[2] <- "N_zavrnjenih_po_izpitu"


# N Lurkerjev PRED izpitom
data.predmeti.PO$lurker[data.predmeti.PO$lurker==0] <- NA
poNLurkerji <- aggregate(as.numeric(data.predmeti.PO$lurker), by = data.predmeti.PO["predmet.sifra"],FUN=function(x) sum(!is.na(x)))
colnames(poNLurkerji)[2] <- "N_lurkerjev_po"


programi.PO <- unique(data.predmeti.PO[c("student.program.sifra", "student.program.ime")])
programi.PO <- subset(programi.PO, !is.na(student.program.sifra))
programi.PO <- subset(programi.PO, student.program.ime != "NA")
programi.PO <- programi.PO[order(programi.PO$student.program.ime), ]

## ŠTUDIJSKI PROGRAMI (ANKETA PO IZPTTU) ##
# Še za aneto PO izpitu izračunamo povprečja študijskih programov
# Skupne ocene predmetov po posameznih študijskih programih
progMeanPredm.PO <- aggregate(data.predmeti.PO[c(vars.predmet$cont$vars[8:20],vars.predmet$krediti$vars,vars.predmet$kompetence1$vars)],
                              by = data.predmeti.PO["student.program.sifra"], FUN = mean, na.rm = TRUE)
progMeanPredm.PO$predmet.ocena.SKUPAJ.po <- rowMeans(progMeanPredm.PO[vars.predmet$cont$po[-1]], na.rm = TRUE)
progMeanPredm.PO$predmet.ocena.SKUPAJ.praksa <- rowMeans(progMeanPredm.PO[vars.predmet$cont$praksa], na.rm = TRUE)


## course averages by programme: ANKETA PO IZPITU ##
povprecja.predmeti.programi.PO <- NULL
povprecja.predmeti.programi.PO.brez.cenzure.PO <- NULL   # Zapišemo vsa povprečja oz. vse ocene, tudi tista, ki imajo 4 odgovore ali manj
##  course averages by programme  ##
for (program in programi.PO$student.program.sifra) {
  # povprečja
  data.program <- subset(data.predmeti.PO, student.program.sifra == program)
  predMean <- aggregate(data.program[c(vars.predmet$cont$vars[8:20],vars.predmet$krediti$vars,vars.predmet$kompetence1$vars)], 
                        by = data.program["predmet.sifra"], FUN = mean, na.rm = TRUE)
  colnames(predMean)[2:ncol(predMean)] <- paste0(c(vars.predmet$cont$vars[8:20],vars.predmet$krediti$vars,vars.predmet$kompetence1$vars),"_mean")
  # N posamezne spremenljivke
  predN <- aggregate(data.program[c(vars.predmet$cont$vars[8:20],vars.predmet$krediti$vars,vars.predmet$kompetence1$vars)], 
                     by = data.program["predmet.sifra"], FUN = function(x) sum(!is.na(x)))
  colnames(predN)[2:ncol(predN)] <- paste0(c(vars.predmet$cont$vars[8:20],vars.predmet$krediti$vars,vars.predmet$kompetence1$vars),"_N")
  # N answering before and after exam
  predNanket <- aggregate(data.program$veljavna, by = data.program["predmet.sifra"], FUN = sum)
  colnames(predNanket)[2] <- "N_anket"
  predNanket_po_izpitu <- aggregate(data.program$veljavna_po_izpitu, by = data.program["predmet.sifra"], FUN = sum)
  colnames(predNanket_po_izpitu)[2] <- "N_anket_po_izpitu"
  
  predmeti.program <- merge(predMean, predN, by = "predmet.sifra", all = TRUE, sort = FALSE)
  predmeti.program <- merge(predmeti.program, predNanket, by = "predmet.sifra", all = TRUE, sort = FALSE)
  predmeti.program <- merge(predmeti.program, predNanket_po_izpitu, by = "predmet.sifra", all = TRUE, sort = FALSE)
  
  povprecja.predmeti.programi.PO.brez.cenzure.PO <- rbind(povprecja.predmeti.programi.PO.brez.cenzure.PO,cbind(predmeti.program, 
                                                                                                               program.studentov = program, 
                                                                                                               program.studentov.ime = programi.PO[programi.PO$student.program.sifra == program,
                                                                                                                                                "student.program.ime"]))
  
  # zakrivanje vrednosti kjer ni dovolj enot
  premalo <- predmeti.program[c(paste0(vars.predmet$cont$vars[8:20],"_N"),"predmet.ocena.krediti_N","predmet.ocena.kompetence1_N")] < minEnot
  predmeti.program[c(paste0(vars.predmet$cont$vars[8:20],"_mean"),"predmet.ocena.krediti_mean","predmet.ocena.kompetence1_mean")][premalo] <- NA
  
  
  # average of components - all, before, after exam
  
  predmeti.program$predmet.ocena.SKUPAJ.po <- rowMeans(predmeti.program[paste0(vars.predmet$cont$po[-1],"_mean")],na.rm=T)
  predmeti.program$predmet.ocena.SKUPAJ.praksa <- rowMeans(predmeti.program[paste0(vars.predmet$cont$praksa,"_mean")],na.rm=T)
  
  povprecja.predmeti.programi.PO <- rbind(povprecja.predmeti.programi.PO, cbind(predmeti.program, program.studentov = program,
                                                                                program.studentov.ime = programi.PO[programi.PO$student.program.sifra==program,
                                                                                                                 "student.program.ime"]))
}
povprecja.predmeti.programi.PO <- merge(povprecja.predmeti.programi.PO, povprecja.predmeti[, c("predmet.sifra", "ime.predmeta", "NACIN_STUDIJA")],
                                        by = "predmet.sifra", all.x = T)
povprecja.predmeti.programi.PO.brez.cenzure.PO <- merge(povprecja.predmeti.programi.PO.brez.cenzure.PO, 
                                                        povprecja.predmeti[, c("predmet.sifra", "ime.predmeta", "NACIN_STUDIJA")], 
                                                        by = "predmet.sifra", all.x = T)
## //course averages by programme// ##


## course averages by programme ##
povprecja.predmeti.programi <- NULL
povprecja.predmeti.programi.brez.cenzure <- NULL   # Zapišemo vsa povprečja oz. vse ocene, tudi tista, ki imajo 4 odgovore ali manj
##  course averages by programme  ##
for (program in programi$student.program.sifra) {
  # povprečja
  data.program <- subset(data.predmeti, student.program.sifra == program)
  
  predMean <- aggregate(data.program[c(vars.predmet$cont$vars,vars.predmet$krediti$vars,vars.predmet$kompetence1$vars)], by = data.program["predmet.sifra"], FUN = mean, na.rm = TRUE)
 # predMean.po <- aggregate(data.program.po[c(vars.predmet$cont$vars[8:20],vars.predmet$krediti$vars,vars.predmet$kompetence1$vars)], by = data.program.po["predmet.sifra"], FUN = mean, na.rm = TRUE)
#  predMean <- merge(predMean,predMean.po[c("predmet.sifra","predmet.ocena.kompetence","predmet.ocena.vsebine",
 #                                          "predmet.ocena.naloge","predmet.ocena.kriteriji",
  #                                         "predmet.ocena.krediti","predmet.ocena.kompetence1")], by="predmet.sifra", all=T, sort=F)
  #predMean <- predMean[, -grep(".x", colnames(predMean))]
  #colnames(predMean) <- gsub("\\.y", "", colnames(predMean))
  #predMean <- predMean[c(1:8,18:21,9:17,22:23)]
  colnames(predMean)[2:ncol(predMean)] <- paste0(c(vars.predmet$cont$vars,vars.predmet$krediti$vars,vars.predmet$kompetence1$vars),"_mean")
  # N posamezne spremenljivke
  predN <- aggregate(data.program[c(vars.predmet$cont$vars,vars.predmet$krediti$vars,vars.predmet$kompetence1$vars)], by = data.program["predmet.sifra"], FUN = function(x) sum(!is.na(x)))
 # predNpo <- aggregate(data.program.po[c(vars.predmet$cont$vars[8:20],vars.predmet$krediti$vars,vars.predmet$kompetence1$vars)], by = data.program.po["predmet.sifra"], FUN = function(x) sum(!is.na(x)))
  #predN <- merge(predN,predNpo[c("predmet.sifra","predmet.ocena.kompetence","predmet.ocena.vsebine",
   #                                        "predmet.ocena.naloge","predmet.ocena.kriteriji",
    #                                       "predmet.ocena.krediti","predmet.ocena.kompetence1")], by="predmet.sifra", all=T, sort=F)
  #predN <- predN[, -grep(".x", colnames(predN))]
  #colnames(predN) <- gsub("\\.y", "", colnames(predN))
  #predN <- predN[c(1:8,18:21,9:17,22:23)]
  colnames(predN)[2:ncol(predN)] <- paste0(c(vars.predmet$cont$vars,vars.predmet$krediti$vars,vars.predmet$kompetence1$vars),"_N")
  # N answering before and after exam
  predNanket <- aggregate(data.program$veljavna, by = data.program["predmet.sifra"], FUN = sum)
  colnames(predNanket)[2] <- "N_anket"
  predNanket_po_izpitu <- aggregate(data.program$veljavna_po_izpitu, by = data.program["predmet.sifra"], FUN = sum)
  colnames(predNanket_po_izpitu)[2] <- "N_anket_po_izpitu"
  predmeti.program <- merge(predMean, predN, by = "predmet.sifra", all = TRUE, sort = FALSE)
  predmeti.program <- merge(predmeti.program, predNanket, by = "predmet.sifra", all = TRUE, sort = FALSE)
  predmeti.program <- merge(predmeti.program, predNanket_po_izpitu, by = "predmet.sifra", all = TRUE, sort = FALSE)
  
  povprecja.predmeti.programi.brez.cenzure <- rbind(povprecja.predmeti.programi.brez.cenzure,cbind(predmeti.program, 
                                                                                                   program.studentov = program, 
                                                                                                   program.studentov.ime = programi[programi$student.program.sifra == program,
                                                                                                                                    "student.program.ime"]))

  # zakrivanje vrednosti kjer ni dovolj enot
  premalo <- predmeti.program[c(paste0(vars.predmet$cont$vars,"_N"),"predmet.ocena.krediti_N","predmet.ocena.kompetence1_N")] < minEnot
  predmeti.program[c(paste0(vars.predmet$cont$vars,"_mean"),"predmet.ocena.krediti_mean","predmet.ocena.kompetence1_mean")][premalo] <- NA
  
  
  # average of components - all, before, after exam
  predmeti.program$predmet.ocena.SKUPAJ <- rowMeans(predmeti.program[paste0(vars.predmet$cont$vars,"_mean")],na.rm=T)
  predmeti.program$predmet.ocena.SKUPAJ.pred <- rowMeans(predmeti.program[paste0(vars.predmet$cont$pred,"_mean")],na.rm=T)
  predmeti.program$predmet.ocena.SKUPAJ.po <- rowMeans(predmeti.program[paste0(vars.predmet$cont$po[-1],"_mean")],na.rm=T)
  predmeti.program$predmet.ocena.SKUPAJ.praksa <- rowMeans(predmeti.program[paste0(vars.predmet$cont$praksa,"_mean")],na.rm=T)
  
  povprecja.predmeti.programi <- rbind(povprecja.predmeti.programi, cbind(predmeti.program, program.studentov = program,
                                                                          program.studentov.ime = programi[programi$student.program.sifra==program,
                                                                                                           "student.program.ime"]))
}
povprecja.predmeti.programi <- merge(povprecja.predmeti.programi, povprecja.predmeti[, c("predmet.sifra", "ime.predmeta", "NACIN_STUDIJA")],
                                     by = "predmet.sifra", all.x = T)
povprecja.predmeti.programi.brez.cenzure <- merge(povprecja.predmeti.programi.brez.cenzure, 
                                                  povprecja.predmeti[, c("predmet.sifra", "ime.predmeta", "NACIN_STUDIJA")], 
                                                  by = "predmet.sifra", all.x = T)
## //course averages by programme// ##



 
## course averages by student's year ANKETA PO IZPITU ##
povprecja.predmeti.letniki.PO <- NULL
povprecja.predmeti.letniki.PO.brez.cenzure.PO <- NULL  # Vsa povprečja oz. vse ocene, tudi tiste, ki imajo 4 odgovore ali manj
##  course averages by students' year  ##
for (letnik in unique(sort(data.predmeti.PO$student.letnik))) {
  # povprečja
  data.letnik <- subset(data.predmeti.PO, student.letnik == letnik)
  predMean <- aggregate(data.letnik[c(vars.predmet$cont$vars[8:20],vars.predmet$krediti$vars,vars.predmet$kompetence1$vars)], 
                        by = data.letnik["predmet.sifra"], 
                        FUN=mean, na.rm=TRUE)
  colnames(predMean)[2:ncol(predMean)] <- paste0(c(vars.predmet$cont$vars[8:20],vars.predmet$krediti$vars,vars.predmet$kompetence1$vars),"_mean")
  # N posamezne spremenljivke
  predN <- aggregate(data.letnik[c(vars.predmet$cont$vars[8:20],vars.predmet$krediti$vars,vars.predmet$kompetence1$vars)],
                     by=data.letnik["predmet.sifra"], FUN=function(x) sum(!is.na(x)))
  colnames(predN)[2:ncol(predN)] <- paste0(c(vars.predmet$cont$vars[8:20],vars.predmet$krediti$vars,vars.predmet$kompetence1$vars),"_N")
  # N answering before and after exam
  predNanket <- aggregate(data.letnik$veljavna, by = data.letnik["predmet.sifra"], FUN = sum)
  colnames(predNanket)[2] <- "N_anket"
  predNanket_po_izpitu <- aggregate(data.letnik$veljavna_po_izpitu, by=data.letnik["predmet.sifra"], FUN = sum)
  colnames(predNanket_po_izpitu)[2] <- "N_anket_po_izpitu"
  
  predmeti.letnik <- merge(predMean, predN, by = "predmet.sifra", all = TRUE, sort = FALSE)
  predmeti.letnik <- merge(predmeti.letnik, predNanket, by = "predmet.sifra", all = TRUE, sort = FALSE)
  predmeti.letnik <- merge(predmeti.letnik, predNanket_po_izpitu, by = "predmet.sifra", all = TRUE, sort = FALSE)
  
  povprecja.predmeti.letniki.PO.brez.cenzure.PO <- rbind(povprecja.predmeti.letniki.PO.brez.cenzure.PO, cbind(predmeti.letnik, letnik.studentov = letnik))
  
  # zakrivanje vrednosti kjer ni dovolj enot
  premalo <- predmeti.letnik[c(paste0(vars.predmet$cont$vars[8:20],"_N"),"predmet.ocena.krediti_N","predmet.ocena.kompetence1_N")] < minEnot
  predmeti.letnik[c(paste0(vars.predmet$cont$vars[8:20],"_mean"),"predmet.ocena.krediti_mean","predmet.ocena.kompetence1_mean")][premalo] <- NA
  
  
  # average of components - all, before, after exam
  predmeti.letnik$predmet.ocena.SKUPAJ.po <- rowMeans(predmeti.letnik[paste0(vars.predmet$cont$po[-1],"_mean")], na.rm = T)
  predmeti.letnik$predmet.ocena.SKUPAJ.praksa <- rowMeans(predmeti.letnik[paste0(vars.predmet$cont$praksa,"_mean")], na.rm = T)
  
  povprecja.predmeti.letniki.PO <- rbind(povprecja.predmeti.letniki.PO, cbind(predmeti.letnik, letnik.studentov=letnik))
}
povprecja.predmeti.letniki.PO <- merge(povprecja.predmeti.letniki.PO, povprecja.predmeti[, c("predmet.sifra", "ime.predmeta", "NACIN_STUDIJA")], 
                                       by = "predmet.sifra", all.x = T)
povprecja.predmeti.letniki.PO.brez.cenzure.PO <- merge(povprecja.predmeti.letniki.PO.brez.cenzure.PO, 
                                                       povprecja.predmeti[, c("predmet.sifra", "ime.predmeta", "NACIN_STUDIJA")], 
                                                       by = "predmet.sifra", all.x = T)
## //course averages by students' year// ##



## course averages by student's year ##
povprecja.predmeti.letniki <- NULL
povprecja.predmeti.letniki.brez.cenzure <- NULL  # Vsa povprečja oz. vse ocene, tudi tiste, ki imajo 4 odgovore ali manj
##  course averages by students' year  ##
for (letnik in unique(sort(data.predmeti$student.letnik))) {
  # povprečja
  data.letnik <- subset(data.predmeti, student.letnik == letnik)
 # data.letnik.po <- subset(data.predmeti.PO, student.program.sifra == program)
  
  predMean <- aggregate(data.letnik[c(vars.predmet$cont$vars,vars.predmet$krediti$vars,vars.predmet$kompetence1$vars)], 
                        by = data.letnik["predmet.sifra"], FUN=mean, na.rm=TRUE)
  #predMean.po <- aggregate(data.letnik.po[c(vars.predmet$cont$vars[8:20],vars.predmet$krediti$vars,vars.predmet$kompetence1$vars)], by = data.letnik.po["predmet.sifra"], FUN = mean, na.rm = TRUE)
  #predMean <- merge(predMean,predMean.po[c("predmet.sifra","predmet.ocena.kompetence","predmet.ocena.vsebine",
   #                                        "predmet.ocena.naloge","predmet.ocena.kriteriji",
    #                                       "predmet.ocena.krediti","predmet.ocena.kompetence1")], by="predmet.sifra", all=T, sort=F)
  #predMean <- predMean[, -grep(".x", colnames(predMean))]
  #colnames(predMean) <- gsub("\\.y", "", colnames(predMean))
  #predMean <- predMean[c(1:8,18:21,9:17,22:23)]
  colnames(predMean)[2:ncol(predMean)] <- paste0(c(vars.predmet$cont$vars,vars.predmet$krediti$vars,vars.predmet$kompetence1$vars),"_mean")
  # N posamezne spremenljivke
  predN <- aggregate(data.letnik[c(vars.predmet$cont$vars,vars.predmet$krediti$vars,vars.predmet$kompetence1$vars)],
                     by=data.letnik["predmet.sifra"], FUN=function(x) sum(!is.na(x)))
  #predNpo <- aggregate(data.letnik.po[c(vars.predmet$cont$vars[8:20],vars.predmet$krediti$vars,vars.predmet$kompetence1$vars)], by = data.letnik.po["predmet.sifra"], FUN = function(x) sum(!is.na(x)))
  #predN <- merge(predN,predNpo[c("predmet.sifra","predmet.ocena.kompetence","predmet.ocena.vsebine",
   #                              "predmet.ocena.naloge","predmet.ocena.kriteriji",
    #                             "predmet.ocena.krediti","predmet.ocena.kompetence1")], by="predmet.sifra", all=T, sort=F)
  #predN <- predN[, -grep(".x", colnames(predN))]
  #colnames(predN) <- gsub("\\.y", "", colnames(predN))
  #predN <- predN[c(1:8,18:21,9:17,22:23)]
  colnames(predN)[2:ncol(predN)] <- paste0(c(vars.predmet$cont$vars,vars.predmet$krediti$vars,vars.predmet$kompetence1$vars),"_N")
  # N answering before and after exam
  predNanket <- aggregate(data.letnik$veljavna, by = data.letnik["predmet.sifra"], FUN = sum)
  colnames(predNanket)[2] <- "N_anket"
  predNanket_po_izpitu <- aggregate(data.letnik$veljavna_po_izpitu, by=data.letnik["predmet.sifra"], FUN = sum)
  colnames(predNanket_po_izpitu)[2] <- "N_anket_po_izpitu"
  
  predmeti.letnik <- merge(predMean, predN, by = "predmet.sifra", all = TRUE, sort = FALSE)
  predmeti.letnik <- merge(predmeti.letnik, predNanket, by = "predmet.sifra", all = TRUE, sort = FALSE)
  predmeti.letnik <- merge(predmeti.letnik, predNanket_po_izpitu, by = "predmet.sifra", all = TRUE, sort = FALSE)
  
  povprecja.predmeti.letniki.brez.cenzure <- rbind(povprecja.predmeti.letniki.brez.cenzure, cbind(predmeti.letnik, letnik.studentov = letnik))
  
  # zakrivanje vrednosti kjer ni dovolj enot
  premalo <- predmeti.letnik[c(paste0(vars.predmet$cont$vars,"_N"),"predmet.ocena.krediti_N","predmet.ocena.kompetence1_N")] < minEnot
  predmeti.letnik[c(paste0(vars.predmet$cont$vars,"_mean"),"predmet.ocena.krediti_mean","predmet.ocena.kompetence1_mean")][premalo] <- NA
  
  
  # average of components - all, before, after exam
  predmeti.letnik$predmet.ocena.SKUPAJ <- rowMeans(predmeti.letnik[paste0(vars.predmet$cont$vars,"_mean")], na.rm = T)
  predmeti.letnik$predmet.ocena.SKUPAJ.pred <- rowMeans(predmeti.letnik[paste0(vars.predmet$cont$pred,"_mean")], na.rm = T)
  predmeti.letnik$predmet.ocena.SKUPAJ.po <- rowMeans(predmeti.letnik[paste0(vars.predmet$cont$po[-1],"_mean")], na.rm = T)
  predmeti.letnik$predmet.ocena.SKUPAJ.praksa <- rowMeans(predmeti.letnik[paste0(vars.predmet$cont$praksa,"_mean")], na.rm = T)
  
  povprecja.predmeti.letniki <- rbind(povprecja.predmeti.letniki, cbind(predmeti.letnik, letnik.studentov=letnik))
}
povprecja.predmeti.letniki <- merge(povprecja.predmeti.letniki, povprecja.predmeti[, c("predmet.sifra", "ime.predmeta", "NACIN_STUDIJA")], 
                                    by = "predmet.sifra", all.x = T)
povprecja.predmeti.letniki.brez.cenzure <- merge(povprecja.predmeti.letniki.brez.cenzure, 
                                                 povprecja.predmeti[, c("predmet.sifra", "ime.predmeta", "NACIN_STUDIJA")], 
                                                 by = "predmet.sifra", all.x = T)
## //course averages by students' year// ##

####################################
## lecturer averages by programme ##
####################################
povprecja.izvajalci.programi <- NULL
povprecja.izvajalci.programi.brez.cenzure <- NULL # Vsa povprečja oz. vse ocene, tudi tiste, ki imajo 4 odgovore ali manj
##  lecturer averages by programme  ##
for (program in programi$student.program.sifra) {
  data.program <- subset(data.izvajalci, student.program.sifra == program)
  if (nrow(data.program)>0){
    # povprečja
    izvMean <- aggregate(data.program[vars.izvajalec$cont$vars],by=data.program[c("predmet.sifra","izvajalec.sifra")], FUN = mean, na.rm = TRUE)
    colnames(izvMean)[3:ncol(izvMean)] <- paste0(vars.izvajalec$cont$vars,"_mean")
   
    # N posamezne spremenljivke
    izvN <- aggregate(data.program[vars.izvajalec$cont$vars], by=data.program[c("predmet.sifra","izvajalec.sifra")], FUN=function(x) sum(!is.na(x)))
    colnames(izvN)[3:ncol(izvN)] <- paste0(vars.izvajalec$cont$vars,"_N")
   
    # N anket
    izvNanket <- aggregate(data.program$veljavna, by=data.program[c("predmet.sifra","izvajalec.sifra")], FUN = sum)
    colnames(izvNanket)[3] <- "N_anket"
    
    # Merge
    izvajalci.program <- merge(izvMean, izvN, by=c("izvajalec.sifra", "predmet.sifra"), all = TRUE, sort = FALSE)
    izvajalci.program <- merge(izvajalci.program, izvNanket, by=c("izvajalec.sifra", "predmet.sifra"), all = TRUE, sort = FALSE)
    povprecja.izvajalci.programi.brez.cenzure <-  rbind(povprecja.izvajalci.programi.brez.cenzure, 
                                                        cbind(izvajalci.program, program.studentov=program, 
                                                              program.studentov.ime=programi[programi$student.program.sifra==program,
                                                                                             "student.program.ime"]))
    
    # zakrivanje vrednosti kjer ni dovolj enot
    premalo <- izvajalci.program[paste0(vars.izvajalec$cont$vars,"_N")] < minEnot
    izvajalci.program[paste0(vars.izvajalec$cont$vars,"_mean")][premalo] <- NA
    # average of components
    izvajalci.program$izvajalec.ocena.SKUPAJ <- rowMeans(izvajalci.program[paste0(vars.izvajalec$cont$vars,"_mean")],na.rm=T)
    
    povprecja.izvajalci.programi <- rbind(povprecja.izvajalci.programi, cbind(izvajalci.program, program.studentov=program, 
                                                                              program.studentov.ime=programi[programi$student.program.sifra==program,
                                                                                                             "student.program.ime"]))
  }
}
povprecja.izvajalci.programi <- merge(povprecja.izvajalci.programi, 
                                      povprecja.izvajalci[,c("izvajalec.sifra", "predmet.sifra",
                                                             "ime.predmeta", "NAZIV.PEDAGOGA", "NACIN_STUDIJA")],
                                      by=c("izvajalec.sifra", "predmet.sifra"), all.x=T)
povprecja.predmeti.programi1 <- merge(povprecja.predmeti.programi,
                                      povprecja.predmeti[, c("predmet.sifra", "ime.predmeta", "NACIN_STUDIJA",
                                                             "ST_STUD","sodelujocih.pct",	"sodelujocih.pct_po_izpitu",
                                                             "zavrnjenih.pct",	"zavrnjenih.pct_po_izpitu","neodzivnih.pct",
                                                             "neodzivnih.pct_po_izpitu")], 
                                      by="predmet.sifra", all.x=T)

povprecja.izvajalci.programi.brez.cenzure <- merge(povprecja.izvajalci.programi.brez.cenzure, 
                                                   povprecja.izvajalci[,c("izvajalec.sifra", "predmet.sifra", "ime.predmeta", "NAZIV.PEDAGOGA", "NACIN_STUDIJA")],
                                                   by=c("izvajalec.sifra", "predmet.sifra"), all.x=T)
## //lecturer averages by programme// ##

#########################################
## lecturer averages by students' year ##
#########################################
povprecja.izvajalci.letniki <- NULL
povprecja.izvajalci.letniki.brez.cenzure <- NULL # Vsa povprečja oz. vse ocene, tudi tiste, ki imajo 4 odgovore ali manj
##  lecturer averages by students' year  ##
for (letnik in unique(sort(data.izvajalci$student.letnik))) {
  data.letnik <- subset(data.izvajalci, student.letnik == letnik)
  
  # povprečja
  izvMean <- aggregate(data.letnik[vars.izvajalec$cont$vars], by=data.letnik[c("predmet.sifra","izvajalec.sifra")], FUN=mean, na.rm=TRUE)
  colnames(izvMean)[3:ncol(izvMean)] <- paste0(vars.izvajalec$cont$vars,"_mean")
 
   # N posamezne spremenljivke
  izvN <- aggregate(data.letnik[vars.izvajalec$cont$vars], by=data.letnik[c("predmet.sifra","izvajalec.sifra")], FUN=function(x) sum(!is.na(x)))
  colnames(izvN)[3:ncol(izvN)] <- paste0(vars.izvajalec$cont$vars,"_N")
  
  # N anket
  izvNanket <- aggregate(data.letnik$veljavna, by=data.letnik[c("predmet.sifra","izvajalec.sifra")], FUN=sum)
  colnames(izvNanket)[3] <- "N_anket"
  
  # Merge
  izvajalci.letnik <- merge(izvMean, izvN, by=c("izvajalec.sifra", "predmet.sifra"), all=TRUE, sort=FALSE)
  izvajalci.letnik <- merge(izvajalci.letnik, izvNanket, by=c("izvajalec.sifra", "predmet.sifra"), all=TRUE, sort=FALSE)
  povprecja.izvajalci.letniki.brez.cenzure <- rbind(povprecja.izvajalci.letniki.brez.cenzure, 
                                                    cbind(izvajalci.letnik, letnik.studentov=letnik))
  
  # zakrivanje vrednosti kjer ni dovolj enot
  premalo <- izvajalci.letnik[paste0(vars.izvajalec$cont$vars,"_N")] < minEnot
  izvajalci.letnik[paste0(vars.izvajalec$cont$vars,"_mean")][premalo] <- NA
  
  povprecja.izvajalci.letniki <- rbind(povprecja.izvajalci.letniki, cbind(izvajalci.letnik, letnik.studentov=letnik))
}
povprecja.izvajalci.letniki <- merge(povprecja.izvajalci.letniki,
                                     povprecja.izvajalci[,c("izvajalec.sifra", "predmet.sifra",
                                                            "ime.predmeta", "NAZIV.PEDAGOGA", "NACIN_STUDIJA")],
                                     by=c("izvajalec.sifra", "predmet.sifra"), all.x=T)
povprecja.izvajalci.letniki.brez.cenzure <- merge(povprecja.izvajalci.letniki.brez.cenzure, 
                                                  povprecja.izvajalci[,c("izvajalec.sifra", "predmet.sifra", "ime.predmeta",
                                                                         "NAZIV.PEDAGOGA", "NACIN_STUDIJA")],
                                                  by=c("izvajalec.sifra", "predmet.sifra"), all.x=T)
## //lecturer averages by students' year// ##

############################
#  quantiles by programme  #
###########################
kvantili.izvajalci.programi <- NULL
for (program in unique(povprecja.izvajalci.programi$program.studentov)) {
  kvantili.izvajalci.program <- povprecja.izvajalci.programi[povprecja.izvajalci.programi$program.studentov == program &
                                                               povprecja.izvajalci.programi$N_anket > 0, 
                                                             c("izvajalec.sifra","predmet.sifra","program.studentov","program.studentov.ime",
                                                               "N_anket",paste0(vars.izvajalec$cont$vars,"_mean"),"izvajalec.ocena.SKUPAJ")]
  for (var in c(paste0(vars.izvajalec$cont$vars,"_mean"),"izvajalec.ocena.SKUPAJ")) {
    kvantili.izvajalci.program[[var]] <- kvantRang(kvantili.izvajalci.program[[var]])
  }
  
  for (var in c("N_anket")) {
    kvantili.izvajalci.program[[var]] <- kvantRang1(kvantili.izvajalci.program[[var]])
  }
  
  kvantili.izvajalci.programi <- rbind(kvantili.izvajalci.programi, kvantili.izvajalci.program)
}

kvantili.predmeti.programi <- NULL
for (program in unique(povprecja.predmeti.programi$program.studentov)) {
  kvantili.predmeti.program <- povprecja.predmeti.programi[povprecja.predmeti.programi$program.studentov == program & 
                                                             (povprecja.predmeti.programi$N_anket > 0 | povprecja.predmeti.programi$N_anket_po_izpitu > 0), 
                                                           c("predmet.sifra","N_anket","N_anket_po_izpitu","program.studentov","program.studentov.ime",
                                                             paste0(vars.predmet$cont$vars,"_mean"),"predmet.ocena.SKUPAJ","predmet.ocena.SKUPAJ.pred",
                                                             "predmet.ocena.SKUPAJ.po","predmet.ocena.SKUPAJ.praksa","predmet.ocena.krediti_mean",
                                                             "predmet.ocena.kompetence1_mean")]
  for (var in c(paste0(vars.predmet$cont$vars,"_mean"),"predmet.ocena.SKUPAJ",
                "predmet.ocena.SKUPAJ.pred","predmet.ocena.SKUPAJ.po","predmet.ocena.SKUPAJ.praksa")) {
    kvantili.predmeti.program[[var]] <- kvantRang(kvantili.predmeti.program[[var]])
  }
  for (var in c("N_anket","N_anket_po_izpitu")) {
    kvantili.predmeti.program[[var]] <- kvantRang1(kvantili.predmeti.program[[var]])
  }
  
  for (var in c("predmet.ocena.krediti_mean","predmet.ocena.kompetence1_mean")) {
    kvantili.predmeti.program[[var]] <- kvantRang2(kvantili.predmeti.program[[var]])
  }
  
  
  kvantili.predmeti.programi <- rbind(kvantili.predmeti.programi, kvantili.predmeti.program)
}


kvantili.predmeti.programi.PO <- NULL
for (program in unique(povprecja.predmeti.programi.PO$program.studentov)) {
  kvantili.predmeti.program <- povprecja.predmeti.programi.PO[povprecja.predmeti.programi.PO$program.studentov == program & 
                                                                (povprecja.predmeti.programi.PO$N_anket > 0 | povprecja.predmeti.programi.PO$N_anket_po_izpitu > 0), 
                                                              c("predmet.sifra","N_anket","N_anket_po_izpitu","program.studentov","program.studentov.ime",
                                                                paste0(vars.predmet$cont$vars[8:20],"_mean"),
                                                                "predmet.ocena.SKUPAJ.po","predmet.ocena.SKUPAJ.praksa","predmet.ocena.krediti_mean",
                                                                "predmet.ocena.kompetence1_mean")]
  for (var in c(paste0(vars.predmet$cont$vars[8:20],"_mean"),"predmet.ocena.SKUPAJ.po","predmet.ocena.SKUPAJ.praksa")) {
    kvantili.predmeti.program[[var]] <- kvantRang(kvantili.predmeti.program[[var]])
  }
  for (var in c("N_anket","N_anket_po_izpitu")) {
    kvantili.predmeti.program[[var]] <- kvantRang1(kvantili.predmeti.program[[var]])
  }
  
  for (var in c("predmet.ocena.krediti_mean","predmet.ocena.kompetence1_mean")) {
    kvantili.predmeti.program[[var]] <- kvantRang2(kvantili.predmeti.program[[var]])
  }
  
  
  kvantili.predmeti.programi.PO <- rbind(kvantili.predmeti.programi.PO, kvantili.predmeti.program)
}
# /quantiles by programme/ #


#################################
## statistics for methodology ## (Glej izpis za izvajalca, in sicer poglavje Metodološko pojasnilo)  
#################################
data.predmeti <- merge(data.predmeti, sifrant[!duplicated(sifrant$IDP), c("IDP","SEMESTER_IZV")],
                       by.x="predmet.sifra", by.y="IDP",  all.x=TRUE)

## ZIMSKI SEMESTER ##
metod_XXX <- length(unique(subset(sifrant, SEMESTER_IZV %in% prvi_semester)$IDP)) # število predmetov
metod_YYY <- length(unique(subset(sifrant, SEMESTER_IZV %in% prvi_semester)$IDPEDAGOGA)) # število pedagogov
metod_ZZZ <- length(unique(studenti$"ID_studenta_.MD5.")) # Število študentov

metod_UUU <- nrow(subset(sifrant, SEMESTER_IZV %in% prvi_semester)) # število izvedb..

metod_VVV <- metod_XXX # number of prepared evaluations for courses
metod_RRR <- metod_UUU # number of prepared evaluations for lecturers

# ANKETA PRED izpitom
metod_X1 <- sum(subset(povprecja.predmeti, SEMESTER_IZV %in% prvi_semester)$N_anket, na.rm=TRUE) # no. evaluations answers
metod_X2 <- sum(subset(povprecja.predmeti, SEMESTER_IZV %in% prvi_semester)$N_zavrnjenih, na.rm=TRUE) # no. evaluations rejected
metod_X3 <- sum(subset(povprecja.predmeti, SEMESTER_IZV %in% prvi_semester)$N_neodzivnih, na.rm=TRUE) # no. evaluations didn't start
method_xsum<-metod_X1+metod_X2+metod_X3

metod_X4 <- sum((aggregate(subset(data.predmeti, SEMESTER_IZV %in% prvi_semester)$veljavna, by=data.predmeti[data.predmeti$SEMESTER_IZV %in% prvi_semester, "student.sifra", drop=FALSE], FUN=sum, na.rm=TRUE)$x == 0) & (aggregate(subset(data.predmeti, SEMESTER_IZV %in% prvi_semester)$zavrnjena, by=data.predmeti[data.predmeti$SEMESTER_IZV %in% prvi_semester, "student.sifra", drop=FALSE], FUN=sum, na.rm=TRUE)$x > 0)) # no. students rejected all evaluations
metod_X5 <- sum(!(unique(studenti$"ID_studenta_.MD5.") %in% data_pred_izpitom[data_pred_izpitom[[navodila["predmet.sifra","lokacije.predmet"]]] %in% subset(sifrant, SEMESTER_IZV %in% prvi_semester)$IDP, navodila["student.sifra","lokacije.student"]])) # no. students with no started evaluations
metod_X6 <- length(unique(subset(data.predmeti, veljavna & SEMESTER_IZV %in% prvi_semester)$student.sifra)) # no. students participated in at least 1 evaluation
metodPREDSum <- metod_X4 + metod_X5 + metod_X6

metod_X4.pct <- round((metod_X4/metodPREDSum) * 100, 0) # Percentage of students rejected all evaluations
metod_X5.pct <- round((metod_X5/metodPREDSum) * 100, 0) # Percentage of students with no started evaluations
metod_X6.pct <- round((metod_X6/metodPREDSum) * 100, 0) # Percentage od students participated in at least 1 evaluation

# ANKETA PO izpitu
metod_Y1 <- sum(subset(povprecja.predmeti, SEMESTER_IZV %in% prvi_semester)$N_anket_po_izpitu, na.rm=TRUE) # no. evaluations answers
metod_Y2 <- sum(subset(povprecja.predmeti, SEMESTER_IZV %in% prvi_semester)$N_zavrnjenih_po_izpitu, na.rm=TRUE) # no. evaluations rejected
metod_Y3 <- sum(subset(povprecja.predmeti, SEMESTER_IZV %in% prvi_semester)$N_neodzivnih_po_izpitu, na.rm=TRUE) # no. evaluations didn't start

metod_Y4 <- sum((aggregate(subset(data.predmeti, SEMESTER_IZV %in% prvi_semester)$veljavna_po_izpitu, by=data.predmeti[data.predmeti$SEMESTER_IZV %in% prvi_semester, "student.sifra", drop=FALSE], FUN=sum, na.rm=TRUE)$x == 0) & (aggregate(subset(data.predmeti, SEMESTER_IZV %in% prvi_semester)$zavrnjena_po_izpitu, by=data.predmeti[data.predmeti$SEMESTER_IZV %in% prvi_semester, "student.sifra", drop=FALSE], FUN=sum, na.rm=TRUE)$x > 0)) # no. students rejected all evaluations
metod_Y5 <- sum(!(unique(studenti$"ID_studenta_.MD5.") %in% data_po_izpitu[data_po_izpitu[[navodila["predmet.sifra","lokacije.predmet"]]] %in% subset(sifrant, SEMESTER_IZV %in% prvi_semester)$IDP, navodila["student.sifra","lokacije.student"]])) # no. students with no started evaluations
metod_Y6 <- length(unique(subset(data.predmeti, veljavna_po_izpitu & SEMESTER_IZV %in% prvi_semester)$student.sifra)) # no. students participated in at least 1 evaluation
metodPOSum <- metod_Y4 + metod_Y5 + metod_Y6

metod_Y4.pct <- round((metod_Y4/metodPOSum) * 100, 0) # Percentage of students rejected all evaluations
metod_Y5.pct <- round((metod_Y5/metodPOSum) * 100, 0) # Percentage of students with no started evaluations
metod_Y6.pct <- round((metod_Y6/metodPOSum) * 100, 0) # Percentage od students participated in at least 1 evaluation
## //ZIMSKI// ##


## LETNI/CELOLETNI (drugi semester) ##
metod_XXX1 <- length(unique(subset(sifrant, SEMESTER_IZV %in% drugi_semester)$IDP)) # število predmetov
metod_YYY1 <- length(unique(subset(sifrant, SEMESTER_IZV %in% drugi_semester)$IDPEDAGOGA)) # število pedagogov
metod_ZZZ1 <- length(unique(studenti$"ID_studenta_.MD5.")) # število študentov

metod_UUU1 <- nrow(subset(sifrant, SEMESTER_IZV %in% drugi_semester)) # število izvedb..

# ANKETA PRED izpitom
metod_X11 <- sum(subset(povprecja.predmeti, SEMESTER_IZV %in% drugi_semester)$N_anket, na.rm=TRUE) # no. evaluations answers
metod_X21 <- sum(subset(povprecja.predmeti, SEMESTER_IZV %in% drugi_semester)$N_zavrnjenih, na.rm=TRUE) # no. evaluations rejected
metod_X31 <- sum(subset(povprecja.predmeti, SEMESTER_IZV %in% drugi_semester)$N_neodzivnih, na.rm=TRUE) # no. evaluations didn't start
method_xsum1 <- metod_X11 + metod_X21 + metod_X31

if (length(subset(data.predmeti, SEMESTER_IZV %in% drugi_semester)$veljavna > 0)) { # V primeru da ni vrednosti naj bodo v tabela 0 in ne NA vrednosti
  metod_X41 <- sum((aggregate(subset(data.predmeti, SEMESTER_IZV %in% drugi_semester)$veljavna, by=data.predmeti[data.predmeti$SEMESTER_IZV %in% drugi_semester, "student.sifra", drop=FALSE], FUN=sum, na.rm=TRUE)$x == 0) & (aggregate(subset(data.predmeti, SEMESTER_IZV %in% drugi_semester)$zavrnjena, by=data.predmeti[data.predmeti$SEMESTER_IZV %in% drugi_semester, "student.sifra", drop=FALSE], FUN=sum, na.rm=TRUE)$x > 0)) # no. students rejected all evaluations
} else {metod_X41 <- 0}
metod_X51 <- sum(!(unique(studenti$"ID_studenta_.MD5.") %in% data_pred_izpitom[data_pred_izpitom[[navodila["predmet.sifra","lokacije.predmet"]]] %in% subset(sifrant, SEMESTER_IZV %in% drugi_semester)$IDP, navodila["student.sifra","lokacije.student"]])) # no. students with no started evaluations
metod_X61 <- length(unique(subset(data.predmeti, veljavna & SEMESTER_IZV %in% drugi_semester)$student.sifra)) # no. students participated in at least 1 evaluation
metodPREDSum_2 <- metod_X41 + metod_X51 + metod_X61

metod_X41.pct<-round((metod_X41/metodPREDSum_2) * 100, 0) # Percentage of students rejected all evaluations
metod_X51.pct<-round((metod_X51/metodPREDSum_2) * 100, 0) # Percentage of students with no started evaluations
metod_X61.pct<-round((metod_X61/metodPREDSum_2) * 100, 0) # Percentage od students participated in at least 1 evaluation

# ANKETA PO izpitu
metod_Y11 <- sum(subset(povprecja.predmeti, SEMESTER_IZV %in% drugi_semester)$N_anket_po_izpitu, na.rm=TRUE) # no. evaluations answers
metod_Y21 <- sum(subset(povprecja.predmeti, SEMESTER_IZV %in% drugi_semester)$N_zavrnjenih_po_izpitu, na.rm=TRUE) # no. evaluations rejected
metod_Y31 <- sum(subset(povprecja.predmeti, SEMESTER_IZV %in% drugi_semester)$N_neodzivnih_po_izpitu, na.rm=TRUE) # no. evaluations didn't start

if (length(subset(data.predmeti, SEMESTER_IZV %in% drugi_semester)$veljavna_po_izpitu > 0)) {
  metod_Y41 <- sum((aggregate(subset(data.predmeti, SEMESTER_IZV %in% drugi_semester)$veljavna_po_izpitu, by=data.predmeti[data.predmeti$SEMESTER_IZV %in% drugi_semester, "student.sifra", drop=FALSE], FUN=sum, na.rm=TRUE)$x == 0) & (aggregate(subset(data.predmeti, SEMESTER_IZV %in% drugi_semester)$zavrnjena_po_izpitu, by=data.predmeti[data.predmeti$SEMESTER_IZV %in% drugi_semester, "student.sifra", drop=FALSE], FUN=sum, na.rm=TRUE)$x > 0)) # no. students rejected all evaluations
} else {metod_Y41 <- 0}
metod_Y51 <- sum(!(unique(studenti$"ID_studenta_.MD5.") %in% data_po_izpitu[data_po_izpitu[[navodila["predmet.sifra","lokacije.predmet"]]] %in% subset(sifrant, SEMESTER_IZV %in% drugi_semester)$IDP, navodila["student.sifra","lokacije.student"]])) # no. students with no started evaluations
metod_Y61 <- length(unique(subset(data.predmeti, veljavna_po_izpitu & SEMESTER_IZV %in% drugi_semester)$student.sifra)) # no. students participated in at least 1 evaluation
metodPOSum_2 <- metod_Y41 + metod_Y51 + metod_Y61


metod_Y41.pct <- round((metod_Y41/metodPOSum_2) * 100, 0) # Percentage of students rejected all evaluations
metod_Y51.pct <- round((metod_Y51/metodPOSum_2) * 100, 0) # Percentage of students with no started evaluations
metod_Y61.pct <- round((metod_Y61/metodPOSum_2) * 100, 0) # Percentage od students participated in at least 1 evaluation

## //LETNI/CELOLETNI// ##


# answers 
metod_XX <- round(FDVpredmeti["prvi_semester", "sodelujocih.pct"]) # Delež študentov FDV, ki so v sodelovali v anketi PRED (v prvem semestru)
metod_YY <- round(FDVpredmeti["prvi_semester", "zavrnjenih.pct"])  # Delež študentov FDV, ki so sodelovanje v anketi PRED zavrnili (v prvem semestru)
metod_ZZ <- round(FDVpredmeti["prvi_semester", "neodzivnih.pct"])  # Delež študentov FDV, ki ki k anketi PRED niso pristopili (v prvem semestru)
metod_ZZ1 <- round(FDVpredmeti["prvi_semester", "sodelujocih.pct_po_izpitu"]) # -"- Anketa PO
metod_ZZ2 <- round(FDVpredmeti["prvi_semester", "zavrnjenih.pct_po_izpitu"])  # -"- Anketa PO
metod_ZZ3 <- round(FDVpredmeti["prvi_semester", "neodzivnih.pct_po_izpitu"])  # -"- Anketa PO

metod_XX1 <- round(FDVpredmeti["drugi_semester", "sodelujocih.pct"])
metod_XX2 <- round(FDVpredmeti["drugi_semester", "zavrnjenih.pct"])
metod_XX3 <- round(FDVpredmeti["drugi_semester", "neodzivnih.pct"])
metod_ZZ1L <- round(FDVpredmeti["drugi_semester", "sodelujocih.pct_po_izpitu"])
metod_ZZ2L <- round(FDVpredmeti["drugi_semester", "zavrnjenih.pct_po_izpitu"])
metod_ZZ3L <- round(FDVpredmeti["drugi_semester", "neodzivnih.pct_po_izpitu"])


# Če ni podatkov za drugi semester potem spremenljivkam pripiši vrednost 0 (da v tabelah v poglavju Splošna metodologija ne pojavljajo NA)
if (is.na(round(FDVpredmeti["drugi_semester", "ST_STUD"])) & is.na(round(FDVpredmeti["drugi_semester", "N_anket"]))) {
  metod_XX1 <- 0
  metod_XX2 <- 0
  metod_XX3 <- 0
  metod_ZZ1L <- 0
  metod_ZZ2L <- 0
  metod_ZZ3L <- 0
  
}

# Tekst v poglavju Metodološko pojasnilo
# da npr. v I. semestru vsak predmet izvaja 2.2 (:RRR:/:XXX:) pedagogov 266/123
method_IZR <- round(metod_RRR/metod_XXX, digits = 1)
#vsak pedagog pa v povprečju izvaja 2.5 (266/105) predmetov.
method_IZR1 <- round(metod_RRR/metod_YYY, digits = 1)
#Trenutni datum oz stanje izvoza, ki se izpiše pod tabelo v poglavju: Metodološko pojasnilo
date <- format(Sys.time(), "%d.%m.%Y")

# Številke, v poglavju SPLOŠNA METODOLOGIJA (glej npr.
# ne glede na stopnjo odgovorov je povprečno zadovoljstvo okoli 4.2)
# Najprej za Dodiplomski študij: 
# Povprečje komponent predmetov po študijskih programih (anketa PRED izpitom) sortirano po povprečju \\textbf{Skupaj}"
stopnja_program <- merge(povprecja.predmeti[c("predmet.sifra","STOPNJA")],povprecja.predmeti.programi[c("predmet.sifra",paste0(vars.predmet$cont$vars,"_mean"),
                                                       paste0(vars.predmet$krediti$vars,"_mean"),"program.studentov",
                                                       "program.studentov.ime","N_anket","N_anket_po_izpitu" )], by="predmet.sifra", sort=FALSE)
stopnja_program <- stopnja_program[stopnja_program$N_anket >=minEnot, c("predmet.sifra","program.studentov","program.studentov.ime","STOPNJA")]
if (nrow(stopnja_program) > 0) {
  stopnja_program <- aggregate(stopnja_program$predmet.sifra,
                               by=stopnja_program[c("program.studentov","program.studentov.ime","STOPNJA")],
                               function(x) length(unique(x)))
} else {stopnja_program <- stopnja_program}
stopnja_program.pred <- merge(test.pred, stopnja_program, 
                              by.x="student.program.ime",
                              by.y="program.studentov.ime", 
                              all=TRUE)
program.1stopnja <- aggregate(data.predmeti[vars.predmet.vars], 
                              by=data.predmeti[c("student.program.sifra","student.program.ime")],
                              FUN=mean, 
                              na.rm=TRUE)
program.1stopnja <- cbind(program.1stopnja, predmet.ocena.SKUPAJ=rowMeans(program.1stopnja[vars.predmet.vars], na.rm=TRUE))
stopnja_program1 <- stopnja_program
colnames(stopnja_program1)[4] <- "N_anket"
rownames(stopnja_program1) <- stopnja_program1[rownames(stopnja_program1),"student.program.ime"]
if (nrow(stopnja_program1) > 0) {
  program_BD_pred.skupaj <- merge(stopnja_program1, program.1stopnja, 
                                  by.x=c("program.studentov","program.studentov.ime"),
                                  by.y=c("student.program.sifra","student.program.ime"), all=TRUE, sort=FALSE)
  program_BD_pred.skupaj <- subset(program_BD_pred.skupaj, STOPNJA==1)
  program_BD_pred.skupaj <- program_BD_pred.skupaj[, !(colnames(program_BD_pred.skupaj) %in% c("STOPNJA"))]
} else {program_BD_pred.skupaj <- stopnja_program1}
# Izračunamo povprečje, ki je potem zapisano v poglavju SPLOŠNA METODOLOGIJA
if (nrow(program_BD_pred.skupaj) > 0) {
method_povp1 <- round(colMeans(program_BD_pred.skupaj[11:ncol(program_BD_pred.skupaj)], na.rm=TRUE), 1)
} else {method_povp1 <- 0}
# ŠE ZA Podiplomski študij: 
# Povprečje komponent predmetov po študijskih programih (anketa PRED izpitom) sortirano po povprečju \\textbf{Skupaj}"
stopnja_program_podipl <- merge(povprecja.predmeti[c("predmet.sifra","STOPNJA")], 
                                povprecja.predmeti.programi[c("predmet.sifra",
                                                              paste0(vars.predmet$cont$vars,"_mean"),
                                                              paste0(vars.predmet$krediti$vars,"_mean"),
                                                              "program.studentov","program.studentov.ime",
                                                              "N_anket","N_anket_po_izpitu" )], 
                                by="predmet.sifra",  sort=FALSE)
stopnja_program_podipl <- stopnja_program_podipl[stopnja_program_podipl$N_anket >=minEnot, 
                                               c("predmet.sifra","program.studentov","program.studentov.ime","STOPNJA")]
if (nrow(stopnja_program_podipl) > 0) {
  stopnja_program_podipl <- aggregate(stopnja_program_podipl$predmet.sifra, 
                                    by=stopnja_program_podipl[c("program.studentov","program.studentov.ime","STOPNJA")],
                                    function(x) length(unique(x)))
}
stopnja_program_podipl.pred <- merge(test.pred, stopnja_program_podipl, 
                                     by.x="student.program.ime",
                                     by.y="program.studentov.ime",  all=TRUE)
program.2stopnja <- aggregate(data.predmeti[vars.predmet.vars], 
                              by=data.predmeti[c("student.program.sifra","student.program.ime")],
                              FUN=mean, na.rm=TRUE)
program.2stopnja <- cbind(program.2stopnja, predmet.ocena.SKUPAJ=rowMeans(program.2stopnja[vars.predmet.vars], na.rm=TRUE))
stopnja_program_podipl1 <- stopnja_program_podipl
colnames(stopnja_program_podipl1)[4] <- "N_anket"
rownames(stopnja_program_podipl1) <- stopnja_program_podipl1[rownames(stopnja_program_podipl1),"student.program.ime"]
if (nrow(stopnja_program_podipl1) > 0) {
  program_BD_pred.podipl <- merge(stopnja_program_podipl1, program.2stopnja, 
                                  by.x=c("program.studentov","program.studentov.ime"),
                                  by.y=c("student.program.sifra","student.program.ime"), all=TRUE, sort=FALSE)
  program_BD_pred.podipl <- subset(program_BD_pred.podipl, STOPNJA==2)
  program_BD_pred.podipl <- program_BD_pred.podipl[, !(colnames(program_BD_pred.podipl) %in% c("STOPNJA"))]
} else{program_BD_pred.podipl <- stopnja_program_podipl1}
# Izračunamo povprečje, ki je potem zapisano v poglavju SPLOŠNA METODOLOGIJA
if (nrow(program_BD_pred.podipl) > 0) {
method_povp2 <- round(colMeans(program_BD_pred.podipl[11:ncol(program_BD_pred.podipl)],na.rm=TRUE), 1)
} else {method_povp2 <- 0}

#Podatki, ki generirajo vrednosti v latex datoteki metodolosko.pojasnilo. Glej mapo latexkosi
# S funkcijo scan preberemo tex. datoteko metodolosko.pojasnilo.tex
tex.okvir <- scan("Evalvacija/latexkosi/metodolosko.pojasnilo.tex", character(0), sep = "\n", quiet = TRUE, encoding = 'UTF-8')
tex.okvir <- gsub(pattern=":XXX:", replacement=metod_XXX, x=tex.okvir)
tex.okvir <- gsub(pattern=":YYY:", replacement=metod_YYY, x=tex.okvir)
tex.okvir <- gsub(pattern=":ZZZ:", replacement=metod_ZZZ, x=tex.okvir)
tex.okvir <- gsub(pattern=":UUU:", replacement=metod_UUU, x=tex.okvir)
tex.okvir <- gsub(pattern=":VVV:", replacement=metod_VVV, x=tex.okvir)
tex.okvir <- gsub(pattern=":RRR:", replacement=metod_RRR, x=tex.okvir)
tex.okvir <- gsub(pattern=":X1:", replacement=method_xsum, x=tex.okvir)
tex.okvir <- gsub(pattern=":UUU1:", replacement=metod_UUU1, x=tex.okvir)

tex.okvir <- gsub(pattern=":XXX1:", replacement=metod_XXX1, x=tex.okvir)
tex.okvir <- gsub(pattern=":YYY1:", replacement=metod_YYY1, x=tex.okvir)
tex.okvir <- gsub(pattern=":ZZZ1:", replacement=metod_ZZZ1, x=tex.okvir)

tex.okvir <- gsub(pattern=":XX:", replacement=metod_XX, x=tex.okvir)
tex.okvir <- gsub(pattern=":YY:", replacement=metod_YY, x=tex.okvir)
tex.okvir <- gsub(pattern=":ZZ:", replacement=metod_ZZ, x=tex.okvir)
tex.okvir <- gsub(pattern=":ZZ1:", replacement=metod_ZZ1, x=tex.okvir)
tex.okvir <- gsub(pattern=":ZZ2:", replacement=metod_ZZ2, x=tex.okvir)
tex.okvir <- gsub(pattern=":ZZ3:", replacement=metod_ZZ3, x=tex.okvir)

# DELEŽ študentov (PRVI SMESTER)
## ANKETA PRED
# no. students rejected all evaluations
tex.okvir <- gsub(pattern=":metod_X4.pct:", replacement=metod_X4.pct, x=tex.okvir)
# no. students with no started evaluations
tex.okvir <- gsub(pattern=":metod_X5.pct:", replacement=metod_X5.pct, x=tex.okvir)
# no. students participated in at least 1 evaluation
tex.okvir <- gsub(pattern=":metod_X6.pct:", replacement=metod_X6.pct, x=tex.okvir)
## ANKETA PO
# no. students rejected all evaluations
tex.okvir <- gsub(pattern=":metod_Y4.pct:", replacement=metod_Y4.pct, x=tex.okvir)
# no. students with no started evaluations
tex.okvir <- gsub(pattern=":metod_Y5.pct:", replacement=metod_Y5.pct, x=tex.okvir)
# no. students participated in at least 1 evaluation
tex.okvir <- gsub(pattern=":metod_Y6.pct:", replacement=metod_Y6.pct, x=tex.okvir)

# DRUGI SEMESTER ANKETA PRED IN PO IZPITU
tex.okvir <- gsub(pattern=":XX1:", replacement=metod_XX1, x=tex.okvir)
tex.okvir <- gsub(pattern=":XX2:", replacement=metod_XX2, x=tex.okvir)
tex.okvir <- gsub(pattern=":XX3:", replacement=metod_XX3, x=tex.okvir)
tex.okvir <- gsub(pattern=":ZZ1L:", replacement=metod_ZZ1L, x=tex.okvir)
tex.okvir <- gsub(pattern=":ZZ2L:", replacement=metod_ZZ2L, x=tex.okvir)
tex.okvir <- gsub(pattern=":ZZ3L:", replacement=metod_ZZ3L, x=tex.okvir)
tex.okvir <- gsub(pattern=":Y1:", replacement=method_xsum1, x=tex.okvir)

tex.okvir <- gsub(pattern=":IZR:", replacement=method_IZR, x=tex.okvir)
tex.okvir <- gsub(pattern=":IZR1:", replacement=method_IZR1, x=tex.okvir)
tex.okvir <- gsub(pattern=":IME:", replacement=fakulteta, x=tex.okvir)

# Datum izvoza podatkov (tabele v metodologiji)
tex.okvir <- gsub(pattern=":DATUM:", replacement=date, x=tex.okvir)


# DELEŽ študentov (DRUGI SMESTER)
## ANKETA PRED
# no. students rejected all evaluations
tex.okvir <- gsub(pattern=":metod_X41.pct:", replacement=metod_X41.pct, x=tex.okvir)
# no. students with no started evaluations
tex.okvir <- gsub(pattern=":metod_X51.pct:", replacement=metod_X51.pct, x=tex.okvir)
# no. students participated in at least 1 evaluation
tex.okvir <- gsub(pattern=":metod_X61.pct:", replacement=metod_X61.pct, x=tex.okvir)
## ANKETA PO
# no. students rejected all evaluations
tex.okvir <- gsub(pattern=":metod_Y41.pct:", replacement=metod_Y41.pct, x=tex.okvir)
# no. students with no started evaluations
tex.okvir <- gsub(pattern=":metod_Y51.pct:", replacement=metod_Y51.pct, x=tex.okvir)
# no. students participated in at least 1 evaluation
tex.okvir <- gsub(pattern=":metod_Y61.pct:", replacement=metod_Y61.pct, x=tex.okvir)


#Poglavje SPLOŠNA METODOLOGIJA
#Številka oz povprečji za dodiplomski in podpilomski študij za anketo PRED izpitom
tex.okvir <- gsub(pattern=":DODI:", replacement=method_povp1, x=tex.okvir)
tex.okvir <- gsub(pattern=":PODI:", replacement=method_povp2, x=tex.okvir)
# /statistics for methodology/ #



# Dodatno Pojasnilo za tabele: glej skripto koda-izvajalec_predmet.r
# Opomba za Uszreznost KT
KTust <- "{\\footnotesize \\textit{* Vrednost pod 3.0 pomeni, da je predmet glede 
na \\guillemotright število kreditnih točk\\guillemotleft \\ zahteval podpovprečno
število ur, vrednost nad 3.0 pa pomeni nadpovprečno število ur. 
{\\color{Orange}\\textbf{Oranžno}} so označena opazna
odstopanja ({\\color{Orange}\\textbf{2.4-2.6}}) in ({\\color{Orange}\\textbf{3.4-3.6}}),
{\\color{BrickRed}\\textbf{rdeče}} pa izrazita 
odstopanja (pod {\\color{BrickRed}\\textbf{2.4}}) in (nad {\\color{BrickRed}\\textbf{3.6}}).
\\newline ** Program je izbran na podlagi najvišjega števila odgovorov. Ocene ostalih programov, 
v katere so vpisani študenti, so v poglavju \\textbf{Sumarne ocene študijskih programov}.}}"

# Vprašanje komponente Kompetence
Kompetence.note <- "{\\footnotesize \\textit{* \\guillemotright Tekst vprašanja: V kolikšni meri 
ste pri predmetu pridobili pričakovane \\textbf{kompetence}? \\guillemotleft }}"

# Kvantilni rangi 
kvan.pojas <- "{\\footnotesize \\textit{* Vrednost za \\guillemotright št.odgovorov\\guillemotleft\\ je kvantilni rang 
za odgovarjajoče vrednosti, vendar ni obarvan, saj gre za administrativni podatek.}}"
kvan.pojas1 <- "{\\footnotesize \\textit{* Gre za vse predmete z vsaj 4 odgovori (tudi predmete drugih programov, 
če so bili izbirni), ki so jih vpisali študenti določenega programa. \\newline ** Vrednost za \\guillemotright št.odgovorov\\guillemotleft\\ 
je kvantilni rang za odgovarjajoče vrednosti v tabeli 1.1 (položaj predmeta med vsemi predmeti določenega programa), 
vendar ni obarvan, saj gre za administrativni podatek.}}"
kvan.pojas3 <- c(paste0("{\\footnotesize \\textit{* Vrednost za \\guillemotright št.odgovorov\\guillemotleft\\ je kvantilni rang 
                        za odgovarjajoče vrednosti v tabeli 1.3 (položaj IPP med vsemi IPP določenega programa v pogledu števila vpisanih študentov). 
                        \\newline ** Gre za vse predmete z vsaj 4 odgovori
                        (vključno s predmeti drugih programov, če so bili izbirni), ki so jih vpisali študenti določenega programa.
                        \\newline *** \\guillemotright št. IPP\\guillemotleft \\ - število vseh izvajalcev pri predmetih na določenem programu
                        (v povprečju ima vsak predmet ", method_IZR ," izvajalca).}}"))
# NOT USING THIS NOW
# Pojasnilo za izvajalca pri predmetu: študijski program
# pojasIZV.tmp <- c(paste0("{\\footnotesize \\textit{* Prikazani so samo programi, pri katerih je imel izvajalec vsaj 4 ocene. 
#                        \\newline ** \\guillemotright št. IPP\\guillemotleft \\ - število vseh izvajalcev pri predmetih na določenem programu
#                        (v povprečju ima vsak predmet ", method_IZR ," izvajalca).}}"))
# Pojasnilo za izvajalca
# pojasPRED.tmp <- c(paste0("{\\footnotesize \\textit{* Prikazani so samo programi, pri katerih je imel izvajalec vsaj 4 ocene.}}"))



######DODATNI PODATKI ZA TABELE ANALIZA IZVAJALCA PRI PREDMETU PO PROGRAMIH IN LETNIKIH: glej skripto koda-izvajalec_predmet.r
proggIZ.tmp <- povprecja.izvajalci.programi[povprecja.izvajalci.programi$N_anket >=minEnot, c("predmet.sifra","program.studentov","program.studentov.ime")]
if (nrow(proggIZ.tmp) > 0) {
  proggIZ.tmp <- aggregate(proggIZ.tmp$predmet.sifra, by = proggIZ.tmp[c("program.studentov","program.studentov.ime")], function(x) length(x))
  izv.predmet <- merge(test2, proggIZ.tmp, by.x="student.program.ime", by.y = "program.studentov.ime", all = TRUE)
} else {izv.predmet <- proggIZ.tmp}

######DODATNI PODATKI ZA TABELE ANALIZE PREDMETA PO PROGRAMIH IN LETNIKIH - ANKETA PRED
proggPRED.tmp <- povprecja.predmeti.programi[povprecja.predmeti.programi$N_anket >=minEnot, 
                                             c("predmet.sifra","program.studentov","program.studentov.ime")]
if (nrow(proggPRED.tmp) > 0) {
  proggPRED.tmp <- aggregate(proggPRED.tmp$predmet.sifra, by = proggPRED.tmp[c("program.studentov","program.studentov.ime")],
                             function(x) length(unique(x)))
  pred.predmet <- merge(test.pred, proggPRED.tmp, 
                        by.x = "student.program.ime", by.y = "program.studentov.ime", all = TRUE)
} else {pred.predmet <- proggPRED.tmp}
###// ANKETA PRED //###


######DODATNI PODATKI ZA TABELE ANALIZE PREDMETA PO PROGRAMIH IN LETNIKIH - ANKETA PO
test.po <- aggregate(data.predmeti.PO[vars.predmet$cont$po], by = data.predmeti.PO[c("student.program.ime")], FUN = mean, na.rm = TRUE)
test.po <- cbind(test.po, predmet.ocena.SKUPAJ = rowMeans(test.po[vars.predmet$cont$po[-1]], na.rm = TRUE))
test.po <- round_df(test.po, 1)
proggPO.tmp <- povprecja.predmeti.programi.PO[povprecja.predmeti.programi.PO$N_anket_po_izpitu >=minEnot, c("predmet.sifra","program.studentov","program.studentov.ime")]
if (nrow(proggPO.tmp)>0) {
  proggPO.tmp <- aggregate(proggPO.tmp$predmet.sifra, by=proggPO.tmp[c("program.studentov","program.studentov.ime")], function(x) length(unique(x)))
  proggPO.tmp1 <- proggPO.tmp
  colnames(proggPO.tmp1)[3] <- "N_anket"
  po.predmet <- merge(test.po, proggPO.tmp, by.x = "student.program.ime", by.y = "program.studentov.ime", all = TRUE)
} else {proggPO.tmp <- NULL
proggPO.tmp1 <- NULL
po.predmet <- NULL
}
## //ANKETA PO// ##

#FAKULTETA: PROGRAMI-ANKETA PRED IZPITOM
# Povprečja komponent predmetov ankete PRED izpitom po študijskih programih
progMeanPRED.tmp <- aggregate(data.predmeti[vars.predmet.vars], 
                              by = data.predmeti[c("student.program.sifra","student.program.ime")],
                              FUN = mean, na.rm = TRUE)
progMeanPRED.tmp <- cbind(progMeanPRED.tmp, predmet.ocena.SKUPAJ = rowMeans(progMeanPRED.tmp[vars.predmet.vars], na.rm = TRUE))
proggPRED.tmp1 <- proggPRED.tmp
colnames(proggPRED.tmp1)[3] <- "N_anket"
if (nrow(proggPRED.tmp1) > 0) {
  progMeanPRED.n <- merge(proggPRED.tmp1, progMeanPRED.tmp, 
                          by.x = c("program.studentov","program.studentov.ime"),
                          by.y = c("student.program.sifra","student.program.ime"), all = TRUE, sort = FALSE)
} else {progMeanPRED.n <- proggPRED.tmp1}

#Dodajanje povprečja programa k izvajalcu na konec
#Povprečja programov anketa pred izpitom 1 STOPNJAA
program_1stopnja <- proggPRED.tmp


########################################################
### analiza predmeta po smereh in letnikih študentov ###
#tabelaBy (ki jo uporabimo v koda-izvajalec_predmet.r)
#######################################################
# Anketa PRED
# Pojasnilo funkcije tabelaby1: glej skripto koda-izvajalec_predmet.r
# Ločimo komponente, na komponente, ki so v anketi PRED izpitom in anketi PO izpitu, saj ji bomo zapisali v ločeni tabeli
vars.predmet$cont$ime.kratko1 <- vars.predmet$cont$ime.kratko[-c(12,13,14,15,16,17,18,19,20)]
vars.predmet$cont$decimalke1 <- vars.predmet$cont$decimalke[-c(12,13,14,15,16,17,18,19,20)]
vars.predmet$cont$pobarvanka1 <- vars.predmet$cont$pobarvanka[-c(12,13,14,15,16,17,18,19,20)]

# Komponente PRED izpitom zapišemo v vektorje, ki bodo v Latex tabelah
komponente.predmeta.PRED <- vars.predmet$cont$vars1[-c(8,9,10,11)] # Komponente: Zadovoljstvo, Usklajenost, Samostojnost, ...itd
imena_stolpcevPRED <- as.character(vars.predmet$cont$ime.kratko1[-c(8,9,10,11)]) # Komponente, ki bodo kot imena stolpcev v tabeli tabelaBy1
decimalno_mestoPRED <- as.numeric(vars.predmet$cont$decimalke1[-c(8,9,10,11)]) # Decimalke: zakoroževanje povprečnih vrednosti komponent na 1 decimalno mesto
pobarvanka.PRED <- as.character(vars.predmet$cont$pobarvanka1[-c(8,9,10,11)]) # Pobarvanka: mejne vrednosti  "3,4,Inf,Inf", ki barvajo povprečja v tabelah


# Pojasnilo funkcije tabelaby2: glej skripto koda-izvajalec_predmet.r
# Anketa PO
komponente.predmeta.PO <- vars.predmet$cont$vars1[-c(1,2,3,4,5,6,7)] # Komponente za anketo PO izpitu: Kompetence, Vsebine, naloge, Kriteriji + Ustreznost kreditnih točk
imena_stolpcevPO <- as.character(vars.predmet$cont$ime.kratko1[-c(1,2,3,4,5,6,7)]) # Komponente bodo predstavljale imena stolpcev v tabelah
decimalno_mestoPO <- as.numeric(vars.predmet$cont$decimalke1[-c(1,2,3,4,5,6,7)])
pobarvanka.PO <- as.character(vars.predmet$cont$pobarvanka1[-c(1,2,3,4,5,6,7)])

# Iz stringa povlečemo le števila
# Pride v poštev v tabelah v povzetku, kjer so negativne vrednosti za delež nesodelujočih
#library(stringr)
#numextract <- function(string){ 
#  str_extract(string, "\\-*\\d+\\.*\\d*")
#} 

##############################################################
# KOMENTARJI PRI POVPREČJIH IZVAJALCEV HABILITACIJSKA KOMISIJA
# K povprečni ocenam izvajalcev dodamo še komentarje študentov
# Uporabimo le vpimeru, da delamo poročila za habilitacijsko komisijo
Habilitacijska <- FALSE
if (Habilitacijska == TRUE) {
  povprecja.izvajalci <- merge(povprecja.izvajalci, data.izvajalci[c("izvajalec.sifra","predmet.sifra","izvajalec.komentar.dobro","izvajalec.komentar.slabo")],
                                   by=c("izvajalec.sifra","predmet.sifra"), all = T, sort = F)
  # Ustvarimo csv datoteki, ki ju nato uporabimo za generiranje poročil TRENDOV in HABILITACIJSKE KOMISIJE
  write.csv2(povprecja.izvajalci,"povprecja.izvajalci.csv")
  write.csv2(povprecja.predmeti,"povprecja.predmeti.csv")
}
#############################################################
povprecja.predmeti <- merge(povprecja.predmeti, poNLurkerji, by = "predmet.sifra", all = TRUE, sort = FALSE)

# povprecja.izvajalci <- subset(povprecja.izvajalci, !is.na(ST_STUD))
# 
# povprecja.predmeti <- subset(povprecja.predmeti, !is.na(ST_STUD))