Develop and Download Open Source Software

XooNIps

Browse CVS Repository

/[OSDN]/xoonips/AL/commonal.cc

Contents of /xoonips/AL/commonal.cc

Parent Directory Parent Directory | Revision Log Revision Log | View Revision Graph Revision Graph

Revision 1.118 - (show annotations) (download) (as text)
Tue Jan 10 10:56:30 2006 UTC (18 years, 3 months ago) by tani
Branch: MAIN
CVS Tags: REL20060323, REL20060213
Branch point for: XOONIPS_STABLE_2
Changes since 1.117: +5 -1 lines
File MIME type: text/x-c++src 
selectiveHarvesting:stat.item_idでorder by(asc)
1 /*
2 * --------------------------------------------------------------------------
3 * XooNiPs Xoops modules for Neuroinformatics Platforms
4 * Copyright (C) 2005 RIKEN, Japan. All rights reserved.
5 * http://sourceforge.jp/projects/xoonips/
6 * --------------------------------------------------------------------------
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version 2
10 * of the License, or (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20 * --------------------------------------------------------------------------
21 *
22 *
23 * $Revision: 1.117 $
24 * $Log: commonal.cc,v $
25 * Revision 1.117 2006/01/06 05:50:32 aga4096
26 * 鐃緒申 ctype.h 鐃緒申include.
27 *
28 * Revision 1.116 2005/11/22 11:29:54 tani
29 * deleteItem: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申Related to鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
30 * getRelatedTo: isActivatedBySession鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申).
31 *
32 * Revision 1.115 2005/11/17 10:59:36 tani
33 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申: insertRelatedTo, deleteRelatedTo, getRelatedTo鐃緒申鐃緒申鐃緒申.
34 *
35 * Revision 1.114 2005/11/16 03:59:06 tani
36 * XOONIPS_STABLE鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申MergePnt_20051116鐃緒申鐃緒申XooNIps_STABLE鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申CURRENT鐃緒申鐃緒申鐃緒申鐃緒申.
37 *
38 * Revision 1.113.2.3 2005/11/01 10:36:14 tani
39 * _insertItem: dierct鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
40 *
41 * Revision 1.113.2.2 2005/10/28 07:02:52 aga4096
42 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
43 *
44 * Revision 1.113.2.1 2005/10/18 09:19:53 aga4096
45 * 鐃緒申PubMed鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
46 *
47 * Revision 1.113 2005/10/11 16:20:22 orrisroot
48 * SQLRowCount 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
49 *
50 * Revision 1.112 2005/10/07 06:22:46 aga4096
51 * 鐃緒申updateAccount()鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
52 *
53 * Revision 1.111 2005/09/26 02:24:34 aga4096
54 * 鐃緒申isAdmin()鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
55 *
56 * Revision 1.110 2005/09/09 06:26:35 aga4096
57 * 鐃緒申xnp_use_syslog()鐃緒申鐃緒申鐃緒申.
58 *
59 * Revision 1.109 2005/09/09 01:29:27 aga4096
60 * 鐃緒申refresh_item_status, update_item_status鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
61 *
62 * Revision 1.108 2005/09/08 05:40:21 tani
63 * freeStringArray鐃緒申鐃緒申鐃緒申.
64 * selectiveHarvesting鐃緒申OAIPMH鐃緒申identifier鐃緒申鐃緒申鐃緒申.
65 * XNP_CONFIG_REPOSITORY_NIJC_CODE鐃緒申鐃緒申鐃緒申.
66 *
67 * Revision 1.107 2005/08/30 09:39:31 aga4096
68 * 鐃緒申xnp_get_item_status 鐃緒申鐃緒申鐃緒申.
69 *
70 * Revision 1.106 2005/08/29 07:11:05 aga4096
71 * 鐃緒申xnp_update_item_status, xnp_selective_harvesting鐃緒申鐃緒申鐃緒申.
72 *
73 * Revision 1.105 2005/08/29 05:27:37 aga4096
74 * 鐃緒申update_item_status鐃緒申鐃緒申鐃緒申.
75 *
76 * Revision 1.104 2005/08/29 02:05:34 aga4096
77 * 鐃緒申xnp_update_item_status(), xnp_refresh_item_status(), xnp_selective_harvesting() 鐃緒申鐃緒申鐃緒申.
78 *
79 * Revision 1.103 2005/08/23 07:34:24 tani
80 * Language鐃緒申鐃緒申: getItems, _insetItem, updateItem
81 *
82 * Revision 1.102 2005/08/23 02:19:10 tani
83 * getEventsForRSS鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
84 *
85 * Revision 1.101 2005/08/08 01:57:00 aga4096
86 * 鐃緒申2鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申initializeDB鐃緒申鐃緒申鐃緒申.
87 * 鐃緒申valgrind鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
88 *
89 * Revision 1.100 2005/07/21 01:47:57 tani
90 * getEventsForRSS鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
91 *
92 * Revision 1.99 2005/07/15 04:42:33 aga4096
93 * 鐃緒申getItemTypes鐃緒申鐃緒申DB鐃緒申NULL鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
94 *
95 * Revision 1.98 2005/07/12 06:40:44 aga4096
96 * 鐃緒申setConfigValue鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
97 *
98 * Revision 1.97 2005/06/30 07:21:42 aga4096
99 * 鐃緒申get_all_index鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申index鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
100 *
101 * Revision 1.96 2005/06/29 00:10:18 aga4096
102 * 鐃緒申login name -> additional info 鐃緒申鐃緒申鐃緒申.
103 *
104 * Revision 1.95 2005/06/24 02:07:34 tani
105 * insertItemDirect鐃緒申鐃緒申鐃緒申(Import鐃緒申)
106 * getPrivateItemID鐃緒申鐃緒申BINDER鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)
107 *
108 * Revision 1.94 2005/06/23 07:58:12 aga4096
109 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
110 *
111 * Revision 1.93 2005/06/14 01:02:20 aga4096
112 * 鐃緒申鐃緒申鐃緒申Binder鐃緒申鐃緒申鐃緒申鐃緒申. xnp_extract_public_item_id, xnp_extract_nonbinder_item_id 鐃緒申鐃緒申鐃緒申.
113 *
114 * Revision 1.92 2005/06/08 04:27:08 tani
115 * default鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
116 *
117 * Revision 1.91 2005/06/07 01:10:33 tani
118 * SQLGetData鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
119 * SQLExecDirect鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申SQLExecute鐃緒申鐃緒申鐃緒申.
120 *
121 * Revision 1.90 2005/05/23 08:00:30 tani
122 * insertGroup, updateGroup: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
123 *
124 * Revision 1.89 2005/05/18 10:00:17 aga4096
125 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
126 *
127 * Revision 1.88 2005/03/17 16:02:40 orrisroot
128 * UNIX 鐃緒申鐃緒申鐃緒申鐃緒申 SQLLEN 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申configure
129 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申 config.h 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
130 * 鐃緒申 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申 MacOS X 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
131 *
132 * Revision 1.87 2005/03/15 12:09:39 tani
133 * deleteItem 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
134 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
135 *
136 * Revision 1.86 2005/03/15 04:49:40 tani
137 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
138 *
139 * Revision 1.85 2005/03/14 09:30:50 aga4096
140 * 鐃緒申getItemCountByIndex鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
141 *
142 * Revision 1.84 2005/03/14 06:12:11 tani
143 * __BORLANDC__鐃緒申鐃緒申.
144 *
145 * Revision 1.83 2005/03/11 20:00:28 orrisroot
146 * - Autotoolized XooNiPs Abstract Layer projects.
147 * - changelog.cc commonal.cc index.cc item.cc :
148 * included <time.h> header file for undefined data type 'time_t' error.
149 *
150 * Revision 1.82 2005/03/11 07:11:30 tani
151 * itemid_t鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(*iidsLen)鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
152 *
153 * Revision 1.81 2005/03/11 00:34:57 tani
154 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申certify_state鐃緒申鐃緒申.
155 *
156 * Revision 1.80 2005/03/09 07:27:37 aga4096
157 * 鐃緒申activate=0鐃緒申鐃緒申loginUser鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
158 *
159 * Revision 1.79 2005/03/07 01:20:09 aga4096
160 * 鐃緒申getItemCountGroupByIndex鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
161 *
162 * Revision 1.78 2005/03/05 02:28:05 aga4096
163 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申 Private 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
164 *
165 * Revision 1.77 2005/03/05 01:48:35 aga4096
166 * 鐃緒申getItemCountGroupByIndex鐃緒申鐃緒申鐃緒申.
167 *
168 * Revision 1.76 2005/03/04 06:13:28 aga4096
169 * 鐃緒申updateIndex鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
170 *
171 * Revision 1.75 2005/03/03 10:13:00 aga4096
172 * 鐃緒申isValidSession鐃緒申timestamp鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
173 * 鐃緒申session鐃緒申isValidSession鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申1鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
174 * 鐃緒申loginUser, createSession鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申session鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
175 *
176 * Revision 1.74 2005/02/26 05:11:31 tani
177 * getGroupItemID鐃緒申鐃緒申.
178 *
179 * Revision 1.73 2005/02/25 07:41:35 tani
180 * getGroupItemID鐃緒申鐃緒申.
181 * item, index鐃緒申limit鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
182 *
183 * Revision 1.72 2005/02/25 01:03:42 tani
184 * dbtype==DBTYPE_SQLITE鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
185 *
186 * Revision 1.71 2005/02/24 11:32:55 aga4096
187 * 鐃緒申updateGroup鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
188 *
189 * Revision 1.70 2005/02/23 06:39:28 tani
190 * isGuestEnabled: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
191 *
192 * Revision 1.69 2005/02/22 02:39:30 tani
193 * public_item_target_user_all鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
194 * SQL鐃緒申鐃緒申public_item_target_user_all鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申public_item_target_user_all鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
195 * session鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申LEFT JOIN鐃緒申鐃緒申鐃緒申鐃緒申sid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
196 * DB鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
197 *
198 * Revision 1.68 2005/02/21 05:46:18 tani
199 * getItemCount鐃緒申鐃緒申鐃緒申.
200 * dumpItemID, getItems鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
201 *
202 * Revision 1.67 2005/02/19 02:06:11 tani
203 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
204 *
205 * Revision 1.66 2005/02/16 10:03:13 youi
206 * publication_year/month/mday鐃緒申鐃緒申鐃緒申.
207 *
208 * Revision 1.65 2005/02/16 07:37:17 youi
209 * insertItem, updateItem, getItems: publication_date鐃緒申鐃緒申鐃緒申.
210 *
211 * Revision 1.64 2005/02/15 02:35:47 youi
212 * SQLINTEGER鐃緒申鐃緒申SQLLEN鐃緒申鐃緒申鐃緒申鐃緒申.
213 *
214 * Revision 1.63 2005/02/10 02:33:16 aga
215 * 鐃緒申zipCreate鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
216 *
217 * Revision 1.62 2005/02/09 11:11:52 youi
218 * deleteItem鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
219 *
220 * Revision 1.61 2005/02/09 07:23:50 aga
221 * 鐃緒申URL to My Personal Archive 鐃緒申DB鐃緒申AL鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
222 *
223 * Revision 1.60 2005/02/09 02:14:15 aga
224 * 鐃緒申initializeDB()鐃緒申dbtype鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(SQLite鐃緒申).
225 *
226 * Revision 1.59 2005/02/08 07:15:02 youi
227 * pubmed鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申:
228 *
229 * Revision 1.58 2005/02/08 06:40:51 youi
230 * pubmedComplete:鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申pubmed_t鐃緒申鐃緒申鐃緒申鐃緒申.
231 *
232 * Revision 1.57 2005/02/03 12:04:58 youi
233 * getOwnPublicItemID鐃緒申鐃緒申鐃緒申.
234 * binder_item_link鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
235 *
236 * Revision 1.56 2005/01/29 09:49:22 youi
237 * syslog_printf: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
238 * getCertifyPermission: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申sql鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
239 * SQLINTEGER->SQLLEN鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
240 * getItemPermission: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
241 *
242 * Revision 1.55 2005/01/28 07:01:38 youi
243 * getItemIDByIndexID: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
244 * SQLAllocHandle鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
245 *
246 * Revision 1.54 2005/01/28 00:36:58 aga
247 * 鐃緒申freeString鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
248 *
249 * Revision 1.53 2005/01/27 08:30:35 youi
250 * getIndexIDByItemID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
251 *
252 * Revision 1.52 2005/01/25 06:46:50 aga
253 * 鐃緒申Binders鐃緒申鐃緒申鐃緒申index鐃緒申deleteIndex鐃緒申鐃緒申.
254 * 鐃緒申getItems鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
255 *
256 * Revision 1.51 2005/01/24 10:50:29 youi
257 * freeItemType,getItemTypes鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
258 *
259 * Revision 1.50 2005/01/24 01:54:38 youi
260 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
261 * dumpItemID, getItemIDByBinderID, getItemIDByIndexID
262 * 鐃緒申鐃緒申鐃緒申鐃緒申
263 * getPrivateItemID, getUncertifiedLink
264 *
265 * Revision 1.49 2005/01/22 09:30:58 youi
266 * setLastErrorString鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
267 *
268 * Revision 1.48 2005/01/22 04:18:22 aga
269 * 鐃緒申loginUser, insertAccount鐃緒申鐃緒申鐃緒申md5()鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
270 *
271 * Revision 1.47 2005/01/22 02:41:14 aga
272 * 鐃緒申amazon鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
273 *
274 * Revision 1.46 2005/01/21 01:36:11 youi
275 * pubmed鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
276 *
277 * Revision 1.45 2005/01/19 10:07:53 aga
278 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
279 *
280 * Revision 1.44 2005/01/19 06:01:59 youi
281 * 鐃緒申鐃緒申鐃緒申鐃緒申
282 * getConfigValue
283 * setConfigValue
284 * getChangeLogs
285 * insertChangeLog
286 * getItemIDByBinderID
287 * registerBinderItem
288 * unregisterBinderItem
289 * getIndexPermission
290 * freeString
291 * freeChangeLog
292 * 鐃緒申鐃緒申鐃緒申criteria_t鐃緒申鐃緒申鐃緒申
293 * getItemIDByIndexID
294 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
295 * getCertifyState
296 * setCertifyState
297 * getCertifyPermission
298 * sessionID2UID,querySimple,queryGetUnsignedInt鐃緒申鐃緒申鐃緒申
299 * insertItem鐃緒申鐃緒申鐃緒申鐃緒申PrivateIndex鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
300 * getItems: getItemPermission鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
301 *
302 * Revision 1.43 2005/01/19 01:42:15 aga
303 * 鐃緒申x_xoonips_index鐃緒申gid,uid鐃緒申0鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
304 *
305 * Revision 1.42 2005/01/19 00:51:29 aga
306 * 鐃緒申insertIndex鐃緒申x_xoonips_index.index_id鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
307 *
308 * Revision 1.41 2005/01/19 00:06:51 aga
309 * 鐃緒申updateIndex鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
310 * 鐃緒申createSession鐃緒申鐃緒申uid鐃緒申Platform鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申activate鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
311 *
312 * Revision 1.40 2005/01/17 00:15:05 aga
313 * 鐃緒申deleteIndex, updateIndex鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
314 *
315 * Revision 1.39 2005/01/15 05:38:10 youi
316 * insertAccount: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
317 * updateAccount: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
318 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
319 * insertItem, getItem, getItems, dumpItemID, updateItem, deleteItem鐃緒申鐃緒申.
320 * freeGID, freeUID: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
321 *
322 * Revision 1.38 2005/01/15 00:39:16 aga
323 * 鐃緒申x_xoonips_item_basic鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
324 *
325 * Revision 1.37 2005/01/14 10:36:59 aga
326 * 鐃緒申index鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
327 * 鐃緒申insertAccount鐃緒申private index鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
328 * 鐃緒申insertGroup鐃緒申group index 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
329 *
330 * Revision 1.36 2005/01/13 04:19:22 aga
331 * 鐃緒申VP鐃緒申XNP鐃緒申鐃緒申鐃緒申.
332 *
333 * Revision 1.35 2005/01/06 07:20:17 youi
334 * WIN32鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
335 * MySQL API鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
336 * deleteAccount: 鐃緒申鐃緒申鐃緒申鐃緒申Platform鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
337 * insertAccount: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申Platform鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
338 * deleteMember: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申Platform鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
339 * deleteMemberNoLimit鐃緒申鐃緒申鐃緒申.
340 *
341 * Revision 1.34 2004/12/28 04:38:14 aga
342 * 鐃緒申logoutUser()鐃緒申鐃緒申鐃緒申.
343 *
344 * Revision 1.33 2004/12/27 05:56:23 youi
345 * odbcDiagString: STMT鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
346 * syslog鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
347 *
348 * Revision 1.32 2004/12/25 09:46:47 youi
349 * MySQL+MyODBC鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
350 *
351 * Revision 1.31 2004/12/21 11:42:59 youi
352 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
353 *
354 * Revision 1.30 2004/12/18 10:24:54 youi
355 * IMPORT_MYSQLDLL鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申MYSQL鐃緒申DLL鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
356 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
357 *
358 * Revision 1.29 2004/12/18 01:12:29 youi
359 * freeResult鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申free<鐃緒申鐃緒申鐃緒申鐃緒申>鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
360 *
361 * Revision 1.28 2004/12/14 12:02:08 youi
362 * __WIN__鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申windows鐃緒申dll鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
363 * USE_SYSLOG鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申syslogd鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
364 * getAccounts: uidsLen鐃緒申0鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
365 *
366 * Revision 1.27 2004/12/06 11:34:47 aga
367 * 鐃緒申uninitializeDB()鐃緒申鐃緒申鐃緒申.
368 *
369 * Revision 1.26 2004/12/06 10:17:36 youi
370 * mysql_use_result鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
371 * while( row = mysql_fetch_row(result) );鐃緒申鐃緒申鐃緒申鐃緒申
372 *
373 * Revision 1.25 2004/12/06 07:24:33 youi
374 * insertAccount, insertGroup:
375 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
376 *
377 * Revision 1.24 2004/12/06 01:45:50 aga
378 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
379 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
380 *
381 * Revision 1.23 2004/12/04 09:21:10 aga
382 * 鐃緒申xnp_config 鐃緒申 xoonips_config.
383 *
384 * Revision 1.22 2004/12/03 07:17:21 youi
385 * isModerator鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
386 *
387 * Revision 1.21 2004/12/01 10:28:58 youi
388 * DB鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
389 * institute -> division
390 * organizaion -> company_name
391 *
392 * Revis1.20 2004/12/01 04:37:04 youi
393 * freeResult: unsigned int* 鐃緒申 int* 鐃緒申鐃緒申鐃緒申.
394 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
395 *
396 * Revision 1.19 2004/11/30 06:40:11 youi
397 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(gidExists, uidExists)
398 * getGroupCount鐃緒申鐃緒申鐃緒申.
399 * getGroupsByUid鐃緒申鐃緒申鐃緒申.
400 * isGroupAdmin鐃緒申鐃緒申鐃緒申.
401 * dumpGroupAdmins鐃緒申鐃緒申鐃緒申.
402 * deleteMember鐃緒申鐃緒申鐃緒申.
403 * insertMember鐃緒申鐃緒申鐃緒申.
404 * getMembers鐃緒申鐃緒申鐃緒申.
405 * isModerator鐃緒申鐃緒申鐃緒申.
406 *
407 * Revision 1.18 2004/11/30 05:46:32 aga
408 * 鐃緒申session鐃緒申鐃緒申remoteHost鐃緒申鐃緒申鐃緒申.
409 *
410 * Revision 1.17 2004/11/27 09:35:49 youi
411 * isActivated鐃緒申鐃緒申鐃緒申.
412 * activate鐃緒申鐃緒申鐃緒申.
413 * dumpUid鐃緒申鐃緒申鐃緒申.
414 *
415 * Revision 1.16 2004/11/27 06:29:29 youi
416 * getAccountCount鐃緒申鐃緒申鐃緒申.
417 * dumpGids鐃緒申鐃緒申鐃緒申.
418 * insertGroup, deleteGroup, updateGroup鐃緒申鐃緒申鐃緒申.
419 * getGroup, getGroups鐃緒申鐃緒申鐃緒申.
420 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申RES_DB_NOT_INITIALIZED鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
421 * (鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)
422 *
423 * Revision 1.15 2004/11/27 02:22:22 aga
424 * 鐃緒申initializeDB鐃緒申鐃緒申addSlashes()鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
425 *
426 * Revision 1.14 2004/11/27 01:07:31 youi
427 * criteria2str: LIMIT鐃緒申ORDER BY鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
428 *
429 * Revision 1.13 2004/11/27 00:35:39 youi
430 * getAccounts鐃緒申鐃緒申鐃緒申.
431 * getAccount鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申getAccounts鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
432 * criteria2str鐃緒申鐃緒申鐃緒申.
433 *
434 * Revision 1.12 2004/11/26 09:45:28 youi
435 * getAccount鐃緒申鐃緒申鐃緒申.
436 *
437 * Revision 1.11 2004/11/26 08:16:26 aga
438 * 鐃緒申getSession, loginUser, createSession, freeResult(const session_t*) 鐃緒申鐃緒申.
439 *
440 * Revision 1.10 2004/11/26 07:57:42 youi
441 * updateAccount, deleteAccount鐃緒申鐃緒申鐃緒申.
442 * mysql_query鐃緒申鐃緒申鐃緒申鐃緒申stderr鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
443 *
444 * Revision 1.9 2004/11/26 07:38:02 aga
445 * 鐃緒申FAILUE -> FAILURE.
446 *
447 * Revision 1.8 2004/11/26 06:36:55 aga
448 * 鐃緒申createSession, getSession 鐃緒申鐃緒申鐃緒申.
449 *
450 * Revision 1.7 2004/11/26 04:51:47 youi
451 * dbprefix鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
452 * insertAccount鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
453 * isValidSessionID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
454 *
455 * Revision 1.6 2004/11/26 04:35:55 aga
456 * 鐃緒申loginUser(), logoutUser()鐃緒申鐃緒申鐃緒申.
457 *
458 * Revision 1.5 2004/11/26 01:08:25 aga
459 * 鐃緒申addSlashes()鐃緒申鐃緒申.
460 *
461 * Revision 1.4 2004/11/25 12:14:29 youi
462 * getUid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
463 *
464 * Revision 1.3 2004/11/25 11:13:59 youi
465 * getLastErrorString/setLastErrorString鐃緒申鐃緒申鐃緒申.
466 *
467 * Revision 1.2 2004/11/25 08:55:19 youi
468 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
469 * freeResult鐃緒申鐃緒申鐃緒申.
470 *
471 * Revision 1.1 2004/11/25 05:14:58 youi
472 * initial version
473 *
474 *
475 */
476 #ifdef HAVE_CONFIG_H
477 # include <config.h>
478 #endif
479
480 #ifdef WIN32
481 #include <windows.h>
482 #endif
483
484 #ifdef USE_SYSLOG
485 #include <syslog.h>
486 #endif
487
488 #include <stdio.h>
489 #include <stdlib.h>
490 #include <string.h>
491 #include <string>
492 #include <assert.h>
493 #include <time.h>
494 #include <sql.h>
495 #include <sqlext.h>
496 #include <libxml/xmlreader.h>
497 #include <ctype.h>
498
499 using namespace std;
500
501 #include "common.h"
502 #include "account.h"
503 #include "group.h"
504 #include "session.h"
505 #include "item.h"
506 #include "itemtype.h"
507 #include "criteria.h"
508 #include "commonal.h"
509 #include "item.h"
510 #include "index.h"
511 #include "changelog.h"
512 #include "pubmed.h"
513 #include "amazonbook.h"
514
515 static string dbprefix; //!< XOOPS鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申PREFIX
516 static dbtype_t dbtype; //!< MySQL/SQLite
517 static bool useSyslogFlag = false;
518
519 static SQLHANDLE henv = NULL;
520 static SQLHANDLE hdbc = NULL;
521
522
523 static void processEsummary(xmlTextReaderPtr reader, string &title, string &title_abbr);
524 static bool processEsearch(xmlTextReaderPtr reader, pubmed_t* p, int* DocID );
525 static void processEfetch(xmlTextReaderPtr reader, pubmed_t* p);
526 static int streamPubmedFile(const char *filename, pubmed_t* p);
527 static result_t insertIndexInternal( sessionid_t sid, index_t *index, indexid_t *xid );
528 static string odbcDiagString( SQLSMALLINT HandleType, SQLHANDLE hstmt, SQLRETURN sqlcode );
529 static result_t deleteMemberNoLimit( sessionid_t sid, groupid_t gid, userid_t uid );
530 static result_t getXoopsModuleConfigValue( const char *module, const char *key, char **value );
531 static void setLastErrorString( const char* str );
532 static result_t checkTitleConflict( sessionid_t sid, indexid_t parentIndexID, const char *title, bool *conflict );
533 static result_t _insertItem( sessionid_t sid, const item_t* item, itemid_t* itemid, bool direct );
534 static result_t getEvents(sessionid_t sid, event_t** events, int* eventsLen, string condition );
535 static result_t insertMetadataEvent( metadataevent_t me, itemid_t iid );
536 static result_t insertMetadataEventAuto( itemid_t iid, bool isCreate = false );
537
538 static void syslog_printf( char* format, ... )
539 {
540 #ifdef USE_SYSLOG
541 if ( useSyslogFlag ){
542 va_list ap;
543 va_start(ap, format);
544 openlog( "commonal", LOG_ODELAY, LOG_USER );
545 vsyslog( LOG_DEBUG, format, ap );
546 }
547 #endif
548 }
549
550 void useSyslog( bool f )
551 {
552 useSyslogFlag = f;
553 }
554
555 /** ',' . implode( ',', pi ) 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申comma鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
556 * @param pi int鐃緒申鐃緒申
557 * @param len 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
558 */
559 static string getCsvStr( const itemid_t *pi, int len ){
560 char *buf = new char[(sizeof(int)*3+1)*len+1];
561 buf[0] = '\0';
562 char *p = buf;
563 for ( int i = 0; i < len; i++ ){
564 int len = sprintf( p, ",%u", pi[i] );
565 p += len;
566 }
567 string iids_str(buf);
568 delete[] buf;
569 return iids_str;
570 }
571
572 string urlencode( string str ){
573 int len = str.length();
574 char *buf = new char[len*3+1];
575 char *p = buf;
576 for ( int i = 0; i < len; i++ ){
577 char c = str[i];
578 if ( isalnum(c) || c =='$' || c == '*' || c == '_' || c =='.' )
579 *p++ = c;
580 else {
581 sprintf( p, "%%%02X", c & 0x00ff );
582 p += 3;
583 }
584 }
585 *p = '\0';
586 string encoded(buf);
587 delete[] buf;
588 return encoded;
589 }
590
591 /**
592 *
593 * public_item_target_user鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申'all'鐃緒申鐃緒申true鐃緒申鐃緒申鐃緒申鐃緒申
594 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申'all'鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申false鐃緒申鐃緒申鐃緒申鐃緒申
595 *
596 */
597 static bool public_item_target_user_all( )
598 {
599 char* value = 0;
600 bool public_item_target_user_all = false;
601 if( getConfigValue( XNP_CONFIG_PUBLIC_ITEM_TARGET_USER_KEY, &value ) == RES_OK ){
602 public_item_target_user_all = ( strcmp( value, XNP_CONFIG_PUBLIC_ITEM_TARGET_USER_ALL ) == 0 );
603 freeString( value );
604 }
605 return public_item_target_user_all;
606 }
607
608 static result_t countResultRows( const char* sql, SQLLEN* count )
609 {
610 result_t ret = RES_ERROR;
611 SQLRETURN sqlcode;
612 SQLHANDLE hstmt = NULL;
613 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
614 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql, strlen( sql ) ) ) == SQL_SUCCESS ){
615 *count = 0;
616 while( ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS ) ( *count )++;
617 ret = RES_OK;
618 }else{
619 string s( "SQLExecDirect in countResultRows " );
620 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
621 s += "sql=";
622 s += string( sql );
623 setLastErrorString( s.c_str( ) );
624 ret = RES_DB_QUERY_ERROR;
625 }
626 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
627 }
628 return ret;
629 }
630
631
632 /**
633 *
634 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
635 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
636 *
637 */
638 static certify_t getInitialCertifyStateFromConfig( )
639 {
640 char* certify_item_val;
641 certify_t ret = index::NOT_CERTIFIED;
642
643 if( getConfigValue( XNP_CONFIG_CERTIFY_ITEM_KEY, &certify_item_val ) == RES_OK ){
644 if( strcmp( certify_item_val, XNP_CONFIG_CERTIFY_ITEM_AUTO ) == 0 ){
645 //certify automatic
646 ret = index::CERTIFIED;
647 }else if( strcmp( certify_item_val, XNP_CONFIG_CERTIFY_ITEM_ON ) == 0 ){
648 //certify by moderator or group admin
649 ret = index::CERTIFY_REQUIRED;
650 }
651 syslog_printf( "\ngetInitialCertifyStateFromConfig certify_item_val=%s", certify_item_val );
652 freeString( certify_item_val );
653 }
654 return ret;
655 }
656
657 /**
658 *
659 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申Platform鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申Activate鐃緒申
660 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
661 *
662 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
663 * @return true Activate鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
664 * @return false Activate鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
665 *
666 */
667 static bool isActivatedBySession( sessionid_t sid )
668 {
669 const session_t* session;
670 if( getSession( sid, &session ) == RES_OK ){
671 userid_t sess_uid = session -> getUID( );
672 freeSession( session );
673 return isActivated( sid, sess_uid );
674 }
675 return false;
676 }
677
678 /**
679 *
680 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
681 *
682 *
683 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
684 * @return true 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
685 * @return false 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
686 *
687 */
688 static bool isModeratorBySession( sessionid_t sid )
689 {
690 const session_t* session;
691 if( getSession( sid, &session ) == RES_OK ){
692 userid_t sess_uid = session -> getUID( );
693 freeSession( session );
694 return isModerator( sid, sess_uid );
695 }
696 return false;
697 }
698
699
700 // SQLAllocHandle鐃緒申SQLExecDirect鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申hstmt鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
701 class sqlexec_t {
702 private:
703 SQLRETURN sqlcode;
704 SQLHANDLE hstmt;
705 public:
706 SQLRETURN getSqlcode(){ return sqlcode; }
707 SQLHANDLE getHstmt(){ return hstmt; }
708 //SQLRETURN SQLFetch(){ return sqlcode = SQLFetch(hstmt); } // 鐃緒申鐃緒申鐃緒申wrapper鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
709
710 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申: SQLAllocHandle, SQLExecDirect鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申getSqlcode()==SQL_SUCCESS
711 * @param functionName 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
712 * @param sql 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申SQL
713 * @param ret 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
714 */
715 sqlexec_t( const char *functionName, string &sql, result_t *ret ){
716 sqlcode = 0;
717 hstmt = 0;
718
719 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
720 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
721 return;
722 }else {
723 string s( "SQLExecDirect in " );
724 s += functionName;
725 s += " ";
726 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
727 s += " sql=";
728 s += string( sql );
729 setLastErrorString( s.c_str( ) );
730 *ret = RES_DB_QUERY_ERROR;
731 return;
732 }
733 }else {
734 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in " );
735 s += functionName;
736 s += " ";
737 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
738 setLastErrorString( s.c_str( ) );
739 *ret = RES_ERROR;
740 return;
741 }
742 }
743 ~sqlexec_t(){
744 if ( hstmt )
745 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
746 }
747 };
748
749
750 /** SQL鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
751 * @param sql sql
752 * @return result_t
753 */
754 static result_t querySimple( const char *functionName, string &sql ){
755 result_t ret = RES_ERROR;
756 SQLRETURN sqlcode;
757 SQLHANDLE hstmt = NULL;
758 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
759 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), strlen( sql.c_str() ) ) ) == SQL_SUCCESS ){
760 ret = RES_OK;
761 }else{
762 string s( "SQLExecDirect in querySimple " );
763 s += functionName;
764 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
765 s += "sql=";
766 s += sql;
767 setLastErrorString( s.c_str( ) );
768 ret = RES_DB_QUERY_ERROR;
769 }
770 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
771 }
772 else {
773 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in querySimple " );
774 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
775 setLastErrorString( s.c_str( ) );
776 ret = RES_ERROR;
777 }
778 return ret;
779 }
780
781 /** SQL鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申1鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(NULL鐃緒申鐃緒申0鐃緒申鐃緒申鐃緒申鐃緒申)鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
782 * @param sql sql
783 * @param u 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
784 * @return result_t
785 */
786 static result_t queryGetUnsignedInt( const char *functionName, string &sql, unsigned int *u ){
787 result_t ret = RES_ERROR;
788 SQLRETURN sqlcode;
789 SQLHANDLE hstmt = NULL;
790
791 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
792 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), strlen( sql.c_str() ) ) ) == SQL_SUCCESS ){
793 SQLUINTEGER sInt = 0;
794 SQLLEN len = 0;
795 SQLBindCol( hstmt, 1, SQL_C_ULONG, &sInt, 0, &len );
796 if( ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS ){
797 if ( len == SQL_NULL_DATA )
798 sInt = 0;
799 *u = sInt;
800 ret = RES_OK;
801 }else{
802 string s( "SQLFetch in queryGetUnsignedInt " );
803 s += functionName;
804 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
805 setLastErrorString( s.c_str( ) );
806 ret = RES_ERROR;
807 }
808 }else{
809 string s( "SQLExecDirect in queryGetUnsignedInt " );
810 s += functionName;
811 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
812 s += "sql=";
813 s += sql;
814 setLastErrorString( s.c_str( ) );
815 ret = RES_DB_QUERY_ERROR;
816 }
817 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
818 }
819 else {
820 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in queryGetUnsignedInt " );
821 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
822 setLastErrorString( s.c_str( ) );
823 ret = RES_ERROR;
824 }
825 return ret;
826 }
827
828 /**
829 *
830 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
831 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申NULL鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
832 * ( dst鐃緒申鐃緒申鐃緒申鐃緒申 >= len + 1 )鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
833 *
834 */
835 static char* strncpy2( char* dst, const char* src, int len )
836 {
837 strncpy( dst, src, len );
838 dst[ len ] = '\0';
839 syslog_printf( "\nstrncpy2 '%s'\n", dst );
840 return dst;
841 }
842
843 /**
844 *
845 * SQL鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
846 *
847 * @param hstmt SQL鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
848 * @param sqlcode SQLExecDirect,SQLExecute鐃緒申鐃緒申鐃緒申鐃緒申
849 * @return 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
850 */
851 static string odbcDiagString( SQLSMALLINT HandleType, SQLHANDLE hstmt, SQLRETURN sqlcode )
852 {
853 string s;
854 if( sqlcode == SQL_ERROR || sqlcode == SQL_SUCCESS_WITH_INFO ){
855 SQLCHAR SQLState[6];
856 SQLINTEGER NativeError;
857 SQLCHAR MessageText[ 1024 ];
858 SQLSMALLINT TextLength;
859 SQLGetDiagRec( HandleType, hstmt, 1, SQLState, &NativeError, MessageText, 1024, &TextLength );
860
861 s += string( (char*)MessageText );
862 s += " SQLSTATE=";
863 s += string( (char*)SQLState );
864
865 }
866 s += " sqlcode=";
867 s += intToString( sqlcode );
868 return s;
869 }
870
871 /**
872 *
873 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
874 *
875 */
876 string getResultCol( SQLHANDLE hstmt, int col, SQLSMALLINT targetType = SQL_C_CHAR )
877 {
878 string s;
879 SQLRETURN sqlcode;
880 SQLCHAR BinaryPtr[5000];
881 SQLLEN BinaryLenOrInd;
882 SQLINTEGER NumBytes;
883
884 syslog_printf( "getResultCol" );
885 while ( ( sqlcode = SQLGetData(hstmt, col, targetType, BinaryPtr, sizeof(BinaryPtr),
886 &BinaryLenOrInd)) != SQL_NO_DATA) {
887 syslog_printf( "SQLGetData BinaryLenOrInd=%d", BinaryLenOrInd );
888 NumBytes = (BinaryLenOrInd > 5000) || (BinaryLenOrInd == SQL_NO_TOTAL) ? 5000 : BinaryLenOrInd;
889 if( NumBytes <= 0 ) break;
890 else if( NumBytes > 0 ){
891 s += string( (char*)BinaryPtr, NumBytes );
892 }
893 }
894 syslog_printf( "getResultCol returns %s", s.c_str() );
895 return s;
896 }
897
898
899 /**
900 *
901 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申\鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
902 *
903 * @param str addslashes鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申NULL鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
904 * @return 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
905 */
906 string addSlashes( const char *str )
907 {
908 if ( hdbc == NULL ){
909 string s;
910 return s;
911 }else{
912 string s( str );
913 return s;
914 }
915
916 int len = strlen(str) * 3;
917 char* dst = new char[ len ];
918 const char* from = str;
919 char* to = dst;
920 while( *from != '\0' ){
921 switch( *from ){
922 case '\'':
923 case '\"':
924 case ';':
925 *to = '\\'; to++;
926 break;
927 }
928 *to = *from; to++;
929 from++;
930 }
931 *to = '\0';
932 string s( dst );
933 delete[] dst;
934 return s;
935 }
936
937 /** Xoops Module 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
938 * @param module 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申dirname
939 * @param key 鐃緒申鐃緒申鐃緒申key
940 * @param value 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
941 * @return
942 */
943 static result_t getXoopsModuleConfigValue( const char *module, const char *key, char **value ){
944 SQLRETURN sqlcode;
945 SQLHANDLE hstmt = NULL;
946 result_t result = RES_ERROR;
947
948 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
949 string sql = "SELECT conf_value "
950 " from " + dbprefix + "_config as tc, " + dbprefix + "_modules as tm "
951 " where tm.mid=tc.conf_modid and tm.dirname = ? and tc.conf_name = ? ";
952 sqlcode = SQLPrepare(hstmt, (SQLCHAR*)sql.c_str(), SQL_NTS);
953 SQLLEN cbModule = SQL_NTS, cbKey = SQL_NTS;
954 SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_VARCHAR, strlen(module), 0, (SQLCHAR *)module, 0, &cbModule );
955 SQLBindParameter(hstmt, 2, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_VARCHAR, strlen(key), 0, (SQLCHAR *)key, 0, &cbKey );
956 sqlcode = SQLExecute( hstmt );
957 if( sqlcode == SQL_SUCCESS || sqlcode == SQL_SUCCESS_WITH_INFO ){
958 if ( ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS ){
959 string s = getResultCol( hstmt, 1 );
960 *value = new char[s.length()+1];
961 strcpy( *value, s.c_str() );
962 result = RES_OK;
963 }
964 else if ( sqlcode == SQL_NO_DATA ){
965 *value = 0;
966 result = RES_OK;
967 }
968 else {
969 string s( "SQLFetch in getXoopsModuleConfig " );
970 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
971 s += "sql=";
972 s += sql;
973 setLastErrorString( s.c_str( ) );
974 result = RES_ERROR;
975 }
976 }else{
977 string s( "SQLExecDirect in getXoopsModuleConfig " );
978 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
979 s += "sql=";
980 s += sql;
981 setLastErrorString( s.c_str( ) );
982 result = RES_DB_QUERY_ERROR;
983 }
984 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
985 }
986 else {
987 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in getXoopsModuleConfig " );
988 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
989 setLastErrorString( s.c_str( ) );
990 result = RES_ERROR;
991 }
992 return result;
993 }
994
995 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申XooNiPs鐃緒申Public鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
996 */
997 static bool isGuestEnabled(){
998 char *value = 0;
999 result_t result = getConfigValue( XNP_CONFIG_PUBLIC_ITEM_TARGET_USER_KEY, &value );
1000 if ( result != RES_OK )
1001 return false;
1002 if ( value == 0 )
1003 return false;
1004 bool enabled = ( strcmp( value, XNP_CONFIG_PUBLIC_ITEM_TARGET_USER_ALL ) == 0 );
1005 freeString( value );
1006 return enabled;
1007 }
1008
1009 /** sid鐃緒申鐃緒申uid鐃緒申鐃緒申鐃緒申鐃緒申
1010 * @param sid session id
1011 * @param uid uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1012 * @return RES_OK
1013 * sid鐃緒申鐃緒申鐃緒申鐃緒申sessionid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申*uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申uid鐃緒申鐃緒申鐃緒申鐃緒申
1014 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申XooNiPs鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申 鐃緒申鐃緒申sid鐃緒申session::SID_GUEST(=0)鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申*uid鐃緒申鐃緒申account::UID_GUEST(=0)鐃緒申鐃緒申鐃緒申鐃緒申
1015 * @return 鐃緒申鐃緒申鐃緒申 鐃緒申鐃緒申鐃緒申
1016 */
1017 static result_t sessionID2UID( sessionid_t sid, userid_t *uid ){
1018 if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
1019
1020 if ( sid == session::SID_GUEST ){
1021 if ( isGuestEnabled() ){
1022 *uid = account::UID_GUEST;
1023 return RES_OK;
1024 }
1025 return RES_NO_SUCH_SESSION;
1026 }
1027 else {
1028 string sql = "SELECT uid FROM " + dbprefix + "_xoonips_session WHERE sid=" + unsignedIntToString(sid);
1029 syslog_printf( "sql=%s", sql.c_str() );
1030 return queryGetUnsignedInt( "sessionID2UID", sql, uid );
1031 }
1032 }
1033
1034
1035
1036 /**
1037 *
1038 * gid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
1039 * DB鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申false鐃緒申鐃緒申鐃緒申鐃緒申
1040 *
1041 * @param gid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申GID
1042 * @return true 鐃緒申鐃緒申鐃緒申鐃緒申
1043 * @return false 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1044 *
1045 */
1046 static bool gidExists( groupid_t gid )
1047 {
1048 string sql;
1049 SQLRETURN sqlcode;
1050 SQLHANDLE hstmt = NULL;
1051
1052 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) != SQL_SUCCESS ) {
1053 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in gidExists" );
1054 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
1055 setLastErrorString( s.c_str( ) );
1056 return false;
1057 }
1058
1059 sql = "SELECT * FROM " + dbprefix + "_xoonips_groups ";
1060 sql += "WHERE gid=" + string( unsignedIntToString( gid ) );
1061 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) != SQL_SUCCESS ){
1062 setLastErrorString( "SQLExecDirect in gidExists" );
1063 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
1064 return false;
1065 }
1066
1067 if( ( sqlcode = SQLFetch( hstmt ) ) != SQL_SUCCESS ){
1068 setLastErrorString( "SQLFetch in gidExists" );
1069 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
1070 return false;
1071 }
1072
1073 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
1074 return true;
1075 }
1076
1077
1078 /**
1079 *
1080 * Platform鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
1081 * DB鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申false鐃緒申鐃緒申鐃緒申鐃緒申
1082 *
1083 * @param uid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申UID
1084 * @return true 鐃緒申鐃緒申鐃緒申鐃緒申
1085 * @return false 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1086 *
1087 */
1088 static bool uidExists( userid_t uid )
1089 {
1090 bool ret = false;
1091 string sql;
1092 SQLHANDLE hstmt = NULL;
1093 SQLRETURN sqlcode;
1094
1095 sql = "SELECT * FROM " + dbprefix + "_xoonips_users ";
1096 sql += "WHERE uid=" + string( unsignedIntToString( uid ) );
1097 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
1098 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
1099 if( ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS ){
1100 ret = true;
1101 }else{
1102 string s( "SQLFetch in uidExists ");
1103 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
1104 s += string( ", sql=" ) + string( sql );
1105 setLastErrorString( s.c_str( ) );
1106 ret = false;
1107 }
1108 }else{
1109 string s( "SQLExecDirect in uidExists ");
1110 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
1111 s += string( ", sql=" ) + string( sql );
1112 setLastErrorString( s.c_str( ) );
1113 ret = false;
1114 }
1115 }else{
1116 string s( "SQLAllocHandle in uidExists ");
1117 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
1118 setLastErrorString( s.c_str( ) );
1119 ret = false;
1120 }
1121 return ret;
1122 }
1123
1124
1125 /**
1126 *
1127 * criteria 鐃緒申 SQL鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1128 *
1129 *
1130 *
1131 */
1132 string criteria2str( criteria* cri )
1133 {
1134 string sql;
1135
1136 const orderby* odrby = cri -> headOrderBy( );
1137 if( odrby != 0 ){
1138 sql += " ORDER BY " + string( odrby -> getColumn( ) );
1139 sql += ( odrby -> getOrder( ) == orderby::DESC ) ? " DESC" : " ";
1140 while( ( odrby = cri -> nextOrderBy( ) ) != 0 ){
1141 sql += ", " + string( odrby -> getColumn( ) );
1142 sql += ( odrby -> getOrder( ) == orderby::DESC ) ? " DESC" : " ";
1143 }
1144 }
1145
1146 if( cri -> getLimitStart( ) != 0 || cri -> getLimitRows( ) != 0 ){
1147 sql += " LIMIT " + string( intToString( cri -> getLimitStart( ) ) )
1148 + ", " + string( intToString( cri -> getLimitRows( ) ) );
1149 }
1150 return sql;
1151 }
1152
1153
1154 /**
1155 *
1156 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1157 *
1158 * @param dsn ODBC鐃緒申DSN
1159 * @param user 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1160 * @param password 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1161 * @param reserve 鐃緒申鐃緒申鐃緒申(NULL)
1162 * @param prefix XOOPS鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申PREFIX
1163 * @param type DBTYPE_MYSQL or DBTYPE_SQLITE
1164 * @return RES_OK
1165 * @return RES_DB_INITIALIZE_ERROR
1166 * @return RES_DB_CONNECT_ERROR
1167 * @see result_t
1168 */
1169 result_t initializeDB( const char* dsn, const char* user, const char* password, const char* reserve, const char* prefix, dbtype_t type )
1170 {
1171 SQLRETURN sqlcode;
1172
1173 // 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1174 if ( hdbc != NULL ){
1175 SQLDisconnect( hdbc );
1176 hdbc = NULL;
1177 }
1178
1179 dbprefix = prefix;
1180 dbtype = type;
1181
1182 // 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1183 // if( SQLAllocEnv( &henv ) != SQL_SUCCESS ) {
1184 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv ) ) != SQL_SUCCESS ) {
1185 string s( "SQLAllocHandle(SQL_HANDLE_ENV,...) in initializeDB" );
1186 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
1187 setLastErrorString( s.c_str( ) );
1188 syslog_printf( "initializeDB %s", getLastErrorString( ) );
1189 return RES_DB_INITIALIZE_ERROR;
1190 }
1191 //ODBC Ver.3 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1192 SQLSetEnvAttr(henv, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0);
1193
1194 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_DBC, henv, &hdbc ) ) != SQL_SUCCESS ) {
1195 string s( "SQLAllocHandle(SQL_HANDLE_DBC,...) in initializeDB" );
1196 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
1197 setLastErrorString( s.c_str( ) );
1198 syslog_printf( "initializeDB %s", getLastErrorString( ) );
1199 return RES_DB_INITIALIZE_ERROR;
1200 }
1201 //鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申5鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1202 //SQLSetConnectAttr(hdbc, SQL_LOGIN_TIMEOUT, (SQLPOINTER *)5, 0);
1203
1204 if ( ( sqlcode = SQLConnect( hdbc, (SQLCHAR*)dsn, strlen( dsn ), (SQLCHAR*)user, strlen( user ), (SQLCHAR*)password, strlen( password ) ) ) != SQL_SUCCESS ){
1205 string s( "SQLConnect in initializeDB " );
1206 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
1207 setLastErrorString( s.c_str( ) );
1208 syslog_printf( "initializeDB %s", getLastErrorString( ) );
1209 return RES_DB_CONNECT_ERROR;
1210 }
1211 syslog_printf( "initializeDB succeed" );
1212 return RES_OK;
1213 }
1214
1215 /**
1216 *
1217 * 鐃緒申鐃緒申DB鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1218 *
1219 * @param 鐃緒申鐃緒申
1220 * @return RES_OK
1221 */
1222 result_t uninitializeDB()
1223 {
1224 if ( hdbc != NULL ){
1225 SQLDisconnect( hdbc );
1226 hdbc = NULL;
1227 }
1228 return RES_OK;
1229 }
1230
1231 /**
1232 *
1233 * Platform鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1234 *
1235 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1236 * @param uid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申UID
1237 * @return true 鐃緒申鐃緒申鐃緒申鐃緒申
1238 * @return false 鐃緒申鐃緒申鐃緒申
1239 *
1240 */
1241 bool isActivated( sessionid_t sid, userid_t uid )
1242 {
1243 if( hdbc == NULL ) return false;
1244 if( !isValidSessionID( sid ) ) return false;
1245
1246 bool ret = false;
1247 string sql;
1248 SQLRETURN sqlcode;
1249 SQLHANDLE hstmt = NULL;
1250
1251 sql = "SELECT * FROM " + dbprefix + "_xoonips_users ";
1252 sql += "WHERE activate=1 and uid=" + string( unsignedIntToString( uid ) );
1253 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
1254 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
1255 if( ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS ){
1256 ret = true;
1257 }else{
1258 string s( "SQLFetch in isActivated " );
1259 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
1260 s += ", sql=" + sql;
1261 setLastErrorString( s.c_str() );
1262 ret = false;
1263 }
1264 }else{
1265 string s( "SQLExecDirect in isActivated " );
1266 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
1267 s += ", sql=" + sql;
1268 setLastErrorString( s.c_str() );
1269 ret = false;
1270 }
1271 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
1272 }else{
1273 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in isActivated" );
1274 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
1275 setLastErrorString( s.c_str( ) );
1276 ret = false;
1277 }
1278 return ret;
1279 }
1280
1281 /**
1282 *
1283 * Platform鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1284 *
1285 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1286 * @param uid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申UID
1287 * @param activate 鐃緒申鐃緒申(true) / 鐃緒申鐃緒申鐃緒申(false)鐃緒申鐃緒申鐃緒申
1288 * @return RES_OK
1289 * @return RES_ERROR
1290 * @return RES_DB_QUERY_ERROR
1291 * @return RES_NO_SUCH_USER
1292 * @return RES_NO_SUCH_SESSION
1293 * @return RES_DB_NOT_INITIALIZED;
1294 */
1295 result_t activate( sessionid_t sid, userid_t uid, bool activate )
1296 {
1297 if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
1298 if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
1299
1300 string sql;
1301 SQLHANDLE hstmt = NULL;
1302 SQLRETURN sqlcode;
1303 result_t ret = RES_ERROR;
1304
1305 sql = "UPDATE " + dbprefix + "_xoonips_users ";
1306 sql += "SET activate=" + string( activate ? "1" : "0" );
1307 sql += " WHERE uid=" + string( unsignedIntToString( uid ) );
1308 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
1309 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
1310 SQLLEN count = 0;
1311 if( ( sqlcode = SQLRowCount( hstmt, &count ) ) == SQL_SUCCESS && count > 0 ){
1312 ret = RES_OK;
1313 }else{
1314 string s( "SQLRowCount in activate ");
1315 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
1316 s += string( ", sql=" ) + string( sql );
1317 setLastErrorString( s.c_str( ) );
1318 ret = RES_NO_SUCH_USER;
1319 }
1320 }else{
1321 string s( "SQLExecDirect in activate " );
1322 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
1323 s += ", sql=";
1324 s += string( sql );
1325 setLastErrorString( s.c_str( ) );
1326 ret = RES_DB_QUERY_ERROR;
1327 }
1328 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
1329 }else{
1330 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in activate" );
1331 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
1332 setLastErrorString( s.c_str( ) );
1333 ret = RES_ERROR;
1334 }
1335 return ret;
1336 }
1337
1338 /**
1339 *
1340 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1341 *
1342 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1343 * @return 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申0)
1344 *
1345 */
1346 int getAccountCount( sessionid_t sid )
1347 {
1348 if( hdbc == NULL ) return 0;
1349 if( !isValidSessionID( sid ) ) return 0;
1350
1351 int ret = 0;
1352 string sql;
1353 SQLRETURN sqlcode;
1354 SQLHANDLE hstmt = NULL;
1355
1356 //鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1357 sql = "SELECT COUNT(*) FROM " + dbprefix + "_xoonips_users ";
1358 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
1359 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
1360 SQLUINTEGER count = 0;
1361 SQLLEN len = 0;
1362 SQLBindCol( hstmt, 1, SQL_C_ULONG, &count, 0, &len );
1363 if( ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS ){
1364 ret = count;
1365 }else {
1366 string s( "SQLFetch in getAccountCount sql=" );
1367 s += string( sql );
1368 setLastErrorString( s.c_str( ) );
1369 ret = 0;
1370 }
1371 }else{
1372 setLastErrorString( "SQLExecDirect in getAccountCount" );
1373 ret = 0;
1374 }
1375 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
1376 }else{
1377 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in getAccountCount" );
1378 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
1379 setLastErrorString( s.c_str( ) );
1380 ret = 0;
1381 }
1382 return ret;
1383 }
1384
1385 /**
1386 *
1387 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1388 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1389 *
1390 * @param
1391 * @return RES_OK
1392 * @return RES_ERROR
1393 * @return RES_DB_NOT_INITIALIZED
1394 * @return RES_NO_SUCH_SESSION
1395 * @return RES_DB_QUERY_ERROR
1396 *
1397 */
1398 result_t deleteAccount( sessionid_t sid, userid_t uid )
1399 {
1400 if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
1401 if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
1402
1403 result_t ret1 = RES_ERROR, ret2 = RES_ERROR;
1404 criteria_t c;
1405 string sql;
1406 groupid_t* gids;
1407 int gidsLen;
1408 SQLRETURN sqlcode;
1409 SQLHANDLE hstmt = NULL;
1410
1411 /*
1412 1. delete user from default platform group
1413 2. delete user profile from xoops_users
1414 3. delete platform user from xoonips_users
1415 */
1416
1417 //1. delete user from platform groups
1418 c.clearAll();
1419 if( getGroupsByUid( sid, uid, &c, &gids, &gidsLen ) == RES_OK ){
1420 for( int i = 0; i < gidsLen; i++ )
1421 deleteMemberNoLimit( sid, gids[ i ], uid );
1422 freeGID( gids );
1423 }
1424
1425 //2. delete user profile from xoops_users
1426 sql = "DELETE FROM " + dbprefix + "_users ";
1427 sql += "WHERE uid = " + string( unsignedIntToString( uid ) );
1428 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
1429 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
1430 SQLLEN count = 0;
1431 if( ( sqlcode = SQLRowCount( hstmt, &count ) ) == SQL_SUCCESS && count > 0 ){
1432 ret1 = RES_OK;
1433 }else{
1434 string s( "SQLRowCount in deleteAccount" );
1435 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
1436 s += string( ", sql=" ) + string( sql );
1437 setLastErrorString( s.c_str( ) );
1438 ret1 = RES_NO_SUCH_USER;
1439 }
1440 }else{
1441 string s( "SQLExecDirect in deleteAccount" );
1442 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
1443 s += ", sql=";
1444 s += string( sql );
1445 setLastErrorString( s.c_str( ) );
1446 ret1 = RES_DB_QUERY_ERROR;
1447 }
1448 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
1449 }else{
1450 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in deleteAccount" );
1451 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
1452 setLastErrorString( s.c_str( ) );
1453 ret1 = RES_ERROR;
1454 }
1455
1456 //3. delete platform user from xoonips_users
1457 sql = "DELETE FROM " + dbprefix + "_xoonips_users ";
1458 sql += "WHERE uid = " + string( unsignedIntToString( uid ) );
1459 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
1460 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
1461 SQLLEN count = 0;
1462 if( ( sqlcode = SQLRowCount( hstmt, &count ) ) == SQL_SUCCESS && count > 0 ){
1463 ret2 = RES_OK;
1464 }else{
1465 string s( "SQLRowCount in deleteAccount" );
1466 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
1467 s += string( ", sql=" ) + string( sql );
1468 setLastErrorString( s.c_str( ) );
1469 ret2 = RES_NO_SUCH_USER;
1470 }
1471 }else{
1472 string s( "SQLExecDirect in deleteAccount" );
1473 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
1474 s += ", sql=";
1475 s += string( sql );
1476 setLastErrorString( s.c_str( ) );
1477 ret2 = RES_DB_QUERY_ERROR;
1478 }
1479 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
1480 }else{
1481 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in deleteAccount" );
1482 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
1483 setLastErrorString( s.c_str( ) );
1484 ret2 = RES_ERROR;
1485 }
1486
1487 //鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1488 return ret1 != RES_OK ? ret1 : ret2;
1489 }
1490
1491 /**
1492 *
1493 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1494 *
1495 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1496 * @param uid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申UID
1497 * @param acc 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(account_t)鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1498 * @return RES_OK
1499 * @return RES_DB_NOT_INITIALIZED
1500 * @return RES_NO_SUCH_USER
1501 * @return RES_NO_SUCH_SESSION
1502 * @return RES_DB_QUERY_ERROR
1503 * @see freeAccount
1504 *
1505 */
1506 result_t getAccount( sessionid_t sid, userid_t uid, const account_t** acc )
1507 {
1508 int len = 0;
1509 static criteria c;
1510 result_t res = getAccounts( sid, &uid, 1, &c, acc, &len );
1511 if( res == RES_OK && len == 0 ) return RES_NO_SUCH_USER;
1512 return res;
1513 }
1514
1515 /**
1516 *
1517 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1518 *
1519 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1520 * @param uids 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申UID鐃緒申鐃緒申鐃緒申
1521 * @param uidsLen uids鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1522 * @param cri 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1523 * @param accounts 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1524 * @param accountsLen 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申*accounts鐃緒申鐃緒申鐃緒申鐃緒申)
1525 * @return RES_OK
1526 * @return RES_DB_NOT_INITIALIZED
1527 * @return RES_NO_SUCH_SESSION
1528 * @return RES_DB_QUERY_ERROR
1529 * @see freeAccount
1530 *
1531 */
1532 result_t getAccounts( sessionid_t sid, const userid_t* uids, int uidsLen, criteria_t* cri, const account_t** accounts, int* accountsLen )
1533 {
1534 if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
1535 if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
1536 if( uidsLen <= 0 ){
1537 *accounts = new account_t[ 0 ];
1538 *accountsLen = 0;
1539 syslog_printf( "getAccounts succeed len=0" );
1540 return RES_OK;
1541 }
1542
1543 syslog_printf( "begin of getAccounts" );
1544 result_t ret = RES_ERROR;
1545 SQLRETURN sqlcode;
1546 SQLHANDLE hstmt = NULL;
1547 string sql;
1548 account_t* dst = new account_t[ uidsLen ];
1549
1550 sql += "SELECT u1.uid, u1.name, u1.uname, u1.email, u1.url, u1.user_avatar, u1.user_regdate, u1.user_icq, u1.user_from, u1.user_sig, u1.user_viewemail, u1.actkey, u1.user_aim, u1.user_yim, u1.user_msnm, u1.pass, u1.posts, u1.attachsig, u1.rank, u1.level, u1.theme, u1.timezone_offset, u1.last_login, u1.umode, u1.uorder, u1.notify_method, u1.notify_mode, u1.user_occ, u1.bio, u1.user_intrest, u1.user_mailok, u2.activate, u2.address, u2.division, u2.tel, u2.company_name, u2.country, u2.zipcode, u2.fax, u2.notice_mail, u2.notice_mail_since, u2.private_index_id, u2.private_item_number_limit, u2.private_index_number_limit, u2.private_item_storage_limit ";
1551 sql += "FROM " + dbprefix + "_users AS u1, " + dbprefix + "_xoonips_users AS u2 ";
1552 sql += "WHERE u1.uid = u2.uid ";
1553 if( uidsLen > 0 ){
1554 syslog_printf( "set uid[%d] value=%d to ...", 0, uids[0] );
1555 sql += "AND ( u1.uid=" + string( unsignedIntToString( uids[ 0 ] ) );
1556 for( int i = 1; i < uidsLen; i++ ){
1557 syslog_printf( "set uid[%d] value=%d to ...", i, uids[i] );
1558 sql += " OR u1.uid=" + string( unsignedIntToString( uids[ i ] ) );
1559 }
1560 sql += " ) ";
1561 }
1562 sql += criteria2str( cri );
1563 syslog_printf( "sql=%s", sql.c_str() );
1564
1565 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
1566 syslog_printf( "SQLAllocHandle" );
1567 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
1568 syslog_printf( "SQLExecDirect" );
1569 SQLLEN cbUid = 0, cbStorageLimit = 0;
1570 userid_t uid = 0;
1571 SQLDOUBLE storage_limit = 0;
1572 SQLBindCol( hstmt, 1, SQL_C_ULONG, &uid, 0, &cbUid );
1573 SQLBindCol( hstmt, 45, SQL_C_DOUBLE, &storage_limit, 0, &cbStorageLimit );
1574 syslog_printf( "SQLBindCol" );
1575 *accountsLen=0;
1576 for( int i = 0; ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS && i < uidsLen ; i++ ){
1577 syslog_printf( "SQLFetch" );
1578 dst[ i ].setUID( uid );
1579 dst[ i ].setName( getResultCol( hstmt, 2 ).c_str() );
1580 dst[ i ].setUname( getResultCol( hstmt, 3 ).c_str() );
1581 dst[ i ].setEmail( getResultCol( hstmt, 4 ).c_str() );
1582 dst[ i ].setURL( getResultCol( hstmt, 5 ).c_str() );
1583 dst[ i ].setUserAvatar( getResultCol( hstmt, 6 ).c_str() );
1584 dst[ i ].setUserRegdate( atoi( getResultCol( hstmt, 7 ).c_str() ) );
1585 dst[ i ].setUserIcq( getResultCol( hstmt, 8 ).c_str() );
1586 dst[ i ].setUserFrom( getResultCol( hstmt, 9 ).c_str() );
1587 dst[ i ].setUserSig( getResultCol( hstmt, 10 ).c_str() );
1588 dst[ i ].setUserViewemail( atoi( getResultCol( hstmt, 11 ).c_str() ));
1589 dst[ i ].setActkey( getResultCol( hstmt, 12 ).c_str() );
1590 dst[ i ].setUserAim( getResultCol( hstmt, 13 ).c_str() );
1591 dst[ i ].setUserYim( getResultCol( hstmt, 14 ).c_str() );
1592 dst[ i ].setUserMsnm( getResultCol( hstmt, 15 ).c_str() );
1593 dst[ i ].setPass( getResultCol( hstmt, 16 ).c_str() );
1594 dst[ i ].setPosts( atoi( getResultCol( hstmt, 17 ).c_str() ));
1595 dst[ i ].setAttachsig( atoi( getResultCol( hstmt, 18 ).c_str() ));
1596 dst[ i ].setRank( atoi( getResultCol( hstmt, 19 ).c_str() ));
1597 dst[ i ].setLevel( atoi( getResultCol( hstmt, 20 ).c_str() ));
1598 dst[ i ].setTheme( getResultCol( hstmt, 21 ).c_str() );
1599 dst[ i ].setTimezoneOffset( atof( getResultCol( hstmt, 22 ).c_str() ) );
1600 dst[ i ].setLastLogin( atoi( getResultCol( hstmt, 23 ).c_str() ));
1601 dst[ i ].setUmode( getResultCol( hstmt, 24 ).c_str() );
1602 dst[ i ].setUorder( atoi( getResultCol( hstmt, 25 ).c_str() ));
1603 dst[ i ].setNotifyMethod( atoi( getResultCol( hstmt, 26 ).c_str() ));
1604 dst[ i ].setNotifyMode( atoi( getResultCol( hstmt, 27 ).c_str() ));
1605 dst[ i ].setUserOcc( getResultCol( hstmt, 28 ).c_str() );
1606 dst[ i ].setBio( getResultCol( hstmt, 29 ).c_str() );
1607 dst[ i ].setUserIntrest( getResultCol( hstmt, 30 ).c_str() );
1608 dst[ i ].setUserMailok( atoi( getResultCol( hstmt, 31 ).c_str() ));
1609 dst[ i ].setActivate( atoi( getResultCol( hstmt, 32 ).c_str() ));
1610 dst[ i ].setAddress( getResultCol( hstmt, 33 ).c_str() );
1611 dst[ i ].setDivision( getResultCol( hstmt, 34 ).c_str() );
1612 dst[ i ].setTel( getResultCol( hstmt, 35 ).c_str() );
1613 dst[ i ].setCompanyName( getResultCol( hstmt, 36 ).c_str() );
1614 dst[ i ].setCountry( getResultCol( hstmt, 37 ).c_str() );
1615 dst[ i ].setZipcode( getResultCol( hstmt, 38 ).c_str() );
1616 dst[ i ].setFax( getResultCol( hstmt, 39 ).c_str() );
1617 dst[ i ].setNoticeMail( atoi( getResultCol( hstmt, 40 ).c_str() ));
1618 dst[ i ].setNoticeMailSince( atoi( getResultCol( hstmt, 41 ).c_str() ));
1619 dst[ i ].setPrivateIndexID( atoi( getResultCol( hstmt, 42 ).c_str() ));
1620 dst[ i ].setItemNumberLimit( atoi( getResultCol( hstmt, 43 ).c_str() ));
1621 dst[ i ].setIndexNumberLimit( atoi( getResultCol( hstmt, 44 ).c_str() ));
1622 dst[ i ].setItemStorageLimit( storage_limit );
1623 ( *accountsLen )++;
1624 }
1625 *accounts = dst;
1626 syslog_printf( "getAccounts succeed" );
1627 ret = RES_OK;
1628 }else{
1629 string s( "SQLExecDirect in getAccounts" );
1630 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
1631 s += string( ", sql=" ) + string( sql );
1632 setLastErrorString( s.c_str( ) );
1633 syslog_printf( "getAccounts %s", getLastErrorString( ) );
1634 ret = RES_DB_QUERY_ERROR;
1635 }
1636 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
1637 }else{
1638 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in getAccounts" );
1639 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
1640 setLastErrorString( s.c_str( ) );
1641 syslog_printf( "getAccounts %s", getLastErrorString( ) );
1642 ret = RES_DB_QUERY_ERROR;
1643 }
1644 return ret;
1645 }
1646
1647 /**
1648 *
1649 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1650 *
1651 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1652 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1653 *
1654 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1655 * @param account 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1656 * @param uid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1657 * @return RES_OK
1658 * @return RES_NO_SUCH_SESSION
1659 * @return RES_DB_QUERY_ERROR
1660 * @return RES_DB_NOT_INITIALIZED
1661 *
1662 */
1663 result_t insertAccount( sessionid_t sid, const account_t* account, userid_t* uid )
1664 {
1665 if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
1666 if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
1667
1668 string sql;
1669 string tmp;
1670 SQLHANDLE hstmt = NULL;
1671 SQLRETURN sqlcode;
1672 result_t ret = RES_ERROR;
1673
1674 /*
1675 1. insert user profile into xoops_users
1676 2. insert platform user profile into xoonips_users
1677 3. add user to default platform group
1678 4. create private index
1679 5. update account set private_index_id=...
1680 */
1681
1682 //1.xoops鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1683 SQLCHAR uname[ACCOUNT_UNAME_LEN+1], name[ACCOUNT_NAME_LEN+1], email[ACCOUNT_EMAIL_LEN+1], url[ACCOUNT_URL_LEN+1], user_avatar[ACCOUNT_USER_AVATAR_LEN+1], user_icq[ACCOUNT_USER_ICQ_LEN+1], user_from[ACCOUNT_USER_FROM_LEN+1], user_sig[ACCOUNT_USER_SIG_LEN+1], actkey[ACCOUNT_ACTKEY_LEN+1], user_aim[ACCOUNT_USER_AIM_LEN+1], user_yim[ACCOUNT_USER_YIM_LEN+1], user_msnm[ACCOUNT_USER_MSNM_LEN+1], pass[ACCOUNT_PASS_LEN+1], theme[ACCOUNT_THEME_LEN+1], umode[ACCOUNT_UMODE_LEN+1], user_occ[ACCOUNT_USER_OCC_LEN+1], bio[ACCOUNT_BIO_LEN+1], user_intrest[ACCOUNT_USER_INTREST_LEN+1];
1684 SQLINTEGER user_regdate, user_viewemail, posts, attachsig, rank, level, last_login, uorder, notify_method, notify_mode, user_mailok;
1685 SQLDOUBLE timezone_offset;
1686
1687 SQLLEN cbUname = SQL_NTS, cbName = SQL_NTS, cbEmail = SQL_NTS, cbUrl = SQL_NTS, cbUser_avatar = SQL_NTS, cbUser_icq = SQL_NTS, cbUser_from = SQL_NTS, cbUser_sig = SQL_NTS, cbActkey = SQL_NTS, cbUser_aim = SQL_NTS, cbUser_yim = SQL_NTS, cbUser_msnm = SQL_NTS, cbPass = SQL_NTS, cbTheme = SQL_NTS, cbUmode = SQL_NTS, cbUser_occ = SQL_NTS, cbBio = SQL_NTS, cbUser_intrest = SQL_NTS;
1688 SQLLEN cbUser_regdate = 0, cbUser_viewemail = 0, cbPosts = 0, cbAttachsig = 0, cbRank = 0, cbLevel = 0, cbLast_login = 0, cbUorder = 0, cbNotify_method = 0, cbNotify_mode = 0, cbUser_mailok = 0, cbTimezone_offset = 0;
1689
1690 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
1691 string sql;
1692 sql = "INSERT INTO " + dbprefix + "_users (uname, name, email, url, user_avatar, user_regdate, user_icq, user_from, user_sig, user_viewemail, actkey, user_aim, user_yim, user_msnm, pass, posts, attachsig, rank, level, theme, timezone_offset, last_login, umode, uorder, notify_method, notify_mode, user_occ, bio, user_intrest, user_mailok) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
1693 sqlcode = SQLPrepare(hstmt, (SQLCHAR*)sql.c_str(), SQL_NTS);
1694 if( sqlcode == SQL_SUCCESS || sqlcode == SQL_SUCCESS_WITH_INFO ){
1695 SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_UNAME_LEN, 0, uname, 0, &cbUname );
1696 SQLBindParameter(hstmt, 2, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_NAME_LEN, 0, name, 0, &cbName );
1697 SQLBindParameter(hstmt, 3, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_EMAIL_LEN, 0, email, 0, &cbEmail );
1698 SQLBindParameter(hstmt, 4, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_URL_LEN, 0, url, 0, &cbUrl );
1699 SQLBindParameter(hstmt, 5, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_AVATAR_LEN, 0, user_avatar, 0, &cbUser_avatar );
1700 SQLBindParameter(hstmt, 6, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &user_regdate, 0, &cbUser_regdate );
1701 SQLBindParameter(hstmt, 7, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_ICQ_LEN, 0, user_icq, 0, &cbUser_icq );
1702 SQLBindParameter(hstmt, 8, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_FROM_LEN, 0, user_from, 0, &cbUser_from );
1703 SQLBindParameter(hstmt, 9, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_SIG_LEN, 0, user_sig, 0, &cbUser_sig );
1704 SQLBindParameter(hstmt, 10, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &user_viewemail, 0, &cbUser_viewemail );
1705 SQLBindParameter(hstmt, 11, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_ACTKEY_LEN, 0, actkey, 0, &cbActkey );
1706 SQLBindParameter(hstmt, 12, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_AIM_LEN, 0, user_aim, 0, &cbUser_aim );
1707 SQLBindParameter(hstmt, 13, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_YIM_LEN, 0, user_yim, 0, &cbUser_yim );
1708 SQLBindParameter(hstmt, 14, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_MSNM_LEN, 0, user_msnm, 0, &cbUser_msnm );
1709 SQLBindParameter(hstmt, 15, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_PASS_LEN, 0, pass, 0, &cbPass );
1710 SQLBindParameter(hstmt, 16, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &posts, 0, &cbPosts );
1711 SQLBindParameter(hstmt, 17, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &attachsig, 0, &cbAttachsig );
1712 SQLBindParameter(hstmt, 18, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &rank, 0, &cbRank );
1713 SQLBindParameter(hstmt, 19, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &level, 0, &cbLevel );
1714 SQLBindParameter(hstmt, 20, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_THEME_LEN, 0, theme, 0, &cbTheme );
1715 SQLBindParameter(hstmt, 21, SQL_PARAM_INPUT, SQL_C_DOUBLE, SQL_DOUBLE, 0, 0, &timezone_offset, 0, &cbTimezone_offset );
1716 SQLBindParameter(hstmt, 22, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &last_login, 0, &cbLast_login );
1717 SQLBindParameter(hstmt, 23, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_UMODE_LEN, 0, umode, 0, &cbUmode );
1718 SQLBindParameter(hstmt, 24, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &uorder, 0, &cbUorder );
1719 SQLBindParameter(hstmt, 25, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &notify_method, 0, &cbNotify_method );
1720 SQLBindParameter(hstmt, 26, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &notify_mode, 0, &cbNotify_mode );
1721 SQLBindParameter(hstmt, 27, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_OCC_LEN, 0, user_occ, 0, &cbUser_occ );
1722 SQLBindParameter(hstmt, 28, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_BIO_LEN, 0, bio, 0, &cbBio );
1723 SQLBindParameter(hstmt, 29, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_INTREST_LEN, 0, user_intrest, 0, &cbUser_intrest );
1724 SQLBindParameter(hstmt, 30, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &user_mailok, 0, &cbUser_mailok );
1725
1726 strncpy2( (char*)uname, account -> getUname( ), ACCOUNT_UNAME_LEN );
1727 strncpy2( (char*)name, account -> getName( ), ACCOUNT_NAME_LEN );
1728 strncpy2( (char*)email, account -> getEmail( ), ACCOUNT_EMAIL_LEN );
1729 strncpy2( (char*)url, account -> getURL( ), ACCOUNT_URL_LEN );
1730 strncpy2( (char*)user_avatar, account -> getUserAvatar( ), ACCOUNT_USER_AVATAR_LEN );
1731 user_regdate = time( NULL );
1732 strncpy2( (char*)user_icq, account -> getUserIcq( ), ACCOUNT_USER_ICQ_LEN );
1733 strncpy2( (char*)user_from, account -> getUserFrom( ), ACCOUNT_USER_FROM_LEN );
1734 strncpy2( (char*)user_sig, account -> getUserSig( ), ACCOUNT_USER_SIG_LEN );
1735 user_viewemail = account -> getUserViewemail( );
1736 strncpy2( (char*)actkey, account -> getActkey( ), ACCOUNT_ACTKEY_LEN );
1737 strncpy2( (char*)user_aim, account -> getUserAim( ), ACCOUNT_USER_AIM_LEN );
1738 strncpy2( (char*)user_yim, account -> getUserYim( ), ACCOUNT_USER_YIM_LEN );
1739 strncpy2( (char*)user_msnm, account -> getUserMsnm( ), ACCOUNT_USER_MSNM_LEN );
1740 strncpy2( (char*)pass, account -> getPass( ), ACCOUNT_PASS_LEN );
1741 posts = account -> getPosts( );
1742 attachsig = account -> getAttachsig( );
1743 rank = account -> getRank( );
1744 level = account -> getLevel( );
1745 strncpy2( (char*)theme, account -> getTheme( ), ACCOUNT_THEME_LEN );
1746 timezone_offset = account -> getTimezoneOffset( );
1747 last_login = 0;
1748 strncpy2( (char*)umode, account -> getUmode( ), ACCOUNT_UMODE_LEN );
1749 uorder = account -> getUorder( );
1750 notify_method = account -> getNotifyMethod( );
1751 notify_mode = account -> getNotifyMode( );
1752 strncpy2( (char*)user_occ, account -> getUserOcc( ), ACCOUNT_USER_OCC_LEN );
1753 strncpy2( (char*)bio, account -> getBio( ), ACCOUNT_BIO_LEN );
1754 strncpy2( (char*)user_intrest, account -> getUserIntrest( ), ACCOUNT_USER_INTREST_LEN );
1755 user_mailok = account -> getUserMailok( );
1756
1757 if( ( sqlcode = SQLExecute( hstmt ) ) == SQL_SUCCESS ){
1758 SQLLEN count = 0;
1759 if( ( sqlcode = SQLRowCount( hstmt, &count ) ) == SQL_SUCCESS && count > 0 ){
1760 //鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1761 if( dbtype == DBTYPE_MYSQL ){
1762 sql = "SELECT LAST_INSERT_ID()";
1763 }else if( dbtype == DBTYPE_SQLITE ){
1764 sql = "SELECT LAST_INSERT_ROWID()";
1765 }
1766 ret = queryGetUnsignedInt( "insertAccount", sql, (unsigned int*)uid );
1767 }else{
1768 string s( "SQLRowCount in insertAccount sql=" );
1769 s += string( sql );
1770 setLastErrorString( s.c_str( ) );
1771 ret = RES_DB_QUERY_ERROR;
1772 }
1773 }else{
1774 string s( "SQLExecute in insertAccount " );
1775 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
1776 setLastErrorString( s.c_str( ) );
1777 ret = RES_DB_QUERY_ERROR;
1778 }
1779 }else{
1780 string s( "SQLPrepare in insertAccount " );
1781 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
1782 setLastErrorString( s.c_str( ) );
1783 ret = RES_ERROR;
1784 }
1785 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
1786 }else{
1787 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in insertAccount" );
1788 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
1789 setLastErrorString( s.c_str( ) );
1790 ret = RES_ERROR;
1791 }
1792
1793 if( ret == RES_OK ){
1794 //2.xoonips鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1795 SQLUINTEGER activate;
1796 SQLCHAR address[XNP_ACCOUNT_ADDRESS_LEN+1];
1797 SQLCHAR division[XNP_ACCOUNT_DIVISION_LEN+1];
1798 SQLCHAR tel[XNP_ACCOUNT_TEL_LEN+1];
1799 SQLCHAR company_name[XNP_ACCOUNT_COMPANY_NAME_LEN+1];
1800 SQLCHAR country[XNP_ACCOUNT_COUNTRY_LEN+1];
1801 SQLCHAR zipcode[XNP_ACCOUNT_ZIPCODE_LEN+1];
1802 SQLCHAR fax[XNP_ACCOUNT_FAX_LEN+1];
1803 SQLLEN cbAddress = SQL_NTS, cbDivision = SQL_NTS, cbTel = SQL_NTS, cbCompany_name = SQL_NTS, cbCountry = SQL_NTS, cbZipcode = SQL_NTS, cbFax = SQL_NTS;
1804 SQLLEN cbUid = 0, cbActivate = 0, cbNotice_mail = 0, cbNotice_mail_since = 0, cbItem_number_limit = 0, cbIndex_number_limit = 0, cbItem_storage_limit = 0;
1805 SQLUINTEGER notice_mail;
1806 SQLUINTEGER notice_mail_since;
1807 SQLINTEGER item_number_limit;
1808 SQLINTEGER index_number_limit;
1809 SQLDOUBLE item_storage_limit;
1810
1811 if( ret == RES_OK && ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
1812 string sql;
1813 sql = "INSERT INTO " + dbprefix + "_xoonips_users (uid, activate, address, division, tel, company_name, country, zipcode, fax, notice_mail, notice_mail_since, private_item_number_limit, private_index_number_limit, private_item_storage_limit) VALUES ( ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ? )";
1814 sqlcode = SQLPrepare(hstmt, (SQLCHAR*)sql.c_str(), SQL_NTS);
1815 if( sqlcode == SQL_SUCCESS || sqlcode == SQL_SUCCESS_WITH_INFO ){
1816 SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, uid, 0, &cbUid);
1817 SQLBindParameter(hstmt, 2, SQL_PARAM_INPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, &activate, 0, &cbActivate);
1818 SQLBindParameter(hstmt, 3, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_ADDRESS_LEN, 0, address, 0, &cbAddress);
1819 SQLBindParameter(hstmt, 4, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_DIVISION_LEN, 0, division, 0, &cbDivision);
1820 SQLBindParameter(hstmt, 5, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_TEL_LEN, 0, tel, 0, &cbTel);
1821 SQLBindParameter(hstmt, 6, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_COMPANY_NAME_LEN, 0, company_name, 0, &cbCompany_name);
1822 SQLBindParameter(hstmt, 7, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_COUNTRY_LEN, 0, country, 0, &cbCountry);
1823 SQLBindParameter(hstmt, 8, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_ZIPCODE_LEN, 0, zipcode, 0, &cbZipcode);
1824 SQLBindParameter(hstmt, 9, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_FAX_LEN, 0, fax, 0, &cbFax);
1825 SQLBindParameter(hstmt, 10, SQL_PARAM_INPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, &notice_mail, 0, &cbNotice_mail);
1826 SQLBindParameter(hstmt, 11, SQL_PARAM_INPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, &notice_mail_since, 0, &cbNotice_mail_since);
1827 SQLBindParameter(hstmt, 12, SQL_PARAM_INPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, &item_number_limit, 0, &cbItem_number_limit);
1828 SQLBindParameter(hstmt, 13, SQL_PARAM_INPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, &index_number_limit, 0, &cbIndex_number_limit);
1829 SQLBindParameter(hstmt, 14, SQL_PARAM_INPUT, SQL_C_DOUBLE, SQL_DOUBLE, 0, 0, &item_storage_limit, 0, &cbItem_storage_limit);
1830
1831 activate = account -> getActivate() ? 1 : 0;
1832 strncpy2( (char*)address, account -> getAddress(), XNP_ACCOUNT_ADDRESS_LEN );
1833 strncpy2( (char*)division, account -> getDivision(), XNP_ACCOUNT_DIVISION_LEN );
1834 strncpy2( (char*)tel, account -> getTel(), XNP_ACCOUNT_TEL_LEN );
1835 strncpy2( (char*)company_name, account -> getCompanyName(), XNP_ACCOUNT_COMPANY_NAME_LEN );
1836 strncpy2( (char*)country, account -> getCountry(), XNP_ACCOUNT_COUNTRY_LEN );
1837 strncpy2( (char*)zipcode, account -> getZipcode(), XNP_ACCOUNT_ZIPCODE_LEN );
1838 strncpy2( (char*)fax, account -> getFax(), XNP_ACCOUNT_FAX_LEN );
1839 notice_mail = account -> getNoticeMail( );
1840 notice_mail_since = time( NULL );
1841 item_number_limit = account -> getItemNumberLimit( );
1842 index_number_limit = account -> getIndexNumberLimit( );
1843 item_storage_limit = account -> getItemStorageLimit( );
1844
1845 if( ( sqlcode = SQLExecute( hstmt ) ) == SQL_SUCCESS ){
1846 SQLLEN count = 0;
1847 if( ( sqlcode = SQLRowCount( hstmt, &count ) ) == SQL_SUCCESS && count > 0 ){
1848 ret = RES_OK;
1849 if( ret == RES_OK ){
1850 //3.add new user to default group(not a group admin)
1851 ret = insertMember( sid, group_t::GID_DEFAULT, *uid, false );
1852 }else{
1853 //xoops_users鐃緒申insert鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1854 sql = "DELETE FROM " + dbprefix + "_users where uid=";
1855 sql += unsignedIntToString( *uid );
1856 SQLHANDLE hstmt2 = NULL;
1857 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt2 ) ) == SQL_SUCCESS ) {
1858 SQLExecDirect( hstmt2, (SQLCHAR*)sql.c_str(), sql.length() );
1859 SQLFreeHandle( SQL_HANDLE_STMT, hstmt2 );
1860 }
1861 setLastErrorString( "insertMember in insertAccount" );
1862 ret = RES_DB_QUERY_ERROR;
1863 }
1864 }else{
1865 string s( "SQLRowCount in insertAccount sql=" );
1866 s += string( sql );
1867 setLastErrorString( s.c_str( ) );
1868 ret = RES_DB_QUERY_ERROR;
1869 }
1870 }else{
1871 string s( "SQLExecute in insertAccount " );
1872 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
1873 setLastErrorString( s.c_str( ) );
1874 ret = RES_DB_QUERY_ERROR;
1875 }
1876 }else{
1877 //xoops_users鐃緒申insert鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1878 sql = "DELETE FROM " + dbprefix + "_users where uid=";
1879 sql += unsignedIntToString( *uid );
1880 SQLHANDLE hstmt2 = NULL;
1881 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt2 ) ) == SQL_SUCCESS ) {
1882 SQLExecDirect( hstmt2, (SQLCHAR*)sql.c_str(), sql.length() );
1883 SQLFreeHandle( SQL_HANDLE_STMT, hstmt2 );
1884 }
1885 string s( "SQLExecDirect in insertAccount sql=" );
1886 s += string( sql );
1887 setLastErrorString( s.c_str( ) );
1888 ret = RES_DB_QUERY_ERROR;
1889 }
1890 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
1891 }else{
1892 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in insertAccount" );
1893 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
1894 setLastErrorString( s.c_str( ) );
1895 ret = RES_ERROR;
1896 }
1897 }
1898
1899 if ( ret == RES_OK ){
1900 //4.private index鐃緒申鐃緒申鐃緒申
1901
1902 // private index鐃緒申鐃緒申sort_number鐃緒申鐃緒申
1903 string sql = "select min(sort_number) from " +
1904 dbprefix + "_xoonips_index where parent_index_id=" + unsignedIntToString(item::IID_ROOT) +
1905 " and open_level=" + unsignedIntToString(index::OL_PRIVATE);
1906 unsigned int sortNumber;
1907 ret = queryGetUnsignedInt( "insertAccount", sql, &sortNumber );
1908 sortNumber--;
1909 if ( ret == RES_OK ){
1910 // private index鐃緒申鐃緒申
1911 index_t index;
1912 index.setItemTypeID(item::ITID_INDEX);
1913 index.setContributorUID(*uid);
1914 index.setParentIndexID(item::IID_ROOT);
1915 index.setOwnerUID(*uid);
1916 index.setOpenLevel(index::OL_PRIVATE);
1917 index.setSortNumber(sortNumber);
1918 index.setTitle(account->getUname());
1919 indexid_t privateXID;
1920 ret = insertIndexInternal( sid, &index, &privateXID );
1921 if ( ret == RES_OK ){
1922 // xnpaccuont_users鐃緒申private_index_id鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1923 sql = "UPDATE " + dbprefix + "_xoonips_users SET private_index_id="
1924 + unsignedIntToString(privateXID) + " WHERE uid=" + unsignedIntToString(*uid);
1925 ret = querySimple( "insertAccount", sql );
1926 }
1927 }
1928 }
1929
1930 return ret;
1931 }
1932
1933 /**
1934 *
1935 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
1936 * account鐃緒申uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1937 *
1938 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1939 * @param account 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1940 * @return RES_OK
1941 * @return RES_DB_NOT_INITIALIZED
1942 * @return RES_NO_SUCH_SESSION
1943 * @return RES_DB_QUERY_ERROR
1944 * @return RES_NO_SUCH_USER
1945 * @return RES_ERROR
1946 *
1947 */
1948 result_t updateAccount( sessionid_t sid, const account_t* account )
1949 {
1950 if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
1951 if( account == NULL ) return RES_ERROR;
1952 if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
1953 if( !uidExists( account -> getUID( ) ) ) return RES_NO_SUCH_USER;
1954
1955 SQLRETURN sqlcode;
1956 result_t ret = RES_ERROR;
1957 SQLHANDLE hstmt = NULL;
1958
1959 //xoops鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1960 SQLCHAR uname[ACCOUNT_UNAME_LEN+1], name[ACCOUNT_NAME_LEN+1], email[ACCOUNT_EMAIL_LEN+1], url[ACCOUNT_URL_LEN+1], user_avatar[ACCOUNT_USER_AVATAR_LEN+1], user_icq[ACCOUNT_USER_ICQ_LEN+1], user_from[ACCOUNT_USER_FROM_LEN+1], user_sig[ACCOUNT_USER_SIG_LEN+1], actkey[ACCOUNT_ACTKEY_LEN+1], user_aim[ACCOUNT_USER_AIM_LEN+1], user_yim[ACCOUNT_USER_YIM_LEN+1], user_msnm[ACCOUNT_USER_MSNM_LEN+1], pass[ACCOUNT_PASS_LEN+1], theme[ACCOUNT_THEME_LEN+1], umode[ACCOUNT_UMODE_LEN+1], user_occ[ACCOUNT_USER_OCC_LEN+1], bio[ACCOUNT_BIO_LEN+1], user_intrest[ACCOUNT_USER_INTREST_LEN+1];
1961 SQLINTEGER uid, user_regdate, user_viewemail, posts, attachsig, rank, level, last_login, uorder, notify_method, notify_mode, user_mailok;
1962 SQLDOUBLE timezone_offset;
1963
1964 SQLLEN cbUname = SQL_NTS, cbName = SQL_NTS, cbEmail = SQL_NTS, cbUrl = SQL_NTS, cbUser_avatar = SQL_NTS, cbUser_icq = SQL_NTS, cbUser_from = SQL_NTS, cbUser_sig = SQL_NTS, cbActkey = SQL_NTS, cbUser_aim = SQL_NTS, cbUser_yim = SQL_NTS, cbUser_msnm = SQL_NTS, cbPass = SQL_NTS, cbTheme = SQL_NTS, cbUmode = SQL_NTS, cbUser_occ = SQL_NTS, cbBio = SQL_NTS, cbUser_intrest = SQL_NTS;
1965 SQLLEN cbUid = 0, cbUser_regdate = 0, cbUser_viewemail = 0, cbPosts = 0, cbAttachsig = 0, cbRank = 0, cbLevel = 0, cbLast_login = 0, cbUorder = 0, cbNotify_method = 0, cbNotify_mode = 0, cbUser_mailok = 0, cbTimezone_offset = 0;
1966
1967 SQLUINTEGER activate;
1968 SQLCHAR address[XNP_ACCOUNT_ADDRESS_LEN+1];
1969 SQLCHAR division[XNP_ACCOUNT_DIVISION_LEN+1];
1970 SQLCHAR tel[XNP_ACCOUNT_TEL_LEN+1];
1971 SQLCHAR company_name[XNP_ACCOUNT_COMPANY_NAME_LEN+1];
1972 SQLCHAR country[XNP_ACCOUNT_COUNTRY_LEN+1];
1973 SQLCHAR zipcode[XNP_ACCOUNT_ZIPCODE_LEN+1];
1974 SQLCHAR fax[XNP_ACCOUNT_FAX_LEN+1];
1975 SQLLEN cbActivate = 0, cbAddress = SQL_NTS, cbDivision = SQL_NTS, cbTel = SQL_NTS, cbCompany_name = SQL_NTS, cbCountry = SQL_NTS, cbZipcode = SQL_NTS, cbFax = SQL_NTS;
1976 SQLUINTEGER notice_mail, notice_mail_since;
1977 SQLLEN cbNotice_mail = 0, cbNotice_mail_since = 0;
1978
1979 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
1980 string sql;
1981
1982 sql = "UPDATE " + dbprefix + "_users SET ";
1983 sql += "uname=?";
1984 sql += ", name=?";
1985 sql += ", email=?";
1986 sql += ", url=?";
1987 sql += ", user_avatar=?";
1988 sql += ", user_regdate=?";
1989 sql += ", user_icq=?";
1990 sql += ", user_from=?";
1991 sql += ", user_sig=?";
1992 sql += ", user_viewemail=?";
1993 sql += ", actkey=?";
1994 sql += ", user_aim=?";
1995 sql += ", user_yim=?";
1996 sql += ", user_msnm=?";
1997 sql += ", pass=?";
1998 sql += ", posts=?";
1999 sql += ", attachsig=?";
2000 sql += ", rank=?";
2001 sql += ", level=?";
2002 sql += ", theme=?";
2003 sql += ", timezone_offset=?";
2004 sql += ", last_login=?";
2005 sql += ", umode=?";
2006 sql += ", uorder=?";
2007 sql += ", notify_method=?";
2008 sql += ", notify_mode=?";
2009 sql += ", user_occ=?";
2010 sql += ", bio=?";
2011 sql += ", user_intrest=?";
2012 sql += ", user_mailok=? ";
2013 sql += " WHERE uid = ?";
2014
2015 sqlcode = SQLPrepare(hstmt, (SQLCHAR*)sql.c_str(), SQL_NTS);
2016 if( sqlcode == SQL_SUCCESS || sqlcode == SQL_SUCCESS_WITH_INFO ){
2017 SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_UNAME_LEN, 0, uname, 0, &cbUname );
2018 SQLBindParameter(hstmt, 2, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_NAME_LEN, 0, name, 0, &cbName );
2019 SQLBindParameter(hstmt, 3, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_EMAIL_LEN, 0, email, 0, &cbEmail );
2020 SQLBindParameter(hstmt, 4, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_URL_LEN, 0, url, 0, &cbUrl );
2021 SQLBindParameter(hstmt, 5, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_AVATAR_LEN, 0, user_avatar, 0, &cbUser_avatar );
2022 SQLBindParameter(hstmt, 6, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &user_regdate, 0, &cbUser_regdate );
2023 SQLBindParameter(hstmt, 7, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_ICQ_LEN, 0, user_icq, 0, &cbUser_icq );
2024 SQLBindParameter(hstmt, 8, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_FROM_LEN, 0, user_from, 0, &cbUser_from );
2025 SQLBindParameter(hstmt, 9, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_SIG_LEN, 0, user_sig, 0, &cbUser_sig );
2026 SQLBindParameter(hstmt, 10, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &user_viewemail, 0, &cbUser_viewemail );
2027 SQLBindParameter(hstmt, 11, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_ACTKEY_LEN, 0, actkey, 0, &cbActkey );
2028 SQLBindParameter(hstmt, 12, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_AIM_LEN, 0, user_aim, 0, &cbUser_aim );
2029 SQLBindParameter(hstmt, 13, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_YIM_LEN, 0, user_yim, 0, &cbUser_yim );
2030 SQLBindParameter(hstmt, 14, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_MSNM_LEN, 0, user_msnm, 0, &cbUser_msnm );
2031 SQLBindParameter(hstmt, 15, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_PASS_LEN, 0, pass, 0, &cbPass );
2032 SQLBindParameter(hstmt, 16, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &posts, 0, &cbPosts );
2033 SQLBindParameter(hstmt, 17, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &attachsig, 0, &cbAttachsig );
2034 SQLBindParameter(hstmt, 18, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &rank, 0, &cbRank );
2035 SQLBindParameter(hstmt, 19, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &level, 0, &cbLevel );
2036 SQLBindParameter(hstmt, 20, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_THEME_LEN, 0, theme, 0, &cbTheme );
2037 SQLBindParameter(hstmt, 21, SQL_PARAM_INPUT, SQL_C_DOUBLE, SQL_DOUBLE, 0, 0, &timezone_offset, 0, &cbTimezone_offset );
2038 SQLBindParameter(hstmt, 22, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &last_login, 0, &cbLast_login );
2039 SQLBindParameter(hstmt, 23, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_UMODE_LEN, 0, umode, 0, &cbUmode );
2040 SQLBindParameter(hstmt, 24, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &uorder, 0, &cbUorder );
2041 SQLBindParameter(hstmt, 25, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &notify_method, 0, &cbNotify_method );
2042 SQLBindParameter(hstmt, 26, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &notify_mode, 0, &cbNotify_mode );
2043 SQLBindParameter(hstmt, 27, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_OCC_LEN, 0, user_occ, 0, &cbUser_occ );
2044 SQLBindParameter(hstmt, 28, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_BIO_LEN, 0, bio, 0, &cbBio );
2045 SQLBindParameter(hstmt, 29, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_INTREST_LEN, 0, user_intrest, 0, &cbUser_intrest );
2046 SQLBindParameter(hstmt, 30, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &user_mailok, 0, &cbUser_mailok );
2047 SQLBindParameter(hstmt, 31, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &uid, 0, &cbUid );
2048
2049 strncpy2( (char*)uname, account -> getUname( ), ACCOUNT_UNAME_LEN );
2050 strncpy2( (char*)name, account -> getName( ), ACCOUNT_NAME_LEN );
2051 strncpy2( (char*)email, account -> getEmail( ), ACCOUNT_EMAIL_LEN );
2052 strncpy2( (char*)url, account -> getURL( ), ACCOUNT_URL_LEN );
2053 strncpy2( (char*)user_avatar, account -> getUserAvatar( ), ACCOUNT_USER_AVATAR_LEN );
2054 user_regdate = time( NULL );
2055 strncpy2( (char*)user_icq, account -> getUserIcq( ), ACCOUNT_USER_ICQ_LEN );
2056 strncpy2( (char*)user_from, account -> getUserFrom( ), ACCOUNT_USER_FROM_LEN );
2057 strncpy2( (char*)user_sig, account -> getUserSig( ), ACCOUNT_USER_SIG_LEN );
2058 user_viewemail = account -> getUserViewemail( );
2059 strncpy2( (char*)actkey, account -> getActkey( ), ACCOUNT_ACTKEY_LEN );
2060 strncpy2( (char*)user_aim, account -> getUserAim( ), ACCOUNT_USER_AIM_LEN );
2061 strncpy2( (char*)user_yim, account -> getUserYim( ), ACCOUNT_USER_YIM_LEN );
2062 strncpy2( (char*)user_msnm, account -> getUserMsnm( ), ACCOUNT_USER_MSNM_LEN );
2063 strncpy2( (char*)pass, account -> getPass( ), ACCOUNT_PASS_LEN );
2064 posts = account -> getPosts( );
2065 attachsig = account -> getAttachsig( );
2066 rank = account -> getRank( );
2067 level = account -> getLevel( );
2068 strncpy2( (char*)theme, account -> getTheme( ), ACCOUNT_THEME_LEN );
2069 timezone_offset = account -> getTimezoneOffset( );
2070 last_login = 0;
2071 strncpy2( (char*)umode, account -> getUmode( ), ACCOUNT_UMODE_LEN );
2072 uorder = account -> getUorder( );
2073 notify_method = account -> getNotifyMethod( );
2074 notify_mode = account -> getNotifyMode( );
2075 strncpy2( (char*)user_occ, account -> getUserOcc( ), ACCOUNT_USER_OCC_LEN );
2076 strncpy2( (char*)bio, account -> getBio( ), ACCOUNT_BIO_LEN );
2077 strncpy2( (char*)user_intrest, account -> getUserIntrest( ), ACCOUNT_USER_INTREST_LEN );
2078 user_mailok = account -> getUserMailok( );
2079 uid = account -> getUID( );
2080
2081 if( ( sqlcode = SQLExecute( hstmt ) ) == SQL_SUCCESS ){
2082 SQLLEN count = 0;
2083 if( ( sqlcode = SQLRowCount( hstmt, &count ) ) == SQL_SUCCESS && count > 0 ){
2084 ret = RES_OK;
2085 }else{
2086 string s( "SQLRowCount in updateAccount sql=" );
2087 s += string( sql );
2088 setLastErrorString( s.c_str( ) );
2089 ret = RES_DB_QUERY_ERROR;
2090 }
2091 }else{
2092 string s( "SQLExecute in updateAccount 1 " );
2093 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
2094 setLastErrorString( s.c_str( ) );
2095 ret = RES_DB_QUERY_ERROR;
2096 }
2097 }else{
2098 setLastErrorString( "SQLPrepare in updateAccount sql=" );
2099 ret = RES_ERROR;
2100 }
2101 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
2102 hstmt = NULL;
2103 }else{
2104 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in updateAccount" );
2105 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
2106 setLastErrorString( s.c_str( ) );
2107 ret = RES_ERROR;
2108 }
2109
2110 if( ret != RES_OK ){
2111 return ret;
2112 }
2113
2114 //xoonips鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2115 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
2116 string sql;
2117
2118 sql = "UPDATE " + dbprefix + "_xoonips_users SET ";
2119 sql += "activate=?, ";
2120 sql += "address=?, ";
2121 sql += "division=?, ";
2122 sql += "tel=?, ";
2123 sql += "company_name=?, ";
2124 sql += "country=?, ";
2125 sql += "zipcode=?, ";
2126 sql += "fax=?, ";
2127 sql += "notice_mail=?, ";
2128 sql += "notice_mail_since=? ,";
2129 sql += "private_item_number_limit=" + unsignedIntToString( account -> getItemNumberLimit( ) ) + " ,";
2130 sql += "private_index_number_limit=" + unsignedIntToString( account -> getIndexNumberLimit( ) ) + " ,";
2131 sql += "private_item_storage_limit=" + doubleToString( account -> getItemStorageLimit( ) ) + " ";
2132 sql += "WHERE uid=?";
2133
2134 sqlcode = SQLPrepare(hstmt, (SQLCHAR*)sql.c_str(), SQL_NTS);
2135 if( sqlcode == SQL_SUCCESS || sqlcode == SQL_SUCCESS_WITH_INFO ){
2136 SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, &activate, 0, &cbActivate);
2137 SQLBindParameter(hstmt, 2, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_ADDRESS_LEN, 0, address, 0, &cbAddress);
2138 SQLBindParameter(hstmt, 3, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_DIVISION_LEN, 0, division, 0, &cbDivision);
2139 SQLBindParameter(hstmt, 4, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_TEL_LEN, 0, tel, 0, &cbTel);
2140 SQLBindParameter(hstmt, 5, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_COMPANY_NAME_LEN, 0, company_name, 0, &cbCompany_name);
2141 SQLBindParameter(hstmt, 6, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_COUNTRY_LEN, 0, country, 0, &cbCountry);
2142 SQLBindParameter(hstmt, 7, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_ZIPCODE_LEN, 0, zipcode, 0, &cbZipcode);
2143 SQLBindParameter(hstmt, 8, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_FAX_LEN, 0, fax, 0, &cbFax);
2144 SQLBindParameter(hstmt, 9, SQL_PARAM_INPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, &notice_mail, 0, &cbNotice_mail);
2145 SQLBindParameter(hstmt, 10, SQL_PARAM_INPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, &notice_mail_since, 0, &cbNotice_mail_since);
2146 SQLBindParameter(hstmt, 11, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &uid, 0, &cbUid );
2147
2148 activate = account -> getActivate() ? 1 : 0;
2149 strncpy2( (char*)address, account -> getAddress( ) , XNP_ACCOUNT_ADDRESS_LEN );
2150 strncpy2( (char*)division, account -> getDivision(), XNP_ACCOUNT_DIVISION_LEN );
2151 strncpy2( (char*)tel, account -> getTel(), XNP_ACCOUNT_TEL_LEN );
2152 strncpy2( (char*)company_name, account -> getCompanyName(), XNP_ACCOUNT_COMPANY_NAME_LEN );
2153 strncpy2( (char*)country, account -> getCountry(), XNP_ACCOUNT_COUNTRY_LEN );
2154 strncpy2( (char*)zipcode, account -> getZipcode(), XNP_ACCOUNT_ZIPCODE_LEN );
2155 strncpy2( (char*)fax, account -> getFax(), XNP_ACCOUNT_FAX_LEN );
2156 notice_mail = account -> getNoticeMail( );
2157 notice_mail_since = account -> getNoticeMailSince( );
2158 uid = account -> getUID( );
2159
2160 if( ( sqlcode = SQLExecute( hstmt ) ) == SQL_SUCCESS ){
2161 SQLLEN count = 0;
2162 if( ( sqlcode = SQLRowCount( hstmt, &count ) ) == SQL_SUCCESS && count > 0 ){
2163 ret = RES_OK;
2164 }else{
2165 string s( "SQLRowCount in updateAccount sql=" );
2166 s += string( sql );
2167 setLastErrorString( s.c_str( ) );
2168 ret = RES_DB_QUERY_ERROR;
2169 }
2170 }else{
2171 string s( "SQLExecute in updateAccount 2 " );
2172 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
2173 setLastErrorString( s.c_str( ) );
2174 ret = RES_DB_QUERY_ERROR;
2175 }
2176 }else{
2177 setLastErrorString( "SQLPrepare in updateAccount sql=" );
2178 ret = RES_ERROR;
2179 }
2180 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
2181 }else{
2182 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in updateAccount" );
2183 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
2184 setLastErrorString( s.c_str( ) );
2185 ret = RES_ERROR;
2186 }
2187 return ret;
2188 }
2189
2190 /**
2191 *
2192 * criteria_t鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申.
2193 * 鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申*uids鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2194 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申*uidsLen鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2195 *
2196 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2197 * @param cri 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2198 * @param uids 鐃緒申鐃緒申鐃緒申鐃緒申UID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2199 * @param uidsLen uids鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2200 * @return RES_OK
2201 * @return RES_DB_NOT_INITIALIZED
2202 * @return RES_NO_SUCH_SESSION
2203 * @return RES_DB_QUERY_ERROR
2204 * @see freeUID
2205 */
2206 result_t dumpUids( sessionid_t sid, criteria_t* cri, userid_t** uids, int* uidsLen )
2207 {
2208 if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
2209 if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
2210
2211 result_t ret = RES_ERROR;
2212 userid_t* dst = 0;
2213 string sql;
2214 SQLHANDLE hstmt = NULL;
2215 SQLRETURN sqlcode;
2216 SQLLEN count = 0;
2217
2218
2219 sql = "SELECT uid FROM " + dbprefix + "_xoonips_users ";
2220 sql += criteria2str( cri );
2221 if( countResultRows( sql.c_str(), &count ) == RES_OK ){
2222 *uidsLen = count;
2223 dst = new userid_t[ *uidsLen ];
2224 *uids = dst;
2225 }else{
2226 return RES_ERROR;
2227 }
2228 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
2229 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
2230 userid_t uid = 0;
2231 SQLLEN len = 0;
2232 SQLBindCol( hstmt, 1, SQL_C_ULONG, &uid, 0, &len );
2233
2234 for( int i = 0; ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS && i < *uidsLen ; i++ ){
2235 dst[ i ] = uid;
2236 }
2237
2238 syslog_printf( "dumpUids succeed" );
2239 ret = RES_OK;
2240 }else{
2241 string s( "SQLExecDirect in dumpUids " );
2242 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
2243 s += "sql=";
2244 s += string( sql );
2245 setLastErrorString( s.c_str( ) );
2246 syslog_printf( "dumpUids %s", getLastErrorString( ) );
2247 ret = RES_DB_QUERY_ERROR;
2248 }
2249 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
2250 }else{
2251 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in dumpUids" );
2252 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
2253 setLastErrorString( s.c_str( ) );
2254 syslog_printf( "dumpUids %s", getLastErrorString( ) );
2255 ret = RES_ERROR;
2256 }
2257 return ret;
2258 }
2259
2260 /**
2261 *
2262 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(default鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申).
2263 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申0鐃緒申鐃緒申鐃緒申.
2264 *
2265 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2266 * @return 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2267 *
2268 */
2269 int getGroupCount( sessionid_t sid )
2270 {
2271 if( hdbc == NULL ) return 0;
2272 if( !isValidSessionID( sid ) ) return 0;
2273
2274 SQLRETURN sqlcode;
2275 SQLHANDLE hstmt = NULL;
2276 string sql;
2277 int ret = 0;
2278
2279 //鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2280 sql = "SELECT COUNT(*) FROM " + dbprefix + "_xoonips_groups";
2281 sql += " WHERE gid != " + unsignedIntToString( group::GID_DEFAULT );
2282 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
2283 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
2284 SQLUINTEGER count = 0;
2285 SQLLEN len = 0;
2286 SQLBindCol( hstmt, 1, SQL_C_ULONG, &count, 0, &len );
2287 if( ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS ){
2288 ret = count;
2289 }else {
2290 string s( "SQLFetch in getGroupCount sql=" );
2291 s += string( sql );
2292 setLastErrorString( s.c_str( ) );
2293 ret = 0;
2294 }
2295 }else{
2296 setLastErrorString( "SQLExecDirect in getGroupCount" );
2297 ret = 0;
2298 }
2299 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
2300 }else{
2301 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in getGroupCount" );
2302 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
2303 setLastErrorString( s.c_str( ) );
2304 ret = 0;
2305 }
2306 return ret;
2307 }
2308
2309 /**
2310 *
2311 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2312 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(default鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申).
2313 *
2314 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2315 * @param uid 鐃緒申鐃緒申鐃緒申鐃緒申UID
2316 * @param cri 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2317 * @param gids 鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2318 * @param gidsLen gids鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2319 * @return RES_DB_NOT_INITIALIZED
2320 * @return RES_NO_SUCH_SESSION
2321 * @return RES_NO_SUCH_USER
2322 * @return RES_DB_QUERY_ERROR
2323 * @return RES_OK
2324 * @see freeGID
2325 */
2326 result_t getGroupsByUid( sessionid_t sid, userid_t uid, criteria_t* cri, groupid_t** gids, int* gidsLen )
2327 {
2328 if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
2329 if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
2330 if( !uidExists( uid ) ) return RES_NO_SUCH_USER; //uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2331
2332 result_t ret = RES_ERROR;
2333 string sql;
2334 SQLRETURN sqlcode;
2335 SQLHANDLE hstmt = NULL;
2336 SQLLEN count = 0;
2337 groupid_t* dst = 0;
2338
2339 sql = "SELECT gid FROM " + dbprefix + "_xoonips_groups_users_link";
2340 sql += " WHERE uid=" + string( unsignedIntToString( uid ) );
2341 sql += " AND gid != " + unsignedIntToString( group::GID_DEFAULT );
2342 sql += criteria2str( cri );
2343 if( countResultRows( sql.c_str(), &count ) == RES_OK ){
2344 *gidsLen = count;
2345 dst = new groupid_t[ *gidsLen ];
2346 *gids = dst;
2347 }else{
2348 return RES_ERROR;
2349 }
2350
2351 //鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2352 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
2353 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
2354 if( count > 0 ){
2355 SQLHANDLE hstmt2 = NULL;
2356 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt2 ) ) == SQL_SUCCESS ) {
2357 sql = "SELECT gid, uid, is_admin FROM " + dbprefix + "_xoonips_groups_users_link";
2358 sql += " WHERE uid=" + string( unsignedIntToString( uid ) );
2359 sql += " AND gid != " + unsignedIntToString( group::GID_DEFAULT );
2360 sql += criteria2str( cri );
2361 if( ( sqlcode = SQLExecDirect( hstmt2, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
2362 SQLLEN len = 0;
2363 groupid_t gid = 0;
2364 SQLBindCol( hstmt, 1, SQL_C_ULONG, &gid, 0, &len );
2365 for( int i = 0; ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS && i < *gidsLen ; i++ ){
2366 dst[ i ] = gid;
2367 }
2368 ret = RES_OK;
2369 }else{
2370 string s( "SQLExecDirect in getGroupsByUid " );
2371 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
2372 s += string( ", sql=" ) + string( sql );
2373 setLastErrorString( s.c_str( ) );
2374 ret = RES_DB_QUERY_ERROR;
2375 }
2376 }else{
2377 string s( "SQLAllocHandle in getGroupsByUid " );
2378 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
2379 setLastErrorString( s.c_str( ) );
2380 ret = RES_ERROR;
2381 }
2382 }else{
2383 ret = RES_OK;
2384 }
2385 }else{
2386 string s( "SQLExecDirect in getGroupsByUid " );
2387 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
2388 s += string( ", sql=" ) + string( sql );
2389 setLastErrorString( s.c_str( ) );
2390 ret = RES_DB_QUERY_ERROR;
2391 }
2392 }else{
2393 string s( "SQLAllocHandle in getGroupsByUid " );
2394 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
2395 setLastErrorString( s.c_str( ) );
2396 ret = RES_ERROR;
2397 }
2398 return ret;
2399 }
2400
2401 /**
2402 *
2403 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2404 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2405 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申false鐃緒申鐃緒申鐃緒申.
2406 *
2407 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2408 * @param gid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申UID
2409 * @param uid 鐃緒申鐃緒申鐃緒申鐃緒申UID
2410 * @return true 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2411 * @return false 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2412 * @see
2413 */
2414 bool isGroupAdmin( sessionid_t sid, groupid_t gid, userid_t uid )
2415 {
2416 if( hdbc == NULL ) return false;
2417 if( !isValidSessionID( sid ) ) return false;
2418 if( !uidExists( uid ) ) return false;
2419 if( !gidExists( gid ) ) return false;
2420
2421 bool ret = false;
2422 string sql;
2423 SQLLEN count = 0;
2424
2425 sql = "SELECT * FROM " + dbprefix + "_xoonips_groups_users_link ";
2426 sql += "WHERE gid=" + string( unsignedIntToString( gid ) );
2427 sql += " AND uid=" + string( unsignedIntToString( uid ) );
2428 sql += " AND is_admin=1";
2429 if( countResultRows( sql.c_str(), &count ) == RES_OK ){
2430 if( count > 0 ){
2431 ret = true;
2432 }else{
2433 ret = false;
2434 }
2435 }else{
2436 ret = false;
2437 }
2438 return ret;
2439 }
2440
2441 /**
2442 *
2443 * 鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申.
2444 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2445 *
2446 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2447 * @param cri 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2448 * @param gids 鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2449 * @param gidsLen gids鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2450 * @return RES_DB_NOT_INITIALIZED
2451 * @return RES_NO_SUCH_SESSION
2452 * @return RES_DB_QUERY_ERROR
2453 * @return RES_OK
2454 *
2455 */
2456 result_t dumpGids( sessionid_t sid, criteria_t* cri, groupid_t** gids, int* gidsLen )
2457 {
2458 if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
2459 if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
2460
2461 result_t ret = RES_ERROR;
2462 groupid_t* dst = 0;
2463 string sql;
2464 SQLHANDLE hstmt = NULL;
2465 SQLRETURN sqlcode;
2466 SQLLEN count = 0;
2467
2468 sql = "SELECT gid FROM " + dbprefix + "_xoonips_groups ";
2469 sql += " WHERE gid != " + unsignedIntToString( group::GID_DEFAULT );
2470 sql += criteria2str( cri );
2471 if( countResultRows( sql.c_str(), &count ) == RES_OK ){
2472 *gidsLen = count;
2473 dst = new groupid_t[ *gidsLen ];
2474 *gids = dst;
2475 }else{
2476 return RES_ERROR;
2477 }
2478
2479 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
2480 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
2481 groupid_t gid = 0;
2482 SQLLEN len = 0;
2483 SQLBindCol( hstmt, 1, SQL_C_ULONG, &gid, 0, &len );
2484 for( int i = 0; ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS && i < *gidsLen ; i++ ){
2485 dst[ i ] = gid;
2486 }
2487
2488 ret = RES_OK;
2489 }else{
2490 string s( "SQLExecDirect in dumpGids " );
2491 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
2492 s += "sql=";
2493 s += string( sql );
2494 setLastErrorString( s.c_str( ) );
2495 ret = RES_DB_QUERY_ERROR;
2496 }
2497 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
2498 }
2499 return ret;
2500 }
2501
2502 /**
2503 *
2504 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2505 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2506 *
2507 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2508 * @param gid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2509 * @param cri 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2510 * @param uids 鐃緒申鐃緒申鐃緒申鐃緒申UID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2511 * @param uidsLen uids鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2512 * @return RES_OK
2513 * @return RES_DB_NOT_INITIALIZED
2514 * @return RES_NO_SUCH_SESSION
2515 * @return RES_DB_QUERY_ERROR
2516 * @return RES_ERROR
2517 *
2518 */
2519 result_t dumpGroupAdmins( sessionid_t sid, groupid_t gid, criteria_t* cri, userid_t** uids, int* uidsLen )
2520 {
2521 if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
2522 if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
2523
2524 result_t ret = RES_ERROR;
2525 string sql;
2526 SQLHANDLE hstmt = NULL;
2527 SQLRETURN sqlcode;
2528 SQLLEN count = 0;
2529
2530 sql = "SELECT uid FROM " + dbprefix + "_xoonips_groups_users_link ";
2531 sql += " WHERE is_admin=1 and gid=" + unsignedIntToString( gid );
2532 if( countResultRows( sql.c_str(), &count ) == RES_OK ){
2533 *uidsLen = count;
2534 *uids = new groupid_t[ *uidsLen ];
2535 }else{
2536 return RES_ERROR;
2537 }
2538 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
2539 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
2540 userid_t uid;
2541 SQLLEN len = 0;
2542 SQLBindCol( hstmt, 1, SQL_C_ULONG, &uid, 0, &len );
2543 for( int i = 0; ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS && i < *uidsLen ; i++ ){
2544 (*uids)[ i ] = uid;
2545 }
2546 ret = RES_OK;
2547 }else{
2548 string s( "SQLExecDirect in dumpGroupAdmins " );
2549 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
2550 s += "sql=";
2551 s += string( sql );
2552 setLastErrorString( s.c_str( ) );
2553 ret = RES_DB_QUERY_ERROR;
2554 }
2555 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
2556 }
2557 return ret;
2558 }
2559
2560 /**
2561 *
2562 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2563 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2564 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2565 *
2566 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2567 * @param gid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2568 * @param uid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2569 * @return RES_DB_NOT_INITIALIZED
2570 * @return RES_NO_SUCH_SESSION
2571 * @return RES_NO_SUCH_USER
2572 * @return RES_NO_SUCH_GROUP
2573 * @return RES_DB_QUERY_ERROR
2574 * @return RES_OK
2575 * @return RES_ERROR
2576 *
2577 */
2578 result_t deleteMember( sessionid_t sid, groupid_t gid, userid_t uid )
2579 {
2580 if( gid == group_t::GID_DEFAULT ) return RES_ERROR;
2581 return deleteMemberNoLimit( sid, gid, uid );
2582 }
2583
2584 /**
2585 *
2586 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2587 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2588 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申deleteMember鐃緒申鐃緒申鐃緒申鐃緒申
2589 *
2590 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2591 * @param gid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2592 * @param uid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2593 * @return RES_DB_NOT_INITIALIZED
2594 * @return RES_NO_SUCH_SESSION
2595 * @return RES_NO_SUCH_USER
2596 * @return RES_NO_SUCH_GROUP
2597 * @return RES_DB_QUERY_ERROR
2598 * @return RES_OK
2599 * @return RES_ERROR
2600 *
2601 */
2602 static result_t deleteMemberNoLimit( sessionid_t sid, groupid_t gid, userid_t uid )
2603 {
2604 if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
2605 if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
2606 if( !uidExists( uid ) ) return RES_NO_SUCH_USER; //uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2607 if( !gidExists( gid ) ) return RES_NO_SUCH_GROUP; //gid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2608
2609 result_t ret = RES_ERROR;
2610 string sql;
2611 SQLRETURN sqlcode;
2612 SQLHANDLE hstmt = NULL;
2613
2614 sql = "DELETE FROM " + dbprefix + "_xoonips_groups_users_link ";
2615 sql += "WHERE gid=" + string( unsignedIntToString( gid ) );
2616 sql += " AND uid=" + string( unsignedIntToString( uid ) );
2617 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
2618 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
2619 SQLLEN count = 0;
2620 if( ( sqlcode = SQLRowCount( hstmt, &count ) ) == SQL_SUCCESS && count > 0 ){
2621 ret = RES_OK;
2622 }else{
2623 string s( "SQLRowCount in deleteMember" );
2624 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
2625 s += string( ", sql=" ) + string( sql );
2626 setLastErrorString( s.c_str( ) );
2627 ret = RES_NO_SUCH_USER;
2628 }
2629 }else{
2630 string s( "SQLExecDirect in deleteMember" );
2631 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
2632 s += ", sql=";
2633 s += string( sql );
2634 setLastErrorString( s.c_str( ) );
2635 ret = RES_DB_QUERY_ERROR;
2636 }
2637 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
2638 }else{
2639 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in deleteMember" );
2640 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
2641 setLastErrorString( s.c_str( ) );
2642 ret = RES_ERROR;
2643 }
2644 return ret;
2645 }
2646
2647 /**
2648 *
2649 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2650 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2651 *
2652 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2653 * @param gid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2654 * @param uid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2655 * @param admin 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申true
2656 * @return RES_OK
2657 * @return RES_DB_NOT_INITIALIZED
2658 * @return RES_NO_SUCH_SESSION
2659 * @return RES_NO_SUCH_USER
2660 * @return RES_NO_SUCH_GROUP
2661 * @return RES_DB_QUERY_ERROR
2662 *
2663 */
2664 result_t insertMember( sessionid_t sid, groupid_t gid, userid_t uid, bool admin )
2665 {
2666 if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
2667 if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
2668 if( !uidExists( uid ) ) return RES_NO_SUCH_USER; //uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2669 if( !gidExists( gid ) ) return RES_NO_SUCH_GROUP; //gid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2670
2671 result_t ret = RES_ERROR;
2672 string sql;
2673 SQLHANDLE hstmt = NULL;
2674 SQLRETURN sqlcode;
2675
2676 //鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2677 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
2678 sql = "INSERT INTO " + dbprefix + "_xoonips_groups_users_link ( gid, uid, is_admin ) VALUES (";
2679 sql += string( unsignedIntToString( gid ) ) + ", ";
2680 sql += string( unsignedIntToString( uid ) ) + ", ";
2681 sql += string( admin ? "1" : "0" ) + ") ";
2682 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
2683 SQLLEN count = 0;
2684 if( ( sqlcode = SQLRowCount( hstmt, &count ) ) == SQL_SUCCESS && count > 0 ){
2685 ret = RES_OK;
2686 }else{
2687 string s( "SQLRowCount in insertMember " );
2688 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
2689 s += string( ", sql=" ) + string( sql );
2690 setLastErrorString( s.c_str( ) );
2691 ret = RES_DB_QUERY_ERROR;
2692 }
2693 }else{
2694 string s( "SQLExecDirect in insertMember " );
2695 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
2696 s += string( ", sql=" ) + string( sql );
2697 setLastErrorString( s.c_str( ) );
2698 ret = RES_DB_QUERY_ERROR;
2699 }
2700 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
2701 }else{
2702 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in insertMember" );
2703 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
2704 setLastErrorString( s.c_str( ) );
2705 ret = RES_ERROR;
2706 }
2707 return ret;
2708 }
2709
2710 /**
2711 *
2712 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2713 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2714 *
2715 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2716 * @param gid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申
2717 * @param cri 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2718 * @param uids 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申UID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2719 * @param uidsLen uids鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2720 * @return RES_OK
2721 * @return RES_DB_NOT_INITIALIZED
2722 * @return RES_NO_SUCH_SESSION
2723 * @return RES_NO_SUCH_GROUP
2724 * @return RES_DB_QUERY_ERROR
2725 * @return RES_ERROR
2726 *
2727 */
2728 result_t getMembers( sessionid_t sid, groupid_t gid, criteria_t* cri, userid_t** uids, int* uidsLen )
2729 {
2730 if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
2731 if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
2732 if( !gidExists( gid ) ) return RES_NO_SUCH_GROUP; //gid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2733
2734 result_t ret = RES_ERROR;
2735 string sql;
2736 SQLRETURN sqlcode;
2737 SQLHANDLE hstmt = NULL;
2738 userid_t* dst = 0;
2739
2740 //how many members ?
2741 sql = "SELECT COUNT(*) FROM " + dbprefix + "_xoonips_groups_users_link ";
2742 sql += " WHERE gid=" + string( unsignedIntToString( gid ) );
2743 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
2744 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
2745 SQLUINTEGER count = 0;
2746 SQLLEN len = 0;
2747 SQLBindCol( hstmt, 1, SQL_C_ULONG, &count, 0, &len );
2748 if( ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS ){
2749 dst = new userid_t[ count ];
2750 *uids = dst;
2751 *uidsLen = count;
2752 if( count > 0 ){
2753 //retrieve member's IDs
2754 SQLHANDLE hstmt2 = NULL;
2755 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt2 ) ) == SQL_SUCCESS ) {
2756 sql = "SELECT uid, gid, is_admin FROM " + dbprefix + "_xoonips_groups_users_link ";
2757 sql += " WHERE gid=" + string( unsignedIntToString( gid ) );
2758 sql += " " + string( criteria2str( cri ) );
2759 if( ( sqlcode = SQLExecDirect( hstmt2, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
2760 SQLUINTEGER uid = 0;
2761 SQLLEN len = 0;
2762 SQLBindCol( hstmt2, 1, SQL_C_ULONG, &uid, 0, &len );
2763 for( SQLUINTEGER i = 0; ( sqlcode = SQLFetch( hstmt2 ) ) == SQL_SUCCESS && i < count ; i++ ){
2764 dst[ i ] = uid;
2765 }
2766 ret = RES_OK;
2767 }else{
2768 setLastErrorString( "SQLExecDirect in getMembers" );
2769 ret = RES_DB_QUERY_ERROR;
2770 }
2771 SQLFreeHandle( SQL_HANDLE_STMT, hstmt2 );
2772 }else{
2773 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in getMembers" );
2774 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
2775 setLastErrorString( s.c_str( ) );
2776 ret = RES_ERROR;
2777 }
2778 }else{
2779 ret = RES_OK;
2780 }
2781 }else{
2782 string s( "SQLFetch in getMembers sql=" );
2783 s += string( sql );
2784 setLastErrorString( s.c_str( ) );
2785 ret = RES_DB_QUERY_ERROR;
2786 }
2787 }else{
2788 setLastErrorString( "SQLExecDirect in getMembers" );
2789 ret = RES_DB_QUERY_ERROR;
2790 }
2791 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
2792 }else{
2793 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in getMembers" );
2794 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
2795 setLastErrorString( s.c_str( ) );
2796 ret = RES_ERROR;
2797 }
2798 return ret;
2799 }
2800
2801 /**
2802 *
2803 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2804 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2805 *
2806 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2807 * @param gid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申
2808 * @return RES_OK
2809 * @return RES_DB_QUERY_ERROR
2810 * @return RES_NO_SUCH_SESSION
2811 * @return RES_DB_NOT_INITIALIZED
2812 *
2813 */
2814 result_t deleteGroup( sessionid_t sid, groupid_t gid )
2815 {
2816 if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
2817 if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
2818
2819 result_t ret = RES_ERROR;
2820 string sql;
2821 SQLRETURN sqlcode;
2822 SQLHANDLE hstmt = NULL;
2823
2824 sql = "DELETE FROM " + dbprefix + "_xoonips_groups ";
2825 sql += "WHERE gid = " + string( unsignedIntToString( gid ) );
2826 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
2827 if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
2828 SQLLEN count = 0;
2829 if( ( sqlcode = SQLRowCount( hstmt, &count ) ) == SQL_SUCCESS && count > 0 ){
2830 ret = RES_OK;
2831 }else{
2832 string s( "SQLRowCount in deleteGroup" );
2833 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
2834 s += string( ", sql=" ) + string( sql );
2835 setLastErrorString( s.c_str( ) );
2836 ret = RES_NO_SUCH_USER;
2837 }
2838 }else{
2839 string s( "SQLExecDirect in deleteGroup" );
2840 s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
2841 s += ", sql=";
2842 s += string( sql );
2843 setLastErrorString( s.c_str( ) );
2844 ret = RES_DB_QUERY_ERROR;
2845 }
2846 SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
2847 }else{
2848 string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in deleteGroup" );
2849 s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
2850 setLastErrorString( s.c_str( ) );
2851 ret = RES_ERROR;
2852 }
2853 return ret;
2854 }
2855
2856
2857 /**
2858 *
2859 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2860 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2861 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申gid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2862 *
2863 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2864 * @param group 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2865 * @param gid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2866 * @return RES_OK
2867 * @return RES_DB_NOT_INITIALIZED
2868 * @return RES_NO_SUCH_SESSION
2869 * @return RES_DB_QUERY_ERROR
2870 * @return RES_GROUPNAME_ALREADY_EXISTS
2871 */
2872 result_t insertGroup( sessionid_t sid, const group_t* group, groupid_t* gid )
2873 {
2874 if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
2875 if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
2876
2877 result_t ret = RES_ERROR;
2878 string sql;
2879 SQLCHAR gname[XNP_GROUP_GNAME_LEN+1], gdesc[XNP_GROUP_GDESC_LEN+1];
2880 SQLINTEGER item_number_limit;
2881 SQLINTEGER index_number_limit;
2882 SQLDOUBLE item_storage_limit;
2883 SQLLEN cbGname = SQL_NTS, cbGdesc = SQL_NTS, cbItem_number_limit = 0, cbIndex_number_limit = 0, cbItem_storage_limit = 0;
2884 SQLHANDLE hstmt = NULL;
2885 SQLRETURN sqlcode;
2886
2887 // examine whether there is already a group name
2888 if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
2889 string sql = "SELECT gid FROM " + dbprefix + "_xoonips_groups WHERE gname=? AND gid!=" + unsignedIntToString(group -> getGID() ) + " AND gid != " + unsignedIntToString