|
1
31
32 package org.opencms.db.generic;
33
34 import org.opencms.configuration.CmsConfigurationManager;
35 import org.opencms.db.CmsDbContext;
36 import org.opencms.db.CmsDbEntryAlreadyExistsException;
37 import org.opencms.db.CmsDbEntryNotFoundException;
38 import org.opencms.db.CmsDbIoException;
39 import org.opencms.db.CmsDbSqlException;
40 import org.opencms.db.CmsDbUtil;
41 import org.opencms.db.CmsDriverManager;
42 import org.opencms.db.I_CmsDriver;
43 import org.opencms.db.I_CmsUserDriver;
44 import org.opencms.file.CmsDataAccessException;
45 import org.opencms.file.CmsGroup;
46 import org.opencms.file.CmsProject;
47 import org.opencms.file.CmsUser;
48 import org.opencms.i18n.CmsEncoder;
49 import org.opencms.i18n.CmsMessageContainer;
50 import org.opencms.main.CmsException;
51 import org.opencms.main.CmsInitException;
52 import org.opencms.main.CmsLog;
53 import org.opencms.main.OpenCms;
54 import org.opencms.security.CmsAccessControlEntry;
55 import org.opencms.security.CmsPasswordEncryptionException;
56 import org.opencms.security.I_CmsPrincipal;
57 import org.opencms.util.CmsStringUtil;
58 import org.opencms.util.CmsUUID;
59
60 import java.io.ByteArrayInputStream  ;
61 import java.io.ByteArrayOutputStream ;
62 import java.io.IOException ;
63 import java.io.ObjectInputStream ;
64 import java.io.ObjectOutputStream ;
65 import java.security.MessageDigest ;
66 import java.security.NoSuchAlgorithmException ;
67 import java.sql.Connection ;
68 import java.sql.PreparedStatement ;
69 import java.sql.ResultSet ;
70 import java.sql.SQLException ;
71 import java.util.ArrayList ;
72 import java.util.Collections ;
73 import java.util.HashMap ;
74 import java.util.Hashtable ;
75 import java.util.List ;
76 import java.util.Map ;
77
78 import org.apache.commons.collections.ExtendedProperties;
79 import org.apache.commons.logging.Log;
80
81
92 public class CmsUserDriver implements I_CmsDriver, I_CmsUserDriver {
93
94
95 private static final Log LOG = CmsLog.getLog(org.opencms.db.generic.CmsUserDriver.class);
96
97
98 protected String m_adminUserName;
99
100
101 protected MessageDigest m_digest;
102
103
104 protected String m_digestAlgorithm;
105
106
107 protected String m_digestFileEncoding;
108
109
110 protected CmsDriverManager m_driverManager;
111
112
113 protected org.opencms.db.generic.CmsSqlManager m_sqlManager;
114
115
118 public void createAccessControlEntry(
119 CmsDbContext dbc,
120 CmsProject project,
121 CmsUUID resource,
122 CmsUUID principal,
123 int allowed,
124 int denied,
125 int flags) throws CmsDataAccessException {
126
127 PreparedStatement stmt = null;
128 Connection conn = null;
129
130 try {
131 conn = m_sqlManager.getConnection(dbc, project.getId());
132 stmt = m_sqlManager.getPreparedStatement(conn, project, "C_ACCESS_CREATE");
133
134 stmt.setString(1, resource.toString());
135 stmt.setString(2, principal.toString());
136 stmt.setInt(3, allowed);
137 stmt.setInt(4, denied);
138 stmt.setInt(5, flags);
139
140 stmt.executeUpdate();
141
142 } catch (SQLException e) {
143 throw new CmsDbSqlException(Messages.get().container(
144 Messages.ERR_GENERIC_SQL_1,
145 CmsDbSqlException.getErrorQuery(stmt)), e);
146 } finally {
147 m_sqlManager.closeAll(dbc, conn, stmt, null);
148 }
149 }
150
151
154 public CmsGroup createGroup(
155 CmsDbContext dbc,
156 CmsUUID groupId,
157 String groupName,
158 String description,
159 int flags,
160 String parentGroupName,
161 Object reservedParam) throws CmsDataAccessException {
162
163 CmsUUID parentId = CmsUUID.getNullUUID();
164 CmsGroup group = null;
165 Connection conn = null;
166 PreparedStatement stmt = null;
167
168 if (existsGroup(dbc, groupName, reservedParam)) {
169 CmsMessageContainer message = Messages.get().container(
170 Messages.ERR_GROUP_WITH_NAME_ALREADY_EXISTS_1,
171 groupName);
172 if (LOG.isErrorEnabled()) {
173 LOG.error(message.key());
174 }
175 throw new CmsDbEntryAlreadyExistsException(message);
176 }
177
178 try {
179 if (CmsStringUtil.isNotEmpty(parentGroupName)) {
181 parentId = readGroup(dbc, parentGroupName).getId();
182 }
183
184 if (reservedParam == null) {
185 conn = m_sqlManager.getConnection(dbc);
187 } else {
188 conn = m_sqlManager.getConnection(dbc, ((Integer )reservedParam).intValue());
190 }
191
192 stmt = m_sqlManager.getPreparedStatement(conn, "C_GROUPS_CREATEGROUP");
193
194 stmt.setString(1, groupId.toString());
196 stmt.setString(2, parentId.toString());
197 stmt.setString(3, groupName);
198 stmt.setString(4, m_sqlManager.validateEmpty(description));
199 stmt.setInt(5, flags);
200 stmt.executeUpdate();
201
202 group = new CmsGroup(groupId, parentId, groupName, description, flags);
203 } catch (SQLException e) {
204 throw new CmsDbSqlException(Messages.get().container(
205 Messages.ERR_GENERIC_SQL_1,
206 CmsDbSqlException.getErrorQuery(stmt)), e);
207 } finally {
208 m_sqlManager.closeAll(dbc, conn, stmt, null);
209 }
210
211 return group;
212 }
213
214
217 public CmsUser createUser(
218 CmsDbContext dbc,
219 String name,
220 String password,
221 String description,
222 String firstname,
223 String lastname,
224 String email,
225 long lastlogin,
226 int flags,
227 Map additionalInfos,
228 String address,
229 int type) throws CmsDataAccessException, CmsPasswordEncryptionException {
230
231 CmsUUID id = new CmsUUID();
232 Connection conn = null;
233 PreparedStatement stmt = null;
234
235 if (existsUser(dbc, name, type, null)) {
236 CmsMessageContainer message = Messages.get().container(Messages.ERR_USER_WITH_NAME_ALREADY_EXISTS_1, name);
237 if (LOG.isErrorEnabled()) {
238 LOG.error(message.key());
239 }
240 throw new CmsDbEntryAlreadyExistsException(message);
241 }
242
243 try {
244 conn = m_sqlManager.getConnection(dbc);
245 stmt = m_sqlManager.getPreparedStatement(conn, "C_USERS_ADD");
246
247 stmt.setString(1, id.toString());
248 stmt.setString(2, name);
249 stmt.setString(3, OpenCms.getPasswordHandler().digest(password));
250 stmt.setString(4, m_sqlManager.validateEmpty(description));
251 stmt.setString(5, m_sqlManager.validateEmpty(firstname));
252 stmt.setString(6, m_sqlManager.validateEmpty(lastname));
253 stmt.setString(7, m_sqlManager.validateEmpty(email));
254 stmt.setLong(8, lastlogin);
255 stmt.setInt(9, flags);
256 m_sqlManager.setBytes(stmt, 10, internalSerializeAdditionalUserInfo(additionalInfos));
257 stmt.setString(11, m_sqlManager.validateEmpty(address));
258 stmt.setInt(12, type);
259 stmt.executeUpdate();
260 } catch (SQLException e) {
261 throw new CmsDbSqlException(Messages.get().container(
262 Messages.ERR_GENERIC_SQL_1,
263 CmsDbSqlException.getErrorQuery(stmt)), e);
264 } catch (IOException e) {
265 throw new CmsDbIoException(Messages.get().container(Messages.ERR_SERIALIZING_USER_DATA_1, name), e);
266 } finally {
267 m_sqlManager.closeAll(dbc, conn, stmt, null);
268 }
269
270 return this.readUser(dbc, id);
271 }
272
273
276 public void createUserInGroup(CmsDbContext dbc, CmsUUID userid, CmsUUID groupid, Object reservedParam)
277 throws CmsDataAccessException {
278
279 Connection conn = null;
280 PreparedStatement stmt = null;
281
282 if (!internalValidateUserInGroup(dbc, userid, groupid, reservedParam)) {
284 try {
286 if (reservedParam == null) {
287 conn = m_sqlManager.getConnection(dbc);
289 } else {
290 conn = m_sqlManager.getConnection(dbc, ((Integer )reservedParam).intValue());
292 }
293
294 stmt = m_sqlManager.getPreparedStatement(conn, "C_GROUPS_ADDUSERTOGROUP");
295
296 stmt.setString(1, groupid.toString());
298 stmt.setString(2, userid.toString());
299 stmt.setInt(3, CmsDbUtil.UNKNOWN_ID);
301 stmt.executeUpdate();
302
303 } catch (SQLException e) {
304 throw new CmsDbSqlException(Messages.get().container(
305 Messages.ERR_GENERIC_SQL_1,
306 CmsDbSqlException.getErrorQuery(stmt)), e);
307 } finally {
308 m_sqlManager.closeAll(dbc, conn, stmt, null);
309 }
310 }
311 }
312
313
316 public void deleteAccessControlEntries(CmsDbContext dbc, CmsProject project, CmsUUID resource)
317 throws CmsDataAccessException {
318
319 PreparedStatement stmt = null;
320 Connection conn = null;
321
322 try {
323 conn = m_sqlManager.getConnection(dbc, project.getId());
324 stmt = m_sqlManager.getPreparedStatement(conn, project, "C_ACCESS_SETFLAGS_ALL");
325
326 stmt.setInt(1, CmsAccessControlEntry.ACCESS_FLAGS_DELETED);
327 stmt.setString(2, resource.toString());
328
329 stmt.executeUpdate();
330
331 } catch (SQLException e) {
332 throw new CmsDbSqlException(Messages.get().container(
333 Messages.ERR_GENERIC_SQL_1,
334 CmsDbSqlException.getErrorQuery(stmt)), e);
335 } finally {
336 m_sqlManager.closeAll(dbc, conn, stmt, null);
337 }
338 }
339
340
343 public void deleteGroup(CmsDbContext dbc, String name) throws CmsDataAccessException {
344
345 Connection conn = null;
346 PreparedStatement stmt = null;
347
348 try {
349 conn = m_sqlManager.getConnection(dbc);
351 stmt = m_sqlManager.getPreparedStatement(conn, "C_GROUPS_DELETEGROUP");
352
353 stmt.setString(1, name);
354 stmt.executeUpdate();
355 } catch (SQLException e) {
356 throw new CmsDbSqlException(Messages.get().container(
357 Messages.ERR_GENERIC_SQL_1,
358 CmsDbSqlException.getErrorQuery(stmt)), e);
359 } finally {
360 m_sqlManager.closeAll(dbc, conn, stmt, null);
361 }
362 }
363
364
367 public void deleteUser(CmsDbContext dbc, String userName) throws CmsDataAccessException {
368
369 Connection conn = null;
370 PreparedStatement stmt = null;
371
372 try {
373 conn = m_sqlManager.getConnection(dbc);
374 stmt = m_sqlManager.getPreparedStatement(conn, "C_USERS_DELETE");
375
376 stmt.setString(1, userName);
377 stmt.executeUpdate();
378 } catch (SQLException e) {
379 throw new CmsDbSqlException(Messages.get().container(
380 Messages.ERR_GENERIC_SQL_1,
381 CmsDbSqlException.getErrorQuery(stmt)), e);
382 } finally {
383 m_sqlManager.closeAll(dbc, conn, stmt, null);
384 }
385 }
386
387
390 public void deleteUserInGroup(CmsDbContext dbc, CmsUUID userId, CmsUUID groupId) throws CmsDataAccessException {
391
392 PreparedStatement stmt = null;
393 Connection conn = null;
394 try {
395 conn = m_sqlManager.getConnection(dbc);
397 stmt = m_sqlManager.getPreparedStatement(conn, "C_GROUPS_REMOVEUSERFROMGROUP");
398
399 stmt.setString(1, groupId.toString());
400 stmt.setString(2, userId.toString());
401 stmt.executeUpdate();
402 } catch (SQLException e) {
403 throw new CmsDbSqlException(Messages.get().container(
404 Messages.ERR_GENERIC_SQL_1,
405 CmsDbSqlException.getErrorQuery(stmt)), e);
406 } finally {
407 m_sqlManager.closeAll(dbc, conn, stmt, null);
408 }
409 }
410
411
414 public void destroy() throws Throwable {
415
416 finalize();
417 if (CmsLog.INIT.isInfoEnabled()) {
418 CmsLog.INIT.info(Messages.get().getBundle().key(Messages.INIT_SHUTDOWN_DRIVER_1, getClass().getName()));
419 }
420 }
421
422
425 public boolean existsGroup(CmsDbContext dbc, String groupName, Object reservedParam) throws CmsDataAccessException {
426
427 ResultSet res = null;
428 PreparedStatement stmt = null;
429 Connection conn = null;
430 boolean result = false;
431
432 try {
433 if (reservedParam == null) {
434 conn = m_sqlManager.getConnection(dbc);
436 } else {
437 conn = m_sqlManager.getConnection(dbc, ((Integer )reservedParam).intValue());
439 }
440
441 stmt = m_sqlManager.getPreparedStatement(conn, "C_GROUPS_READGROUP");
442
443 stmt.setString(1, groupName);
444 res = stmt.executeQuery();
445
446 if (res.next()) {
448 result = true;
449 } else {
450 result = false;
451 }
452
453 } catch (SQLException e) {
454 throw new CmsDbSqlException(Messages.get().container(
455 Messages.ERR_GENERIC_SQL_1,
456 CmsDbSqlException.getErrorQuery(stmt)), e);
457 } finally {
458 m_sqlManager.closeAll(dbc, conn, stmt, res);
459 }
460
461 return result;
462 }
463
464
467 public boolean existsUser(CmsDbContext dbc, String username, int usertype, Object reservedParam)
468 throws CmsDataAccessException {
469
470 PreparedStatement stmt = null;
471 ResultSet res = null;
472 Connection conn = null;
473 boolean result = false;
474
475 try {
476 if (reservedParam == null) {
477 conn = m_sqlManager.getConnection(dbc);
479 } else {
480 conn = m_sqlManager.getConnection(dbc, ((Integer )reservedParam).intValue());
482 }
483
484 stmt = m_sqlManager.getPreparedStatement(conn, "C_USERS_READ");
485 stmt.setString(1, username);
486 stmt.setInt(2, usertype);
487
488 res = stmt.executeQuery();
489
490 if (res.next()) {
491 result = true;
492 } else {
493 result = false;
494 }
495 } catch (SQLException e) {
496 throw new CmsDbSqlException(Messages.get().container(
497 Messages.ERR_GENERIC_SQL_1,
498 CmsDbSqlException.getErrorQuery(stmt)), e);
499 } finally {
500 m_sqlManager.closeAll(dbc, conn, stmt, res);
501 }
502
503 return result;
504 }
505
506
509 public CmsSqlManager getSqlManager() {
510
511 return m_sqlManager;
512 }
513
514
517 public CmsUser importUser(
518 CmsDbContext dbc,
519 CmsUUID id,
520 String name,
521 String password,
522 String description,
523 String firstname,
524 String lastname,
525 String email,
526 long lastlogin,
527 int flags,
528 Map additionalInfos,
529 String address,
530 int type,
531 Object reservedParam) throws CmsDataAccessException {
532
533 Connection conn = null;
534 PreparedStatement stmt = null;
535
536 if (existsUser(dbc, name, type, reservedParam)) {
537 CmsMessageContainer message = Messages.get().container(Messages.ERR_USER_WITH_NAME_ALREADY_EXISTS_1, name);
538 if (LOG.isErrorEnabled()) {
539 LOG.error(message.key());
540 }
541 throw new CmsDbEntryAlreadyExistsException(message);
542 }
543
544 try {
545 if (reservedParam == null) {
546 conn = m_sqlManager.getConnection(dbc);
548 } else {
549 conn = m_sqlManager.getConnection(dbc, ((Integer )reservedParam).intValue());
551 }
552
553 stmt = m_sqlManager.getPreparedStatement(conn, "C_USERS_ADD");
554
555 stmt.setString(1, id.toString());
556 stmt.setString(2, name);
557 stmt.setString(3, m_sqlManager.validateEmpty(password));
558 stmt.setString(4, m_sqlManager.validateEmpty(description));
559 stmt.setString(5, m_sqlManager.validateEmpty(firstname));
560 stmt.setString(6, m_sqlManager.validateEmpty(lastname));
561 stmt.setString(7, m_sqlManager.validateEmpty(email));
562 stmt.setLong(8, lastlogin);
563 stmt.setInt(9, flags);
564 m_sqlManager.setBytes(stmt, 10, internalSerializeAdditionalUserInfo(additionalInfos));
565 stmt.setString(11, m_sqlManager.validateEmpty(address));
566 stmt.setInt(12, type);
567 stmt.executeUpdate();
568 } catch (SQLException e) {
569 throw new CmsDbSqlException(Messages.get().container(
570 Messages.ERR_GENERIC_SQL_1,
571 CmsDbSqlException.getErrorQuery(stmt)), e);
572 } catch (IOException e) {
573 throw new CmsDbIoException(Messages.get().container(Messages.ERR_SERIALIZING_USER_DATA_1, name), e);
574 } finally {
575 m_sqlManager.closeAll(dbc, conn, stmt, null);
576 }
577
578 return readUser(dbc, id);
579 }
580
581
584 public void init(
585 CmsDbContext dbc,
586 CmsConfigurationManager configurationManager,
587 List successiveDrivers,
588 CmsDriverManager driverManager) {
589
590 Map configuration = configurationManager.getConfiguration();
591
592 ExtendedProperties config;
593 if (configuration instanceof ExtendedProperties) {
594 config = (ExtendedProperties)configuration;
595 } else {
596 config = new ExtendedProperties();
597 config.putAll(configuration);
598 }
599
600 String poolUrl = config.get("db.user.pool").toString();
601 String classname = config.get("db.user.sqlmanager").toString();
602 m_sqlManager = this.initSqlManager(classname);
603 m_sqlManager.init(I_CmsUserDriver.DRIVER_TYPE_ID, poolUrl);
604
605 m_driverManager = driverManager;
606
607 if (CmsLog.INIT.isInfoEnabled()) {
608 CmsLog.INIT.info(Messages.get().getBundle().key(Messages.INIT_ASSIGNED_POOL_1, poolUrl));
609 }
610
611 m_digestAlgorithm = config.getString(CmsDriverManager.CONFIGURATION_DB + ".user.digest.type", "MD5");
612 if (CmsLog.INIT.isInfoEnabled()) {
613 CmsLog.INIT.info(Messages.get().getBundle().key(Messages.INIT_DIGEST_ALGORITHM_1, m_digestAlgorithm));
614 }
615
616 m_digestFileEncoding = config.getString(
617 CmsDriverManager.CONFIGURATION_DB + ".user.digest.encoding",
618 CmsEncoder.ENCODING_UTF_8);
619 if (CmsLog.INIT.isInfoEnabled()) {
620 CmsLog.INIT.info(Messages.get().getBundle().key(Messages.INIT_DIGEST_ENCODING_1, m_digestFileEncoding));
621 }
622
623 try {
625 m_digest = MessageDigest.getInstance(m_digestAlgorithm);
626 if (CmsLog.INIT.isInfoEnabled()) {
627 CmsLog.INIT.info(Messages.get().getBundle().key(
628 Messages.INIT_DIGEST_ENC_3,
629 m_digest.getAlgorithm(),
630 m_digest.getProvider().getName(),
631 String.valueOf(m_digest.getProvider().getVersion())));
632 }
633 } catch (NoSuchAlgorithmException e) {
634 if (CmsLog.INIT.isInfoEnabled()) {
635 CmsLog.INIT.info(Messages.get().getBundle().key(Messages.INIT_SET_DIGEST_ERROR_0), e);
636 }
637 }
638
639 m_adminUserName = OpenCms.getDefaultUsers().getUserAdmin();
640
641 try {
642 if (!existsGroup(dbc, OpenCms.getDefaultUsers().getGroupAdministrators(), null)) {
643 fillDefaults(dbc);
644 }
645 } catch (CmsException e) {
646 if (CmsLog.INIT.isErrorEnabled()) {
647 CmsLog.INIT.error(Messages.get().getBundle().key(Messages.INIT_USER_GROUP_INITIALIZATION_FAILED_0), e);
648 }
649 throw new CmsInitException(Messages.get().container(Messages.ERR_INITIALIZING_USER_DRIVER_0), e);
650 }
651
652 if (successiveDrivers != null && !successiveDrivers.isEmpty()) {
653 if (LOG.isWarnEnabled()) {
654 LOG.warn(Messages.get().getBundle().key(
655 Messages.LOG_SUCCESSIVE_DRIVERS_UNSUPPORTED_1,
656 getClass().getName()));
657 }
658 }
659 }
660
661
664 public org.opencms.db.generic.CmsSqlManager initSqlManager(String classname) {
665
666 return CmsSqlManager.getInstance(classname);
667 }
668
669
672 public void publishAccessControlEntries(
673 CmsDbContext dbc,
674 CmsProject offlineProject,
675 CmsProject onlineProject,
676 CmsUUID offlineId,
677 CmsUUID onlineId) throws CmsDataAccessException {
678
679 PreparedStatement stmt = null;
680 Connection conn = null;
681 ResultSet res = null;
682
683 removeAccessControlEntries(dbc, onlineProject, onlineId);
685
686 try {
688 conn = m_sqlManager.getConnection(dbc);
689 stmt = m_sqlManager.getPreparedStatement(conn, offlineProject, "C_ACCESS_READ_ENTRIES");
690
691 stmt.setString(1, offlineId.toString());
692
693 res = stmt.executeQuery();
694
695 while (res.next()) {
696 CmsAccessControlEntry ace = internalCreateAce(res, onlineId);
697 if ((ace.getFlags() & CmsAccessControlEntry.ACCESS_FLAGS_DELETED) == 0) {
698 writeAccessControlEntry(dbc, onlineProject, ace);
699 }
700 }
701
702 } catch (SQLException e) {
703 throw new CmsDbSqlException(Messages.get().container(
704 Messages.ERR_GENERIC_SQL_1,
705 CmsDbSqlException.getErrorQuery(stmt)), e);
706 } finally {
707 m_sqlManager.closeAll(dbc, conn, stmt, res);
708 }
709 }
710
711
714 public List readAccessControlEntries(CmsDbContext dbc, CmsProject project, CmsUUID resource, boolean inheritedOnly)
715 throws CmsDataAccessException {
716
717 List aceList = new ArrayList ();
718 PreparedStatement stmt = null;
719 Connection conn = null;
720 ResultSet res = null;
721
722 try {
723 conn = m_sqlManager.getConnection(dbc);
724 stmt = m_sqlManager.getPreparedStatement(conn, project, "C_ACCESS_READ_ENTRIES");
725
726 String resId = resource.toString();
727 stmt.setString(1, resId);
728
729 res = stmt.executeQuery();
730
731 while (res.next()) {
733 CmsAccessControlEntry ace = internalCreateAce(res);
734 if ((ace.getFlags() & CmsAccessControlEntry.ACCESS_FLAGS_DELETED) > 0) {
735 continue;
736 }
737
738 if (inheritedOnly && ((ace.getFlags() & CmsAccessControlEntry.ACCESS_FLAGS_INHERIT) == 0)) {
739 continue;
740 }
741
742 if (inheritedOnly && ((ace.getFlags() & CmsAccessControlEntry.ACCESS_FLAGS_INHERIT) > 0)) {
743 ace.setFlags(CmsAccessControlEntry.ACCESS_FLAGS_INHERITED);
744 }
745
746 aceList.add(ace);
747 }
748
749 return aceList;
750
751 } catch (SQLException e) {
752 throw new CmsDbSqlException(Messages.get().container(
753 Messages.ERR_GENERIC_SQL_1,
754 CmsDbSqlException.getErrorQuery(stmt)), e);
755 } finally {
756 m_sqlManager.closeAll(dbc, conn, stmt, res);
757 }
758 }
759
760
763 public CmsAccessControlEntry readAccessControlEntry(
764 CmsDbContext dbc,
765 CmsProject project,
766 CmsUUID resource,
767 CmsUUID principal) throws CmsDataAccessException {
768
769 CmsAccessControlEntry ace = null;
770 PreparedStatement stmt = null;
771 Connection conn = null;
772 ResultSet res = null;
773
774 try {
775 conn = m_sqlManager.getConnection(dbc);
776 stmt = m_sqlManager.getPreparedStatement(conn, project, "C_ACCESS_READ_ENTRY");
777
778 stmt.setString(1, resource.toString());
779 stmt.setString(2, principal.toString());
780
781 res = stmt.executeQuery();
782
783 if (res.next()) {
785 ace = internalCreateAce(res);
786 } else {
787 res.close();
788 res = null;
789 throw new CmsDbEntryNotFoundException(Messages.get().container(
790 Messages.ERR_NO_ACE_FOUND_2,
791 resource,
792 principal));
793 }
794
795 return ace;
796
797 } catch (SQLException e) {
798 throw new CmsDbSqlException(Messages.get().container(
799 Messages.ERR_GENERIC_SQL_1,
800 CmsDbSqlException.getErrorQuery(stmt)), e);
801 } finally {
802 m_sqlManager.closeAll(dbc, conn, stmt, res);
803 }
804 }
805
806
809 public List readChildGroups(CmsDbContext dbc, String groupname) throws CmsDataAccessException {
810
811 List childs = new ArrayList ();
812 CmsGroup group;
813 CmsGroup parent;
814 ResultSet res = null;
815 PreparedStatement stmt = null;
816 Connection conn = null;
817 try {
818 parent = readGroup(dbc, groupname);
820 if (parent != null) {
822 conn = m_sqlManager.getConnection(dbc);
824 stmt = m_sqlManager.getPreparedStatement(conn, "C_GROUPS_GETCHILD");
825 stmt.setString(1, parent.getId().toString());
826 res = stmt.executeQuery();
827 while (res.next()) {
829 group = new CmsGroup(
830 new CmsUUID(res.getString(m_sqlManager.readQuery("C_GROUPS_GROUP_ID"))),
831 new CmsUUID(res.getString(m_sqlManager.readQuery("C_GROUPS_PARENT_GROUP_ID"))),
832 res.getString(m_sqlManager.readQuery("C_GROUPS_GROUP_NAME")),
833 res.getString(m_sqlManager.readQuery("C_GROUPS_GROUP_DESCRIPTION")),
834 res.getInt(m_sqlManager.readQuery("C_GROUPS_GROUP_FLAGS")));
835 childs.add(group);
836 }
837 }
838
839 } catch (SQLException e) {
840 throw new CmsDbSqlException(Messages.get().container(
841 Messages.ERR_GENERIC_SQL_1,
842 CmsDbSqlException.getErrorQuery(stmt)), e);
843 } finally {
844 m_sqlManager.closeAll(dbc, conn, stmt, res);
846 }
847 return childs;
848 }
849
850
853 public CmsGroup readGroup(CmsDbContext dbc, CmsUUID groupId) throws CmsDataAccessException {
854
855 CmsGroup group = null;
856 ResultSet res = null;
857 PreparedStatement stmt = null;
858 Connection conn = null;
859
860 try {
861 conn = m_sqlManager.getConnection(dbc);
862 stmt = m_sqlManager.getPreparedStatement(conn, "C_GROUPS_READGROUP2");
863
864 stmt.setString(1, groupId.toString());
866 res = stmt.executeQuery();
867 if (res.next()) {
869 group = internalCreateGroup(res);
870 } else {
871 CmsMessageContainer message = Messages.get().container(Messages.ERR_NO_GROUP_WITH_ID_1, groupId);
872 if (LOG.isDebugEnabled()) {
873 LOG.debug(message.key());
874 }
875 throw new CmsDbEntryNotFoundException(message);
876 }
877
878 } catch (SQLException e) {
879 throw new CmsDbSqlException(Messages.get().container(
880 Messages.ERR_GENERIC_SQL_1,
881 CmsDbSqlException.getErrorQuery(stmt)), e);
882 } finally {
883 m_sqlManager.closeAll(dbc, conn, stmt, res);
884 }
885
886 return group;
887 }
888
889
892 public CmsGroup readGroup(CmsDbContext dbc, String groupName) throws CmsDataAccessException {
893
894 CmsGroup group = null;
895 ResultSet res = null;
896 PreparedStatement stmt = null;
897 Connection conn = null;
898
899 try {
900 conn = m_sqlManager.getConnection(dbc);
901 stmt = m_sqlManager.getPreparedStatement(conn, "C_GROUPS_READGROUP");
902
903 stmt.setString(1, groupName);
905 res = stmt.executeQuery();
906
907 if (res.next()) {
909 group = internalCreateGroup(res);
910 } else {
911 CmsMessageContainer message = org.opencms.db.Messages.get().container(
912 org.opencms.db.Messages.ERR_UNKNOWN_GROUP_1,
913 groupName);
914 if (LOG.isWarnEnabled()) {
915 LOG.warn(message.key());
916 }
917 throw new CmsDbEntryNotFoundException(message);
918 }
919
920 } catch (SQLException e) {
921 throw new CmsDbSqlException(Messages.get().container(
922 Messages.ERR_GENERIC_SQL_1,
923 CmsDbSqlException.getErrorQuery(stmt)), e);
924 } finally {
925 m_sqlManager.closeAll(dbc, conn, stmt, res);
926 }
927 return group;
928 }
929
930
933 public List readGroups(CmsDbContext dbc) throws CmsDataAccessException {
934
935 List groups = new ArrayList ();
936 ResultSet res = null;
938 PreparedStatement stmt = null;
939 Connection conn = null;
940 try {
941 conn = m_sqlManager.getConnection(dbc);
943 stmt = m_sqlManager.getPreparedStatement(conn, "C_GROUPS_GETGROUPS");
944
945 res = stmt.executeQuery();
946
947 while (res.next()) {
949 groups.add(internalCreateGroup(res));
950 }
951
952 } catch (SQLException e) {
953 throw new CmsDbSqlException(Messages.get().container(
954 Messages.ERR_GENERIC_SQL_1,
955 CmsDbSqlException.getErrorQuery(stmt)), e);
956 } finally {
957 m_sqlManager.closeAll(dbc, conn, stmt, res);
958 }
959 return groups;
960 }
961
962
965 public List readGroupsOfUser(CmsDbContext dbc, CmsUUID userId, String paramStr) throws CmsDataAccessException {
966
967 List groups = new ArrayList ();
969
970 PreparedStatement stmt = null;
971 ResultSet res = null;
972 Connection conn = null;
973
974 try {
975 conn = m_sqlManager.getConnection(dbc);
976 stmt = m_sqlManager.getPreparedStatement(conn, "C_GROUPS_GETGROUPSOFUSER");
977
978 stmt.setString(1, userId.toString());
980
981 res = stmt.executeQuery();
982
983 while (res.next()) {
984 groups.add(internalCreateGroup(res));
985 }
986 } catch (SQLException e) {
987 throw new CmsDbSqlException(Messages.get().container(
988 Messages.ERR_GENERIC_SQL_1,
989 CmsDbSqlException.getErrorQuery(stmt)), e);
990 } finally {
991 m_sqlManager.closeAll(dbc, conn, stmt, res);
992 }
993 return groups;
994 }
995
996
999 public CmsUser readUser(CmsDbContext dbc, CmsUUID id) throws CmsDataAccessException {
1000
1001 PreparedStatement stmt = null;
1002 ResultSet res = null;
1003 CmsUser user = null;
1004 Connection conn = null;
1005
1006 try {
1007 conn = m_sqlManager.getConnection(dbc);
1008 stmt = m_sqlManager.getPreparedStatement(conn, "C_USERS_READID");
1009
1010 stmt.setString(1, id.toString());
1011 res = stmt.executeQuery();
1012
1013 if (res.next()) {
1015 user = internalCreateUser(res);
1016 } else {
1017 CmsMessageContainer message = Messages.get().container(Messages.ERR_NO_USER_WITH_ID_1, id);
1018 if (LOG.isDebugEnabled()) {
1019 LOG.debug(message.key());
1020 }
1021 throw new CmsDbEntryNotFoundException(message);
1022 }
1023
1024 return user;
1025 } catch (SQLException e) {
1026 throw new CmsDbSqlException(Messages.get().container(
1027 Messages.ERR_GENERIC_SQL_1,
1028 CmsDbSqlException.getErrorQuery(stmt)), e);
1029 } catch (IOException e) {
1030 throw new CmsDbIoException(Messages.get().container(Messages.ERR_READING_USER_0), e);
1031 } catch (ClassNotFoundException e) {
1032 throw new CmsDataAccessException(Messages.get().container(Messages.ERR_READING_USER_0), e);
1033 } finally {
1034 m_sqlManager.closeAll(dbc, conn, stmt, res);
1035 }
1036 }
1037
1038
1041 public CmsUser readUser(CmsDbContext dbc, String name, int type) throws CmsDataAccessException {
1042
1043 PreparedStatement stmt = null;
1044 ResultSet res = null;
1045 CmsUser user = null;
1046 Connection conn = null;
1047
1048 try {
1049 conn = m_sqlManager.getConnection(dbc);
1050 stmt = m_sqlManager.getPreparedStatement(conn, "C_USERS_READ");
1051 stmt.setString(1, name);
1052 stmt.setInt(2, type);
1053
1054 res = stmt.executeQuery();
1055
1056 if (res.next()) {
1057 user = internalCreateUser(res);
1058 } else {
1059 CmsMessageContainer message = org.opencms.db.Messages.get().container(
1060 org.opencms.db.Messages.ERR_UNKNOWN_USER_1,
1061 name);
1062 if (LOG.isDebugEnabled()) {
1063 LOG.debug(message.key());
1064 }
1065 throw new CmsDbEntryNotFoundException(message);
1066 }
1067 } catch (SQLException e) {
1068 throw new CmsDbSqlException(Messages.get().container(
1069 Messages.ERR_GENERIC_SQL_1,
1070 CmsDbSqlException.getErrorQuery(stmt)), e);
1071 } catch (IOException e) {
1072 throw new CmsDbIoException(Messages.get().container(Messages.ERR_READING_USER_0), e);
1073 } catch (ClassNotFoundException e) {
1074 throw new CmsDataAccessException(Messages.get().container(Messages.ERR_READING_USER_0), e);
1075 } finally {
1076 m_sqlManager.closeAll(dbc, conn, stmt, res);
1077 }
1078
1079 return user;
1080 }
1081
1082
1085 public CmsUser readUser(CmsDbContext dbc, String name, String password, int type)
1086 throws CmsDataAccessException, CmsPasswordEncryptionException {
1087
1088 PreparedStatement stmt = null;
1089 ResultSet res = null;
1090 CmsUser user = null;
1091 Connection conn = null;
1092 try {
1093 conn = m_sqlManager.getConnection(dbc);
1094 stmt = m_sqlManager.getPreparedStatement(conn, "C_USERS_READPW");
1095 stmt.setString(1, name);
1096 stmt.setString(2, OpenCms.getPasswordHandler().digest(password));
1097 stmt.setInt(3, type);
1098 res = stmt.executeQuery();
1099
1100 if (res.next()) {
1102 user = internalCreateUser(res);
1103 } else {
1104 res.close();
1105 res = null;
1106 CmsMessageContainer message = org.opencms.db.Messages.get().container(
1107 org.opencms.db.Messages.ERR_UNKNOWN_USER_1,
1108 name);
1109 if (LOG.isDebugEnabled()) {
1110 LOG.debug(message.key());
1111 }
1112 throw new CmsDbEntryNotFoundException(message);
1113 }
1114
1115 return user;
1116 } catch (SQLException e) {
1117 throw new CmsDbSqlException(Messages.get().container(
1118 Messages.ERR_GENERIC_SQL_1,
1119 CmsDbSqlException.getErrorQuery(stmt)), e);
1120 } catch (IOException e) {
1121 throw new CmsDbIoException(Messages.get().container(Messages.ERR_READING_USER_0), e);
1122 } catch (ClassNotFoundException e) {
1123 throw new CmsDataAccessException(Messages.get().container(Messages.ERR_READING_USER_0), e);
1124 } finally {
1125 m_sqlManager.closeAll(dbc, conn, stmt, res);
1126 }
1127 }
1128
1129
1132 public CmsUser readUser(CmsDbContext dbc, String name, String password, String remoteAddress, int type)
1133 throws CmsDataAccessException, CmsPasswordEncryptionException {
1134
1135 CmsUser user = readUser(dbc, name, password, type);
1136 return user;
1137 }
1138
1139
1142 public List readUsers(CmsDbContext dbc, int type) throws CmsDataAccessException {
1143
1144 List users = new ArrayList ();
1145 PreparedStatement stmt = null;
1146 ResultSet res = null;
1147 Connection conn = null;
1148
1149 try {
1150 conn = m_sqlManager.getConnection(dbc);
1151 stmt = m_sqlManager.getPreparedStatement(conn, "C_USERS_GETUSERS");
1152 stmt.setInt(1, type);
1153 res = stmt.executeQuery();
1154 while (res.next()) {
1156 users.add(internalCreateUser(res));
1157 }
1158 } catch (SQLException e) {
1159 throw new CmsDbSqlException(Messages.get().container(
1160 Messages.ERR_GENERIC_SQL_1,
1161 CmsDbSqlException.getErrorQuery(stmt)), e);
1162 } catch (IOException e) {
1163 throw new CmsDbIoException(Messages.get().container(Messages.ERR_READING_USERS_0), e);
1164 } catch (ClassNotFoundException e) {
1165 throw new CmsDataAccessException(Messages.get().container(Messages.ERR_READING_USERS_0), e);
1166 } finally {
1167 m_sqlManager.closeAll(dbc, conn, stmt, res);
1168 }
1169 return users;
1170 }
1171
1172
1175 public List readUsersOfGroup(CmsDbContext dbc, String name, int type) throws CmsDataAccessException {
1176
1177 List users = new ArrayList ();
1178
1179 PreparedStatement stmt = null;
1180 ResultSet res = null;
1181 Connection conn = null;
1182
1183 try {
1184 conn = m_sqlManager.getConnection(dbc);
1185 stmt = m_sqlManager.getPreparedStatement(conn, "C_GROUPS_GETUSERSOFGROUP");
1186 stmt.setString(1, name);
1187 stmt.setInt(2, type);
1188
1189 res = stmt.executeQuery();
1190
1191 while (res.next()) {
1192 users.add(internalCreateUser(res));
1193 }
1194 } catch (SQLException e) {
1195 throw new CmsDbSqlException(Messages.get().container(
1196 Messages.ERR_GENERIC_SQL_1,
1197 CmsDbSqlException.getErrorQuery(stmt)), e);
1198 } catch (IOException e) {
1199 throw new CmsDbIoException(org.opencms.db.Messages.get().container(
1200 org.opencms.db.Messages.ERR_GET_USERS_OF_GROUP_1,
1201 name), e);
1202 } catch (ClassNotFoundException e) {
1203 throw new CmsDataAccessException(org.opencms.db.Messages.get().container(
1204 org.opencms.db.Messages.ERR_GET_USERS_OF_GROUP_1,
1205 name), e);
1206 } finally {
1207 m_sqlManager.closeAll(dbc, conn, stmt, res);
1208 }
1209
1210 return users;
1211 }
1212
1213
1216 public void removeAccessControlEntries(CmsDbContext dbc, CmsProject project, CmsUUID resource)
1217 throws CmsDataAccessException {
1218
1219 PreparedStatement stmt = null;
1220 Connection conn = null;
1221
1222 try {
1223 conn = m_sqlManager.getConnection(dbc, project.getId());
1224 stmt = m_sqlManager.getPreparedStatement(conn, project, "C_ACCESS_REMOVE_ALL");
1225
1226 stmt.setString(1, resource.toString());
1227
1228 stmt.executeUpdate();
1229
1230 } catch (SQLException e) {
1231 throw new CmsDbSqlException(Messages.get().container(
1232 Messages.ERR_GENERIC_SQL_1,
1233 CmsDbSqlException.getErrorQuery(stmt)), e);
1234 } finally {
1235 m_sqlManager.closeAll(dbc, conn, stmt, null);
1236 }
1237 }
1238
1239
1242 public void removeAccessControlEntriesForPrincipal(
1243 CmsDbContext dbc,
1244 CmsProject project,
1245 CmsProject onlineProject,
1246 CmsUUID principal) throws CmsDataAccessException {
1247
1248 PreparedStatement stmt = null;
1249 Connection conn = null;
1250
1251 try {
1252
1253 conn = m_sqlManager.getConnection(dbc, project.getId());
1254 stmt = m_sqlManager.getPreparedStatement(conn, project, "C_ACCESS_REMOVE_ALL_FOR_PRINCIPAL");
1255
1256 stmt.setString(1, principal.toString());
1257 stmt.executeUpdate();
1258 } catch (SQLException e) {
1259 throw new CmsDbSqlException(Messages.get().container(
1260 Messages.ERR_GENERIC_SQL_1,
1261 CmsDbSqlException.getErrorQuery(stmt)), e);
1262 } finally {
1263 m_sqlManager.closeAll(dbc, conn, stmt, null);
1264 }
1265
1266 try {
1267 conn = m_sqlManager.getConnection(dbc, project.getId());
1268 stmt = m_sqlManager.getPreparedStatement(conn, project, "C_ACCESS_REMOVE_ALL_FOR_PRINCIPAL_ONLINE");
1269
1270 stmt.setString(1, principal.toString());
1271
1272 stmt.executeUpdate();
1273
1274 } catch (SQLException e) {
1275 throw new CmsDbSqlException(Messages.get().container(Messages.ERR_GENERIC_SQL_1, stmt), e);
1276 } finally {
1277 m_sqlManager.closeAll(dbc, conn, stmt, null);
1278 }
1279 }
1280
1281
1284 public void removeAccessControlEntry(CmsDbContext dbc, CmsProject project, CmsUUID resource, CmsUUID principal)
1285 throws CmsDataAccessException {
1286
1287 PreparedStatement stmt = null;
1288 Connection conn = null;
1289
1290 try {
1291 conn = m_sqlManager.getConnection(dbc, project.getId());
1292 stmt = m_sqlManager.getPreparedStatement(conn, project, "C_ACCESS_REMOVE");
1293
1294 stmt.setString(1, resource.toString());
1295 stmt.setString(2, principal.toString());
1296 stmt.executeUpdate();
1297
1298 } catch (SQLException e) {
1299 throw new CmsDbSqlException(Messages.get().container(
1300 Messages.ERR_GENERIC_SQL_1,
1301 CmsDbSqlException.getErrorQuery(stmt)), e);
1302 } finally {
1303 m_sqlManager.closeAll(dbc, conn, stmt, null);
1304 }
1305 }
1306
1307
1310 public void writeAccessControlEntry(CmsDbContext dbc, CmsProject project, CmsAccessControlEntry acEntry)
1311 throws CmsDataAccessException {
1312
1313 PreparedStatement stmt = null;
1314 Connection conn = null;
1315 ResultSet res = null;
1316
1317 try {
1318 conn = m_sqlManager.getConnection(dbc, project.getId());
1319 stmt = m_sqlManager.getPreparedStatement(conn, project, "C_ACCESS_READ_ENTRY");
1320
1321 stmt.setString(1, acEntry.getResource().toString());
1322 stmt.setString(2, acEntry.getPrincipal().toString());
1323
1324 res = stmt.executeQuery();
1325 if (!res.next()) {
1326 createAccessControlEntry(
1327 dbc,
1328 project,
1329 acEntry.getResource(),
1330 acEntry.getPrincipal(),
1331 acEntry.getAllowedPermissions(),
1332 acEntry.getDeniedPermissions(),
1333 acEntry.getFlags());
1334 return;
1335 }
1336
1337
1339 stmt = m_sqlManager.getPreparedStatement(conn, project, "C_ACCESS_UPDATE");
1340
1341 stmt.setInt(1, acEntry.getAllowedPermissions());
1342 stmt.setInt(2, acEntry.getDeniedPermissions());
1343 stmt.setInt(3, acEntry.getFlags());
1344 stmt.setString(4, acEntry.getResource().toString());
1345 stmt.setString(5, acEntry.getPrincipal().toString());
1346
1347 stmt.executeUpdate();
1348
1349 } catch (SQLException e) {
1350 throw new CmsDbSqlException(Messages.get().container(
1351 Messages.ERR_GENERIC_SQL_1,
1352 CmsDbSqlException.getErrorQuery(stmt)), e);
1353 } finally {
1354 m_sqlManager.closeAll(dbc, conn, stmt, res);
1355 }
1356 }
1357
1358
1361 public void writeGroup(CmsDbContext dbc, CmsGroup group) throws CmsDataAccessException {
1362
1363 PreparedStatement stmt = null;
1364 Connection conn = null;
1365 if (group != null) {
1366 try {
1367
1368 conn = m_sqlManager.getConnection(dbc);
1370 stmt = m_sqlManager.getPreparedStatement(conn, "C_GROUPS_WRITEGROUP");
1371
1372 stmt.setString(1, m_sqlManager.validateEmpty(group.getDescription()));
1373 stmt.setInt(2, group.getFlags());
1374 stmt.setString(3, group.getParentId().toString());
1375 stmt.setString(4, group.getId().toString());
1376 stmt.executeUpdate();
1377
1378 } catch (SQLException e) {
1379 throw new CmsDbSqlException(Messages.get().container(
1380 Messages.ERR_GENERIC_SQL_1,
1381 CmsDbSqlException.getErrorQuery(stmt)), e);
1382 } finally {
1383 m_sqlManager.closeAll(dbc, conn, stmt, null);
1384 }
1385 } else {
1386 throw new CmsDbEntryNotFoundException(org.opencms.db.Messages.get().container(
1387 org.opencms.db.Messages.ERR_UNKNOWN_GROUP_1,
1388 group.getName()));
1389 }
1390 }
1391
1392
1395 public void writePassword(CmsDbContext dbc, String userName, int type, String oldPassword, String newPassword)
1396 throws CmsDataAccessException, CmsPasswordEncryptionException {
1397
1398 PreparedStatement stmt = null;
1399 Connection conn = null;
1400
1401 try {
1404 conn = m_sqlManager.getConnection(dbc);
1405 stmt = m_sqlManager.getPreparedStatement(conn, "C_USERS_SETPW");
1406 stmt.setString(1, OpenCms.getPasswordHandler().digest(newPassword));
1407 stmt.setString(2, userName);
1408 stmt.executeUpdate();
1409 } catch (SQLException e) {
1410 throw new CmsDbSqlException(Messages.get().container(
1411 Messages.ERR_GENERIC_SQL_1,
1412 CmsDbSqlException.getErrorQuery(stmt)), e);
1413 } finally {
1414 m_sqlManager.closeAll(dbc, conn, stmt, null);
1415 }
1416 }
1417
1418
1421 public void writeUser(CmsDbContext dbc, CmsUser user) throws CmsDataAccessException {
1422
1423 PreparedStatement stmt = null;
1424 Connection conn = null;
1425
1426 try {
1427 conn = m_sqlManager.getConnection(dbc);
1428 stmt = m_sqlManager.getPreparedStatement(conn, "C_USERS_WRITE");
1429 stmt.setString(1, m_sqlManager.validateEmpty(user.getDescription()));
1431 stmt.setString(2, m_sqlManager.validateEmpty(user.getFirstname()));
1432 stmt.setString(3, m_sqlManager.validateEmpty(user.getLastname()));
1433 stmt.setString(4, m_sqlManager.validateEmpty(user.getEmail()));
1434 stmt.setLong(5, user.getLastlogin());
1435 stmt.setInt(6, user.getFlags());
1436 m_sqlManager.setBytes(stmt, 7, internalSerializeAdditionalUserInfo(user.getAdditionalInfo()));
1437 stmt.setString(8, m_sqlManager.validateEmpty(user.getAddress()));
1438 stmt.setInt(9, user.getType());
1439 stmt.setString(10, user.getId().toString());
1440 stmt.executeUpdate();
1441 } catch (SQLException e) {
1442 throw new CmsDbSqlException(Messages.get().container(
1443 Messages.ERR_GENERIC_SQL_1,
1444 CmsDbSqlException.getErrorQuery(stmt)), e);
1445 } catch (IOException e) {
1446 throw new CmsDbIoException(
1447 Messages.get().container(Messages.ERR_SERIALIZING_USER_DATA_1, user.getName()),
1448 e);
1449 } finally {
1450 m_sqlManager.closeAll(dbc, conn, stmt, null);
1451 }
1452 }
1453
1454
1457 public void writeUserType(CmsDbContext dbc, CmsUUID userId, int userType) throws CmsDataAccessException {
1458
1459 PreparedStatement stmt = null;
1460 Connection conn = null;
1461
1462 try {
1463 conn = m_sqlManager.getConnection(dbc);
1464 stmt = m_sqlManager.getPreparedStatement(conn, "C_USERS_UPDATE_USERTYPE");
1465
1466 stmt.setInt(1, userType);
1468 stmt.setString(2, userId.toString());
1469 stmt.executeUpdate();
1470 } catch (SQLException e) {
1471 throw new CmsDbSqlException(Messages.get().container(
1472 Messages.ERR_GENERIC_SQL_1,
1473 CmsDbSqlException.getErrorQuery(stmt)), e);
1474 } finally {
1475 m_sqlManager.closeAll(dbc, conn, stmt, null);
1476 }
1477 }
1478
1479
1482 protected void finalize() throws Throwable {
1483
1484 try {
1485 m_sqlManager = null;
1486 m_driverManager = null;
1487 } catch (Throwable t) {
1488 }
1490 super.finalize();
1491 }
1492
1493
1500 protected CmsGroup internalCreateGroup(ResultSet res) throws SQLException {
1501
1502 return new CmsGroup(
1503 new CmsUUID(res.getString(m_sqlManager.readQuery("C_GROUPS_GROUP_ID"))),
1504 new CmsUUID(res.getString(m_sqlManager.readQuery("C_GROUPS_PARENT_GROUP_ID"))),
1505 res.getString(m_sqlManager.readQuery("C_GROUPS_GROUP_NAME")),
1506 res.getString(m_sqlManager.readQuery("C_GROUPS_GROUP_DESCRIPTION")),
1507 res.getInt(m_sqlManager.readQuery("C_GROUPS_GROUP_FLAGS")));
1508 }
1509
1510
1519 protected CmsUser internalCreateUser(ResultSet res) throws SQLException , IOException , ClassNotFoundException {
1520
1521 String userName = res.getString(m_sqlManager.readQuery("C_USERS_USER_NAME"));
1522
1523 ByteArrayInputStream bin = new ByteArrayInputStream (m_sqlManager.getBytes(
1525 res,
1526 m_sqlManager.readQuery("C_USERS_USER_INFO")));
1527 ObjectInputStream oin = new ObjectInputStream (bin);
1528
1529 Map info;
1530 try {
1532 info = (Map )oin.readObject();
1533 } catch (IOException e) {
1534 CmsMessageContainer message = Messages.get().container(Messages.ERR_READING_ADDITIONAL_INFO_1, userName);
1535 LOG.error(message.key(), e);
1536
1537 info = new HashMap ();
1538 }
1539
1540 return new CmsUser(
1541 new CmsUUID(res.getString(m_sqlManager.readQuery("C_USERS_USER_ID"))),
1542 userName,
1543 res.getString(m_sqlManager.readQuery("C_USERS_USER_PASSWORD")),
1544 res.getString(m_sqlManager.readQuery("C_USERS_USER_DESCRIPTION")),
1545 res.getString(m_sqlManager.readQuery("C_USERS_USER_FIRSTNAME")),
1546 res.getString(m_sqlManager.readQuery("C_USERS_USER_LASTNAME")),
1547 res.getString(m_sqlManager.readQuery("C_USERS_USER_EMAIL")),
1548 res.getLong(m_sqlManager.readQuery("C_USERS_USER_LASTLOGIN")),
1549 res.getInt(m_sqlManager.readQuery("C_USERS_USER_FLAGS")),
1550 info,
1551 res.getString(m_sqlManager.readQuery("C_USERS_USER_ADDRESS")),
1552 res.getInt(m_sqlManager.readQuery("C_USERS_USER_TYPE")));
1553 }
1554
1555
1562 protected byte[] internalSerializeAdditionalUserInfo(Map additionalUserInfo) throws IOException {
1563
1564 ByteArrayOutputStream bout = new ByteArrayOutputStream ();
1566 ObjectOutputStream oout = new ObjectOutputStream (bout);
1567 oout.writeObject(additionalUserInfo != null ? new Hashtable (additionalUserInfo) : null);
1568 oout.close();
1569
1570 return bout.toByteArray();
1571 }
1572
1573
1581 private void fillDefaults(CmsDbContext dbc) throws CmsDataAccessException, CmsPasswordEncryptionException {
1582
1583 String guestGroup = OpenCms.getDefaultUsers().getGroupGuests();
1584 String administratorsGroup = OpenCms.getDefaultUsers().getGroupAdministrators();
1585 String usersGroup = OpenCms.getDefaultUsers().getGroupUsers();
1586 String projectmanagersGroup = OpenCms.getDefaultUsers().getGroupProjectmanagers();
1587 String guestUser = OpenCms.getDefaultUsers().getUserGuest();
1588 String adminUser = OpenCms.getDefaultUsers().getUserAdmin();
1589 String exportUser = OpenCms.getDefaultUsers().getUserExport();
1590
1591 CmsGroup guests, administrators, users, projectmanager;
1592 CmsUser guest, admin, export;
1593
1594 guests = createGroup(
1595 dbc,
1596 CmsUUID.getConstantUUID(guestGroup),
1597 guestGroup,
1598 "The guest group",
1599 I_CmsPrincipal.FLAG_ENABLED,
1600 null,
1601 null);
1602 administrators = createGroup(
1603 dbc,
1604 CmsUUID.getConstantUUID(administratorsGroup),
1605 administratorsGroup,
1606 "The administrators group",
1607 I_CmsPrincipal.FLAG_ENABLED | I_CmsPrincipal.FLAG_GROUP_PROJECT_MANAGER,
1608 null,
1609 null);
1610 users = createGroup(
1611 dbc,
1612 CmsUUID.getConstantUUID(usersGroup),
1613 usersGroup,
1614 "The users group",
1615 I_CmsPrincipal.FLAG_ENABLED
1616 | I_CmsPrincipal.FLAG_GROUP_WORKFLOW_ROLE
1617 | I_CmsPrincipal.FLAG_GROUP_PROJECT_USER,
1618 null,
1619 null);
1620 projectmanager = createGroup(
1621 dbc,
1622 CmsUUID.getConstantUUID(projectmanagersGroup),
1623 projectmanagersGroup,
1624 "The projectmanager group",
1625 I_CmsPrincipal.FLAG_ENABLED
1626 | I_CmsPrincipal.FLAG_GROUP_PROJECT_MANAGER
1627 | I_CmsPrincipal.FLAG_GROUP_PROJECT_USER
1628 | I_CmsPrincipal.FLAG_GROUP_WORKFLOW_ROLE,
1629 users.getName(),
1630 null);
1631
1632 guest = importUser(
1633 dbc,
1634 CmsUUID.getConstantUUID(guestUser),
1635 guestUser,
1636 OpenCms.getPasswordHandler().digest(""),
1637 "The guest user",
1638 " ",
1639 " ",
1640 " ",
1641 0,
1642 I_CmsPrincipal.FLAG_ENABLED,
1643 new Hashtable (),
1644 " ",
1645 CmsUser.USER_TYPE_SYSTEMUSER,
1646 null);
1647 admin = importUser(
1648 dbc,
1649 CmsUUID.getConstantUUID(adminUser),
1650 adminUser,
1651 OpenCms.getPasswordHandler().digest("admin"),
1652 "The admin user",
1653 " ",
1654 " ",
1655 " ",
1656 0,
1657 I_CmsPrincipal.FLAG_ENABLED,
1658 new Hashtable (),
1659 " ",
1660 CmsUser.USER_TYPE_SYSTEMUSER,
1661 null);
1662
1663 createUserInGroup(dbc, guest.getId(), guests.getId(), null);
1664 createUserInGroup(dbc, admin.getId(), administrators.getId(), null);
1665
1666 if (!exportUser.equals(OpenCms.getDefaultUsers().getUserAdmin())
1667 && !exportUser.equals(OpenCms.getDefaultUsers().getUserGuest())) {
1668
1669 export = importUser(
1670 dbc,
1671 CmsUUID.getConstantUUID(exportUser),
1672 exportUser,
1673 OpenCms.getPasswordHandler().digest((new CmsUUID()).toString()),
1674 "The static export user",
1675 " ",
1676 " ",
1677 " ",
1678 0,
1679 I_CmsPrincipal.FLAG_ENABLED,
1680 Collections.EMPTY_MAP,
1681 " ",
1682 CmsUser.USER_TYPE_SYSTEMUSER,
1683 null);
1684 createUserInGroup(dbc, export.getId(), guests.getId(), null);
1685 }
1686
1687 if (CmsLog.INIT.isInfoEnabled()) {
1688 CmsLog.INIT.info(Messages.get().getBundle().key(Messages.INIT_USER_GROUP_DEFAULTS_INITIALIZED_0));
1689 }
1690
1691 projectmanager.setEnabled(true);
1693 }
1694
1695
1702 private CmsAccessControlEntry internalCreateAce(ResultSet res) throws SQLException {
1703
1704 return new CmsAccessControlEntry(
1705 new CmsUUID(res.getString(m_sqlManager.readQuery("C_ACCESS_RESOURCE_ID"))),
1706 new CmsUUID(res.getString(m_sqlManager.readQuery("C_ACCESS_PRINCIPAL_ID"))),
1707 res.getInt(m_sqlManager.readQuery("C_ACCESS_ACCESS_ALLOWED")),
1708 res.getInt(m_sqlManager.readQuery("C_ACCESS_ACCESS_DENIED")),
1709 res.getInt(m_sqlManager.readQuery("C_ACCESS_ACCESS_FLAGS")));
1710 }
1711
1712
1720 private CmsAccessControlEntry internalCreateAce(ResultSet res, CmsUUID newId) throws SQLException {
1721
1722
1724 return new CmsAccessControlEntry(
1725 newId,
1726 new CmsUUID(res.getString(m_sqlManager.readQuery("C_ACCESS_PRINCIPAL_ID"))),
1727 res.getInt(m_sqlManager.readQuery("C_ACCESS_ACCESS_ALLOWED")),
1728 res.getInt(m_sqlManager.readQuery("C_ACCESS_ACCESS_DENIED")),
1729 res.getInt(m_sqlManager.readQuery("C_ACCESS_ACCESS_FLAGS")));
1730 }
1731
1732
1744 private boolean internalValidateUserInGroup(CmsDbContext dbc, CmsUUID userId, CmsUUID groupId, Object reservedParam)
1745 throws CmsDataAccessException {
1746
1747 boolean userInGroup = false;
1748 PreparedStatement stmt = null;
1749 ResultSet res = null;
1750 Connection conn = null;
1751
1752 try {
1753 if (reservedParam == null) {
1754 conn = m_sqlManager.getConnection(dbc);
1756 } else {
1757 conn = m_sqlManager.getConnection(dbc, ((Integer )reservedParam).intValue());
1759 }
1760
1761 stmt = m_sqlManager.getPreparedStatement(conn, "C_GROUPS_USERINGROUP");
1762
1763 stmt.setString(1, groupId.toString());
1764 stmt.setString(2, userId.toString());
1765 res = stmt.executeQuery();
1766 if (res.next()) {
1767 userInGroup = true;
1768 }
1769 } catch (SQLException e) {
1770 throw new CmsDbSqlException(Messages.get().container(
1771 Messages.ERR_GENERIC_SQL_1,
1772 CmsDbSqlException.getErrorQuery(stmt)), e);
1773 } finally {
1774 m_sqlManager.closeAll(dbc, conn, stmt, res);
1775 }
1776
1777 return userInGroup;
1778 }
1779
1780} |
Popular Tags |
Java API By Example, From Geeks To Geeks.