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