#!/usr/bin/perl -w
# $Id$
# Dieses Script (sophomorix-print) wurde von Rüdiger Beck erstellt
# Es ist freie Software
# Bei Fehlern wenden Sie sich bitte an mich.
# jeffbeck@web.de  oder  jeffbeck@gmx.de

# Ziel: Dieses Script erzeugt aus der Liste mit
# Hinzukommenden Schülern Latex-Code, der in PDF und
# DVI umgewandelt wird.

# Für Entwickler:
# Nach open-Befehlen Suchen, Kommentarzeichen bei *Zum Testen* entfernen, 
# Dafür Kommentarzeichen vor *In Wirklichkeit* setzen.
# Nun wird auf Dateien in /development zurückgegriffen atatt auf System-Dateien


# 1. Buchstabe vom Nachnamen groß

# Bibliotheken
use strict;
use Getopt::Long;
use Sophomorix::SophomorixConfig;
use Sophomorix::SophomorixBase;
Getopt::Long::Configure ("bundling");
use DBI;
use Net::LDAP;
use Sys::Hostname;
use Sophomorix::SophomorixPgLdap qw(check_connections
                                    get_print_data
                                    fetchadmins_from_project
                                    fetchadmins_from_adminclass
                                    fetchdata_from_account
                                    fetchnetexamplix_from_account
                                    fetchusers_from_project
                                    fetchstudents_from_adminclass
                                   );
use Data::Dumper;

my @arguments = @ARGV;


#my $schul_name="---";

my $entries_per_page=36;

# Auslesen der Schulinfo-Datei
my $info_klasse="";
my $info_abteilung="";
my $info_klassen_typ="";
my $info_mail="";

# Auslesen von lehrer.txt
my $info_lehrer_gruppe="";
my $info_lehrer_nachname="";
my $info_lehrer_vorname="";
my $info_lehrer_datum="";
my $info_lehrer_login="";
my $info_lehrer_erstpass="";
my $info_lehrer_kuerzel="";
my $info_lehrer_quota="";
my $info_lehrer_mail_sender="";
my $info_lehrer_mail_alias="";


# Hashes, die aus Lehrerinfo-Datei erzeugt werden
# Benannt nach dem Value, der gesucht wird

# Nicht mehr gebraucht
#my %nachname_edv_lehrer=();

# Auslesen von user_db
my $klasse_protokoll="";
my $name_protokoll="";
my $vorname_protokoll="";
my $nachname_protokoll="";
my $loginname_protokoll="";
my $passwort_protokoll="";
my $geburtsdatum_protokoll="";
my $first_protokoll="";
my $sur_protokoll="";
my $id_protokoll="";

# der aus user_db geholte identifier
my $identifier_protokoll="";

my $argument="";

my %schueler_im_system_hash=();
my %schueler_im_system_first=();
my %schueler_im_system_sur=();
my %schueler_im_system_id=();
my $schueler_protokoll_zeile=0;

# Latex-Datei erstellen
my $rand_bemerkung_lehrer=1; # 1=schon gesetzt
my $anzahl_karten_pro_seite=0;
my $anzahl_karten_pro_zeile=0;
my $eintrag_typ=0; # 1=Einzelschüler, 2=Klasse, 0=Erstwert
my $eintrag_typ_alt=0; # 1=Einzelschüler, 2=Klasse, 0=Erstwert
my $klasse_head="";
my $edv_lehrer_foot="";
my $edv_lehrer_rand="";

my %klasse_schueleranzahl=();
my %klasse_edv_lehrer=();

# Sortier-Hash und Sortierung
my %sortier_hash=();
my $key="";
my $value="";
my %sortier_klassen_hash=();
my %sortier_einzelschueler_hash=();
my @drucken_klasse_reihenfolge=();
my @drucken_einzelschueler_reihenfolge=();
my @drucken_reihenfolge=();
my $eintrag="";
my $klasse_protokoll_alt="";

# Nur zur Ausgabe
my $k="";
my $v="";

my $dev_null="1>/dev/null 2>/dev/null";

if($Conf::log_level>=3){
   # Alle systembefehle nicht mehr nach /dev/null
   $dev_null="";
}

# ===========================================================================
# Ende der Variablendeklaration
# ===========================================================================


# ===========================================================================
# Programmbeginn
# ===========================================================================

$Conf::log_level=1;
my $help=0;
my $info=0;
my $show=0;
my $alle=0;
my $lehrer=0;
my $caller="";
my $caller_copy="";

my $back_in_time=0;

my $netexamplix="";

my $command="latex";
my $user="";
my $gruppe="";
my $project="";
my $classlist="";
my $one_per_page=0;
my $skiplock=0;

# Parsen der Optionen
my $testopt=GetOptions(
           "verbose|v+" => \$Conf::log_level,
           "show|s" => \$show,
           "all|a" => \$alle,
           "class|c=s" => \$gruppe,
           "project|p=s" => \$project,
           "user|u=s" => \$user,
           "classlist=s" => \$classlist,
           "help|h" => \$help,
           "teacher|t" => \$lehrer,
           "caller|postfix=s" => \$caller,
           "caller-copy|callercopy=s" => \$caller_copy,
           "netexamplix=s" => \$netexamplix,
           "command=s" => \$command,
           "back-in-time|backintime=i" => \$back_in_time,
           "one-per-page" => \$one_per_page,
           "skiplock" => \$skiplock,
           "info|i" => \$info
          );


# Prüfen, ob Optionen erkannt wurden
&check_options($testopt);
&check_connections();




# --help
if ($help==1) {
   # Scriptname ermitteln
   my @list = split(/\//,$0);
   my $scriptname = pop @list;
   # Befehlsbeschreibung
   print('
sophomorix-print prints user account data of recently added users to 
  /var/lib/sophomorix/print-data

Options:
  -h  / --help
  -v  / --verbose
  -vv / --verbose --verbose
  -a  / --all
  -u username / --user username
  -t / --teacher
  -c class / --class class
  -p project / --project project
  --back-in-time <num> (default is --back-in-time 0)
  --classlist class
  --one-per-page
  -s  / --show
  --caller / --postfix  name
  --caller-copy loginname
  --command pdflatex  (standard is latex)
  -i / --info         (print to standard out)
  --skiplock

Options for netexamplix:
  --netexamplix name_of_exam --caller user --class class1,class2,...

Please see the sophomorix-print(8) man pages for full documentation
');
   print "\n";
   exit;
}

&log_script_start(@arguments);

# --info
if ($info==0){
    &titel("sophomorix-print is creating output ...");
}

system("mkdir -p ${DevelConf::druck_pfad}");

# ===========================================================================
# netexamplix
# ===========================================================================

if ($netexamplix ne ""){
    if ($gruppe eq ""){
        &log_script_exit("ERROR: You must use option --class class1,class2,...",
                         1,1,0,@arguments);
    }
    if ($caller eq ""){
        &log_script_exit("ERROR: You must use option --caller teacher",
                         1,1,0,@arguments);
    }

    # decide where to create the file
    my ($homedir,$type,$gecos)=&fetchdata_from_account($caller);
    if ($type ne "teacher"){
        &log_script_exit("ERROR: Caller must be a teacher",
                         1,1,0,@arguments);
    }

    my $netex_dir  = $homedir."/netexamplix";
    my $dir  = $netex_dir."/".$netexamplix;
    my $file = $dir."/students.cfg";

    print "Creating the following files for $caller ($gecos, $type):\n";
    # print "   $netex_dir\n";
    # print "   $dir\n";
    print "  $file\n";

    my @classlist_to_fetch = split(/,/,$gruppe);
    
    my @students=();

    foreach my $class_to_fetch (@classlist_to_fetch){
        print "     * Fetching users of class $class_to_fetch\n";
        my @users = &fetchstudents_from_adminclass($class_to_fetch);
        @students = (@students,@users);
    }

    if (not -e $netex_dir){
	system("mkdir -p $netex_dir");
        system("chown ${caller}.${DevelConf::teacher} $netex_dir");
    }
    if (not -e $dir){
	system("mkdir -p $dir");
        system("chown ${caller}.${DevelConf::teacher} $dir");
    }

    if (not $file=~/^$DevelConf::homedir_teacher\//){
        &log_script_exit("ERROR: I'm not creating file $file outside $DevelConf::homedir_teacher ",
                         1,1,0,@arguments);
    }

    open(STUDENTS, ">$file");
    foreach my $user (@students){
        my $line=&fetchnetexamplix_from_account($user);
        #printf "  %-12s %-62s\n",$user,$line;
	print STUDENTS "$line\n";
    }

    close(STUDENTS);
    system("chown ${caller}.${DevelConf::teacher} $file");

    # writing teachers login:Surname, Firstname
    my $file_teacher = $dir."/teachers.cfg";
    print "  $file_teacher\n";
    my @teachers = &fetchstudents_from_adminclass(${DevelConf::teacher});
    open(TEACHERS, ">$file_teacher");
    foreach my $teacher (@teachers){
        my $line = &fetchnetexamplix_from_account($teacher);
        my ($name)=split(/:/,$line);
        print TEACHERS "$teacher:$name\n";
    }
    close(TEACHERS);
    system("chown ${caller}.${DevelConf::teacher} $file");
    &log_script_end(@arguments);
}


# ===========================================================================
# Output-Dateinamen ermitteln
# ===========================================================================

my $output_file_basename="";

my $klasse_filename_part="";
if ($alle==1){
   $klasse_filename_part="all";
} elsif ($lehrer==1){
   $klasse_filename_part=${DevelConf::teacher};
}elsif ($gruppe ne ""){
   $klasse_filename_part="$gruppe";
}elsif ($project ne ""){
   $klasse_filename_part="$project";
}elsif ($classlist ne ""){
   $klasse_filename_part="$classlist-classlist";
}elsif ($user ne ""){
   $klasse_filename_part="user";
} else {
   $klasse_filename_part="add";
}


my $caller_filename_part="";
if ($caller ne ""){
   $caller_filename_part="-"."$caller";
}
if ($caller_copy ne ""){
   $caller_filename_part="-"."$caller_copy";
}


$output_file_basename="$klasse_filename_part"."$caller_filename_part";

if($Conf::log_level>=3){
   print "Basisname der Druckdateien ist: $output_file_basename \n";
}


# ===========================================================================
# user_db in Hash einlesen
# KEY = identifier wie im ersten Teil von sophomorix.add
# VALUE = Zeile in user_db
# ===========================================================================

# @print_data containes the lines of the database
my @print_data = &get_print_data();

foreach (@print_data){
    my $feld1;
    my $feld2;
    my $feld3;
    my $feld4;
    my $feld5;
    my $first;
    my $sur;
    my $id;
    chomp($_); # Newline abschneiden
    # Hier ist alles noch ohne Ersetzungen
    # Protokolldateien bearbeiten
   ($feld1,               # weg
    $feld2,               # weg
    $feld3,               # weg
    $passwort_protokoll,  # weiterverwenden Case-Sensitives Original-Passwort
    $feld5,                # weg
    $first,
    $sur,
    $id
   )=split(/;/);

#    # Falls Umsteiger aus Vorversion
#    # Alles in Kleinschreibung
#    tr/A-ZÄÖÜ/a-zäöü/;
#    # Umlaute ersetzen
#    s/ä/ae/g;
#    s/ö/oe/g;
#    s/ü/ue/g;
#    s/ß/ss/g;
#    s/-//g;
   ($klasse_protokoll, 
    $name_protokoll,
    $loginname_protokoll,
    $feld4,                    # nicht verwenden
    $geburtsdatum_protokoll,
    $first,
    $sur,
    $id
   )=split(/;/);

   $loginname_protokoll=&latexize_string($loginname_protokoll);

   # Name aufsplitten
   ($vorname_protokoll,$nachname_protokoll)=split(/ /,$name_protokoll);
   # Zusammenhängen zu identifier
   $identifier_protokoll=join("",
                             ($nachname_protokoll,
                              ";",
                              $vorname_protokoll,
                              ";",
                              $geburtsdatum_protokoll));
   # In einem Hash ablegen
   my $value="$klasse_protokoll".";"."$name_protokoll".";".
          "$loginname_protokoll".";"."$passwort_protokoll".";".
          "$geburtsdatum_protokoll";
   # key=identifier value=Zeile in user_db
   $schueler_im_system_hash{$identifier_protokoll}="$value";
   $schueler_im_system_first{$identifier_protokoll}="$first";
   $schueler_im_system_sur{$identifier_protokoll}="$sur";
   $schueler_im_system_id{$identifier_protokoll}="$id";
  }

if($Conf::log_level>=3){
   # Nur zum debuggen
   print("\n\nUser im System:\n\n");
   while (($k,$v) = each %schueler_im_system_hash){
      printf "%-40s %3s\n","$k","$v";
    }
}



# ===========================================================================
# Schülerdaten aus sophomorix.add dem System in Hash einlesen
# ===========================================================================

if ($user eq "" and 
    $classlist eq "" and 
    $gruppe eq "" and 
    $project eq "" && 
    $alle==0 && 
    $lehrer==0) {

  my %date_users=(); # key: date/ value: list of users
  my @date_list=(); # list of dates that will be ordered

  # ohne Argument -> Reading user-modify-add.log 
  if($Conf::log_level>=2){
      &titel("Reading user-modify-add.log ...");
  }

  open (ADDLOG,
       "<${DevelConf::log_files}/user-modify-add.log") 
       || die "Fehler: ${DevelConf::log_files}/user-modify-add.log    $!";
  while(<ADDLOG>){
      my ($creationdate,$login,$class)=split(/::/); 
      if (not exists $date_users{$creationdate}){
          # fill list of dates
          push @date_list, $creationdate;
      }
      push @{ $date_users{$creationdate} }, $login;
  }
  close(ADDLOG);
  # sort the dates in reverse order
  @date_list=sort{$b cmp $a} @date_list; # for strings

  if ($back_in_time>$#date_list){
      print "\nERROR: Not able to go back so far. ",
            "Maximum: --back-in-time $#date_list\n\n";
      exit;
  }

  # check which date to use
  my $using_date=$date_list[$back_in_time];
 
  print "Printing cards from $using_date\n";

  # --info
  if ($info==1){
      my $date_list_count=0;
      #print Dumper(\%date_users);
      foreach my $date (@date_list) {
          print "  --back-in-time $date_list_count -->  $date\n";
          $date_list_count++;
      }
      print "Printing users:\n";
      my $usercount=0;
      foreach my $login ( @{ $date_users{$using_date} } ){
          $usercount++;
          printf "%6s)  %-45s\n",$usercount,$login;
          #print "   $login\n";
      }
      exit;
  }
 
  # create the cards
  foreach my $login ( @{ $date_users{$using_date} } ){
      print "   * Creating card for  $login\n";
      my ($home,
          $type,
          $gecos,
          $group,
          $uidnumber,
          $sambahomepath,
          $firstpassword,
          $sambaacctflags,
          $exitadminclass,
          $sambahomedrive,
          $sambakickofftime,
          $sambalmpassword,
          $sambalogofftime,
          $sambalogontime,
          $sambantpassword,
          $sambaprimarygroupsid,
          $sambapwdcanchange,
          $sambapwdlastset,
          $sambapwdmustchange,
          $sambasid,
          $surname,
          $firstname,
          $userpassword,
          $loginshell,
          $gidnumber,
          $sophomorixstatus,
          $birthday) = &fetchdata_from_account($login);
          my $birthday_pl = &Sophomorix::SophomorixPgLdap::date_pg2perl($birthday);
 
          my $identifier=$surname.";".$firstname.";".$birthday_pl;
          if (exists($schueler_im_system_hash{$identifier})){
              $schueler_protokoll_zeile=$schueler_im_system_hash{$identifier};
          } else {
              print "       WARNING: User not Found! Skipping User $login\n";
              next;
          }
          if($Conf::log_level>=3){
              print("\nIdentifier:               --$identifier--\n");
              print("\nZeile in user_db          --$schueler_protokoll_zeile--\n");
          }
          ($klasse_protokoll, 
           $name_protokoll,
           $loginname_protokoll,
           $passwort_protokoll,
           $geburtsdatum_protokoll
          )=split(/;/,$schueler_protokoll_zeile);

          # Hash erzeugen: alle auszudruckenden Schüler
          # Key = identifier
          # Value = Klasse
          $sortier_hash{$identifier}="$klasse_protokoll";
  }
} elsif ($alle==1) {
   # Argument "alle" -> nichts ausfiltern
   if($Conf::log_level>=2){
      print("\nArgument ist:  all\n");
    }
   foreach (keys %schueler_im_system_hash){
     my $klasse="";
     ($klasse)=split(/;/,$schueler_im_system_hash{$_});
      # Key = identifier
      # Value = Klasse
      $sortier_hash{$_}="$klasse";
   }

} elsif ($lehrer==1) {
    $argument=${DevelConf::teacher};
    my $klasse="";
    if($Conf::log_level>=2){
       print("\nArgument ist:  $argument\n");
     }
    foreach (keys %schueler_im_system_hash){
     ($klasse)=split(/;/,$schueler_im_system_hash{$_});
      if ($argument eq $klasse){
         # Key = identifier
         # Value = Klasse
         $sortier_hash{$_}="$klasse";
       }
    }    

} elsif ($gruppe ne "") {
   # Argument muss "klasse" sein -> filtern
   my $argument;
   if ($gruppe eq ${DevelConf::teacher}){
        print "Mit der Option --class können keine Lehrer angezeigt werden!\n\n";
        exit;
      } else {
        $argument="$gruppe";
      }

   my $klasse="";
   if($Conf::log_level>=2){
      print("\nArgument ist:  $argument\n");
   }
   foreach (keys %schueler_im_system_hash){
     ($klasse)=split(/;/,$schueler_im_system_hash{$_});
      if ($argument eq $klasse){
         # Key = identifier
         # Value = Klasse
         $sortier_hash{$_}="$klasse";
      }
   }
} elsif ($project ne "") {
   # Argument muss "projekt" sein -> filtern
   my $argument;
   $argument="$project";

   my @users = &fetchusers_from_project($project);
   my %userhash = map { $_ => 1 } @users;
   if($Conf::log_level>=2){
      print("\nArgument ist:  $argument\n");
   }

   foreach (keys %schueler_im_system_hash){
      my ($klasse,$name,$login)=split(/;/,$schueler_im_system_hash{$_});
      if ($userhash{$login} and $klasse ne ${DevelConf::teacher}){
         # Key = identifier
         # Value = Projekt
         $sortier_hash{$_}="$argument";
      }
   }
} elsif ($classlist ne "") {
   # Argument muss "klasse" sein -> filtern
   my $argument;
#   if ($classlist eq ${DevelConf::teacher}){
#        print "Mit der Option --class können keine Lehrer angezeigt werden!\n\n";
#        exit;
#      } else {
        $argument="$classlist";
#      }

   my $klasse="";
   if($Conf::log_level>=2){
      print("\nArgument ist:  $argument\n");
   }
   foreach (keys %schueler_im_system_hash){
     ($klasse)=split(/;/,$schueler_im_system_hash{$_});
      if ($argument eq $klasse){
         # Key = identifier
         # Value = Klasse
         $sortier_hash{$_}="$klasse";
      }
   }
} elsif ($user ne "") {
   if($Conf::log_level>=2){
      print("\nArgument ist:  $argument\n");
   }
   foreach (keys %schueler_im_system_hash){
     my ($class,$name,$login)=split(/;/,$schueler_im_system_hash{$_});
      if ($login eq $user){
         # Key = identifier
         # Value = Klasse
         $sortier_hash{$_}="$class";
      }
   }
    
}


if($Conf::log_level>=3){
   # Nur zum ausgeben 
   print("Create Login Cards for the following users:\n");
   print "------------------------------------------------------------\n"; 
   while (($key,$value) = each %sortier_hash){
      printf "%-40s %3s\n","$key","-$value-";
   }
}

# ===========================================================================
# Im sortier-Hash stehen nun alle auszudruckenden Schüler
# ===========================================================================


# ===========================================================================
# LATEX-Vorspann schreiben
# ===========================================================================

# *.tex-Datei öffnen
open(LATEX,
     ">${DevelConf::druck_pfad}/${output_file_basename}.tex") || die "Fehler: $!";

if ($classlist ne ""){
    # *.mediawiki-Datei öffnen
    open(MEDIAWIKI,
         ">${DevelConf::druck_pfad}/${output_file_basename}.mediawiki") || die "Fehler: $!";
}
# *.csv-Datei öffnen (windows)
open(CSV,
        ">${DevelConf::druck_pfad}/${output_file_basename}.csv") || die "Fehler: $!";
# *.csv-Datei öffnen (linux)
open(UNIXCSV,
        ">${DevelConf::druck_pfad}/${output_file_basename}-unix.csv") || die "Fehler: $!";

# *_WebUntis.csv-Datei öffnen (windows)
open(WEBCSV,
        ">${DevelConf::druck_pfad}/${output_file_basename}_WebUntis.csv") || die "Fehler: $!";
# *_WebUntis.csv-Datei öffnen (linux)
open(WEBUNIXCSV,
        ">${DevelConf::druck_pfad}/${output_file_basename}_WebUntis-unix.csv") || die "Fehler: $!";


print LATEX ('%% This preamble was created from sophomorix-print
\documentclass[11pt,fleqn,oneside,a4paper]{article}
\usepackage[T1]{fontenc}
\usepackage[utf8]{inputenc}
\usepackage{ngerman}
\usepackage{fancyheadings}
\usepackage{multicol}
\usepackage{graphicx}
\usepackage{url}
\usepackage{hyperref}

\pagestyle{fancy}
%% Erst mal auf Einzelschüler stellen
\lhead{\bf \large \today}
');


print LATEX ('\rhead{\bf \large Seite \thepage}');

if ($gruppe ne "") {
   # Klassenangabe gemacht  
  if ($classlist ne ""){
      print MEDIAWIKI "===$gruppe===\n"; 
  }
  print LATEX ('
      \chead{\LARGE \bf ',"$gruppe",'}
   ');
} elsif ($project ne "") {
   # Projektangabe gemacht  
  if ($classlist ne ""){
      print MEDIAWIKI "===$project===\n"; 
  }
  print LATEX ('
      \chead{\LARGE \bf ',&latexize_string($project),'}
   ');
} elsif ($classlist ne "") {
   # Klassenangabe gemacht

  print MEDIAWIKI "===$classlist===\n"; 

  print LATEX ('
      \chead{\LARGE \bf ',"$classlist",'}
   ');
} else {
  print LATEX ('
      \chead{\LARGE \bf Einzelschüler}
   ');
}

my $latex_schoolname=&latexize_string("$Conf::schul_name");

print LATEX ('\lfoot{',"$latex_schoolname",'}',"\n");
print LATEX ('\rfoot{'," ",&latexize_string(${output_file_basename}),'.pdf','}',"\n");

print LATEX ('
\setlength{\voffset}{0mm}
\setlength{\hoffset}{0mm}
\setlength{\oddsidemargin}{0mm}
\setlength{\evensidemargin}{0mm}
\setlength{\marginparsep}{1.5mm}
\setlength{\marginparwidth}{60mm}
\setlength{\marginparpush}{1mm}
\setlength{\parindent}{0cm} %% Einrückungen am Absatzanfang verhindern
\setlength{\paperwidth}{210mm} %% Papierbreite angeben
\setlength{\paperheight}{297mm} %%Papierhöhe angeben
%% linker Rand einstellen:
\setlength{\oddsidemargin}{-17.9mm}
\setlength{\headsep}{3mm}      
\setlength{\headheight}{8mm}
\setlength{\topskip}{0mm}      
\setlength{\topmargin}{-18mm}
\setlength{\footskip}{-1mm}

\setlength{\headwidth}{189mm}
%% Einstellungen fuer die Umrahmungen:
\setlength{\textwidth}{189mm}
\setlength{\textheight}{261.5mm}

\renewcommand{\headrulewidth}{0.25mm}
\renewcommand{\footrulewidth}{0.25mm}
\setlength{\fboxrule}{0.1mm}
\renewcommand{\baselinestretch}{1}

%% Datensatz in ein Kärtchen umwandeln
\newcommand{\daten}[5]{
\fbox{
\begin{minipage}[b][26mm][c]{41mm}
\begin{center}
#1 #2 \par #3 \par #4 \par #5
\end{center}
\end{minipage}
}}

\newcommand{\datenoneperpage}[5]{
\begin{center}
\fbox{
\begin{minipage}[b][54mm][c]{85mm}
\begin{center}
\Large #1 #2 \par #3 \par \vspace{2mm} #4 \par #5
\end{center}
\end{minipage}
}
\end{center}
}

%% Lehrereintrag am Seitenrand erzeugen
\newcommand{\edvlehrer}[1]{
\marginpar{%
  %\begin{minipage}[t]{30mm}
\rotatebox{90}{%
\begin{minipage}[t]{26mm}
\begin{center}
\small #1
\end{center}
\end{minipage}
}%
 % \end{minipage}
}%
}

\begin{document}

');
if ($project ne "") {
    print LATEX ('\addtocontents{toc}{\textbf{Projekt \dotfill Seite} \par}',"\n");
} else {
    print LATEX ('\addtocontents{toc}{\textbf{Klasse \dotfill Seite} \par}',"\n");
}
print LATEX ('%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Hier beginnen die erzeugten Einträge

');

# ===========================================================================
# LATEX-Vorspann geschrieben
# ===========================================================================



# ===========================================================================
# Schülerdaten in Klassen (über 4 Schüler) und Einzelschüler (1-4) einteilen
# ===========================================================================
# Hash mit Klassenbezeichnung und Anzahl erzeugen aus allen Schülern
foreach (values %sortier_hash){
#print "$_\n\n"; # gibt den Wert zurück (hier die Klasse)
   if (exists($klasse_schueleranzahl{$_})){
               $klasse_schueleranzahl{$_}++; # 1 dazuzählen
            } else {
   	      $klasse_schueleranzahl{$_}=1;
	    }
}
# Hash wurde erzeugt mit Klassenbezeichnung -- Schüleranzahl



# ===========================================================================
# Aufteilen aller Schülerdatensätze sortier_hash in 2 Hashes
# sortier_klassen_hash  und  sortier_einzelschueler_hash
# ===========================================================================

while(($key, $value) = each(%sortier_hash)){
# $key ist identifier, $value ist klasse
  if ($klasse_schueleranzahl{$value} < 5) {
     if($Conf::log_level>=3){
         # Alle Klassen unter 4 Schüler ausdrucken
         print "1 bis 4 $value\n";
      }
     $sortier_einzelschueler_hash{$key}="$value";
  } else {
     $sortier_klassen_hash{$key}="$value";
  }
}


# ===========================================================================
# Klassen Schülerdaten sortieren
# ===========================================================================
# Sortier-Hash sortieren
@drucken_klasse_reihenfolge = sort { 
   # sortieren nach Wert (Klassenbezeichnung) alphabetisch
   $sortier_klassen_hash{$a} cmp $sortier_klassen_hash{$b}
   or
   # Innerhalb der Klassenbezeichnung alphabetisch
   $a cmp $b 
} keys %sortier_klassen_hash;
# Alle anzulegenden Schüler befinden sich nun im sortier_hash

if($Conf::log_level>=3){
   # Nur zum Testen ausdrucken
   print "\n\nsortier_klassen_hash: \n\n";
   while (($k,$v) = each %sortier_klassen_hash){
      printf "%-40s %3s\n","$k","$v";
    }
}


# ===========================================================================
# Einzelschüler Schülerdaten sortieren
# ===========================================================================
# Sortier-Hash sortieren
@drucken_einzelschueler_reihenfolge = sort { 
   # sortieren nach Wert (Klassenbezeichnung) alphabetisch
   $sortier_einzelschueler_hash{$a} cmp $sortier_einzelschueler_hash{$b}
   or
   # Innerhalb der Klassenbezeichnung alphabetisch
   $a cmp $b 
} keys %sortier_einzelschueler_hash;
# Alle anzulegenden Schüler befinden sich nun im sortier_hash


if($Conf::log_level>=3){
   # Nur zum Testen ausdrucken
   print "\n\nEinzelschüler_hash:\n";
   print "------------------------------------------------------------\n";
   while (($k,$v) = each %sortier_einzelschueler_hash){
      printf "%-40s %3s\n","$k","$v";
    }
}

# ===========================================================================
# Liste Einzelschüler an Liste Klasse anhängen
# ===========================================================================
# Folgendes geht nicht mit push
@drucken_reihenfolge = (@drucken_klasse_reihenfolge, 
                         @drucken_einzelschueler_reihenfolge);



############################################################
# CLASSLIST
############################################################
if ($classlist ne ""){
    &titel("Creating classlist of $classlist");
    my $count=0;

    print MEDIAWIKI "{|border=\"1\"\n";
    print MEDIAWIKI "|Nr.\n|Name\n|SP1\n|SP2\n|SP3\n|SP4\n|SP5\n|SP6\n|SP7\n|-\n";

    print LATEX "\\begin{tabular}{|r|p{55mm}|p{116mm}|}\\hline \n";
    print LATEX "\\rule[-2mm]{0mm}{7mm}\\textbf{Nr}& \\textbf{Name, Vorname} & \\\\ \\hline\\hline
";

    foreach $eintrag (@drucken_reihenfolge) {
        $count++;
        $schueler_protokoll_zeile=$schueler_im_system_hash{$eintrag};
        ($klasse_protokoll, 
        $name_protokoll,
        $loginname_protokoll,
        $passwort_protokoll,
        $geburtsdatum_protokoll
        )=split(/;/,$schueler_protokoll_zeile);

        my ($firstname,$surname)=split(/\s/,$name_protokoll);
        my $name=$surname.", ".$firstname;

        # Ausgabe
        if($Conf::log_level>=2){
           print "Erstelle Klassenliste für  $loginname_protokoll  ",
                 "in   $klasse_protokoll \n";
        }

        print LATEX "\\rule[-2mm]{0mm}{6.7mm} $count & $name &  \\\\  \\hline \n";
        print MEDIAWIKI "|$count\n|$name\n|\n|\n|\n|\n|\n|\n|\n|-\n";

    }

    print LATEX "\\end{tabular} \n";
    print MEDIAWIKI "|}";


}# End CLASSLIST



############################################################
# ONE ENTRY PER PAGE
############################################################
if ($one_per_page==1){
    &titel("Creating a login list (1 per page)");
    # fetch dnsdomainname and hostname
    my $hostname=&hostname();
    my $dnsdomainname=`dnsdomainname`;
    chomp($dnsdomainname);

    # internal server name
    my $server=$hostname.".".$dnsdomainname;
    if (defined $Conf::server_fqdn_internal_print){
        if ($Conf::server_fqdn_internal_print ne ""){
	    $server=$Conf::server_fqdn_internal_print;
        }
    }
    # external server name
    my $server_external=$server;
    if (defined $Conf::server_fqdn_external_print){
        if ($Conf::server_fqdn_external_print ne ""){
	    $server_external=$Conf::server_fqdn_external_print;
        }
    }
    # samba domain
    my $smb_domain="";
    if (defined $Conf::smb_domain_print){
        if ($Conf::smb_domain_print ne ""){
	    $smb_domain=$Conf::smb_domain_print;
        }
    }

    # common changes to the template
    my $admins="";
    if (defined $Conf::admins_print){
        if ($Conf::admins_print ne ""){
	    $admins=$Conf::admins_print;
        }
    }


    # read the template into variable
    my $template=${DevelConf::latex_templates}.
       "/login-info-".${Conf::lang}.".tex";
    my $template_content="\n\n";
    open(TEMPLATE,"<$template") || die "Fehler: $!";
    while(<TEMPLATE>){
        $template_content=$template_content.$_;
    }
    close (TEMPLATE);

    foreach $eintrag (@drucken_reihenfolge) {
        $schueler_protokoll_zeile=$schueler_im_system_hash{$eintrag};
        ($klasse_protokoll, 
        $name_protokoll,
        $loginname_protokoll,
        $passwort_protokoll,
        $geburtsdatum_protokoll
        )=split(/;/,$schueler_protokoll_zeile);
        # Klasse oder Projekt verwenden
        $klasse_protokoll = $sortier_hash{$eintrag};
        
        # Ausgabe
        if($Conf::log_level>=2){
           print "Erstelle Login-Karte für  $loginname_protokoll  ",
                 "in   $klasse_protokoll \n";
        }

        # replace some characters
        my $latex_passwort_protokoll=&latexize_string($passwort_protokoll);

        # write header/contents of page
        if ($klasse_protokoll=~/^p_/) {
            print LATEX '\chead{\LARGE \bf ',
                   "$name_protokoll (",&latexize_string($klasse_protokoll),")",'}';
        } else {
            print LATEX '\chead{\LARGE \bf ',
                   "$name_protokoll ($klasse_protokoll)",'}';
        }
        print LATEX ('\addtocontents{toc}{',
                       "$name_protokoll",
                       ' \dotfill \thepage  \par}',"\n");
        print LATEX "\n";

        # copy the template
        my $template_data=$template_content;

        # modify the template
        $template_data=~s/\@\@user\@\@/${name_protokoll}/g;
        $template_data=~s/\@\@admins\@\@/${admins}/g;

        print LATEX "$template_data \n\n";

        print LATEX ('\datenoneperpage');
        # 1 Name
        print LATEX ('{',"$name_protokoll",'}');
        # 2 Nicht genutzt
        print LATEX ('{}');
        # 3 Klasse/Projekt
        if ($klasse_protokoll=~/^p_/) {
            print LATEX ('{',"Projekt: ",&latexize_string($klasse_protokoll),'}');
        } else {
            print LATEX ('{',"Klasse: $klasse_protokoll",'}');
        }
        # 4 Login
        print LATEX ('{',"Login: \\texttt{$loginname_protokoll}",'}');


        # 5 Passwort
        print LATEX ('{',"Erst-Passwort: \\texttt{$latex_passwort_protokoll}",'}',"\n");

        # windows
        print LATEX "\\rule{\\linewidth}{0.25mm}  \n\n";
        print LATEX "Anmeldung an einem Windowsrechner:\n\n";
        print LATEX "\\begin{tabbing}\n";
        print LATEX "\\qquad Benutzername:\\qquad \\= \\texttt{$loginname_protokoll} \\\\ \n";
        print LATEX "\\qquad Kennwort:     \\> \\texttt{$latex_passwort_protokoll} \\\\ \n";
        print LATEX "\\qquad Domäne:       \\> \\texttt{$smb_domain} \\\\ \n";
        print LATEX "\\end{tabbing}\n\n";
        print LATEX "\\vspace{-6mm}\n\n";

        # linux 
        print LATEX "\\rule{\\linewidth}{0.25mm}  \n\n";
        print LATEX "Anmeldung an einem Linuxrechner:\n";
        print LATEX "\\begin{tabbing}\n";
        print LATEX "\\qquad Login:\\qquad\\qquad \\= \\texttt{$loginname_protokoll} \\\\ \n";
        print LATEX "\\qquad Passwort: \\> \\texttt{$latex_passwort_protokoll} \\\\ \n";
        print LATEX "\\end{tabbing}\n";
        print LATEX "\\vspace{-6mm}\n\n";

        # schulkonsole
        print LATEX "\\rule{\\linewidth}{0.25mm}  \n\n";
        print LATEX "Pädagogische Funktionen mit der Schulkonsole im Intranet:\n\n";
        print LATEX " URL: \\url{https://${server}:242}\n\n";

        # horde
        print LATEX "\\rule{\\linewidth}{0.25mm}  \n\n";
        print LATEX "Webmail mit Horde: \n\n";
        print LATEX " URL: \\url{https://${server_external}/horde3}\n\n";

        # ogo
        #print LATEX "\\rule{\\linewidth}{0.25mm}  \n\n";
        #print LATEX " Groupware mit OpenGroupware: \n\n";
        #print LATEX " URL: \\url{https://${server_external}/OpenGroupware}\n\n";

        # moodle
        print LATEX "\\rule{\\linewidth}{0.25mm}  \n\n";
        print LATEX " Lernplattform mit Moodle: \n\n";
        if (not defined $Conf::moodle_url){
            print LATEX " URL: \\url{https://${server_external}/moodle}\n\n";
        } else {
            print LATEX " URL: \\url{${Conf::moodle_url}}\n\n";
        }
        # phpmyadmin
        #print LATEX "\\rule{\\linewidth}{0.25mm}  \n\n";
        #print LATEX " Datenbankzugriff mit phpmyadmin: \n\n";
        #print LATEX " URL: \\url{https://${server}/phpmyadmin}\n\n";

        # websvn
        #print LATEX "\\rule{\\linewidth}{0.25mm}  \n\n";
        #print LATEX " Versionskontrolle mit svn per Webfrontend: \n\n";
        #print LATEX " URL: \\url{https://${server}/websvn}\n\n";



        print LATEX "\\newpage \n\n";
   }
} # End 1 PER PAGE



############################################################
# 36 ENTRIES PER PAGE
############################################################
if ($one_per_page==0 and $classlist eq ""){
    &titel("Creating a login list (36 per page)");
    $klasse_protokoll_alt="";

    # Sortierten Hash ausgeben lassen
    foreach $eintrag (@drucken_reihenfolge) {
       my $identifier="";

       # dirty fix
       if ($eintrag=~m/::/){
           ($a,$identifier)=split(/::/, $eintrag);
       } else {
            $identifier=$eintrag;
       }
       $schueler_protokoll_zeile=$schueler_im_system_hash{$identifier};
       if($Conf::log_level>=3){
       print ("\nDieser User wird gedruckt: $eintrag\n");
       print("Identifier:               --$identifier--\n");
       print("Zeile in user_db          --$schueler_protokoll_zeile--\n\n");
    }
   
   ($klasse_protokoll, 
    $name_protokoll,
    $loginname_protokoll,
    $passwort_protokoll,
    $geburtsdatum_protokoll
   )=split(/;/,$schueler_protokoll_zeile);
   # Entweder Klasse oder Projekt verwenden
   $klasse_protokoll = $sortier_hash{$identifier};
   # Zusatzwerte
   $first_protokoll=$schueler_im_system_first{$identifier};
   $sur_protokoll=$schueler_im_system_sur{$identifier};
   $id_protokoll=$schueler_im_system_id{$identifier};
   # Ausgabe
   if($Conf::log_level>=2){
      print "Erstelle Login-Karte für  $loginname_protokoll  ",
            "in   $klasse_protokoll \n";
   }

   # replace some characters
   my $latex_passwort_protokoll=&latexize_string($passwort_protokoll);

   # Vorheriger Eintrag speichern
   $eintrag_typ_alt=$eintrag_typ;

   # Handelt es sich beim Eintrag um eine Klasse(2) oder Einzelschüler(1)
   if ($klasse_protokoll eq "") {
     # Einzelschüler
       $eintrag_typ=1;
   } elsif ($klasse_schueleranzahl{$klasse_protokoll} < 5) {
     # Einzelschüler
       $eintrag_typ=1;
   } else {
     # Klasse
       $eintrag_typ=2;
   }
   ###################################################################
   # Wenn neue Klasse begonnen wird
   if ($klasse_protokoll_alt ne $klasse_protokoll){
     # Wenn Klasse
     if ($eintrag_typ==2){
       $rand_bemerkung_lehrer=1; # Randbemerkung nicht mehr notwendig    
       if ($klasse_protokoll_alt ne ""){
          # Nicht der allererste Eintrag
          # Auffüllen der Seite
          while ($anzahl_karten_pro_seite < $entries_per_page){
             print LATEX ('\daten{\rule[2mm]{30mm}{0.5mm}}{}{}{}{}');
             print LATEX ("\n");
             $anzahl_karten_pro_seite++;
          }
          # Neue Seite beginnen
          print LATEX ("\n",'\newpage',"\n\n");
          # Katenzähler/Seite auf 0
          $anzahl_karten_pro_seite=0;
       }
       # Klassenbezeichner anpassen
       $klasse_head=$klasse_protokoll;
       # Erstes k entfernen
       $klasse_head=~s/k//;
       # alles in Großbuchstaben
       $klasse_head=~tr/a-z/A-Z/;
       # Kopfzeileneintrag
       print LATEX ('\chead{\LARGE \bf ',&latexize_string($klasse_head),'}');
       print LATEX "\n";
       # Verantwortlicher Lehrer ermitteln

       # $edv_lehrer_foot
       my @lehrerliste;
       if ($klasse_protokoll =~ /^p_/ ) {
          @lehrerliste =
            &Sophomorix::SophomorixPgLdap::fetchadmins_from_project($klasse_protokoll);
       } else {
          @lehrerliste =
            &Sophomorix::SophomorixPgLdap::fetchadmins_from_adminclass($klasse_protokoll);
       }
       $edv_lehrer_foot = join(", ",@lehrerliste);

       print LATEX ('\cfoot{\bf ',
                         "$edv_lehrer_foot",
                         '}');
       print LATEX "\n";
       # Eintrag in das Inhaltsverzeichnis
       print LATEX ('\addtocontents{toc}{',
                       &latexize_string($klasse_head),
                       ' \dotfill \thepage  \par}',"\n");
       print LATEX "\n";
     #######################################################################
     } else {
        # Wenn Einzelschüler
        # Wenn Vorgänger zu Klasse gehörte, Seite füllen
        if($eintrag_typ_alt==0){
            $rand_bemerkung_lehrer=0;
        }
        if($eintrag_typ_alt==2){
           # Vorgänger gehörte zur einer Klasse (über 4 Schüler)
           $rand_bemerkung_lehrer=0; # Randbemerkung wurde nicht gemacht
           # Auffüllen der Seite
           while ($anzahl_karten_pro_seite < $entries_per_page){
              print LATEX ('\daten{\rule[1mm]{30mm}{0.5mm}}{}{}{}{}');
              print LATEX ("\n");
              $anzahl_karten_pro_seite++;
           }
           # Neue Seite beginnen
           print LATEX ("\n",'\newpage',"\n\n");
           # Kartenzähler/Seite auf 0
           $anzahl_karten_pro_seite=0;
           # Kartenzähler/Zeile auf 0
           $anzahl_karten_pro_zeile=0;
           # Kopfzeileneintrag
           print LATEX ('\chead{\LARGE \bf ',"Einzelschüler",'}');
           print LATEX "\n";
           print LATEX ('\cfoot{}');
           print LATEX "\n";
           # Eintrag in das Inhaltsverzeichnis
           print LATEX ('\addtocontents{toc}{\textbf{',
                            "Einzelschüler",
                            '} \dotfill \thepage  \par}');
           print LATEX "\n";
           # EDV-Lehrerangabe machen, Zähler auf 0 setzen
           $rand_bemerkung_lehrer=0; # Randbemerkung wurde nicht gemacht
	} elsif ($eintrag_typ_alt==1) {
           # Wenn Einzelschüler
           # Vorgänger war auch Einzelschüler
           
           # Auffüllen der Zeile
	  if ($anzahl_karten_pro_zeile == 4) {$rand_bemerkung_lehrer=0};
           while ($anzahl_karten_pro_zeile !=4) {
               print LATEX ('\daten{\rule[2mm]{30mm}{0.5mm}}{}{}{}{}');
               print LATEX ("\n");
               $anzahl_karten_pro_seite++;
               $anzahl_karten_pro_zeile++;
               $rand_bemerkung_lehrer=0; # Randbemerkung wurde nicht gemacht
           }
           if($anzahl_karten_pro_seite == $entries_per_page) {
               print LATEX ("\n\n",'\newpage',"\n\n");
               $anzahl_karten_pro_seite=0;
	   }
          $anzahl_karten_pro_zeile=0;
        }
     }
   }


   # alte Klassenbezeicnung für nächsten Vergleich speichern
   $klasse_protokoll_alt=$klasse_protokoll;


   # wenn Randbemerkung noch nicht angegeben wurde, jetzt tun
   # Switch zur Randbemerkung schalten 
   if ($rand_bemerkung_lehrer==0) {
      # Verantwortlicher Lehrer ermitteln
      # Nur zuweisen, wenn Eintrag im Hash sonst wirds undef ??


      # $edv_lehrer_rand
      my @lehrerliste;
      if ($klasse_protokoll =~ /^p_/ ) {
        @lehrerliste =
        &Sophomorix::SophomorixPgLdap::fetchadmins_from_project($klasse_protokoll);
      } else {
        @lehrerliste =
        &Sophomorix::SophomorixPgLdap::fetchadmins_from_adminclass($klasse_protokoll);
      }
      $edv_lehrer_rand = join(",",@lehrerliste);

      # Verantwortlichen Lehrer einsetzten
      print LATEX ("\n",
                        '\edvlehrer{',
                        "$edv_lehrer_rand",
                        '}',
                        "\n");
      $rand_bemerkung_lehrer=1; # Randbemerkung wurde gemacht
   } # Ende der Randbemerkung


   # Datensatz anhängen
   print LATEX ('\daten');
   # 1 Name
   print LATEX ('{',"$name_protokoll",'}');
   # 2 Nicht genutzt
   print LATEX ('{}');
   # 3 Klasse/Projekt
   if ($klasse_protokoll =~ /^p_/) {
    print LATEX ('{',"Projekt: ",&latexize_string($klasse_protokoll),'}');
   } else {
    print LATEX ('{',"Klasse: $klasse_protokoll",'}');
   }
   # 4 Login
   print LATEX ('{',"Login: \\texttt{$loginname_protokoll}",'}');
   # 5 Passwort
   print LATEX ('{',"Erst-Passwort: \\texttt{$latex_passwort_protokoll}",'}',"\n");
   # Eintag ferig, Zähler erhöhen
   $anzahl_karten_pro_seite++;
   $anzahl_karten_pro_zeile++;
   
   # Zeile in add.csv schreiben (unix)georg: linliste
   print UNIXCSV ("$name_protokoll",";","$klasse_protokoll",";",
                  "$loginname_protokoll",";","$passwort_protokoll",";","\n");
   print WEBUNIXCSV ("$klasse_protokoll",";","$sur_protokoll",";","$first_protokoll",";",
                  "$loginname_protokoll",";","$id_protokoll",";","\n");
   # Zeile in add.csv schreiben (windows-versuch 1) georg: winliste
   print CSV ("$name_protokoll",";","$klasse_protokoll",";",
              "$loginname_protokoll",";","$passwort_protokoll",";","\l\r");
   print WEBCSV ("$klasse_protokoll",";","$sur_protokoll",";","$first_protokoll",";",
                  "$loginname_protokoll",";","$id_protokoll",";","\l\r");

} # Ende foreach
# Nun sind alle Schüler in der LATEX-Datei eingelesen




# Allerletzte Seite (vor Inhaltsverzeichnis noch auffüllen)
while ($anzahl_karten_pro_seite < $entries_per_page){
   print LATEX ('\daten{\rule[2mm]{30mm}{0.5mm}}{}{}{}{}');
   print LATEX ("\n");
   $anzahl_karten_pro_seite++;
}

# ===========================================================================
# Klassen LATEX-Nachspann schreiben
# ===========================================================================
# Letze Seite mit leeren Einträgen füllen
while ($anzahl_karten_pro_seite < $entries_per_page){
        print LATEX ('\daten{\rule[2mm]{30mm}{0.5mm}}{}{}{}{}');
        print LATEX ("\n");
        $anzahl_karten_pro_seite++;
}



} # End 36 PER PAGE
############################################################
















# ===========================================================================
# Dokument beenden und Inhaltsverzeichnis schreiben
if ($gruppe ne "" or $project ne "") {
   # Klassen-/Projektangabe gemacht  
   print LATEX ('
      \end{document}
   ');
} elsif ($classlist ne "") {
   # Klassenangabe gemacht  
   print LATEX ('
      \end{document}
   ');
} else {
   print LATEX ('

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Hier enden die erzeugten Einträge

\newpage

\setlength{\columnsep}{15mm}
\setlength{\columnseprule}{0.4mm}

% Wenn sie bis 225 Klassen im Inhaltsverzeichnis wollen 
% dann erhöhen Sie folgenden Wert auf 5 erhöhen
\begin{multicols}{4}

\rhead{\bf \LARGE I}
\lhead{}
\chead{\bf \LARGE Inhaltsverzeichnis}
\cfoot{}

\tableofcontents

\end{multicols}

\end{document}

');
}


# ===========================================================================
if ($classlist ne ""){
    # mediawiki-Dokument schließen
    close(MEDIAWIKI);
}
# Latex-Dokument schließen
close(LATEX);
# CSV-Dokument schließen
close(CSV);
close(UNIXCSV);
close(WEBCSV);
close(WEBUNIXCSV);

# ===========================================================================
# LATEXEN des Dokuments
# ===========================================================================


if ($info==1){
    &log_script_end(@arguments);
    #exit;
}


# einfacher
if ($command eq "pdflatex"){
    &pdflatexen;
} elsif ($command eq "latex"){
    # hoehere Qualitaet
    &latexen;
} else {
    print "\nI do not know how to process the file ($command ?)\n\n";
}


# Dateien ins home kopieren
if ($caller_copy ne ""){
    print "#### Copying $output_file_basename into home of user $caller_copy:\n";

    # which files should be copied to $HOME of --caller-copy user
    my @extensions=(".ps",".pdf");

    foreach my $extension (@extensions){
        my  $file=${DevelConf::druck_pfad}."/".$output_file_basename.$extension;
        if (-f $file){
            print "  ## $file\n";
            # check if user is teacher
            my ($homedir,$type,$gecos)=&fetchdata_from_account($caller_copy);
            if ($type ne "teacher"){
            &log_script_exit("ERROR: $caller_copy must be a teacher (--caller-copy)",
                             1,1,0,@arguments);
            }

            # copy it
            my $target_dir=$homedir."/sophomorix-print-data";
            if (not -d $target_dir){
                system("mkdir $target_dir");
            }
            system("cp $file $target_dir");
                system("chown -R ${caller_copy}: $target_dir");
                system("chmod 0700 $target_dir");
                system("chmod 0600 $target_dir/*");
        }
    }
}



# Datei öffnen und mit PDF-reader, z.B. acrobat-reader/xpdf/evince anzeigen falls --show
if ($show==1) {
      print "\nPDF-Reader: Öffne ${DevelConf::druck_pfad}/$output_file_basename.pdf\n\n";
      system("xdg-open ${DevelConf::druck_pfad}/$output_file_basename.pdf");
}


&log_script_end(@arguments);


# ===========================================================================
# Subroutinen
# ===========================================================================



sub pdflatexen {
    &titel("pdflatex is creating $output_file_basename.pdf");
   system("cd ${DevelConf::druck_pfad}; pdflatex $output_file_basename.tex $dev_null");

   system("rm ${DevelConf::druck_pfad}/$output_file_basename.log $dev_null");
   system("rm ${DevelConf::druck_pfad}/$output_file_basename.toc $dev_null");
   system("rm ${DevelConf::druck_pfad}/$output_file_basename.aux $dev_null");
   system("rm ${DevelConf::druck_pfad}/$output_file_basename.out $dev_null");

}

sub latexen {
   &titel("latex is creating $output_file_basename.dvi");
   # PS aus $output_file_basename.tex erzeugen
   system("cd ${DevelConf::druck_pfad}; latex $output_file_basename.tex $dev_null");
   # 2x, wegen Inhaltsverzeichnis
   system("cd ${DevelConf::druck_pfad}; latex $output_file_basename.tex $dev_null");
   &titel("dvips is creating $output_file_basename.ps");
   system("cd ${DevelConf::druck_pfad}; dvips $output_file_basename.dvi $dev_null");
   &titel("ps2pdf is creating $output_file_basename.pdf");
   system("cd ${DevelConf::druck_pfad}; ps2pdf $output_file_basename.ps $dev_null");

   system("rm ${DevelConf::druck_pfad}/$output_file_basename.log $dev_null");
   system("rm ${DevelConf::druck_pfad}/$output_file_basename.toc $dev_null");
   system("rm ${DevelConf::druck_pfad}/$output_file_basename.aux $dev_null");
   system("rm ${DevelConf::druck_pfad}/$output_file_basename.out $dev_null");

   # Dateien für user unlesbar machen
   system("chmod 400 ${DevelConf::druck_pfad}/$output_file_basename.* $dev_null");
   # Zugriff von admin von windows aus erlauben
   system("chown admin.admin ${DevelConf::druck_pfad}/$output_file_basename.* $dev_null");
}



