litesoft
Subversion Repository Public Repository

litesoft

URLs

Copy to Clipboard
Explore
Commits

Diff Revisions 947 vs 948 for /trunk/GWT_Sandbox/Prioritizer/src/org/litesoft/prioritizer/server/pos/User.java

Diff revisions: vs.
  @@ -1,14 +1,11 @@
1 1 package org.litesoft.prioritizer.server.pos;
2 2
3 - import org.litesoft.commonfoundation.exceptions.*;
4 - import org.litesoft.commonfoundation.typeutils.*;
5 -
6 - import java.util.*;
7 -
8 3 import org.litesoft.codec.*;
9 4 import org.litesoft.commonfoundation.base.*;
10 - import org.litesoft.core.simpletypes.*;
5 + import org.litesoft.commonfoundation.exceptions.*;
6 + import org.litesoft.commonfoundation.typeutils.*;
11 7 import org.litesoft.commonfoundation.typeutils.Objects;
8 + import org.litesoft.core.simpletypes.*;
12 9 import org.litesoft.core.util.*;
13 10 import org.litesoft.orsup.selection.*;
14 11 import org.litesoft.orsup.transact.*;
  @@ -16,94 +13,80 @@
16 13 import org.litesoft.prioritizer.server.*;
17 14 import org.litesoft.security.*;
18 15
19 - public class User extends UserGO implements SecurityUser<User>
20 - {
16 + import java.util.*;
17 +
18 + public class User extends UserGO implements SecurityUser<User> {
21 19 public User( Transaction pTransaction ) // Only used for New
22 20 {
23 21 super( pTransaction );
24 22 }
25 23
26 - public User( ConstructionControl pConstructionControl )
27 - {
24 + public User( ConstructionControl pConstructionControl ) {
28 25 super( pConstructionControl );
29 26 }
30 27
31 28 private boolean mDemo;
32 29
33 30 @Override
34 - public Boolean getDemoUser()
35 - {
31 + public Boolean getDemoUser() {
36 32 return mDemo;
37 33 }
38 34
39 35 @Override
40 - protected void LLclearDemoUser()
41 - {
36 + protected void LLclearDemoUser() {
42 37 }
43 38
44 39 @Override
45 - public boolean isDemo()
46 - {
40 + public boolean isDemo() {
47 41 return mDemo;
48 42 }
49 43
50 44 @Override
51 - public void setDemo()
52 - {
45 + public void setDemo() {
53 46 mDemo = true;
54 47 }
55 48
56 49 @Override
57 - public String getHexPassword()
58 - {
50 + public String getHexPassword() {
59 51 String zEncryptedPassword = LLgetPassword();
60 52 return (zEncryptedPassword == null) ? null : HexStringCodec.encode( zEncryptedPassword );
61 53 }
62 54
63 55 @Override
64 - protected void LLsetHexPassword( String pHexPassword )
65 - {
56 + protected void LLsetHexPassword( String pHexPassword ) {
66 57 LLsetPassword( (pHexPassword == null) ? null : HexStringCodec.decode( pHexPassword ) );
67 58 }
68 59
69 60 @Override
70 - protected void LLclearHexPassword()
71 - {
61 + protected void LLclearHexPassword() {
72 62 }
73 63
74 64 @Override
75 - public String getFullName()
76 - {
65 + public String getFullName() {
77 66 return ((Strings.deNull( getFirstName() ) + " " + Strings.deNull( getMiddleInitial() )).trim() + " " + Strings.deNull( getLastName() )).trim();
78 67 }
79 68
80 69 @Override
81 - protected void LLclearFullName()
82 - {
70 + protected void LLclearFullName() {
83 71 }
84 72
85 73 @Override
86 - public Boolean getVisibleToCurrentRestrictedResource()
87 - {
74 + public Boolean getVisibleToCurrentRestrictedResource() {
88 75 UserXrefRestrictedResource zRestrictedResource = getCurrentRestrictedResource();
89 76
90 77 return (zRestrictedResource != null) ? zRestrictedResource.getVisible() : null;
91 78 }
92 79
93 80 @Override
94 - protected void LLclearVisibleToCurrentRestrictedResource()
95 - {
81 + protected void LLclearVisibleToCurrentRestrictedResource() {
96 82 }
97 83
98 84 @Override
99 - protected void LLsetVisibleToCurrentRestrictedResource( Boolean pVisibleToCurrentRestrictedResource )
100 - {
101 - if ( pVisibleToCurrentRestrictedResource != null )
102 - {
85 + protected void LLsetVisibleToCurrentRestrictedResource( Boolean pVisibleToCurrentRestrictedResource ) {
86 + if ( pVisibleToCurrentRestrictedResource != null ) {
103 87 UserXrefRestrictedResource zRestrictedResource = getCurrentRestrictedResource();
104 88
105 - if ( zRestrictedResource != null )
106 - {
89 + if ( zRestrictedResource != null ) {
107 90 zRestrictedResource.setVisible( pVisibleToCurrentRestrictedResource );
108 91 }
109 92 }
  @@ -113,31 +96,25 @@
113 96 private UserXrefRestrictedResource mLastUserXrefRestrictedResource;
114 97
115 98 @Override
116 - public UserXrefRestrictedResource getCurrentRestrictedResource()
117 - {
118 - if ( (mLastUserXrefRestrictedResource != null) && (getTransaction() != null) )
119 - {
99 + public UserXrefRestrictedResource getCurrentRestrictedResource() {
100 + if ( (mLastUserXrefRestrictedResource != null) && (getTransaction() != null) ) {
120 101 return mLastUserXrefRestrictedResource;
121 102 }
122 103 RestrictedResource zCurrentRestrictedResource = CurrentRestrictedResourceAccessor.get().getOptionalRestrictedResource();
123 - if ( zCurrentRestrictedResource != null )
124 - {
125 - if ( zCurrentRestrictedResource.equals( mLastCurrentRestrictedResource ) && zCurrentRestrictedResource.getRecordVersion().equals( mLastCurrentRestrictedResource.getRecordVersion() ) )
126 - {
104 + if ( zCurrentRestrictedResource != null ) {
105 + if ( zCurrentRestrictedResource.equals( mLastCurrentRestrictedResource ) &&
106 + zCurrentRestrictedResource.getRecordVersion().equals( mLastCurrentRestrictedResource.getRecordVersion() ) ) {
127 107 return mLastUserXrefRestrictedResource;
128 108 }
129 - for ( UserXrefRestrictedResource zUserXrefRestrictedResource : getRestrictedResources() )
130 - {
109 + for ( UserXrefRestrictedResource zUserXrefRestrictedResource : getRestrictedResources() ) {
131 110 RestrictedResource zRestrictedResource = zUserXrefRestrictedResource.getRestrictedResource();
132 - if ( zCurrentRestrictedResource.equals( zRestrictedResource ) )
133 - {
111 + if ( zCurrentRestrictedResource.equals( zRestrictedResource ) ) {
134 112 mLastCurrentRestrictedResource = zRestrictedResource;
135 113 return mLastUserXrefRestrictedResource = zUserXrefRestrictedResource;
136 114 }
137 115 }
138 116 // todo: Is Next Appropriate for Super Users?
139 - if ( getTransaction() != null )
140 - {
117 + if ( getTransaction() != null ) {
141 118 mLastUserXrefRestrictedResource = new UserXrefRestrictedResource( getTransaction(), this, zCurrentRestrictedResource );
142 119 mLastCurrentRestrictedResource = mLastUserXrefRestrictedResource.getRestrictedResource();
143 120 return mLastUserXrefRestrictedResource;
  @@ -148,68 +125,53 @@
148 125 }
149 126
150 127 @Override
151 - protected void LLclearCurrentRestrictedResource()
152 - {
128 + protected void LLclearCurrentRestrictedResource() {
153 129 mLastCurrentRestrictedResource = null;
154 130 mLastUserXrefRestrictedResource = null;
155 131 }
156 132
157 - public UserRestrictedResourcePair<User, RestrictedResource> loginToRestrictedResourceIfAcceptable( RestrictedResource pRestrictedResource )
158 - {
133 + public UserRestrictedResourcePair<User, RestrictedResource> loginToRestrictedResourceIfAcceptable( RestrictedResource pRestrictedResource ) {
159 134 Objects.assertNotNull( "RestrictedResource", pRestrictedResource );
160 135 Object o = attemptRestrictedResourceLink( pRestrictedResource );
161 - if ( o instanceof UserRestrictedResourcePair )
162 - {
136 + if ( o instanceof UserRestrictedResourcePair ) {
163 137 return Cast.it( o );
164 138 }
165 139 throw new DisplayableRuntimeException( "RestrictedResource Not Authorized" );
166 140 }
167 141
168 - public UserRestrictedResourcePair<User, RestrictedResource> getLoginRestrictedResource( RestrictedResource pCurrentRestrictedResource )
169 - {
142 + public UserRestrictedResourcePair<User, RestrictedResource> getLoginRestrictedResource( RestrictedResource pCurrentRestrictedResource ) {
170 143 Object o = attemptRestrictedResourceLink( pCurrentRestrictedResource );
171 - if ( o instanceof UserRestrictedResourcePair )
172 - {
144 + if ( o instanceof UserRestrictedResourcePair ) {
173 145 return Cast.it( o );
174 146 }
175 147 List<RestrictedResource> zAuthorizedRestrictedResources = Cast.it( o );
176 148 RestrictedResource zLastRestrictedResource = getLastRestrictedResource();
177 - if ( zLastRestrictedResource != null )
178 - {
179 - for ( RestrictedResource zRestrictedResource : zAuthorizedRestrictedResources )
180 - {
181 - if ( zRestrictedResource.equals( zLastRestrictedResource ) )
182 - {
149 + if ( zLastRestrictedResource != null ) {
150 + for ( RestrictedResource zRestrictedResource : zAuthorizedRestrictedResources ) {
151 + if ( zRestrictedResource.equals( zLastRestrictedResource ) ) {
183 152 return new UserRestrictedResourcePair<User, RestrictedResource>( this, zLastRestrictedResource );
184 153 }
185 154 }
186 155 }
187 - if ( zAuthorizedRestrictedResources.isEmpty() )
188 - {
156 + if ( zAuthorizedRestrictedResources.isEmpty() ) {
189 157 throw new DisplayableRuntimeException( "NoAuthorizedRestrictedResources" );
190 158 }
191 159 return new UserRestrictedResourcePair<User, RestrictedResource>( this, zAuthorizedRestrictedResources.get( 0 ) );
192 160 }
193 161
194 - private Object attemptRestrictedResourceLink( RestrictedResource pRestrictedResource )
195 - {
162 + private Object attemptRestrictedResourceLink( RestrictedResource pRestrictedResource ) {
196 163 List<RestrictedResource> zAuthorizedRestrictedResources = new ArrayList<RestrictedResource>();
197 - for ( UserXrefRestrictedResource zUserXrefRestrictedResource : getRestrictedResources() )
198 - {
199 - if ( zUserXrefRestrictedResource.isLoginAllowed() )
200 - {
164 + for ( UserXrefRestrictedResource zUserXrefRestrictedResource : getRestrictedResources() ) {
165 + if ( zUserXrefRestrictedResource.isLoginAllowed() ) {
201 166 RestrictedResource zRestrictedResource = zUserXrefRestrictedResource.getRestrictedResource();
202 - if ( zRestrictedResource.equals( pRestrictedResource ) )
203 - {
167 + if ( zRestrictedResource.equals( pRestrictedResource ) ) {
204 168 return new UserRestrictedResourcePair<User, RestrictedResource>( this, pRestrictedResource );
205 169 }
206 170 zAuthorizedRestrictedResources.add( zRestrictedResource );
207 171 }
208 172 }
209 - if ( canAccessAllRestrictedResources() )
210 - {
211 - if ( pRestrictedResource == null )
212 - {
173 + if ( canAccessAllRestrictedResources() ) {
174 + if ( pRestrictedResource == null ) {
213 175 return zAuthorizedRestrictedResources;
214 176 }
215 177 Transaction zTransaction = getFinder().createTransaction();
  @@ -219,22 +181,17 @@
219 181 zTransaction.commit();
220 182 return new UserRestrictedResourcePair<User, RestrictedResource>( zUser, zRestrictedResource );
221 183 }
222 - if ( zAuthorizedRestrictedResources.isEmpty() )
223 - {
184 + if ( zAuthorizedRestrictedResources.isEmpty() ) {
224 185 throw new DisplayableRuntimeException( "NoAuthorizedRestrictedResources" );
225 186 }
226 187 return zAuthorizedRestrictedResources;
227 188 }
228 189
229 - public String acceptablePassword( String pPassword )
230 - {
231 - if ( !isDemo() )
232 - {
233 - if ( pPassword.length() < 8 )
234 - {
190 + public String acceptablePassword( String pPassword ) {
191 + if ( !isDemo() ) {
192 + if ( pPassword.length() < 8 ) {
235 193 String zCurrentPassword = Strings.noEmpty( getPassword() );
236 - if ( (zCurrentPassword == null) || (pPassword.length() < zCurrentPassword.length()) )
237 - {
194 + if ( (zCurrentPassword == null) || (pPassword.length() < zCurrentPassword.length()) ) {
238 195 return "Unacceptable New Password - Too Short";
239 196 }
240 197 }
  @@ -242,32 +199,26 @@
242 199 return null;
243 200 }
244 201
245 - public boolean validatePassword( String pPassword )
246 - {
202 + public boolean validatePassword( String pPassword ) {
247 203 return isDemo() || Strings.deNull( pPassword ).trim().equals( getPassword() );
248 204 }
249 205
250 - public RestrictedResource[] getAlternateRestrictedResourceOptions( RestrictedResource pRestrictedResource )
251 - {
206 + public RestrictedResource[] getAlternateRestrictedResourceOptions( RestrictedResource pRestrictedResource ) {
252 207 List<RestrictedResource> zOptions = new ArrayList<RestrictedResource>();
253 - for ( UserXrefRestrictedResource zUserXrefRestrictedResource : getRestrictedResources() )
254 - {
208 + for ( UserXrefRestrictedResource zUserXrefRestrictedResource : getRestrictedResources() ) {
255 209 RestrictedResource zRestrictedResource = zUserXrefRestrictedResource.getRestrictedResource();
256 - if ( !zRestrictedResource.equals( pRestrictedResource ) )
257 - {
210 + if ( !zRestrictedResource.equals( pRestrictedResource ) ) {
258 211 zOptions.add( zRestrictedResource );
259 212 }
260 213 }
261 214 return zOptions.toArray( new RestrictedResource[zOptions.size()] );
262 215 }
263 216
264 - public boolean canAccessAllRestrictedResources()
265 - {
217 + public boolean canAccessAllRestrictedResources() {
266 218 return Booleans.isAnyTrue( getRestrictedResourceManage(), getSuperAdmin(), getHelpDeskMember() );
267 219 }
268 220
269 - public static WhereClause getLimitToCurrentRestrictedResourceAndVisible()
270 - {
221 + public static WhereClause getLimitToCurrentRestrictedResourceAndVisible() {
271 222 // Add filter to where clause to only select based on RestrictedResource.
272 223 RestrictedResource zRestrictedResource = CurrentRestrictedResourceAccessor.get().getRequiredRestrictedResource();
273 224 WhereClauseFactory zWCF = WhereClauseFactory.INSTANCE;
  @@ -278,8 +229,7 @@
278 229 }
279 230
280 231 @Override
281 - public TextLines getCurrentRestrictedResourceAllowedRoles()
282 - {
232 + public TextLines getCurrentRestrictedResourceAllowedRoles() {
283 233 return new TextLines( Role.OPTIONS ); // todo: Make work for real.
284 234 }
285 235
  @@ -287,14 +237,11 @@
287 237 * Depends upon CurrentRestrictedResource.LastRole
288 238 */
289 239 @Override
290 - public String getLastRestrictedResourceRole()
291 - {
240 + public String getLastRestrictedResourceRole() {
292 241 UserXrefRestrictedResource zCurrentRestrictedResource = getCurrentRestrictedResource();
293 - if ( zCurrentRestrictedResource != null )
294 - {
242 + if ( zCurrentRestrictedResource != null ) {
295 243 String zLastRole = zCurrentRestrictedResource.getLastRole();
296 - if ( zLastRole != null )
297 - {
244 + if ( zLastRole != null ) {
298 245 return zLastRole;
299 246 }
300 247 }
  @@ -302,21 +249,17 @@
302 249 }
303 250
304 251 @Override
305 - protected void LLclearCurrentRestrictedResourceAllowedRoles()
306 - {
252 + protected void LLclearCurrentRestrictedResourceAllowedRoles() {
307 253 }
308 254
309 255 @Override
310 - protected void LLclearLastRestrictedResourceRole()
311 - {
256 + protected void LLclearLastRestrictedResourceRole() {
312 257 }
313 258
314 259 @Override
315 - protected void LLsetLastRestrictedResourceRole( String pLastRestrictedResourceRole )
316 - {
260 + protected void LLsetLastRestrictedResourceRole( String pLastRestrictedResourceRole ) {
317 261 UserXrefRestrictedResource zCurrentRestrictedResource = getCurrentRestrictedResource();
318 - if ( zCurrentRestrictedResource != null )
319 - {
262 + if ( zCurrentRestrictedResource != null ) {
320 263 zCurrentRestrictedResource.setLastRole( pLastRestrictedResourceRole );
321 264 }
322 265 }

View View this file contents

History View the full history

Feeds

Commits for /trunk/GWT_Sandbox/Prioritizer/src/org/litesoft/prioritizer/server/pos/User.java

Need assistance?   Get in touch, or head to our documentation site.