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