home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 2 BBS / 02-BBS.zip / muprg110.zip / MUPURGE.CTL < prev    next >
Text File  |  1995-09-09  |  12KB  |  163 lines
  1. ;*****************************************************************************;
  2. ;                                                                             ;
  3. ;   This is a sample control file for MUPURGE / MUPURGEP.                     ;
  4. ;                                                                             ;
  5. ;   MUPURGE(P) is Copyright (c) by Bob Swift, 1995.  All Rights Reserved.     ;
  6. ;                                                                             ;
  7. ;   This control file is to allow you to define the user purge criteria       ;
  8. ;   as well as changing the default operation of the program.  The default    ;
  9. ;   operation is to ignore the first user record (usually the Sysop),         ;
  10. ;   mark the records for deletion (but not remove them from the user file),   ;
  11. ;   use the USER.BBS and USER.IDX files in the current directory, and not     ;
  12. ;   to produce a log file.                                                    ;
  13. ;                                                                             ;
  14. ;   The keywords which are used in this control file are:                     ;
  15. ;                                                                             ;
  16. ;   LOGFILE <filename>                                                        ;
  17. ;   LOGMAX                                                                    ;
  18. ;   USERPATH <path>                                                           ;
  19. ;   CHKFIRST                                                                  ;
  20. ;   PURGE                                                                     ;
  21. ;   DELETE A=<numeric access level> C=<calls> D=<days since last call>        ;
  22. ;                                                                             ;
  23. ;   These are further described below.  Note that any other commands          ;
  24. ;   will be ignored.  Each command must appear on a separate line and         ;
  25. ;   may not be preceded with any characters other than spaces.  Also note     ;
  26. ;   that none of the commands are case sensitive.                             ;
  27. ;                                                                             ;
  28. ;*****************************************************************************;
  29. ;                                                                             ;
  30. ;                                                                             ;
  31. ;   LOGFILE <filename>                                                        ;
  32. ;                                                                             ;
  33. ;   This command allows you to select to log all program activity to a        ;
  34. ;   file.  The filename may include a fully-qualified drive and path          ;
  35. ;   specifier.  If this keyword is omitted, no log file will be written.      ;
  36. ;                                                                             ;
  37. ;                                                                             ;
  38. ;                                                                             ;
  39. ;   LOGMAX                                                                    ;
  40. ;                                                                             ;
  41. ;   This command allows you to select to log all information in a style       ;
  42. ;   compatible with the log files created by Maximus.  If this keyword is     ;
  43. ;   omitted, all logging will be done in standard text format.                ;
  44. ;                                                                             ;
  45. ;                                                                             ;
  46. ;                                                                             ;
  47. ;   USERPATH <path>                                                           ;
  48. ;                                                                             ;
  49. ;   This command allows you to specify the path to the Maximus USER.BBS       ;
  50. ;   and USER.IDX files.  This allows you to run the program without the       ;
  51. ;   files being in the current directory.                                     ;
  52. ;                                                                             ;
  53. ;                                                                             ;
  54. ;                                                                             ;
  55. ;   CHKFIRST                                                                  ;
  56. ;                                                                             ;
  57. ;   This command tells the program to apply the deletion rules to the         ;
  58. ;   first name in the user file.  The default is to ignore the first name     ;
  59. ;   in the file because this is typically the Sysop.                          ;
  60. ;                                                                             ;
  61. ;                                                                             ;
  62. ;                                                                             ;
  63. ;   PURGE                                                                     ;
  64. ;                                                                             ;
  65. ;   This command tells the program to remove all deleted entried from         ;
  66. ;   the output file.  The default is to leave the entries in the file         ;
  67. ;   but mark them as DELETED.                                                 ;
  68. ;                                                                             ;
  69. ;                                                                             ;
  70. ;                                                                             ;
  71. ;   DELETE A=<numeric access level> C=<calls> D=<days since last call>        ;
  72. ;                                                                             ;
  73. ;   This command defines the rules for deleting users from the file.  Each    ;
  74. ;   line must include three parameters (in any order) to identify the         ;
  75. ;   deletion rule.  The parameters are:                                       ;
  76. ;                                                                             ;
  77. ;       A=<number>  which is the numeric access identified in Maximus.        ;
  78. ;                   The rule will be applied to all users with a level        ;
  79. ;                   less than or equal to this access number.                 ;
  80. ;                                                                             ;
  81. ;       C=<number>  which is the number of times the user has called.         ;
  82. ;                   The rule will be applied to all users who have called     ;
  83. ;                   less than or equal to the number of calls indicated.      ;
  84. ;                   If this number is set at zero, then this parameter is     ;
  85. ;                   ignored when applying the rule.                           ;
  86. ;                                                                             ;
  87. ;       D=<number>  which is the number of days allowed since the last        ;
  88. ;                   time the user called.  The rule will be applied to        ;
  89. ;                   all users who have not called within the specified        ;
  90. ;                   number of days.                                           ;
  91. ;                                                                             ;
  92. ;   Note that there must not be any spaces in any of these parameters.        ;
  93. ;   If an invalid DELETE line is entered (one or more incorrect or missing    ;
  94. ;   parameters), the line will be ignored during processing.                  ;
  95. ;                                                                             ;
  96. ;   Each DELETE line is handled separately, and all three parameters must     ;
  97. ;   be met in order for a record to be deleted.  If a record matches ANY      ;
  98. ;   valid DELETE line, it will be deleted.  This allows you to set a          ;
  99. ;   number of different deletion criteria which can vary widely.              ;
  100. ;                                                                             ;
  101. ;   For the programmer types among you, think of the three conditions on      ;
  102. ;   each DELETE line as being ANDed, and the deletion lines themselves        ;
  103. ;   being ORed.  For example:                                                 ;
  104. ;                                                                             ;
  105. ;       DELETE (if)   a=19  (and)  c=0  (and)  d=30                           ;
  106. ;                                                                             ;
  107. ;                           (or)                                              ;
  108. ;                                                                             ;
  109. ;       DELETE (if)   a=19  (and)  c=1  (and)  d=5                            ;
  110. ;                                                                             ;
  111. ;                           (or)                                              ;
  112. ;                                                                             ;
  113. ;       DELETE (if)   a=29  (and)  c=0  (and)  d=60                           ;
  114. ;                                                                             ;
  115. ;                                                                             ;
  116. ;   There are a maximum of 20 DELETE lines allowed.  Some examples of         ;
  117. ;   valid deletion rules are:                                                 ;
  118. ;                                                                             ;
  119. ;       DeLeTe c=0               D=120 a=87                                   ;
  120. ;       DELETE  A=100   C=5     D=30                                          ;
  121. ;                                                                             ;
  122. ;   The following lines are NOT valid, and would be ignored:                  ;
  123. ;                                                                             ;
  124. ;       ; DELETE    A=100   C=5     D=30                                      ;
  125. ;       delete a = 100 c = 5 d = 30                                           ;
  126. ;       DELETE  a=100   C=5     A=30                                          ;
  127. ;       Delete  C=1 D=90                                                      ;
  128. ;       Delete  a=50    c=1     d=0                                           ;
  129. ;       Delete  a=0     c=1     d=90                                          ;
  130. ;       Delete  a=-1    c=1     d=90                                          ;
  131. ;                                                                             ;
  132. ;                                                                             ;
  133. ;*****************************************************************************;
  134.  
  135. ;
  136. ;       Set up the defaults...
  137. ;
  138. ; Note that blank lines and leading spaces are ignored.
  139. ; Note that the USERPATH statement can have a trailing backslash but it is
  140. ; not necessary.
  141. ;
  142.  
  143. ;USERPATH   H:\Max          ;User files in this directory.
  144. LOGFILE     MaxPurge.Log    ;Log activity to file.
  145. LOGMAX                      ;Use Maximus style log file.
  146. ;CHKFIRST                   ;Include first record in check.
  147. ;PURGE                      ;Remove deleted records from file.
  148.  
  149. ;
  150. ;       Now for the deletion rules...
  151. ;
  152.  
  153. DELETE      A=29    C=1     D=30
  154. DELETE      A=99    C=1     D=60
  155. DELETE      A=29    C=0     D=60
  156. DELETE      A=49    C=0     D=90
  157. DELETE      A=89    C=0     D=120
  158. DELETE      A=99    C=0     D=365
  159.  
  160. ;
  161. ;   End of sample MUPURGE / MUPURGEP control file.
  162. ;
  163.