source/mircoders/accesscontrol/AccessControl.java

   1 /*
   2  * Copyright (C) 2001, 2002 The Mir-coders group
   3  *
   4  * This file is part of Mir.
   5  *
   6  * Mir is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * Mir is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with Mir; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  * In addition, as a special exception, The Mir-coders gives permission to link
  21  * the code of this program with  any library licensed under the Apache Software License,
  22  * The Sun (tm) Java Advanced Imaging library (JAI), The Sun JIMI library
  23  * (or with modified versions of the above that use the same license as the above),
  24  * and distribute linked combinations including the two.  You must obey the
  25  * GNU General Public License in all respects for all of the code used other than
  26  * the above mentioned libraries.  If you modify this file, you may extend this
  27  * exception to your version of the file, but you are not obligated to do so.
  28  * If you do not wish to do so, delete this exception statement from your version.
  29  */
  30
  31 package mircoders.accesscontrol;
  32
  33 import java.util.List;
  34 import java.util.Vector;
  35
  36 import mir.config.MirPropertiesConfiguration;
  37 import mir.log.LoggerWrapper;
  38 import mircoders.entity.EntityUsers;
  39
  40 public class AccessControl {
  41   private UserAccessControl user;
  42   private GeneralAccessControl general;
  43   protected LoggerWrapper logger = new LoggerWrapper("Global.AccessControl");
  44   protected MirPropertiesConfiguration configuration;
  45
  46   public AccessControl() {
  47     try {
  48       configuration = MirPropertiesConfiguration.instance();
  49
  50       user = new UserAccessControl(configuration.getVector("AccessControl.SuperUsers"));
  51       general = new GeneralAccessControl();
  52     }
  53     catch (Throwable t) {
  54       throw new RuntimeException(t.toString());
  55     }
  56   }
  57
  58   public UserAccessControl user() {
  59     return user;
  60   }
  61
  62   public GeneralAccessControl general() {
  63     return general;
  64   }
  65
  66   public class GeneralAccessControl {
  67     public boolean mayDeleteArticles(EntityUsers aSubject) {
  68       return configuration.getString("Mir.Localizer.Admin.AllowDeleteArticle", "0").equals("1");
  69     }
  70
  71     public void assertMayDeleteArticles(EntityUsers aSubject) throws AuthorizationExc, AuthorizationFailure {
  72       try {
  73         if (!mayDeleteArticles(aSubject))
  74           throw new AuthorizationExc("not allowed to delete articles");
  75       }
  76       catch (Throwable t) {
  77         throw new AuthorizationFailure(t);
  78       }
  79     }
  80
  81     public boolean mayDeleteComments(EntityUsers aSubject) {
  82       return configuration.getString("Mir.Localizer.Admin.AllowDeleteComment", "0").equals("1");
  83     }
  84
  85     public void assertMayDeleteComments(EntityUsers aSubject) throws AuthorizationExc, AuthorizationFailure {
  86       try {
  87         if (!mayDeleteArticles(aSubject))
  88           throw new AuthorizationExc("not allowed to delete comments");
  89       }
  90       catch (Throwable t) {
  91         throw new AuthorizationFailure(t);
  92       }
  93     }
  94   }
  95
  96   public class UserAccessControl {
  97     private List superusers;
  98
  99     public UserAccessControl(List aSuperUsers) {
 100       superusers = new Vector(aSuperUsers);
 101     }
 102
 103     public void assertMayAddUsers(EntityUsers aSubject) throws AuthorizationExc, AuthorizationFailure {
 104       try {
 105         if (!mayAddUsers(aSubject))
 106           throw new AuthorizationExc("not allowed to add users");
 107       }
 108       catch (Throwable t) {
 109         throw new AuthorizationFailure(t);
 110       }
 111
 112     }
 113
 114     public boolean mayAddUsers(EntityUsers aSubject) {
 115       return superusers.contains(aSubject.getValue("login"));
 116     }
 117
 118     public void assertMayEditUser(EntityUsers aSubject, EntityUsers anObject) throws AuthorizationExc, AuthorizationFailure {
 119       try {
 120         if (!mayEditUser(aSubject, anObject))
 121           throw new AuthorizationExc("not allowed to edit user " + anObject.getId());
 122       }
 123       catch (Throwable t) {
 124         throw new AuthorizationFailure(t);
 125       }
 126
 127     }
 128
 129     public boolean mayEditUser(EntityUsers aSubject, EntityUsers anObject) {
 130       return superusers.contains(aSubject.getValue("login"));
 131     }
 132
 133     public boolean mayEditUsers(EntityUsers aSubject) {
 134       return superusers.contains(aSubject.getValue("login"));
 135     }
 136
 137     public void assertMayDeleteUser(EntityUsers aSubject, EntityUsers anObject) throws AuthorizationExc, AuthorizationFailure {
 138       try {
 139         if (!mayDeleteUser(aSubject, anObject))
 140           throw new AuthorizationExc("not allowed to delete user " + anObject.getId());
 141       }
 142       catch (Throwable t) {
 143         throw new AuthorizationFailure(t);
 144       }
 145     }
 146
 147     public boolean mayDeleteUser(EntityUsers aSubject, EntityUsers anObject) {
 148       return superusers.contains(aSubject.getValue("login"));
 149     }
 150
 151     public boolean mayDeleteUsers(EntityUsers aSubject) {
 152       return superusers.contains(aSubject.getValue("login"));
 153     }
 154
 155     public boolean mayChangeUserPassword(EntityUsers aSubject, EntityUsers anObject) {
 156       return aSubject.getId().equals(anObject.getId()) || superusers.contains(aSubject.getValue("login"));
 157     }
 158
 159     public void assertMayChangeUserPassword(EntityUsers aSubject, EntityUsers anObject) throws AuthorizationExc, AuthorizationFailure {
 160       try {
 161         if (!mayChangeUserPassword(aSubject, anObject))
 162           throw new AuthorizationExc("not allowed to change user " + anObject.getId()+"'s password");
 163       }
 164       catch (Throwable t) {
 165         throw new AuthorizationFailure(t);
 166       }
 167     }
 168   }
 169 }