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