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