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