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