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