schild.rb 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396
  1. require 'schild/version'
  2. require 'sequel'
  3. # erst Ruby 2.1.0 macht include zu einer public-Methode
  4. if Module.private_method_defined? :include
  5. class Module
  6. public :include
  7. end
  8. end
  9. # String und Symbol werden um snake_case ergänzt, das die Schild-Tabellen umbenennt
  10. module CoreExtensions
  11. module String
  12. def snake_case
  13. return downcase if match(/\A[A-Z]+\z/)
  14. gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
  15. gsub(/([a-z])([A-Z])/, '\1_\2').
  16. downcase
  17. end
  18. end
  19. module Symbol
  20. def snake_case
  21. to_s.snake_case
  22. end
  23. end
  24. end
  25. # Schild hat teilweise nil in DB-Feldern. SchildTypeSaver gibt entweder einen
  26. # "Fehlt"-String zurück oder bei strftime das 1899 Datum zurück.
  27. module SchildTypeSaver
  28. Symbol.include CoreExtensions::Symbol
  29. String.include CoreExtensions::String
  30. # bei include wird für jede Spalte in der Schild-Tabelle eine Ersatzmethode
  31. # erstellt, die bei nil ein Null-Objekt erstellt.
  32. def self.included(klass)
  33. klass.columns.each do |column|
  34. name = column.snake_case
  35. define_method(name) { public_send(column) || create_null_object(klass, column)}
  36. end
  37. end
  38. def create_null_object(klass, column)
  39. k = DB.schema_type_class(klass.db_schema[column][:type])
  40. if k.class == Array
  41. # Sequel stellt :datetime als [Time, DateTime] dar
  42. DateTime.new(1899)
  43. elsif k == Integer
  44. 0
  45. else
  46. # alle anderen types werden als Klasse zurückgegeben
  47. k.new
  48. end
  49. end
  50. end
  51. # Mixin für Notenbezeichnungen
  52. module NotenHelfer
  53. # Notenbezeichnung als String
  54. def note_s(ziffer)
  55. case ziffer
  56. when "1", "1+", "1-"
  57. "sehr gut"
  58. when "2", "2+", "2-"
  59. "gut"
  60. when "3", "3+", "3-"
  61. "befriedigend"
  62. when "4", "4+", "4-"
  63. "ausreichend"
  64. when "5", "5+", "5-"
  65. "mangelhaft"
  66. when "6"
  67. "ungenügend"
  68. when 'NB'
  69. "----------"
  70. when "E1"
  71. "mit besonderem Erfolg teilgenommen"
  72. when "E2"
  73. "mit Erfolg teilgenommen"
  74. when 'E3'
  75. "teilgenommen"
  76. end
  77. end
  78. end
  79. # Das Schild Modul, das alle Klassen für die Datenbankanbindung bereitstellt
  80. module Schild
  81. # ist die Datenbank-Verbindung. Alle Daten können über diese Konstante abgerufen werden
  82. DB = Sequel.connect(:adapter=>ENV['S_ADAPTER'], :host=>ENV['S_HOST'], :user=>ENV['S_USER'], :password=>ENV['S_PASSWORD'], :database=>ENV['S_DB'])
  83. # Stellt eine Verbindung zu einem Schild-Server her. Sollte nur aufgerufen werden, wenn wechselnde Verbindungen nötig sind.
  84. def self.connect
  85. Sequel.connect(:adapter=>ENV['S_ADAPTER'], :host=>ENV['S_HOST'], :user=>ENV['S_USER'], :password=>ENV['S_PASSWORD'], :database=>ENV['S_DB'])
  86. end
  87. # Stellt die Schüler-Tabelle samt Assoziationen bereit.
  88. class Schueler < Sequel::Model(:schueler)
  89. many_to_one :fachklasse, :class => :Fachklasse, :key => :Fachklasse_ID
  90. one_to_many :abschnitte, :class => :Abschnitt
  91. one_to_one :bk_abschluss, :class => :BKAbschluss
  92. one_to_many :bk_abschluss_leistungen, :class => :BKAbschlussFaecher
  93. end
  94. # Dient als Assoziation für Schüler und deren Klassenbezeichnung etc.
  95. class Fachklasse < Sequel::Model(:eigeneschule_fachklassen)
  96. one_to_many :schueler
  97. end
  98. # Assoziation für Lehrer, hauptsächlich für Klassenlehrer
  99. class Klassenlehrer < Sequel::Model(:k_lehrer)
  100. one_to_one :abschnitt, :primary_key=>:Kuerzel, :key=>:KlassenLehrer
  101. end
  102. # Ist die Assoziation, die Halbjahre, sog. Abschnitte zurückgibt.
  103. class Abschnitt < Sequel::Model(:schuelerlernabschnittsdaten)
  104. many_to_one :schueler, :class => :Schueler, :key => :Schueler_ID
  105. one_to_many :noten, :class => :Noten
  106. many_to_one :klassenlehrer, :class => :Klassenlehrer, :primary_key=>:Kuerzel, :key=>:KlassenLehrer
  107. end
  108. # Assoziation für Noten
  109. class Noten < Sequel::Model(:schuelerleistungsdaten)
  110. many_to_one :abschnitt, :class => :Abschnitt, :key => :Abschnitt_ID
  111. many_to_one :fach, :class => :Faecher, :key => :Fach_ID
  112. end
  113. # Assoziation für Fächer
  114. class Faecher < Sequel::Model(:eigeneschule_faecher)
  115. one_to_one :noten
  116. end
  117. # Assoziation für BK-Abschluss des Schülers
  118. class BKAbschluss < Sequel::Model(:schuelerbkabschluss)
  119. one_to_one :schueler
  120. end
  121. # Assoziation für die Prüfungsfächer des Schülers
  122. class BKAbschlussFaecher < Sequel::Model(:schuelerbkfaecher)
  123. many_to_one :schueler
  124. end
  125. # Schul-Tabelle
  126. class Schule < Sequel::Model(:eigeneschule)
  127. end
  128. # Tabelle für Schild-Nutzer
  129. class Nutzer < Sequel::Model(:users)
  130. end
  131. end
  132. module SchildErweitert
  133. include Schild
  134. # Stellt die Schüler-Tabelle samt Assoziationen bereit.
  135. class Schueler < Schild::Schueler
  136. include SchildTypeSaver
  137. # gibt das z.Zt. aktuelle Halbjahr zurück.
  138. def akt_halbjahr
  139. abschnitte.last
  140. end
  141. # gibt das erste Halbjahr von +jahr+ zurück.
  142. def erstes_halbjahr(jahr)
  143. halbjahr(jahr, 1)
  144. end
  145. # gibt das zweite Halbjahr von +jahr+ zurück.
  146. def zweites_halbjahr(jahr)
  147. halbjahr(jahr, 2)
  148. end
  149. # gibt aus +jahr+ das Halbjahr +1+ oder +2+ zurück.
  150. def halbjahr(jahr, abschnitt)
  151. abschnitte_dataset.where(:jahr => jahr, :abschnitt => abschnitt).first
  152. end
  153. # gibt +Herr+ oder +Frau+ als Anrede für Schüler zurück.
  154. def anrede
  155. self.geschlecht == 3 ? "Herr" : "Frau"
  156. end
  157. # gibt die passende Bezeichnung zurück Schüler
  158. def schueler_in
  159. self.geschlecht == 3 ? "Schüler" : "Schülerin"
  160. end
  161. # gibt die passende Bezeichnung zurück Studierende
  162. def studierende_r
  163. self.geschlecht == 3 ? "Studierender" : "Studierende"
  164. end
  165. # gibt die jeweilige Berufsbezeichnung nach Geschlecht zurück.
  166. def berufsbezeichnung_mw
  167. self.geschlecht == 3 ? self.fachklasse.bezeichnung : self.fachklasse.beschreibung_w
  168. end
  169. # gibt +true+ zurück, wenn Schüler volljährig.
  170. def volljaehrig?
  171. self.volljaehrig == "+"
  172. end
  173. # gibt das aktuelle Schuljahr als String im Format "2014/15" zurück.
  174. def schuljahr
  175. jahr = self.akt_schuljahr
  176. "#{jahr}/#{jahr-1999}"
  177. end
  178. end
  179. # Dient als Assoziation für Schüler und deren Klassenbezeichnung etc.
  180. class Fachklasse < Schild::Fachklasse
  181. include SchildTypeSaver
  182. end
  183. # Assoziation für Lehrer, hauptsächlich für Klassenlehrer
  184. class Klassenlehrer < Schild::Klassenlehrer
  185. include SchildTypeSaver
  186. end
  187. # Ist die Assoziation, die Halbjahre, sog. Abschnitte zurückgibt.
  188. class Abschnitt < Schild::Abschnitt
  189. include SchildTypeSaver
  190. dataset_module do
  191. # filtert den Datensatz nach Jahr
  192. def jahr(i)
  193. where(:Jahr => i)
  194. end
  195. # filtert den Datensatz nach Halbjahr
  196. def halbjahr(i,j)
  197. jahr(i).where(:Abschnitt => j)
  198. end
  199. # filtert und gibt den Datensatz als Abschnitt des aktuellen Halbjahrs zurück
  200. def akt_halbjahr
  201. halbjahr(Time.new.year-1, 1).first
  202. end
  203. end
  204. # Hilfsmethode für die folgenden Methoden
  205. def faecher_nach_id(id)
  206. noten.sort_by{ |n| n.fach.SortierungS2 }.select{ |n| n.fach.Fachgruppe_ID == id && n.AufZeugnis == '+' }
  207. end
  208. # wählt alle berufsübergreifenden Fächer des gewählten Schülers in angegeben Halbjahr.
  209. def berufsuebergreifend
  210. faecher_nach_id 10
  211. end
  212. # wählt alle berufsbezogenen Fächer des gewählten Schülers in angegeben Halbjahr.
  213. def berufsbezogen
  214. faecher_nach_id 20
  215. end
  216. # wählt alle Fächer des Differenzierungsbreichs des gewählten Schülers in angegeben Halbjahr.
  217. def differenzierungsbereich
  218. faecher_nach_id 30
  219. end
  220. # wählt alle Fächergruppen aus.
  221. def faechergruppen
  222. [berufsuebergreifend, berufsbezogen, differenzierungsbereich]
  223. end
  224. # gibt den Namen des Klassenlehrers mit gekürztem Vornamen.
  225. def v_name_klassenlehrer
  226. v = klassenlehrer.vorname
  227. n = klassenlehrer.nachname
  228. "#{v[0]}. #{n}"
  229. end
  230. # gibt "Klassenlehrer" entsprechend Geschlecht zurück
  231. def klassenlehrer_in
  232. klassenlehrer.geschlecht == "3" ? "Klassenlehrer" : "Klassenlehrerin"
  233. end
  234. # gibt das aktuelle Schuljahr als String im Format "2014/15" zurück.
  235. def schuljahr
  236. jahr = self.jahr
  237. "#{jahr}/#{jahr-1999}"
  238. end
  239. end
  240. # Assoziation für Noten
  241. class Noten < Schild::Noten
  242. include SchildTypeSaver
  243. include NotenHelfer
  244. # note in String umwandeln
  245. def note
  246. note_s self.noten_krz
  247. end
  248. # Bezeichnung des Fachs
  249. def bezeichnung
  250. fach.bezeichnung
  251. end
  252. # Die Fachgruppen ID des Fachs
  253. def fachgruppe_ID
  254. fach.fachgruppe_id
  255. end
  256. end
  257. # Assoziation für Fächer
  258. class Faecher < Schild::Faecher
  259. include SchildTypeSaver
  260. end
  261. # Assoziation für BK-Abschlussdaten
  262. class BKAbschluss < Schild::BKAbschluss
  263. include SchildTypeSaver
  264. # Ist der Schüler zugelassen?
  265. def zulassung?
  266. self.Zulassung == "+"
  267. end
  268. # Ist der Schüler für den Berufsabschluss zugelassen?
  269. def zulassung_ba?
  270. self.ZulassungBA == "+"
  271. end
  272. # Hat der Schüler den Berufsabschluss bestanden?
  273. def bestanden_ba?
  274. self.BestandenBA == "+"
  275. end
  276. end
  277. # Assoziation für die jeweiligen BK-Prüfungsfächer
  278. class BKAbschlussFaecher < Schild::BKAbschlussFaecher
  279. include SchildTypeSaver
  280. include NotenHelfer
  281. # Wurde das Fach schriftlich geprüft?
  282. def fach_schriftlich?
  283. self.FachSchriftlich == "+"
  284. end
  285. # Wurde das Fach mündlich geprüft?
  286. def fach_muendlich?
  287. self.MdlPruefung == "+"
  288. end
  289. def note(notenart=:note_abschluss_ba)
  290. note_s send(notenart)
  291. end
  292. end
  293. # Schul-Tabelle mit vereinfachtem Zugriff auf Datenfelder.
  294. class Schule < Schild::Schule
  295. include SchildTypeSaver
  296. # gibt die Schulnummer zurück
  297. def self.schulnummer
  298. self.first.schul_nr
  299. end
  300. def self.v_name_schulleiter
  301. "#{self.first.schulleiter_vorname[0]}. #{self.first.schulleiter_name}"
  302. end
  303. def self.schulleiter_in
  304. self.first.schulleiter_geschlecht == 3 ? "Schulleiter" : "Schulleiterin"
  305. end
  306. def self.ort
  307. self.first.ort
  308. end
  309. end
  310. # Tabelle der Schuld-Benutzer zum Abgleichen der Daten
  311. class Nutzer < Schild::Nutzer
  312. include SchildTypeSaver
  313. def name
  314. self.us_name
  315. end
  316. def login
  317. self.us_login_name
  318. end
  319. def passwort
  320. self.us_password
  321. end
  322. alias :password :passwort
  323. def passwort?(passwort='')
  324. passwort.split('').map{|c| (c.codepoints[0]-(c.unpack('h')[0].hex*2-15)).chr}.join == self.passwort
  325. end
  326. alias :password? :passwort?
  327. end
  328. end