| /* ========================================================================= |
| |
| Ein Mailobjekt fuer Morgengrauen. |
| (C) 1993-97 Loco@MG. Unter Verwendung des std/post-codes von Jof |
| |
| Verwendung ausserhalb von Morgengrauen ist gestattet unter folgenden |
| Bedingungen: |
| - Benutzung erfolgt auf eigene Gefahr. Jegliche Verantwortung wird |
| abgelehnt. |
| - Auch in veraenderten oder abgeleiteten Objekten muss ein Hinweis auf |
| die Herkunft erhalten bleiben. |
| - Bitte Loco Bescheid sagen. |
| Ein Update-Service besteht nicht. Diese Lizenz kann jederzeit |
| zurueckgezogen werden. |
| |
| Letzte Aenderungen: |
| 190494 [Loco] mail <spieler> fuehrt nicht ins mailmenue anschliessend. |
| 280494 [Loco] .mailrc |
| 020594 [Loco] system.mailrc, aliase anzeigen, Text retten, selfdestruct |
| in reset() im Fehlerfall, kleinere bugfixes |
| 070794 [Loco] Kleinigkeiten (bugfixes und Optimierungen), '+' |
| 231195 [Loco] Bereiche bei Speichern und Loeschen |
| 171295 [Loco] Bereiche bei forward. Stapelweise Kleinigkeiten. |
| 191295 [Loco] Kleinere Zeitoptimierungen, teilweise schiefgelaufen und |
| deswegen doch nicht, minor bugfixes. |
| 190295 [Loco] keine folderlist beim hochstarten |
| 110696 [Loco] Forwardserver-Unterstuetzung (.forward-aehnlich) |
| 031296 [Loco] major update: |
| Erlaube in der Blueprint nichtinteraktives Versenden |
| vorbereiteter mails (z.B. fuer mpa: versende artikel); |
| Zeitoptimierungen durch effektiveres caching; |
| '-'; |
| Einige optische Aenderungen; |
| Warnung bei grossen mailfiles; |
| Unterstuetzung von bcc's; |
| d,m,f,s erlauben Listen; |
| Abkuerzungen und '-' bei Folderargumenten |
| 080297 [Loco] Zeitoptimierungen, interne Aenderungen, Bugfixes |
| 280103 [Muadib]Silentflag |
| 020304 [Vanion]In do_mail() wird jetzt M_NOCHECK gemovet, sonst hat ein |
| Mailer eines Spielers, der voll ist, kein Environment. |
| 100105 [Zook] Magier mit Level >= 26 bekommen erst spaeter eine |
| Mitteilung (Gebietswartung insb. f. Regionsmagier |
| erfordert schlicht ein groesseres Postfach). |
| |
| ---------------------------------------------------------------------------- |
| |
| Aufrufe von aussen zur Benutzung: |
| |
| a) im geklonten Objekt: |
| obj->do_mail() interaktives Mailmenue |
| obj->do_mail(empf) 'halbinteraktiv': _eine_ mail, an Empfaenger str |
| Objekt zerstoert sich nach Gebrauch selbst. |
| Bei obj->do_mail("-silent") wird der Inhalt des Mailfolders nicht |
| aufgelistet. Ansonsten wie obj->do_mail() |
| |
| b) in der blueprint: nur non-interactive |
| obj->do_mail(empf,titel,text) |
| sendet mail mit Titel titel und Inhalt text an Empfaenger empf. |
| Aliase etc. werden von this_interactive() genommen. |
| Nur fuer 'trusted objects' zugelassen, siehe #define TRUSTED |
| |
| =========================================================================== */ |
| |
| #include "post.h" |
| |
| inherit "/std/thing"; |
| //inherit "std/more"; // wird vom nedit inherited |
| inherit NEDIT; |
| |
| #include <properties.h> |
| #include <language.h> |
| #include <config.h> |
| #include <mail.h> |
| #include <wizlevels.h> |
| #include <moving.h> |
| #include <defines.h> |
| #include <input_to.h> |
| |
| #undef DEBUG |
| |
| #define TRUSTED(o) (objectp(o) && BLUE_NAME(o)=="/obj/mpa") |
| // (geteuid(o)=="p:service"|| \ |
| // geteuid(o)==geteuid(this_interactive()))) |
| |
| #define MAILFILE(name) (MAILPATH+name[0..0]+"/"+name) |
| #define MAILFILEO(name) (MAILFILE(name)+".o") |
| #define MAILDEMON0297 // Maildemon-Version 8.Feb.97 vorhanden? |
| |
| #define IS_NUMBER(n) (stringp(n) && sizeof(n) && n[0]>='0' && n[0]<='9') |
| |
| #ifdef DEBUG |
| #define DEBUGVAR(x) if(find_player("tiamak")) tell_object(find_player("tiamak"),sprintf("Value of x is %O\n",x)) |
| #else |
| #define DEBUGVAR(x) |
| #endif |
| |
| // Zaehlung: akt_nr ab 1, akt_folder ab 0 |
| |
| static string subject, message, receiver, sender, *carbon; |
| #ifdef MAIL_SUPPORT_BCC |
| static string* blindcarbon; |
| #endif |
| static string name, office_name; |
| static int done, akt_folder, i, akt_nr, directflag; |
| static int folder_size,folder_date; // cacheverwaltung |
| static mapping aliases; |
| |
| mixed *folders; |
| |
| // Prototypen, die nun mal gebraucht werden |
| |
| static varargs void SendMail(string text,int flag); |
| static void input(); |
| static mixed process_names(mixed s); |
| static void get_carbon_copy(string str); |
| static varargs string* send_mail(mixed back); |
| string * unify_array(string * a); |
| static mapping Read_mailrc(string file); |
| static varargs void update(int directflag,int nocondflag); |
| static varargs void ListContent(int limit); |
| string GetFolderName(mixed fol); |
| static void LagWarning(); |
| string GetReTitle(string s); |
| static string Message2string(int nr); |
| int * GetNumbers(mixed s); |
| |
| protected void create() { |
| ::create(); |
| seteuid(getuid()); |
| SetProp(P_IDS,({"mailer"})); |
| SetProp(P_NAME,"mailer"); |
| office_name="Morgengrauens Post"; |
| akt_folder=-1; |
| folder_size=folder_date=-42; |
| SetProp(P_NODROP,1); |
| SetProp(P_SHORT,0); |
| SetProp(P_WEIGHT,0); |
| } |
| |
| |
| public varargs void init(object origin) { |
| (::init()); |
| init_rescue(); |
| add_action("postneustart","post"); |
| add_action("postneustart","mail"); |
| } |
| |
| |
| void reset() { |
| object pl; |
| (::reset()); |
| if (!name) {remove();return;} |
| pl=find_player(name); |
| if (!pl || environment()!=pl) {remove();return;} |
| if (nedittext && !query_input_pending(pl)) { |
| tell_object(pl,"\ |
| *** Hoppla! Du hast noch einen nicht fertiggeschriebenen Brief!\n\ |
| *** Mit ~r kannst Du weiterschreiben.\n"); |
| return; |
| } |
| if (query_input_pending(pl)!=this_object()) |
| {remove();return;} |
| } |
| |
| |
| mixed postneustart() { |
| if (!this_interactive() || name!=geteuid(this_interactive()) |
| || query_input_pending(this_interactive()) |
| || this_interactive()!=this_player()) return 0; |
| write("Und weiter gehts...\n"); |
| if (nedittext) return RescueText(); |
| return input(); |
| } |
| |
| |
| string SetOfficeName(string n) { |
| return office_name=n; |
| } |
| |
| |
| static varargs void write_mail(mixed str, string std_subject, string text) { |
| string str2; |
| int h; |
| |
| carbon=process_names(str); |
| if (!sizeof(carbon)) { |
| write("Kein Empfaenger angegeben!\n"),(directflag?remove():input()); |
| return; |
| } |
| write("Empfaenger: "+implode(map(carbon,#'capitalize/*'*/),", ")+"\n"); |
| str=carbon[0]; |
| if (sizeof(carbon)>=2) carbon=carbon[1..<1]; |
| else carbon=0; |
| if ((str2=str) && str2!="" && str2[0]=='\\') str2=str2[1..]; |
| if (!str) { write("WEM willst Du schreiben?\n"),(directflag?remove():input()); return; |
| } |
| if (!master()->find_userinfo(str2) && member(str2,'@')==-1) |
| { |
| write("Mit dem Namen gibt es hier niemanden.\n"),(directflag?remove():input()); |
| return; |
| } |
| |
| receiver=str; |
| |
| if (text) { |
| subject=std_subject; |
| return SendMail(text,1); // flag 1: keine CC's bitte. |
| } |
| |
| //write("Titel"); |
| //if (std_subject) write(" ("+std_subject+")"); |
| //write(": "); |
| string pr; |
| if (std_subject) pr = "Titel ("+std_subject+"): "; |
| else pr = "Titel: "; |
| subject=std_subject; |
| input_to("get_subject",INPUT_PROMPT,pr); |
| return; |
| } |
| |
| |
| static varargs void get_subject(string str,string pretext) { |
| DEBUGVAR(str); |
| DEBUGVAR(subject); |
| if ((!str||str=="") && !subject) |
| { |
| input_to("get_subject",INPUT_PROMPT,"Titel (Abbrechen mit ~q): "); |
| return; |
| } |
| if (str=="~q"||str=="~Q") return SendMail(0); // entspricht Abbruch im Editor. |
| if (str && str!="") subject=str; |
| write("Bitte gib jetzt Deine Nachricht an:\n\ |
| ** oder . wenn fertig, ~q fuer Abbruch, ~h fuer eine Hilfsseite\n"); |
| nedit("SendMail",pretext); |
| } |
| |
| |
| static varargs void SendMail(string text,int flag) { |
| // flag: 1 = keine CC abfragen. |
| if (!text) { |
| write("Abbruch! Brief landet im Reisswolf.\n"); |
| if (directflag) {remove(); return; |
| } |
| |
| subject=receiver=carbon=message=0; |
| return input(); |
| } |
| message=text; |
| if (flag) return get_carbon_copy(0); |
| //write("Cc: "); |
| input_to("get_carbon_copy",INPUT_PROMPT, "Cc: "); |
| return; |
| } |
| |
| |
| static void get_carbon_copy(string str) { // Aufruf mit 0, wenn keine cc gewuenscht. |
| int i,j; |
| object p; |
| string *oldcarbons,*h,*receivers; |
| mapping orignames; |
| |
| oldcarbons=carbon; |
| if (str=="~q") return SendMail(0); // Abbruch, entspricht Abbruch im Editor |
| if (!str || str=="") carbon=0; |
| else carbon=process_names(str); |
| carbon=(oldcarbons ? oldcarbons : ({}))+(carbon ? carbon : ({})); |
| |
| #ifdef MAIL_SUPPORT_BCC |
| blindcarbon=filter(carbon, |
| function status (string x) |
| {if (x[0]=='-') return(1); |
| return(0);}); |
| carbon-=blindcarbon; |
| blindcarbon=map(blindcarbon, |
| function string (string x) |
| {return(x[1..]);} ); |
| #endif |
| |
| #ifdef MAIL_SUPPORT_BCC |
| oldcarbons=({receiver})+carbon+blindcarbon; // speichere alle Originaladressen |
| #else |
| oldcarbons=({receiver})+carbon; |
| #endif |
| |
| /* Forwards auswerten, dabei werden auch ungueltige Adressen gefiltert */ |
| /* orignames speichert die Zuordnung Zieladressen -> Originaladressen */ |
| |
| orignames=([]); |
| h=explode(FWSERV->QueryForward(receiver),","); |
| |
| DEBUGVAR(h); |
| for (j=sizeof(h);j--;) |
| orignames[(h[j][0]=='\\'?h[j][1..]:h[j])]=({receiver[0]=='\\'?receiver[1..]:receiver}); |
| receiver=h[0]; |
| receivers=h[1..]; // Missbrauch dieser Variable! |
| |
| DEBUGVAR(orignames); |
| |
| for (i=sizeof(carbon);i--;) { |
| h=explode(FWSERV->QueryForward(carbon[i])||"",","); |
| for (j=sizeof(h);j--;) { |
| h[j]=(h[j][0]=='\\'?h[j][1..]:h[j]); |
| orignames[h[j]]=(orignames[h[j]]||({}))+({carbon[i][0]=='\\'?carbon[i][1..]:carbon[i]}); |
| receivers+=h; |
| } |
| } |
| carbon=receivers; |
| |
| #ifdef MAIL_SUPPORT_BCC |
| receivers=({}); |
| for (i=sizeof(blindcarbon)-1;i>=0;i--) { |
| h=old_explode(FWSERV->QueryForward(blindcarbon[i]),","); |
| for (j=sizeof(h)-1;j>=0;j--) { |
| h[j]=(h[j][0]=='\\'?h[j][1..]:h[j]); |
| orignames[h[j]]=(orignames[h[j]]||({}))+({blindcarbon[i][0]=='\\'?blindcarbon[i][1..]:blindcarbon[i]}); |
| receivers+=h; |
| } |
| } |
| blindcarbon=receivers; |
| #endif |
| |
| carbon=send_mail(); |
| receivers=({}); |
| |
| if (!pointerp(carbon) || !sizeof(carbon)){ |
| write("Brief NICHT verschickt, da keine Empfaenger gefunden!\n"); |
| } else { |
| string *a; |
| DEBUGVAR(orignames); |
| for (i=0;i<sizeof(carbon);i++){ |
| DEBUGVAR(carbon[i]); |
| /* evtl. abfragen nach query_editing und/oder query_input_to */ |
| /* Benachrichtige Spieler, die ein forward gesetzt haben */ |
| a=orignames[carbon[i]]; |
| if (pointerp(a)) |
| { |
| a=a-({carbon[i]}); |
| for (j=sizeof(a);j--;) |
| if (p=find_player(a[j])) |
| tell_object(p,"Ein Postreiter ruft Dir aus einiger Entfernung zu, dass Du neue Post hast!\nDer Brief wurde wunschgemaess weitergeleitet.\n"); |
| } |
| /* Benachrichtige Empfaenger */ |
| #ifndef MAILDEMON0297 |
| if (p=find_player(carbon[i])) |
| tell_object(p,"Ein Postreiter ruft Dir aus einiger Entfernung zu, dass Du neue Post hast!\n"); |
| #endif |
| receivers+=orignames[carbon[i]]||orignames["\\"+carbon[i]]||({}); |
| } |
| DEBUGVAR(carbon); |
| write("Abgesandt an: "+implode(unify_array(map(receivers,#'capitalize)),", ")+"\n");//'))); |
| } |
| for (i=sizeof(oldcarbons);i--;) |
| if (oldcarbons[i][0]=='\\') |
| oldcarbons[i]=oldcarbons[i][1..]; |
| oldcarbons=oldcarbons-receivers; |
| if (sizeof(oldcarbons)) { |
| write("Empfaenger unbekannt: "+implode(map(oldcarbons,#'capitalize),", ")+"\nIrgendjemand wirft Dir den zurueckgekommenen Brief zu.\n");//'))) |
| send_mail(oldcarbons); |
| } |
| |
| message=receiver=carbon=subject=0; |
| if (directflag) { |
| if (directflag==1) remove(); // 1: Direktmodus, 2: non-interactive |
| return; |
| } |
| return input(); |
| } |
| |
| |
| static varargs string* send_mail(mixed back) { |
| mixed *mail; |
| |
| mail=allocate(9); |
| |
| #ifdef DEBUG |
| DEBUGVAR(receiver); |
| DEBUGVAR(carbon); |
| #endif |
| |
| if (!pointerp(carbon) || !sizeof(carbon)) carbon=0; |
| mail[MSG_FROM]=this_player()->query_real_name(); |
| mail[MSG_SENDER]=office_name; |
| mail[MSG_RECIPIENT]=(back ? mail[MSG_FROM] : receiver); |
| mail[MSG_CC]=(back ? 0 : carbon); |
| #ifdef MAIL_SUPPORT_BCC |
| mail[MSG_BCC]=blindcarbon; |
| #else |
| mail[MSG_BCC]=0; |
| #endif |
| |
| mail[MSG_SUBJECT]=(back ? "Zurueck! Empfaenger unbekannt: "+implode(back,", ") : subject); |
| mail[MSG_DATE]=ctime(time()); |
| mail[MSG_ID]="MorgenGrauen:"+time(); |
| mail[MSG_BODY]=message; |
| return MAILDEMON->DeliverMail(mail,NO_SYSTEM_ALIASES|NO_USER_ALIASES); |
| } |
| |
| varargs void do_mail(mixed str,string titel,string text) { |
| // text und titel angegeben: versende Text, keine weiteren Taetigkeiten. |
| |
| int i; |
| int silent; |
| |
| if (name) |
| return; /* security flag :-) */ |
| |
| if (!this_interactive()) |
| return; |
| |
| if (!text) { |
| name = geteuid(this_interactive()); |
| move(this_interactive(), M_NOCHECK); |
| if (!name) |
| remove(); |
| } |
| |
| aliases = Read_mailrc(ALIASFILE(geteuid(this_interactive())))+ |
| Read_mailrc(SYSALIAS); |
| |
| int display_limit; |
| if (str) |
| { |
| str = lower_case(str); |
| |
| // Eingabestring zerlegen, um die Elemente der Reihe nach parsen zu |
| // koennen. |
| string* params = explode(str, " "); |
| string* recipients = ({}); |
| |
| /* Ueber alle Argumente laufen und auf Verwendbares pruefen. |
| Muss for() sein, damit wir zwischendrin mittels p++ Eintraege |
| ueberspringen koennen. |
| Gueltige Argumente sind -show [<zahl>|zeilen], -silent, |
| Empfaengerliste. |
| Wenn hinter -show irgendwas kommt, das weder Integer noch "zeilen" |
| ist, wird es verworfen. |
| Wenn irgendwelche Empfaenger angegeben sind, wird auf jeden Fall |
| an write_mail() weitergegeben, egal was sonst fuer Argumente |
| dabeiwaren. Dies ist Absicht, damit man sich z.B. ein Alias |
| "mail -show 20 $*" bauen kann, das ohne weitere Angaben den |
| Posteingang oeffnet, aber eine neue Mail erstellt, wenn man dahinter |
| einen Empfaenger angibt. Auf diese Weise kann man einen im Alias |
| eingestellten Defaultwert bei der Eingabe des Befehls immer noch |
| mit -silent oder einer anderen Zahl ueberschreiben. */ |
| int p; |
| for(p=0; p<sizeof(params); p++) |
| { |
| // Wenn das Argument -silent ist, Flag setzen. |
| if (params[p] == "-silent") |
| { |
| display_limit = 0; |
| silent = 1; |
| } |
| // Wenn es -show ist, checken wir ob das Array noch ein weiteres |
| // Element enthaelt und wenn ja, werten wir es aus und |
| else if (params[p] == "-show") |
| { |
| // hat das Array noch ein Element nach -show? |
| if (sizeof(params) >= p+2) |
| { |
| // wenn ja, ist es ein String ungleich Leerstring? |
| if (sizeof(params[p+1])) |
| { |
| string howmany = params[p+1]; |
| // "zeilen" zuerst checken, weil das sonst im naechsten Check |
| // auch zu silent = 1 fuehren wuerde. |
| if (howmany == "zeilen") |
| display_limit = this_player()->QueryProp(P_SCREENSIZE); |
| // Kann man es in ein Integer >0 wandeln? |
| // Wenn 0 rauskommt, wurde entweder "-show 0" angegeben, oder |
| // ein ungueltiger Parameter. Beides interpretieren wir als |
| // "silent". |
| else if (to_int(howmany) == 0) |
| silent = 1; |
| // Alle anderen Ergebnisse werden als Zeilenlimit fuer die |
| // Anzeige interpretiert. |
| else |
| display_limit = to_int(howmany); |
| } |
| // Argumente nach -show werden in jedem Fall nicht nochmal |
| // verarbeitet, d.h. ein Schleifendurchlauf wird uebersprungen. |
| p++; |
| } |
| } |
| // Alles andere duerfte dann wohl ein Adressat sein. |
| else |
| { |
| recipients += ({params[p]}); |
| } |
| } |
| |
| // Wenn wir potentielle Empfaenger identifiziert haben, bauen wir den |
| // Argumentstring neu zusammen, damit wir ihn spaeter an write_mail() |
| // uebergeben koennen. |
| if(sizeof(recipients)) |
| { |
| str = implode(recipients, " "); |
| directflag = 1; |
| if (text) |
| { |
| if (this_interactive()!=this_player()) |
| return 0; |
| if (!TRUSTED(previous_object())) |
| return write(break_string( |
| "WARNUNG!!! Objekt "+object_name(previous_object())+" versucht, " |
| "Mail mit Deinem Absender zu versenden! Bitte Erzmagier oder " |
| "Loco verstaendigen.",78)+"\n"); |
| directflag = 2; |
| return write_mail(str, titel, text); |
| } |
| directflag = 1; |
| return write_mail(str); |
| } |
| } |
| |
| update(0,1); |
| if (!pointerp(folders) || sizeof(folders)!=2 || sizeof(folders[0])==0) { |
| write("Du hast im Moment keine Post !\n"); |
| folders=({({}),({})}); |
| } |
| write("Du hast "+sizeof(folders[0])+" Ordner, Liste mit 'i'.\n"); |
| |
| if(!silent) |
| { |
| ListContent(display_limit); |
| } |
| |
| write("Gesamtgroesse Deines Postfachs: "+ |
| (i=(file_size(MAILFILEO(name))+512)/1024)+" KB.\n"); |
| // Kleiner Hack als Uebergangsloesung, weil ich die dumme Warnung |
| // nicht mehr sehen kann. ;^) |
| // 22.10.2000, Tiamak |
| if(IS_ARCH(this_interactive())) i=0; |
| |
| // |
| // Kleiner Hack, damit Regionsmitarbeiter und groessere Magier |
| // bei ihren Gebietswartungen nicht staendig mit nervigen |
| // Meldungen belaestigt werden: |
| // |
| // 2005-01-10, Zook |
| if (query_wiz_level(this_interactive()) > DOMAINMEMBER_LVL) { |
| if (i>700) |
| write("*************************************************************\n" |
| "* Dein Postfach ist zu gross! Bitte versuche aufzuraeumen *\n" |
| "* und damit die Groesse zu reduzieren. Grosse Postfaecher *\n" |
| "* verursachen unnoetiges Lag fuer die Spieler. *\n" |
| "*************************************************************\n"); |
| i=0; |
| } |
| |
| if (i>500) // Extra-Warnung fuer Catweazle |
| // man koennte natuerlich auch eine Channel-Meldung ausspucken |
| // mit dem Hinweis, wer das aktuelle Lag verursacht... vielleicht |
| // ab 800 KB? ;-) |
| write("*****************************************************************\n" |
| "* Dein Postfach hat eine absolut unakzeptable Groesse erreicht. *\n" |
| "* Uebergrosse Postfaecher verursachen unnoetiges Lag fuer alle! *\n" |
| "* Bitte raeume es dringend auf, d.h. loesche alle Briefe, die *\n" |
| "* Du nicht _unbedingt_ benoetigst, oder lager sie aus und *\n" |
| "* loesche sie anschliessend. Hauptsache, weg damit. *\n" |
| "*****************************************************************\n"); |
| else if (i>300) // Warnung fuer bestimmte Magier und Seher ab 300 KB |
| write("WARNUNG! Dein Postfach hat eine bedenkliche Groesse erreicht.\n" |
| "Beachte, dass uebergrosse Postfaecher nicht nur unnoetig Speicher, sondern\n" |
| "insbesondere auch Rechenzeit verbrauchen und damit groesseres Lag verursachen\n" |
| "koennen. Du solltest also dringend aufraeumen und alle nicht unbedingt\n" |
| "notwendigen Briefe loeschen (evtl. natuerlich vorher auslagern.\n"); |
| else if (i>200) // Hinweis fuer andere. |
| write("Der Postbeamte macht dich darauf aufmerksam, dass Dein Postfach bereits\n" |
| "ziemlich voll ist und Du dringend einmal aufraeumen solltest.\n"); |
| else if (i>100) // Hinweis fuer andere. |
| write("Der Postbeamte macht dich darauf aufmerksam, dass Dein Postfach\n" |
| "relativ voll ist.\n"); |
| |
| |
| if ((i=FWSERV->QueryForward(name))!=name) |
| write("Du hast einen Nachsendeauftrag gestellt, Deine Post wird an\n" |
| +i+" weitergeleitet.\n"); |
| return input(); |
| } |
| |
| |
| static void MediumHelpPage() { |
| if (sizeof(folders[0])) |
| write("Aktueller Ordner ist \""+folders[0][akt_folder]+"\"\n"); |
| write("\n\ |
| Brief <nr> lesen '<nr>' (lies <nr>)\n\ |
| Aktueller / naechster / letzter Brief '.' / '+' / '-'\n\ |
| Brief schreiben 'm <name>' (schreibe)\n\ |
| Brief beantworten 'r [nr]' (beantworte)\n\ |
| Gruppenantwort an alle Empfaenger 'g [nr]' (gruppe)\n\ |
| Brief(e) loeschen 'd [nummern]' (loesche)\n\ |
| Brief(e) weitersenden 'f [nummern] <name>' (weiter)\n\ |
| Weitersenden plus eigenen Text 'F [nr] <name>' (Weiter)\n\ |
| Brief(e) in anderen Ordner verschieben 'v [nummern] <ordner>' (verschiebe)\n\ |
| Mails in diesem Ordner listen 'l' (oder nichts) (anzeigen)\n\ |
| Aktuellen Ordner wechseln 'c <ordner>' (oeffne)\n\ |
| Neuen Ordner anlegen 'n <ordnername>' (erzeuge)\n\ |
| Leeren Ordner loeschen 'e <ordner>' (entferne)\n\ |
| Alle Ordner anzeigen 'i' (ordner)\n\ |
| "+ (IS_WIZARD(this_player()) ? "\ |
| Brief(e) speichern in Datei 's [nummern]' (speichere)\n\ |
| "+SAVEFILENAME+"\n" : "")+ "\ |
| Mailaliase anzeigen 'a' (aliase)\n\ |
| Verfuegbare Kommandos zeigen '?' oder 'h'\n\ |
| Postmenue verlassen 'q'\n\ |
| Kommando <cmd> ausfuehren '!<cmd>'\n\ |
| [nummern] bedeutet: [nr|nr-nr [nr|nr-nr ...]]. (Liste von Nr und Bereichen)\n\ |
| Bei der Langform reicht es, die ersten 4 Zeichen eines Kommandos anzugeben.\n\ |
| Falls ein Befehl (z.B. \'v\' nicht funktioniert, pruefe bitte, ob dies ein \n\ |
| clientseitiges Makro bei Dir ist.\n\ |
| "); |
| return input(); |
| } |
| |
| static varargs int GetFolders(int nocondflag) { |
| // nocondflag: no condition, unbedingt neuladen |
| |
| // Cache-Verwaltung endlich funktionsfaehig [251196] |
| // IDEE: Uhrzeit & Groesse untersuchen, ausserdem nach Verschieben neuladen. |
| // Auch nach automatischem Verschieben (unread -> newmail)! |
| |
| |
| // write("DEBUG: GetFolders called, old date "+folder_date+", old size "+folder_size+", nocondflag="+nocondflag+"\n"); |
| if (!nocondflag && |
| file_time(MAILFILEO(name))==folder_date && |
| file_size(MAILFILEO(name))==folder_size) return 0; |
| |
| if (!restore_object(MAILFILE(name))) folders=({({}),({})}); |
| folder_date=file_time(MAILFILEO(name)); |
| folder_size=file_size(MAILFILEO(name)); |
| if (!pointerp(folders) || sizeof(folders)!=2) folders=({({}),({})}); |
| // write("DEBUG: GetFolders finished, new date "+folder_date+", new size "+folder_size+"\n"); |
| return 1; |
| } |
| |
| static varargs void update(int directflag,int nocondflag) { |
| // directflag: Mailer wird im Direktmodus betrieben |
| // nocondflag: Unbedingt neuladen |
| |
| int i,j,k,newletters; |
| mixed *ignored; |
| |
| if (!GetFolders(nocondflag)) return; // es hat sich nix getan |
| |
| if (akt_nr<1) akt_nr=1; |
| |
| DEBUGVAR(akt_folder); |
| |
| if (akt_folder>=sizeof(folders[0]) || akt_folder<0) { |
| akt_folder=member(folders[0], "newmail"); |
| if (akt_folder==-1) { |
| MAILDEMON->MakeFolder("newmail",name); |
| GetFolders(1); |
| DEBUGVAR(folders[0]); |
| akt_folder=member(folders[0], "newmail"); |
| } |
| if (!directflag && akt_folder!=-1) write("Ordner 'newmail' aufgeschlagen.\n"); |
| } |
| |
| // if (!pointerp(folders)) return write("ERROR: folders no array in update\n"); // Kann eigentlich nicht vorkommen |
| if (sizeof(folders[0]) && akt_nr>sizeof(folders[1][akt_folder])) |
| akt_nr=sizeof(folders[1][akt_folder]); |
| j=member(folders[0], "unread"); |
| if (j==-1) return; |
| newletters=0; |
| |
| // Testweise eine neue Version, die aber voraussetzt, dass die Position von |
| // unread in der Folderliste von /secure/mail waehrend der Aktion |
| // nicht veraendert wird. |
| // alt ausgeklammert, ausserdem ueberall 0 statt k |
| // k=0; |
| // Neue Version wieder testweise drin |
| |
| // while (j != -1 && pointerp(folders[1][j]) && sizeof(folders[1][j])>0) { |
| for (k=0;k<sizeof(folders[1][j]);k++) { |
| |
| // write("DEBUG: j="+j+"\n"); |
| |
| if (pointerp(ignored=this_player()->QueryProp(P_IGNORE)) && |
| member(ignored, lower_case(folders[1][j][k][MSG_FROM]+".mail"))>=0) { |
| mixed msg; |
| msg=folders[1][j][k]; |
| write("Du laesst einen Brief von "+capitalize(msg[MSG_FROM])+ |
| " unbesehen zurueckgehen.\n"); |
| msg[MSG_BODY]=this_player()->name()+" \ |
| hat diesen Brief ungeoeffnet an Dich zurueckgehen lassen\n\ |
| und moechte nicht mehr von Deinen Briefen belaestigt werden.\n\ |
| Titel: "+msg[MSG_SUBJECT]+"\n\ |
| ------ Inhalt: ------------------------\n"+ |
| msg[MSG_BODY]; |
| msg[MSG_RECIPIENT]=msg[MSG_FROM]; |
| msg[MSG_SUBJECT]="Annahme verweigert - zurueck an Absender"; |
| msg[MSG_CC]=0; |
| msg[MSG_BCC]=0; |
| MAILDEMON->DeliverMail(msg,NO_SYSTEM_ALIASES|NO_USER_ALIASES); |
| if (find_player(msg[MSG_RECIPIENT])) |
| tell_object(find_player(msg[MSG_RECIPIENT]), |
| "Ein Postreiter ruft Dir aus einiger Entfernung leicht sauer zu, dass er einen\nzurueckgekommenen Brief fuer Dich hat.\n"); |
| MAILDEMON->RemoveMsg(0,j,name); |
| } else { |
| // Testweise durch DeleteUnreadFolder ersetzt (080297) |
| #ifndef MAILDEMON0297 |
| MAILDEMON->MoveMsg(0, j, "newmail", name); |
| #endif |
| newletters++; |
| } |
| // GetFolders(1); |
| // j=member_array("unread",folders[0]); |
| // Letzte 2 Zeilen in "neuer" Version ersatzlos gestrichen |
| } |
| |
| #ifdef MAILDEMON0297 |
| MAILDEMON->DeleteUnreadFolder(name); |
| #else |
| MAILDEMON->RemoveFolder("unread",name); |
| #endif |
| if (newletters) { |
| if (office_name=="mpa Kurierdienst") |
| write(break_string("Ein Kurier sagt \"Tach, Post!\", drueckt Dir "+ |
| ((newletters==1) ? "einen neuen Brief" : newletters+" neue Briefe") |
| +" in die Hand und verschwindet wieder.\n",78)); |
| else |
| write("Du siehst, wie ein Postbeamter "+ |
| ((newletters==1) ? "einen neuen Brief" : newletters+" neue Briefe") |
| +" in Dein Fach legt.\n"); |
| } |
| GetFolders(1); // jetzt ohne unread, damit im endgueltigen Zustand. |
| while (akt_folder>=sizeof(folders[0])) akt_folder--; |
| if ((!akt_nr)&&sizeof(folders[1][akt_folder])) akt_nr=1; |
| } |
| |
| // MSG_TIME enthaelt leider einen Datumsstring, so dass wir die MSG_ID |
| // verwenden, um die Zeit daraus zu ermitteln. Die MSG_ID hat immer das |
| // Format MUDNAME+":"+time(). |
| private string msgIDtoTime(string msg_id) { |
| int msg_time; |
| string unused; |
| // Damit das auch dann funktioniert, wenn man die Mailfolder aus dem |
| // Livemud im Testmud einliest, das ja ggf. einen anderen Namen hat, |
| // verwenden wir einen generischen Suchstring. Das Mud sollte dann aber |
| // keinen : im Namen haben. |
| if (sscanf(msg_id, "%s:%d", unused, msg_time) == 2) |
| return strftime("%d.%m.%Y", msg_time); |
| else |
| return "unbekannt"; |
| } |
| |
| static varargs void ListContent(int limit) { |
| update(); |
| |
| if (!pointerp(folders) || sizeof(folders) != 2 || |
| !pointerp(folders[0]) || !sizeof(folders[0])) { |
| write("Du hast keinen einzigen Ordner!\n"); |
| return; |
| } |
| |
| write("Ordner "+folders[0][akt_folder]+": "); |
| if (!pointerp(folders[1]) || akt_folder >= sizeof(folders[1]) || |
| !pointerp(folders[1][akt_folder])) { |
| write("Dieser Ordner ist leer.\n"); |
| return; |
| } |
| |
| int mailcount = sizeof(folders[1][akt_folder]); |
| write(sprintf("%d Brief%s\n", mailcount, mailcount!=1 ? "e" : "")); |
| |
| // Wieviele Zeichen muessen wir fuer die fortlaufenden Mail-Nummern |
| // reservieren? Dazu errechnen wir die Anzahl Ziffern der Arraygroesse. |
| int num_width = sizeof(to_string(mailcount)); |
| // 4 Zeichen muessen reichen, damit sind immerhin 9999 Mails numerierbar. |
| num_width = min(4, num_width); |
| |
| int sender_width; |
| string sender_name; |
| // Feldbreite fuer die Absenderangabe ermitteln. Wird weiter unten fuer |
| // die Anzeige der Mails benoetigt, um das Namensfeld dynamisch |
| // einzustellen. Dies soll helfen, mehr vom Subject anzeigen zu koennen. |
| // Leider muessen wir dazu einmal extra ueber die Liste laufen. |
| int i; |
| if (limit) { |
| limit = max(mailcount - limit, 0); |
| } |
| for (i = limit ; i < mailcount ; i++) { |
| sender_name = folders[1][akt_folder][i][MSG_FROM]; |
| if (sizeof(sender_name) > sender_width) |
| sender_width = sizeof(sender_name); |
| // Wenn wir schon die max. Namenslaenge fuer Spieler erreicht haben, |
| // muss der Rest nicht mehr durchlaufen werden. |
| if (sender_width >= 11) { |
| // Groesse beschraenken; es kann sein, dass alte Mailboxen noch Mails |
| // von extern enthalten, und deren Mailadressen sprengen dann das |
| // Format. |
| sender_width = min(11, sender_width); |
| break; |
| } |
| } |
| |
| // Subject-Breite anpassen, je nach Groesse der anderen dynamischen Felder. |
| // sender_width ist max 11, num_width ist max 4. |
| int subject_width = 46+(11-sender_width)+(4-num_width); |
| |
| /* Format der Zeile. Wir bauen dynamische Feldbreiten an den Stellen ein, |
| wo es sinnvoll ist, und haben um den Mailzaehler herum zwei String- |
| Felder, die die Markierung fuer die aktuell bearbeitete Mail aufnehmen. |
| Absender und Betreffzeile werden durch den : im Formatcode |
| abgeschnitten. Es muss insbesondere beim Absender der : verwendet |
| werden, damit laengere Namen abgeschnitten werden, bei kuerzeren aber |
| korrekt mit Leerzeichen aufgefuellt wird. Verwendet man stattdessen |
| den ., macht sprintf() das nicht. |
| |
| Beispiel einer Zeile mit markierter Mail: |
| [125:](Spielername, 18.12.2019) Test |
| ^_^ ^---------^ ^--^ |
| | | | |
| num_width sender_width subject_width */ |
| string lineformat = "%s%"+num_width+"d:%s"+ // Mail-Zaehler |
| "(%:"+sender_width+"s, %10s) "+ // Absender + Datum |
| "%:-"+subject_width+"s\n"; // Betreffzeile |
| |
| for (i = limit ; i < mailcount ; i++) { |
| // Leeres Subject wird als 0 gespeichert. Falls das zutrifft, wird das |
| // hier beruecksichtigt. |
| string subject = folders[1][akt_folder][i][MSG_SUBJECT]; |
| if (!stringp(subject) || !sizeof(subject)) |
| subject = "<kein Betreff>"; |
| write(sprintf(lineformat, |
| (i+1==akt_nr) ? "[" : " ", |
| i+1, |
| (i+1==akt_nr) ? "]" : " ", |
| capitalize(folders[1][akt_folder][i][MSG_FROM]), |
| msgIDtoTime(folders[1][akt_folder][i][MSG_ID]), |
| subject |
| )); |
| } |
| return; |
| } |
| |
| |
| static void ChangeFolder(mixed x) { |
| if (!(x=GetFolderName(x))) return; |
| akt_folder=member(folders[0],x); |
| write("Du oeffnest den Ordner '"+x+"'.\n"); |
| if (akt_nr<=0) akt_nr=1; |
| if (akt_nr>=sizeof(folders[1][akt_folder])) |
| akt_nr=sizeof(folders[1][akt_folder]); |
| ListContent(); |
| } |
| |
| |
| static void ListFolders() { |
| int i; |
| update(); |
| write("Du hast "+sizeof(folders[0])+" Ordner:\n"); |
| for (i=0;i<sizeof(folders[0]);i++) |
| write(sprintf("%2s%3d: %-20s(%3d Briefe)\n", |
| ((i==akt_folder)?"->":" "), |
| i+1,folders[0][i],sizeof(folders[1][i]))); |
| write("Gesamtgroesse Deines Postfachs: "+ |
| ((file_size(MAILFILEO(name))+512)/1024)+" KB.\n"); |
| } |
| |
| |
| static void MakeFolder(string s) { |
| int ret; |
| if (sscanf(s,"%d",ret)||s[0]<'a'||s[0]>'z') return |
| write("Um Probleme zu vermeiden, duerfen Ordner nicht mit Nummern oder Sonderzeichen\nbezeichnet werden.\n"); |
| if (s=="newmail"||s=="unread") return |
| write("Die Ordnernamen 'newmail' und 'unread' sind reserviert.\n"); |
| ret=MAILDEMON->MakeFolder(s, name); |
| if (ret==1) write("Ok, neuer Ordner mit Namen "+s+" angelegt.\n"); |
| else write("Ein Ordner mit dem Namen existiert bereits.\n"); |
| return; |
| } |
| |
| |
| static int RemoveFolder(string x) { |
| int ret; |
| if (!x) return -42; // folder existiert nicht, Fehlermeldung bereits geg. |
| // if (intp(x)) x=folders[0][x]; |
| |
| if (x=="newmail") return |
| write("Der Ordnername 'newmail' ist reserviert.\nDieser Ordner darf nicht geloescht werden.\n"),-43; |
| |
| ret=MAILDEMON->RemoveFolder(x, name); |
| switch (ret) { |
| case 1: write("Ordner "+x+" geloescht.\n"); break; |
| case -1: write("Kein solcher Ordner.\n"); break; |
| case 0: write("Der Ordner war nicht leer - nicht geloescht.\n"); break; |
| default: write("Fehler Nummer "+ret+" - was auch immer das heisst...\n"); break; |
| } |
| return ret; |
| } |
| |
| |
| static varargs int DeleteMessage(int *nrs) { |
| int ret,x; |
| mixed m; |
| if ( sizeof(nrs) > 15 ) LagWarning(); |
| |
| for (x=sizeof(nrs)-1;x>=0;x--) { |
| write("Loesche Brief "+(nrs[x]+1)+": "); |
| ret=MAILDEMON->RemoveMsg(nrs[x], akt_folder, name); |
| switch(ret) { |
| case 1: write("Ok.\n"); break; |
| case 0: write("Kein solcher Brief im aktuellen Ordner.\n"); break; |
| case -1:write("Kein aktueller Ordner.\n"); update(); return ret; |
| default: write("MAILDEMON: Interner Fehler Nummer "+ret+"!\n"); break; |
| } |
| } |
| |
| return ret; |
| } |
| |
| //" |
| |
| static int MoveMessage(mixed msg,mixed fol) { |
| int ret,i; |
| |
| for (i=0;i<sizeof(msg);i++) { |
| ret=MAILDEMON->MoveMsg(msg[i]-i, akt_folder, fol, name); |
| switch(ret) { |
| case 1: |
| write("Brief "+(msg[i]+1)+" verschoben nach "+fol+".\n"); |
| break; |
| case 0: |
| write("So viele Briefe sind nicht im aktuellen Ordner.\n"); return 0; |
| case -1: |
| write("Seltsamer Fehler - duerfte eigentlich nicht passieren:\n'Kein aktueller Ordner.'\n"); return -1; |
| case -3: |
| write("Den Zielordner "+fol+" gibt es nicht!\n"); return ret; |
| default: |
| write("MAILDEMON: MoveMsg Interner Fehler "+ret+". Bitte Erzmagier verstaendigen.\n"); return ret; |
| } |
| } |
| if (akt_nr>=sizeof(folders[1][akt_folder])) |
| akt_nr=sizeof(folders[1][akt_folder])-1; |
| |
| return ret; |
| } |
| |
| |
| static varargs int Reply(int nr,int group) { |
| mixed to,dummy; |
| if (!pointerp(folders)||!pointerp(folders[0])|| |
| sizeof(folders[0])<=akt_folder) { |
| write("Seltsamer Fehler: Kein aktueller Ordner!\n"); |
| return 0; |
| } |
| if (nr<0 || !pointerp(folders[1][akt_folder]) || |
| sizeof(folders[1][akt_folder])<=nr){ |
| write("Einen Brief mit Nummer "+(nr+1)+" gibt es in diesem Ordner nicht!\n"); |
| return 0; |
| } |
| |
| if (sscanf("\n"+lower_case(folders[1][akt_folder][nr][MSG_BODY]), |
| "%s\nreply-to:%s\n",dummy,to)==2) { // Reply-to gesetzt |
| while (to[0]==' ') to=to[1..]; // ueberschuessige Leerzeichen entfernen |
| while (to[<1]==' ') to=to[0..<2]; |
| } |
| else |
| to=folders[1][akt_folder][nr][MSG_FROM]; |
| if (group) // Gruppenantwort |
| to=({to, |
| folders[1][akt_folder][nr][MSG_RECIPIENT]})+ |
| (pointerp(folders[1][akt_folder][nr][MSG_CC]) ? folders[1][akt_folder][nr][MSG_CC] : ({})) |
| -({name}); |
| #ifdef DEBUG |
| DEBUGVAR(name); |
| DEBUGVAR(to); |
| #endif |
| write_mail(to,GetReTitle(folders[1][akt_folder][nr][MSG_SUBJECT])); |
| return 1; |
| } |
| |
| |
| static varargs int Forward(mixed to,mixed nr,int appendflag) { |
| mixed msg; |
| if (!pointerp(folders)||!pointerp(folders[0])|| |
| sizeof(folders[0])<=akt_folder) { |
| write("Seltsamer Fehler: Kein aktueller Ordner!\n"); |
| return 0; |
| } |
| if (nr<0 || !pointerp(folders[1][akt_folder]) || |
| sizeof(folders[1][akt_folder])<=nr){ |
| write("Nicht so viele Briefe in diesem Ordner!\n"); |
| return 0; |
| } |
| to=process_names(to); |
| receiver=to[0]; |
| carbon=to[1..]; |
| subject="Fw: "+folders[1][akt_folder][nr][MSG_SUBJECT]; |
| message="Weitergesendeter Brief, urspruenglich von: "+ |
| folders[1][akt_folder][nr][MSG_FROM]+"\n\ |
| -----------------------------\n\ |
| "+folders[1][akt_folder][nr][MSG_BODY]+"\ |
| -----------------------------\n"; |
| if (!appendflag) return get_carbon_copy(0),1; |
| else { |
| write("Text kann angehaengt werden\n"); |
| get_subject(subject,message); |
| } |
| return 1; |
| } |
| |
| |
| |
| static int ForwardArea(mixed to,int * nrs) { |
| mixed msg; |
| |
| if (!sizeof(nrs)) return 0; |
| if (sizeof(nrs)==1) return Forward(to,nrs[0]); |
| if (sizeof(nrs)>15) LagWarning(); |
| |
| to=process_names(to); |
| receiver=to[0]; |
| carbon=to[1..]; |
| subject="Fw: Gesammelte Briefe ("+dtime(time())[5..23]+")"; |
| message=""; |
| for (i=0;i<sizeof(nrs);i++) { |
| write("Brief "+(nrs[i]+1)+": "); |
| message+=Message2string(nrs[i])+ |
| "----------------------------------------------------------------------\n"; |
| write("Angehaengt.\n"); |
| } |
| /* |
| if (!appendflag) { |
| */ |
| return get_carbon_copy(0),1; |
| /* } |
| else { |
| write("Text kann angehaengt werden\n"); |
| get_subject(subject,message); |
| } |
| return 1; |
| */ |
| } |
| |
| //---------- |
| |
| |
| static int ReadMessage(int nr) { |
| if (nr<sizeof(folders[1][akt_folder]) && nr>=0) |
| akt_nr=nr+1; |
| message=Message2string(nr); |
| if (!message) return 0; |
| this_player()->More(message,0,#'input); //') |
| return 1; |
| } |
| |
| |
| static string Message2string(int nr) { |
| mixed letter; |
| string message; |
| int x; |
| if (!pointerp(folders)||!pointerp(folders[0])|| |
| sizeof(folders[0])<=akt_folder){ |
| write("Seltsamer Fehler: Kein aktueller Ordner!\n"); |
| return 0; |
| } |
| if (!pointerp(folders[1][akt_folder]) || |
| sizeof(folders[1][akt_folder])<=nr || |
| nr<0) { |
| write("Diese Nummer gibt es in diesem Ordner nicht!\n"); |
| return 0; |
| } |
| letter=folders[1][akt_folder][nr]; |
| message= |
| "Absender: "+capitalize(letter[MSG_FROM])+"\n"+ |
| ((letter[MSG_FROM]==letter[MSG_SENDER]) ? "" : |
| "Abgesandt aber von: "+capitalize(letter[MSG_SENDER])+"\n") + |
| "An: "+capitalize(letter[MSG_RECIPIENT]); |
| if (stringp(letter[MSG_CC]) && letter[MSG_CC]!="" || |
| pointerp(letter[MSG_CC]) && sizeof(letter[MSG_CC])) { |
| message+="\nCc: "; |
| if (!pointerp(letter[MSG_CC])) message+=capitalize(letter[MSG_CC]); |
| else message+=implode(map(letter[MSG_CC],#'capitalize),", ");//')) |
| } |
| message+="\nDatum: "+letter[MSG_DATE]+"\n"+ |
| /* Sinnlos, oder? "Id: "+letter[MSG_ID]+"\n"+ */ |
| "Titel: "+letter[MSG_SUBJECT]+"\n\n"+ |
| letter[MSG_BODY]+"\n\n"; |
| return message; |
| } |
| |
| |
| static void LagWarning() { |
| write("\ |
| WARNUNG!!! Diese Aktion kann sehr lange benoetigen. Bitte sparsam verwenden,\n\ |
| um das Lag fuer alle ertraeglich zu halten. Falls die Aktion mit einem\n\ |
| Fehler abbricht, waren es wahrscheinlich zu viele Briefe auf einmal.\n\ |
| Dann kannst Du mit \"mail\" wieder in das Mailmenu einsteigen und solltest\n\ |
| es mit weniger Briefen versuchen.\n"); |
| } |
| |
| |
| static varargs int SaveMessage(int * nrs) { |
| int x,nr; |
| string rest; |
| mixed letter; |
| |
| if (!IS_WIZARD(this_player())) { |
| write("Das koennen nur Magier!\n"); |
| return 0; |
| } |
| if (!sizeof(nrs)) { |
| write("Speichere nichts.\n"); |
| return 1; |
| } |
| |
| if ( sizeof(nrs) > 15 ) LagWarning(); |
| |
| for (nr=0;nr<sizeof(nrs);nr++) { |
| write("Speichere Brief "+(nrs[nr]+1)+": "); |
| letter=Message2string(nrs[nr]); |
| letter+="----------------------------------------------------------------------\n"; |
| if (!letter) { |
| write("Speichern unmoeglich.\n"); |
| return 0; |
| } |
| if (!write_file(SAVEFILENAME, letter)) |
| write("Brief zu lang!\n"); |
| else |
| write("Ok.\n"); |
| } |
| write("Speichern nach "+SAVEFILENAME+" fertig.\nBitte denk dran, diese Datei wieder zu loeschen!\n"); |
| return 1; |
| } |
| |
| // {'} |
| |
| static void ListAliases() { |
| mixed a; |
| int i; |
| string s; |
| a=sort_array(m_indices(aliases),#'>); // '); |
| s=( "Definierte Aliase:\n" |
| "d.xyz = Alle Mitarbeiter der Domain xyz\n" |
| "freunde = Deine Freunde (entsprechend Freundschaftsband)\n" |
| "me = "+(this_player()->QueryProp(P_MAILADDR))+"\n"); |
| for (i=0;i<sizeof(a);i++) |
| if (strstr(aliases[a[i]],"@")==-1) s+=sprintf("%-12s = %s\n",a[i],aliases[a[i]]); |
| write(s); |
| } |
| |
| |
| |
| /* ------ Das Mailmenue --------------------------------------------------*/ |
| |
| |
| static void mail_cmds(string str) { |
| |
| string *strargs; |
| int i,nrargs; |
| |
| update(); |
| |
| if (!str || str=="" || !(nrargs=sizeof(strargs=old_explode(str[0..0]+lower_case(str[1..])," ")))) { |
| ListContent(); |
| return input(); |
| } |
| strargs[0]=strargs[0][0..3]; |
| if (IS_NUMBER(strargs[0])) { |
| strargs=({"lies",strargs[0]}); |
| nrargs=2; |
| } |
| DEBUGVAR(strargs); |
| switch (strargs[0]) { |
| case "q": // quit |
| case "quit": |
| remove(); return; |
| case "?": // Hilfeseite |
| case "hilf": |
| case "h": |
| MediumHelpPage(); |
| return; |
| case "oeff": // change folder |
| case "c": |
| if (nrargs<2) { |
| write("Welchen Ordner willst Du oeffnen (Name, Nummer, +, -)?\n"); |
| break; |
| } |
| ChangeFolder(strargs[1]); |
| break; |
| case "ordn": // list folders |
| case "i": |
| ListFolders(); |
| break; |
| case "anze": // list content |
| case "l": |
| ListContent(); |
| break; |
| case "alia": // list aliases |
| case "a": |
| ListAliases(); |
| break; |
| case "erze": // make new folder |
| case "n": |
| if (nrargs<2) { |
| write("Bitte als Argument einen Namen fuer den neuen Ordner angeben!\n"); |
| break; |
| } |
| MakeFolder(lower_case(strargs[1])); |
| break; |
| case "entf": // delete folder |
| case "e": |
| if (nrargs<2) { |
| write("Bitte als Argument Name oder Nummer des zu loeschenden Ordners angeben.\n"); |
| break; |
| } |
| RemoveFolder(GetFolderName(strargs[1])); |
| break; |
| case "loes": // delete message |
| case "d": |
| if (nrargs==1) DeleteMessage(({akt_nr-1})); |
| else DeleteMessage(GetNumbers(strargs[1..])); |
| break; |
| case "schr": // write mail |
| case "m": |
| if (nrargs<2) { |
| write("Bitte Empfaenger als Argument angeben!\n"); |
| break; |
| } |
| write_mail(strargs[1..]); |
| return; |
| case "vers": // move message to other folder |
| case "verl": |
| case "v": |
| if (nrargs<2 || (nrargs>2 && !IS_NUMBER(strargs[1]))) { |
| write("Syntax: v [nr|nr-nr [nr|nr-nr ...]] <ordnername>|<ordnernr>|+|-\n"); |
| break; |
| } |
| if (nrargs==2) MoveMessage(({akt_nr-1}),GetFolderName(strargs[1])); |
| else MoveMessage(GetNumbers(strargs[1..<2]),GetFolderName(strargs[<1])); |
| update(0,1); // unbedingt neuladen. |
| break; |
| case "bean": |
| case "r": |
| case "grup": |
| case "g": |
| if (nrargs<2) { |
| if (Reply(akt_nr-1,(strargs[0][0]=='g'))) return; |
| break; |
| } |
| if (!IS_NUMBER(strargs[1])) { |
| write("Argumentfehler: Bitte Nummer des Briefes angeben, auf den sich die Antwort\n" |
| "beziehen soll. Ohne Argument bezieht sie sich auf den aktuellen Brief.\n"); |
| break; |
| } |
| if (nrargs>2) { |
| write("Zu viele Argumente. Eine Antwort darf sich nur auf einen Brief beziehen!\n"); |
| break; |
| } |
| if (Reply(to_int(strargs[1])-1,(strargs[0][0]=='g'))) return; |
| break; |
| case "weit": |
| case "f": |
| if (nrargs<2 || |
| (IS_NUMBER(strargs[nrargs-1])&&sizeof(old_explode(strargs[nrargs-1],"@"))==1)) { |
| write("Syntax: f [nr|nr-nr [nr|nr-nr ...]] empfaenger [empf2 ...]\n"); |
| break; |
| } |
| if (!IS_NUMBER(strargs[1])) { |
| if (Forward(strargs[1..],akt_nr-1)) return; |
| } // return, nicht break: input() wird von get_carbon_copy() aufger. |
| else { |
| int pos; // letzte Position, an der eine Nummer steht |
| |
| for (pos=nrargs-1;pos>1&&!IS_NUMBER(strargs[pos]);pos--); |
| if (ForwardArea(strargs[(pos+1)..],GetNumbers(strargs[1..pos]))) |
| return; |
| } |
| break; |
| case "Weit": |
| case "F": |
| if (nrargs<2 || (nrargs==2 && IS_NUMBER(strargs[1]))) { |
| write("Haeh? Bitte so: F [nr] empfaenger\n"); |
| break; |
| } |
| if (!IS_NUMBER(strargs[1])) { |
| if (Forward(strargs[1..],akt_nr-1,1)) return; |
| break; |
| } |
| if (IS_NUMBER(strargs[2])||member(strargs[1],'-')>=0) { |
| write("Argumentfehler: Wenn Du eigenen Text anhaengen willst, darfst Du nur einen\n" |
| "Brief angeben, nicht mehrere.\n"); |
| break; |
| } |
| if (Forward(strargs[2..],to_int(strargs[1])-1,1)) return; |
| break; |
| case "lies": |
| if (nrargs<2) { if (ReadMessage(akt_nr-1)) return; } else |
| if (ReadMessage(to_int(strargs[1])-1)) return; |
| break; |
| case ".": |
| if (ReadMessage(akt_nr-1)) return; |
| break; |
| case "+": |
| if (akt_nr==sizeof(folders[1][akt_folder])) |
| write("Noch weiter vorwaerts gehts nicht!\nMit 'c +' kannst Du den naechsten Ordner oeffnen.\n"); |
| else if (ReadMessage(akt_nr)) return; |
| break; |
| case "-": |
| if (akt_nr==1) |
| write("Noch weiter zurueck gehts nicht!\nMit 'c -' kannst Du den vorhergehenden Ordner oeffnen.\n"); |
| else if (ReadMessage(akt_nr-2)) return; |
| break; |
| case "spei": |
| case "s": |
| if ((nrargs==2 && !IS_NUMBER(strargs[1]))) { |
| write("Syntax: s [nr|nr-nr [nr|nr-nr ...]]\n"); |
| break; |
| } |
| if (nrargs==1) (SaveMessage(({akt_nr-1}))); |
| else (SaveMessage(GetNumbers(strargs[1..]))); |
| break; |
| default: |
| write("Kommando nicht verstanden. Eine Hilfsseite bekommst Du mit 'h'.\n"); |
| break; |
| } |
| return input(); |
| } |
| |
| |
| /*------------------------------------------------------------------------*/ |
| |
| static string prompt() { |
| string path; |
| |
| update(); |
| if (!pointerp(folders)||!pointerp(folders[0])|| |
| sizeof(folders[0])<=akt_folder) |
| path="(kein Ordner)"; |
| else |
| path= "(" + folders[0][akt_folder] + ":" + |
| ( sizeof(folders[1][akt_folder]) ? |
| akt_nr + "/" + sizeof(folders[1][akt_folder]) : |
| "leer") + ")"; |
| return(path + " [Hilfe mit h] => "); |
| } |
| |
| |
| static void input() { |
| //prompt(); |
| input_to("mail_cmds", INPUT_PROMPT, prompt()); |
| return; |
| } |
| |
| |
| static mixed GetAlias(mixed a); |
| |
| #ifdef MAIL_SUPPORT_BCC |
| static mixed RecurseProcessNames(mixed a); |
| #endif |
| |
| |
| static mixed process_names(mixed s) { |
| mixed a1,a2,h; |
| int i; |
| string domain; |
| |
| if (stringp(s)) { |
| a1=explode(regreplace(lower_case(s),","," ",1)," ")-({""}); |
| } |
| else a1=s; |
| a2=({}); |
| foreach(string str: a1) |
| a2+=explode(str,","); |
| |
| a1=({}); |
| |
| // printf("DEBUG ANFANG: %O\n",a2); |
| |
| foreach(string str: a2) { |
| if( !sizeof(str) ) continue; |
| if (sscanf(str,"d.%s",domain)) { |
| h=(get_dir("/d/"+domain+"/*")||({}))-({".",".."}); |
| // h immer ein Array |
| h=filter(h,#'query_wiz_level); |
| if (sizeof(h)) |
| a1+=h; |
| else |
| a1+=({"d."+domain}); |
| } |
| else if (str=="freunde") |
| a1+=("/p/service/tiamak/obj/fbmaster"->get_friends(getuid(this_player()), 8)); |
| else if (str=="me") |
| a1+=({this_player()->QueryProp(P_MAILADDR)}); |
| else if (aliases[str]) |
| a1+=GetAlias(str); |
| #ifdef MAIL_SUPPORT_BCC |
| else if (str[0]=='-') |
| a1+=map(RecurseProcessNames(str[1..]), function string (string x) { |
| return("-"+x);}); |
| #endif |
| else if ( (str[0]>='a' && str[0]<='z') |
| || (sscanf(str,"%s@%s",domain,domain)) |
| || str[0]=='\\') |
| a1+=({str}); |
| } |
| |
| // printf("DEBUG ENDE: %O\n",a1); |
| |
| a1=filter(a1,function int (string x) |
| { return(sizeof(x)>1); } ); |
| |
| return(map(a1,#'lower_case)); |
| } |
| |
| |
| static mixed GetAlias(mixed a) { return process_names(aliases[a]); } |
| #ifdef MAIL_SUPPORT_BCC |
| static mixed RecurseProcessNames(mixed a) { return process_names(a); } |
| #endif |
| |
| |
| static mapping Read_mailrc(string file) { |
| mapping al; |
| int i; |
| mixed ar; |
| string s1,s2; |
| |
| if (!(ar=read_file(file))) { |
| // write(file+" not readable\n"); |
| return ([]); |
| } |
| al=([]); |
| ar=explode(ar,"\n"); |
| for (i=sizeof(ar)-1;i>=0;i--) |
| if (sscanf(ar[i],"%s %s",s1,s2)==2) |
| al+=([s1:s2]); |
| // printf("Got aliases %O",al); |
| return al; |
| } |
| |
| |
| string * unify_array(string * a) { |
| // int i; |
| // for (i=sizeof(a)-1;i>=0;i--) a=a-({a[i]})+({a[i]}); |
| // Rikus 14.02.2001 |
| a=m_indices(mkmapping(a)); |
| return a; |
| } |
| |
| |
| string GetReTitle(string s) { |
| int nr,s2; |
| |
| if (!s) s=""; |
| if (s[0..7]=="Re: Re: ") return "Re^3: "+s[8..]; |
| else if (sscanf(s,"Re^%d: %s",nr,s2)) |
| return "Re^"+(nr+1)+": "+s2; |
| else return "Re: "+s; |
| } |
| |
| |
| int * GetNumbers(mixed s) { |
| int i,h1,h2; |
| mixed ret; |
| |
| if (intp(s)) return ({s-1}); |
| if (stringp(s)) s=({s-1}); |
| if (!pointerp(s)) return 0; |
| |
| ret=({}); |
| |
| for (i=sizeof(s)-1;i>=0;i--) { |
| if (sscanf(s[i],"%d-%d",h1,h2)==2) { |
| if (h2-h1>100) { |
| write("Nicht so viele auf einmal, bitte.\n"); |
| return ({}); |
| } |
| for (h1--;h1<h2;h1++) ret=ret-({h1})+({h1}); |
| } |
| else |
| ret=ret-({h1=to_int(s[i])-1})+({h1}); |
| } |
| ret=sort_array(ret,#'>); //') |
| DEBUGVAR(ret); |
| if (ret[0]<0) { |
| write("Illegale Nummer: "+(ret[0]+1)+", nichts unter 1 bitte!\n"); |
| return ({}); |
| } |
| if (ret[<1]>=sizeof(folders[1][akt_folder])) { |
| write("Illegale Nummer: "+(ret[<1]+1)+", so gross ist dieser Ordner nicht!\n"); |
| return ({}); |
| } |
| return ret; |
| } |
| |
| |
| /* |
| int is_number(string s) { |
| return (s[0]>='0'&&s[0]<='9'); |
| } |
| */ |
| |
| |
| string GetFolderName(mixed fol) { // int oder string. alles andere -> Fehler! |
| mixed h; |
| |
| if (fol=="+") fol=akt_folder+1; |
| if (fol=="-") fol=akt_folder-1; |
| if ((!fol)||(intp(fol))||(IS_NUMBER(fol))) { |
| if (!intp(fol)) fol=to_int(fol)-1; |
| if (fol<0||fol>=sizeof(folders[0])) |
| return write("Einen Ordner mit Nummer "+(fol+1)+" gibt es nicht.\n"),0; |
| return folders[0][fol]; |
| } |
| fol=lower_case(fol); |
| if (sizeof(h=regexp(folders[0],"^"+fol))==1) return h[0]; |
| if (member(folders[0],fol)==-1) |
| return write("Einen Ordner mit Namen "+fol+" hast Du nicht.\n"),0; |
| return fol; |
| } |
| |
| int query_prevent_shadow() { return 1; } |