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