litesoft
Subversion Repository Public Repository

litesoft

URLs

Copy to Clipboard
Explore
Commits

Diff Revisions 947 vs 948 for /trunk/Java/DATT/src/org/litesoft/datt/server/pos/User.java

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

View View this file contents

History View the full history

Feeds

Commits for /trunk/Java/DATT/src/org/litesoft/datt/server/pos/User.java

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