Develop and Download Open Source Software

XooNIps

Browse CVS Repository

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

Annotation of /xoonips/AL/xnpal.cc

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

Revision 1.53 - (hide annotations) (download) (as text)
Tue Aug 23 07:35:33 2005 UTC (18 years, 7 months ago) by tani
Branch: MAIN
Changes since 1.52: +7 -1 lines
File MIME type: text/x-c++src 
Languag対応.
1 aga 1.1 /*
2 tani 1.39 * --------------------------------------------------------------------------
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 tani 1.53 * $Revision: 1.52 $
23 tani 1.39 * XNPAL: XooNiPs Platform Abstract Layer
24     * zend_parse_parameters鐃緒申php4.1.0鐃緒申鐃緒申鐃緒申
25     * .so鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
26     * C++鐃緒申鐃緒申鐃緒申extern "C"{}, BEGIN/END_EXTERN_C()鐃緒申鐃緒申鐃緒申鐃緒申
27     */
28 aga 1.1
29    
30     #include <stdio.h>
31 aga 1.2 #include "criteria.h"
32     #include "common.h"
33     #include "commonal.h"
34     #include "session.h"
35     #include "group.h"
36 youi 1.24 #include "index.h"
37 youi 1.21 #include "xnpal.h"
38 youi 1.24 #include "amazonbook.h"
39 aga 1.1
40 aga 1.2 // for inet_aton
41     #include <sys/socket.h>
42     #include <netinet/in.h>
43     #include <arpa/inet.h>
44    
45 aga 1.1 // global variables
46    
47 youi 1.21 PHP_MSHUTDOWN_FUNCTION(xnpalmod)
48 aga 1.18 {
49 tani 1.52 uninitializeDB();
50 aga 1.18 return SUCCESS;
51     }
52 aga 1.1
53     /* declaration of functions to be exported */
54     extern "C" {
55 aga 1.2 ZEND_FUNCTION(first_module );
56 youi 1.21 ZEND_FUNCTION(xnp_initialize_db );
57     ZEND_FUNCTION(xnp_login_user );
58     ZEND_FUNCTION(xnp_logout_user );
59     ZEND_FUNCTION(xnp_create_session );
60     ZEND_FUNCTION(xnp_get_session );
61     ZEND_FUNCTION(xnp_is_activated );
62     ZEND_FUNCTION(xnp_activate );
63     ZEND_FUNCTION(xnp_get_account_count );
64     ZEND_FUNCTION(xnp_delete_account );
65     ZEND_FUNCTION(xnp_get_account );
66     ZEND_FUNCTION(xnp_get_accounts );
67     ZEND_FUNCTION(xnp_insert_account );
68     ZEND_FUNCTION(xnp_update_account );
69     ZEND_FUNCTION(xnp_dump_uids );
70     ZEND_FUNCTION(xnp_get_group_count );
71     ZEND_FUNCTION(xnp_get_groups_by_uid );
72     ZEND_FUNCTION(xnp_is_group_admin );
73     ZEND_FUNCTION(xnp_dump_gids );
74     ZEND_FUNCTION(xnp_dump_group_admins );
75     ZEND_FUNCTION(xnp_delete_member );
76     ZEND_FUNCTION(xnp_insert_member );
77     ZEND_FUNCTION(xnp_get_members );
78     ZEND_FUNCTION(xnp_delete_group );
79     ZEND_FUNCTION(xnp_insert_group );
80     ZEND_FUNCTION(xnp_update_group );
81     ZEND_FUNCTION(xnp_get_group );
82     ZEND_FUNCTION(xnp_get_groups );
83     ZEND_FUNCTION(xnp_is_moderator );
84     ZEND_FUNCTION(xnp_get_uid );
85 aga 1.2
86 aga 1.22 ZEND_FUNCTION(xnp_get_all_indexes );
87     ZEND_FUNCTION(xnp_get_indexes );
88     ZEND_FUNCTION(xnp_insert_index );
89     ZEND_FUNCTION(xnp_update_index );
90     ZEND_FUNCTION(xnp_delete_index );
91     ZEND_FUNCTION(xnp_get_index );
92     ZEND_FUNCTION(xnp_is_index_readable );
93     ZEND_FUNCTION(xnp_is_index_writable );
94     ZEND_FUNCTION(xnp_swap_index_sort_number );
95    
96 youi 1.21 ZEND_FUNCTION(xnp_is_valid_session_id );
97     ZEND_FUNCTION(xnp_get_last_error_string );
98 aga 1.9
99 youi 1.21 ZEND_FUNCTION(xnp_test_criteria );
100     ZEND_FUNCTION(xnp_test_uids );
101 youi 1.24
102    
103     ZEND_FUNCTION(xnp_get_item_permission );
104     ZEND_FUNCTION(xnp_get_index_permission );
105     ZEND_FUNCTION(xnp_get_certify_permission );
106    
107     ZEND_FUNCTION(xnp_get_certify_state );
108     ZEND_FUNCTION(xnp_set_certify_state );
109    
110     ZEND_FUNCTION(xnp_insert_change_log );
111     ZEND_FUNCTION(xnp_get_change_logs );
112    
113     ZEND_FUNCTION(xnp_get_config_value );
114     ZEND_FUNCTION(xnp_set_config_value );
115    
116     ZEND_FUNCTION(xnp_dump_item_id );
117     ZEND_FUNCTION(xnp_get_item_id_by_binder_id );
118     ZEND_FUNCTION(xnp_get_item_id_by_index_id );
119     ZEND_FUNCTION(xnp_get_overlapped_items );
120    
121     ZEND_FUNCTION(xnp_insert_item );
122 tani 1.43 ZEND_FUNCTION(xnp_insert_item_direct );
123 youi 1.24 ZEND_FUNCTION(xnp_update_item );
124     ZEND_FUNCTION(xnp_delete_item );
125     ZEND_FUNCTION(xnp_get_item );
126     ZEND_FUNCTION(xnp_get_items );
127    
128     ZEND_FUNCTION(xnp_pubmed_complete );
129     ZEND_FUNCTION(xnp_amazon_complete );
130    
131     //ZEND_FUNCTION(xnp_uninitialize_db );
132    
133     ZEND_FUNCTION(xnp_register_binder_item );
134     ZEND_FUNCTION(xnp_unregister_binder_item );
135    
136     ZEND_FUNCTION(xnp_register_item );
137     ZEND_FUNCTION(xnp_unregister_item );
138    
139 youi 1.26 ZEND_FUNCTION(xnp_get_uncertified_link );
140     ZEND_FUNCTION(xnp_get_private_item_id );
141 tani 1.37 ZEND_FUNCTION(xnp_get_group_item_id );
142 youi 1.26
143 youi 1.28 ZEND_FUNCTION(xnp_get_item_types );
144     ZEND_FUNCTION(xnp_get_index_id_by_item_id );
145 youi 1.30 ZEND_FUNCTION(xnp_get_own_public_item_id );
146 youi 1.26
147 youi 1.33 ZEND_FUNCTION(xnp_zip_create );
148 tani 1.35 ZEND_FUNCTION(xnp_get_item_count );
149 aga4096 1.38 ZEND_FUNCTION(xnp_get_item_count_group_by_index );
150 aga4096 1.41
151     ZEND_FUNCTION(xnp_extract_public_item_id);
152     ZEND_FUNCTION(xnp_extract_nonbinder_item_id);
153 aga4096 1.42 ZEND_FUNCTION(xnp_insert_event);
154     ZEND_FUNCTION(xnp_get_events);
155 tani 1.48 ZEND_FUNCTION(xnp_get_events_for_rss);
156 aga 1.1 };
157 aga4096 1.47
158 aga4096 1.50
159     #ifdef ZEND_ENGINE_2
160     static
161     ZEND_BEGIN_ARG_INFO(second_and_third_args_force_ref, 0)
162     ZEND_ARG_PASS_INFO(0)
163     ZEND_ARG_PASS_INFO(1)
164     ZEND_ARG_PASS_INFO(1)
165     ZEND_END_ARG_INFO();
166     #else
167 aga4096 1.47 static unsigned char fourth_arg_force_ref[] = { 4, BYREF_NONE, BYREF_NONE, BYREF_NONE, BYREF_FORCE };
168 aga4096 1.50 static unsigned char second_and_third_args_force_ref[] = { 3, BYREF_NONE, BYREF_FORCE, BYREF_FORCE };
169     #endif
170    
171 aga4096 1.47
172 aga 1.1 /* compiled function list so Zend knows what's in this module */
173 youi 1.21 zend_function_entry xnpalmod_functions[] =
174 aga 1.1 {
175 aga4096 1.47 ZEND_FE(first_module ,NULL)
176 youi 1.24 ZEND_FE(xnp_initialize_db ,NULL)
177 aga4096 1.47 ZEND_FE(xnp_login_user ,third_arg_force_ref)
178 youi 1.24 ZEND_FE(xnp_logout_user ,NULL)
179 aga4096 1.47 ZEND_FE(xnp_create_session ,third_arg_force_ref)
180     ZEND_FE(xnp_get_session ,second_arg_force_ref )
181 youi 1.24 ZEND_FE(xnp_is_activated ,NULL)
182     ZEND_FE(xnp_activate ,NULL)
183     ZEND_FE(xnp_get_account_count ,NULL)
184     ZEND_FE(xnp_delete_account ,NULL)
185 aga4096 1.47 ZEND_FE(xnp_get_account ,third_arg_force_ref)
186     ZEND_FE(xnp_get_accounts ,fourth_arg_force_ref)
187     ZEND_FE(xnp_insert_account ,third_arg_force_ref)
188 youi 1.24 ZEND_FE(xnp_update_account ,NULL)
189 aga4096 1.47 ZEND_FE(xnp_dump_uids ,third_arg_force_ref)
190 youi 1.24 ZEND_FE(xnp_get_group_count ,NULL)
191 aga4096 1.47 ZEND_FE(xnp_get_groups_by_uid ,fourth_arg_force_ref)
192 youi 1.24 ZEND_FE(xnp_is_group_admin ,NULL)
193 aga4096 1.47 ZEND_FE(xnp_dump_gids ,third_arg_force_ref)
194 youi 1.24 ZEND_FE(xnp_dump_group_admins ,NULL)
195     ZEND_FE(xnp_delete_member ,NULL)
196     ZEND_FE(xnp_insert_member ,NULL)
197 aga4096 1.47 ZEND_FE(xnp_get_members ,fourth_arg_force_ref)
198 youi 1.24 ZEND_FE(xnp_delete_group ,NULL)
199 aga4096 1.47 ZEND_FE(xnp_insert_group ,third_arg_force_ref)
200 youi 1.24 ZEND_FE(xnp_update_group ,NULL)
201 aga4096 1.47 ZEND_FE(xnp_get_group ,third_arg_force_ref)
202     ZEND_FE(xnp_get_groups ,fourth_arg_force_ref)
203 youi 1.24 ZEND_FE(xnp_is_moderator ,NULL)
204 aga4096 1.47 ZEND_FE(xnp_get_uid ,second_arg_force_ref)
205 youi 1.24
206 aga4096 1.47 ZEND_FE(xnp_get_all_indexes ,third_arg_force_ref)
207     ZEND_FE(xnp_get_indexes ,fourth_arg_force_ref)
208     ZEND_FE(xnp_insert_index ,third_arg_force_ref)
209 youi 1.24 ZEND_FE(xnp_update_index ,NULL)
210     ZEND_FE(xnp_delete_index ,NULL)
211 aga4096 1.47 ZEND_FE(xnp_get_index ,third_arg_force_ref)
212 youi 1.24 ZEND_FE(xnp_is_index_readable ,NULL)
213     ZEND_FE(xnp_is_index_writable ,NULL)
214     ZEND_FE(xnp_swap_index_sort_number ,NULL)
215    
216     ZEND_FE(xnp_is_valid_session_id ,NULL)
217     ZEND_FE(xnp_get_last_error_string ,NULL)
218     ZEND_FE(xnp_test_criteria ,NULL)
219     ZEND_FE(xnp_test_uids ,NULL)
220    
221     ZEND_FE(xnp_get_item_permission ,NULL)
222     ZEND_FE(xnp_get_index_permission ,NULL)
223     ZEND_FE(xnp_get_certify_permission ,NULL)
224    
225 aga4096 1.47 ZEND_FE(xnp_get_certify_state ,fourth_arg_force_ref)
226 youi 1.24 ZEND_FE(xnp_set_certify_state ,NULL)
227    
228     ZEND_FE(xnp_insert_change_log ,NULL)
229 aga4096 1.47 ZEND_FE(xnp_get_change_logs ,third_arg_force_ref)
230 youi 1.24
231 aga4096 1.47 ZEND_FE(xnp_get_config_value ,second_arg_force_ref)
232 youi 1.24 ZEND_FE(xnp_set_config_value ,NULL)
233    
234     ZEND_FE(xnp_dump_item_id ,NULL)
235 aga4096 1.47 ZEND_FE(xnp_get_item_id_by_binder_id ,fourth_arg_force_ref)
236     ZEND_FE(xnp_get_item_id_by_index_id ,fourth_arg_force_ref)
237     ZEND_FE(xnp_get_overlapped_items ,NULL) /*?*/
238 youi 1.24
239 aga4096 1.47 ZEND_FE(xnp_insert_item ,third_arg_force_ref)
240     ZEND_FE(xnp_insert_item_direct ,third_arg_force_ref)
241 youi 1.24 ZEND_FE(xnp_update_item ,NULL)
242     ZEND_FE(xnp_delete_item ,NULL)
243 aga4096 1.47 ZEND_FE(xnp_get_item ,third_arg_force_ref)
244     ZEND_FE(xnp_get_items ,fourth_arg_force_ref)
245 youi 1.24
246 aga4096 1.47 ZEND_FE(xnp_pubmed_complete ,second_arg_force_ref)
247     ZEND_FE(xnp_amazon_complete ,second_arg_force_ref)
248 youi 1.24
249     // ZEND_FE(xnp_uninitialize_db ,NULL)
250    
251     ZEND_FE(xnp_register_binder_item ,NULL)
252     ZEND_FE(xnp_unregister_binder_item ,NULL)
253    
254     ZEND_FE(xnp_register_item ,NULL)
255     ZEND_FE(xnp_unregister_item ,NULL)
256    
257 aga4096 1.50 ZEND_FE(xnp_get_uncertified_link ,second_and_third_args_force_ref)
258 aga4096 1.47 ZEND_FE(xnp_get_private_item_id ,third_arg_force_ref)
259     ZEND_FE(xnp_get_group_item_id ,third_arg_force_ref)
260 youi 1.26
261 aga4096 1.47 ZEND_FE(xnp_get_item_types ,first_arg_force_ref)
262 youi 1.26
263 aga4096 1.47 ZEND_FE(xnp_get_index_id_by_item_id ,third_arg_force_ref)
264     ZEND_FE(xnp_get_own_public_item_id ,third_arg_force_ref)
265 youi 1.28
266 youi 1.33 ZEND_FE(xnp_zip_create ,NULL)
267 tani 1.35 ZEND_FE(xnp_get_item_count ,NULL)
268 aga4096 1.47 ZEND_FE(xnp_get_item_count_group_by_index ,second_arg_force_ref)
269 youi 1.33
270 aga4096 1.47 ZEND_FE(xnp_extract_public_item_id ,third_arg_force_ref)
271     ZEND_FE(xnp_extract_nonbinder_item_id,third_arg_force_ref)
272 aga4096 1.42 ZEND_FE(xnp_insert_event ,NULL)
273 tani 1.49 ZEND_FE(xnp_get_events ,second_arg_force_ref)
274 tani 1.48 ZEND_FE(xnp_get_events_for_rss ,NULL)
275 tani 1.49 {NULL, NULL, NULL}
276 aga 1.1 };
277    
278     /* compiled module information */
279 youi 1.21 zend_module_entry xnpalmod_module_entry =
280 aga 1.1 {
281 youi 1.24 STANDARD_MODULE_HEADER,
282 orrisroot 1.45 "XooNIps Abstract Layer",
283 youi 1.24 xnpalmod_functions,
284     NULL,
285 youi 1.21 PHP_MSHUTDOWN(xnpalmod),
286 youi 1.24 NULL,
287     NULL,
288     NULL,
289     NO_VERSION_YET,
290     STANDARD_MODULE_PROPERTIES
291 aga 1.1 };
292    
293     /* implement standard "stub" routine to introduce ourselves to Zend */
294     #if COMPILE_DL_FIRST_MODULE
295     BEGIN_EXTERN_C()
296 youi 1.21 ZEND_GET_MODULE(xnpalmod)
297 aga 1.1 END_EXTERN_C()
298     #endif
299    
300 aga 1.16
301 aga 1.1 /* implement function that is meant to be made available to PHP */
302     ZEND_FUNCTION(first_module)
303     {
304 youi 1.24 long parameter;
305 aga 1.1 // if(ZEND_NUM_ARGS() != 2) WRONG_PARAM_COUNT;
306 youi 1.24 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &parameter) == FAILURE) {
307     return;
308     }
309 aga 1.1 parameter++;
310 youi 1.24 RETURN_LONG(parameter);
311 aga 1.1 }
312     /** zval鐃緒申鐃緒申C鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
313     */
314     char *getZvalString( zval **p ){
315     convert_to_string_ex(p);
316     return Z_STRVAL_PP(p); //(**p).value.str.val;
317     }
318    
319     /** zval鐃緒申鐃緒申int鐃緒申鐃緒申鐃緒申鐃緒申
320     */
321     int getZvalInt( zval **p ){
322     convert_to_long_ex(p);
323     return Z_LVAL_PP(p); // (int)(**p).value.lval;
324     }
325    
326 aga 1.2 // keylen鐃緒申鐃緒申鐃緒申鐃緒申\0鐃緒申鐃緒申鐃緒申鐃緒申
327     static void print_hash_key( int res, const char *key, uint keyLen, ulong index ){
328     zend_printf( "print_hash_key : key=0x%08x keylen=%08d index=%08d<br> ", key, keyLen, index );
329     if ( res == HASH_KEY_IS_STRING ){
330     char *p = new char[keyLen+1];
331     memcpy( p, key, keyLen );
332     p[keyLen] = 0;
333     zend_printf( " key is string[%s]<br>\n", p );
334     }
335     else {
336     zend_printf( " key is integer[%d]<br>\n", index );
337     }
338     }
339    
340    
341 aga 1.16 /** zval*鐃緒申鐃緒申criteria_t鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申getResult()!=RES_OK <br>
342 youi 1.24 criteria :
343     array( 'start'=>0, 'rows'=>10,
344     'orders'=>array(
345     array('name'=>'id','order'=>'0'),
346     array('name'=>'timestamp','name'=>'1'), ...)
347     ); 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
348 aga 1.2 */
349     class zCriteria_t : public criteria {
350     private:
351     result_t result;
352 aga 1.16
353 aga 1.2 // pz: array('name'=>'timestamp','name'=>'1')
354     // 鐃緒申鐃緒申鐃緒申鐃緒申orderby鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
355     void setOrder( zval *pz ){
356     char *column = 0;
357     order_t order = (order_t)0;
358 youi 1.24
359 aga 1.2 HashPosition pos;
360     zval **ppzTmp = 0;
361     int res2;
362     zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(pz), &pos);
363     while ( (res2=zend_hash_get_current_data_ex(Z_ARRVAL_P(pz), (void **)&ppzTmp, &pos)) == SUCCESS ) {
364     char *key = 0;
365     uint keyLen = 0;
366     ulong index = 0;
367     int keyType = zend_hash_get_current_key_ex(Z_ARRVAL_P(pz), &key, &keyLen, &index, false/*duplicate flag*/, &pos );
368     if ( keyType == HASH_KEY_IS_STRING/*1*/ || keyType == HASH_KEY_IS_LONG/*2*/ ){
369 aga 1.14 //print_hash_key( keyType, key, keyLen, index );
370     if ( strncasecmp( key, "name", keyLen ) == 0 && keyLen == 5 ){
371 aga 1.2 SEPARATE_ZVAL(ppzTmp);
372     column = getZvalString(ppzTmp);
373     // zend_printf( "column=%s<br>\n", column );
374     }
375     else if ( strncasecmp( key, "order", keyLen ) == 0 && keyLen == 6 ){
376     SEPARATE_ZVAL(ppzTmp);
377     order = (order_t)getZvalInt(ppzTmp);
378     // zend_printf( "order=%d<br>\n", order );
379     }
380     }
381 youi 1.24
382 aga 1.2 zend_hash_move_forward_ex(Z_ARRVAL_P(pz), &pos);
383     }
384     if ( column ){
385     orderby *o = new orderby( column, order );
386     addOrderBy( o );
387     }
388 youi 1.24
389 aga 1.2 result = RES_OK;
390     }
391 youi 1.24
392 aga 1.2 // pz: array( array('column'=>'hoge','order'=>'1'), array('column'=>'huga','order'=>'2'), ...)
393     void setOrders( zval *pz ){
394     HashPosition pos;
395 youi 1.24
396 aga 1.2 zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(pz), &pos);
397 youi 1.24
398 aga 1.2 zval **ppzTmp = 0;
399     int res2;
400     while ( (res2=zend_hash_get_current_data_ex(Z_ARRVAL_P(pz), (void **)&ppzTmp, &pos)) == SUCCESS ) {
401     char *key = 0;
402     uint keyLen = 0;
403     ulong index = 0;
404     int keyType = zend_hash_get_current_key_ex(Z_ARRVAL_P(pz), &key, &keyLen, &index, false/*duplicate flag*/, &pos );
405     if ( keyType == HASH_KEY_IS_STRING/*1*/ || keyType == HASH_KEY_IS_LONG/*2*/ ){
406 aga 1.14 //print_hash_key( keyType, key, keyLen, index );
407 aga 1.2 setOrder( *ppzTmp );
408     }
409     zend_hash_move_forward_ex(Z_ARRVAL_P(pz), &pos);
410     }
411     result = RES_OK;
412     }
413 youi 1.24
414 aga 1.2 void initialize( zval *pz ){
415     HashPosition pos;
416     zval **ppzTmp = 0;
417     int res2;
418     zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(pz), &pos);
419     while ( (res2=zend_hash_get_current_data_ex(Z_ARRVAL_P(pz), (void **)&ppzTmp, &pos)) == SUCCESS ) {
420     char *key = 0;
421     uint keyLen = 0;
422     ulong index = 0;
423     int keyType = zend_hash_get_current_key_ex(Z_ARRVAL_P(pz), &key, &keyLen, &index, false/*duplicate flag*/, &pos );
424     if ( keyType == HASH_KEY_IS_STRING/*1*/ || keyType == HASH_KEY_IS_LONG/*2*/ ){
425 aga 1.14 //print_hash_key( keyType, key, keyLen, index );
426 aga 1.2 if ( strncasecmp( key, "start", keyLen ) == 0 && keyLen == 6 ){
427     SEPARATE_ZVAL(ppzTmp);
428     int tmp = getZvalInt(ppzTmp);
429     // zend_printf( "start=%d<br>\n", tmp );
430     setLimit( tmp, getLimitRows() );
431     }
432     else if ( strncasecmp( key, "rows", keyLen ) == 0 && keyLen == 5 ){
433     SEPARATE_ZVAL(ppzTmp);
434     int tmp = getZvalInt(ppzTmp);
435     // zend_printf( "rows=%d<br>\n", tmp );
436     setLimit( getLimitStart(), tmp );
437     }
438     else if ( strncasecmp( key, "orders", keyLen ) == 0 && keyLen == 7 ){
439     setOrders( *ppzTmp );
440     }
441     else
442     ; // ignore unknown key
443     }
444     else
445     ; // ignore bad key
446     zend_hash_move_forward_ex(Z_ARRVAL_P(pz), &pos);
447     }
448     result = RES_OK;
449     }
450 aga 1.16
451     public:
452 aga 1.2 zCriteria_t() : criteria(){ result = RES_ERROR; }
453     zCriteria_t( zval *pz ) : criteria(){ initialize(pz); }
454     zCriteria_t( zval **ppz ) : criteria() { initialize(*ppz); }
455     result_t getResult(){ return result; };
456 youi 1.24
457 aga 1.2 void dump(){
458     zend_printf( "dumping zCriteria...<br>\n" );
459     zend_printf( "result=%d<br>\n", (int)result );
460     zend_printf( "start=%d, rows=%d<br>\n", getLimitStart(), getLimitRows() );
461     const orderby *p = headOrderBy();
462     while ( p ){
463     zend_printf( "column=%s, order=%d<br>\n", p->getColumn(), p->getOrder() );
464     p = nextOrderBy();
465     }
466     }
467     };
468    
469 aga 1.16
470     /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申long鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
471     @param ht 鐃緒申鐃緒申鐃緒申鐃緒申
472     @param key 鐃緒申鐃緒申
473     @param val long鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
474     @return 鐃緒申鐃緒申鐃緒申鐃緒申true
475     */
476     static bool hashGetLong( HashTable *ht, const char *key, long *val ){
477 youi 1.24 zval **tmp;
478     if( zend_hash_find( ht, (char *)key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
479     convert_to_long_ex( tmp );
480     *val = Z_LVAL_PP(tmp);
481     return true;
482     }
483     return false;
484 aga 1.14 }
485    
486 aga 1.16 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
487     @param ht 鐃緒申鐃緒申鐃緒申鐃緒申
488     @param key 鐃緒申鐃緒申
489     @param val 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
490     @return 鐃緒申鐃緒申鐃緒申鐃緒申true
491     */
492     static bool hashGetString( HashTable *ht, const char *key, char **val ){
493 youi 1.24 zval **tmp;
494     if( zend_hash_find( ht, (char *)key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
495     convert_to_string_ex( tmp );
496     *val = Z_STRVAL_PP(tmp);
497     return true;
498     }
499     return false;
500 aga 1.14 }
501    
502 aga 1.16 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申double鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
503     @param ht 鐃緒申鐃緒申鐃緒申鐃緒申
504     @param key 鐃緒申鐃緒申
505     @param val double鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
506     @return 鐃緒申鐃緒申鐃緒申鐃緒申true
507     */
508     static bool hashGetDouble( HashTable *ht, const char *key, double *val ){
509 youi 1.24 zval **tmp;
510     if( zend_hash_find( ht, (char *)key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
511     convert_to_double_ex( tmp );
512     *val = Z_DVAL_PP(tmp);
513     return true;
514     }
515     return false;
516 aga 1.14 }
517 aga 1.2
518 aga 1.16 /** zval*鐃緒申鐃緒申account鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申 <br>
519 youi 1.24 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申getResult()!=RES_OK <br>
520 aga 1.16 */
521 aga 1.2 class zAccount_t : public account {
522     private:
523     result_t result;
524     void initialize(zval *pz){
525 aga 1.14 HashTable *ht = Z_ARRVAL_P(pz);
526     long l;
527     char *p;
528     double d;
529     if ( hashGetLong ( ht, "uid" , &l ) ) setUID ( l );
530     if ( hashGetString( ht, "uname" , &p ) ) setUname ( p );
531     if ( hashGetString( ht, "name" , &p ) ) setName ( p );
532     if ( hashGetString( ht, "email" , &p ) ) setEmail ( p );
533     if ( hashGetString( ht, "url" , &p ) ) setURL ( p );
534     if ( hashGetString( ht, "user_avatar" , &p ) ) setUserAvatar ( p );
535     if ( hashGetString( ht, "user_icq" , &p ) ) setUserIcq ( p );
536     if ( hashGetString( ht, "user_from" , &p ) ) setUserFrom ( p );
537     if ( hashGetString( ht, "user_sig" , &p ) ) setUserSig ( p );
538     if ( hashGetString( ht, "actkey" , &p ) ) setActkey ( p );
539     if ( hashGetString( ht, "user_aim" , &p ) ) setUserAim ( p );
540     if ( hashGetString( ht, "user_yim" , &p ) ) setUserYim ( p );
541     if ( hashGetString( ht, "user_msnm" , &p ) ) setUserMsnm ( p );
542     if ( hashGetString( ht, "pass" , &p ) ) setPass ( p );
543     if ( hashGetString( ht, "theme" , &p ) ) setTheme ( p );
544     if ( hashGetString( ht, "umode" , &p ) ) setUmode ( p );
545     if ( hashGetString( ht, "user_occ" , &p ) ) setUserOcc ( p );
546     if ( hashGetString( ht, "bio" , &p ) ) setBio ( p );
547     if ( hashGetString( ht, "user_intrest" , &p ) ) setUserIntrest ( p );
548     if ( hashGetDouble( ht, "timezone_offset" , &d ) ) setTimezoneOffset ( d );
549     if ( hashGetLong ( ht, "attachsig" , &l ) ) setAttachsig ( l );
550     if ( hashGetLong ( ht, "last_login" , &l ) ) setLastLogin ( l );
551     if ( hashGetLong ( ht, "level" , &l ) ) setLevel ( l );
552     if ( hashGetLong ( ht, "notify_method" , &l ) ) setNotifyMethod ( l );
553     if ( hashGetLong ( ht, "notify_mode" , &l ) ) setNotifyMode ( l );
554     if ( hashGetLong ( ht, "posts" , &l ) ) setPosts ( l );
555     if ( hashGetLong ( ht, "rank" , &l ) ) setRank ( l );
556     if ( hashGetLong ( ht, "uorder" , &l ) ) setUorder ( l );
557     if ( hashGetLong ( ht, "user_mailok" , &l ) ) setUserMailok ( l );
558     if ( hashGetLong ( ht, "user_regdate" , &l ) ) setUserRegdate ( l );
559     if ( hashGetLong ( ht, "user_viewemail" , &l ) ) setUserViewemail ( l );
560     if ( hashGetLong ( ht, "activate" , &l ) ) setActivate ( l );
561     if ( hashGetString( ht, "address" , &p ) ) setAddress ( p );
562 aga 1.16 if ( hashGetString( ht, "division" , &p ) ) setDivision ( p );
563 aga 1.14 if ( hashGetString( ht, "tel" , &p ) ) setTel ( p );
564 aga 1.16 if ( hashGetString( ht, "company_name" , &p ) ) setCompanyName ( p );
565 aga 1.14 if ( hashGetString( ht, "country" , &p ) ) setCountry ( p );
566     if ( hashGetString( ht, "zipcode" , &p ) ) setZipcode ( p );
567     if ( hashGetString( ht, "fax" , &p ) ) setFax ( p );
568     if ( hashGetLong ( ht, "notice_mail" , &l ) ) setNoticeMail ( l );
569     if ( hashGetLong ( ht, "notice_mail_since" , &l ) ) setNoticeMailSince ( l );
570 aga 1.22 if ( hashGetLong ( ht, "private_index_id " , &l ) ) setPrivateIndexID ( l );
571 tani 1.36 if ( hashGetLong ( ht, "item_number_limit" , &l ) ) setItemNumberLimit ( l );
572     if ( hashGetLong ( ht, "index_number_limit", &l ) ) setIndexNumberLimit ( l );
573     if ( hashGetDouble( ht, "item_storage_limit", &d ) ) setItemStorageLimit ( d );
574 aga 1.14
575     result = RES_OK;
576 aga 1.2 }
577 aga 1.16 public:
578 aga 1.2 zAccount_t() : account(){ result = RES_ERROR; }
579 youi 1.24
580     /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
581     @param pz array( 'uid'=>1, 'uname'=>'root', ... ); 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申 */
582 aga 1.2 zAccount_t( zval *pz ) : account(){ initialize(pz); }
583     zAccount_t( zval **ppz ) : account() { initialize(*ppz); }
584     result_t getResult(){ return result; };
585     };
586    
587 aga 1.22 class zIndex_t : public index {
588     private:
589     result_t result;
590 youi 1.24
591 aga 1.22 void initialize(zval *pz){
592     HashTable *ht = Z_ARRVAL_P(pz);
593     long l;
594     char *p;
595     if ( hashGetLong ( ht, "item_id" , &l ) ) setItemID ( l );
596     if ( hashGetLong ( ht, "item_type_id" , &l ) ) setItemTypeID ( l );
597     if ( hashGetLong ( ht, "contributor_uid" , &l ) ) setContributorUID ( l );
598     if ( hashGetString( ht, "title" , &p ) ) setTitle ( p );
599     if ( hashGetString( ht, "keywords" , &p ) ) setKeywords ( p );
600     if ( hashGetString( ht, "description" , &p ) ) setDescription ( p );
601     if ( hashGetLong ( ht, "last_update_date" , &l ) ) setLastUpdateDate ( l );
602     if ( hashGetLong ( ht, "creation_date" , &l ) ) setCreationDate ( l );
603     if ( hashGetLong ( ht, "parent_index_id" , &l ) ) setParentIndexID ( l );
604     if ( hashGetLong ( ht, "owner_uid" , &l ) ) setOwnerUID ( l );
605     if ( hashGetLong ( ht, "owner_gid" , &l ) ) setOwnerGID ( l );
606     if ( hashGetLong ( ht, "open_level" , &l ) ) setOpenLevel ( l );
607     if ( hashGetLong ( ht, "sort_number" , &l ) ) setSortNumber ( l );
608    
609     result = RES_OK;
610     }
611     public:
612     zIndex_t() : index(){ result = RES_ERROR; }
613     zIndex_t( zval *pz ) : index(){ initialize(pz); }
614     zIndex_t( zval **ppz ) : index() { initialize(*ppz); }
615     result_t getResult(){ return result; };
616 youi 1.24
617 aga 1.22 void dump(){
618     }
619     };
620    
621 aga 1.16 /** zval*鐃緒申鐃緒申(userid_t *puid,int uidLen)鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申 <br>
622 youi 1.24 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申getResult()!=RES_OK <br>
623 aga 1.2 */
624     class zUIDs_t {
625     private:
626     result_t result;
627     userid_t *pUID;
628     int len;
629     public:
630     zUIDs_t(){
631     pUID = 0;
632     len = 0;
633     result = RES_ERROR;
634     }
635 youi 1.24
636     /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
637     @param pza array( '1', '3', '4', '6', ... ); 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申 */
638 aga 1.2 zUIDs_t( zval *pza ){
639     pUID = 0;
640     len = 0;
641     result = RES_ERROR;
642 youi 1.24
643 aga 1.2 if ( Z_TYPE_P(pza) != IS_ARRAY ){
644     result = RES_ERROR;
645     }
646     else {
647     len = zend_hash_num_elements(Z_ARRVAL_P(pza));
648     if(len == 0) {
649     pUID = new userid_t[1];
650     result = RES_OK;
651     }
652     else {
653     /* php/ext/standard/string.c 鐃緒申 implode鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
654     zend_hash_*鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
655     */
656     zval **tmp;
657     HashPosition pos;
658     int i = 0;
659     pUID = new userid_t[len];
660 youi 1.24
661 aga 1.2 zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(pza), &pos);
662     while (zend_hash_get_current_data_ex(Z_ARRVAL_P(pza), (void **) &tmp, &pos) == SUCCESS ) {
663     SEPARATE_ZVAL(tmp); // zend.arguments.write-safety.html 鐃緒申鐃緒申
664     convert_to_long_ex(tmp);
665     if ( i < len )
666     pUID[i++] = Z_LVAL_PP(tmp);
667     zend_hash_move_forward_ex(Z_ARRVAL_P(pza), &pos);
668     }
669     len = i;
670     result = RES_OK;
671     }
672     }
673     }
674 youi 1.24
675 aga 1.2 ~zUIDs_t(){
676     if ( pUID ) delete[] pUID;
677     }
678     result_t getResult(){ return result; }
679     userid_t *getPUID(){ return pUID; }
680     int getLen(){ return len; }
681     void dump(){
682 youi 1.24 zend_printf( "dumping zUIDs...<br>\n" );
683 aga 1.2 zend_printf( "result=%d<br>\n", (int)result );
684     zend_printf( "len=%d<br>\n", len );
685     for ( int i = 0; i < len; i++ ){
686     zend_printf( "pUID[%d] = %d<br>\n", i, pUID[i] );
687     }
688     }
689     };
690    
691 youi 1.24 /** zval*鐃緒申鐃緒申(itemid_t *piid,int iidLen)鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申 <br>
692     鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申getResult()!=RES_OK <br>
693     */
694     class zIIDs_t {
695     private:
696     result_t result;
697     itemid_t *pIID;
698     int len;
699     public:
700     zIIDs_t(){
701     pIID = 0;
702     len = 0;
703     result = RES_ERROR;
704     }
705    
706     /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
707     @param pza array( '1', '3', '4', '6', ... ); 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申 */
708     zIIDs_t( zval *pza ){
709     pIID = 0;
710     len = 0;
711     result = RES_ERROR;
712    
713     if ( Z_TYPE_P(pza) != IS_ARRAY ){
714     result = RES_ERROR;
715     }
716     else {
717     len = zend_hash_num_elements(Z_ARRVAL_P(pza));
718     if(len == 0) {
719     pIID = new itemid_t[1];
720     result = RES_OK;
721     }
722     else {
723     /* php/ext/standard/string.c 鐃緒申 implode鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
724     zend_hash_*鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
725     */
726     zval **tmp;
727     HashPosition pos;
728     int i = 0;
729     pIID = new itemid_t[len];
730    
731     zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(pza), &pos);
732     while (zend_hash_get_current_data_ex(Z_ARRVAL_P(pza), (void **) &tmp, &pos) == SUCCESS ) {
733     SEPARATE_ZVAL(tmp); // zend.arguments.write-safety.html 鐃緒申鐃緒申
734     convert_to_long_ex(tmp);
735     if ( i < len )
736     pIID[i++] = Z_LVAL_PP(tmp);
737     zend_hash_move_forward_ex(Z_ARRVAL_P(pza), &pos);
738     }
739     len = i;
740     result = RES_OK;
741     }
742     }
743     }
744    
745     ~zIIDs_t(){
746     if ( pIID ) delete[] pIID;
747     }
748     result_t getResult(){ return result; }
749     itemid_t *getPIID(){ return pIID; }
750     int getLen(){ return len; }
751     void dump(){
752     zend_printf( "dumping zIIDs...<br>\n" );
753     zend_printf( "result=%d<br>\n", (int)result );
754     zend_printf( "len=%d<br>\n", len );
755     for ( int i = 0; i < len; i++ ){
756     zend_printf( "pIID[%d] = %d<br>\n", i, pIID[i] );
757     }
758     }
759     };
760    
761     /**
762     *
763     * amazonbook_t鐃緒申鐃緒申鐃緒申鐃緒申PHP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
764     * @param pAmazonbook 鐃緒申鐃緒申鐃緒申鐃緒申amazonbook_t*
765     * @param z 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)
766     * @return RES_OK
767     *
768     */
769     result_t amazonbookToZval( const amazonbook_t *pAmazonbook, zval *z )
770     {
771     zend_hash_clean( z -> value.ht );
772    
773     add_assoc_string( z, "title", ( char* )pAmazonbook -> getTitle( ), 1 );
774     add_assoc_string( z, "author", ( char* )pAmazonbook -> getAuthor( ), 1 );
775     add_assoc_string( z, "publisher", ( char* )pAmazonbook -> getPublisher( ), 1 );
776     add_assoc_long( z, "year_of_publication", pAmazonbook -> getYearOfPublication( ) );
777     add_assoc_string( z, "isbn", ( char* )pAmazonbook -> getISBN( ), 1 );
778     add_assoc_string( z, "url", ( char* )pAmazonbook -> getURL( ), 1 );
779    
780     return RES_OK;
781     }
782    
783     /**
784     *
785     * pubmed_t鐃緒申鐃緒申鐃緒申鐃緒申PHP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
786     * @param pPubmed 鐃緒申鐃緒申鐃緒申鐃緒申pubmed_t*
787     * @param z 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)
788     * @return RES_OK
789     *
790     */
791     result_t pubmedToZval( const pubmed_t *pPubmed, zval *z )
792     {
793     zend_hash_clean( z -> value.ht );
794    
795     add_assoc_long( z, "pmid", pPubmed -> getID( ) );
796     add_assoc_string( z, "title", ( char* )pPubmed -> getTitle( ), 1 );
797     add_assoc_string( z, "author", ( char* )pPubmed -> getAuthor( ), 1 );
798     add_assoc_string( z, "journal", ( char* )pPubmed -> getJournal( ), 1 );
799     add_assoc_long( z, "year_of_publication", pPubmed -> getYearOfPublication( ) );
800     add_assoc_long( z, "volume", pPubmed -> getVolume( ) );
801     add_assoc_long( z, "number", pPubmed -> getNumber( ) );
802     add_assoc_string( z, "page", ( char* )pPubmed -> getPage( ), 1 );
803     add_assoc_string( z, "abstract", ( char* )pPubmed -> getAbstract( ), 1 );
804    
805     return RES_OK;
806     }
807    
808     /**
809     *
810     * itemid_t鐃緒申鐃緒申鐃緒申鐃緒申PHP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
811     * @param piid 鐃緒申鐃緒申鐃緒申鐃緒申itemid_t鐃緒申鐃緒申鐃緒申
812     * @param len piid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
813     * @param ppz 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)
814     * @return RES_OK
815     *
816     */
817 youi 1.25 result_t itemidsToZval( const itemid_t *piid, int len, zval **ppz )
818 youi 1.24 {
819     zend_hash_clean( Z_ARRVAL_PP(ppz) );
820    
821 youi 1.26 // add IDs
822     for ( int i = 0; i < len; i++ ){
823     add_next_index_long(*ppz, (long)(piid[i]) );
824     }
825    
826     return RES_OK;
827     }
828    
829     /**
830     *
831     * indexid_t鐃緒申鐃緒申鐃緒申鐃緒申PHP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
832     * @param piid 鐃緒申鐃緒申鐃緒申鐃緒申indexid_t鐃緒申鐃緒申鐃緒申
833     * @param len piid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
834     * @param ppz 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)
835     * @return RES_OK
836     *
837     */
838     result_t indexidsToZval( const indexid_t *piid, int len, zval **ppz )
839     {
840     zend_hash_clean( Z_ARRVAL_PP(ppz) );
841    
842     // add IDs
843 youi 1.24 for ( int i = 0; i < len; i++ ){
844     add_next_index_long(*ppz, (long)(piid[i]) );
845     }
846    
847     return RES_OK;
848     }
849    
850 aga 1.8 /**
851 youi 1.24 *
852 aga 1.8 * uids_t鐃緒申鐃緒申鐃緒申鐃緒申PHP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
853 youi 1.24 *
854 aga 1.16 * @param pUID 鐃緒申鐃緒申鐃緒申鐃緒申userid_t鐃緒申鐃緒申鐃緒申
855 aga 1.8 * @param len pUID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
856     * @param pz 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)
857     * @return RES_OK
858 youi 1.24 *
859 aga 1.8 */
860 aga 1.4 result_t uidsToZval( userid_t *pUID, int len, zval **ppz )
861     {
862 youi 1.24 zend_hash_clean( Z_ARRVAL_PP(ppz) );
863    
864 aga 1.2 // add UIDs
865     for ( int i = 0; i < len; i++ ){
866 aga 1.8 add_next_index_long(*ppz, (long)(pUID[i]) );
867 aga 1.2 }
868 youi 1.24
869 aga 1.2 return RES_OK;
870     }
871 youi 1.24
872 aga 1.16 /**
873     *
874     * groupid_t鐃緒申鐃緒申鐃緒申鐃緒申PHP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
875     * @param pGID 鐃緒申鐃緒申鐃緒申鐃緒申groupid_t鐃緒申鐃緒申鐃緒申
876     * @param len pGID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
877     * @param ppz 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)
878     * @return RES_OK
879     *
880     */
881 aga 1.4 result_t gidsToZval( groupid_t *pGID, int len, zval **ppz )
882     {
883 youi 1.24 zend_hash_clean( Z_ARRVAL_PP(ppz) );
884    
885 aga 1.2 // add GIDs
886     for ( int i = 0; i < len; i++ ){
887 aga 1.8 add_next_index_long(*ppz, (long)(pGID[i]) );
888 aga 1.2 }
889 youi 1.24
890     return RES_OK;
891     }
892    
893     /**
894     *
895     * changelog_t鐃緒申鐃緒申鐃緒申鐃緒申PHP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
896     * @param pChangelog 鐃緒申鐃緒申鐃緒申鐃緒申changelog_t*
897     * @param z 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)
898     * @return RES_OK
899     *
900     */
901     result_t changelogToZval( const changelog_t *pChangelog, zval *z )
902     {
903     zend_hash_clean( z -> value.ht );
904    
905     add_assoc_long( z, "log_id", pChangelog -> getChangelogID( ) );
906     add_assoc_long( z, "item_id", pChangelog -> getItemID( ) );
907     add_assoc_long( z, "log_date", pChangelog -> getDate( ) );
908     add_assoc_string( z, "log", ( char* )pChangelog -> getLog( ), 1 );
909    
910     return RES_OK;
911     }
912    
913     /**
914     *
915     * item_t鐃緒申鐃緒申鐃緒申鐃緒申PHP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
916     * @param pItem 鐃緒申鐃緒申鐃緒申鐃緒申item_t*
917     * @param z 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)
918     * @return RES_OK
919     *
920     */
921     result_t itemToZval( const item_t *pItem, zval *z )
922     {
923     zend_hash_clean( z -> value.ht );
924    
925     add_assoc_long( z, "item_id", pItem -> getItemID( ) );
926     add_assoc_long( z, "item_type_id", pItem -> getItemTypeID( ) );
927     add_assoc_long( z, "uid", pItem -> getContributorUID( ) );
928     add_assoc_string( z, "title", ( char* )pItem -> getTitle( ), 1 );
929     add_assoc_string( z, "keywords", ( char* )pItem -> getKeywords( ), 1 );
930     add_assoc_string( z, "description", ( char* )pItem -> getDescription( ), 1 );
931     add_assoc_string( z, "doi", ( char* )pItem -> getDOI( ), 1 );
932     add_assoc_long( z, "last_update_date", pItem -> getLastUpdateDate( ) );
933     add_assoc_long( z, "creation_date", pItem -> getCreationDate( ) );
934 youi 1.34 add_assoc_long( z, "publication_year", pItem -> getPublicationYear( ) );
935     add_assoc_long( z, "publication_month", pItem -> getPublicationMonth( ) );
936     add_assoc_long( z, "publication_mday", pItem -> getPublicationMday( ) );
937 tani 1.53 add_assoc_string( z, "lang", ( char* )pItem -> getLang( ), 1 );
938 youi 1.24
939     return RES_OK;
940     }
941    
942    
943     result_t itemsToZval( const item_t *pItems, int itemsLen, zval *z )
944     {
945     zend_hash_clean( z -> value.ht );
946     for( int i = 0; i < itemsLen; i++ ){
947     zval *new_array;
948     MAKE_STD_ZVAL(new_array);
949     if(array_init(new_array) != SUCCESS){
950     return RES_ERROR;
951     }
952     add_index_zval( z, i, new_array );
953     itemToZval( &pItems[ i ], new_array );
954     }
955 aga 1.2 return RES_OK;
956     }
957    
958 youi 1.24 /**
959     *
960     * PHP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申group_t鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
961     *
962     * @param z 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
963     * @param pGroup 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
964     * @return RES_OK
965     *
966     */
967     result_t zvalToItem( zval *z, item_t* pItem )
968     {
969     zval **tmp;
970     char* key = 0;
971    
972     key = "item_id";
973     if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
974     convert_to_long_ex( tmp ) ;
975     pItem -> setItemID( (*tmp) -> value.lval );
976     }
977     key = "item_type_id";
978     if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
979     convert_to_long_ex( tmp ) ;
980     pItem -> setItemTypeID( (*tmp) -> value.lval );
981     }
982     key = "uid";
983     if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
984     convert_to_long_ex( tmp ) ;
985     pItem -> setContributorUID( (*tmp) -> value.lval );
986     }
987     key = "title";
988     if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
989     convert_to_string_ex( tmp ) ;
990     pItem -> setTitle( (*tmp) -> value.str.val );
991     }
992     key = "keywords";
993     if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
994     convert_to_string_ex( tmp ) ;
995     pItem -> setKeywords( (*tmp) -> value.str.val );
996     }
997     key = "description";
998     if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
999     convert_to_string_ex( tmp ) ;
1000     pItem -> setDescription( (*tmp) -> value.str.val );
1001     }
1002     key = "doi";
1003     if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
1004     convert_to_string_ex( tmp ) ;
1005     pItem -> setDOI( (*tmp) -> value.str.val );
1006     }
1007     key = "last_update_date";
1008     if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
1009     convert_to_long_ex( tmp ) ;
1010     pItem -> setLastUpdateDate( (*tmp) -> value.lval );
1011     }
1012     key = "creation_date";
1013     if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
1014     convert_to_long_ex( tmp ) ;
1015     pItem -> setCreationDate( (*tmp) -> value.lval );
1016 youi 1.34 }
1017     key = "publication_year";
1018     if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
1019     convert_to_long_ex( tmp ) ;
1020     pItem -> setPublicationYear( (*tmp) -> value.lval );
1021     }
1022     key = "publication_month";
1023     if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
1024     convert_to_long_ex( tmp ) ;
1025     pItem -> setPublicationMonth( (*tmp) -> value.lval );
1026     }
1027     key = "publication_mday";
1028     if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
1029     convert_to_long_ex( tmp ) ;
1030     pItem -> setPublicationMday( (*tmp) -> value.lval );
1031 youi 1.24 }
1032 tani 1.53 key = "lang";
1033     if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
1034     convert_to_string_ex( tmp ) ;
1035     pItem -> setLang( (*tmp) -> value.str.val );
1036     }
1037 youi 1.24 return RES_OK;
1038     }
1039 aga 1.16
1040     /**
1041     *
1042     * account_t鐃緒申鐃緒申鐃緒申鐃緒申PHP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1043     * @param pAccount 鐃緒申鐃緒申鐃緒申鐃緒申account_t*
1044     * @param z 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)
1045     * @return RES_OK
1046     *
1047     */
1048 youi 1.6 result_t accountToZval( const account_t *pAccount, zval *z )
1049     {
1050 youi 1.24 zend_hash_clean( z -> value.ht );
1051    
1052     add_assoc_long( z, "uid", pAccount -> getUID( ) );
1053     add_assoc_string( z, "uname", ( char* )pAccount -> getUname( ), 1 );
1054     add_assoc_string( z, "name", ( char* )pAccount -> getName( ), 1 );
1055     add_assoc_string( z, "email", ( char* )pAccount -> getEmail( ), 1 );
1056     add_assoc_string( z, "url", ( char* )pAccount -> getURL( ), 1 );
1057     add_assoc_string( z, "user_avatar", ( char* )pAccount -> getUserAvatar( ), 1 );
1058     add_assoc_string( z, "user_icq", ( char* )pAccount -> getUserIcq( ), 1 );
1059     add_assoc_string( z, "user_from", ( char* )pAccount -> getUserFrom( ), 1 );
1060     add_assoc_string( z, "user_sig", ( char* )pAccount -> getUserSig( ), 1 );
1061     add_assoc_string( z, "actkey", ( char* )pAccount -> getActkey( ), 1 );
1062     add_assoc_string( z, "user_aim", ( char* )pAccount -> getUserAim( ), 1 );
1063     add_assoc_string( z, "user_yim", ( char* )pAccount -> getUserYim( ), 1 );
1064     add_assoc_string( z, "user_msnm", ( char* )pAccount -> getUserMsnm( ), 1 );
1065     add_assoc_string( z, "pass", ( char* )pAccount -> getPass( ), 1 );
1066     add_assoc_string( z, "theme", ( char* )pAccount -> getTheme( ), 1 );
1067     add_assoc_string( z, "umode", ( char* )pAccount -> getUmode( ), 1 );
1068     add_assoc_string( z, "user_occ", ( char* )pAccount -> getUserOcc( ), 1 );
1069     add_assoc_string( z, "bio", ( char* )pAccount -> getBio( ), 1 );
1070     add_assoc_string( z, "user_intrest", ( char* )pAccount -> getUserIntrest( ), 1 );
1071     add_assoc_double( z, "timezone_offset", pAccount -> getTimezoneOffset( ) );
1072     add_assoc_long( z, "attachsig", pAccount -> getAttachsig( ) );
1073     add_assoc_long( z, "last_login", pAccount -> getLastLogin( ) );
1074     add_assoc_long( z, "level", pAccount -> getLevel( ) );
1075     add_assoc_long( z, "notify_method", pAccount -> getNotifyMethod( ) );
1076     add_assoc_long( z, "notify_mode", pAccount -> getNotifyMode( ) );
1077     add_assoc_long( z, "posts", pAccount -> getPosts( ) );
1078     add_assoc_long( z, "rank", pAccount -> getRank( ) );
1079     add_assoc_long( z, "uorder", pAccount -> getUorder( ) );
1080     add_assoc_long( z, "user_mailok", pAccount -> getUserMailok( ) );
1081     add_assoc_long( z, "user_regdate", pAccount -> getUserRegdate( ) );
1082     add_assoc_long( z, "user_viewemail", pAccount -> getUserViewemail( ) );
1083    
1084     add_assoc_long( z, "activate", pAccount -> getActivate( ) );
1085     add_assoc_string( z, "address", ( char* )pAccount -> getAddress( ), 1 );
1086     add_assoc_string( z, "division", ( char* )pAccount -> getDivision( ), 1 );
1087     add_assoc_string( z, "tel", ( char* )pAccount -> getTel( ), 1 );
1088     add_assoc_string( z, "company_name", ( char* )pAccount -> getCompanyName( ), 1 );
1089     add_assoc_string( z, "country", ( char* )pAccount -> getCountry( ), 1 );
1090     add_assoc_string( z, "zipcode", ( char* )pAccount -> getZipcode( ), 1 );
1091     add_assoc_string( z, "fax", ( char* )pAccount -> getFax( ), 1 );
1092     add_assoc_long( z, "notice_mail", pAccount -> getNoticeMail( ) );
1093     add_assoc_long( z, "notice_mail_since", pAccount -> getNoticeMailSince( ) );
1094     add_assoc_long( z, "private_index_id", pAccount -> getPrivateIndexID( ) );
1095 tani 1.36 add_assoc_long( z, "item_number_limit", pAccount -> getItemNumberLimit( ) );
1096     add_assoc_long( z, "index_number_limit", pAccount -> getIndexNumberLimit( ) );
1097     add_assoc_double( z, "item_storage_limit", pAccount -> getItemStorageLimit( ) );
1098 youi 1.6 return RES_OK;
1099     }
1100 youi 1.24
1101 aga 1.16 /**
1102     *
1103     * 鐃緒申鐃緒申鐃緒申account_t鐃緒申鐃緒申鐃緒申鐃緒申PHP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1104     * @param pAccounts 鐃緒申鐃緒申鐃緒申鐃緒申account_t*
1105     * @param accountsLen pAccounts鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1106     * @param z 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)
1107     * @return RES_OK
1108     *
1109     z: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申 <br>
1110 youi 1.24 array(
1111     array(
1112     'uid'=>100,
1113     'activate'=>1,
1114     'division'=>'foo',
1115     'tel'=>'123-456-789',
1116     ...
1117     ),
1118     ...
1119     )
1120 aga 1.16 */
1121 youi 1.6 result_t accountsToZval( const account_t *pAccounts, int accountsLen, zval *z )
1122 aga 1.4 {
1123 youi 1.24 zend_hash_clean( z -> value.ht );
1124     for( int i = 0; i < accountsLen; i++ ){
1125     zval *new_array;
1126     MAKE_STD_ZVAL(new_array);
1127     if(array_init(new_array) != SUCCESS){
1128     return RES_ERROR;
1129     }
1130     add_index_zval( z, i, new_array );
1131     accountToZval( &pAccounts[ i ], new_array );
1132     }
1133 youi 1.6 return RES_OK;
1134 aga 1.2 }
1135    
1136 aga 1.16 /**
1137     *
1138     * 鐃緒申鐃緒申鐃緒申group_t鐃緒申鐃緒申鐃緒申鐃緒申PHP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1139     * @param pGroups 鐃緒申鐃緒申鐃緒申鐃緒申group_t*
1140     * @param groupsLen pGroups鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1141     * @param z 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)
1142     * @return RES_OK
1143     *
1144     z: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申 <br>
1145 youi 1.24 array(
1146     array(
1147     'gid'=>1,
1148     'gname'=>'foo group',
1149     'gdesc'=>'group of foo'
1150     ),
1151     ...
1152     )
1153 aga 1.16 */
1154 youi 1.6 result_t groupsToZval( const group_t *pGroups, int groupsLen, zval *z )
1155 aga 1.4 {
1156 youi 1.24 zend_hash_clean( z -> value.ht );
1157     for( int i = 0; i < groupsLen; i++ ){
1158     zval *new_array;
1159     MAKE_STD_ZVAL(new_array);
1160     if(array_init(new_array) != SUCCESS){
1161     return RES_ERROR;
1162     }
1163     add_index_zval( z, i, new_array );
1164     add_assoc_long( new_array, "gid", pGroups[ i ].getGID( ) );
1165     add_assoc_string( new_array, "gname", ( char* )pGroups[ i ].getGname( ), 1 );
1166     add_assoc_string( new_array, "gdesc", ( char* )pGroups[ i ].getDesc( ), 1 );
1167     add_assoc_long( new_array, "group_index_id", pGroups[ i ].getGroupIndexID( ) );
1168 tani 1.36 add_assoc_long( new_array, "item_number_limit", pGroups[ i ].getItemNumberLimit( ) );
1169     add_assoc_long( new_array, "index_number_limit", pGroups[ i ].getIndexNumberLimit( ) );
1170     add_assoc_double( new_array, "item_storage_limit", pGroups[ i ].getItemStorageLimit( ) );
1171 youi 1.24 }
1172 youi 1.6 return RES_OK;
1173 aga 1.2 }
1174    
1175 youi 1.7 /**
1176 youi 1.24 *
1177 youi 1.7 * group_t鐃緒申鐃緒申鐃緒申鐃緒申PHP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1178 youi 1.24 *
1179 aga 1.16 * @param pGroup 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1180 youi 1.7 * @param z 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)
1181     * @return RES_OK
1182 youi 1.24 *
1183 youi 1.7 */
1184     result_t groupToZval( const group_t *pGroup, zval *z )
1185 youi 1.6 {
1186 youi 1.24 zend_hash_clean( z -> value.ht );
1187     add_assoc_long( z, "gid", pGroup -> getGID( ) );
1188     add_assoc_string( z, "gname", ( char* )pGroup -> getGname( ), 1 );
1189     add_assoc_string( z, "gdesc", ( char* )pGroup -> getDesc( ), 1 );
1190     add_assoc_long( z, "group_index_id", pGroup -> getGroupIndexID( ) );
1191 tani 1.36 add_assoc_long( z, "item_number_limit", pGroup -> getItemNumberLimit( ) );
1192     add_assoc_long( z, "index_number_limit", pGroup -> getIndexNumberLimit( ) );
1193     add_assoc_double( z, "item_storage_limit", pGroup -> getItemStorageLimit( ) );
1194 youi 1.6 return RES_OK;
1195     }
1196    
1197 aga 1.16 /**
1198 youi 1.24 *
1199 aga 1.16 * PHP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申group_t鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1200 youi 1.24 *
1201 aga 1.16 * @param z 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1202     * @param pGroup 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1203     * @return RES_OK
1204 youi 1.24 *
1205 aga 1.16 */
1206 youi 1.7 result_t zvalToGroup( zval *z, group_t *pGroup )
1207     {
1208 youi 1.24 zval **tmp;
1209     char* key = 0;
1210    
1211     key = "gid";
1212     if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
1213     convert_to_long_ex( tmp ) ;
1214     pGroup -> setGID( (*tmp) -> value.lval );
1215     }
1216     key = "gname";
1217     if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
1218     convert_to_string_ex( tmp ) ;
1219     pGroup -> setGname( (*tmp) -> value.str.val );
1220     }
1221     key = "gdesc";
1222     if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
1223     convert_to_string_ex( tmp ) ;
1224     pGroup -> setDesc( (*tmp) -> value.str.val );
1225     }
1226     key = "group_index_id";
1227     if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
1228     convert_to_long_ex( tmp ) ;
1229     pGroup -> setGroupIndexID( (*tmp) -> value.lval );
1230     }
1231 tani 1.36 key = "item_number_limit";
1232     if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
1233     convert_to_long_ex( tmp ) ;
1234     pGroup -> setItemNumberLimit( (*tmp) -> value.lval );
1235     }
1236     key = "index_number_limit";
1237     if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
1238     convert_to_long_ex( tmp ) ;
1239     pGroup -> setIndexNumberLimit( (*tmp) -> value.lval );
1240     }
1241     key = "item_storage_limit";
1242     if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
1243     convert_to_double_ex( tmp ) ;
1244     pGroup -> setItemStorageLimit( (*tmp) -> value.dval );
1245     }
1246 youi 1.7 return RES_OK;
1247     }
1248    
1249 aga 1.16 /**
1250 youi 1.24 *
1251 aga 1.16 * session_t鐃緒申鐃緒申鐃緒申鐃緒申PHP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1252 youi 1.24 *
1253 aga 1.16 * @param pSession 鐃緒申鐃緒申鐃緒申鐃緒申session_t
1254     * @param z 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)
1255     * @return RES_OK
1256 youi 1.24 *
1257 aga 1.16 */
1258     result_t sessionToZval( const session_t *pSession, zval *z )
1259     {
1260     string sessionID(unsignedIntToString(pSession->getSessionID()));
1261     add_assoc_string(z, "session_id", (char *)sessionID.c_str(), 1);
1262 youi 1.24
1263 aga 1.16 string date(unsignedIntToString((unsigned int)pSession->getDate()));
1264     add_assoc_string(z, "date", (char *)date.c_str(), 1);
1265 youi 1.24
1266 aga 1.20 string userID(unsignedIntToString((unsigned int)pSession->getUID()));
1267 aga 1.16 add_assoc_string(z, "user_id", (char *)userID.c_str(), 1);
1268 youi 1.24
1269 aga 1.16 return RES_OK;
1270     }
1271    
1272 aga 1.22 /**
1273     *
1274     * index_t鐃緒申鐃緒申鐃緒申鐃緒申PHP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1275     * @param pIndex 鐃緒申鐃緒申鐃緒申鐃緒申index_t*
1276     * @param z 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)
1277     * @return RES_OK
1278     *
1279     */
1280     result_t indexToZval( const index_t *pIndex, zval *z )
1281     {
1282 youi 1.24 zend_hash_clean( z -> value.ht );
1283    
1284     add_assoc_long( z, "item_id", pIndex -> getItemID( ) );
1285     add_assoc_long( z, "item_type_id", pIndex -> getItemTypeID( ) );
1286     add_assoc_long( z, "contributor_uid", pIndex -> getContributorUID( ) );
1287     add_assoc_string( z, "title", ( char* )pIndex -> getTitle( ), 1 );
1288     add_assoc_string( z, "keywords", ( char* )pIndex -> getKeywords( ), 1 );
1289     add_assoc_string( z, "description", ( char* )pIndex -> getDescription( ), 1 );
1290     add_assoc_long( z, "last_update_date", pIndex -> getLastUpdateDate( ) );
1291     add_assoc_long( z, "creation_date", pIndex-> getCreationDate( ) );
1292     add_assoc_long( z, "parent_index_id", pIndex -> getParentIndexID( ) );
1293     add_assoc_long( z, "owner_uid", pIndex -> getOwnerUID( ) );
1294     add_assoc_long( z, "owner_gid", pIndex -> getOwnerGID( ) );
1295     add_assoc_long( z, "open_level", pIndex -> getOpenLevel( ) );
1296     add_assoc_long( z, "sort_number", pIndex -> getSortNumber( ) );
1297 aga 1.22 return RES_OK;
1298     }
1299    
1300     result_t indexesToZval( const index_t *pIndexes, int indexesLen, zval *z )
1301     {
1302 youi 1.24 zend_hash_clean( z -> value.ht );
1303     for( int i = 0; i < indexesLen; i++ ){
1304     zval *new_array;
1305     MAKE_STD_ZVAL(new_array);
1306     if(array_init(new_array) != SUCCESS){
1307     return RES_ERROR;
1308     }
1309     add_index_zval( z, i, new_array );
1310     indexToZval( &pIndexes[ i ], new_array );
1311     }
1312 aga 1.22 return RES_OK;
1313     }
1314    
1315 aga4096 1.42 /**
1316     *
1317     * event_t鐃緒申鐃緒申鐃緒申鐃緒申PHP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1318     * @param pevent 鐃緒申鐃緒申鐃緒申鐃緒申event_t*
1319     * @param z 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)
1320     * @return RES_OK
1321     *
1322     */
1323     result_t eventToZval( const event_t *pEvent, zval *z )
1324     {
1325     zend_hash_clean( z -> value.ht );
1326    
1327     add_assoc_long ( z, "event_id" , pEvent -> getEventID() );
1328     add_assoc_long ( z, "event_type_id" , pEvent -> getEventTypeID() );
1329    
1330 aga4096 1.44 if ( pEvent->isValidTimestamp () ) add_assoc_long ( z, "timestamp" , pEvent -> getTimestamp() );
1331     if ( pEvent->isValidExecUID () ) add_assoc_long ( z, "exec_uid" , pEvent -> getExecUID() );
1332     if ( pEvent->isValidIndexID () ) add_assoc_long ( z, "index_id" , pEvent -> getIndexID() );
1333     if ( pEvent->isValidItemID () ) add_assoc_long ( z, "item_id" , pEvent -> getItemID() );
1334     if ( pEvent->isValidFileID () ) add_assoc_long ( z, "file_id" , pEvent -> getFileID() );
1335     if ( pEvent->isValidUID () ) add_assoc_long ( z, "uid" , pEvent -> getUID() );
1336     if ( pEvent->isValidGID () ) add_assoc_long ( z, "gid" , pEvent -> getGID() );
1337     if ( pEvent->isValidRemoteHost () ) add_assoc_string( z, "remote_host" , (char*)pEvent -> getRemoteHost() , 1 );
1338     if ( pEvent->isValidSearchKeyword () ) add_assoc_string( z, "search_keyword" , (char*)pEvent -> getSearchKeyword() , 1 );
1339     if ( pEvent->isValidAdditionalInfo() ) add_assoc_string( z, "additional_info", (char*)pEvent -> getAdditionalInfo(), 1 );
1340 aga4096 1.42
1341     return RES_OK;
1342     }
1343    
1344     result_t eventsToZval( const event_t *pevents, int eventsLen, zval *z )
1345     {
1346     zend_hash_clean( z -> value.ht );
1347     for( int i = 0; i < eventsLen; i++ ){
1348     zval *new_array;
1349     MAKE_STD_ZVAL(new_array);
1350     if(array_init(new_array) != SUCCESS){
1351     return RES_ERROR;
1352     }
1353     add_index_zval( z, i, new_array );
1354     eventToZval( &pevents[ i ], new_array );
1355     }
1356     return RES_OK;
1357     }
1358    
1359 aga 1.22
1360 youi 1.7
1361 aga 1.16
1362     /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
1363 youi 1.24 int xnp_get_group( int sid, int gid, array group );
1364     @param sid XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1365     @param gid XNP 鐃緒申 group_id
1366     @param group 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1367     @return 0 success <br>
1368 aga 1.16 */
1369 youi 1.21 ZEND_FUNCTION(xnp_get_group)
1370 aga 1.4 {
1371 youi 1.6 long sid, gid;
1372     zval *zgroup;
1373 youi 1.24
1374 youi 1.6 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lla",
1375 youi 1.24 &sid, &gid, &zgroup) == FAILURE) {
1376 youi 1.6 return;
1377     }
1378 youi 1.24
1379 youi 1.6 const group_t *pgroup;
1380     result_t result = getGroup( (sessionid_t)sid, (groupid_t)gid, &pgroup );
1381     if ( RES_OK == result ){
1382 youi 1.7 groupToZval( pgroup, zgroup );
1383 youi 1.19 freeGroup( pgroup );
1384 youi 1.6 }
1385 youi 1.24
1386     RETURN_LONG(result);
1387 youi 1.6 }
1388    
1389 aga 1.2
1390 aga 1.16 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申)鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
1391 youi 1.24 xnp_get_groups( int sid, array gids, array criteria, array groups );
1392     @param sid XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1393     @param gids XNP 鐃緒申 group_id 鐃緒申鐃緒申鐃緒申
1394     @param criteria 鐃緒申鐃緒申
1395     @param groups 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1396     @return 0 success <br>
1397 aga 1.16 */
1398 youi 1.21 ZEND_FUNCTION(xnp_get_groups)
1399 youi 1.6 {
1400     result_t result;
1401 youi 1.29 long sid;
1402 youi 1.6 zval *zcriteria;
1403     zval *zgids;
1404     zval *zgroups;
1405 youi 1.24 zval **ppzTmp = 0;
1406     HashPosition pos;
1407     int res2;
1408     int gidsLen;
1409     const group_t* groups;
1410     int groupsLen;
1411    
1412 youi 1.6 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "laaa",
1413 youi 1.24 &sid, &zgids, &zcriteria, &zgroups) == FAILURE) {
1414 youi 1.6 return;
1415     }
1416 youi 1.24
1417     //gids鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1418     gidsLen = zend_hash_num_elements(Z_ARRVAL_P(zgids));
1419     groupid_t *gids = new groupid_t[ gidsLen ];
1420     zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(zgids), &pos);
1421     for( int i = 0; i < gidsLen; i++ ){
1422     if( (res2=zend_hash_get_current_data_ex(Z_ARRVAL_P(zgids), (void **)&ppzTmp, &pos)) == SUCCESS ){
1423     SEPARATE_ZVAL(ppzTmp);
1424     convert_to_long_ex(ppzTmp);
1425     gids[ i ] = Z_LVAL_PP(ppzTmp);
1426     }
1427     zend_hash_move_forward_ex(Z_ARRVAL_P(zgids), &pos);
1428     }
1429    
1430 youi 1.6 zCriteria_t zcri(zcriteria);
1431     result = zcri.getResult();
1432     if ( RES_OK == result ){
1433 youi 1.24 result = getGroups( (sessionid_t)sid, gids, gidsLen, &zcri, &groups, &groupsLen );
1434     if ( RES_OK == result ){
1435     groupsToZval( groups, groupsLen, zgroups );
1436     delete[] gids;
1437     freeGroup( groups );
1438     }
1439     }
1440     RETURN_LONG(result);
1441 youi 1.6 }
1442    
1443    
1444 aga 1.16 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
1445 youi 1.24 int xnp_is_moderator(int sid, int uid)
1446     @param sid XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1447     @param uid xoops 鐃緒申 uid (xoops_users.uid)
1448     @return true 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申 <br>
1449 aga 1.16 */
1450 youi 1.21 ZEND_FUNCTION(xnp_is_moderator)
1451 youi 1.6 {
1452 youi 1.21 long xnpSessionID;
1453 youi 1.6 userid_t uid;
1454 youi 1.24
1455     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll",
1456     &xnpSessionID, &uid) == FAILURE) {
1457 youi 1.6 return;
1458     }
1459 youi 1.24
1460 youi 1.21 bool result = isModerator( (sessionid_t)xnpSessionID, uid );
1461 youi 1.24 RETURN_BOOL(result)
1462 youi 1.6 }
1463    
1464 aga 1.16 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申uid鐃緒申鐃緒申鐃緒申鐃緒申<br>
1465 youi 1.24 int xnp_get_uid(string uname,int &uid)
1466     @param sid XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1467     @param uname xoops 鐃緒申 uname (xoops_users.uname)
1468     @param uid xoops 鐃緒申 uid (xoops_users.uid) 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1469     @return 0 success
1470 aga 1.16 */
1471 youi 1.21 ZEND_FUNCTION(xnp_get_uid)
1472 youi 1.6 {
1473     char *uname;
1474     int unameLen;
1475 aga 1.14 zval *zuid;
1476 youi 1.6 userid_t uid;
1477 youi 1.24
1478     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz",
1479 aga 1.14 &uname, &unameLen, &zuid) == FAILURE) {
1480 youi 1.6 return;
1481     }
1482 youi 1.24
1483 aga 1.14 if (!PZVAL_IS_REF(zuid)) {
1484     zend_error(E_WARNING, "2nd parameter wasn't passed by reference");
1485     RETURN_LONG(RES_PHP_NONREF);
1486     }
1487 youi 1.24
1488 youi 1.6 string strUname( uname, unameLen );
1489     result_t result = getUid( strUname.c_str(), &uid );
1490 aga 1.14 ZVAL_LONG(zuid, (long)uid);
1491     RETURN_LONG((long)result);
1492 aga 1.2 }
1493    
1494 youi 1.21 ZEND_FUNCTION(xnp_test_criteria)
1495 aga 1.2 {
1496     zval *z;
1497 youi 1.24
1498     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a",
1499 aga 1.2 &z) == FAILURE) {
1500     return;
1501     }
1502     zend_printf("zend_printf...<br>\n");
1503     zCriteria_t zcri(z);
1504     zcri.dump();
1505     RETURN_FALSE
1506     }
1507    
1508 youi 1.21 ZEND_FUNCTION(xnp_test_uids)
1509 aga 1.2 {
1510     zval *z;
1511 youi 1.24
1512     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a",
1513 aga 1.2 &z) == FAILURE) {
1514     return;
1515     }
1516     zend_printf("zend_printf...<br>\n");
1517     zUIDs_t zuids(z);
1518     zuids.dump();
1519     RETURN_FALSE
1520     }
1521    
1522    
1523    
1524 aga 1.4 /** DB鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
1525 aga 1.31 int initialize_db( string host[, string user[, string password[, string dbname[, string prefix, int dbtype]]]] );
1526 youi 1.24 @param host 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申NULL
1527     @param user DB鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申NULL
1528     @param password DB鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申NULL
1529     @param dbname DB鐃緒申鐃緒申鐃緒申鐃緒申DB鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申""
1530     @param prefix XOOPS DB 鐃緒申prefix鐃緒申
1531 aga 1.31 @param dbtype 1=MySQL 2=SQLite鐃緒申common.h鐃緒申鐃緒申
1532 youi 1.24 @return 0 success <br>
1533 aga 1.1 */
1534 youi 1.21 ZEND_FUNCTION(xnp_initialize_db)
1535 aga 1.1 {
1536     zval **parameters[5];
1537     char *host;
1538     char *user;
1539 aga 1.2 char *password;
1540     char *dbname;
1541     char *prefix;
1542 aga 1.31 long dbtype;
1543 aga 1.1
1544     /* get the number of arguments */
1545     int argNum = ZEND_NUM_ARGS();
1546     if (argNum > 5)
1547     WRONG_PARAM_COUNT;
1548    
1549     /* argument count is correct, now retrieve arguments */
1550     if(zend_get_parameters_array_ex(argNum, parameters) != SUCCESS)
1551     WRONG_PARAM_COUNT;
1552    
1553 aga 1.2 if (argNum < 1) host = NULL;
1554 aga 1.1 else host = getZvalString( parameters[0] );
1555 youi 1.24
1556 aga 1.1 if (argNum < 2) user = NULL;
1557     else user = getZvalString( parameters[1] );
1558 youi 1.24
1559 aga 1.2 if (argNum < 3) password = NULL;
1560     else password = getZvalString( parameters[2] );
1561 youi 1.24
1562 aga 1.2 if (argNum < 4) dbname = "";
1563     else dbname = getZvalString( parameters[3] );
1564 youi 1.24
1565 aga 1.2 if (argNum < 5) prefix = "";
1566     else prefix = getZvalString( parameters[4] );
1567 youi 1.24
1568 aga 1.31 if (argNum < 6) dbtype = DBTYPE_MYSQL;
1569     else dbtype = getZvalInt( parameters[5] );
1570    
1571     result_t result = initializeDB( host, user, password, dbname, prefix, (dbtype_t)dbtype );
1572 youi 1.24
1573 aga 1.2 RETURN_LONG(result);
1574 aga 1.1 }
1575    
1576 aga 1.4 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
1577 youi 1.24 int xnp_login_user(string uname, string password, int &session_id)
1578     @param uname 鐃緒申鐃緒申鐃緒申鐃緒申(xoops_users.uname)
1579     @param password 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(md5(password)=xoops_users.pass)
1580     @return 0 success
1581 aga 1.4 */
1582 youi 1.21 ZEND_FUNCTION(xnp_login_user)
1583 aga 1.1 {
1584     char *uname;
1585     int unameLen;
1586     char *passwd;
1587     int passwdLen;
1588 youi 1.21 zval *zXNPSessionID;
1589 youi 1.24
1590     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ssz",
1591 youi 1.21 &uname, &unameLen, &passwd, &passwdLen, &zXNPSessionID) == FAILURE) {
1592 aga 1.1 return;
1593     }
1594 youi 1.24
1595 youi 1.21 if (!PZVAL_IS_REF(zXNPSessionID)) {
1596 aga 1.14 zend_error(E_WARNING, "3rd parameter wasn't passed by reference");
1597     RETURN_LONG(RES_PHP_NONREF);
1598     }
1599 youi 1.24
1600 youi 1.21 sessionid_t xnpSessionID;
1601     result_t result = loginUser( uname, passwd, &xnpSessionID );
1602 aga 1.14 if ( result == RES_OK )
1603 youi 1.21 ZVAL_LONG(zXNPSessionID, (long)xnpSessionID);
1604 aga 1.14 RETURN_LONG((long)result);
1605 aga 1.1 }
1606    
1607 aga 1.4 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
1608 youi 1.24 void xnp_logout_user(int xnp_session_id)
1609     @param xnp_session_id XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1610     @return 鐃緒申鐃緒申
1611 aga 1.4 */
1612 youi 1.21 ZEND_FUNCTION(xnp_logout_user)
1613 aga 1.1 {
1614 youi 1.21 long xnpSessionID;
1615 youi 1.24
1616 youi 1.21 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &xnpSessionID) == FAILURE) {
1617 aga 1.1 return;
1618     }
1619 youi 1.21 logoutUser( (sessionid_t)xnpSessionID );
1620 youi 1.24
1621     RETURN_NULL();
1622 aga 1.1 }
1623    
1624 youi 1.21 /** XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID 鐃緒申鐃緒申<br>
1625 youi 1.24 int xnp_create_session( string xoops_sess_id, int uid, int &session )
1626     @param xoops_sess_id xoops鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1627     @param uid xoops 鐃緒申 uid (xoops_users.uid)
1628     @param session 鐃緒申鐃緒申鐃緒申鐃緒申XNP鐃緒申session鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1629     @return 0 鐃緒申鐃緒申
1630 aga 1.4 */
1631 youi 1.21 ZEND_FUNCTION(xnp_create_session)
1632 aga 1.2 {
1633     char *xoopsSessionID;
1634     int xoopsSessionIDLen;
1635 aga 1.5 long uid;
1636 youi 1.21 zval *zXNPSessionID;
1637 youi 1.24
1638 aga 1.14 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "slz",
1639 youi 1.21 &xoopsSessionID, &xoopsSessionIDLen, &uid, &zXNPSessionID) == FAILURE) {
1640 aga 1.2 return;
1641     }
1642 youi 1.24
1643 youi 1.21 if (!PZVAL_IS_REF(zXNPSessionID)) {
1644 aga 1.14 zend_error(E_WARNING, "3rd parameter wasn't passed by reference");
1645     RETURN_LONG(RES_PHP_NONREF);
1646     }
1647 youi 1.24
1648 youi 1.21 sessionid_t xnpSessionID = 0;
1649     result_t result = createSession( xoopsSessionID, (userid_t)uid, &xnpSessionID );
1650 aga 1.14 if ( result == RES_OK )
1651 youi 1.21 ZVAL_LONG(zXNPSessionID, (long)xnpSessionID);
1652 aga 1.14 RETURN_LONG((long)result);
1653 aga 1.4 }
1654    
1655 youi 1.21 /** XNP 鐃緒申 session 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
1656 youi 1.24 int xnp_get_session( int xnp_session_id, array session_info )
1657     @param xnp_session_id XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1658     @param session_info 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1659     @return 0 success
1660 aga 1.4 */
1661 youi 1.21 ZEND_FUNCTION(xnp_get_session)
1662 aga 1.4 {
1663 youi 1.21 long xnpSessionID;
1664 aga 1.4 zval *sessionInfo;
1665     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "la",
1666 youi 1.21 &xnpSessionID, &sessionInfo) == FAILURE) {
1667 aga 1.4 return;
1668     }
1669     const session_t *session = 0;
1670 youi 1.21 result_t result = getSession( (sessionid_t)xnpSessionID, &session );
1671 aga 1.4 if ( result == RES_OK ){
1672     sessionToZval( session, sessionInfo );
1673 youi 1.19 freeSession( session );
1674 aga 1.4 }
1675 youi 1.24
1676 aga 1.4 RETURN_LONG((long)result);
1677 aga 1.2 }
1678 aga 1.1
1679 aga 1.16 /** 鐃緒申鐃緒申鐃緒申鐃緒申activate鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
1680 youi 1.24 bool xnp_is_activated( int xnp_session_id, int user_id )
1681     @param xnp_session_id XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1682     @param user_id xoops_users.uid
1683     @return 0 success
1684 aga 1.5 */
1685 youi 1.21 ZEND_FUNCTION(xnp_is_activated)
1686 aga 1.2 {
1687     long sid, uid;
1688 youi 1.24
1689 aga 1.5 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll", &sid, &uid) == FAILURE) {
1690 aga 1.2 return;
1691     }
1692 youi 1.24
1693 aga 1.2 bool result = isActivated( (sessionid_t)sid, (userid_t)uid );
1694 youi 1.24
1695     RETURN_BOOL(result);
1696 aga 1.2 }
1697 aga 1.1
1698 youi 1.17 /** activate鐃緒申鐃緒申鐃緒申<br>
1699 youi 1.24 bool xnp_activate( int xnp_session_id, int user_id, bool activated )
1700     @param xnp_session_id xnp 鐃緒申 session id
1701     @param user_id xoops_users.uid
1702     @param activated true:activate, false:inactivate
1703     @return 0 success
1704 aga 1.5 */
1705 youi 1.21 ZEND_FUNCTION(xnp_activate)
1706 aga 1.2 {
1707     long sid, uid;
1708     bool activated;
1709 youi 1.24
1710 aga 1.2 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "llb",
1711     &sid, &uid, &activated) == FAILURE) {
1712     return;
1713     }
1714 youi 1.24
1715 aga 1.2 result_t result = activate( (sessionid_t)sid, (userid_t)uid, activated );
1716 youi 1.24
1717     RETURN_LONG(result);
1718 aga 1.2 }
1719 aga 1.1
1720 youi 1.21 /** XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
1721 youi 1.24 int xnp_get_account_count( int xnp_session_id )
1722     @param xnp_session_id XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1723     @return 0 success
1724 aga 1.5 */
1725 youi 1.21 ZEND_FUNCTION(xnp_get_account_count)
1726 aga 1.2 {
1727     long sid;
1728 youi 1.24
1729 aga 1.2 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l",
1730     &sid) == FAILURE) {
1731     return;
1732     }
1733 youi 1.24
1734 aga 1.2 long count = getAccountCount( (sessionid_t)sid );
1735 youi 1.24 RETURN_LONG(count);
1736 aga 1.2 }
1737 aga 1.1
1738 aga 1.5 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
1739 youi 1.24 bool xnp_delete_account( int xnp_session_id, int user_id )
1740     @param xnp_session_id XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1741     @param user_id xoops_users.uid
1742     @return 0 success
1743 aga 1.5 */
1744 youi 1.21 ZEND_FUNCTION(xnp_delete_account)
1745 aga 1.2 {
1746     long sid, uid;
1747 youi 1.24
1748 aga 1.2 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll",
1749     &sid, &uid) == FAILURE) {
1750     return;
1751     }
1752 youi 1.24
1753 aga 1.2 result_t result = deleteAccount( (sessionid_t)sid, (userid_t)uid );
1754 youi 1.24
1755     RETURN_LONG(result);
1756 aga 1.2 }
1757 aga 1.1
1758 aga 1.5 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
1759 youi 1.24 int xnp_get_account( int xnp_session_id, int user_id, array account_info )
1760     @param xnp_session_id XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1761     @param user_id xoops_users.uid
1762     @param account_info 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1763     @return 0 success
1764 aga 1.5 */
1765 youi 1.21 ZEND_FUNCTION(xnp_get_account)
1766 aga 1.2 {
1767     long sid, uid;
1768     zval *zaccount;
1769 youi 1.24
1770 aga 1.2 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lla",
1771     &sid, &uid, &zaccount) == FAILURE) {
1772 youi 1.24 fprintf( stderr, "error occured " );
1773 aga 1.2 return;
1774     }
1775 youi 1.24
1776 aga 1.2 const account_t *paccount;
1777     result_t result = getAccount( (sessionid_t)sid, (userid_t)uid, &paccount );
1778     if ( RES_OK == result ){
1779     accountToZval( paccount, zaccount );
1780 youi 1.19 freeAccount( paccount );
1781 aga 1.2 }
1782 youi 1.24
1783     RETURN_LONG(result);
1784 aga 1.2 }
1785 aga 1.1
1786 aga 1.5 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
1787 youi 1.24 int xnp_get_accoutns( int sid, array uids, array criteria, array accounts );
1788     @param xnp_session_id XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1789     @param user_id xoops_users.uid
1790     @param criteria 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1791     @param account_info 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1792     @return 0 success
1793 aga 1.5 */
1794 youi 1.21 ZEND_FUNCTION(xnp_get_accounts)
1795 aga 1.2 {
1796     result_t result;
1797     long sid;
1798     zval *zuids;
1799     zval *zcriteria;
1800     zval *zaccount;
1801 youi 1.24
1802 aga 1.2 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "laaa",
1803     &sid, &zuids, &zcriteria, &zaccount) == FAILURE) {
1804     return;
1805     }
1806 youi 1.24
1807 aga 1.2 zCriteria_t zcri(zcriteria);
1808     result = zcri.getResult();
1809     if ( RES_OK == result ){
1810     zUIDs_t zUIDs(zuids);
1811     result = zUIDs.getResult();
1812     if ( RES_OK == result ){
1813     const account_t *paccounts;
1814     int accountLen;
1815 youi 1.24 result = getAccounts( (sessionid_t)sid,
1816 aga 1.2 zUIDs.getPUID(), zUIDs.getLen(),
1817     &zcri, &paccounts, &accountLen );
1818     if ( RES_OK == result ){
1819     accountsToZval( paccounts, accountLen, zaccount );
1820 youi 1.19 freeAccount( paccounts );
1821 aga 1.2 }
1822     }
1823     }
1824 youi 1.24
1825     RETURN_LONG(result);
1826 aga 1.2 }
1827 aga 1.1
1828 youi 1.17 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
1829 youi 1.24 int xnp_insert_account( int sid, array account_info, int &user_id );
1830     @param xnp_session_id xnp 鐃緒申 session id
1831     @param account_info 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1832     @param user_id 鐃緒申鐃緒申鐃緒申ID(xoops_users.uid)鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1833     @return 0 success
1834 aga 1.5 */
1835 youi 1.21 ZEND_FUNCTION(xnp_insert_account)
1836 aga 1.2 {
1837     result_t result;
1838     long sid;
1839     zval *zaccount;
1840 youi 1.17 zval *zuid;
1841 youi 1.24 userid_t uid;
1842    
1843 youi 1.17 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "laz",
1844     &sid, &zaccount, &zuid) == FAILURE) {
1845 aga 1.2 return;
1846     }
1847 youi 1.24
1848 aga 1.2 zAccount_t zacc(zaccount);
1849     result = zacc.getResult();
1850     if ( RES_OK == result ){
1851 youi 1.17 result = insertAccount( (sessionid_t)sid, &zacc, &uid );
1852 aga 1.2 }
1853 youi 1.24 zuid -> type = IS_LONG;
1854     zuid -> value.lval = uid;
1855     RETURN_LONG(result);
1856 aga 1.2 }
1857 aga 1.1
1858 aga 1.5 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
1859 youi 1.24 int xnp_update_account( int sid, array account );
1860     @param xnp_session_id XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1861     @param account_info 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1862     @return 0 success
1863 aga 1.5 */
1864 youi 1.21 ZEND_FUNCTION(xnp_update_account)
1865 aga 1.2 {
1866     result_t result;
1867     long sid;
1868     zval *zaccount;
1869 youi 1.24
1870 aga 1.2 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "la",
1871     &sid, &zaccount) == FAILURE) {
1872     return;
1873     }
1874 youi 1.24
1875 aga 1.2 zAccount_t zacc(zaccount);
1876     result = zacc.getResult();
1877     if ( RES_OK == result ){
1878     result = updateAccount( (sessionid_t)sid, &zacc );
1879     }
1880 youi 1.24
1881     RETURN_LONG(result);
1882 aga 1.2 }
1883 aga 1.1
1884 aga 1.5 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
1885 youi 1.24 int xnp_dump_uids( int xnp_session_id, array criteria, array uids );
1886     @param xnp_session_id XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1887     @param criteria 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1888     @param uids uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1889     @return 0 success
1890 aga 1.5 */
1891 youi 1.21 ZEND_FUNCTION(xnp_dump_uids)
1892 aga 1.2 {
1893     result_t result;
1894     long sid;
1895     zval *zcriteria;
1896     zval *zuids;
1897 youi 1.24
1898 aga 1.2 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "laa",
1899     &sid, &zcriteria, &zuids) == FAILURE) {
1900     return;
1901     }
1902 youi 1.24
1903 aga 1.2 zCriteria_t zcri(zcriteria);
1904     result = zcri.getResult();
1905     if ( RES_OK == result ){
1906     userid_t *puid;
1907     int uidLen;
1908     result = dumpUids( (sessionid_t)sid, &zcri, &puid, &uidLen );
1909     if ( RES_OK == result ){
1910     uidsToZval( puid, uidLen, &zuids );
1911 youi 1.19 freeUID( puid );
1912 aga 1.2 }
1913     }
1914 youi 1.24
1915     RETURN_LONG(result);
1916 aga 1.2 }
1917 aga 1.1
1918 youi 1.21 /** XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
1919 youi 1.24 int xnp_get_group_count( int xnp_session_id );
1920     @param xnp_session_id XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1921     @return 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1922 aga 1.5 */
1923 youi 1.21 ZEND_FUNCTION(xnp_get_group_count)
1924 aga 1.1 {
1925 aga 1.2 long sid;
1926 youi 1.24
1927 aga 1.2 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l",
1928     &sid) == FAILURE) {
1929     return;
1930     }
1931 youi 1.24
1932 aga 1.2 int count = getGroupCount( (sessionid_t)sid );
1933 youi 1.24
1934     RETURN_LONG(count);
1935 aga 1.2 }
1936 aga 1.1
1937 aga 1.5 /** uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申gid鐃緒申鐃緒申鐃緒申<br>
1938 youi 1.24 int xnp_get_group_by_uid( int xnp_session_id, int uid, array criteria, array gids );
1939     @param xnp_session_id XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1940     @param user_id xoops_users.uid
1941     @param criteria 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1942     @param gids gid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1943     @return 0 success
1944 aga 1.5 */
1945 youi 1.21 ZEND_FUNCTION(xnp_get_groups_by_uid)
1946 aga 1.2 {
1947     result_t result;
1948     long sid, uid;
1949     zval *zcriteria;
1950     zval *zgids;
1951 youi 1.24
1952 aga 1.2 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "llaa",
1953     &sid, &uid, &zcriteria, &zgids) == FAILURE) {
1954     return;
1955 aga 1.1 }
1956 youi 1.24
1957 aga 1.2 zCriteria_t zcri(zcriteria);
1958     result = zcri.getResult();
1959     if ( RES_OK == result ){
1960     groupid_t *pgids;
1961     int gidLen;
1962     result = getGroupsByUid( (sessionid_t)sid, (userid_t)uid, &zcri, &pgids, &gidLen );
1963     if ( RES_OK == result ){
1964     gidsToZval( pgids, gidLen, &zgids );
1965 youi 1.19 freeGID( pgids );
1966 aga 1.2 }
1967 aga 1.1 }
1968 youi 1.24
1969     RETURN_LONG(result);
1970 aga 1.2 }
1971    
1972    
1973 aga 1.5
1974     /** uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申gid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
1975 youi 1.24 int xnp_is_group_admin( int sid, int gid, int uid );
1976     @param xnp_session_id XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1977     @param group_id XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1978     @param user_id xoops_users.uid
1979     @return true: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1980     @return false: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1981 aga 1.5 */
1982 youi 1.21 ZEND_FUNCTION(xnp_is_group_admin)
1983 aga 1.2 {
1984     long sid, gid, uid;
1985 youi 1.24
1986 aga 1.2 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lll",
1987     &sid, &gid, &uid) == FAILURE) {
1988     return;
1989 aga 1.1 }
1990 youi 1.24
1991 aga 1.2 bool b = isGroupAdmin( (sessionid_t)sid, (groupid_t)gid, (userid_t)uid );
1992 youi 1.24
1993     RETURN_BOOL(b);
1994 aga 1.2 }
1995    
1996 aga 1.5 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申gid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
1997 youi 1.24 int xnp_dump_gids( int sid, array criteria, array gids );
1998     @param xnp_session_id XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1999     @param criteria 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2000     @param gids gid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2001     @return 0 success
2002 aga 1.5 */
2003 youi 1.21 ZEND_FUNCTION(xnp_dump_gids)
2004 aga 1.2 {
2005     result_t result;
2006     long sid;
2007     zval *zcriteria;
2008     zval *zgids;
2009 youi 1.24
2010 aga 1.2 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "laa",
2011     &sid, &zcriteria, &zgids) == FAILURE) {
2012     return;
2013     }
2014 youi 1.24
2015 aga 1.2 zCriteria_t zcri(zcriteria);
2016     result = zcri.getResult();
2017     if ( RES_OK == result ){
2018     groupid_t *pgid;
2019     int gidLen;
2020     result = dumpGids( (sessionid_t)sid, &zcri, &pgid, &gidLen );
2021     if ( RES_OK == result ){
2022     gidsToZval( pgid, gidLen, &zgids );
2023 youi 1.19 freeGID( pgid );
2024 aga 1.1 }
2025     }
2026 youi 1.24
2027     RETURN_LONG(result);
2028 aga 1.1 }
2029 aga 1.8
2030     /** gid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
2031 youi 1.24 int xnp_dump_group_admins(int sid, int group_id, array criteria, array uids )
2032     @param sid XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2033     @param group_id XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2034     @param criteria 鐃緒申鐃緒申
2035     @param uids uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2036     @return 0 success
2037 aga 1.8 */
2038    
2039 youi 1.21 ZEND_FUNCTION(xnp_dump_group_admins)
2040 aga 1.8 {
2041     long sid, gid;
2042     zval *zcriteria;
2043     zval *zuids;
2044 youi 1.24
2045     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "llaa",
2046     &sid, &gid, &zcriteria, &zuids) == FAILURE) {
2047 aga 1.8 return;
2048     }
2049 youi 1.24
2050 aga 1.8 zCriteria_t zcri(zcriteria);
2051     result_t result = zcri.getResult();
2052     if ( result == RES_OK ){
2053     userid_t *uids;
2054     int uidsLen;
2055     result = dumpGroupAdmins( sid, gid, &zcri, &uids, &uidsLen );
2056     if ( result == RES_OK ){
2057     uidsToZval( uids, uidsLen, &zuids );
2058 youi 1.19 freeUID( uids );
2059 aga 1.8 }
2060     }
2061     RETURN_LONG( result );
2062     }
2063    
2064 aga 1.11 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
2065 youi 1.24 int xnp_delete_member(int sid, int group_id, int user_id )
2066     @param sid XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2067     @param group_id XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2068     @param user_id 鐃緒申鐃緒申鐃緒申ID
2069     @return 0 success
2070 aga 1.11 */
2071    
2072 youi 1.21 ZEND_FUNCTION(xnp_delete_member)
2073 aga 1.11 {
2074     long sid, gid, uid;
2075 youi 1.24
2076     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lll",
2077     &sid, &gid, &uid) == FAILURE) {
2078 aga 1.11 return;
2079     }
2080 youi 1.24
2081 aga 1.11 result_t result = deleteMember( (sessionid_t)sid, (groupid_t)gid, (userid_t)uid );
2082     RETURN_LONG( result );
2083     }
2084    
2085     /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
2086 youi 1.24 int xnp_insert_member(int sid, int group_id, int user_id, bool admin )
2087     @param sid XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2088     @param group_id XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2089     @param user_id 鐃緒申鐃緒申鐃緒申ID
2090     @param admin 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申true
2091     @return 0 success
2092 aga 1.11 */
2093    
2094 youi 1.21 ZEND_FUNCTION(xnp_insert_member)
2095 aga 1.11 {
2096     long sid, gid, uid;
2097     zend_bool admin;
2098 youi 1.24
2099     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lllb",
2100     &sid, &gid, &uid, &admin) == FAILURE) {
2101 aga 1.11 return;
2102     }
2103 youi 1.24
2104 aga 1.11 result_t result = insertMember( (sessionid_t)sid, (groupid_t)gid, (userid_t)uid, (bool)admin );
2105     RETURN_LONG( result );
2106     }
2107    
2108     /** gid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
2109 youi 1.24 int xnp_get_members(int sid, int group_id, array criteria, array uids )
2110     @param sid XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2111     @param group_id XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2112     @param criteria 鐃緒申鐃緒申
2113     @param uids uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2114     @return 0 success
2115 aga 1.11 */
2116    
2117 youi 1.21 ZEND_FUNCTION(xnp_get_members)
2118 aga 1.11 {
2119     long sid, gid;
2120     zval *zcriteria;
2121     zval *zuids;
2122 youi 1.24
2123     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "llaa",
2124     &sid, &gid, &zcriteria, &zuids) == FAILURE) {
2125 aga 1.11 return;
2126     }
2127 youi 1.24
2128 aga 1.11 zCriteria_t zcri(zcriteria);
2129     result_t result = zcri.getResult();
2130     if ( result == RES_OK ){
2131     userid_t *uids;
2132     int uidsLen;
2133     result = getMembers( (sessionid_t)sid, (groupid_t)gid, &zcri, &uids, &uidsLen );
2134     if ( result == RES_OK ){
2135     uidsToZval( uids, uidsLen, &zuids );
2136 youi 1.19 freeUID( uids );
2137 aga 1.11 }
2138     }
2139     RETURN_LONG( result );
2140     }
2141 youi 1.7
2142     /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
2143 youi 1.24 int xnp_update_group(int sid, array group )
2144     @param sid XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2145     @param group 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2146     @return 0 success
2147 youi 1.7 */
2148 youi 1.21 ZEND_FUNCTION(xnp_update_group)
2149 youi 1.7 {
2150     long sid;
2151     zval *zgroup;
2152 youi 1.24 group_t group;
2153    
2154     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "la",
2155     &sid, &zgroup) == FAILURE) {
2156 youi 1.7 return;
2157     }
2158 youi 1.24
2159     zvalToGroup( zgroup, &group );
2160     result_t result = updateGroup( sid, &group );
2161     RETURN_LONG( result );
2162 aga 1.10 }
2163    
2164 youi 1.12 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
2165 youi 1.24 int xnp_insert_group( int sid, array group, int &gid )
2166     @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2167     @param group 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2168     @param gid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2169     @return RES_OK
2170     @return RES_DB_NOT_INITIALIZED
2171     @return RES_NO_SUCH_SESSION
2172     @return RES_DB_QUERY_ERROR
2173 youi 1.12 */
2174 youi 1.21 ZEND_FUNCTION(xnp_insert_group)
2175 youi 1.12 {
2176     long sid;
2177     zval *zgroup;
2178 youi 1.24 zval *zgid;
2179     group_t group;
2180     groupid_t gid;
2181    
2182     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "laz",
2183     &sid, &zgroup, &zgid ) == FAILURE) {
2184 youi 1.12 return;
2185     }
2186 youi 1.24
2187     zvalToGroup( zgroup, &group );
2188     result_t result = insertGroup( sid, &group, &gid );
2189     zgid -> type = IS_LONG;
2190     zgid -> value.lval = gid;
2191     RETURN_LONG( result );
2192 youi 1.12 }
2193    
2194    
2195     /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
2196 youi 1.24 int xnp_delete_group( int sid, int gid )
2197     @param sid XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2198     @param gid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2199     @return RES_OK
2200     @return RES_DB_QUERY_ERROR
2201     @return RES_NO_SUCH_SESSION
2202     @return RES_DB_NOT_INITIALIZED
2203 youi 1.12 */
2204 youi 1.21 ZEND_FUNCTION(xnp_delete_group)
2205 youi 1.12 {
2206     long sid;
2207     long gid;
2208 youi 1.24
2209     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll",
2210     &sid, &gid) == FAILURE) {
2211 youi 1.12 return;
2212     }
2213 youi 1.24 RETURN_LONG( deleteGroup( sid, gid ) );
2214 youi 1.12 }
2215    
2216     /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
2217 youi 1.24 int xnp_dump_group_admins( int sid, int gid, array criteria, array uids )
2218     @param sid XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2219     @param gid XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2220     @param criteria uids鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2221     @param uids 鐃緒申鐃緒申鐃緒申鐃緒申UID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2222     @return RES_OK
2223     @return RES_DB_QUERY_ERROR
2224     @return RES_NO_SUCH_SESSION
2225     @return RES_DB_NOT_INITIALIZED
2226 youi 1.12 */
2227     /*
2228 youi 1.21 ZEND_FUNCTION(xnp_dump_group_admins)
2229 youi 1.12 {
2230     long sid;
2231     long gid;
2232     zval *zcriteria;
2233     zval *zuids;
2234 youi 1.24
2235     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "llaa",
2236     &sid, &gid, &zcriteria, &zuids) == FAILURE) {
2237 youi 1.12 return;
2238     }
2239     zCriteria_t zcri(zcriteria);
2240     result_t result = zcri.getResult();
2241     if ( RES_OK == result ){
2242 youi 1.24 userid_t* uids;
2243     int uidsLen;
2244     result_t result = dumpGroupAdmins( sid, gid, &zcri, &uids, &uidsLen );
2245     if( result != RES_OK ) RETURN_LONG( result );
2246     uidsToZval( uids, uidsLen, &zuids );
2247     fprintf( stderr, "uidsLen=%d\n", uidsLen );
2248     for( int i = 0; i < uidsLen; i++ ){
2249     fprintf( stderr, "%d, \n", uids[ i ] );
2250     }
2251     freeUID( uids );
2252     RETURN_LONG( result );
2253     }
2254     RETURN_LONG( result );
2255 youi 1.12 }
2256     */
2257 aga 1.22
2258     /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
2259     * int xnp_get_all_indexes( int sid, array criteria, array indexes );
2260     * @param sid XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2261     * @param cri 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2262     * @return RES_OK
2263     */
2264     ZEND_FUNCTION(xnp_get_all_indexes)
2265     {
2266     long sid;
2267     zval *zcriteria;
2268     zval *zindexes;
2269 youi 1.24
2270     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "laa",
2271     &sid, &zcriteria, &zindexes) == FAILURE) {
2272 aga 1.22 return;
2273     }
2274     zCriteria_t zcri(zcriteria);
2275     result_t result = zcri.getResult();
2276     if ( RES_OK == result ){
2277     const index_t *indexes;
2278     int indexesLen;
2279     result = getAllIndexes( sid, &zcri, &indexes, &indexesLen );
2280     if ( RES_OK == result ){
2281     result = indexesToZval( indexes, indexesLen, zindexes );
2282     freeIndex( indexes );
2283     }
2284     }
2285     RETURN_LONG(result);
2286     }
2287    
2288     /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
2289     * int xnp_get_indexes( int sid, int parentXID, array criteria, array indexes );
2290     * @param sid XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2291     * @param parentXID 鐃緒申鐃緒申indexID
2292     * @param cri 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2293     * @param indexes 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2294     * @return RES_OK
2295     */
2296     ZEND_FUNCTION(xnp_get_indexes)
2297     {
2298     long sid;
2299     long parentXID;
2300     zval *zcriteria;
2301     zval *zindexes;
2302 youi 1.24
2303     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "llaa",
2304     &sid, &parentXID, &zcriteria, &zindexes) == FAILURE) {
2305 aga 1.22 return;
2306     }
2307     zCriteria_t zcri(zcriteria);
2308     result_t result = zcri.getResult();
2309     if ( RES_OK == result ){
2310     const index_t *indexes;
2311     int indexesLen;
2312     result = getIndexes( sid, parentXID, &zcri, &indexes, &indexesLen );
2313     if ( RES_OK == result ){
2314     result = indexesToZval( indexes, indexesLen, zindexes );
2315     freeIndex( indexes );
2316     }
2317     }
2318     RETURN_LONG(result);
2319     }
2320    
2321    
2322     /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
2323     * int xnp_insert_index( int sid, array index, int &indexID );
2324     * @param sid XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2325     * @param index 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2326     * @param indexID 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2327     * @return RES_OK
2328     */
2329     ZEND_FUNCTION(xnp_insert_index)
2330     {
2331     long sid;
2332     zval *zindex;
2333     zval *zIndexID;
2334 youi 1.24
2335     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "laz",
2336     &sid, &zindex, &zIndexID) == FAILURE) {
2337 aga 1.22 return;
2338     }
2339 youi 1.24
2340 aga 1.22 if (!PZVAL_IS_REF(zIndexID)) {
2341     zend_error(E_WARNING, "3rd parameter wasn't passed by reference");