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