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