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