Develop and Download Open Source Software

XooNIps

Browse CVS Repository

/[OSDN]/xoonips/AL/xnpal.cc

Contents of /xoonips/AL/xnpal.cc

Parent Directory Parent Directory | Revision Log Revision Log | View Revision Graph Revision Graph

Revision 1.53 - (show annotations) (download) (as text)
Tue Aug 23 07:35:33 2005 UTC (18 years, 7 months ago) by tani
Branch: MAIN
Changes since 1.52: +7 -1 lines
File MIME type: text/x-c++src 
Languag対応.
1 /*
2 * --------------------------------------------------------------------------
3 * XooNiPs Xoops modules for Neuroinformatics Platforms
4 * Copyright (C) 2005 RIKEN, Japan. All rights reserved.
5 * http://sourceforge.jp/projects/xoonips/
6 * --------------------------------------------------------------------------
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version 2
10 * of the License, or (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20 * --------------------------------------------------------------------------
21 *
22 * $Revision: 1.52 $
23 * XNPAL: XooNiPs Platform Abstract Layer
24 * zend_parse_parameters鐃緒申php4.1.0鐃緒申鐃緒申鐃緒申
25 * .so鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
26 * C++鐃緒申鐃緒申鐃緒申extern "C"{}, BEGIN/END_EXTERN_C()鐃緒申鐃緒申鐃緒申鐃緒申
27 */
28
29
30 #include <stdio.h>
31 #include "criteria.h"
32 #include "common.h"
33 #include "commonal.h"
34 #include "session.h"
35 #include "group.h"
36 #include "index.h"
37 #include "xnpal.h"
38 #include "amazonbook.h"
39
40 // for inet_aton
41 #include <sys/socket.h>
42 #include <netinet/in.h>
43 #include <arpa/inet.h>
44
45 // global variables
46
47 PHP_MSHUTDOWN_FUNCTION(xnpalmod)
48 {
49 uninitializeDB();
50 return SUCCESS;
51 }
52
53 /* declaration of functions to be exported */
54 extern "C" {
55 ZEND_FUNCTION(first_module );
56 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
86 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 ZEND_FUNCTION(xnp_is_valid_session_id );
97 ZEND_FUNCTION(xnp_get_last_error_string );
98
99 ZEND_FUNCTION(xnp_test_criteria );
100 ZEND_FUNCTION(xnp_test_uids );
101
102
103 ZEND_FUNCTION(xnp_get_item_permission );
104 ZEND_FUNCTION(xnp_get_index_permission );
105 ZEND_FUNCTION(xnp_get_certify_permission );
106
107 ZEND_FUNCTION(xnp_get_certify_state );
108 ZEND_FUNCTION(xnp_set_certify_state );
109
110 ZEND_FUNCTION(xnp_insert_change_log );
111 ZEND_FUNCTION(xnp_get_change_logs );
112
113 ZEND_FUNCTION(xnp_get_config_value );
114 ZEND_FUNCTION(xnp_set_config_value );
115
116 ZEND_FUNCTION(xnp_dump_item_id );
117 ZEND_FUNCTION(xnp_get_item_id_by_binder_id );
118 ZEND_FUNCTION(xnp_get_item_id_by_index_id );
119 ZEND_FUNCTION(xnp_get_overlapped_items );
120
121 ZEND_FUNCTION(xnp_insert_item );
122 ZEND_FUNCTION(xnp_insert_item_direct );
123 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 ZEND_FUNCTION(xnp_get_uncertified_link );
140 ZEND_FUNCTION(xnp_get_private_item_id );
141 ZEND_FUNCTION(xnp_get_group_item_id );
142
143 ZEND_FUNCTION(xnp_get_item_types );
144 ZEND_FUNCTION(xnp_get_index_id_by_item_id );
145 ZEND_FUNCTION(xnp_get_own_public_item_id );
146
147 ZEND_FUNCTION(xnp_zip_create );
148 ZEND_FUNCTION(xnp_get_item_count );
149 ZEND_FUNCTION(xnp_get_item_count_group_by_index );
150
151 ZEND_FUNCTION(xnp_extract_public_item_id);
152 ZEND_FUNCTION(xnp_extract_nonbinder_item_id);
153 ZEND_FUNCTION(xnp_insert_event);
154 ZEND_FUNCTION(xnp_get_events);
155 ZEND_FUNCTION(xnp_get_events_for_rss);
156 };
157
158
159 #ifdef ZEND_ENGINE_2
160 static
161 ZEND_BEGIN_ARG_INFO(second_and_third_args_force_ref, 0)
162 ZEND_ARG_PASS_INFO(0)
163 ZEND_ARG_PASS_INFO(1)
164 ZEND_ARG_PASS_INFO(1)
165 ZEND_END_ARG_INFO();
166 #else
167 static unsigned char fourth_arg_force_ref[] = { 4, BYREF_NONE, BYREF_NONE, BYREF_NONE, BYREF_FORCE };
168 static unsigned char second_and_third_args_force_ref[] = { 3, BYREF_NONE, BYREF_FORCE, BYREF_FORCE };
169 #endif
170
171
172 /* compiled function list so Zend knows what's in this module */
173 zend_function_entry xnpalmod_functions[] =
174 {
175 ZEND_FE(first_module ,NULL)
176 ZEND_FE(xnp_initialize_db ,NULL)
177 ZEND_FE(xnp_login_user ,third_arg_force_ref)
178 ZEND_FE(xnp_logout_user ,NULL)
179 ZEND_FE(xnp_create_session ,third_arg_force_ref)
180 ZEND_FE(xnp_get_session ,second_arg_force_ref )
181 ZEND_FE(xnp_is_activated ,NULL)
182 ZEND_FE(xnp_activate ,NULL)
183 ZEND_FE(xnp_get_account_count ,NULL)
184 ZEND_FE(xnp_delete_account ,NULL)
185 ZEND_FE(xnp_get_account ,third_arg_force_ref)
186 ZEND_FE(xnp_get_accounts ,fourth_arg_force_ref)
187 ZEND_FE(xnp_insert_account ,third_arg_force_ref)
188 ZEND_FE(xnp_update_account ,NULL)
189 ZEND_FE(xnp_dump_uids ,third_arg_force_ref)
190 ZEND_FE(xnp_get_group_count ,NULL)
191 ZEND_FE(xnp_get_groups_by_uid ,fourth_arg_force_ref)
192 ZEND_FE(xnp_is_group_admin ,NULL)
193 ZEND_FE(xnp_dump_gids ,third_arg_force_ref)
194 ZEND_FE(xnp_dump_group_admins ,NULL)
195 ZEND_FE(xnp_delete_member ,NULL)
196 ZEND_FE(xnp_insert_member ,NULL)
197 ZEND_FE(xnp_get_members ,fourth_arg_force_ref)
198 ZEND_FE(xnp_delete_group ,NULL)
199 ZEND_FE(xnp_insert_group ,third_arg_force_ref)
200 ZEND_FE(xnp_update_group ,NULL)
201 ZEND_FE(xnp_get_group ,third_arg_force_ref)
202 ZEND_FE(xnp_get_groups ,fourth_arg_force_ref)
203 ZEND_FE(xnp_is_moderator ,NULL)
204 ZEND_FE(xnp_get_uid ,second_arg_force_ref)
205
206 ZEND_FE(xnp_get_all_indexes ,third_arg_force_ref)
207 ZEND_FE(xnp_get_indexes ,fourth_arg_force_ref)
208 ZEND_FE(xnp_insert_index ,third_arg_force_ref)
209 ZEND_FE(xnp_update_index ,NULL)
210 ZEND_FE(xnp_delete_index ,NULL)
211 ZEND_FE(xnp_get_index ,third_arg_force_ref)
212 ZEND_FE(xnp_is_index_readable ,NULL)
213 ZEND_FE(xnp_is_index_writable ,NULL)
214 ZEND_FE(xnp_swap_index_sort_number ,NULL)
215
216 ZEND_FE(xnp_is_valid_session_id ,NULL)
217 ZEND_FE(xnp_get_last_error_string ,NULL)
218 ZEND_FE(xnp_test_criteria ,NULL)
219 ZEND_FE(xnp_test_uids ,NULL)
220
221 ZEND_FE(xnp_get_item_permission ,NULL)
222 ZEND_FE(xnp_get_index_permission ,NULL)
223 ZEND_FE(xnp_get_certify_permission ,NULL)
224
225 ZEND_FE(xnp_get_certify_state ,fourth_arg_force_ref)
226 ZEND_FE(xnp_set_certify_state ,NULL)
227
228 ZEND_FE(xnp_insert_change_log ,NULL)
229 ZEND_FE(xnp_get_change_logs ,third_arg_force_ref)
230
231 ZEND_FE(xnp_get_config_value ,second_arg_force_ref)
232 ZEND_FE(xnp_set_config_value ,NULL)
233
234 ZEND_FE(xnp_dump_item_id ,NULL)
235 ZEND_FE(xnp_get_item_id_by_binder_id ,fourth_arg_force_ref)
236 ZEND_FE(xnp_get_item_id_by_index_id ,fourth_arg_force_ref)
237 ZEND_FE(xnp_get_overlapped_items ,NULL) /*?*/
238
239 ZEND_FE(xnp_insert_item ,third_arg_force_ref)
240 ZEND_FE(xnp_insert_item_direct ,third_arg_force_ref)
241 ZEND_FE(xnp_update_item ,NULL)
242 ZEND_FE(xnp_delete_item ,NULL)
243 ZEND_FE(xnp_get_item ,third_arg_force_ref)
244 ZEND_FE(xnp_get_items ,fourth_arg_force_ref)
245
246 ZEND_FE(xnp_pubmed_complete ,second_arg_force_ref)
247 ZEND_FE(xnp_amazon_complete ,second_arg_force_ref)
248
249 // ZEND_FE(xnp_uninitialize_db ,NULL)
250
251 ZEND_FE(xnp_register_binder_item ,NULL)
252 ZEND_FE(xnp_unregister_binder_item ,NULL)
253
254 ZEND_FE(xnp_register_item ,NULL)
255 ZEND_FE(xnp_unregister_item ,NULL)
256
257 ZEND_FE(xnp_get_uncertified_link ,second_and_third_args_force_ref)
258 ZEND_FE(xnp_get_private_item_id ,third_arg_force_ref)
259 ZEND_FE(xnp_get_group_item_id ,third_arg_force_ref)
260
261 ZEND_FE(xnp_get_item_types ,first_arg_force_ref)
262
263 ZEND_FE(xnp_get_index_id_by_item_id ,third_arg_force_ref)
264 ZEND_FE(xnp_get_own_public_item_id ,third_arg_force_ref)
265
266 ZEND_FE(xnp_zip_create ,NULL)
267 ZEND_FE(xnp_get_item_count ,NULL)
268 ZEND_FE(xnp_get_item_count_group_by_index ,second_arg_force_ref)
269
270 ZEND_FE(xnp_extract_public_item_id ,third_arg_force_ref)
271 ZEND_FE(xnp_extract_nonbinder_item_id,third_arg_force_ref)
272 ZEND_FE(xnp_insert_event ,NULL)
273 ZEND_FE(xnp_get_events ,second_arg_force_ref)
274 ZEND_FE(xnp_get_events_for_rss ,NULL)
275 {NULL, NULL, NULL}
276 };
277
278 /* compiled module information */
279 zend_module_entry xnpalmod_module_entry =
280 {
281 STANDARD_MODULE_HEADER,
282 "XooNIps Abstract Layer",
283 xnpalmod_functions,
284 NULL,
285 PHP_MSHUTDOWN(xnpalmod),
286 NULL,
287 NULL,
288 NULL,
289 NO_VERSION_YET,
290 STANDARD_MODULE_PROPERTIES
291 };
292
293 /* implement standard "stub" routine to introduce ourselves to Zend */
294 #if COMPILE_DL_FIRST_MODULE
295 BEGIN_EXTERN_C()
296 ZEND_GET_MODULE(xnpalmod)
297 END_EXTERN_C()
298 #endif
299
300
301 /* implement function that is meant to be made available to PHP */
302 ZEND_FUNCTION(first_module)
303 {
304 long parameter;
305 // if(ZEND_NUM_ARGS() != 2) WRONG_PARAM_COUNT;
306 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &parameter) == FAILURE) {
307 return;
308 }
309 parameter++;
310 RETURN_LONG(parameter);
311 }
312 /** zval鐃緒申鐃緒申C鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
313 */
314 char *getZvalString( zval **p ){
315 convert_to_string_ex(p);
316 return Z_STRVAL_PP(p); //(**p).value.str.val;
317 }
318
319 /** zval鐃緒申鐃緒申int鐃緒申鐃緒申鐃緒申鐃緒申
320 */
321 int getZvalInt( zval **p ){
322 convert_to_long_ex(p);
323 return Z_LVAL_PP(p); // (int)(**p).value.lval;
324 }
325
326 // keylen鐃緒申鐃緒申鐃緒申鐃緒申\0鐃緒申鐃緒申鐃緒申鐃緒申
327 static void print_hash_key( int res, const char *key, uint keyLen, ulong index ){
328 zend_printf( "print_hash_key : key=0x%08x keylen=%08d index=%08d<br> ", key, keyLen, index );
329 if ( res == HASH_KEY_IS_STRING ){
330 char *p = new char[keyLen+1];
331 memcpy( p, key, keyLen );
332 p[keyLen] = 0;
333 zend_printf( " key is string[%s]<br>\n", p );
334 }
335 else {
336 zend_printf( " key is integer[%d]<br>\n", index );
337 }
338 }
339
340
341 /** zval*鐃緒申鐃緒申criteria_t鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申getResult()!=RES_OK <br>
342 criteria :
343 array( 'start'=>0, 'rows'=>10,
344 'orders'=>array(
345 array('name'=>'id','order'=>'0'),
346 array('name'=>'timestamp','name'=>'1'), ...)
347 ); 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
348 */
349 class zCriteria_t : public criteria {
350 private:
351 result_t result;
352
353 // pz: array('name'=>'timestamp','name'=>'1')
354 // 鐃緒申鐃緒申鐃緒申鐃緒申orderby鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
355 void setOrder( zval *pz ){
356 char *column = 0;
357 order_t order = (order_t)0;
358
359 HashPosition pos;
360 zval **ppzTmp = 0;
361 int res2;
362 zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(pz), &pos);
363 while ( (res2=zend_hash_get_current_data_ex(Z_ARRVAL_P(pz), (void **)&ppzTmp, &pos)) == SUCCESS ) {
364 char *key = 0;
365 uint keyLen = 0;
366 ulong index = 0;
367 int keyType = zend_hash_get_current_key_ex(Z_ARRVAL_P(pz), &key, &keyLen, &index, false/*duplicate flag*/, &pos );
368 if ( keyType == HASH_KEY_IS_STRING/*1*/ || keyType == HASH_KEY_IS_LONG/*2*/ ){
369 //print_hash_key( keyType, key, keyLen, index );
370 if ( strncasecmp( key, "name", keyLen ) == 0 && keyLen == 5 ){
371 SEPARATE_ZVAL(ppzTmp);
372 column = getZvalString(ppzTmp);
373 // zend_printf( "column=%s<br>\n", column );
374 }
375 else if ( strncasecmp( key, "order", keyLen ) == 0 && keyLen == 6 ){
376 SEPARATE_ZVAL(ppzTmp);
377 order = (order_t)getZvalInt(ppzTmp);
378 // zend_printf( "order=%d<br>\n", order );
379 }
380 }
381
382 zend_hash_move_forward_ex(Z_ARRVAL_P(pz), &pos);
383 }
384 if ( column ){
385 orderby *o = new orderby( column, order );
386 addOrderBy( o );
387 }
388
389 result = RES_OK;
390 }
391
392 // pz: array( array('column'=>'hoge','order'=>'1'), array('column'=>'huga','order'=>'2'), ...)
393 void setOrders( zval *pz ){
394 HashPosition pos;
395
396 zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(pz), &pos);
397
398 zval **ppzTmp = 0;
399 int res2;
400 while ( (res2=zend_hash_get_current_data_ex(Z_ARRVAL_P(pz), (void **)&ppzTmp, &pos)) == SUCCESS ) {
401 char *key = 0;
402 uint keyLen = 0;
403 ulong index = 0;
404 int keyType = zend_hash_get_current_key_ex(Z_ARRVAL_P(pz), &key, &keyLen, &index, false/*duplicate flag*/, &pos );
405 if ( keyType == HASH_KEY_IS_STRING/*1*/ || keyType == HASH_KEY_IS_LONG/*2*/ ){
406 //print_hash_key( keyType, key, keyLen, index );
407 setOrder( *ppzTmp );
408 }
409 zend_hash_move_forward_ex(Z_ARRVAL_P(pz), &pos);
410 }
411 result = RES_OK;
412 }
413
414 void initialize( zval *pz ){
415 HashPosition pos;
416 zval **ppzTmp = 0;
417 int res2;
418 zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(pz), &pos);
419 while ( (res2=zend_hash_get_current_data_ex(Z_ARRVAL_P(pz), (void **)&ppzTmp, &pos)) == SUCCESS ) {
420 char *key = 0;
421 uint keyLen = 0;
422 ulong index = 0;
423 int keyType = zend_hash_get_current_key_ex(Z_ARRVAL_P(pz), &key, &keyLen, &index, false/*duplicate flag*/, &pos );
424 if ( keyType == HASH_KEY_IS_STRING/*1*/ || keyType == HASH_KEY_IS_LONG/*2*/ ){
425 //print_hash_key( keyType, key, keyLen, index );
426 if ( strncasecmp( key, "start", keyLen ) == 0 && keyLen == 6 ){
427 SEPARATE_ZVAL(ppzTmp);
428 int tmp = getZvalInt(ppzTmp);
429 // zend_printf( "start=%d<br>\n", tmp );
430 setLimit( tmp, getLimitRows() );
431 }
432 else if ( strncasecmp( key, "rows", keyLen ) == 0 && keyLen == 5 ){
433 SEPARATE_ZVAL(ppzTmp);
434 int tmp = getZvalInt(ppzTmp);
435 // zend_printf( "rows=%d<br>\n", tmp );
436 setLimit( getLimitStart(), tmp );
437 }
438 else if ( strncasecmp( key, "orders", keyLen ) == 0 && keyLen == 7 ){
439 setOrders( *ppzTmp );
440 }
441 else
442 ; // ignore unknown key
443 }
444 else
445 ; // ignore bad key
446 zend_hash_move_forward_ex(Z_ARRVAL_P(pz), &pos);
447 }
448 result = RES_OK;
449 }
450
451 public:
452 zCriteria_t() : criteria(){ result = RES_ERROR; }
453 zCriteria_t( zval *pz ) : criteria(){ initialize(pz); }
454 zCriteria_t( zval **ppz ) : criteria() { initialize(*ppz); }
455 result_t getResult(){ return result; };
456
457 void dump(){
458 zend_printf( "dumping zCriteria...<br>\n" );
459 zend_printf( "result=%d<br>\n", (int)result );
460 zend_printf( "start=%d, rows=%d<br>\n", getLimitStart(), getLimitRows() );
461 const orderby *p = headOrderBy();
462 while ( p ){
463 zend_printf( "column=%s, order=%d<br>\n", p->getColumn(), p->getOrder() );
464 p = nextOrderBy();
465 }
466 }
467 };
468
469
470 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申long鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
471 @param ht 鐃緒申鐃緒申鐃緒申鐃緒申
472 @param key 鐃緒申鐃緒申
473 @param val long鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
474 @return 鐃緒申鐃緒申鐃緒申鐃緒申true
475 */
476 static bool hashGetLong( HashTable *ht, const char *key, long *val ){
477 zval **tmp;
478 if( zend_hash_find( ht, (char *)key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
479 convert_to_long_ex( tmp );
480 *val = Z_LVAL_PP(tmp);
481 return true;
482 }
483 return false;
484 }
485
486 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
487 @param ht 鐃緒申鐃緒申鐃緒申鐃緒申
488 @param key 鐃緒申鐃緒申
489 @param val 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
490 @return 鐃緒申鐃緒申鐃緒申鐃緒申true
491 */
492 static bool hashGetString( HashTable *ht, const char *key, char **val ){
493 zval **tmp;
494 if( zend_hash_find( ht, (char *)key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
495 convert_to_string_ex( tmp );
496 *val = Z_STRVAL_PP(tmp);
497 return true;
498 }
499 return false;
500 }
501
502 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申double鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
503 @param ht 鐃緒申鐃緒申鐃緒申鐃緒申
504 @param key 鐃緒申鐃緒申
505 @param val double鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
506 @return 鐃緒申鐃緒申鐃緒申鐃緒申true
507 */
508 static bool hashGetDouble( HashTable *ht, const char *key, double *val ){
509 zval **tmp;
510 if( zend_hash_find( ht, (char *)key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
511 convert_to_double_ex( tmp );
512 *val = Z_DVAL_PP(tmp);
513 return true;
514 }
515 return false;
516 }
517
518 /** zval*鐃緒申鐃緒申account鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申 <br>
519 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申getResult()!=RES_OK <br>
520 */
521 class zAccount_t : public account {
522 private:
523 result_t result;
524 void initialize(zval *pz){
525 HashTable *ht = Z_ARRVAL_P(pz);
526 long l;
527 char *p;
528 double d;
529 if ( hashGetLong ( ht, "uid" , &l ) ) setUID ( l );
530 if ( hashGetString( ht, "uname" , &p ) ) setUname ( p );
531 if ( hashGetString( ht, "name" , &p ) ) setName ( p );
532 if ( hashGetString( ht, "email" , &p ) ) setEmail ( p );
533 if ( hashGetString( ht, "url" , &p ) ) setURL ( p );
534 if ( hashGetString( ht, "user_avatar" , &p ) ) setUserAvatar ( p );
535 if ( hashGetString( ht, "user_icq" , &p ) ) setUserIcq ( p );
536 if ( hashGetString( ht, "user_from" , &p ) ) setUserFrom ( p );
537 if ( hashGetString( ht, "user_sig" , &p ) ) setUserSig ( p );
538 if ( hashGetString( ht, "actkey" , &p ) ) setActkey ( p );
539 if ( hashGetString( ht, "user_aim" , &p ) ) setUserAim ( p );
540 if ( hashGetString( ht, "user_yim" , &p ) ) setUserYim ( p );
541 if ( hashGetString( ht, "user_msnm" , &p ) ) setUserMsnm ( p );
542 if ( hashGetString( ht, "pass" , &p ) ) setPass ( p );
543 if ( hashGetString( ht, "theme" , &p ) ) setTheme ( p );
544 if ( hashGetString( ht, "umode" , &p ) ) setUmode ( p );
545 if ( hashGetString( ht, "user_occ" , &p ) ) setUserOcc ( p );
546 if ( hashGetString( ht, "bio" , &p ) ) setBio ( p );
547 if ( hashGetString( ht, "user_intrest" , &p ) ) setUserIntrest ( p );
548 if ( hashGetDouble( ht, "timezone_offset" , &d ) ) setTimezoneOffset ( d );
549 if ( hashGetLong ( ht, "attachsig" , &l ) ) setAttachsig ( l );
550 if ( hashGetLong ( ht, "last_login" , &l ) ) setLastLogin ( l );
551 if ( hashGetLong ( ht, "level" , &l ) ) setLevel ( l );
552 if ( hashGetLong ( ht, "notify_method" , &l ) ) setNotifyMethod ( l );
553 if ( hashGetLong ( ht, "notify_mode" , &l ) ) setNotifyMode ( l );
554 if ( hashGetLong ( ht, "posts" , &l ) ) setPosts ( l );
555 if ( hashGetLong ( ht, "rank" , &l ) ) setRank ( l );
556 if ( hashGetLong ( ht, "uorder" , &l ) ) setUorder ( l );
557 if ( hashGetLong ( ht, "user_mailok" , &l ) ) setUserMailok ( l );
558 if ( hashGetLong ( ht, "user_regdate" , &l ) ) setUserRegdate ( l );
559 if ( hashGetLong ( ht, "user_viewemail" , &l ) ) setUserViewemail ( l );
560 if ( hashGetLong ( ht, "activate" , &l ) ) setActivate ( l );
561 if ( hashGetString( ht, "address" , &p ) ) setAddress ( p );
562 if ( hashGetString( ht, "division" , &p ) ) setDivision ( p );
563 if ( hashGetString( ht, "tel" , &p ) ) setTel ( p );
564 if ( hashGetString( ht, "company_name" , &p ) ) setCompanyName ( p );
565 if ( hashGetString( ht, "country" , &p ) ) setCountry ( p );
566 if ( hashGetString( ht, "zipcode" , &p ) ) setZipcode ( p );
567 if ( hashGetString( ht, "fax" , &p ) ) setFax ( p );
568 if ( hashGetLong ( ht, "notice_mail" , &l ) ) setNoticeMail ( l );
569 if ( hashGetLong ( ht, "notice_mail_since" , &l ) ) setNoticeMailSince ( l );
570 if ( hashGetLong ( ht, "private_index_id " , &l ) ) setPrivateIndexID ( l );
571 if ( hashGetLong ( ht, "item_number_limit" , &l ) ) setItemNumberLimit ( l );
572 if ( hashGetLong ( ht, "index_number_limit", &l ) ) setIndexNumberLimit ( l );
573 if ( hashGetDouble( ht, "item_storage_limit", &d ) ) setItemStorageLimit ( d );
574
575 result = RES_OK;
576 }
577 public:
578 zAccount_t() : account(){ result = RES_ERROR; }
579
580 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
581 @param pz array( 'uid'=>1, 'uname'=>'root', ... ); 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申 */
582 zAccount_t( zval *pz ) : account(){ initialize(pz); }
583 zAccount_t( zval **ppz ) : account() { initialize(*ppz); }
584 result_t getResult(){ return result; };
585 };
586
587 class zIndex_t : public index {
588 private:
589 result_t result;
590
591 void initialize(zval *pz){
592 HashTable *ht = Z_ARRVAL_P(pz);
593 long l;
594 char *p;
595 if ( hashGetLong ( ht, "item_id" , &l ) ) setItemID ( l );
596 if ( hashGetLong ( ht, "item_type_id" , &l ) ) setItemTypeID ( l );
597 if ( hashGetLong ( ht, "contributor_uid" , &l ) ) setContributorUID ( l );
598 if ( hashGetString( ht, "title" , &p ) ) setTitle ( p );
599 if ( hashGetString( ht, "keywords" , &p ) ) setKeywords ( p );
600 if ( hashGetString( ht, "description" , &p ) ) setDescription ( p );
601 if ( hashGetLong ( ht, "last_update_date" , &l ) ) setLastUpdateDate ( l );
602 if ( hashGetLong ( ht, "creation_date" , &l ) ) setCreationDate ( l );
603 if ( hashGetLong ( ht, "parent_index_id" , &l ) ) setParentIndexID ( l );
604 if ( hashGetLong ( ht, "owner_uid" , &l ) ) setOwnerUID ( l );
605 if ( hashGetLong ( ht, "owner_gid" , &l ) ) setOwnerGID ( l );
606 if ( hashGetLong ( ht, "open_level" , &l ) ) setOpenLevel ( l );
607 if ( hashGetLong ( ht, "sort_number" , &l ) ) setSortNumber ( l );
608
609 result = RES_OK;
610 }
611 public:
612 zIndex_t() : index(){ result = RES_ERROR; }
613 zIndex_t( zval *pz ) : index(){ initialize(pz); }
614 zIndex_t( zval **ppz ) : index() { initialize(*ppz); }
615 result_t getResult(){ return result; };
616
617 void dump(){
618 }
619 };
620
621 /** zval*鐃緒申鐃緒申(userid_t *puid,int uidLen)鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申 <br>
622 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申getResult()!=RES_OK <br>
623 */
624 class zUIDs_t {
625 private:
626 result_t result;
627 userid_t *pUID;
628 int len;
629 public:
630 zUIDs_t(){
631 pUID = 0;
632 len = 0;
633 result = RES_ERROR;
634 }
635
636 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
637 @param pza array( '1', '3', '4', '6', ... ); 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申 */
638 zUIDs_t( zval *pza ){
639 pUID = 0;
640 len = 0;
641 result = RES_ERROR;
642
643 if ( Z_TYPE_P(pza) != IS_ARRAY ){
644 result = RES_ERROR;
645 }
646 else {
647 len = zend_hash_num_elements(Z_ARRVAL_P(pza));
648 if(len == 0) {
649 pUID = new userid_t[1];
650 result = RES_OK;
651 }
652 else {
653 /* php/ext/standard/string.c 鐃緒申 implode鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
654 zend_hash_*鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
655 */
656 zval **tmp;
657 HashPosition pos;
658 int i = 0;
659 pUID = new userid_t[len];
660
661 zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(pza), &pos);
662 while (zend_hash_get_current_data_ex(Z_ARRVAL_P(pza), (void **) &tmp, &pos) == SUCCESS ) {
663 SEPARATE_ZVAL(tmp); // zend.arguments.write-safety.html 鐃緒申鐃緒申
664 convert_to_long_ex(tmp);
665 if ( i < len )
666 pUID[i++] = Z_LVAL_PP(tmp);
667 zend_hash_move_forward_ex(Z_ARRVAL_P(pza), &pos);
668 }
669 len = i;
670 result = RES_OK;
671 }
672 }
673 }
674
675 ~zUIDs_t(){
676 if ( pUID ) delete[] pUID;
677 }
678 result_t getResult(){ return result; }
679 userid_t *getPUID(){ return pUID; }
680 int getLen(){ return len; }
681 void dump(){
682 zend_printf( "dumping zUIDs...<br>\n" );
683 zend_printf( "result=%d<br>\n", (int)result );
684 zend_printf( "len=%d<br>\n", len );
685 for ( int i = 0; i < len; i++ ){
686 zend_printf( "pUID[%d] = %d<br>\n", i, pUID[i] );
687 }
688 }
689 };
690
691 /** zval*鐃緒申鐃緒申(itemid_t *piid,int iidLen)鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申 <br>
692 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申getResult()!=RES_OK <br>
693 */
694 class zIIDs_t {
695 private:
696 result_t result;
697 itemid_t *pIID;
698 int len;
699 public:
700 zIIDs_t(){
701 pIID = 0;
702 len = 0;
703 result = RES_ERROR;
704 }
705
706 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
707 @param pza array( '1', '3', '4', '6', ... ); 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申 */
708 zIIDs_t( zval *pza ){
709 pIID = 0;
710 len = 0;
711 result = RES_ERROR;
712
713 if ( Z_TYPE_P(pza) != IS_ARRAY ){
714 result = RES_ERROR;
715 }
716 else {
717 len = zend_hash_num_elements(Z_ARRVAL_P(pza));
718 if(len == 0) {
719 pIID = new itemid_t[1];
720 result = RES_OK;
721 }
722 else {
723 /* php/ext/standard/string.c 鐃緒申 implode鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
724 zend_hash_*鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
725 */
726 zval **tmp;
727 HashPosition pos;
728 int i = 0;
729 pIID = new itemid_t[len];
730
731 zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(pza), &pos);
732 while (zend_hash_get_current_data_ex(Z_ARRVAL_P(pza), (void **) &tmp, &pos) == SUCCESS ) {
733 SEPARATE_ZVAL(tmp); // zend.arguments.write-safety.html 鐃緒申鐃緒申
734 convert_to_long_ex(tmp);
735 if ( i < len )
736 pIID[i++] = Z_LVAL_PP(tmp);
737 zend_hash_move_forward_ex(Z_ARRVAL_P(pza), &pos);
738 }
739 len = i;
740 result = RES_OK;
741 }
742 }
743 }
744
745 ~zIIDs_t(){
746 if ( pIID ) delete[] pIID;
747 }
748 result_t getResult(){ return result; }
749 itemid_t *getPIID(){ return pIID; }
750 int getLen(){ return len; }
751 void dump(){
752 zend_printf( "dumping zIIDs...<br>\n" );
753 zend_printf( "result=%d<br>\n", (int)result );
754 zend_printf( "len=%d<br>\n", len );
755 for ( int i = 0; i < len; i++ ){
756 zend_printf( "pIID[%d] = %d<br>\n", i, pIID[i] );
757 }
758 }
759 };
760
761 /**
762 *
763 * amazonbook_t鐃緒申鐃緒申鐃緒申鐃緒申PHP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
764 * @param pAmazonbook 鐃緒申鐃緒申鐃緒申鐃緒申amazonbook_t*
765 * @param z 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)
766 * @return RES_OK
767 *
768 */
769 result_t amazonbookToZval( const amazonbook_t *pAmazonbook, zval *z )
770 {
771 zend_hash_clean( z -> value.ht );
772
773 add_assoc_string( z, "title", ( char* )pAmazonbook -> getTitle( ), 1 );
774 add_assoc_string( z, "author", ( char* )pAmazonbook -> getAuthor( ), 1 );
775 add_assoc_string( z, "publisher", ( char* )pAmazonbook -> getPublisher( ), 1 );
776 add_assoc_long( z, "year_of_publication", pAmazonbook -> getYearOfPublication( ) );
777 add_assoc_string( z, "isbn", ( char* )pAmazonbook -> getISBN( ), 1 );
778 add_assoc_string( z, "url", ( char* )pAmazonbook -> getURL( ), 1 );
779
780 return RES_OK;
781 }
782
783 /**
784 *
785 * pubmed_t鐃緒申鐃緒申鐃緒申鐃緒申PHP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
786 * @param pPubmed 鐃緒申鐃緒申鐃緒申鐃緒申pubmed_t*
787 * @param z 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)
788 * @return RES_OK
789 *
790 */
791 result_t pubmedToZval( const pubmed_t *pPubmed, zval *z )
792 {
793 zend_hash_clean( z -> value.ht );
794
795 add_assoc_long( z, "pmid", pPubmed -> getID( ) );
796 add_assoc_string( z, "title", ( char* )pPubmed -> getTitle( ), 1 );
797 add_assoc_string( z, "author", ( char* )pPubmed -> getAuthor( ), 1 );
798 add_assoc_string( z, "journal", ( char* )pPubmed -> getJournal( ), 1 );
799 add_assoc_long( z, "year_of_publication", pPubmed -> getYearOfPublication( ) );
800 add_assoc_long( z, "volume", pPubmed -> getVolume( ) );
801 add_assoc_long( z, "number", pPubmed -> getNumber( ) );
802 add_assoc_string( z, "page", ( char* )pPubmed -> getPage( ), 1 );
803 add_assoc_string( z, "abstract", ( char* )pPubmed -> getAbstract( ), 1 );
804
805 return RES_OK;
806 }
807
808 /**
809 *
810 * itemid_t鐃緒申鐃緒申鐃緒申鐃緒申PHP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
811 * @param piid 鐃緒申鐃緒申鐃緒申鐃緒申itemid_t鐃緒申鐃緒申鐃緒申
812 * @param len piid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
813 * @param ppz 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)
814 * @return RES_OK
815 *
816 */
817 result_t itemidsToZval( const itemid_t *piid, int len, zval **ppz )
818 {
819 zend_hash_clean( Z_ARRVAL_PP(ppz) );
820
821 // add IDs
822 for ( int i = 0; i < len; i++ ){
823 add_next_index_long(*ppz, (long)(piid[i]) );
824 }
825
826 return RES_OK;
827 }
828
829 /**
830 *
831 * indexid_t鐃緒申鐃緒申鐃緒申鐃緒申PHP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
832 * @param piid 鐃緒申鐃緒申鐃緒申鐃緒申indexid_t鐃緒申鐃緒申鐃緒申
833 * @param len piid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
834 * @param ppz 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)
835 * @return RES_OK
836 *
837 */
838 result_t indexidsToZval( const indexid_t *piid, int len, zval **ppz )
839 {
840 zend_hash_clean( Z_ARRVAL_PP(ppz) );
841
842 // add IDs
843 for ( int i = 0; i < len; i++ ){
844 add_next_index_long(*ppz, (long)(piid[i]) );
845 }
846
847 return RES_OK;
848 }
849
850 /**
851 *
852 * uids_t鐃緒申鐃緒申鐃緒申鐃緒申PHP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
853 *
854 * @param pUID 鐃緒申鐃緒申鐃緒申鐃緒申userid_t鐃緒申鐃緒申鐃緒申
855 * @param len pUID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
856 * @param pz 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)
857 * @return RES_OK
858 *
859 */
860 result_t uidsToZval( userid_t *pUID, int len, zval **ppz )
861 {
862 zend_hash_clean( Z_ARRVAL_PP(ppz) );
863
864 // add UIDs
865 for ( int i = 0; i < len; i++ ){
866 add_next_index_long(*ppz, (long)(pUID[i]) );
867 }
868
869 return RES_OK;
870 }
871
872 /**
873 *
874 * groupid_t鐃緒申鐃緒申鐃緒申鐃緒申PHP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
875 * @param pGID 鐃緒申鐃緒申鐃緒申鐃緒申groupid_t鐃緒申鐃緒申鐃緒申
876 * @param len pGID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
877 * @param ppz 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)
878 * @return RES_OK
879 *
880 */
881 result_t gidsToZval( groupid_t *pGID, int len, zval **ppz )
882 {
883 zend_hash_clean( Z_ARRVAL_PP(ppz) );
884
885 // add GIDs
886 for ( int i = 0; i < len; i++ ){
887 add_next_index_long(*ppz, (long)(pGID[i]) );
888 }
889
890 return RES_OK;
891 }
892
893 /**
894 *
895 * changelog_t鐃緒申鐃緒申鐃緒申鐃緒申PHP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
896 * @param pChangelog 鐃緒申鐃緒申鐃緒申鐃緒申changelog_t*
897 * @param z 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)
898 * @return RES_OK
899 *
900 */
901 result_t changelogToZval( const changelog_t *pChangelog, zval *z )
902 {
903 zend_hash_clean( z -> value.ht );
904
905 add_assoc_long( z, "log_id", pChangelog -> getChangelogID( ) );
906 add_assoc_long( z, "item_id", pChangelog -> getItemID( ) );
907 add_assoc_long( z, "log_date", pChangelog -> getDate( ) );
908 add_assoc_string( z, "log", ( char* )pChangelog -> getLog( ), 1 );
909
910 return RES_OK;
911 }
912
913 /**
914 *
915 * item_t鐃緒申鐃緒申鐃緒申鐃緒申PHP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
916 * @param pItem 鐃緒申鐃緒申鐃緒申鐃緒申item_t*
917 * @param z 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)
918 * @return RES_OK
919 *
920 */
921 result_t itemToZval( const item_t *pItem, zval *z )
922 {
923 zend_hash_clean( z -> value.ht );
924
925 add_assoc_long( z, "item_id", pItem -> getItemID( ) );
926 add_assoc_long( z, "item_type_id", pItem -> getItemTypeID( ) );
927 add_assoc_long( z, "uid", pItem -> getContributorUID( ) );
928 add_assoc_string( z, "title", ( char* )pItem -> getTitle( ), 1 );
929 add_assoc_string( z, "keywords", ( char* )pItem -> getKeywords( ), 1 );
930 add_assoc_string( z, "description", ( char* )pItem -> getDescription( ), 1 );
931 add_assoc_string( z, "doi", ( char* )pItem -> getDOI( ), 1 );
932 add_assoc_long( z, "last_update_date", pItem -> getLastUpdateDate( ) );
933 add_assoc_long( z, "creation_date", pItem -> getCreationDate( ) );
934 add_assoc_long( z, "publication_year", pItem -> getPublicationYear( ) );
935 add_assoc_long( z, "publication_month", pItem -> getPublicationMonth( ) );
936 add_assoc_long( z, "publication_mday", pItem -> getPublicationMday( ) );
937 add_assoc_string( z, "lang", ( char* )pItem -> getLang( ), 1 );
938
939 return RES_OK;
940 }
941
942
943 result_t itemsToZval( const item_t *pItems, int itemsLen, zval *z )
944 {
945 zend_hash_clean( z -> value.ht );
946 for( int i = 0; i < itemsLen; i++ ){
947 zval *new_array;
948 MAKE_STD_ZVAL(new_array);
949 if(array_init(new_array) != SUCCESS){
950 return RES_ERROR;
951 }
952 add_index_zval( z, i, new_array );
953 itemToZval( &pItems[ i ], new_array );
954 }
955 return RES_OK;
956 }
957
958 /**
959 *
960 * PHP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申group_t鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
961 *
962 * @param z 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
963 * @param pGroup 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
964 * @return RES_OK
965 *
966 */
967 result_t zvalToItem( zval *z, item_t* pItem )
968 {
969 zval **tmp;
970 char* key = 0;
971
972 key = "item_id";
973 if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
974 convert_to_long_ex( tmp ) ;
975 pItem -> setItemID( (*tmp) -> value.lval );
976 }
977 key = "item_type_id";
978 if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
979 convert_to_long_ex( tmp ) ;
980 pItem -> setItemTypeID( (*tmp) -> value.lval );
981 }
982 key = "uid";
983 if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
984 convert_to_long_ex( tmp ) ;
985 pItem -> setContributorUID( (*tmp) -> value.lval );
986 }
987 key = "title";
988 if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
989 convert_to_string_ex( tmp ) ;
990 pItem -> setTitle( (*tmp) -> value.str.val );
991 }
992 key = "keywords";
993 if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
994 convert_to_string_ex( tmp ) ;
995 pItem -> setKeywords( (*tmp) -> value.str.val );
996 }
997 key = "description";
998 if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
999 convert_to_string_ex( tmp ) ;
1000 pItem -> setDescription( (*tmp) -> value.str.val );
1001 }
1002 key = "doi";
1003 if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
1004 convert_to_string_ex( tmp ) ;
1005 pItem -> setDOI( (*tmp) -> value.str.val );
1006 }
1007 key = "last_update_date";
1008 if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
1009 convert_to_long_ex( tmp ) ;
1010 pItem -> setLastUpdateDate( (*tmp) -> value.lval );
1011 }
1012 key = "creation_date";
1013 if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
1014 convert_to_long_ex( tmp ) ;
1015 pItem -> setCreationDate( (*tmp) -> value.lval );
1016 }
1017 key = "publication_year";
1018 if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
1019 convert_to_long_ex( tmp ) ;
1020 pItem -> setPublicationYear( (*tmp) -> value.lval );
1021 }
1022 key = "publication_month";
1023 if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
1024 convert_to_long_ex( tmp ) ;
1025 pItem -> setPublicationMonth( (*tmp) -> value.lval );
1026 }
1027 key = "publication_mday";
1028 if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
1029 convert_to_long_ex( tmp ) ;
1030 pItem -> setPublicationMday( (*tmp) -> value.lval );
1031 }
1032 key = "lang";
1033 if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
1034 convert_to_string_ex( tmp ) ;
1035 pItem -> setLang( (*tmp) -> value.str.val );
1036 }
1037 return RES_OK;
1038 }
1039
1040 /**
1041 *
1042 * account_t鐃緒申鐃緒申鐃緒申鐃緒申PHP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1043 * @param pAccount 鐃緒申鐃緒申鐃緒申鐃緒申account_t*
1044 * @param z 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)
1045 * @return RES_OK
1046 *
1047 */
1048 result_t accountToZval( const account_t *pAccount, zval *z )
1049 {
1050 zend_hash_clean( z -> value.ht );
1051
1052 add_assoc_long( z, "uid", pAccount -> getUID( ) );
1053 add_assoc_string( z, "uname", ( char* )pAccount -> getUname( ), 1 );
1054 add_assoc_string( z, "name", ( char* )pAccount -> getName( ), 1 );
1055 add_assoc_string( z, "email", ( char* )pAccount -> getEmail( ), 1 );
1056 add_assoc_string( z, "url", ( char* )pAccount -> getURL( ), 1 );
1057 add_assoc_string( z, "user_avatar", ( char* )pAccount -> getUserAvatar( ), 1 );
1058 add_assoc_string( z, "user_icq", ( char* )pAccount -> getUserIcq( ), 1 );
1059 add_assoc_string( z, "user_from", ( char* )pAccount -> getUserFrom( ), 1 );
1060 add_assoc_string( z, "user_sig", ( char* )pAccount -> getUserSig( ), 1 );
1061 add_assoc_string( z, "actkey", ( char* )pAccount -> getActkey( ), 1 );
1062 add_assoc_string( z, "user_aim", ( char* )pAccount -> getUserAim( ), 1 );
1063 add_assoc_string( z, "user_yim", ( char* )pAccount -> getUserYim( ), 1 );
1064 add_assoc_string( z, "user_msnm", ( char* )pAccount -> getUserMsnm( ), 1 );
1065 add_assoc_string( z, "pass", ( char* )pAccount -> getPass( ), 1 );
1066 add_assoc_string( z, "theme", ( char* )pAccount -> getTheme( ), 1 );
1067 add_assoc_string( z, "umode", ( char* )pAccount -> getUmode( ), 1 );
1068 add_assoc_string( z, "user_occ", ( char* )pAccount -> getUserOcc( ), 1 );
1069 add_assoc_string( z, "bio", ( char* )pAccount -> getBio( ), 1 );
1070 add_assoc_string( z, "user_intrest", ( char* )pAccount -> getUserIntrest( ), 1 );
1071 add_assoc_double( z, "timezone_offset", pAccount -> getTimezoneOffset( ) );
1072 add_assoc_long( z, "attachsig", pAccount -> getAttachsig( ) );
1073 add_assoc_long( z, "last_login", pAccount -> getLastLogin( ) );
1074 add_assoc_long( z, "level", pAccount -> getLevel( ) );
1075 add_assoc_long( z, "notify_method", pAccount -> getNotifyMethod( ) );
1076 add_assoc_long( z, "notify_mode", pAccount -> getNotifyMode( ) );
1077 add_assoc_long( z, "posts", pAccount -> getPosts( ) );
1078 add_assoc_long( z, "rank", pAccount -> getRank( ) );
1079 add_assoc_long( z, "uorder", pAccount -> getUorder( ) );
1080 add_assoc_long( z, "user_mailok", pAccount -> getUserMailok( ) );
1081 add_assoc_long( z, "user_regdate", pAccount -> getUserRegdate( ) );
1082 add_assoc_long( z, "user_viewemail", pAccount -> getUserViewemail( ) );
1083
1084 add_assoc_long( z, "activate", pAccount -> getActivate( ) );
1085 add_assoc_string( z, "address", ( char* )pAccount -> getAddress( ), 1 );
1086 add_assoc_string( z, "division", ( char* )pAccount -> getDivision( ), 1 );
1087 add_assoc_string( z, "tel", ( char* )pAccount -> getTel( ), 1 );
1088 add_assoc_string( z, "company_name", ( char* )pAccount -> getCompanyName( ), 1 );
1089 add_assoc_string( z, "country", ( char* )pAccount -> getCountry( ), 1 );
1090 add_assoc_string( z, "zipcode", ( char* )pAccount -> getZipcode( ), 1 );
1091 add_assoc_string( z, "fax", ( char* )pAccount -> getFax( ), 1 );
1092 add_assoc_long( z, "notice_mail", pAccount -> getNoticeMail( ) );
1093 add_assoc_long( z, "notice_mail_since", pAccount -> getNoticeMailSince( ) );
1094 add_assoc_long( z, "private_index_id", pAccount -> getPrivateIndexID( ) );
1095 add_assoc_long( z, "item_number_limit", pAccount -> getItemNumberLimit( ) );
1096 add_assoc_long( z, "index_number_limit", pAccount -> getIndexNumberLimit( ) );
1097 add_assoc_double( z, "item_storage_limit", pAccount -> getItemStorageLimit( ) );
1098 return RES_OK;
1099 }
1100
1101 /**
1102 *
1103 * 鐃緒申鐃緒申鐃緒申account_t鐃緒申鐃緒申鐃緒申鐃緒申PHP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1104 * @param pAccounts 鐃緒申鐃緒申鐃緒申鐃緒申account_t*
1105 * @param accountsLen pAccounts鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1106 * @param z 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)
1107 * @return RES_OK
1108 *
1109 z: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申 <br>
1110 array(
1111 array(
1112 'uid'=>100,
1113 'activate'=>1,
1114 'division'=>'foo',
1115 'tel'=>'123-456-789',
1116 ...
1117 ),
1118 ...
1119 )
1120 */
1121 result_t accountsToZval( const account_t *pAccounts, int accountsLen, zval *z )
1122 {
1123 zend_hash_clean( z -> value.ht );
1124 for( int i = 0; i < accountsLen; i++ ){
1125 zval *new_array;
1126 MAKE_STD_ZVAL(new_array);
1127 if(array_init(new_array) != SUCCESS){
1128 return RES_ERROR;
1129 }
1130 add_index_zval( z, i, new_array );
1131 accountToZval( &pAccounts[ i ], new_array );
1132 }
1133 return RES_OK;
1134 }
1135
1136 /**
1137 *
1138 * 鐃緒申鐃緒申鐃緒申group_t鐃緒申鐃緒申鐃緒申鐃緒申PHP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1139 * @param pGroups 鐃緒申鐃緒申鐃緒申鐃緒申group_t*
1140 * @param groupsLen pGroups鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1141 * @param z 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)
1142 * @return RES_OK
1143 *
1144 z: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申 <br>
1145 array(
1146 array(
1147 'gid'=>1,
1148 'gname'=>'foo group',
1149 'gdesc'=>'group of foo'
1150 ),
1151 ...
1152 )
1153 */
1154 result_t groupsToZval( const group_t *pGroups, int groupsLen, zval *z )
1155 {
1156 zend_hash_clean( z -> value.ht );
1157 for( int i = 0; i < groupsLen; i++ ){
1158 zval *new_array;
1159 MAKE_STD_ZVAL(new_array);
1160 if(array_init(new_array) != SUCCESS){
1161 return RES_ERROR;
1162 }
1163 add_index_zval( z, i, new_array );
1164 add_assoc_long( new_array, "gid", pGroups[ i ].getGID( ) );
1165 add_assoc_string( new_array, "gname", ( char* )pGroups[ i ].getGname( ), 1 );
1166 add_assoc_string( new_array, "gdesc", ( char* )pGroups[ i ].getDesc( ), 1 );
1167 add_assoc_long( new_array, "group_index_id", pGroups[ i ].getGroupIndexID( ) );
1168 add_assoc_long( new_array, "item_number_limit", pGroups[ i ].getItemNumberLimit( ) );
1169 add_assoc_long( new_array, "index_number_limit", pGroups[ i ].getIndexNumberLimit( ) );
1170 add_assoc_double( new_array, "item_storage_limit", pGroups[ i ].getItemStorageLimit( ) );
1171 }
1172 return RES_OK;
1173 }
1174
1175 /**
1176 *
1177 * group_t鐃緒申鐃緒申鐃緒申鐃緒申PHP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1178 *
1179 * @param pGroup 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1180 * @param z 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)
1181 * @return RES_OK
1182 *
1183 */
1184 result_t groupToZval( const group_t *pGroup, zval *z )
1185 {
1186 zend_hash_clean( z -> value.ht );
1187 add_assoc_long( z, "gid", pGroup -> getGID( ) );
1188 add_assoc_string( z, "gname", ( char* )pGroup -> getGname( ), 1 );
1189 add_assoc_string( z, "gdesc", ( char* )pGroup -> getDesc( ), 1 );
1190 add_assoc_long( z, "group_index_id", pGroup -> getGroupIndexID( ) );
1191 add_assoc_long( z, "item_number_limit", pGroup -> getItemNumberLimit( ) );
1192 add_assoc_long( z, "index_number_limit", pGroup -> getIndexNumberLimit( ) );
1193 add_assoc_double( z, "item_storage_limit", pGroup -> getItemStorageLimit( ) );
1194 return RES_OK;
1195 }
1196
1197 /**
1198 *
1199 * PHP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申group_t鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1200 *
1201 * @param z 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1202 * @param pGroup 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1203 * @return RES_OK
1204 *
1205 */
1206 result_t zvalToGroup( zval *z, group_t *pGroup )
1207 {
1208 zval **tmp;
1209 char* key = 0;
1210
1211 key = "gid";
1212 if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
1213 convert_to_long_ex( tmp ) ;
1214 pGroup -> setGID( (*tmp) -> value.lval );
1215 }
1216 key = "gname";
1217 if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
1218 convert_to_string_ex( tmp ) ;
1219 pGroup -> setGname( (*tmp) -> value.str.val );
1220 }
1221 key = "gdesc";
1222 if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
1223 convert_to_string_ex( tmp ) ;
1224 pGroup -> setDesc( (*tmp) -> value.str.val );
1225 }
1226 key = "group_index_id";
1227 if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
1228 convert_to_long_ex( tmp ) ;
1229 pGroup -> setGroupIndexID( (*tmp) -> value.lval );
1230 }
1231 key = "item_number_limit";
1232 if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
1233 convert_to_long_ex( tmp ) ;
1234 pGroup -> setItemNumberLimit( (*tmp) -> value.lval );
1235 }
1236 key = "index_number_limit";
1237 if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
1238 convert_to_long_ex( tmp ) ;
1239 pGroup -> setIndexNumberLimit( (*tmp) -> value.lval );
1240 }
1241 key = "item_storage_limit";
1242 if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
1243 convert_to_double_ex( tmp ) ;
1244 pGroup -> setItemStorageLimit( (*tmp) -> value.dval );
1245 }
1246 return RES_OK;
1247 }
1248
1249 /**
1250 *
1251 * session_t鐃緒申鐃緒申鐃緒申鐃緒申PHP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1252 *
1253 * @param pSession 鐃緒申鐃緒申鐃緒申鐃緒申session_t
1254 * @param z 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)
1255 * @return RES_OK
1256 *
1257 */
1258 result_t sessionToZval( const session_t *pSession, zval *z )
1259 {
1260 string sessionID(unsignedIntToString(pSession->getSessionID()));
1261 add_assoc_string(z, "session_id", (char *)sessionID.c_str(), 1);
1262
1263 string date(unsignedIntToString((unsigned int)pSession->getDate()));
1264 add_assoc_string(z, "date", (char *)date.c_str(), 1);
1265
1266 string userID(unsignedIntToString((unsigned int)pSession->getUID()));
1267 add_assoc_string(z, "user_id", (char *)userID.c_str(), 1);
1268
1269 return RES_OK;
1270 }
1271
1272 /**
1273 *
1274 * index_t鐃緒申鐃緒申鐃緒申鐃緒申PHP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1275 * @param pIndex 鐃緒申鐃緒申鐃緒申鐃緒申index_t*
1276 * @param z 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)
1277 * @return RES_OK
1278 *
1279 */
1280 result_t indexToZval( const index_t *pIndex, zval *z )
1281 {
1282 zend_hash_clean( z -> value.ht );
1283
1284 add_assoc_long( z, "item_id", pIndex -> getItemID( ) );
1285 add_assoc_long( z, "item_type_id", pIndex -> getItemTypeID( ) );
1286 add_assoc_long( z, "contributor_uid", pIndex -> getContributorUID( ) );
1287 add_assoc_string( z, "title", ( char* )pIndex -> getTitle( ), 1 );
1288 add_assoc_string( z, "keywords", ( char* )pIndex -> getKeywords( ), 1 );
1289 add_assoc_string( z, "description", ( char* )pIndex -> getDescription( ), 1 );
1290 add_assoc_long( z, "last_update_date", pIndex -> getLastUpdateDate( ) );
1291 add_assoc_long( z, "creation_date", pIndex-> getCreationDate( ) );
1292 add_assoc_long( z, "parent_index_id", pIndex -> getParentIndexID( ) );
1293 add_assoc_long( z, "owner_uid", pIndex -> getOwnerUID( ) );
1294 add_assoc_long( z, "owner_gid", pIndex -> getOwnerGID( ) );
1295 add_assoc_long( z, "open_level", pIndex -> getOpenLevel( ) );
1296 add_assoc_long( z, "sort_number", pIndex -> getSortNumber( ) );
1297 return RES_OK;
1298 }
1299
1300 result_t indexesToZval( const index_t *pIndexes, int indexesLen, zval *z )
1301 {
1302 zend_hash_clean( z -> value.ht );
1303 for( int i = 0; i < indexesLen; i++ ){
1304 zval *new_array;
1305 MAKE_STD_ZVAL(new_array);
1306 if(array_init(new_array) != SUCCESS){
1307 return RES_ERROR;
1308 }
1309 add_index_zval( z, i, new_array );
1310 indexToZval( &pIndexes[ i ], new_array );
1311 }
1312 return RES_OK;
1313 }
1314
1315 /**
1316 *
1317 * event_t鐃緒申鐃緒申鐃緒申鐃緒申PHP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1318 * @param pevent 鐃緒申鐃緒申鐃緒申鐃緒申event_t*
1319 * @param z 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)
1320 * @return RES_OK
1321 *
1322 */
1323 result_t eventToZval( const event_t *pEvent, zval *z )
1324 {
1325 zend_hash_clean( z -> value.ht );
1326
1327 add_assoc_long ( z, "event_id" , pEvent -> getEventID() );
1328 add_assoc_long ( z, "event_type_id" , pEvent -> getEventTypeID() );
1329
1330 if ( pEvent->isValidTimestamp () ) add_assoc_long ( z, "timestamp" , pEvent -> getTimestamp() );
1331 if ( pEvent->isValidExecUID () ) add_assoc_long ( z, "exec_uid" , pEvent -> getExecUID() );
1332 if ( pEvent->isValidIndexID () ) add_assoc_long ( z, "index_id" , pEvent -> getIndexID() );
1333 if ( pEvent->isValidItemID () ) add_assoc_long ( z, "item_id" , pEvent -> getItemID() );
1334 if ( pEvent->isValidFileID () ) add_assoc_long ( z, "file_id" , pEvent -> getFileID() );
1335 if ( pEvent->isValidUID () ) add_assoc_long ( z, "uid" , pEvent -> getUID() );
1336 if ( pEvent->isValidGID () ) add_assoc_long ( z, "gid" , pEvent -> getGID() );
1337 if ( pEvent->isValidRemoteHost () ) add_assoc_string( z, "remote_host" , (char*)pEvent -> getRemoteHost() , 1 );
1338 if ( pEvent->isValidSearchKeyword () ) add_assoc_string( z, "search_keyword" , (char*)pEvent -> getSearchKeyword() , 1 );
1339 if ( pEvent->isValidAdditionalInfo() ) add_assoc_string( z, "additional_info", (char*)pEvent -> getAdditionalInfo(), 1 );
1340
1341 return RES_OK;
1342 }
1343
1344 result_t eventsToZval( const event_t *pevents, int eventsLen, zval *z )
1345 {
1346 zend_hash_clean( z -> value.ht );
1347 for( int i = 0; i < eventsLen; i++ ){
1348 zval *new_array;
1349 MAKE_STD_ZVAL(new_array);
1350 if(array_init(new_array) != SUCCESS){
1351 return RES_ERROR;
1352 }
1353 add_index_zval( z, i, new_array );
1354 eventToZval( &pevents[ i ], new_array );
1355 }
1356 return RES_OK;
1357 }
1358
1359
1360
1361
1362 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
1363 int xnp_get_group( int sid, int gid, array group );
1364 @param sid XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1365 @param gid XNP 鐃緒申 group_id
1366 @param group 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1367 @return 0 success <br>
1368 */
1369 ZEND_FUNCTION(xnp_get_group)
1370 {
1371 long sid, gid;
1372 zval *zgroup;
1373
1374 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lla",
1375 &sid, &gid, &zgroup) == FAILURE) {
1376 return;
1377 }
1378
1379 const group_t *pgroup;
1380 result_t result = getGroup( (sessionid_t)sid, (groupid_t)gid, &pgroup );
1381 if ( RES_OK == result ){
1382 groupToZval( pgroup, zgroup );
1383 freeGroup( pgroup );
1384 }
1385
1386 RETURN_LONG(result);
1387 }
1388
1389
1390 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申)鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
1391 xnp_get_groups( int sid, array gids, array criteria, array groups );
1392 @param sid XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1393 @param gids XNP 鐃緒申 group_id 鐃緒申鐃緒申鐃緒申
1394 @param criteria 鐃緒申鐃緒申
1395 @param groups 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1396 @return 0 success <br>
1397 */
1398 ZEND_FUNCTION(xnp_get_groups)
1399 {
1400 result_t result;
1401 long sid;
1402 zval *zcriteria;
1403 zval *zgids;
1404 zval *zgroups;
1405 zval **ppzTmp = 0;
1406 HashPosition pos;
1407 int res2;
1408 int gidsLen;
1409 const group_t* groups;
1410 int groupsLen;
1411
1412 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "laaa",
1413 &sid, &zgids, &zcriteria, &zgroups) == FAILURE) {
1414 return;
1415 }
1416
1417 //gids鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1418 gidsLen = zend_hash_num_elements(Z_ARRVAL_P(zgids));
1419 groupid_t *gids = new groupid_t[ gidsLen ];
1420 zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(zgids), &pos);
1421 for( int i = 0; i < gidsLen; i++ ){
1422 if( (res2=zend_hash_get_current_data_ex(Z_ARRVAL_P(zgids), (void **)&ppzTmp, &pos)) == SUCCESS ){
1423 SEPARATE_ZVAL(ppzTmp);
1424 convert_to_long_ex(ppzTmp);
1425 gids[ i ] = Z_LVAL_PP(ppzTmp);
1426 }
1427 zend_hash_move_forward_ex(Z_ARRVAL_P(zgids), &pos);
1428 }
1429
1430 zCriteria_t zcri(zcriteria);
1431 result = zcri.getResult();
1432 if ( RES_OK == result ){
1433 result = getGroups( (sessionid_t)sid, gids, gidsLen, &zcri, &groups, &groupsLen );
1434 if ( RES_OK == result ){
1435 groupsToZval( groups, groupsLen, zgroups );
1436 delete[] gids;
1437 freeGroup( groups );
1438 }
1439 }
1440 RETURN_LONG(result);
1441 }
1442
1443
1444 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
1445 int xnp_is_moderator(int sid, int uid)
1446 @param sid XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1447 @param uid xoops 鐃緒申 uid (xoops_users.uid)
1448 @return true 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申 <br>
1449 */
1450 ZEND_FUNCTION(xnp_is_moderator)
1451 {
1452 long xnpSessionID;
1453 userid_t uid;
1454
1455 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll",
1456 &xnpSessionID, &uid) == FAILURE) {
1457 return;
1458 }
1459
1460 bool result = isModerator( (sessionid_t)xnpSessionID, uid );
1461 RETURN_BOOL(result)
1462 }
1463
1464 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申uid鐃緒申鐃緒申鐃緒申鐃緒申<br>
1465 int xnp_get_uid(string uname,int &uid)
1466 @param sid XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1467 @param uname xoops 鐃緒申 uname (xoops_users.uname)
1468 @param uid xoops 鐃緒申 uid (xoops_users.uid) 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1469 @return 0 success
1470 */
1471 ZEND_FUNCTION(xnp_get_uid)
1472 {
1473 char *uname;
1474 int unameLen;
1475 zval *zuid;
1476 userid_t uid;
1477
1478 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz",
1479 &uname, &unameLen, &zuid) == FAILURE) {
1480 return;
1481 }
1482
1483 if (!PZVAL_IS_REF(zuid)) {
1484 zend_error(E_WARNING, "2nd parameter wasn't passed by reference");
1485 RETURN_LONG(RES_PHP_NONREF);
1486 }
1487
1488 string strUname( uname, unameLen );
1489 result_t result = getUid( strUname.c_str(), &uid );
1490 ZVAL_LONG(zuid, (long)uid);
1491 RETURN_LONG((long)result);
1492 }
1493
1494 ZEND_FUNCTION(xnp_test_criteria)
1495 {
1496 zval *z;
1497
1498 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a",
1499 &z) == FAILURE) {
1500 return;
1501 }
1502 zend_printf("zend_printf...<br>\n");
1503 zCriteria_t zcri(z);
1504 zcri.dump();
1505 RETURN_FALSE
1506 }
1507
1508 ZEND_FUNCTION(xnp_test_uids)
1509 {
1510 zval *z;
1511
1512 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a",
1513 &z) == FAILURE) {
1514 return;
1515 }
1516 zend_printf("zend_printf...<br>\n");
1517 zUIDs_t zuids(z);
1518 zuids.dump();
1519 RETURN_FALSE
1520 }
1521
1522
1523
1524 /** DB鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
1525 int initialize_db( string host[, string user[, string password[, string dbname[, string prefix, int dbtype]]]] );
1526 @param host 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申NULL
1527 @param user DB鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申NULL
1528 @param password DB鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申NULL
1529 @param dbname DB鐃緒申鐃緒申鐃緒申鐃緒申DB鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申""
1530 @param prefix XOOPS DB 鐃緒申prefix鐃緒申
1531 @param dbtype 1=MySQL 2=SQLite鐃緒申common.h鐃緒申鐃緒申
1532 @return 0 success <br>
1533 */
1534 ZEND_FUNCTION(xnp_initialize_db)
1535 {
1536 zval **parameters[5];
1537 char *host;
1538 char *user;
1539 char *password;
1540 char *dbname;
1541 char *prefix;
1542 long dbtype;
1543
1544 /* get the number of arguments */
1545 int argNum = ZEND_NUM_ARGS();
1546 if (argNum > 5)
1547 WRONG_PARAM_COUNT;
1548
1549 /* argument count is correct, now retrieve arguments */
1550 if(zend_get_parameters_array_ex(argNum, parameters) != SUCCESS)
1551 WRONG_PARAM_COUNT;
1552
1553 if (argNum < 1) host = NULL;
1554 else host = getZvalString( parameters[0] );
1555
1556 if (argNum < 2) user = NULL;
1557 else user = getZvalString( parameters[1] );
1558
1559 if (argNum < 3) password = NULL;
1560 else password = getZvalString( parameters[2] );
1561
1562 if (argNum < 4) dbname = "";
1563 else dbname = getZvalString( parameters[3] );
1564
1565 if (argNum < 5) prefix = "";
1566 else prefix = getZvalString( parameters[4] );
1567
1568 if (argNum < 6) dbtype = DBTYPE_MYSQL;
1569 else dbtype = getZvalInt( parameters[5] );
1570
1571 result_t result = initializeDB( host, user, password, dbname, prefix, (dbtype_t)dbtype );
1572
1573 RETURN_LONG(result);
1574 }
1575
1576 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
1577 int xnp_login_user(string uname, string password, int &session_id)
1578 @param uname 鐃緒申鐃緒申鐃緒申鐃緒申(xoops_users.uname)
1579 @param password 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(md5(password)=xoops_users.pass)
1580 @return 0 success
1581 */
1582 ZEND_FUNCTION(xnp_login_user)
1583 {
1584 char *uname;
1585 int unameLen;
1586 char *passwd;
1587 int passwdLen;
1588 zval *zXNPSessionID;
1589
1590 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ssz",
1591 &uname, &unameLen, &passwd, &passwdLen, &zXNPSessionID) == FAILURE) {
1592 return;
1593 }
1594
1595 if (!PZVAL_IS_REF(zXNPSessionID)) {
1596 zend_error(E_WARNING, "3rd parameter wasn't passed by reference");
1597 RETURN_LONG(RES_PHP_NONREF);
1598 }
1599
1600 sessionid_t xnpSessionID;
1601 result_t result = loginUser( uname, passwd, &xnpSessionID );
1602 if ( result == RES_OK )
1603 ZVAL_LONG(zXNPSessionID, (long)xnpSessionID);
1604 RETURN_LONG((long)result);
1605 }
1606
1607 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
1608 void xnp_logout_user(int xnp_session_id)
1609 @param xnp_session_id XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1610 @return 鐃緒申鐃緒申
1611 */
1612 ZEND_FUNCTION(xnp_logout_user)
1613 {
1614 long xnpSessionID;
1615
1616 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &xnpSessionID) == FAILURE) {
1617 return;
1618 }
1619 logoutUser( (sessionid_t)xnpSessionID );
1620
1621 RETURN_NULL();
1622 }
1623
1624 /** XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID 鐃緒申鐃緒申<br>
1625 int xnp_create_session( string xoops_sess_id, int uid, int &session )
1626 @param xoops_sess_id xoops鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1627 @param uid xoops 鐃緒申 uid (xoops_users.uid)
1628 @param session 鐃緒申鐃緒申鐃緒申鐃緒申XNP鐃緒申session鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1629 @return 0 鐃緒申鐃緒申
1630 */
1631 ZEND_FUNCTION(xnp_create_session)
1632 {
1633 char *xoopsSessionID;
1634 int xoopsSessionIDLen;
1635 long uid;
1636 zval *zXNPSessionID;
1637
1638 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "slz",
1639 &xoopsSessionID, &xoopsSessionIDLen, &uid, &zXNPSessionID) == FAILURE) {
1640 return;
1641 }
1642
1643 if (!PZVAL_IS_REF(zXNPSessionID)) {
1644 zend_error(E_WARNING, "3rd parameter wasn't passed by reference");
1645 RETURN_LONG(RES_PHP_NONREF);
1646 }
1647
1648 sessionid_t xnpSessionID = 0;
1649 result_t result = createSession( xoopsSessionID, (userid_t)uid, &xnpSessionID );
1650 if ( result == RES_OK )
1651 ZVAL_LONG(zXNPSessionID, (long)xnpSessionID);
1652 RETURN_LONG((long)result);
1653 }
1654
1655 /** XNP 鐃緒申 session 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
1656 int xnp_get_session( int xnp_session_id, array session_info )
1657 @param xnp_session_id XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1658 @param session_info 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1659 @return 0 success
1660 */
1661 ZEND_FUNCTION(xnp_get_session)
1662 {
1663 long xnpSessionID;
1664 zval *sessionInfo;
1665 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "la",
1666 &xnpSessionID, &sessionInfo) == FAILURE) {
1667 return;
1668 }
1669 const session_t *session = 0;
1670 result_t result = getSession( (sessionid_t)xnpSessionID, &session );
1671 if ( result == RES_OK ){
1672 sessionToZval( session, sessionInfo );
1673 freeSession( session );
1674 }
1675
1676 RETURN_LONG((long)result);
1677 }
1678
1679 /** 鐃緒申鐃緒申鐃緒申鐃緒申activate鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
1680 bool xnp_is_activated( int xnp_session_id, int user_id )
1681 @param xnp_session_id XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1682 @param user_id xoops_users.uid
1683 @return 0 success
1684 */
1685 ZEND_FUNCTION(xnp_is_activated)
1686 {
1687 long sid, uid;
1688
1689 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll", &sid, &uid) == FAILURE) {
1690 return;
1691 }
1692
1693 bool result = isActivated( (sessionid_t)sid, (userid_t)uid );
1694
1695 RETURN_BOOL(result);
1696 }
1697
1698 /** activate鐃緒申鐃緒申鐃緒申<br>
1699 bool xnp_activate( int xnp_session_id, int user_id, bool activated )
1700 @param xnp_session_id xnp 鐃緒申 session id
1701 @param user_id xoops_users.uid
1702 @param activated true:activate, false:inactivate
1703 @return 0 success
1704 */
1705 ZEND_FUNCTION(xnp_activate)
1706 {
1707 long sid, uid;
1708 bool activated;
1709
1710 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "llb",
1711 &sid, &uid, &activated) == FAILURE) {
1712 return;
1713 }
1714
1715 result_t result = activate( (sessionid_t)sid, (userid_t)uid, activated );
1716
1717 RETURN_LONG(result);
1718 }
1719
1720 /** XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
1721 int xnp_get_account_count( int xnp_session_id )
1722 @param xnp_session_id XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1723 @return 0 success
1724 */
1725 ZEND_FUNCTION(xnp_get_account_count)
1726 {
1727 long sid;
1728
1729 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l",
1730 &sid) == FAILURE) {
1731 return;
1732 }
1733
1734 long count = getAccountCount( (sessionid_t)sid );
1735 RETURN_LONG(count);
1736 }
1737
1738 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
1739 bool xnp_delete_account( int xnp_session_id, int user_id )
1740 @param xnp_session_id XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1741 @param user_id xoops_users.uid
1742 @return 0 success
1743 */
1744 ZEND_FUNCTION(xnp_delete_account)
1745 {
1746 long sid, uid;
1747
1748 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll",
1749 &sid, &uid) == FAILURE) {
1750 return;
1751 }
1752
1753 result_t result = deleteAccount( (sessionid_t)sid, (userid_t)uid );
1754
1755 RETURN_LONG(result);
1756 }
1757
1758 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
1759 int xnp_get_account( int xnp_session_id, int user_id, array account_info )
1760 @param xnp_session_id XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1761 @param user_id xoops_users.uid
1762 @param account_info 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1763 @return 0 success
1764 */
1765 ZEND_FUNCTION(xnp_get_account)
1766 {
1767 long sid, uid;
1768 zval *zaccount;
1769
1770 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lla",
1771 &sid, &uid, &zaccount) == FAILURE) {
1772 fprintf( stderr, "error occured " );
1773 return;
1774 }
1775
1776 const account_t *paccount;
1777 result_t result = getAccount( (sessionid_t)sid, (userid_t)uid, &paccount );
1778 if ( RES_OK == result ){
1779 accountToZval( paccount, zaccount );
1780 freeAccount( paccount );
1781 }
1782
1783 RETURN_LONG(result);
1784 }
1785
1786 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
1787 int xnp_get_accoutns( int sid, array uids, array criteria, array accounts );
1788 @param xnp_session_id XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1789 @param user_id xoops_users.uid
1790 @param criteria 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1791 @param account_info 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1792 @return 0 success
1793 */
1794 ZEND_FUNCTION(xnp_get_accounts)
1795 {
1796 result_t result;
1797 long sid;
1798 zval *zuids;
1799 zval *zcriteria;
1800 zval *zaccount;
1801
1802 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "laaa",
1803 &sid, &zuids, &zcriteria, &zaccount) == FAILURE) {
1804 return;
1805 }
1806
1807 zCriteria_t zcri(zcriteria);
1808 result = zcri.getResult();
1809 if ( RES_OK == result ){
1810 zUIDs_t zUIDs(zuids);
1811 result = zUIDs.getResult();
1812 if ( RES_OK == result ){
1813 const account_t *paccounts;
1814 int accountLen;
1815 result = getAccounts( (sessionid_t)sid,
1816 zUIDs.getPUID(), zUIDs.getLen(),
1817 &zcri, &paccounts, &accountLen );
1818 if ( RES_OK == result ){
1819 accountsToZval( paccounts, accountLen, zaccount );
1820 freeAccount( paccounts );
1821 }
1822 }
1823 }
1824
1825 RETURN_LONG(result);
1826 }
1827
1828 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
1829 int xnp_insert_account( int sid, array account_info, int &user_id );
1830 @param xnp_session_id xnp 鐃緒申 session id
1831 @param account_info 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1832 @param user_id 鐃緒申鐃緒申鐃緒申ID(xoops_users.uid)鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1833 @return 0 success
1834 */
1835 ZEND_FUNCTION(xnp_insert_account)
1836 {
1837 result_t result;
1838 long sid;
1839 zval *zaccount;
1840 zval *zuid;
1841 userid_t uid;
1842
1843 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "laz",
1844 &sid, &zaccount, &zuid) == FAILURE) {
1845 return;
1846 }
1847
1848 zAccount_t zacc(zaccount);
1849 result = zacc.getResult();
1850 if ( RES_OK == result ){
1851 result = insertAccount( (sessionid_t)sid, &zacc, &uid );
1852 }
1853 zuid -> type = IS_LONG;
1854 zuid -> value.lval = uid;
1855 RETURN_LONG(result);
1856 }
1857
1858 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
1859 int xnp_update_account( int sid, array account );
1860 @param xnp_session_id XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1861 @param account_info 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1862 @return 0 success
1863 */
1864 ZEND_FUNCTION(xnp_update_account)
1865 {
1866 result_t result;
1867 long sid;
1868 zval *zaccount;
1869
1870 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "la",
1871 &sid, &zaccount) == FAILURE) {
1872 return;
1873 }
1874
1875 zAccount_t zacc(zaccount);
1876 result = zacc.getResult();
1877 if ( RES_OK == result ){
1878 result = updateAccount( (sessionid_t)sid, &zacc );
1879 }
1880
1881 RETURN_LONG(result);
1882 }
1883
1884 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
1885 int xnp_dump_uids( int xnp_session_id, array criteria, array uids );
1886 @param xnp_session_id XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1887 @param criteria 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1888 @param uids uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1889 @return 0 success
1890 */
1891 ZEND_FUNCTION(xnp_dump_uids)
1892 {
1893 result_t result;
1894 long sid;
1895 zval *zcriteria;
1896 zval *zuids;
1897
1898 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "laa",
1899 &sid, &zcriteria, &zuids) == FAILURE) {
1900 return;
1901 }
1902
1903 zCriteria_t zcri(zcriteria);
1904 result = zcri.getResult();
1905 if ( RES_OK == result ){
1906 userid_t *puid;
1907 int uidLen;
1908 result = dumpUids( (sessionid_t)sid, &zcri, &puid, &uidLen );
1909 if ( RES_OK == result ){
1910 uidsToZval( puid, uidLen, &zuids );
1911 freeUID( puid );
1912 }
1913 }
1914
1915 RETURN_LONG(result);
1916 }
1917
1918 /** XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
1919 int xnp_get_group_count( int xnp_session_id );
1920 @param xnp_session_id XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1921 @return 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1922 */
1923 ZEND_FUNCTION(xnp_get_group_count)
1924 {
1925 long sid;
1926
1927 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l",
1928 &sid) == FAILURE) {
1929 return;
1930 }
1931
1932 int count = getGroupCount( (sessionid_t)sid );
1933
1934 RETURN_LONG(count);
1935 }
1936
1937 /** uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申gid鐃緒申鐃緒申鐃緒申<br>
1938 int xnp_get_group_by_uid( int xnp_session_id, int uid, array criteria, array gids );
1939 @param xnp_session_id XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1940 @param user_id xoops_users.uid
1941 @param criteria 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1942 @param gids gid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1943 @return 0 success
1944 */
1945 ZEND_FUNCTION(xnp_get_groups_by_uid)
1946 {
1947 result_t result;
1948 long sid, uid;
1949 zval *zcriteria;
1950 zval *zgids;
1951
1952 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "llaa",
1953 &sid, &uid, &zcriteria, &zgids) == FAILURE) {
1954 return;
1955 }
1956
1957 zCriteria_t zcri(zcriteria);
1958 result = zcri.getResult();
1959 if ( RES_OK == result ){
1960 groupid_t *pgids;
1961 int gidLen;
1962 result = getGroupsByUid( (sessionid_t)sid, (userid_t)uid, &zcri, &pgids, &gidLen );
1963 if ( RES_OK == result ){
1964 gidsToZval( pgids, gidLen, &zgids );
1965 freeGID( pgids );
1966 }
1967 }
1968
1969 RETURN_LONG(result);
1970 }
1971
1972
1973
1974 /** uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申gid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
1975 int xnp_is_group_admin( int sid, int gid, int uid );
1976 @param xnp_session_id XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1977 @param group_id XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1978 @param user_id xoops_users.uid
1979 @return true: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1980 @return false: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
1981 */
1982 ZEND_FUNCTION(xnp_is_group_admin)
1983 {
1984 long sid, gid, uid;
1985
1986 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lll",
1987 &sid, &gid, &uid) == FAILURE) {
1988 return;
1989 }
1990
1991 bool b = isGroupAdmin( (sessionid_t)sid, (groupid_t)gid, (userid_t)uid );
1992
1993 RETURN_BOOL(b);
1994 }
1995
1996 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申gid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
1997 int xnp_dump_gids( int sid, array criteria, array gids );
1998 @param xnp_session_id XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
1999 @param criteria 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2000 @param gids gid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2001 @return 0 success
2002 */
2003 ZEND_FUNCTION(xnp_dump_gids)
2004 {
2005 result_t result;
2006 long sid;
2007 zval *zcriteria;
2008 zval *zgids;
2009
2010 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "laa",
2011 &sid, &zcriteria, &zgids) == FAILURE) {
2012 return;
2013 }
2014
2015 zCriteria_t zcri(zcriteria);
2016 result = zcri.getResult();
2017 if ( RES_OK == result ){
2018 groupid_t *pgid;
2019 int gidLen;
2020 result = dumpGids( (sessionid_t)sid, &zcri, &pgid, &gidLen );
2021 if ( RES_OK == result ){
2022 gidsToZval( pgid, gidLen, &zgids );
2023 freeGID( pgid );
2024 }
2025 }
2026
2027 RETURN_LONG(result);
2028 }
2029
2030 /** gid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
2031 int xnp_dump_group_admins(int sid, int group_id, array criteria, array uids )
2032 @param sid XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2033 @param group_id XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2034 @param criteria 鐃緒申鐃緒申
2035 @param uids uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2036 @return 0 success
2037 */
2038
2039 ZEND_FUNCTION(xnp_dump_group_admins)
2040 {
2041 long sid, gid;
2042 zval *zcriteria;
2043 zval *zuids;
2044
2045 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "llaa",
2046 &sid, &gid, &zcriteria, &zuids) == FAILURE) {
2047 return;
2048 }
2049
2050 zCriteria_t zcri(zcriteria);
2051 result_t result = zcri.getResult();
2052 if ( result == RES_OK ){
2053 userid_t *uids;
2054 int uidsLen;
2055 result = dumpGroupAdmins( sid, gid, &zcri, &uids, &uidsLen );
2056 if ( result == RES_OK ){
2057 uidsToZval( uids, uidsLen, &zuids );
2058 freeUID( uids );
2059 }
2060 }
2061 RETURN_LONG( result );
2062 }
2063
2064 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
2065 int xnp_delete_member(int sid, int group_id, int user_id )
2066 @param sid XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2067 @param group_id XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2068 @param user_id 鐃緒申鐃緒申鐃緒申ID
2069 @return 0 success
2070 */
2071
2072 ZEND_FUNCTION(xnp_delete_member)
2073 {
2074 long sid, gid, uid;
2075
2076 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lll",
2077 &sid, &gid, &uid) == FAILURE) {
2078 return;
2079 }
2080
2081 result_t result = deleteMember( (sessionid_t)sid, (groupid_t)gid, (userid_t)uid );
2082 RETURN_LONG( result );
2083 }
2084
2085 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
2086 int xnp_insert_member(int sid, int group_id, int user_id, bool admin )
2087 @param sid XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2088 @param group_id XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2089 @param user_id 鐃緒申鐃緒申鐃緒申ID
2090 @param admin 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申true
2091 @return 0 success
2092 */
2093
2094 ZEND_FUNCTION(xnp_insert_member)
2095 {
2096 long sid, gid, uid;
2097 zend_bool admin;
2098
2099 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lllb",
2100 &sid, &gid, &uid, &admin) == FAILURE) {
2101 return;
2102 }
2103
2104 result_t result = insertMember( (sessionid_t)sid, (groupid_t)gid, (userid_t)uid, (bool)admin );
2105 RETURN_LONG( result );
2106 }
2107
2108 /** gid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
2109 int xnp_get_members(int sid, int group_id, array criteria, array uids )
2110 @param sid XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2111 @param group_id XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2112 @param criteria 鐃緒申鐃緒申
2113 @param uids uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2114 @return 0 success
2115 */
2116
2117 ZEND_FUNCTION(xnp_get_members)
2118 {
2119 long sid, gid;
2120 zval *zcriteria;
2121 zval *zuids;
2122
2123 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "llaa",
2124 &sid, &gid, &zcriteria, &zuids) == FAILURE) {
2125 return;
2126 }
2127
2128 zCriteria_t zcri(zcriteria);
2129 result_t result = zcri.getResult();
2130 if ( result == RES_OK ){
2131 userid_t *uids;
2132 int uidsLen;
2133 result = getMembers( (sessionid_t)sid, (groupid_t)gid, &zcri, &uids, &uidsLen );
2134 if ( result == RES_OK ){
2135 uidsToZval( uids, uidsLen, &zuids );
2136 freeUID( uids );
2137 }
2138 }
2139 RETURN_LONG( result );
2140 }
2141
2142 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
2143 int xnp_update_group(int sid, array group )
2144 @param sid XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2145 @param group 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2146 @return 0 success
2147 */
2148 ZEND_FUNCTION(xnp_update_group)
2149 {
2150 long sid;
2151 zval *zgroup;
2152 group_t group;
2153
2154 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "la",
2155 &sid, &zgroup) == FAILURE) {
2156 return;
2157 }
2158
2159 zvalToGroup( zgroup, &group );
2160 result_t result = updateGroup( sid, &group );
2161 RETURN_LONG( result );
2162 }
2163
2164 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
2165 int xnp_insert_group( int sid, array group, int &gid )
2166 @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2167 @param group 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2168 @param gid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2169 @return RES_OK
2170 @return RES_DB_NOT_INITIALIZED
2171 @return RES_NO_SUCH_SESSION
2172 @return RES_DB_QUERY_ERROR
2173 */
2174 ZEND_FUNCTION(xnp_insert_group)
2175 {
2176 long sid;
2177 zval *zgroup;
2178 zval *zgid;
2179 group_t group;
2180 groupid_t gid;
2181
2182 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "laz",
2183 &sid, &zgroup, &zgid ) == FAILURE) {
2184 return;
2185 }
2186
2187 zvalToGroup( zgroup, &group );
2188 result_t result = insertGroup( sid, &group, &gid );
2189 zgid -> type = IS_LONG;
2190 zgid -> value.lval = gid;
2191 RETURN_LONG( result );
2192 }
2193
2194
2195 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
2196 int xnp_delete_group( int sid, int gid )
2197 @param sid XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2198 @param gid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2199 @return RES_OK
2200 @return RES_DB_QUERY_ERROR
2201 @return RES_NO_SUCH_SESSION
2202 @return RES_DB_NOT_INITIALIZED
2203 */
2204 ZEND_FUNCTION(xnp_delete_group)
2205 {
2206 long sid;
2207 long gid;
2208
2209 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll",
2210 &sid, &gid) == FAILURE) {
2211 return;
2212 }
2213 RETURN_LONG( deleteGroup( sid, gid ) );
2214 }
2215
2216 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
2217 int xnp_dump_group_admins( int sid, int gid, array criteria, array uids )
2218 @param sid XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2219 @param gid XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2220 @param criteria uids鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2221 @param uids 鐃緒申鐃緒申鐃緒申鐃緒申UID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2222 @return RES_OK
2223 @return RES_DB_QUERY_ERROR
2224 @return RES_NO_SUCH_SESSION
2225 @return RES_DB_NOT_INITIALIZED
2226 */
2227 /*
2228 ZEND_FUNCTION(xnp_dump_group_admins)
2229 {
2230 long sid;
2231 long gid;
2232 zval *zcriteria;
2233 zval *zuids;
2234
2235 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "llaa",
2236 &sid, &gid, &zcriteria, &zuids) == FAILURE) {
2237 return;
2238 }
2239 zCriteria_t zcri(zcriteria);
2240 result_t result = zcri.getResult();
2241 if ( RES_OK == result ){
2242 userid_t* uids;
2243 int uidsLen;
2244 result_t result = dumpGroupAdmins( sid, gid, &zcri, &uids, &uidsLen );
2245 if( result != RES_OK ) RETURN_LONG( result );
2246 uidsToZval( uids, uidsLen, &zuids );
2247 fprintf( stderr, "uidsLen=%d\n", uidsLen );
2248 for( int i = 0; i < uidsLen; i++ ){
2249 fprintf( stderr, "%d, \n", uids[ i ] );
2250 }
2251 freeUID( uids );
2252 RETURN_LONG( result );
2253 }
2254 RETURN_LONG( result );
2255 }
2256 */
2257
2258 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
2259 * int xnp_get_all_indexes( int sid, array criteria, array indexes );
2260 * @param sid XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2261 * @param cri 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2262 * @return RES_OK
2263 */
2264 ZEND_FUNCTION(xnp_get_all_indexes)
2265 {
2266 long sid;
2267 zval *zcriteria;
2268 zval *zindexes;
2269
2270 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "laa",
2271 &sid, &zcriteria, &zindexes) == FAILURE) {
2272 return;
2273 }
2274 zCriteria_t zcri(zcriteria);
2275 result_t result = zcri.getResult();
2276 if ( RES_OK == result ){
2277 const index_t *indexes;
2278 int indexesLen;
2279 result = getAllIndexes( sid, &zcri, &indexes, &indexesLen );
2280 if ( RES_OK == result ){
2281 result = indexesToZval( indexes, indexesLen, zindexes );
2282 freeIndex( indexes );
2283 }
2284 }
2285 RETURN_LONG(result);
2286 }
2287
2288 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
2289 * int xnp_get_indexes( int sid, int parentXID, array criteria, array indexes );
2290 * @param sid XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2291 * @param parentXID 鐃緒申鐃緒申indexID
2292 * @param cri 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2293 * @param indexes 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2294 * @return RES_OK
2295 */
2296 ZEND_FUNCTION(xnp_get_indexes)
2297 {
2298 long sid;
2299 long parentXID;
2300 zval *zcriteria;
2301 zval *zindexes;
2302
2303 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "llaa",
2304 &sid, &parentXID, &zcriteria, &zindexes) == FAILURE) {
2305 return;
2306 }
2307 zCriteria_t zcri(zcriteria);
2308 result_t result = zcri.getResult();
2309 if ( RES_OK == result ){
2310 const index_t *indexes;
2311 int indexesLen;
2312 result = getIndexes( sid, parentXID, &zcri, &indexes, &indexesLen );
2313 if ( RES_OK == result ){
2314 result = indexesToZval( indexes, indexesLen, zindexes );
2315 freeIndex( indexes );
2316 }
2317 }
2318 RETURN_LONG(result);
2319 }
2320
2321
2322 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
2323 * int xnp_insert_index( int sid, array index, int &indexID );
2324 * @param sid XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2325 * @param index 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2326 * @param indexID 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2327 * @return RES_OK
2328 */
2329 ZEND_FUNCTION(xnp_insert_index)
2330 {
2331 long sid;
2332 zval *zindex;
2333 zval *zIndexID;
2334
2335 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "laz",
2336 &sid, &zindex, &zIndexID) == FAILURE) {
2337 return;
2338 }
2339
2340 if (!PZVAL_IS_REF(zIndexID)) {
2341 zend_error(E_WARNING, "3rd parameter wasn't passed by reference");
2342 RETURN_LONG(RES_PHP_NONREF);
2343 }
2344 zIndex_t index( zindex );
2345 indexid_t xid;
2346 result_t result = insertIndex( sid, &index, &xid );
2347 if ( RES_OK == result )
2348 ZVAL_LONG(zIndexID, (long)xid);
2349 RETURN_LONG(result);
2350 }
2351
2352 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
2353 * int xnp_update_index( int sid, array index );
2354 * @param sid XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2355 * @param index 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2356 * @return RES_OK
2357 */
2358 ZEND_FUNCTION(xnp_update_index)
2359 {
2360 long sid;
2361 zval *zindex;
2362
2363 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "la",
2364 &sid, &zindex) == FAILURE) {
2365 return;
2366 }
2367 zIndex_t index(zindex);
2368 result_t result = index.getResult();
2369 if ( RES_OK == result ){
2370 result = updateIndex( sid, &index );
2371 }
2372 RETURN_LONG(result);
2373 }
2374
2375 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
2376 * int xnp_delete_index( int sid, int indexID );
2377 * @param sid XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2378 * @param indexID 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2379 * @return RES_OK
2380 */
2381 ZEND_FUNCTION(xnp_delete_index)
2382 {
2383 long sid;
2384 long xid;
2385
2386 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll",
2387 &sid, &xid) == FAILURE) {
2388 return;
2389 }
2390
2391 result_t result = deleteIndex( sid, xid );
2392 RETURN_LONG(result);
2393 }
2394
2395
2396 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
2397 * int xnp_get_index( int sid, int indexID, array index );
2398 * @param sid XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2399 * @param indexID 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2400 * @param index 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2401 * @return RES_OK
2402 */
2403 ZEND_FUNCTION(xnp_get_index)
2404 {
2405 long sid;
2406 long xid;
2407 zval *zindex;
2408
2409 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lla",
2410 &sid, &xid, &zindex) == FAILURE) {
2411 return;
2412 }
2413
2414 const index_t *index;
2415 result_t result = getIndex( sid, xid, &index );
2416 if ( RES_OK == result ){
2417 result = indexToZval( index, zindex );
2418 freeIndex( index );
2419 }
2420 RETURN_LONG(result);
2421 }
2422
2423
2424
2425 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
2426 * int xnp_is_index_readable( int sid, int indexID );
2427 * @param sid XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2428 * @param indexID 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2429 * @return true false
2430 */
2431 ZEND_FUNCTION(xnp_is_index_readable)
2432 {
2433 long sid;
2434 long xid;
2435
2436 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll",
2437 &sid, &xid) == FAILURE) {
2438 return;
2439 }
2440 RETURN_BOOL(isIndexReadable(sid,xid));
2441 }
2442
2443
2444 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
2445 * int xnp_is_index_writable( int sid, int indexID );
2446 * @param sid XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2447 * @param indexID 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2448 * @return true false
2449 */
2450 ZEND_FUNCTION(xnp_is_index_writable)
2451 {
2452 long sid;
2453 long xid;
2454
2455 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll",
2456 &sid, &xid) == FAILURE) {
2457 return;
2458 }
2459 RETURN_BOOL(isIndexWritable(sid,xid));
2460 }
2461
2462 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
2463 * int xnp_swap_index_sort_number( int sid, int indexID1, int indexID2 );
2464 * @param sid XNP鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2465 * @param indexID1 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2466 * @param indexID2 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2467 * @return true false
2468 */
2469 ZEND_FUNCTION(xnp_swap_index_sort_number)
2470 {
2471 long sid;
2472 long xid1, xid2;
2473
2474 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lll",
2475 &sid, &xid1, &xid2) == FAILURE) {
2476 return;
2477 }
2478
2479 result_t result = swapIndexSortNumber( sid, xid1, xid2 );
2480 RETURN_LONG(result);
2481 }
2482
2483
2484
2485 /** XNP鐃緒申session_id鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
2486 bool xnp_is_valid_session_id( int xnp_session_id)
2487 @return true 鐃緒申鐃緒申鐃緒申XNP鐃緒申session_id鐃緒申鐃緒申鐃緒申<br>
2488 @return false 鐃緒申鐃緒申鐃緒申session_id鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2489 */
2490 ZEND_FUNCTION(xnp_is_valid_session_id)
2491 {
2492 long sid;
2493 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &sid ) == FAILURE) {
2494 return;
2495 }
2496
2497 RETURN_BOOL(isValidSessionID((sessionid_t)sid));
2498 }
2499
2500 /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申<br>
2501 string xnp_get_last_error_string()
2502 @return 0 success
2503 */
2504 ZEND_FUNCTION(xnp_get_last_error_string)
2505 {
2506 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "" ) == FAILURE) {
2507 return;
2508 }
2509
2510 string str( getLastErrorString() );
2511 RETURN_STRING((char *)str.c_str(), 1);
2512 }
2513
2514
2515 /**
2516 *
2517 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2518 *
2519 * @refer itemop_t
2520 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2521 * @param iid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2522 * @param op 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2523 * @return true 鐃緒申鐃緒申鐃緒申鐃緒申
2524 * @return false 鐃緒申鐃緒申鐃緒申鐃緒申
2525 *
2526 */
2527 ZEND_FUNCTION(xnp_get_item_permission)
2528 {
2529 long sid;
2530 itemid_t iid;
2531 long op;
2532
2533 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lll",
2534 &sid, &iid, &op) == FAILURE) {
2535 fprintf( stderr, "error occured " );
2536 return;
2537 }
2538 RETURN_BOOL( getItemPermission( (sessionid_t)sid, iid, op ) );
2539 }
2540
2541
2542 /**
2543 *
2544 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2545 *
2546 * @refer indexop_t
2547 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2548 * @param xid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2549 * @param op 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2550 * @return true 鐃緒申鐃緒申鐃緒申鐃緒申
2551 * @return false 鐃緒申鐃緒申鐃緒申鐃緒申
2552 *
2553 */
2554 ZEND_FUNCTION(xnp_get_index_permission)
2555 {
2556 long sid;
2557 indexid_t xid;
2558 long op;
2559
2560 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lll",
2561 &sid, &xid, &op) == FAILURE) {
2562 fprintf( stderr, "error occured " );
2563 return;
2564 }
2565 RETURN_BOOL( getIndexPermission( (sessionid_t)sid, xid, op ) );
2566 }
2567
2568
2569 /**
2570 *
2571 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2572 * @refer certify_t
2573 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2574 * @param xid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2575 * @param iid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2576 * @param state 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2577 * @return true 鐃緒申鐃緒申鐃緒申鐃緒申
2578 * @return false 鐃緒申鐃緒申鐃緒申鐃緒申
2579 *
2580 */
2581 ZEND_FUNCTION(xnp_get_certify_permission)
2582 {
2583 long sid;
2584 itemid_t iid;
2585 indexid_t xid;
2586 certify_t state;
2587
2588 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "llll",
2589 &sid, &xid, &iid, &state) == FAILURE) {
2590 fprintf( stderr, "error occured " );
2591 return;
2592 }
2593 RETURN_BOOL( getCertifyPermission( (sessionid_t)sid, xid, iid, state ) );
2594 }
2595
2596
2597 /**
2598 *
2599 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2600 * @refer certify_t
2601 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2602 * @param xid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2603 * @param iid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2604 * @param state 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2605 * @return RES_OK
2606 * @return RES_NO_WRITE_ACCESS_RIGHT
2607 *
2608 */
2609 ZEND_FUNCTION(xnp_get_certify_state)
2610 {
2611 long sid;
2612 indexid_t xid;
2613 itemid_t iid;
2614 zval *zstate;
2615 result_t result = RES_ERROR;
2616
2617 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lllz",
2618 &sid, &xid, &iid, &zstate) == FAILURE) {
2619 fprintf( stderr, "error occured " );
2620 return;
2621 }
2622 certify_t st;
2623 result = getCertifyState( (sessionid_t)sid, xid, iid, &st );
2624 if ( RES_OK == result ){
2625 zstate -> type = IS_LONG;
2626 zstate -> value.lval = st;
2627 }
2628 RETURN_LONG( result );
2629 }
2630
2631
2632 /**
2633 *
2634 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2635 * @refer certify_t
2636 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2637 * @param xid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2638 * @param iid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2639 * @param state 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2640 * @return RES_OK
2641 * @return RES_NO_WRITE_ACCESS_RIGHT
2642 *
2643 */
2644 ZEND_FUNCTION(xnp_set_certify_state)
2645 {
2646 long sid;
2647 indexid_t xid;
2648 itemid_t iid;
2649 certify_t state;
2650 result_t result = RES_ERROR;
2651
2652 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "llll",
2653 &sid, &xid, &iid, &state) == FAILURE) {
2654 fprintf( stderr, "error occured " );
2655 return;
2656 }
2657 result = setCertifyState( (sessionid_t)sid, xid, iid, state );
2658 RETURN_LONG( result );
2659 }
2660
2661
2662 /**
2663 *
2664 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2665 *
2666 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2667 * @param itemid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2668 * @param log 鐃緒申鐃緒申鐃緒申鐃緒申
2669 * @return RES_OK
2670 * @return RES_NO_SUCH_SESSION
2671 * @return RES_DB_QUERY_ERROR
2672 * @return RES_NO_WRITE_ACCESS_RIGHT
2673 * @return RES_DB_NOT_INITIALIZED
2674 * @return RES_ERROR
2675 *
2676 */
2677 ZEND_FUNCTION(xnp_insert_change_log)
2678 {
2679 long sid;
2680 itemid_t iid;
2681 zval *zlog;
2682 result_t result = RES_ERROR;
2683
2684 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "llz",
2685 &sid, &iid, &zlog) == FAILURE) {
2686 fprintf( stderr, "error occured " );
2687 return;
2688 }
2689
2690 result = insertChangeLog( sid, iid, getZvalString( &zlog ) );
2691 RETURN_LONG( result );
2692 }
2693
2694
2695 /**
2696 *
2697 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2698 *
2699 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2700 * @param itemid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2701 * @param logs 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2702 * @param logsLen logs鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2703 * @return RES_OK
2704 * @return RES_NO_SUCH_SESSION
2705 * @return RES_NO_READ_ACCESS_RIGHT
2706 * @return RES_DB_NOT_INITIALIZED
2707 * @return RES_ERROR
2708 *
2709 */
2710 ZEND_FUNCTION(xnp_get_change_logs)
2711 {
2712 result_t result;
2713 long sid;
2714 itemid_t iid;
2715 zval *zlogs;
2716
2717 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lla",
2718 &sid, &iid, &zlogs) == FAILURE) {
2719 return;
2720 }
2721
2722 const changelog_t *plogs;
2723 int logLen;
2724 result = getChangeLogs( (sessionid_t)sid, iid, &plogs, &logLen );
2725 if ( RES_OK == result ){
2726 zend_hash_clean( zlogs -> value.ht );
2727 for( int i = 0; i < logLen; i++ ){
2728 zval *new_array;
2729 MAKE_STD_ZVAL(new_array);
2730 if(array_init(new_array) != SUCCESS){
2731 result = RES_ERROR;
2732 break;
2733 }
2734 add_index_zval( zlogs, i, new_array );
2735 changelogToZval( &plogs[ i ], new_array );
2736 }
2737 freeChangeLog( plogs );
2738 }
2739 RETURN_LONG(result);
2740 }
2741
2742
2743 /**
2744 *
2745 * 鐃緒申鐃緒申鐃緒申key鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申vaule鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2746 * value鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申freeString鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2747 * @param key 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2748 * @param value 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2749 *
2750 * @return RES_OK
2751 * @return RES_DB_QUERY_ERROR
2752 * @return RES_ERROR
2753 */
2754 ZEND_FUNCTION(xnp_get_config_value)
2755 {
2756 char* name;
2757 int nameLen;
2758 zval* zvalue;
2759 char* value = 0;
2760
2761 result_t result = RES_ERROR;
2762
2763 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz",
2764 &name, &nameLen, &zvalue ) == FAILURE) {
2765 return;
2766 }
2767
2768 result = getConfigValue( name, &value );
2769 if( result == RES_OK ){
2770 ZVAL_STRING( zvalue, value, true/*duplicate*/ );
2771 }
2772 if ( value != 0 )
2773 freeString( value );
2774 RETURN_LONG( result );
2775 }
2776
2777
2778 /**
2779 *
2780 * 鐃緒申鐃緒申鐃緒申key鐃緒申鐃緒申鐃緒申vaule鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2781 *
2782 * @param key 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2783 * @param value 鐃緒申鐃緒申鐃緒申
2784 *
2785 * @return RES_OK
2786 * @return RES_DB_QUERY_ERROR
2787 * @return RES_ERROR
2788 */
2789 ZEND_FUNCTION(xnp_set_config_value)
2790 {
2791 char *name;
2792 int nameLen;
2793 char *value;
2794 int valueLen;
2795 result_t result = RES_ERROR;
2796 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss",
2797 &name, &nameLen, &value, &valueLen ) == FAILURE) {
2798 return;
2799 }
2800 result = setConfigValue( name, value );
2801 RETURN_LONG( result );
2802 }
2803
2804
2805 /**
2806 *
2807 * 鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2808 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申.
2809 *
2810 * int xnp_dump_item_id( int sid, array cri, array iids )
2811 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2812 * @param cri 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2813 * @param iids 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2814 * @return RES_OK
2815 * @return RES_DB_NOT_INITIALIZED
2816 * @return RES_NO_SUCH_SESSION
2817 * @return RES_DB_QUERY_ERROR
2818 *
2819 */
2820 ZEND_FUNCTION(xnp_dump_item_id)
2821 {
2822 long sid;
2823 zval *zcriteria;
2824 zval *ziids;
2825 result_t result = RES_ERROR;
2826
2827 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "laa",
2828 &sid, &zcriteria, &ziids) == FAILURE) {
2829 fprintf( stderr, "error occured " );
2830 return;
2831 }
2832
2833 zCriteria_t zcri(zcriteria);
2834 result = zcri.getResult();
2835 if ( RES_OK == result ){
2836 const itemid_t *piids;
2837 int iidsLen;
2838 result = dumpItemID( (sessionid_t)sid, &zcri, &piids, &iidsLen );
2839 if ( RES_OK == result ){
2840 itemidsToZval( piids, iidsLen, &ziids );
2841 freeItemID( piids );
2842 }
2843 }
2844
2845 RETURN_LONG( result );
2846 }
2847
2848
2849 /**
2850 *
2851 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2852 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2853 * @param binderid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2854 * @param cri 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2855 * @param iids 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2856 * @param iidsLen iids鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2857 * @return RES_OK
2858 * @return RES_DB_NOT_INITIALIZED
2859 * @return RES_NO_SUCH_SESSION
2860 * @return RES_DB_QUERY_ERROR
2861 * @return RES_ERROR
2862 *
2863 */
2864 ZEND_FUNCTION(xnp_get_item_id_by_binder_id)
2865 {
2866 result_t result;
2867 long sid;
2868 itemid_t iid;
2869 zval *zcriteria;
2870 zval *ziids;
2871
2872 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "llaa",
2873 &sid, &iid, &zcriteria, &ziids) == FAILURE) {
2874 return;
2875 }
2876
2877 zCriteria_t zcri(zcriteria);
2878 result = zcri.getResult();
2879 if ( RES_OK == result ){
2880 const itemid_t *pitemids;
2881 int itemidLen;
2882 result = getItemIDByBinderID( (sessionid_t)sid, iid, &zcri, &pitemids, &itemidLen );
2883 if ( RES_OK == result ){
2884 itemidsToZval( pitemids, itemidLen, &ziids );
2885 freeItemID( pitemids );
2886 }
2887 }
2888 RETURN_LONG(result);
2889 }
2890
2891
2892 /**
2893 *
2894 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2895 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2896 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2897 *
2898 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2899 * @param xid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2900 * @param cri 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2901 * @param iids 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2902 * @param iidsLen iids鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2903 * @return RES_OK
2904 * @return RES_DB_NOT_INITIALIZED
2905 * @return RES_NO_SUCH_SESSION
2906 * @return RES_DB_QUERY_ERROR
2907 * @return RES_ERROR
2908 *
2909 */
2910 ZEND_FUNCTION(xnp_get_item_id_by_index_id)
2911 {
2912 result_t result;
2913 long sid;
2914 indexid_t xid;
2915 zval *zcriteria;
2916 zval *ziids;
2917
2918 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "llaa",
2919 &sid, &xid, &zcriteria, &ziids) == FAILURE) {
2920 return;
2921 }
2922
2923 zCriteria_t zcri(zcriteria);
2924 result = zcri.getResult();
2925 if ( RES_OK == result ){
2926 const itemid_t *pitemids;
2927 int itemidLen;
2928 result = getItemIDByIndexID( (sessionid_t)sid, xid, &zcri, &pitemids, &itemidLen );
2929 if ( RES_OK == result ){
2930 itemidsToZval( pitemids, itemidLen, &ziids );
2931 freeItemID( pitemids );
2932 }
2933 }
2934 RETURN_LONG(result);
2935 }
2936
2937
2938 ZEND_FUNCTION(xnp_get_overlapped_items)
2939 {
2940 RETURN_LONG( RES_ERROR );
2941 }
2942
2943 /**
2944 *
2945 * 鐃緒申鐃緒申鐃緒申鐃緒申(Basic Information)鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2946 * Platform鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2947 *
2948 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2949 * @param item 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2950 * @param itemid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2951 * @return RES_OK
2952 * @return RES_ERROR
2953 * @return RES_NO_SUCH_SESSION
2954 * @return RES_DB_QUERY_ERROR
2955 * @return RES_DB_NOT_INITIALIZED
2956 * @return RES_NO_WRITE_ACCESS_RIGHT
2957 *
2958 */
2959 ZEND_FUNCTION(xnp_insert_item)
2960 {
2961 long sid;
2962 zval *ziid;
2963 zval *zitem;
2964 item_t item;
2965 itemid_t iid;
2966 result_t result = RES_ERROR;
2967
2968 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "laz",
2969 &sid, &zitem, &ziid) == FAILURE) {
2970 fprintf( stderr, "error occured " );
2971 return;
2972 }
2973
2974 zvalToItem( zitem, &item );
2975 result = insertItem( (sessionid_t)sid, &item, &iid );
2976 if ( RES_OK == result ){
2977 ziid -> type = IS_LONG;
2978 ziid -> value.lval = iid;
2979 }
2980 RETURN_LONG( result );
2981 }
2982
2983 /**
2984 *
2985 * 鐃緒申鐃緒申鐃緒申鐃緒申(Basic Information)鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2986 * Platform鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
2987 *
2988 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
2989 * @param item 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2990 * @param itemid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
2991 * @return RES_OK
2992 * @return RES_ERROR
2993 * @return RES_NO_SUCH_SESSION
2994 * @return RES_DB_QUERY_ERROR
2995 * @return RES_DB_NOT_INITIALIZED
2996 * @return RES_NO_WRITE_ACCESS_RIGHT
2997 *
2998 */
2999 ZEND_FUNCTION(xnp_insert_item_direct)
3000 {
3001 long sid;
3002 zval *ziid;
3003 zval *zitem;
3004 item_t item;
3005 itemid_t iid;
3006 result_t result = RES_ERROR;
3007
3008 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "laz",
3009 &sid, &zitem, &ziid) == FAILURE) {
3010 fprintf( stderr, "error occured " );
3011 return;
3012 }
3013
3014 zvalToItem( zitem, &item );
3015 result = insertItemDirect( (sessionid_t)sid, &item, &iid );
3016 if ( RES_OK == result ){
3017 ziid -> type = IS_LONG;
3018 ziid -> value.lval = iid;
3019 }
3020 RETURN_LONG( result );
3021 }
3022
3023 /**
3024 *
3025 * 鐃緒申鐃緒申鐃緒申鐃緒申(Basic Information)鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
3026 * Platform鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
3027 * item鐃緒申item_id鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
3028 *
3029 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
3030 * @param item 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
3031 * @return RES_OK
3032 * @return RES_ERROR
3033 * @return RES_NO_SUCH_SESSION
3034 * @return RES_DB_QUERY_ERROR
3035 * @return RES_DB_NOT_INITIALIZED
3036 * @return RES_NO_WRITE_ACCESS_RIGHT
3037 */
3038 ZEND_FUNCTION(xnp_update_item)
3039 {
3040 long sid;
3041 zval *zitem;
3042 item_t item;
3043 result_t result = RES_ERROR;
3044
3045 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "la",
3046 &sid, &zitem) == FAILURE) {
3047 fprintf( stderr, "error occured " );
3048 return;
3049 }
3050
3051 zvalToItem( zitem, &item );
3052 result = updateItem( (sessionid_t)sid, &item );
3053 RETURN_LONG( result );
3054 }
3055
3056 /**
3057 *
3058 * 鐃緒申鐃緒申鐃緒申鐃緒申(Basic Information)鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
3059 *
3060 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
3061 * @param item 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
3062 * @return RES_OK
3063 * @return RES_ERROR
3064 * @return RES_NO_SUCH_SESSION
3065 * @return RES_DB_QUERY_ERROR
3066 * @return RES_DB_NOT_INITIALIZED
3067 * @return RES_NO_WRITE_ACCESS_RIGHT
3068 */
3069 ZEND_FUNCTION(xnp_delete_item)
3070 {
3071 long sid;
3072 itemid_t iid;
3073 result_t result = RES_ERROR;
3074
3075 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll",
3076 &sid, &iid) == FAILURE) {
3077 fprintf( stderr, "error occured " );
3078 return;
3079 }
3080 result = deleteItem( (sessionid_t)sid, iid );
3081 RETURN_LONG( result );
3082 }
3083
3084
3085 /**
3086 *
3087 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
3088 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
3089 *
3090 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
3091 * @param uid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
3092 * @param iids 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
3093 * @param iidsLen iids鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
3094 * @return RES_OK
3095 * @return RES_DB_NOT_INITIALIZED
3096 * @return RES_NO_SUCH_SESSION
3097 * @return RES_DB_QUERY_ERROR
3098 * @return RES_ERROR
3099 *
3100 */
3101 //result_t getPrivateItemID( sessionid_t sid, userid_t uid, const itemid_t** iids, int* iidsLen )
3102 ZEND_FUNCTION(xnp_get_private_item_id)
3103 {
3104 long sid;
3105 userid_t uid;
3106 zval* ziids;
3107
3108 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lla",
3109 &sid, &uid, &ziids) == FAILURE) {
3110 return;
3111 }
3112
3113 const itemid_t *piids;
3114 int iidsLen;
3115 result_t result = getPrivateItemID( (sessionid_t)sid, uid, &piids, &iidsLen );
3116 if ( RES_OK == result ){
3117 itemidsToZval( piids, iidsLen, &ziids );
3118 freeItemID( piids );
3119 }
3120
3121 RETURN_LONG( result );
3122
3123 }
3124
3125 /**
3126 *
3127 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
3128 *
3129 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
3130 * @param uid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
3131 * @param iids 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
3132 * @param iidsLen iids鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
3133 * @return RES_OK
3134 * @return RES_DB_NOT_INITIALIZED
3135 * @return RES_NO_SUCH_SESSION
3136 * @return RES_DB_QUERY_ERROR
3137 * @return RES_ERROR
3138 *
3139 */
3140 //result_t getGroupItemID( sessionid_t sid, groupid_t gid, const itemid_t** iids, int* iidsLen )
3141 ZEND_FUNCTION(xnp_get_group_item_id)
3142 {
3143 long sid;
3144 groupid_t gid;
3145 zval* ziids;
3146
3147 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lla",
3148 &sid, &gid, &ziids) == FAILURE) {
3149 return;
3150 }
3151
3152 const itemid_t *piids;
3153 int iidsLen;
3154 result_t result = getGroupItemID( (sessionid_t)sid, gid, &piids, &iidsLen );
3155 if ( RES_OK == result ){
3156 itemidsToZval( piids, iidsLen, &ziids );
3157 freeItemID( piids );
3158 }
3159
3160 RETURN_LONG( result );
3161 }
3162
3163
3164 /**
3165 *
3166 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
3167 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申freeItem鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
3168 *
3169 * @refer freeItem
3170 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
3171 * @param iid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
3172 * @param item 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
3173 * @return RES_OK
3174 * @return RES_DB_NOT_INITIALIZED
3175 * @return RES_NO_SUCH_SESSION
3176 * @return RES_NO_SUCH_ITEM
3177 * @return RES_DB_QUERY_ERROR
3178 *
3179 */
3180 ZEND_FUNCTION(xnp_get_item)
3181 {
3182 long sid;
3183 long iid;
3184 zval *zitem;
3185 result_t result = RES_ERROR;
3186
3187 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lla",
3188 &sid, &iid, &zitem) == FAILURE) {
3189 fprintf( stderr, "error occured " );
3190 return;
3191 }
3192
3193 const item_t* pitem;
3194 result = getItem( (sessionid_t)sid, iid, &pitem );
3195 if ( RES_OK == result ){
3196 itemToZval( pitem, zitem );
3197 freeItem( pitem );
3198 }
3199 RETURN_LONG( result );
3200 }
3201
3202
3203 /**
3204 *
3205 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
3206 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申freeItem鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
3207 *
3208 * @refer freeItem
3209 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
3210 * @param iids 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申
3211 * @param iidsLen iids鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
3212 * @param cri 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
3213 * @param items 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
3214 * @param itemsLen 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申*items鐃緒申鐃緒申鐃緒申鐃緒申)
3215 * @return RES_OK
3216 * @return RES_DB_NOT_INITIALIZED
3217 * @return RES_NO_SUCH_SESSION
3218 * @return RES_DB_QUERY_ERROR
3219 *
3220 */
3221 ZEND_FUNCTION(xnp_get_items)
3222 {
3223 result_t result;
3224 long sid;
3225 zval *ziids;
3226 zval *zcriteria;
3227 zval *zitem;
3228
3229 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "laaa",
3230 &sid, &ziids, &zcriteria, &zitem) == FAILURE) {
3231 return;
3232 }
3233
3234 zCriteria_t zcri(zcriteria);
3235 result = zcri.getResult();
3236 if ( RES_OK == result ){
3237 zIIDs_t zIIDs(ziids);
3238 result = zIIDs.getResult();
3239 if ( RES_OK == result ){
3240 const item_t *pitems;
3241 int itemLen;
3242 result = getItems( (sessionid_t)sid,
3243 zIIDs.getPIID(), zIIDs.getLen(),
3244 &zcri, &pitems, &itemLen );
3245 if ( RES_OK == result ){
3246 itemsToZval( pitems, itemLen, zitem );
3247 freeItem( pitems );
3248 }
3249 }
3250 }
3251
3252 RETURN_LONG(result);
3253 }
3254
3255
3256 /**
3257 *
3258 *
3259 * @param pmid PUBMEDID
3260 * @param pubmed 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申pubmed_t鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
3261 *
3262 *
3263 *
3264 */
3265 ZEND_FUNCTION(xnp_pubmed_complete)
3266 {
3267 long pmid;
3268 zval *zpubmed;
3269 result_t result = RES_ERROR;
3270
3271 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "la",
3272 &pmid, &zpubmed) == FAILURE) {
3273 fprintf( stderr, "error occured " );
3274 return;
3275 }
3276
3277 const pubmed_t* ppubmed;
3278 result = pubmedComplete( pmid, &ppubmed );
3279 if ( RES_OK == result ){
3280 pubmedToZval( ppubmed, zpubmed );
3281 freePubmed( ppubmed );
3282 }
3283 RETURN_LONG( result );
3284 }
3285
3286
3287 /**
3288 *
3289 *