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