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