    001/*
    002 * Copyright (c) 2009 The openGion Project.
    003 *
    004 * Licensed under the Apache License, Version 2.0 (the "License");
    005 * you may not use this file except in compliance with the License.
    006 * You may obtain a copy of the License at
    007 *
    008 *     http://www.apache.org/licenses/LICENSE-2.0
    009 *
    010 * Unless required by applicable law or agreed to in writing, software
    011 * distributed under the License is distributed on an "AS IS" BASIS,
    012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
    013 * either express or implied. See the License for the specific language
    014 * governing permissions and limitations under the License.
    015 */
    016package org.opengion.hayabusa.resource;
    017
    018import org.opengion.hayabusa.common.HybsSystem;
    019import org.opengion.hayabusa.common.HybsSystemException;
    020import org.opengion.fukurou.util.StringUtil;
    021
    022import java.util.Map;
    023import java.util.WeakHashMap ;
    024import java.util.Collections ;
    025
    026/**
    027 * ロールモードは、画面オブジェクトやカラムオブジェクトのロール-モード制御の情報を
    028 * 管理するクラスです。
    029 * ROLES 情報は、AAA|BBB|CCC と 『|』で区切られた複数のロールを持っています。
    030 * 通常、ユーザーロールは画面やカラムの各オブジェクトに対してロール制御可能です。
    031 * ログインユーザーは、自分自身のロールを、画面やカラムが持っているかを判定します。
    032 * 画面に関しては、従来のデフォルトアクセスがなくなり、ロールを登録する場合は、
    033 * 必ず ユーザーロールとの比較が行われます。画面ロールを登録しない場合は、アクセス
    034 * 可能と判断されます。つまり、画面の場合は、なにも設定しなければ、アクセス可能と
    035 * 判断されます。
    036 * カラムロールも同様に、何も設定しなければフルアクセスできます。通常、ほとんどの
    037 * ケースでカラムロールが使われることはありません。
    038 * RWMODE 情報は、各ロールに対して、３つの項目で表しています。
    039 *   １："-" メニュー非表示   "m" メニュー表示  "p" メニュー表示(強制プルダウン表示)
    040 *   ２："-" アクセス拒否     "r" 読取許可      "w" 読取、書込許可
    041 *   ３："-" 未対応           "d" ファイル出力  "u" ファイル入力  "f" ファイル入出力
    042 *       uではエディットメニューそのものが、d,fでは【表示項目設定】タブは表示されません。
    043 *       "o" 表示順編集のみ可  … この設定では、【表示項目設定】 タブで位置と表示順のみ変更できます。
    044 *       "e" 画面編集可        … この設定で、編集機能がフルに使えます。
    045 *       互換性の関係より、"" は、"e"  と同等とします。
    046 *       設定キーの関係より、"o" か "e" を設定すると、"f" と同じ権限が自動的に設定されます。
    047 *
    048 * この３項目を順次つないで、"--","-r","-w","mr","mw","mwf" などの設定を行います。
    049 * モードが設定されている場合は、共通モードとして、すべてのロールに同じモードを
    050 * 割り当てます。個別に割り当てる場合は、ROLES 情報の後ろに () 付きで追記します。
    051 * 例えば、AAA|BBB(-r)|CCC とすれば、BBB ロールの場合は、読取専用になります。
    052 * ロールをぶつける場合は、AND 演算になります。
    053 * 過去(Ver3)のモードとの互換性をとる場合、"rw" は "mw" へ、"r-" は"mr" へ変換
    054 * してください。
    055 *
    056 * @og.rev 4.0.0.0 (2004/01/31) 新規作成
    057 * @og.rev 4.3.3.0 (2008/10/01) pモード追加
    058 * @og.group リソース管理
    059 *
    060 * @version  4.0
    061 * @author   Kazuhiko Hasegawa
    062 * @since    JDK5.0,
    063 */
    064public final class RoleMode {
    065        private static final Map<String,RoleMode> roleMap
    066                                        = Collections.synchronizedMap(
    067                                                new WeakHashMap<String,RoleMode>( HybsSystem.BUFFER_SMALL )
    068                                          );
    069
    070        // 4.0.0 (2005/01/31) param属性追加
    071        // 4.3.3.0 (2008/10/01) pを追加するため、ビット表現を拡張
    072//      public static final byte FULL_MODE = (byte)0x1f;        // mwf = 11111 = 0x1f
    073//      public static final byte M_MODE    = (byte)0x10;        // m-- = 10000 = 0x10
    074//      public static final byte R_MODE    = (byte)0x04;        // -r- = 00100 = 0x04
    075//      public static final byte W_MODE    = (byte)0x0C;        // -w- = 01100 = 0x0C
    076//      public static final byte D_MODE    = (byte)0x01;        // --d = 00001 = 0x01
    077//      public static final byte U_MODE    = (byte)0x02;        // --u = 00010 = 0x02
    078//      public static final byte F_MODE    = (byte)0x03;        // --f = 00011 = 0x03
    079
    080//      /** MODE 定義 ( mwf ) */
    081//      public static final byte FULL_MODE = (byte)0x3f;        // mwf = 111111 = 0x3f
    082//      /** MODE 定義 ( m-- ) */
    083//      public static final byte M_MODE    = (byte)0x30;        // m-- = 110000 = 0x30
    084//      /** MODE 定義 ( p-- ) */
    085//      public static final byte P_MODE    = (byte)0x10;        // p-- = 010000 = 0x10
    086//      /** MODE 定義 ( -r- ) */
    087//      public static final byte R_MODE    = (byte)0x04;        // -r- = 000100 = 0x04
    088//      /** MODE 定義 ( -w- ) */
    089//      public static final byte W_MODE    = (byte)0x0C;        // -w- = 001100 = 0x0C
    090//      /** MODE 定義 ( --d ) */
    091//      public static final byte D_MODE    = (byte)0x01;        // --d = 000001 = 0x01
    092//      /** MODE 定義 ( --u ) */
    093//      public static final byte U_MODE    = (byte)0x02;        // --u = 000010 = 0x02
    094//      /** MODE 定義 ( --f ) */
    095//      public static final byte F_MODE    = (byte)0x03;        // --f = 000011 = 0x03
    096//
    097//      public static final String DEFAULT_MODE = "mwf";
    098
    099        // 5.4.2.0 (2011/12/01) eを追加するため、ビット表現を拡張
    100//      /** MODE 定義 ( mwf ) */
    101//      public static final byte FULL_MODE = (byte)0x3f;        // mwe = 1111111 = 0x7f
    102//      /** MODE 定義 ( m-- ) */
    103//      public static final byte M_MODE    = (byte)0x60;        // m-- = 1100000 = 0x60
    104//      /** MODE 定義 ( p-- ) */
    105//      public static final byte P_MODE    = (byte)0x20;        // p-- = 0100000 = 0x20
    106//      /** MODE 定義 ( -r- ) */
    107//      public static final byte R_MODE    = (byte)0x08;        // -r- = 0001000 = 0x08
    108//      /** MODE 定義 ( -w- ) */
    109//      public static final byte W_MODE    = (byte)0x18;        // -w- = 0011000 = 0x18
    110//      /** MODE 定義 ( --d ) */
    111//      public static final byte D_MODE    = (byte)0x02;        // --d = 0000010 = 0x02
    112//      /** MODE 定義 ( --u ) */
    113//      public static final byte U_MODE    = (byte)0x04;        // --u = 0000100 = 0x04
    114//      /** MODE 定義 ( --f ) */
    115//      public static final byte F_MODE    = (byte)0x06;        // --f = 0000110 = 0x06
    116//      /** MODE 定義 ( --f ) */
    117//      public static final byte E_MODE    = (byte)0x07;        // --e = 0000111 = 0x07
    118
    119
    120        // 5.5.5.2 (2012/08/10) oを追加するため、ビット表現を拡張
    121        // 5.7.4.3 (2014/03/28) publicをprivateに変更します。
    122        /** MODE 定義 全許可                         ( mwe ) */
    123        private static final byte FULL_MODE = (byte)0x7f;       // mwe = 01 11 11 11 = 0x7f
    124        /** MODE 定義 メニュー表示                      ( m-- ) */
    125        private static final byte M_MODE    = (byte)0xc0;       // m-- = 11 00 00 00 = 0xc0
    126        /** MODE 定義 強制プルダウン表示   ( p-- ) */
    127        private static final byte P_MODE    = (byte)0x40;       // p-- = 01 00 00 00 = 0x40
    128
    129        /** MODE 定義 読取許可                                ( -r- ) */
    130        private static final byte R_MODE    = (byte)0x10;       // -r- = 00 01 00 00 = 0x10
    131        /** MODE 定義 書込許可                                ( -w- ) */
    132        private static final byte W_MODE    = (byte)0x30;       // -w- = 00 11 00 00 = 0x30
    133
    134        /** MODE 定義 ファイル出力                      ( --d ) */
    135        private static final byte D_MODE    = (byte)0x04;       // --d = 00 00 01 00 = 0x04
    136        /** MODE 定義 ファイル入力                      ( --u ) */
    137        private static final byte U_MODE    = (byte)0x08;       // --u = 00 00 10 00 = 0x08
    138        /** MODE 定義 ファイル入出力             ( --f ) */
    139        private static final byte F_MODE    = (byte)0x0c;       // --f = 00 00 11 00 = 0x0c
    140
    141        /** MODE 定義 表示順編集のみ可            ( --o ) */
    142        private static final byte O_MODE    = (byte)0x0e;       // --o = 00 00 11 10 = 0x0e
    143                                                                                                                //                ~   ←【出力方法設定】タブの表示
    144                                                                                                                //                 ~  ←【表示項目設定】タブの表示順使用
    145        /** MODE 定義 画面編集可                       ( --e ) */
    146        private static final byte E_MODE    = (byte)0x0f;       // --e = 00 00 11 11 = 0x0f
    147
    148        /** 初期のモード */
    149        public static final String DEFAULT_MODE = "mwe";
    150
    151        private final String    roles ;                 // ロールズ
    152        private final String    rwmode ;                // モード
    153        private final String[]  roleArray ;             // ロール配列
    154        private final byte[]    bitModes ;              // モードのビット版(-:00, p:01, m:11,
    155                                                                                        //                                      -:00, r:01, w:11,
    156                                                                                        //                                      -:000, d:010, u:100, f:110, o:111, e:111)
    157//      private final byte              comBitMode  ;
    158        private final boolean   fullAccessFlag; // フルアクセス許可時のフラグ
    159//      private final boolean   oneModeFlag;    // １つのモードですべてのロールを表現する場合 true
    160
    161        private static final RoleMode FULL_ACCESS_ROLE_MODE_OBJ = new RoleMode() ;
    162
    163        /**
    164         * フルアクセスの RoleMode を構築します。
    165         * 内部からのみ構築できるように private コンストラクタにしておきます。
    166         *
    167         * @og.rev 4.3.0.0 (2008/07/04) ロールモードマルチ対応
    168         */
    169        private RoleMode() {
    170                roles                   = "FullAccess";
    171                rwmode                  = DEFAULT_MODE;
    172                roleArray               = null;
    173                bitModes                = new byte[] { FULL_MODE };             // mwf = 01111111 = 0x7f
    174//              comBitMode              = FULL_MODE;
    175                fullAccessFlag  = true;
    176//              oneModeFlag             = true;
    177        }
    178
    179        /**
    180         * ロールとモードを元に、RoleModeオブジェクトを構築します。
    181         * このコンストラクタは、他のパッケージから呼び出せないように、
    182         * パッケージプライベートにしておきます。
    183         *
    184         * @og.rev 4.3.0.0 (2008/07/04) ロールモードマルチ対応
    185         *
    186         * @param       roles   "|"で区切られた ロール文字列
    187         * @param       mode    "|"で区切られ、ロール文字列と対応付けられたモード文字列。唯一の場合は共通モードになる。
    188         */
    189        private RoleMode( final String roles,final String mode ) {
    190                this.roles      = roles ;               // ロールズ
    191                this.rwmode     = mode ;                // モード
    192
    193//              if( rwmode == null || ( rwmode.length() < 2 ) ) {
    194//                      String errMsg = "RWMODE の桁数は、２桁以上必要です。"
    195//                                              + " roles [" + roles + "]  Mode [" + rwmode + "]"
    196//                                              + HybsSystem.CR + toString() ;
    197//                      throw new HybsSystemException( errMsg );
    198//              }
    199
    200//              roleArray = StringUtil.csv2Array( roles,HybsSystem.GUI_DELIMITER ) ;    // ロール配列
    201
    202                // roles="root" または、roleArray がない場合は、フルアクセス
    203//              fullAccessFlag = "root".equals( roles ) || ( roleArray.length == 0 );
    204                fullAccessFlag = "root".equals( roles ) || ( roles == null ) || ( roles.length() == 0 );
    205
    206                // modes が一つだけの場合は、ワンモード
    207//              String[] modes = StringUtil.csv2Array( mode,HybsSystem.GUI_DELIMITER ) ;        // モード
    208//              oneModeFlag = ( modes.length == 1 );
    209
    210                roleArray = StringUtil.csv2Array( roles,HybsSystem.GUI_DELIMITER ) ;    // ロール配列
    211
    212                // bitModes を求めます。最低１つは作成します。同時に、roleArray もセットします。
    213//              bitModes = makeBitMode( modes );
    214                bitModes = makeBitMode( roleArray,rwmode );
    215        }
    216
    217        /**
    218         * ロールとモードを元に、RoleModeオブジェクトを構築します。
    219         * 条件が同じ RoleModeオブジェクト があれば、キャッシュから返します。
    220         * キャッシュになければ、新規に作成します。
    221         * このキャッシュは、完全な内部キャッシュなので、いつクリアされるか保障がありません。
    222         *
    223         * @og.rev 4.3.0.0 (2008/07/04) ロールモードマルチ対応
    224         *
    225         * @param       roles   "|"で区切られた ロール文字列
    226         *
    227         * @return      RoleModeオブジェクト
    228         */
    229        public static RoleMode newInstance( final String roles ) {
    230                if( roles == null || roles.length() == 0 ) {
    231                        return FULL_ACCESS_ROLE_MODE_OBJ;
    232                }
    233
    234                return newInstance( roles,DEFAULT_MODE );
    235        }
    236
    237        /**
    238         * ロールとモードを元に、RoleModeオブジェクトを構築します。
    239         * 条件が同じ RoleModeオブジェクト があれば、キャッシュから返します。
    240         * キャッシュになければ、新規に作成します。
    241         * このキャッシュは、完全な内部キャッシュなので、いつクリアされるか保障がありません。
    242         *
    243         * @og.rev 4.3.0.0 (2008/07/04) ロールモードマルチ対応
    244         *
    245         * @param       roles   "|"で区切られた ロール文字列
    246         * @param       mode    "|"で区切られ、ロール文字列と対応付けられたモード文字列。唯一の場合は共通モードになる。
    247         *
    248         * @return      RoleModeオブジェクト
    249         */
    250        public static RoleMode newInstance( final String roles,final String mode ) {
    251                if( mode == null || mode.length() < 2 ) {
    252                        String errMsg = "RWMODE の桁数は、２桁以上必要です。"
    253                                                + " roles [" + roles + "]  mode [" + mode + "]"
    254                                                + HybsSystem.CR;
    255                        throw new HybsSystemException( errMsg );
    256                }
    257
    258                if( ( roles == null || roles.length() == 0 ) &&
    259                        ( "mw".equals( mode ) || DEFAULT_MODE.equals( mode ) ) ) {
    260                                return FULL_ACCESS_ROLE_MODE_OBJ ;
    261                }
    262
    263                String key = roles + mode ;
    264                RoleMode roleMode = roleMap.get( key );
    265                if( roleMode == null ) {
    266                        roleMode = new RoleMode( roles,mode );
    267                        roleMap.put( key,roleMode );
    268                }
    269
    270                return roleMode;
    271        }
    272
    273        /**
    274         * フルアクセスできるRoleModeオブジェクトを返します。
    275         * これは、カラムオブジェクトなど、ほとんどのケースでフルアクセスできる場合に、
    276         * 同じオブジェクトを常に返すようにすることで、メモリの節約と以降の処理の共通化を
    277         * 図る為の機能です。シングルトン対応のNULLオブジェクトパターンに近いです。
    278         *
    279         * @return RoleMode     フルアクセスできるRoleModeオブジェクト
    280         */
    281//      static RoleMode getFullAccessRoleMode() {
    282//              return FULL_ACCESS_ROLE_MODE_OBJ ;
    283//      }
    284
    285        /**
    286         * ロールズを返します。
    287         *
    288         * @return ロールズ文字列
    289         */
    290        public String getRoles() { return roles; }
    291
    292        /**
    293         * モード配列を返します。
    294         *
    295         * @return モード配列
    296         */
    297        public String getMode() { return rwmode; }
    298
    299        /**
    300         * ユーザーロール配列と比較してアクセス可否を返します。
    301         *
    302         * @param       userRoles       ユーザーロール配列
    303         *
    304         * @return アクセスできる(true)/出来ない(false)
    305         */
    306//      public boolean isAccess( final String[] userRoles ) {
    307//              if( fullAccessFlag ) { return ( bitModes[0] > 0 ); }
    308//
    309//              // ユーザーロールが無い場合は、アクセス不許可
    310//              if( userRoles == null || userRoles.length == 0 ) {
    311//                      return false;
    312//              }
    313//
    314//              for( int g=0; g<roleArray.length; g++ ) {
    315////                    byte bit = ( oneModeFlag ) ? bitModes[0] : bitModes[g] ;
    316//                      byte bit = bitModes[g] ;
    317//                      for( int u=0; u<userRoles.length; u++ ) {
    318//                              // 4.0.0.0 (2007/11/29) 入れ子if の統合
    319//                              if( bit > 0 && roleArray[g].equalsIgnoreCase( userRoles[u] ) ) {
    320//                                      return true;
    321//                              }
    322//                      }
    323//              }
    324//              return false;
    325//      }
    326
    327        /**
    328         * 指定のユーザーロールに対する最終的なアクセス条件を取得します。
    329         * アクセス条件は、複数あるユーザーロールの中で、最大のアクセス条件を算出します。
    330         * 例えば、AAA(-r)|BBB(-w)|CCC(mr) の３つのロール/モードが設定されている場合、
    331         * ユーザーが、AAA だけの場合は、-r ですが、AAA|BBB を持っている場合は、-w になります。
    332         * さらに、BBB|CCC と持っている場合は、(-w:書き込み許可)と(mr:メニューから読取許可)の
    333         * 権限により、mw:メニューからの書き込み許可が与えられます。
    334         * モード指定がある場合は、AND演算になります。
    335         * 例えば、AAA(-r)|BBB(-w)|CCC(mr) と BBB|CCC(-r) の場合、(-r)+(-w)+(mr)*(-r)=-w に
    336         * なります。ロールは、OR ですが、モードは、同一ロールでのAND になります。
    337         * 実際には、メニュー表示の可否は、ポップアップ系によく用いられますので、上記のような
    338         * 許可が実際にあるかどうかは不明ですが、すべてのモードのOR条件での結合になります。
    339         *
    340         * @param       userRoles       ユーザーロール配列
    341         * @param       isRoot  ルートロールフラグ
    342         *
    343         * @return  ビットモード配列 "--:000","-r:001","-w:010","mr:101","mw:110" に対応した数字(0,1,2,5,6)
    344         */
    345//      public byte getAccessBitMode( final String[] userRoles,final boolean isRoot ) {
    346//              if( fullAccessFlag ) { return bitModes[0]; }
    347//
    348//              byte bitMode = 0;
    349//              for( int g=0; g<roleArray.length; g++ ) {
    350////                    byte bit = ( oneModeFlag ) ? bitModes[0] : bitModes[g] ;
    351//                      byte bit = bitModes[g] ;
    352//                      if( isRoot ) {
    353//                              bitMode |= bit;
    354//                      }
    355//                      else {
    356//                              String role = roleArray[g];
    357//                              for( int u=0; u<userRoles.length; u++ ) {
    358//                                      if( role.equalsIgnoreCase( userRoles[u] ) ) {
    359//                                              bitMode |= bit;
    360//                                              break;                                  // 一致すれば、内側のループを抜ける。
    361//                                      }
    362//                              }
    363//                      }
    364//                      if( bitMode >= 6 ) { break; }        // "mw:110" は最大なので、以後判定不要。
    365//              }
    366//
    367//              return bitMode;
    368//      }
    369
    370        /**
    371         * 指定のユーザーロールに対する最終的なアクセス条件を取得します。
    372         * アクセス条件は、複数あるユーザーロールの中で、最大のアクセス条件を算出します。
    373         * 例えば、AAA(-r)|BBB(-w)|CCC(mr) の３つのロール/モードが設定されている場合、
    374         * ユーザーが、AAA だけの場合は、-r ですが、AAA|BBB を持っている場合は、-w になります。
    375         * さらに、BBB|CCC と持っている場合は、(-w:書き込み許可)と(mr:メニューから読取許可)の
    376         * 権限により、mw:メニューからの書き込み許可が与えられます。
    377         * モード指定がある場合は、AND演算になります。
    378         * 例えば、AAA(-r)|BBB(-w)|CCC(mr) と BBB|CCC(-r) の場合、(-r)+(-w)+(mr)*(-r)=-w に
    379         * なります。ロールは、OR ですが、モードは、同一ロールでのAND になります。
    380         * 実際には、メニュー表示の可否は、ポップアップ系によく用いられますので、上記のような
    381         * 許可が実際にあるかどうかは不明ですが、すべてのモードのOR条件での結合になります。
    382         *
    383         * @og.rev 4.3.0.0 (2008/07/04) ロールモードマルチ対応
    384         *
    385         * @param       other   ロールモード
    386         *
    387         * @return アクセスビット
    388         */
    389        public byte getAccessBitMode( final RoleMode other ) {
    390                if( fullAccessFlag || other.fullAccessFlag ) {
    391                        return (byte)(bitModes[0] & other.bitModes[0]) ;
    392                }
    393
    394                String[] othRoleArray = other.roleArray ;               // ロール配列
    395                byte[]   othBitModes  = other.bitModes ;                // モードのビット
    396
    397                byte bitMode = 0;
    398                for( int i=0; i<roleArray.length; i++ ) {
    399                        for( int j=0; j<othRoleArray.length; j++ ) {
    400                                if( roleArray[i].equals( othRoleArray[j] ) ) {
    401                                        bitMode |= (byte)(bitModes[i] & othBitModes[j]) ;
    402                                        if( bitMode == FULL_MODE ) { return FULL_MODE; }        // 途中打ち切り
    403                                }
    404                        }
    405                }
    406
    407                return bitMode;
    408        }
    409
    410        /**
    411         * ビットロールのメニュー表示可否を返します。
    412         *
    413         * ロールが、m## , p## の場合に、true になります。
    414         * これは、メニューに表示されるかどうかの判定に使われます。
    415         *
    416         * @param       bitMode ビットロール
    417         *
    418         * @return メニュー表示できる(true)/出来ない(false)
    419         */
    420        public static boolean isMenu( final byte bitMode ) {
    421                return ( (bitMode & M_MODE) > 0 );
    422        }
    423
    424        /**
    425         * ビットロールのプルダウン化を返します。
    426         *
    427         * ロールが、p## の場合に、true になります。
    428         * ボタンメニュー時でも強制的に従来のプルダウンにします。
    429         * 今後は廃止の方向です。
    430         *
    431         * @og.rev 4.3.3.0 (2008/10/01) メソッド追加
    432         * @param       bitMode ビットロール
    433         *
    434         * @return true:プルダウン化
    435         */
    436        public static boolean isPulldown( final byte bitMode ) {
    437                // M_MODEとの比較でP_MODEの場合は強制プルダウン化
    438                return ( (bitMode & M_MODE) == P_MODE );
    439        }
    440
    441        /**
    442         * ビットロールの読込アクセス可否を返します。
    443         *
    444         * ロールが、#r# , #w# の場合に、true になります。
    445         * 読み取り属性がある場合、画面が利用可能になります。
    446         * #-# の場合は、画面へのアクセスができないため、
    447         * メニューアクセス許可を与える、m-# の設定は無意味です。
    448         * この場合は、メニューにも表示されません。
    449         *
    450         * @param       bitMode ビットロール
    451         *
    452         * @return 読込アクセスできる(true)/出来ない(false)
    453         */
    454        public static boolean isRead( final byte bitMode ) {
    455                return ( (bitMode & R_MODE) > 0 );
    456        }
    457
    458        /**
    459         * ビットロールの書込アクセス可否を返します。
    460         *
    461         * ロールが、#w# の場合に、true になります。
    462         *
    463         * これは、読込、書込みの判断ではなく、書込みができるか
    464         * どうかの判断をしています。
    465         * 画面にアクセスできるかどうかの判断は、isAccess を使用してください。
    466         *
    467         * @param       bitMode ビットロール
    468         *
    469         * @return 書込アクセスできる(true)/出来ない(false)
    470         */
    471        public static boolean isWrite( final byte bitMode ) {
    472                // 注意：W_MODE は、R_MODE と合成されているので、> 0 で判断できない。
    473                return ( (bitMode & W_MODE) == W_MODE );
    474        }
    475
    476        /**
    477         * ビットロールの画面アクセス可否を返します。
    478         *
    479         * これは、画面にアクセスできるかどうかの判断です。
    480         * ロールが、#r# , #w# の場合に、true になります。
    481         * 現時点では、isRead(byte) と計算方法は異なりますが、同じ結果になっています。
    482         * これは、たまたま、現時点のロールの種類がそうなっているだけで、将来的に
    483         * 同じかどうかは、保障されていません。
    484         * よって、読み取り許可と、画面アクセス許可は、分けて考えてください。
    485         *
    486         * @param       bitMode ビットロール
    487         *
    488         * @return 画面アクセスできる(true)/出来ない(false)
    489         */
    490        public static boolean isAccess( final byte bitMode ) {
    491                return ( (bitMode & W_MODE) > 0 );
    492        }
    493
    494        /**
    495         * ビットロールのファイル出力可否を返します。
    496         *
    497         * ロールが、##d , ##f , ##o , ##e(= ##) の場合に、true になります。
    498         * ##u の場合に、false になります。
    499         * ファイル出力の可否を判定します。
    500         * ## は、互換性の関係で、##e と同じです。
    501         *
    502         * @param       bitMode ビットロール
    503         *
    504         * @return ファイル出力できる(true)/出来ない(false)
    505         */
    506        public static boolean isDownload( final byte bitMode ) {
    507                return ( (bitMode & D_MODE) > 0 );
    508        }
    509
    510        /**
    511         * ビットロールのファイル入力可否を返します。
    512         *
    513         * ロールが、##u , ##f , ##o , ##e(= ##) の場合に、true になります。
    514         * ##d の場合に、false になります。
    515         * ファイル入力の可否を判定します。
    516         * ## は、互換性の関係で、##e と同じです。
    517         * ダウンロードはさせないが、アップロードを行う場合に使います。
    518         * ここでのアップロードとは、基本的にデータの取り込みになりますので、
    519         * アップロードのみという扱いは、あまりありません。
    520         *
    521         * @param       bitMode ビットロール
    522         *
    523         * @return ファイル入力できる(true)/出来ない(false)
    524         */
    525        public static boolean isUpload( final byte bitMode ) {
    526                return ( (bitMode & U_MODE) > 0 );
    527        }
    528
    529        /**
    530         * ビットロールの画面編集可否を返します。
    531         *
    532         * ロールが、##o , ##e(= ##) の場合に、true になります。
    533         * このビットロールだけ特殊で、フラグが ON の場合に、機能制限がかかります。
    534         *
    535         * @og.rev 5.4.2.0 (2011/12/01) 新規作成
    536         * @og.rev 5.5.5.2 (2012/08/10) oモード追加に伴い変更
    537         *
    538         * @param       bitMode ビットロール
    539         *
    540         * @return アクセスできる(true)/出来ない(false)
    541         */
    542        public static boolean isEdit( final byte bitMode ) {
    543                // return ( (bitMode & E_MODE) == E_MODE );
    544                return ( (bitMode & O_MODE) == O_MODE );
    545        }
    546
    547        /**
    548         * ビットロールの画面編集のフルコントロール可否を返します。
    549         *
    550         * ロールが、##e(= ##) の場合に、true になります。
    551         * これは、フルコントロールの状態を指します。
    552         *
    553         * @og.rev 5.5.5.2 (2012/08/10) 新規作成
    554         *
    555         * @param       bitMode ビットロール
    556         *
    557         * @return アクセスできる(true)/出来ない(false)
    558         */
    559        public static boolean isFullEdit( final byte bitMode ) {
    560                // return ( (bitMode & E_MODE) == E_MODE );
    561                return ( (bitMode & E_MODE) == E_MODE );
    562        }
    563
    564
    565        /**
    566         * この画面のmode アクセス条件をビット化します。
    567         *
    568         * RWMODE 情報は、各ロールに対して、３つの項目で表しています。
    569         *   １："-" メニュー非表示   "m" メニュー表示  "p" メニュー表示(強制プルダウン表示)
    570         *   ２："-" アクセス拒否     "r" 読取許可      "w" 読取、書込許可
    571         *   ３："-" 未対応           "d" ファイル出力  "u" ファイル入力  "f" ファイル入出力
    572         *       … このd,u,f では、【出力方法設定】タブは表示されません。
    573         *       "o" 表示順編集のみ可  … この設定では、【表示項目設定】 タブで位置と表示順のみ変更できます。
    574         *       "e" 画面編集可        … この設定で、編集機能がフルに使えます。
    575         *       互換性の関係より、"" は、"e"  と同等とします。
    576         *
    577         * 区切り文字『|』で同じ順序で指定します。
    578         * roles がないか、modes が一つか、roles と modes の個数が異なる場合
    579         * 唯一のモード(共通モード)として、modes[0] を割り当てます。
    580         * 互換性のため、"rw" と "r-" も処理できるようにします。
    581         * この３項目を順次つないで、"--","-r","-w","mr","mw" などの設定を行います。
    582         * モードが設定されている場合は、共通モードとして、すべてのロールに同じモードを
    583         * 割り当てます。個別に割り当てる場合は、ROLES 情報の後ろに () 付きで追記します。
    584         * 例えば、AAA|BBB(-r)|CCC とすれば、BBB ロールの場合は、読取専用になります。
    585         * ロールをぶつける場合は、AND 演算になります。
    586         *
    587         * @og.rev 4.3.0.0 (2008/07/04) ロールモードマルチ対応
    588         *
    589         * @param       roles   画面ロール配列
    590         * @param       mode    画面モード
    591         *
    592         * @return  ビットモード配列 "--:000","-r:001","-w:010","mr:101","mw:110" に対応した数字(0,1,2,5,6)
    593         */
    594//      private byte[] makeBitMode( final String[] modes ) {
    595        private byte[] makeBitMode( final String[] roles,final String mode ) {
    596                byte[] bits = null;
    597
    598                byte commnMode = bitMode( mode );               // 共通MODEの設定
    599
    600                int size = roles.length ;
    601                if( size == 0 ) {
    602                        bits = new byte[] { commnMode };
    603                }
    604                else {
    605                        bits = new byte[size] ;
    606                        for( int i=0; i<size; i++ ) {
    607                                String roleMode = null;
    608                                String role = roles[i];
    609                                int adrs = ( role != null ) ? role.indexOf( '(' ) : -1 ;
    610                                if( adrs >= 0 ) {
    611                                        roleMode = role.substring( adrs+1,role.length() -1 );
    612                                        // 注意：roleArray に書き戻しています。(副作用処理)
    613                                        roles[i] = role.substring( 0,adrs );
    614                                }
    615                                bits[i] = (byte)(commnMode & bitMode( roleMode )) ;
    616                        }
    617                }
    618
    619                return bits ;
    620        }
    621
    622        /**
    623         * モード文字列に対するビット変換を行います。
    624         *
    625         * RWMODE 情報は、３つの項目で表しています。
    626         *   １："-" メニュー非表示   "m" メニュー表示
    627         *   ２："-" アクセス拒否     "r" 読取許可      "w" 読取、書込許可
    628         *   ３："-" 未対応           "d" ファイル出力  "u" ファイル入力  "f" ファイル入出力
    629         *       … このd,u,f では、【出力方法設定】タブは表示されません。
    630         *       "o" 表示順編集のみ可  … この設定では、【表示項目設定】 タブで位置と表示順のみ変更できます。
    631         *       "e" 画面編集可        … この設定で、編集機能がフルに使えます。
    632         *       互換性の関係より、"" は、"e"  と同等とします。
    633         *
    634         * それぞれのキーワードに対して、ビット制御を行います。
    635         * このメソッドには、ロールモード(ロール単位に追加するモード)の判定も
    636         * 行う事が出来るように、引数が null の場合は、FULL_MODE を返します。
    637         *
    638         *       全許可                                    ( mwe )  FULL_MODE
    639         *       メニュー表示                 ( m-- )  M_MODE
    640         *       強制プルダウン表示              ( p-- )  P_MODE
    641         *       読取許可                           ( -r- )  R_MODE
    642         *       書込許可                           ( -w- )  W_MODE
    643         *       ファイル出力                 ( --d )  D_MODE
    644         *       ファイル入力                 ( --u )  U_MODE
    645         *       ファイル入出力                        ( --f )  F_MODE
    646         *       表示順編集のみ可               ( --o )  O_MODE
    647         *       画面編集可                          ( --e )  E_MODE
    648         *
    649         * @og.rev 4.3.0.0 (2008/07/04) ロールモードマルチ対応
    650         * @og.rev 4.3.3.0 (2008/10/01) pモード対応(mと同じ扱い)
    651         * @og.rev 5.4.2.0 (2011/12/01) eモード対応
    652         * @og.rev 5.5.5.2 (2012/08/10) oモード対応
    653         *
    654         * @param       mode    モード文字列
    655         *
    656         * @return      ビットモード
    657         */
    658        private byte bitMode( final String mode ) {
    659                byte bit = 0x00;
    660
    661                if( mode == null ) {
    662                        bit = FULL_MODE;
    663                }
    664                else {
    665                        int len = mode.length();
    666                        for( int i=0; i<len; i++ ) {
    667                                switch( mode.charAt(i) ) {
    668                                        case 'm' : bit |= M_MODE; break;
    669                                        case 'p' : bit |= P_MODE; break; // 4.3.3.0 (2008/10/01) Pモード追加
    670                                        case 'r' : bit |= R_MODE; break;
    671                                        case 'w' : bit |= W_MODE; break;
    672                                        case 'd' : bit |= D_MODE; break;
    673                                        case 'u' : bit |= U_MODE; break;
    674                                        case 'f' : bit |= F_MODE; break;
    675                                        case 'e' : bit |= E_MODE; break; // 5.4.2.0 (2011/12/01) Eモード追加
    676                                        case 'o' : bit |= O_MODE; break; // 5.5.5.2 (2011/12/10) Oモード追加
    677                                        case '-' : break;
    678                                        default  :
    679                                                String errMsg = "RWMODE に不正な記号が使用されています。"
    680                                                                        + " mrwdufe- のみ、使用可能です。"
    681                                                                        + " roles [" + roles + "]  mode [" + mode + "]"
    682                                                                        + HybsSystem.CR;
    683                                                throw new HybsSystemException( errMsg );
    684                                }
    685                        }
    686//                      if( len < 3 ) { bit |= F_MODE; }     // 互換性暫定対応
    687                        if( len < 3 ) { bit |= E_MODE; }     // 互換性暫定対応 // 5.4.2.0 (2011/12/01)
    688
    689                        // RWアクセスできない場合は、ファイルアクセスも禁止します。
    690                        if( ( bit & W_MODE ) == 0 ) { bit = 0x00; }
    691                }
    692
    693                return bit ;
    694        }
    695
    696        /**
    697         * オブジェクトの識別子として，詳細なユーザー情報を返します。
    698         *
    699         * @return  詳細な画面情報
    700         */
    701        @Override
    702        public String toString() {
    703                StringBuilder rtn = new StringBuilder( HybsSystem.BUFFER_MIDDLE );
    704                rtn.append( "roles  : " ).append( roles  ).append( HybsSystem.CR );
    705                rtn.append( "rwmode : " ).append( rwmode ).append( HybsSystem.CR );
    706                return rtn.toString();
    707        }
    708}