/******************************************************************* * fm_cust_pol_valid_passwd() * * Validate the given passwd according to the given poid type. * *******************************************************************/ static void fm_cust_pol_valid_passwd( pcm_context_t *ctxp, pin_flist_t *in_flistp, pin_flist_t **out_flistpp, pin_errbuf_t *ebufp) { pin_flist_t *r_flistp = NULL; poid_t *o_pdp; const char *o_type = NULL; if (PIN_ERR_IS_ERR(ebufp)) return; PIN_ERR_CLEAR_ERR(ebufp); /*********************************************************** * Create outgoing flist ***********************************************************/ r_flistp = PIN_FLIST_CREATE(ebufp); *out_flistpp = r_flistp; /*********************************************************** * Get (and add) the object poid. ***********************************************************/ o_pdp = (poid_t *)PIN_FLIST_FLD_GET(in_flistp, PIN_FLD_POID, 0, ebufp); PIN_FLIST_FLD_SET(r_flistp, PIN_FLD_POID, (void *)o_pdp, ebufp); /*********************************************************** * We might have different rules for different services. ***********************************************************/ o_type = PIN_POID_GET_TYPE(o_pdp); if (!strncmp(o_type, "/service", 8)) { /* Any service password */ fm_cust_pol_valid_pwd_srvc(ctxp, in_flistp, r_flistp, ebufp); } else { /* Error - unknown/usupported type */ pin_set_err(ebufp, PIN_ERRLOC_FM, PIN_ERRCLASS_SYSTEM_DETERMINATE, PIN_ERR_BAD_POID_TYPE, PIN_FLD_POID, 0, 0); } /*********************************************************** * Error? ***********************************************************/ if (PIN_ERR_IS_ERR(ebufp)) { PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR, "fm_cust_pol_valid_passwd error", ebufp); } return; }
/******************************************************************* * fm_rate_pol_get_taxcode(): * * This policy will return the cached list of taxcodes * in an flist. * *******************************************************************/ static void fm_rate_pol_get_taxcode( pcm_context_t *ctxp, pin_flist_t *i_flistp, pin_flist_t **o_flistpp, pin_errbuf_t *ebufp) { void *vp = NULL; pin_flist_t *flistp = NULL; char *taxCode = NULL; u_int32 glid = 0; pin_cookie_t cookie = NULL; int32 elemid = 0; if (PIN_ERR_IS_ERR(ebufp)) { return; /*****/ } PIN_ERR_CLEAR_ERR(ebufp); *o_flistpp = NULL; /* * set something to return */ *o_flistpp = PIN_FLIST_CREATE(ebufp); vp = PIN_FLIST_FLD_GET(i_flistp, PIN_FLD_POID, 0, ebufp); PIN_FLIST_FLD_SET(*o_flistpp, PIN_FLD_POID, (void *)vp, ebufp); /* * populate the return flist with cached list of taxcodes */ fm_utils_tax_get_taxcodes(*o_flistpp, ebufp); vp = PIN_FLIST_FLD_GET(i_flistp,PIN_FLD_GL_ID, 1, ebufp); if (vp) { while ((flistp = PIN_FLIST_ELEM_GET_NEXT(*o_flistpp, PIN_FLD_RESULTS, &elemid, 1, &cookie, ebufp)) != (pin_flist_t *)NULL) { /* Get the tax code from the results array */ taxCode = (char*)PIN_FLIST_FLD_GET(flistp,PIN_FLD_TAX_CODE, 0, ebufp); fm_utils_taxcode_to_glid(ctxp, taxCode, &glid, ebufp); PIN_FLIST_FLD_SET(flistp, PIN_FLD_GL_ID, (void *)&glid, ebufp); } } return; }
/************************************************************************ * fm_bill_pol_reverse_payment() ************************************************************************/ static void fm_bill_pol_reverse_payment( pcm_context_t *ctxp, int flags, pin_flist_t *in_flistp, pin_flist_t **ret_flistpp, pin_errbuf_t *ebufp) { poid_t *a_pdp = NULL; pin_flist_t *inh_flistp = NULL; if (PIN_ERR_IS_ERR(ebufp)){ return; } PIN_ERR_CLEAR_ERR(ebufp); *ret_flistpp = PIN_FLIST_CREATE(ebufp); /*********************************************************** * Get and set PIN_FLD_POID in the output flist ***********************************************************/ a_pdp = PIN_FLIST_FLD_GET(in_flistp, PIN_FLD_POID, 0, ebufp); PIN_FLIST_FLD_SET(*ret_flistpp, PIN_FLD_POID, (void *)a_pdp, ebufp); /*********************************************************** * Get INHERITED_INFO from the input flist and * Set in the ouput flist if present ***********************************************************/ inh_flistp = PIN_FLIST_SUBSTR_GET(in_flistp, PIN_FLD_INHERITED_INFO, 1, ebufp); if ( inh_flistp ) { PIN_FLIST_SUBSTR_SET(*ret_flistpp, inh_flistp, PIN_FLD_INHERITED_INFO, ebufp); } fm_bill_pol_reverse_payment_writeoff_account(ctxp, flags, in_flistp, ebufp); if (PIN_ERR_IS_ERR(ebufp)) { PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR, "fm_bill_pol_reverse_payment error", ebufp); } else { PIN_ERR_CLEAR_ERR(ebufp); } return; }
/******************************************************************* * fm_rate_pol_tax_loc(): * * This policy could do several things to prepare the input * flist for the tax calculation. It could locate the locale's * involved. * * The return flist should look like this: * 0 PIN_FLD_POID POID [0] 0.0.0.1 /event/session -1 0 * 0 PIN_FLD_ORDER_ACCEPT STR [0] "Cupertino;CA;95014;US" * 0 PIN_FLD_ORDER_ORIGIN STR [0] "Cupertino;CA;95014;US" * 0 PIN_FLD_SHIP_FROM STR [0] "Cupertino;CA;95014;US" * 0 PIN_FLD_SHIP_TO STR [0] "Cupertino ;CA ;95014 ;USA" * * The default implementation is just to return the POID only. * *******************************************************************/ static void fm_rate_pol_tax_loc( pcm_context_t *ctxp, pin_flist_t *i_flistp, pin_flist_t **o_flistpp, pin_errbuf_t *ebufp) { void *vp = NULL; if (PIN_ERR_IS_ERR(ebufp)) return; PIN_ERR_CLEAR_ERR(ebufp); *o_flistpp = PIN_FLIST_CREATE(ebufp); vp = PIN_FLIST_FLD_GET(i_flistp, PIN_FLD_POID, 0, ebufp); if (vp) { PIN_FLIST_FLD_SET(*o_flistpp, PIN_FLD_POID, (void *)vp, ebufp); } return; }
/******************************************************************* * fm_cust_pol_pre_commit() * * Pre-creation legacy system hook. * * XXX NOOP - STUBBED ONLY XXX * *******************************************************************/ static void fm_cust_pol_pre_commit( pcm_context_t *ctxp, u_int flags, pin_flist_t *in_flistp, pin_flist_t **out_flistpp, pin_errbuf_t *ebufp) { void *vp; if (PIN_ERR_IS_ERR(ebufp)) return; PIN_ERR_CLEAR_ERR(ebufp); /*********************************************************** * Create outgoing flist ***********************************************************/ *out_flistpp = PIN_FLIST_CREATE(ebufp); vp = PIN_FLIST_FLD_GET(in_flistp, PIN_FLD_POID, 0, ebufp); PIN_FLIST_FLD_SET(*out_flistpp, PIN_FLD_POID, vp, ebufp); /*********************************************************** * Check if Out Of Order detection feature is enabled. * If so, create the /profile/event_ordering object. ***********************************************************/ if (fm_cust_pol_pre_commit_is_OOD_feature_enabled(ctxp, in_flistp, ebufp)) { fm_cust_pol_pre_commit_create_profile_OOD_obj(ctxp, flags, in_flistp, ebufp); } /*********************************************************** * Error? ***********************************************************/ if (PIN_ERR_IS_ERR(ebufp)) { PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR, "fm_cust_pol_pre_commit error", ebufp); } return; }
/* * build the return list in case of a read error for func * fm_cust_pol_is_brandname_unique_within_brand(). */ static void fm_cust_pol_read_err_return_list( poid_t *poidp, char *namep, pin_flist_t **r_flistpp, pin_errbuf_t *ebufp) { *r_flistpp = PIN_FLIST_CREATE(ebufp); PIN_FLIST_FLD_SET(*r_flistpp, PIN_FLD_POID, (void *)poidp, ebufp); fm_cust_pol_valid_add_fail(*r_flistpp, PIN_FLD_NAME, 0, PIN_CUST_VAL_ERR_MISSING, PIN_CUST_BAD_VALUE_ERR_MSG, (void *)namep, ebufp); pin_set_err(ebufp, PIN_ERRLOC_FM, PIN_ERRCLASS_SYSTEM_DETERMINATE, PIN_ERR_BAD_READ, PIN_FLD_NAME, 0, 0); }
void fm_cust_pol_create_metafield_obj( pcm_context_t *ctxp, int32 flags, pin_flist_t *in_flistp, pin_flist_t **ret_flistpp, pin_errbuf_t *ebufp) { void *vp = NULL; int count =0; int64 database = pcm_get_current_db_no(ctxp); pin_flist_t *i_flist = NULL; pin_flist_t *sub_flistp = NULL; pin_flist_t *r_flistp = NULL; char *program_name = NULL; char *class_name= NULL; char *default_value= NULL; int fld_type=0; if(PIN_ERRBUF_IS_ERR(ebufp)) return; PIN_ERR_CLEAR_ERR(ebufp); *ret_flistpp = NULL; //Count FIELDS array count = PIN_FLIST_ELEM_COUNT(in_flistp,PIN_FLD_VALUES,ebufp); if (count==0) return; if(count==1) { i_flist= PIN_FLIST_CREATE(ebufp); vp = PIN_FLIST_FLD_GET(in_flistp,PIN_FLD_POID,1,ebufp); PIN_FLIST_FLD_SET(i_flist,PIN_FLD_POID,(void*)vp,ebufp); sub_flistp = PIN_FLIST_ELEM_GET(in_flistp, PIN_FLD_VALUES,PIN_ELEMID_ANY, 1, ebufp); program_name = PIN_FLIST_FLD_GET(sub_flistp,PIN_FLD_NAME,1,ebufp); PIN_FLIST_FLD_SET(i_flist,PIN_FLD_NAME,program_name,ebufp); fld_type =*(int*) PIN_FLIST_FLD_GET(sub_flistp,PIN_FLD_TYPE,1,ebufp); PIN_FLIST_FLD_SET(i_flist,PIN_FLD_TYPE,&fld_type,ebufp); class_name=PIN_FLIST_FLD_GET(sub_flistp,PIN_FLD_CLASS_NAME,1,ebufp); PIN_FLIST_FLD_SET(i_flist,PIN_FLD_CLASS_NAME,class_name,ebufp); default_value=PIN_FLIST_FLD_GET(sub_flistp,PIN_FLD_DEFAULT_VALUE,1,ebufp); if(default_value) PIN_FLIST_FLD_SET(i_flist,PIN_FLD_DEFAULT_VALUE,default_value,ebufp); if (PIN_ERRBUF_IS_ERR(ebufp)) { PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,"Error Occured while creating the input flist",ebufp); return; } PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,"input flist for metafield obj ",i_flist); //Call pcm_op_create_obj PCM_OP(ctxp,PCM_OP_CREATE_OBJ,0,i_flist,ret_flistpp,ebufp); if(PIN_ERRBUF_IS_ERR(ebufp)) { PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,"Error Occured while calling PCM_OP_CREATE_OBJ",ebufp); return; } } else if (count >1) { //Call pcm_op_bulk_create_obj PCM_OP(ctxp,PCM_OP_BULK_CREATE_OBJ ,0,in_flistp,ret_flistpp,ebufp); if(PIN_ERRBUF_IS_ERR(ebufp)) { PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,"Error Occured while calling PCM_OP_BULK_CREATE_OBJ" ,ebufp); return; } } if(ret_flistpp) PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,"Output flist for metafield obj ",*ret_flistpp); return; }
//**************************************************** // updateStatus // Pre: // Post: // bool bs_UpdateStatus::updateStatus( pin_Session * pinp, poid_t * account_pdp, poid_t * service_pdp, int status, int status_flags, string source, string description, pin_flist_t **return_flistpp, pin_errbuf_t *ebufp ) { pin_flist_t * x_flistp = NULL; pin_flist_t * d_flistp = NULL; pin_flist_t * f_flistp = NULL; pin_flist_t * f_outflistp = NULL; pin_errbuf_t localebuf; int flag=status_flags; poid_t * pdp = NULL; void * vp = NULL; bool rc; const string this_program("updateStatus"); if ( source.empty() ) { source.assign(this_program); } if ( description.empty() ) { description.assign(this_program); } PIN_ERR_CLEAR_ERR(ebufp); //--enter function-------------- PIN_ERR_LOG_MSG(PIN_ERR_LEVEL_DEBUG, (char*)this_program.c_str() ); /*--- Create set_status ---*/ if ( status == PIN_STATUS_ACTIVE && status_flags <= 0 ) { PIN_ERR_LOG_MSG(PIN_ERR_LEVEL_ERROR, (char*)"This is an activation - get existing flags" ); PIN_ERR_CLEAR_ERR(&localebuf); pdp = ( pin_poid_is_null(service_pdp)) ? account_pdp : service_pdp; f_flistp = PIN_FLIST_CREATE(ebufp); PIN_FLIST_FLD_SET(f_flistp, PIN_FLD_POID, (void*)pdp, &localebuf); PIN_FLIST_FLD_SET(f_flistp, PIN_FLD_STATUS_FLAGS, (void*)NULL, &localebuf); if ( pinp->call_opcode( PCM_OP_READ_FLDS, 0, f_flistp, &f_outflistp, &localebuf)) { if ((vp=PIN_FLIST_FLD_GET( f_outflistp, PIN_FLD_STATUS_FLAGS, 1, &localebuf )) != NULL ) status_flags = *(int*)vp; } if (f_flistp) PIN_FLIST_DESTROY(f_flistp,NULL); f_flistp = NULL; if (f_outflistp) PIN_FLIST_DESTROY_EX(&f_outflistp,NULL); f_outflistp = NULL; } if ( status_flags < 0) { status_flags = 0; } /*--- Create set_status ---*/ x_flistp = PIN_FLIST_CREATE(ebufp); PIN_FLIST_FLD_SET(x_flistp, PIN_FLD_POID, account_pdp, ebufp); if ( ! pin_poid_is_null(service_pdp) ) PIN_FLIST_FLD_SET(x_flistp, PIN_FLD_SERVICE_OBJ, service_pdp, ebufp); PIN_FLIST_FLD_SET(x_flistp, PIN_FLD_PROGRAM_NAME, (void*)source.c_str(), ebufp); PIN_FLIST_FLD_SET(x_flistp, PIN_FLD_DESCR, (void*)description.c_str(), ebufp); d_flistp = PIN_FLIST_ELEM_ADD( x_flistp, PIN_FLD_STATUSES, PIN_ELEMID_ASSIGN, ebufp ); PIN_FLIST_FLD_SET(d_flistp, PIN_FLD_STATUS, (void*)&status, ebufp); PIN_FLIST_FLD_SET(d_flistp, PIN_FLD_STATUS_FLAGS, (void*)&status_flags, ebufp); if ( (! pin_poid_is_null(service_pdp)) && (status == PIN_STATUS_CLOSED) ) { rc = pinp->call_opcode( PCM_OP_CUST_SET_STATUS, 0, x_flistp, return_flistpp, ebufp); } else { rc = pinp->call_opcode( UOL_OP_SET_STATUS, 0, x_flistp, return_flistpp, ebufp); } PIN_ERR_LOG_FLIST( PIN_ERR_LEVEL_DEBUG,(char*)"leaving bs_UpdateStatus::updateStatus" , *return_flistpp ); if (x_flistp) PIN_FLIST_DESTROY(x_flistp,NULL); return rc; }
static void fm_get_meta_field( pcm_context_t *ctxp, pin_flist_t *in_flistp, pin_flist_t **out_flistpp, pin_errbuf_t *ebufp) { pin_flist_t *keys_flistp = NULL; pin_flist_t *search_flistp = NULL; pin_flist_t *flistp = NULL; poid_t *s_pdp = NULL; poid_t *bi_pdp = NULL; int64 database = 0; int32 sflags = 256; int32 result = PIN_BOOLEAN_FALSE; void *vp = NULL; pin_decimal_t *zero_decimal = pin_decimal("0.0", ebufp); pin_flist_t *r_flistp = NULL; char *name = NULL; char *class_name = NULL; char *default_value; int32 count = 0; int32 cnt_flds = 0; int32 elemid = 1; pin_errbuf_t any_field_ebuf; pin_cookie_t cookie = NULL; pin_fld_num_t field = 0; int32 rec_id = 0; void *type = NULL; if (PIN_ERR_IS_ERR(ebufp)) { return; } PIN_ERR_CLEAR_ERR(ebufp); PIN_ERR_CLEAR_ERR(&any_field_ebuf); PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG, "fm_get_meta_field input flistp", in_flistp); bi_pdp = (poid_t *) PIN_FLIST_FLD_GET(in_flistp, PIN_FLD_POID,0, ebufp); count = PIN_FLIST_ELEM_COUNT (in_flistp, PIN_FLD_KEYS, ebufp); if (count == 0) { pin_set_err(ebufp, PIN_ERRLOC_FM, PIN_ERRCLASS_SYSTEM_DETERMINATE, PIN_ERR_BAD_OPCODE, 0, 0, count); PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR, "op_get_meta_field search flistp", ebufp); *out_flistpp = NULL; return; } else { keys_flistp = PIN_FLIST_ELEM_GET (in_flistp, PIN_FLD_KEYS, PIN_ELEMID_ANY, 0, ebufp); while (PIN_FLIST_ANY_GET_NEXT(keys_flistp, &field, &rec_id, &cookie, &any_field_ebuf) != NULL ){ cnt_flds = cnt_flds + 1; if (field == PIN_FLD_NAME){ name = (char *)PIN_FLIST_FLD_GET(keys_flistp, PIN_FLD_NAME, 1, ebufp); } if (field == PIN_FLD_CLASS_NAME){ class_name = PIN_FLIST_FLD_GET(keys_flistp, PIN_FLD_CLASS_NAME, 0, ebufp ); } if (field == PIN_FLD_TYPE){ type = PIN_FLIST_FLD_GET(keys_flistp, PIN_FLD_TYPE, 0, ebufp ); } } if ( cnt_flds == 1) { vp = (void *)"select X from /metafield where F1 = V1 "; } if ( cnt_flds == 2) { vp = (void *)"select X from /metafield where F1 = V1 and F2 = V2 "; } if ( cnt_flds == 3) { vp = (void *)"select X from /metafield where F1 = V1 and F2 = V2 and F3 = V3 "; } /********************************************************* * Create the search flist to search in the item objects *********************************************************/ search_flistp = PIN_FLIST_CREATE(ebufp); database = PIN_POID_GET_DB(bi_pdp); s_pdp = PIN_POID_CREATE(database, "/search", -1, ebufp); PIN_FLIST_FLD_PUT(search_flistp, PIN_FLD_POID, (void *)s_pdp, ebufp); /****************************************************************** * Set the search template. ******************************************************************/ PIN_FLIST_FLD_SET(search_flistp, PIN_FLD_TEMPLATE, vp, ebufp); PIN_FLIST_FLD_SET(search_flistp, PIN_FLD_FLAGS, (void *)&sflags, ebufp); /********************************************************* * Add the search arguments. *********************************************************/ if (name != NULL) { flistp = PIN_FLIST_ELEM_ADD(search_flistp, PIN_FLD_ARGS, elemid++, ebufp); PIN_FLIST_FLD_SET(flistp, PIN_FLD_NAME, name, ebufp); } /********************************************************* * Add the search arguments. *********************************************************/ if (class_name != NULL) { flistp = PIN_FLIST_ELEM_ADD(search_flistp, PIN_FLD_ARGS, elemid++, ebufp); PIN_FLIST_FLD_SET(flistp, PIN_FLD_CLASS_NAME, class_name, ebufp); } /********************************************************* * Add the search arguments. *********************************************************/ if (type != NULL) { flistp = PIN_FLIST_ELEM_ADD(search_flistp, PIN_FLD_ARGS, elemid++, ebufp); PIN_FLIST_FLD_SET(flistp, PIN_FLD_TYPE, type, ebufp); } /********************************************************* * Add the result array for the search. *********************************************************/ flistp = PIN_FLIST_ELEM_ADD(search_flistp, PIN_FLD_RESULTS, 0, ebufp); PIN_FLIST_FLD_SET(flistp, PIN_FLD_TYPE,(void *)NULL, ebufp); PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG, "op_get_meta_field search flistp", search_flistp); PCM_OP(ctxp, PCM_OP_SEARCH, 0, search_flistp, out_flistpp, ebufp); PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG, "op_get_meta_field search flistp", *out_flistpp); } }
/******************************************************************* * Main routine for the PCM_OP_PYMT_POL_SPEC_COLLECT operation. *******************************************************************/ void op_pymt_pol_spec_collect( cm_nap_connection_t *connp, int32 opcode, int32 flags, pin_flist_t *i_flistp, pin_flist_t **o_flistpp, pin_errbuf_t *ebufp) { pcm_context_t *ctxp = connp->dm_ctx; pin_flist_t *r_flistp = NULL; pin_bill_type_t *p_type = NULL; int32 result = PIN_BOOLEAN_FALSE; char *action = NULL; if (PIN_ERR_IS_ERR(ebufp)) return; PIN_ERR_CLEAR_ERR(ebufp); /*********************************************************** * Insanity check. ***********************************************************/ if (opcode != PCM_OP_PYMT_POL_SPEC_COLLECT) { pin_set_err(ebufp, PIN_ERRLOC_FM, PIN_ERRCLASS_SYSTEM_DETERMINATE, PIN_ERR_BAD_OPCODE, 0, 0, opcode); PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR, "op_pymt_pol_spec_collect opcode error", ebufp); return; } /*********************************************************** * Debug: What we got. ***********************************************************/ PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG, "op_pymt_pol_spec_collect input flist", i_flistp); /*********************************************************** * Prep the return flist. ***********************************************************/ r_flistp = PIN_FLIST_CREATE(ebufp); /*********************************************************** * Get the requested action. The following are supported: * - "commit customer" * ***********************************************************/ action = (char *)PIN_FLIST_FLD_GET(i_flistp, PIN_FLD_ACTION, 0, ebufp); if ((action != (char *)NULL) && (!strcmp(action, "commit customer"))) { p_type = (pin_bill_type_t *)PIN_FLIST_FLD_GET(i_flistp, PIN_FLD_PAY_TYPE, 0, ebufp); /*************************************************** * Credit card ***************************************************/ if ((p_type != NULL) && (*p_type == PIN_BILL_TYPE_CC)) { fm_pymt_pol_spec_collect_commit_cust_cc(ctxp, flags, i_flistp, r_flistp, ebufp); /*************************************************** * Direct Debit ***************************************************/ } else if ((p_type != NULL) && (*p_type == PIN_BILL_TYPE_DD)) { fm_pymt_pol_spec_collect_commit_cust_dd(ctxp, flags, i_flistp, r_flistp, ebufp); /*************************************************** * Assume nothing to collect ***************************************************/ } else { result = PIN_BOOLEAN_FALSE; PIN_FLIST_FLD_SET(r_flistp, PIN_FLD_BOOLEAN, (void *)&result, ebufp); } } else { pin_set_err(ebufp, PIN_ERRLOC_FM, PIN_ERRCLASS_SYSTEM_DETERMINATE, PIN_ERR_BAD_VALUE, PIN_FLD_ACTION, 0, 0); } /*********************************************************** * Results. ***********************************************************/ if (PIN_ERR_IS_ERR(ebufp)) { /*************************************************** * Log something and return nothing. ***************************************************/ PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR, "op_pymt_pol_spec_collect error", ebufp); PIN_FLIST_DESTROY_EX(&r_flistp, NULL); *o_flistpp = NULL; } else { /*************************************************** * Point the real return flist to the right thing. ***************************************************/ PIN_ERR_CLEAR_ERR(ebufp); *o_flistpp = r_flistp; /*************************************************** * Debug: What we're sending back. ***************************************************/ PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG, "op_pymt_pol_spec_collect return flist", r_flistp); } return; }
/******************************************************************* * Main routine for the PCM_OP_PRICE_POL_DELETE_DEAL operation. *******************************************************************/ EXPORT_OP void op_price_pol_delete_deal( cm_nap_connection_t *connp, u_int32 opcode, u_int32 flags, pin_flist_t *i_flistp, pin_flist_t **r_flistpp, pin_errbuf_t *ebufp) { pcm_context_t *ctxp = connp->dm_ctx; u_int32 result; void *vp = NULL; if (PIN_ERR_IS_ERR(ebufp)) return; PIN_ERR_CLEAR_ERR(ebufp); /* * Null out results until we have some. */ *r_flistpp = NULL; /* * Insanity check. */ if (opcode != PCM_OP_PRICE_POL_DELETE_DEAL) { pin_set_err(ebufp, PIN_ERRLOC_FM, PIN_ERRCLASS_SYSTEM_DETERMINATE, PIN_ERR_BAD_OPCODE, 0, 0, opcode); PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR, "bad opcode in op_price_pol_delete_deal", ebufp); return; } /* * Debug - What we got. */ PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG, "op_price_pol_delete_deal input flist", i_flistp); /* * Setup the result flist */ *r_flistpp = PIN_FLIST_CREATE(ebufp); vp = PIN_FLIST_FLD_GET(i_flistp, PIN_FLD_POID, 0, ebufp); PIN_FLIST_FLD_SET(*r_flistpp, PIN_FLD_POID, vp, ebufp); result = PIN_PRICE_VERIFY_PASSED; PIN_FLIST_FLD_SET(*r_flistpp, PIN_FLD_RESULT, (void *)&result, ebufp); /* * Error? */ if (PIN_ERR_IS_ERR(ebufp)) { PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_DEBUG, "op_price_pol_delete_deal error", ebufp); } else { PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG, "op_price_pol_delete_deal return flist", *r_flistpp); } return; }
/******************************************************************* * fm_pymt_pol_collect_writeoff_account(): * This function checks for the event type . * If event type is /event/billing/writeoff_reversal * then it writesoff the account *******************************************************************/ static void fm_pymt_pol_collect_writeoff_account( pcm_context_t *ctxp, pin_flist_t *i_flistp, int flags, pin_errbuf_t *ebufp) { pin_flist_t *flistp = NULL; pin_flist_t *wa_flistp = NULL; pin_flist_t *r_flistp = NULL; char *writeoff_event_type = { "" }; int result_flag = 0; void *vp = NULL; int32 rec_id; pin_cookie_t cookie = NULL; int temp = 0; u_int count = 0; if (PIN_ERR_IS_ERR(ebufp)) return; PIN_ERR_CLEAR_ERR(ebufp); /*********************************************************** * Check for the event type /event/billing/writeoff_reversal ***********************************************************/ cookie = NULL; while ((flistp = PIN_FLIST_ELEM_GET_NEXT(i_flistp, PIN_FLD_EVENTS, &rec_id, 1, &cookie, ebufp)) != (pin_flist_t *)NULL){ vp = PIN_FLIST_FLD_GET( flistp, PIN_FLD_POID, 0, ebufp); if (vp != NULL) writeoff_event_type = (char *)PIN_POID_GET_TYPE((poid_t *) vp ); if( writeoff_event_type && strcmp( writeoff_event_type, PIN_OBJ_TYPE_EVENT_WRITEOFF_REVERSAL) == 0 ){ count++; break; } } /***************************************** * Bail out if no WOR performed *****************************************/ if( !count ) return; vp = PIN_FLIST_FLD_GET( flistp, PIN_FLD_RESULT, 0, ebufp); if ( vp != NULL ) { result_flag = *(int *)vp; } if( result_flag == PIN_REVERSE_RES_PASS ) { /*********************************************************** * Writeoff the Account by calling PCM_OP_AR_ACCOUNT_WRITEOFF ***********************************************************/ wa_flistp = PIN_FLIST_CREATE(ebufp); vp = PIN_FLIST_FLD_GET(i_flistp, PIN_FLD_POID, 0, ebufp); PIN_FLIST_FLD_SET(wa_flistp, PIN_FLD_POID, vp, ebufp); vp = PIN_FLIST_FLD_TAKE(i_flistp, PIN_FLD_PROGRAM_NAME, 0, ebufp); PIN_FLIST_FLD_PUT(wa_flistp, PIN_FLD_PROGRAM_NAME, vp, ebufp); /************************************************************* * Add the String ID and String version for the GL *************************************************************/ temp = PIN_WRITEOFF_FOR_AUTO_WRITEOFF_REVERSAL; PIN_FLIST_FLD_SET(wa_flistp, PIN_FLD_STRING_ID, &temp, ebufp); temp = PIN_REASON_CODES_CREDIT_REASONS; PIN_FLIST_FLD_SET(wa_flistp, PIN_FLD_STR_VERSION, &temp, ebufp); PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG, "fm_pymt_pol_collect_writeoff_account PCM_OP_AR_ACCOUNT_WRITEOFF input flist", wa_flistp); PCM_OP(ctxp, PCM_OP_AR_ACCOUNT_WRITEOFF, flags, wa_flistp, &r_flistp, ebufp); PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG, "fm_pymt_pol_collect_writeoff_account PCM_OP_AR_ACCOUNT_WRITEOFF output flist", r_flistp); if (PIN_ERR_IS_ERR(ebufp)) { PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR, "fm_pymt_pol_collect_writeoff_account", ebufp); } /*********************************************************** * Clean up. ***********************************************************/ PIN_FLIST_DESTROY_EX(&wa_flistp, NULL); PIN_FLIST_DESTROY_EX(&r_flistp, NULL); } if (PIN_ERR_IS_ERR(ebufp)) { PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR, "fm_pymt_pol_collect_writeoff_account error", ebufp); } return; }
/********************************************************************** * fm_pymt_pol_spec_collect_get_ach() * Get ACH information **********************************************************************/ static void fm_pymt_pol_spec_collect_get_ach( pcm_context_t *ctxp, int32 flags, pin_flist_t *i_flistp, pin_flist_t *o_flistp, pin_errbuf_t *ebufp) { void *vp = NULL; pin_flist_t *flistp = NULL; pin_flist_t *p_flistp = NULL; pin_flist_t *rp_flistp = NULL; pin_flist_t *a_flistp = NULL; pin_flist_t *ra_flistp = NULL; int32 rec_id = 0; poid_t *p_pdp = NULL; poid_t *a_pdp = NULL; if (PIN_ERR_IS_ERR(ebufp)) { return; } PIN_ERR_CLEAR_ERR(ebufp); p_pdp = PIN_FLIST_FLD_GET(i_flistp, PIN_FLD_PAYINFO_OBJ, 0, ebufp); a_pdp = PIN_FLIST_FLD_GET(i_flistp, PIN_FLD_POID, 0, ebufp); /** read the payinfo to get the ach pointer. **/ p_flistp = PIN_FLIST_CREATE(ebufp); PIN_FLIST_FLD_SET(p_flistp, PIN_FLD_POID, p_pdp, ebufp); PIN_FLIST_FLD_SET(p_flistp, PIN_FLD_ACH, &rec_id, ebufp); PCM_OP(ctxp, PCM_OP_READ_FLDS, PCM_OPFLG_READ_UNCOMMITTED, p_flistp, &rp_flistp, ebufp); if (rp_flistp != (pin_flist_t *)NULL) { vp = PIN_FLIST_FLD_GET(rp_flistp, PIN_FLD_ACH, 0, ebufp); if (vp) { rec_id = *(int32 *)vp; } a_flistp = PIN_FLIST_CREATE(ebufp); PIN_FLIST_FLD_SET(a_flistp, PIN_FLD_POID, a_pdp, ebufp); PIN_FLIST_FLD_SET(a_flistp, PIN_FLD_ACH, (void *) &rec_id, ebufp); PCM_OP(ctxp, PCM_OP_PYMT_GET_ACH_INFO, 0, a_flistp, &ra_flistp, ebufp); flistp = PIN_FLIST_ELEM_GET(ra_flistp, PIN_FLD_RESULTS, 0, PIN_ELEMID_ANY, ebufp); vp = PIN_FLIST_FLD_GET(flistp, PIN_FLD_MERCHANT, 0, ebufp); PIN_FLIST_FLD_SET(o_flistp, PIN_FLD_MERCHANT, vp, ebufp); PIN_FLIST_FLD_SET(o_flistp, PIN_FLD_ACH, (void *) &rec_id, ebufp); vp = PIN_FLIST_FLD_TAKE(flistp, PIN_FLD_POID_VAL, 0, ebufp); flistp = PIN_FLIST_ELEM_ADD(o_flistp, PIN_FLD_BATCH_INFO, 0, ebufp); PIN_FLIST_FLD_PUT(flistp, PIN_FLD_POID_VAL, vp, ebufp); } if (PIN_ERR_IS_ERR(ebufp)) { PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR, "fm_pymt_pol_spec_collect_get_ach error", ebufp); } PIN_FLIST_DESTROY_EX(&p_flistp, NULL); PIN_FLIST_DESTROY_EX(&rp_flistp, NULL); PIN_FLIST_DESTROY_EX(&a_flistp, NULL); PIN_FLIST_DESTROY_EX(&ra_flistp, NULL); return; }
/******************************************************************* * Step search. * * Performs a read-object step search for services with * md5 encrypted passwords. The first 10 such services are * retrieved in two blocks of 5 services each. * * The "one arg like" search for /service is 236. * *******************************************************************/ void sample_step_search( pcm_context_t *ctxp, u_int64 database, pin_errbuf_t *ebufp) { pin_flist_t *flistp = NULL; pin_flist_t *a_flistp = NULL; pin_flist_t *r_flistp = NULL; poid_t *objp = NULL; u_int64 id; char *passwd = "md5|%"; pin_cookie_t cookie = NULL; int32 rec_id; /*********************************************************** * Check the error buffer. ***********************************************************/ if (PIN_ERR_IS_ERR(ebufp)) return; PIN_ERR_CLEAR_ERR(ebufp); /*********************************************************** * Allocate the flist for searching. ***********************************************************/ flistp = PIN_FLIST_CREATE(ebufp); /*********************************************************** * Allocate the search poid and give it to the flist. ***********************************************************/ id = (u_int64)236; objp = PIN_POID_CREATE(database, "/search", id, ebufp); PIN_FLIST_FLD_PUT(flistp, PIN_FLD_POID, (void *)objp, ebufp); /*********************************************************** * Add a search arguments array. ***********************************************************/ a_flistp = PIN_FLIST_ELEM_ADD(flistp, PIN_FLD_ARGS, 1, ebufp); /*********************************************************** * Put the password value in element 1 of the args array. ***********************************************************/ PIN_FLIST_FLD_SET(a_flistp, PIN_FLD_PASSWD, (void *)passwd, ebufp); /*********************************************************** * Add a search results marker. * * Making this NULL forces the read-object result we want. * The key here is the value 5, which says give me the * first 5 results or objects. ***********************************************************/ a_flistp = (pin_flist_t *)NULL; PIN_FLIST_ELEM_PUT(flistp, a_flistp, PIN_FLD_RESULTS, 5, ebufp); /*********************************************************** * Call the DM to initiate the step search. ***********************************************************/ PCM_OP(ctxp, PCM_OP_STEP_SEARCH, 0, flistp, &r_flistp, ebufp); /*********************************************************** * Walk the first results array. ***********************************************************/ fprintf(stdout,"\n** The first 5 objects:\n"); a_flistp = PIN_FLIST_ELEM_GET_NEXT(r_flistp, PIN_FLD_RESULTS, &rec_id, 1, &cookie, ebufp); while (a_flistp != (pin_flist_t *)NULL) { /*************************************************** * Show this result. ***************************************************/ fprintf(stdout,"\nStep Search Result(%d) Flist:\n", rec_id); PIN_FLIST_PRINT(a_flistp, stdout, ebufp); /*************************************************** * Get the next result. ***************************************************/ a_flistp = PIN_FLIST_ELEM_GET_NEXT(r_flistp, PIN_FLD_RESULTS, &rec_id, 1, &cookie, ebufp); } /*********************************************************** * Recycle the results flist. ***********************************************************/ PIN_FLIST_DESTROY(r_flistp, NULL); r_flistp = (pin_flist_t *)NULL; /*********************************************************** * Call the DM to get the next 5 objects using step next. ***********************************************************/ PCM_OP(ctxp, PCM_OP_STEP_NEXT, 0, flistp, &r_flistp, ebufp); /*********************************************************** * Walk the next results array. ***********************************************************/ fprintf(stdout,"\n** The next 5 objects:\n"); cookie = NULL; a_flistp = PIN_FLIST_ELEM_GET_NEXT(r_flistp, PIN_FLD_RESULTS, &rec_id, 1, &cookie, ebufp); while (a_flistp != (pin_flist_t *)NULL) { /*************************************************** * Show this result. ***************************************************/ fprintf(stdout,"\nStep Search Result(%d) Flist:\n", rec_id); PIN_FLIST_PRINT(a_flistp, stdout, ebufp); /*************************************************** * Get the next result. ***************************************************/ a_flistp = PIN_FLIST_ELEM_GET_NEXT(r_flistp, PIN_FLD_RESULTS, &rec_id, 1, &cookie, ebufp); } /*********************************************************** * Recycle the results flist. ***********************************************************/ PIN_FLIST_DESTROY(r_flistp, NULL); r_flistp = (pin_flist_t *)NULL; /*********************************************************** * Call the DM to end step searching. ***********************************************************/ PCM_OP(ctxp, PCM_OP_STEP_END, 0, flistp, &r_flistp, ebufp); /*********************************************************** * Clean up. ***********************************************************/ /* Free local memory */ PIN_FLIST_DESTROY(r_flistp, NULL); PIN_FLIST_DESTROY(flistp, NULL); /* Error? */ if (PIN_ERR_IS_ERR(ebufp)) { PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR, "sample_step_search error", ebufp); } return; }
/******************************************************************* * Main * * This sets up the parameters and then calls the FM. * *******************************************************************/ int main( int argc, char *argv[]) { pcm_context_t *ctxp; pin_flist_t *flistp = NULL; pin_flist_t *a_flistp = NULL; pin_flist_t *r_flistp = NULL; poid_t *acct_pdp = NULL; poid_t *srvc_pdp = NULL; u_int opcode; int64 database; void *vp; char logfile[256]; char *c_ptr = (char *)NULL; char *program; int32 err; pin_errbuf_t ebuf; PIN_ERR_CLEAR_ERR(&ebuf); /* * Logging initialization */ program = basename(argv[0]); PIN_ERR_SET_PROGRAM(program); PIN_ERR_SET_LEVEL(PIN_ERR_LEVEL_WARNING); strcpy(logfile, "default.pinlog"); pin_conf(program, "logfile", PIN_FLDT_STR, (caddr_t *)&(c_ptr), &err); if (c_ptr != (char *)NULL) { pin_strlcpy(logfile, c_ptr, sizeof(logfile)); pin_free(c_ptr); c_ptr = (char *)NULL; } PIN_ERR_SET_LOGFILE(logfile); /* * Check the input. */ if (argc != 3) { usage(argv[0]); PIN_ERR_LOG_MSG(PIN_ERR_LEVEL_ERROR, "bad # of arguments"); exit(1); } /* * Initialize PCM connection. */ PCM_CONNECT(&ctxp, &database, &ebuf); if (PIN_ERR_IS_ERR(&ebuf)) { PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR, "pcm_connect error", &ebuf); exit(2); } /* * Create the poid prototype. */ srvc_pdp = PIN_POID_CREATE(database, argv[1], 0, &ebuf); /* * Look up the account. */ flistp = PIN_FLIST_CREATE(&ebuf); vp = (void *)srvc_pdp; PIN_FLIST_FLD_SET(flistp, PIN_FLD_POID, vp, &ebuf); vp = (void *)argv[2]; PIN_FLIST_FLD_SET(flistp, PIN_FLD_LOGIN, vp, &ebuf); opcode = PCM_OP_ACT_FIND; PCM_OP(ctxp, opcode, 0, flistp, &a_flistp, &ebuf); /* * Did we find anything? */ acct_pdp = PIN_FLIST_FLD_GET(a_flistp, PIN_FLD_ACCOUNT_OBJ, 0, &ebuf); if (!PIN_POID_IS_NULL(acct_pdp)) { /* * Advisory (or add confirm?) */ fprintf(stdout, "Deleting Account:\t"); pin_poid_print(acct_pdp, 0, &ebuf); fprintf(stdout, "\n"); /* * Put the real account poid on the flist * (The account_obj field will just be ignored) */ vp = (void *)acct_pdp; PIN_FLIST_FLD_SET(a_flistp, PIN_FLD_POID, vp, &ebuf); /* * Delete the account. */ opcode = PCM_OP_CUST_DELETE_ACCT; PCM_OP(ctxp, opcode, 0, a_flistp, &r_flistp, &ebuf); /* * Did we delete or not? */ if (PIN_ERR_IS_ERR(&ebuf)) { fprintf(stdout, "Account Deletion Error Occurred.\n"); PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR, "op_cust_delete_acct error", &ebuf); } else { fprintf(stdout, "Account Deleted.\n"); } } else { /* * FIND error. */ fprintf(stdout, "Unable to locate Account.\n"); PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR, "op_act_find error", &ebuf); } /* * Close the PCM context. */ PCM_CONTEXT_CLOSE(ctxp, 0, &ebuf); /* * Clean up. */ /* Free local memory. */ PIN_FLIST_DESTROY(flistp, NULL); PIN_FLIST_DESTROY(a_flistp, NULL); PIN_FLIST_DESTROY(r_flistp, NULL); /* No errors. */ return(0); }
/******************************************************************** * Function : fm_cust_pol_prep_topup * Description : This function will prepare the input flist for the * Standards as well as the Sponsored topup. ********************************************************************/ static void fm_cust_pol_prep_topup( pcm_context_t *ctxp, int32 flags, pin_flist_t *i_flistp, pin_flist_t **r_flistpp, pin_errbuf_t *ebufp) { int createonly = 0; int status = 0; int index = 0; int sponsore_topup = 0; void *vp = NULL; pin_flist_t *intopup_flistp = NULL; pin_flist_t *outtopup_flistp = NULL; pin_flist_t *ingrptopupmem_flistp = NULL; pin_flist_t *outgrptopupmem_flistp = NULL; pin_flist_t *grptopup_flistp = NULL; pin_flist_t *ingrptopup_flistp = NULL; pin_flist_t *outgrptopup_flistp = NULL; pin_flist_t *r_flistp = NULL; poid_t *intopup_pdp = NULL; poid_t *inparent_pdp = NULL; poid_t *initiator_pdp = NULL; poid_t *grp_pdp = NULL; poid_t *tmp_pdp = NULL; if (PIN_ERR_IS_ERR(ebufp)) return; PIN_ERR_CLEAR_ERR(ebufp); /**************************************************************** * Get the PIN_FLD_TOPUP_INFO from the input flist. * Value available in the input flist this function construct the * output flist. *****************************************************************/ intopup_flistp = PIN_FLIST_ELEM_GET(i_flistp, PIN_FLD_TOPUP_INFO, PIN_ELEMID_ANY, 0, ebufp); /**************************************************************** * Just copy the input flist to the retflist.If any change is required * for the flist we will manipulate the output flist. ****************************************************************/ *r_flistpp = PIN_FLIST_COPY(i_flistp, ebufp); /**************************************************************** * First check requires the POID and PARENT poid from the input * flist. From this we check whether the call is to * create the standard topup or the sponsored topup. ****************************************************************/ intopup_pdp = (poid_t *)PIN_FLIST_FLD_GET(intopup_flistp, PIN_FLD_POID, 0, ebufp); inparent_pdp = (poid_t *)PIN_FLIST_FLD_GET(intopup_flistp, PIN_FLD_PARENT, 1, ebufp); /**************************************************************** * check the topup poid is just type only or not. ****************************************************************/ if( PIN_POID_IS_TYPE_ONLY(intopup_pdp) ) { /**************************************************************** * topup poid is just type only i,e. 0.0.0.x /topup -1 1 ****************************************************************/ if( PIN_POID_IS_NULL(inparent_pdp) ) { fm_cust_pol_prep_create_standard_topup(ctxp, flags, i_flistp, r_flistpp, ebufp); return; } else { createonly = 1; sponsore_topup = 1; fm_cust_pol_prep_create_sponsored_topup(ctxp, flags, i_flistp, r_flistpp, ebufp); } } else { /**************************************************************** * The input flist contains the valid topup poid. ****************************************************************/ /**************************************************************** * Now read PIN_FLD_GROUP_OBJ and PIN_FLD_GROUP_INDEX from * the /topup object ****************************************************************/ grptopup_flistp = PIN_FLIST_CREATE(ebufp); tmp_pdp = PIN_POID_COPY( intopup_pdp, ebufp); PIN_FLIST_FLD_PUT(grptopup_flistp, PIN_FLD_POID, tmp_pdp, ebufp); /**************************************************************** * setting the group dummy group poid and group index ****************************************************************/ PIN_FLIST_FLD_SET(grptopup_flistp, PIN_FLD_GROUP_OBJ, tmp_pdp, ebufp); PIN_FLIST_FLD_SET(grptopup_flistp, PIN_FLD_GROUP_INDEX, (void *) &index, ebufp); PCM_OP(ctxp, PCM_OP_READ_FLDS, flags, grptopup_flistp, &r_flistp, ebufp); /**************************************************************** * Now get the group object from the return flist. ****************************************************************/ grp_pdp = (poid_t *)PIN_FLIST_FLD_GET(r_flistp, PIN_FLD_GROUP_OBJ, 1, ebufp); /**************************************************************** * check whethere the poid is null or not. ****************************************************************/ if( PIN_POID_IS_NULL(grp_pdp) ) { if( PIN_POID_IS_NULL(inparent_pdp) ) { /**************************************************************** * Since the input flist does not contains the PARENT and * specefied the topup object does not have the GROUP_OBJ * it hase to prepare the flist for the modification * standard topup. ****************************************************************/ fm_cust_pol_prep_modify_standard_topup(ctxp, flags, i_flistp, r_flistpp, ebufp); return ; } else { /**************************************************************** * Input flist have the PARENT poid and the topup object does not have the * valid group poid, hence prepare the flist to create the * sponsored topup. * This case if for a account holder having the standard topup * is being added to PARENts some group. ****************************************************************/ createonly = 1; sponsore_topup = 1; fm_cust_pol_prep_create_sponsored_topup(ctxp, flags, i_flistp, r_flistpp, ebufp); } } else { /**************************************************************** * The topup object is having the valid group poid. * Hence prepare the flistp for modifing the sponsored topup. ****************************************************************/ sponsore_topup = 1; fm_cust_pol_prep_modify_sponsored_topup(ctxp, flags, i_flistp, r_flistpp, ebufp); } PIN_FLIST_DESTROY_EX(&grptopup_flistp, NULL); PIN_FLIST_DESTROY_EX(&r_flistp, NULL); } /**************************************************************** * Check whethere we are preparing the flist for standard or * sponsored topup. Becuse we have to continue exution for * for sponsored topup. ****************************************************************/ if( sponsore_topup ) { initiator_pdp = (poid_t *)PIN_FLIST_FLD_GET(i_flistp, PIN_FLD_POID, 0, ebufp); outtopup_flistp = PIN_FLIST_ELEM_GET(*r_flistpp, PIN_FLD_TOPUP_INFO, PIN_ELEMID_ANY, 0, ebufp); outgrptopup_flistp = PIN_FLIST_ELEM_GET(outtopup_flistp, PIN_FLD_GROUP_TOPUP_INFO, PIN_ELEMID_ANY, 0, ebufp); outgrptopupmem_flistp = PIN_FLIST_ELEM_GET(outgrptopup_flistp, PIN_FLD_GROUP_TOPUP_MEMBERS, PIN_ELEMID_ANY, 0, ebufp); /**************************************************************** * Check who is the intiatore of the operation. ****************************************************************/ if( !PIN_POID_COMPARE( inparent_pdp, initiator_pdp , 0, ebufp) ) { /**************************************************************** * Initiatore is the payers. ****************************************************************/ ingrptopup_flistp = PIN_FLIST_ELEM_GET(intopup_flistp, PIN_FLD_GROUP_TOPUP_INFO, PIN_ELEMID_ANY, 0, ebufp); ingrptopupmem_flistp = PIN_FLIST_ELEM_GET(ingrptopup_flistp, PIN_FLD_GROUP_TOPUP_MEMBERS, PIN_ELEMID_ANY, 0, ebufp); /**************************************************************** * If the STATUS is not set set it to ACTIVE. ****************************************************************/ vp = PIN_FLIST_FLD_GET(ingrptopupmem_flistp, PIN_FLD_STATUS, 1, ebufp); if( vp == NULL ) { status = PIN_STATUS_ACTIVE; PIN_FLIST_FLD_SET(outgrptopupmem_flistp, PIN_FLD_STATUS, &status, ebufp); } /**************************************************************** * If the opcode is creating the sponsored topup and the group * name is not set it to default. ****************************************************************/ if( createonly ) { vp = PIN_FLIST_FLD_GET(ingrptopup_flistp, PIN_FLD_NAME, 1, ebufp); if( vp == NULL ) { PIN_FLIST_FLD_SET(outgrptopup_flistp, PIN_FLD_NAME, (void *)"default", ebufp); } } } else { /**************************************************************** * Initiatore is member account. Set the PIN to NULL and * STATUS is INACTIVE. ****************************************************************/ status = PIN_STATUS_INACTIVE; PIN_FLIST_FLD_SET(outgrptopupmem_flistp, PIN_FLD_STATUS, &status, ebufp); PIN_FLIST_FLD_SET(outgrptopupmem_flistp, PIN_FLD_PIN, (void *)"", ebufp); } } if (PIN_ERR_IS_ERR(ebufp)) PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR, "fm_cust_pol_prep_topup error", ebufp); return; }
/* * Search for a brand name in the whole system. */ static void fm_cust_pol_is_brandname_unique_global( pcm_context_t *ctxp, poid_t *poidp, char *namep, pin_flist_t **r_flistpp, pin_errbuf_t *ebufp) { pin_flist_t *flistp = (pin_flist_t *)NULL; pin_flist_t *rlistp = (pin_flist_t *)NULL; pin_flist_t *sublistp; poid_t *search_poidp; int32 int_val; int32 cred; pin_account_type_t brand_type = PIN_ACCOUNT_TYPE_BRAND; pin_cookie_t cookie = (pin_cookie_t)NULL; /* * If there are pending errors, then short circuit immediately */ if (PIN_ERR_IS_ERR(ebufp)) return; PIN_ERR_CLEAR_ERR(ebufp); /* * Create search flist to try to figure out if someone brand already * has this name. * * NOTE: we really only need to search for accounts that are of type * 'brand' and of a particular name. Unfortunately, neither of these * fields are indexed by default, thus causing a performance problem. * * To get around this, we'll turn this into a complex search. We know * that brands are the parent of a /group/billing object, so glue that * in as well. That should be indexed... */ flistp = PIN_FLIST_CREATE(ebufp); search_poidp = PIN_POID_CREATE(PIN_POID_GET_DB(poidp), "/search", -1, ebufp); PIN_FLIST_FLD_PUT(flistp, PIN_FLD_POID, (void *)search_poidp, ebufp); int_val = SRCH_DISTINCT; PIN_FLIST_FLD_SET(flistp, PIN_FLD_FLAGS, (void *)&int_val, ebufp); PIN_FLIST_FLD_SET(flistp, PIN_FLD_TEMPLATE, (void *)"select X from /account 1, /group 2 where 1.F1 = V1 " "AND 1.F2 = V2 AND 1.F3 = 2.F4 AND 1.F5 != V5 ", ebufp); PIN_FLIST_ELEM_SET(flistp, NULL, PIN_FLD_RESULTS, 0, ebufp); /* * Arg 1 is the type of the account; only interested in brand accounts */ sublistp = PIN_FLIST_ELEM_ADD(flistp, PIN_FLD_ARGS, 1, ebufp); PIN_FLIST_FLD_SET(sublistp, PIN_FLD_ACCOUNT_TYPE, (void *)&brand_type, ebufp); /* * Arg 2 is the name of the brand. */ sublistp = PIN_FLIST_ELEM_ADD(flistp, PIN_FLD_ARGS, 2, ebufp); PIN_FLIST_FLD_SET(sublistp, PIN_FLD_NAME, (void *)namep, ebufp); /* * Arg 3 -- POID of account */ sublistp = PIN_FLIST_ELEM_ADD(flistp, PIN_FLD_ARGS, 3, ebufp); PIN_FLIST_FLD_PUT(sublistp, PIN_FLD_POID, NULL, ebufp); /* * Arg 4 -- Parent of the group */ sublistp = PIN_FLIST_ELEM_ADD(flistp, PIN_FLD_ARGS, 4, ebufp); PIN_FLIST_FLD_PUT(sublistp, PIN_FLD_PARENT, NULL, ebufp); /* * Arg 5 -- POID of current account */ sublistp = PIN_FLIST_ELEM_ADD(flistp, PIN_FLD_ARGS, 5, ebufp); PIN_FLIST_FLD_SET(sublistp, PIN_FLD_POID, poidp, ebufp); /* * Ready to search! Temporarily suspend search to ensure that * all brands are traversed. */ cred = CM_FM_BEGIN_OVERRIDE_SCOPE(CM_CRED_SCOPE_OVERRIDE_ROOT); PCM_OP(ctxp, PCM_OP_GLOBAL_SEARCH, PCM_OPFLG_COUNT_ONLY, flistp, &rlistp, ebufp); CM_FM_END_OVERRIDE_SCOPE(cred); /* * See if there is a brand out there right now that already has * this name. If so, flag it as an error. */ PIN_FLIST_ELEM_GET_NEXT(rlistp, PIN_FLD_RESULTS, &int_val, 1, &cookie, ebufp); if(int_val > 0) { *r_flistpp = PIN_FLIST_CREATE(ebufp); PIN_FLIST_FLD_SET(*r_flistpp, PIN_FLD_POID, (void *)poidp, ebufp); fm_cust_pol_valid_add_fail(*r_flistpp, PIN_FLD_NAME, 0, PIN_CUST_VAL_ERR_DUPE, PIN_CUST_DUPE_VALUE_ERR_MSG, (void *)namep, ebufp); pin_set_err(ebufp, PIN_ERRLOC_FM, PIN_ERRCLASS_SYSTEM_DETERMINATE, PIN_ERR_DUPLICATE, PIN_FLD_NAME, 0, 0); } /* * Cleanup and return */ PIN_FLIST_DESTROY_EX(&flistp, NULL); PIN_FLIST_DESTROY_EX(&rlistp, NULL); }
/******************************************************************* * fm_pymt_pol_collect_result_soft(): * * Create the collect result for 'soft' pin declines. * * All soft declines are subject to the same rules, but * we may need/want to treat each command differently. * *******************************************************************/ static void fm_pymt_pol_collect_result_soft( pcm_context_t *ctxp, pin_flist_t *i_flistp, pin_flist_t *r_flistp, pin_errbuf_t *ebufp) { pin_flist_t *a_flistp = NULL; pin_flist_t *b_flistp = NULL; pin_flist_t *flistp = NULL; pin_cookie_t cookie = NULL; int result; int rec_id; char *descr = NULL; pin_status_t *status = NULL; int *flags = NULL; poid_t *a_pdp = NULL; poid_t *s_pdp = NULL; poid_t *b_pdp = NULL; void *vp = NULL; char *templatep; int32 srch_flags = SRCH_DISTINCT; int item_status = PIN_ITEM_STATUS_OPEN; pin_decimal_t *item_due = NULL; time_t start_t = 0; if (PIN_ERR_IS_ERR(ebufp)) return; PIN_ERR_CLEAR_ERR(ebufp); item_due = pbo_decimal_from_str("0.01", ebufp); /*********************************************************** * All get the FAIL result and default descr. ***********************************************************/ result = PIN_RESULT_FAIL; PIN_FLIST_FLD_SET(r_flistp, PIN_FLD_RESULT, (void *)&result, ebufp); descr = "creditcard operation declined"; PIN_FLIST_FLD_SET(r_flistp, PIN_FLD_DESCR, (void *)descr, ebufp); /*********************************************************** * Read the config info. ***********************************************************/ fm_pymt_pol_collect_config(ctxp, i_flistp, &b_flistp, ebufp); /*********************************************************** * If not already inactive for debt/closed, suspend. ***********************************************************/ status = (pin_status_t *)PIN_FLIST_FLD_GET(b_flistp, PIN_FLD_STATUS, 0, ebufp); flags = (int *)PIN_FLIST_FLD_GET(b_flistp, PIN_FLD_STATUS_FLAGS, 0, ebufp); a_pdp = (poid_t *)PIN_FLIST_FLD_GET(b_flistp, PIN_FLD_POID, 0, ebufp); b_pdp = (poid_t *)PIN_FLIST_FLD_GET(b_flistp, PIN_FLD_LAST_BILL_OBJ, 0, ebufp); /*********************************************************** * Nothing to do, if there was no last bill object. ***********************************************************/ if (PIN_POID_IS_NULL(b_pdp)) { PIN_FLIST_DESTROY_EX(&b_flistp, NULL); pbo_decimal_destroy(&item_due); return; } /*********************************************************** * Read the bill object for the start of the billing cycle. ***********************************************************/ vp = (void *)NULL; a_flistp = PIN_FLIST_CREATE(ebufp); PIN_FLIST_FLD_SET(a_flistp, PIN_FLD_POID, (void *)b_pdp, ebufp); PIN_FLIST_FLD_SET(a_flistp, PIN_FLD_START_T, vp, ebufp); /*********************************************************** * Read the info from the last bill object. ***********************************************************/ PCM_OP(ctxp, PCM_OP_READ_FLDS, 0, a_flistp, &flistp, ebufp); vp = PIN_FLIST_FLD_GET(flistp, PIN_FLD_START_T, 0,ebufp); if (vp) start_t = *((time_t *)vp); PIN_FLIST_DESTROY_EX(&a_flistp, NULL); PIN_FLIST_DESTROY_EX(&flistp, NULL); /*********************************************************** * Allocate the flist for search the item objects. ***********************************************************/ a_flistp = PIN_FLIST_CREATE(ebufp); /************************************************************** * Construct the search poid. **************************************************************/ s_pdp = PIN_POID_CREATE(PIN_POID_GET_DB(a_pdp), "/search/pin", -1, ebufp); PIN_FLIST_FLD_PUT(a_flistp, PIN_FLD_POID, (void *)s_pdp, ebufp); PIN_FLIST_FLD_SET(a_flistp, PIN_FLD_FLAGS, &srch_flags, ebufp); /************************************************************** * Specify the search arguments. **************************************************************/ flistp = PIN_FLIST_ELEM_ADD(a_flistp, PIN_FLD_ARGS, 1, ebufp); PIN_FLIST_FLD_SET(flistp, PIN_FLD_ACCOUNT_OBJ, (void *)a_pdp, ebufp); flistp = PIN_FLIST_ELEM_ADD(a_flistp, PIN_FLD_ARGS, 2, ebufp); PIN_FLIST_FLD_SET(flistp, PIN_FLD_STATUS, (void *)&item_status, ebufp); flistp = PIN_FLIST_ELEM_ADD(a_flistp, PIN_FLD_ARGS, 3, ebufp); PIN_FLIST_FLD_SET(flistp, PIN_FLD_DUE, (void *)item_due, ebufp); flistp = PIN_FLIST_ELEM_ADD(a_flistp, PIN_FLD_ARGS, 4, ebufp); PIN_FLIST_FLD_SET(flistp, PIN_FLD_EFFECTIVE_T, (void *)&start_t, ebufp); templatep = "select X from /item/$1 " " where F1 = V1 " " and F2 = V2 " " and F3 >= V3 " " and F4 <= V4 "; PIN_FLIST_FLD_SET(a_flistp, PIN_FLD_TEMPLATE, (void *)templatep, ebufp); /************************************************************** * Set-up the results array. **************************************************************/ vp = (void *)NULL; flistp = PIN_FLIST_ELEM_ADD(a_flistp, PIN_FLD_RESULTS, 0, ebufp); PIN_FLIST_FLD_SET(flistp, PIN_FLD_POID, vp, ebufp); /************************************************************** * Call the PCM_OP_SEARCH opcode to do the actual search. **************************************************************/ PCM_OP(ctxp, PCM_OP_SEARCH, 0, a_flistp, &flistp, ebufp); PIN_FLIST_DESTROY_EX(&a_flistp, NULL); /************************************************************** * Did we find any items with 30 days due. **************************************************************/ a_flistp = PIN_FLIST_ELEM_GET_NEXT(flistp, PIN_FLD_RESULTS, &rec_id, 1, &cookie, ebufp); if ((a_flistp != (pin_flist_t *)NULL) && (status)) { switch (*status) { case PIN_STATUS_INACTIVE: if (flags && (*flags & PIN_STATUS_FLAG_DEBT)) break; /* intentional fall-thru */ case PIN_STATUS_ACTIVE: fm_pymt_pol_collect_set_status(r_flistp, PIN_STATUS_INACTIVE, PIN_STATUS_FLAG_DEBT, "credit card pastdue", ebufp); break; case PIN_STATUS_CLOSED: break; default: break; } } /*********************************************************** * Someday check for age of debt and close after so long. ***********************************************************/ /*********************************************************** * Cleanup. ***********************************************************/ PIN_FLIST_DESTROY_EX(&b_flistp, NULL); PIN_FLIST_DESTROY_EX(&flistp, NULL); pbo_decimal_destroy(&item_due); /* Error? - caught/logged by caller */ return; }
/******************************************************************* * fm_cust_pol_read_plan() * * For the specified plan object, forms a tree. * *******************************************************************/ static void fm_cust_pol_read_plan( pcm_context_t *ctxp, pin_flist_t *i_flistp, pin_flist_t **o_flistpp, pin_errbuf_t *ebufp) { pin_flist_t *d_flistp = NULL; pin_flist_t *s_flistp = NULL; /* service flist */ pin_flist_t *rp_flistp = NULL; /* product flist (read) */ pin_cookie_t d_cookie = NULL; pin_cookie_t cookie = NULL; int32 rec_id = 0; int32 d_rec_id = 0; void *vp = NULL; if (PIN_ERR_IS_ERR(ebufp)) { return; } PIN_ERR_CLEAR_ERR(ebufp); /*********************************************************** * Read the plan object. ***********************************************************/ d_flistp = PIN_FLIST_CREATE(ebufp); vp = PIN_FLIST_FLD_GET(i_flistp, PIN_FLD_POID, 0, ebufp); PIN_FLIST_FLD_SET(d_flistp, PIN_FLD_POID, vp, ebufp); PCM_OP(ctxp, PCM_OP_READ_OBJ, PCM_OPFLG_ORDER_BY_REC_ID, d_flistp, &rp_flistp, ebufp); PIN_FLIST_DESTROY_EX(&d_flistp, NULL); while ((s_flistp = PIN_FLIST_ELEM_GET_NEXT(rp_flistp, PIN_FLD_SERVICES, &rec_id, 1, &d_cookie, ebufp)) != NULL) { vp = PIN_FLIST_FLD_GET(s_flistp, PIN_FLD_DEAL_OBJ, 1, ebufp); if (vp && PIN_POID_IS_NULL(vp)) { cookie = NULL; while ((d_flistp = PIN_FLIST_ELEM_GET_NEXT(s_flistp, PIN_FLD_DEALS, &d_rec_id, 1, &cookie, ebufp)) != NULL) { fm_cust_pol_read_plan_deal(ctxp, d_flistp, 0, 1, ebufp); } } else { fm_cust_pol_read_plan_deal(ctxp, s_flistp, 0, 0, ebufp); } } /************************************************************* * Now deal with account level plans/deals/products (ie those * with no services associated) *************************************************************/ fm_cust_pol_read_plan_deal(ctxp, rp_flistp, 1, 0, ebufp); /*********************************************************** * Errors. ***********************************************************/ if (PIN_ERR_IS_ERR(ebufp)) { PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR, "fm_cust_pol_read_plan error", ebufp); /************************************************** * Since there is an error return a NULL flist and * delete the one we read **************************************************/ *o_flistpp = NULL; PIN_FLIST_DESTROY_EX( &rp_flistp, NULL ); } else { *o_flistpp = rp_flistp; } return; }
/******************************************************************* * fm_cust_pol_read_plan_deal() * * For the specified deal object, forms a tree. * Implemented as a subroutine since it is called once for each * service, and then once for any account level deals * *******************************************************************/ static void fm_cust_pol_read_plan_deal(pcm_context_t *ctxp, pin_flist_t *s_flistp, int32 is_account_deal, int32 deal_array, pin_errbuf_t *ebufp) { pin_flist_t *flistp = NULL; /* temp flist */ pin_flist_t *d_flistp = NULL; /* dummy flist */ pin_flist_t *rd_flistp = NULL; /* deal flist (read) */ pin_flist_t *p_flistp = NULL; /* product flist */ int elem_id; void *vp = NULL; poid_t *d_pdp = NULL; pin_cookie_t p_cookie = NULL; /*************************************************** * No point doing any work if there isn't a deal ***************************************************/ vp = PIN_FLIST_FLD_GET(s_flistp, PIN_FLD_DEAL_OBJ, 1, ebufp); if (PIN_POID_IS_NULL((poid_t *)vp)) { /* * Don't drop the DEAL_OBJ is this is an account deal, * because even though it is NULL, it breaks admin for good * measure! */ if (!is_account_deal) { PIN_FLIST_FLD_DROP(s_flistp, PIN_FLD_DEAL_OBJ, ebufp); } return; } /*************************************************** * Read the deal object and add it to the plan tree. ***************************************************/ d_flistp = PIN_FLIST_CREATE(ebufp); d_pdp = PIN_POID_COPY((poid_t *)vp, ebufp); PIN_FLIST_FLD_SET(d_flistp, PIN_FLD_POID, vp, ebufp); PCM_OP(ctxp, PCM_OP_READ_OBJ, 0, d_flistp, &rd_flistp, ebufp); PIN_FLIST_DESTROY_EX(&d_flistp, NULL); PIN_FLIST_FLD_DROP(rd_flistp, PIN_FLD_POID, ebufp); PIN_FLIST_FLD_PUT(rd_flistp, PIN_FLD_DEAL_OBJ, (poid_t *)d_pdp, ebufp); /*************************************************** * Walk thru the products array and read the fields * needed from the respective product obj. ***************************************************/ while ((flistp = PIN_FLIST_ELEM_GET_NEXT(rd_flistp, PIN_FLD_PRODUCTS, &elem_id, 1, &p_cookie, ebufp)) != NULL) { d_flistp = PIN_FLIST_CREATE(ebufp); vp = PIN_FLIST_FLD_GET(flistp, PIN_FLD_PRODUCT_OBJ, 0, ebufp); PIN_FLIST_FLD_SET(d_flistp, PIN_FLD_POID, vp, ebufp); PIN_FLIST_FLD_SET(d_flistp, PIN_FLD_NAME, NULL, ebufp); PIN_FLIST_FLD_SET(d_flistp, PIN_FLD_DESCR, NULL, ebufp); PIN_FLIST_FLD_SET(d_flistp, PIN_FLD_OWN_MAX, NULL, ebufp); PIN_FLIST_FLD_SET(d_flistp, PIN_FLD_OWN_MIN, NULL, ebufp); PCM_OP(ctxp, PCM_OP_READ_FLDS, 0, d_flistp, &p_flistp, ebufp); PIN_FLIST_FLD_DROP(p_flistp, PIN_FLD_POID, ebufp); PIN_FLIST_CONCAT(flistp, p_flistp, ebufp); PIN_FLIST_DESTROY_EX(&d_flistp, NULL); PIN_FLIST_DESTROY_EX(&p_flistp, NULL); } p_cookie = NULL; while ((flistp = PIN_FLIST_ELEM_GET_NEXT(rd_flistp, PIN_FLD_DISCOUNTS, &elem_id, 1, &p_cookie, ebufp)) != NULL) { d_flistp = PIN_FLIST_CREATE(ebufp); vp = PIN_FLIST_FLD_GET(flistp, PIN_FLD_DISCOUNT_OBJ, 0, ebufp); PIN_FLIST_FLD_SET(d_flistp, PIN_FLD_POID, vp, ebufp); PIN_FLIST_FLD_SET(d_flistp, PIN_FLD_NAME, NULL, ebufp); PIN_FLIST_FLD_SET(d_flistp, PIN_FLD_DESCR, NULL, ebufp); PIN_FLIST_FLD_SET(d_flistp, PIN_FLD_OWN_MAX, NULL, ebufp); PIN_FLIST_FLD_SET(d_flistp, PIN_FLD_OWN_MIN, NULL, ebufp); PCM_OP(ctxp, PCM_OP_READ_FLDS, 0, d_flistp, &p_flistp, ebufp); PIN_FLIST_FLD_DROP(p_flistp, PIN_FLD_POID, ebufp); PIN_FLIST_CONCAT(flistp, p_flistp, ebufp); PIN_FLIST_DESTROY_EX(&d_flistp, NULL); PIN_FLIST_DESTROY_EX(&p_flistp, NULL); } /* Decode the encoded dates into unit and offset */ fm_cust_convert_prod_disc_date_details_into_offset_unit(ctxp, PIN_FLD_PRODUCTS, &rd_flistp, ebufp); fm_cust_convert_prod_disc_date_details_into_offset_unit(ctxp, PIN_FLD_DISCOUNTS, &rd_flistp, ebufp); if (deal_array) { PIN_FLIST_FLD_DROP(rd_flistp, PIN_FLD_DEAL_OBJ, ebufp); PIN_FLIST_CONCAT(s_flistp, rd_flistp, ebufp); PIN_FLIST_DESTROY_EX(&rd_flistp, NULL); } else { PIN_FLIST_ELEM_PUT(s_flistp, rd_flistp, PIN_FLD_DEALS, 0, ebufp); } if (PIN_ERR_IS_ERR(ebufp)) { PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR, "fm_cust_pol_read_plan_deal error", ebufp); } }
/* * Search for a brand name within a brand. */ static void fm_cust_pol_is_brandname_unique_within_brand( pcm_context_t *ctxp, poid_t *poidp, char *namep, pin_flist_t **r_flistpp, pin_errbuf_t *ebufp) { pin_flist_t *flistp = (pin_flist_t *)NULL; pin_flist_t *rlistp = (pin_flist_t *)NULL; pin_flist_t *sublistp; poid_t *search_poidp; int32 int_val; int32 cred; pin_account_type_t brand_type = PIN_ACCOUNT_TYPE_BRAND; pin_cookie_t cookie = (pin_cookie_t)NULL; pin_flist_t *b_flistp = NULL; pin_flist_t *t_flistp = NULL; poid_t *b_pdp = NULL; poid_t *g_pdp = NULL; poid_t *rootp = NULL; int32 elemid = 0; int under_host = PIN_BOOLEAN_FALSE; void *vp = NULL; /* * If there are pending errors, then short circuit immediately */ if (PIN_ERR_IS_ERR(ebufp)) return; PIN_ERR_CLEAR_ERR(ebufp); fm_utils_lineage_get_brand_hierarchy(ctxp, poidp, &b_flistp, ebufp); if (PIN_ERR_IS_ERR(ebufp)) { PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR, "fm_cust_pol_is_brandname_unique_within_brand() : " "Call to get brand hierarchy failed ", ebufp); PIN_FLIST_DESTROY_EX (&b_flistp, NULL); fm_cust_pol_read_err_return_list(poidp, namep, r_flistpp, ebufp); goto cleanup; } PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG, "Got brand hierarchy. Return flist :", b_flistp); t_flistp = PIN_FLIST_ELEM_GET_NEXT(b_flistp, PIN_FLD_RESULTS, &elemid, 1, &cookie, ebufp); if (PIN_ERR_IS_ERR(ebufp) || t_flistp == (pin_flist_t *)NULL) { PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR, "fm_cust_pol_is_brandname_unique_within_brand() : " "Call to get first brand failed ", ebufp); PIN_FLIST_DESTROY_EX (&b_flistp, NULL); fm_cust_pol_read_err_return_list(poidp, namep, r_flistpp, ebufp); goto cleanup; } /******************************************** * Get the first brand object from hierarchy ********************************************/ b_pdp = PIN_FLIST_FLD_GET(t_flistp, PIN_FLD_BRAND_OBJ, 0, ebufp); /*************************************************************** * During the brand creation, the first brand object from the * the hierarchy is the parent brand. But, for an existing * brand, the first object is self, the next one in hierarchy * is the parent brand. ***************************************************************/ if (!PIN_POID_COMPARE(b_pdp, poidp, 0, ebufp)) { PIN_ERR_LOG_MSG(PIN_ERR_LEVEL_DEBUG, "first brand is self"); t_flistp = PIN_FLIST_ELEM_GET_NEXT(b_flistp, PIN_FLD_RESULTS, &elemid, 1, &cookie, ebufp); if (PIN_ERR_IS_ERR(ebufp) || t_flistp == (pin_flist_t *)NULL) { PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR, "fm_cust_pol_is_brandname_unique_within_brand() : " "Call to get second brand failed ", ebufp); PIN_FLIST_DESTROY_EX (&b_flistp, NULL); fm_cust_pol_read_err_return_list(poidp, namep, r_flistpp, ebufp); goto cleanup; } /* Get the parent brand object */ b_pdp = PIN_FLIST_FLD_GET(t_flistp, PIN_FLD_BRAND_OBJ, 0, ebufp); } else { PIN_ERR_LOG_MSG(PIN_ERR_LEVEL_DEBUG, "first brand is parent"); } PIN_ERR_LOG_POID(PIN_ERR_LEVEL_DEBUG, "parent brand = ", b_pdp); /*************************************************************** * Check to see if we are creating brand under brandhost ***************************************************************/ rootp = PIN_POID_CREATE(PIN_POID_GET_DB(poidp), "/account", 1, ebufp); if (!PIN_POID_COMPARE(b_pdp, rootp, 0, ebufp)) { under_host = PIN_BOOLEAN_TRUE; /* creating brand under brandhost */ } else { /* creating sub-brand under a brand */ /* get the group_obj_id0 for the parent brand */ cred = CM_FM_BEGIN_OVERRIDE_SCOPE(CM_CRED_SCOPE_OVERRIDE_ROOT); g_pdp = fm_utils_lineage_get_billing_group_by_parent(ctxp, b_pdp, ebufp); CM_FM_END_OVERRIDE_SCOPE(cred); if (PIN_ERR_IS_ERR(ebufp) || g_pdp == (poid_t*)NULL) { PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR, "fm_cust_pol_is_brandname_unique_within_brand() : " "Call to get parent group failed ", ebufp); PIN_POID_DESTROY(rootp, NULL); PIN_FLIST_DESTROY_EX (&b_flistp, NULL); fm_cust_pol_read_err_return_list(poidp, namep, r_flistpp, ebufp); goto cleanup; } } PIN_POID_DESTROY(rootp, NULL); PIN_FLIST_DESTROY_EX (&b_flistp, NULL); /* * Create search flist to try to figure out if someother brand already * has this name within the parent brand. */ flistp = PIN_FLIST_CREATE(ebufp); search_poidp = PIN_POID_CREATE(PIN_POID_GET_DB(poidp), "/search", -1, ebufp); PIN_FLIST_FLD_PUT(flistp, PIN_FLD_POID, (void *)search_poidp, ebufp); int_val = SRCH_DISTINCT; PIN_FLIST_FLD_SET(flistp, PIN_FLD_FLAGS, (void *)&int_val, ebufp); /*************************************************************** * We need different search templates for checking duplicate * brandnames under the brandhost or another brand. * The brandhost doesnot have an entry in the /group/billing * storable class. The only way we can get the names of the * existing brands under the brandhost is to check the lineage * tag. Arguments 1 to 3 are the same for both search templates, * but arguments 4 & 5 are different. ***************************************************************/ if (under_host == PIN_BOOLEAN_FALSE) { /* creating sub-brands under a brand */ PIN_FLIST_FLD_SET(flistp, PIN_FLD_TEMPLATE, (void *)TEMPLATE_UNIQUE_UNDER_BRAND, ebufp); } else { /* creating brand under brandhost */ PIN_FLIST_FLD_SET(flistp, PIN_FLD_TEMPLATE, (void *)TEMPLATE_UNIQUE_UNDER_BRANDHOST, ebufp); } PIN_FLIST_ELEM_SET(flistp, NULL, PIN_FLD_RESULTS, 0, ebufp); /* * Arg 1 is the type of the account; only interested in brand accounts */ sublistp = PIN_FLIST_ELEM_ADD(flistp, PIN_FLD_ARGS, 1, ebufp); PIN_FLIST_FLD_SET(sublistp, PIN_FLD_ACCOUNT_TYPE, (void *)&brand_type, ebufp); /* * Arg 2 is the name of the brand. */ sublistp = PIN_FLIST_ELEM_ADD(flistp, PIN_FLD_ARGS, 2, ebufp); PIN_FLIST_FLD_SET(sublistp, PIN_FLD_NAME, (void *)namep, ebufp); /* * Arg 3 -- POID of account */ sublistp = PIN_FLIST_ELEM_ADD(flistp, PIN_FLD_ARGS, 3, ebufp); PIN_FLIST_FLD_PUT(sublistp, PIN_FLD_POID, NULL, ebufp); if (under_host == PIN_BOOLEAN_FALSE) { /* creating sub-brands under a brand */ /* * Arg 4 -- OBJECT_ID of members from /group/billing */ sublistp = PIN_FLIST_ELEM_ADD(flistp, PIN_FLD_ARGS, 4, ebufp); sublistp = PIN_FLIST_ELEM_ADD(sublistp, PIN_FLD_MEMBERS, PIN_ELEMID_ANY, ebufp); PIN_FLIST_FLD_PUT(sublistp, PIN_FLD_OBJECT, (void *)NULL, ebufp); /* * Arg 5 -- POID of the group */ sublistp = PIN_FLIST_ELEM_ADD(flistp, PIN_FLD_ARGS, 5, ebufp); PIN_FLIST_FLD_SET(sublistp, PIN_FLD_POID, (void *)g_pdp, ebufp); } else { /* creating brand under brandhost */ /* * Arg 4 -- Parent of the group */ sublistp = PIN_FLIST_ELEM_ADD(flistp, PIN_FLD_ARGS, 4, ebufp); PIN_FLIST_FLD_PUT(sublistp, PIN_FLD_PARENT, NULL, ebufp); /* * Arg 5 -- LINEAGE of account */ /* accounts under brandhost have only one ":" in their lineage tag. We want to exclude others. */ vp = (void *)"%:%:%"; sublistp = PIN_FLIST_ELEM_ADD(flistp, PIN_FLD_ARGS, 5, ebufp); PIN_FLIST_FLD_SET(sublistp, PIN_FLD_LINEAGE, vp, ebufp); } /* * Arg 6 -- POID of current account */ sublistp = PIN_FLIST_ELEM_ADD(flistp, PIN_FLD_ARGS, 6, ebufp); PIN_FLIST_FLD_SET(sublistp, PIN_FLD_POID, poidp, ebufp); /* * For completeness, dump the input flist if debugging is enabled. */ PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG, "fm_cust_pol_is_brandname_unique_within_brand search input flist:", flistp); /* * Ready to search! Temporarily suspend search to ensure that * all brands are traversed. */ cred = CM_FM_BEGIN_OVERRIDE_SCOPE(CM_CRED_SCOPE_OVERRIDE_ROOT); PCM_OP(ctxp, PCM_OP_GLOBAL_SEARCH, PCM_OPFLG_COUNT_ONLY, flistp, &rlistp, ebufp); CM_FM_END_OVERRIDE_SCOPE(cred); /* * For completeness, dump the results flist if debugging is enabled * and we actually have a results flist. */ if(rlistp != (pin_flist_t *)NULL) { PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG, "fm_cust_pol_is_brandname_unique_within_brand search output flist:", rlistp); } /* * See if there is a brand out there right now that already has * this name. If so, flag it as an error. */ cookie = (pin_cookie_t)NULL; int_val = 0; PIN_FLIST_ELEM_GET_NEXT(rlistp, PIN_FLD_RESULTS, &int_val, 1, &cookie, ebufp); if(int_val > 0) { *r_flistpp = PIN_FLIST_CREATE(ebufp); PIN_FLIST_FLD_SET(*r_flistpp, PIN_FLD_POID, (void *)poidp, ebufp); fm_cust_pol_valid_add_fail(*r_flistpp, PIN_FLD_NAME, 0, PIN_CUST_VAL_ERR_DUPE, PIN_CUST_DUPE_VALUE_ERR_MSG, (void *)namep, ebufp); pin_set_err(ebufp, PIN_ERRLOC_FM, PIN_ERRCLASS_SYSTEM_DETERMINATE, PIN_ERR_DUPLICATE, PIN_FLD_NAME, 0, 0); } cleanup: /* * Cleanup and return */ PIN_FLIST_DESTROY_EX(&flistp, NULL); PIN_FLIST_DESTROY_EX(&rlistp, NULL); PIN_POID_DESTROY(g_pdp, NULL); }
/******************************************************************* * Main routine for the PCM_OP_PYMT_POL_COLLECT operation. *******************************************************************/ void op_pymt_pol_collect( cm_nap_connection_t *connp, int opcode, int flags, pin_flist_t *i_flistp, pin_flist_t **o_flistpp, pin_errbuf_t *ebufp) { pcm_context_t *ctxp = connp->dm_ctx; pin_flist_t *r_flistp = NULL; int *cmdp = NULL; pin_flist_t *e_flistp = NULL; pin_cookie_t cookie = NULL; int32 elemid = 0; if (PIN_ERR_IS_ERR(ebufp)) return; PIN_ERR_CLEAR_ERR(ebufp); /*********************************************************** * Insanity check. ***********************************************************/ if (opcode != PCM_OP_PYMT_POL_COLLECT) { pin_set_err(ebufp, PIN_ERRLOC_FM, PIN_ERRCLASS_SYSTEM_DETERMINATE, PIN_ERR_BAD_OPCODE, 0, 0, opcode); PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR, "op_pymt_pol_collect opcode error", ebufp); return; } /*********************************************************** * Debug: What we got. ***********************************************************/ PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG, "op_pymt_pol_collect input flist", i_flistp); /*********************************************************** * Prep the return flist. ***********************************************************/ r_flistp = PIN_FLIST_CREATE(ebufp); /****************************************************** * Addition of PIN_FLD_EVENTS in output flist ******************************************************/ while ((e_flistp = PIN_FLIST_ELEM_GET_NEXT(i_flistp, PIN_FLD_EVENTS, &elemid, 1, &cookie, ebufp)) != (pin_flist_t *)NULL) { PIN_FLIST_ELEM_SET(r_flistp, e_flistp, PIN_FLD_EVENTS, elemid, ebufp); } cmdp = (int *)PIN_FLIST_FLD_GET(i_flistp, PIN_FLD_COMMAND, 0, ebufp); if (cmdp && *cmdp == PIN_CHARGE_CMD_NONE){ /*********************************************************** * Processing for PIN_CHARGE_CMD_NONE ***********************************************************/ fm_pymt_pol_collect_command_none(ctxp, i_flistp, flags, &r_flistp, ebufp); } else { /*********************************************************** * Fill in the results. ***********************************************************/ fm_pymt_pol_collect_result(ctxp, i_flistp, r_flistp, ebufp); } /*********************************************************** * Results. ***********************************************************/ if (PIN_ERR_IS_ERR(ebufp)) { /*************************************************** * Log something and return nothing. ***************************************************/ PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR, "op_pymt_pol_collect error", ebufp); PIN_FLIST_DESTROY_EX(&r_flistp, NULL); *o_flistpp = NULL; } else { /*************************************************** * Point the real return flist to the right thing. ***************************************************/ PIN_ERR_CLEAR_ERR(ebufp); *o_flistpp = r_flistp; /*************************************************** * Debug: What we're sending back. ***************************************************/ PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG, "op_pymt_pol_collect return flist", r_flistp); } return; }
/**************************************************************** * Function : fm_cust_pol_prep_create_sponsored_topup * Description : This function will prepare the flist for * creating the sponsored topup operation. ****************************************************************/ static void fm_cust_pol_prep_create_sponsored_topup( pcm_context_t *ctxp, int32 flags, pin_flist_t *i_flistp, pin_flist_t **r_flistpp, pin_errbuf_t *ebufp) { poid_t *initiator_pdp = NULL; poid_t *parent_pdp = NULL; poid_t *balgrp_pdp = NULL; poid_t *s_pdp = NULL; poid_t *grp_pdp = NULL; pin_flist_t *topup_flistp = NULL; pin_flist_t *ingrptopup_flistp = NULL; pin_flist_t *ingrplmt_flistp = NULL; pin_flist_t *ingrpmem_flistp = NULL; pin_flist_t *tmp_flistp = NULL; pin_flist_t *args1_flistp = NULL; pin_flist_t *args2_flistp = NULL; pin_flist_t *args3_flistp = NULL; pin_flist_t *outtopup_flistp = NULL; pin_flist_t *outgrpmem_flistp = NULL; pin_flist_t *outgrptopup_flistp= NULL; pin_flist_t *reslt_flistp = NULL; pin_flist_t *f_flistp = NULL; pin_flist_t *s_flistp = NULL; pin_flist_t *r_flistp = NULL; char *grp_name = NULL; char *s_tmplt = NULL; int *res_id = NULL; int *topup_interval = NULL; int64 db_no = 0; int search_flag = 256; time_t nexttopup; time_t now; void *vp; if (PIN_ERR_IS_ERR(ebufp)) return; PIN_ERR_CLEAR_ERR(ebufp); initiator_pdp = PIN_FLIST_FLD_GET(i_flistp, PIN_FLD_POID, 0, ebufp); topup_flistp = PIN_FLIST_ELEM_GET(i_flistp, PIN_FLD_TOPUP_INFO, PIN_ELEMID_ANY, 0, ebufp); ingrptopup_flistp = PIN_FLIST_ELEM_GET(topup_flistp, PIN_FLD_GROUP_TOPUP_INFO, PIN_ELEMID_ANY, 0, ebufp); ingrpmem_flistp = PIN_FLIST_ELEM_GET(ingrptopup_flistp, PIN_FLD_GROUP_TOPUP_MEMBERS, PIN_ELEMID_ANY, 0, ebufp); ingrplmt_flistp = PIN_FLIST_ELEM_GET(ingrptopup_flistp, PIN_FLD_GROUP_TOPUP_LIMITS, PIN_ELEMID_ANY, 0, ebufp); /**************************************************************** * Update the NEXT_TOPUP_T in the out put flist. ****************************************************************/ outtopup_flistp = PIN_FLIST_ELEM_GET(*r_flistpp, PIN_FLD_TOPUP_INFO, PIN_ELEMID_ANY, 0, ebufp); outgrptopup_flistp = PIN_FLIST_ELEM_GET(outtopup_flistp, PIN_FLD_GROUP_TOPUP_INFO, PIN_ELEMID_ANY, 0, ebufp); outgrpmem_flistp = PIN_FLIST_ELEM_GET(outgrptopup_flistp, PIN_FLD_GROUP_TOPUP_MEMBERS, PIN_ELEMID_ANY, 0, ebufp); topup_interval = PIN_FLIST_FLD_GET(outgrpmem_flistp, PIN_FLD_TOPUP_INTERVAL, 0, ebufp); if (PIN_ERR_IS_ERR(ebufp)) return; vp = PIN_FLIST_FLD_GET(ingrpmem_flistp , PIN_FLD_NEXT_TOPUP_T, 1, ebufp); if(vp){ PIN_FLIST_FLD_SET(outgrpmem_flistp, PIN_FLD_NEXT_TOPUP_T, vp, ebufp); }else{ now = pin_virtual_time((time_t *) NULL); nexttopup = now + ((*topup_interval) * 24 * 60 * 60 ); PIN_FLIST_FLD_SET(outgrpmem_flistp, PIN_FLD_NEXT_TOPUP_T, &nexttopup, ebufp); } grp_name = PIN_FLIST_FLD_GET(ingrptopup_flistp, PIN_FLD_NAME, 1, ebufp); grp_pdp = PIN_FLIST_FLD_GET(ingrptopup_flistp, PIN_FLD_POID, 0, ebufp); /**************************************************************** * check if the group poid is type only or not and also * it has the name or not. ****************************************************************/ if( PIN_POID_IS_TYPE_ONLY(grp_pdp) || !grp_name ) { /**************************************************************** * If the group name or the group poid is not defind in the * input flist then search /group/topup for the particular * parent and set the name and the group poid. ****************************************************************/ parent_pdp = PIN_FLIST_FLD_GET(ingrptopup_flistp, PIN_FLD_PARENT, 0, ebufp); balgrp_pdp = PIN_FLIST_FLD_GET(ingrptopup_flistp, PIN_FLD_BAL_GRP_OBJ, 0, ebufp); res_id = PIN_FLIST_FLD_GET(ingrplmt_flistp, PIN_FLD_RESOURCE_ID, 0, ebufp); db_no = PIN_POID_GET_DB(initiator_pdp); s_flistp = PIN_FLIST_CREATE(ebufp); s_pdp = PIN_POID_CREATE(db_no, "/search", -1, ebufp); s_tmplt = " select X from /group/topup where F1 = V1 and F2 = V2 and F3 = V3 "; PIN_FLIST_FLD_PUT(s_flistp, PIN_FLD_POID, s_pdp, ebufp); PIN_FLIST_FLD_SET(s_flistp, PIN_FLD_TEMPLATE, s_tmplt, ebufp); PIN_FLIST_FLD_SET(s_flistp, PIN_FLD_FLAGS, &search_flag, ebufp); tmp_flistp = PIN_FLIST_CREATE(ebufp); PIN_FLIST_FLD_SET(tmp_flistp, PIN_FLD_PARENT, parent_pdp, ebufp); args1_flistp = PIN_FLIST_CREATE(ebufp); PIN_FLIST_FLD_SET(args1_flistp, PIN_FLD_BAL_GRP_OBJ, balgrp_pdp, ebufp); f_flistp = PIN_FLIST_CREATE(ebufp); if( grp_name == NULL ) { /**************************************************************** * if the group name is null then the search argument will contain * the resource id. ****************************************************************/ args3_flistp = PIN_FLIST_CREATE(ebufp); PIN_FLIST_FLD_SET(f_flistp, PIN_FLD_RESOURCE_ID, res_id, ebufp); PIN_FLIST_ELEM_PUT(args3_flistp, f_flistp, PIN_FLD_GROUP_TOPUP_LIMITS, PCM_RECID_ALL, ebufp); PIN_FLIST_ELEM_PUT(s_flistp, args3_flistp, PIN_FLD_ARGS, 3, ebufp); } else { PIN_FLIST_FLD_SET(f_flistp, PIN_FLD_NAME, grp_name, ebufp); PIN_FLIST_ELEM_PUT(s_flistp, f_flistp, PIN_FLD_ARGS, 3, ebufp); } PIN_FLIST_ELEM_PUT(s_flistp, tmp_flistp, PIN_FLD_ARGS, 1, ebufp); PIN_FLIST_ELEM_PUT(s_flistp, args1_flistp, PIN_FLD_ARGS, 2, ebufp); reslt_flistp = PIN_FLIST_CREATE(ebufp); PIN_FLIST_FLD_SET(reslt_flistp, PIN_FLD_NAME, "",ebufp); PIN_FLIST_ELEM_PUT(s_flistp, reslt_flistp, PIN_FLD_RESULTS, 0, ebufp); PCM_OP(ctxp, PCM_OP_SEARCH, flags, s_flistp, &r_flistp, ebufp); PIN_FLIST_DESTROY_EX(&s_flistp, NULL); tmp_flistp = PIN_FLIST_ELEM_GET(r_flistp, PIN_FLD_RESULTS, 0, 1, ebufp); /**************************************************************** * If the results array of search contains any record then select the * finst element of the results array and set the group poid and name * else don't set it. ****************************************************************/ if( tmp_flistp != NULL ) { grp_name = PIN_FLIST_FLD_GET(tmp_flistp, PIN_FLD_NAME, 0, ebufp); grp_pdp = PIN_FLIST_FLD_GET(tmp_flistp, PIN_FLD_POID, 0, ebufp); f_flistp = PIN_FLIST_ELEM_GET(outtopup_flistp, PIN_FLD_GROUP_TOPUP_INFO, PIN_ELEMID_ANY, 0, ebufp); PIN_FLIST_FLD_SET(f_flistp, PIN_FLD_NAME, grp_name, ebufp); PIN_FLIST_FLD_SET(f_flistp, PIN_FLD_POID, grp_pdp, ebufp); } PIN_FLIST_DESTROY_EX(&r_flistp, NULL); } if (PIN_ERR_IS_ERR(ebufp)) { PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR, "fm_cust_pol_prep_create_sponsored_topup error", ebufp); } return; }
/******************************************************************* * fm_pymt_pol_collect_config(): * * Performs the initial data gathering needed for figuring * out what policy action is needed. We read some info from * the account object and then also read the last bill object * (as pointed to by the account). * *******************************************************************/ static void fm_pymt_pol_collect_config( pcm_context_t *ctxp, pin_flist_t *i_flistp, pin_flist_t **o_flistpp, pin_errbuf_t *ebufp) { pin_flist_t *a_flistp = NULL; pin_flist_t *r_flistp = NULL; poid_t *a_pdp = NULL; poid_t *b_pdp = NULL; void *vp; if (PIN_ERR_IS_ERR(ebufp)) return; PIN_ERR_CLEAR_ERR(ebufp); /*********************************************************** * Null the results until we have them. ***********************************************************/ *o_flistpp = (pin_flist_t *)NULL; /*********************************************************** * Get the input info. ***********************************************************/ a_pdp = (poid_t *)PIN_FLIST_FLD_GET(i_flistp, PIN_FLD_POID, 0, ebufp); /*********************************************************** * Create the flist for reading the account. ***********************************************************/ a_flistp = PIN_FLIST_CREATE(ebufp); vp = (void *)a_pdp; PIN_FLIST_FLD_SET(a_flistp, PIN_FLD_POID, vp, ebufp); vp = (void *)NULL; PIN_FLIST_FLD_SET(a_flistp, PIN_FLD_STATUS, vp, ebufp); PIN_FLIST_FLD_SET(a_flistp, PIN_FLD_STATUS_FLAGS, vp, ebufp); PIN_FLIST_FLD_SET(a_flistp, PIN_FLD_PENDING_RECV, vp, ebufp); PIN_FLIST_FLD_SET(a_flistp, PIN_FLD_LAST_BILL_OBJ, vp, ebufp); /*********************************************************** * Read the info from the account. ***********************************************************/ PCM_OP(ctxp, PCM_OP_READ_FLDS, 0, a_flistp, o_flistpp, ebufp); /*********************************************************** * Clean up. ***********************************************************/ PIN_FLIST_DESTROY_EX(&a_flistp, NULL); b_pdp = (poid_t *)PIN_FLIST_FLD_GET(i_flistp, PIN_FLD_BILLINFO_OBJ, 0, ebufp); /*********************************************************** * Create the flist for reading the billinfo. ***********************************************************/ a_flistp = PIN_FLIST_CREATE(ebufp); PIN_FLIST_FLD_SET(a_flistp, PIN_FLD_POID, b_pdp, ebufp); vp = (void *)NULL; PIN_FLIST_FLD_SET(a_flistp, PIN_FLD_PENDING_RECV, vp, ebufp); PIN_FLIST_FLD_SET(a_flistp, PIN_FLD_LAST_BILL_OBJ, vp, ebufp); PCM_OP(ctxp, PCM_OP_READ_FLDS, 0, a_flistp, &r_flistp, ebufp); vp = PIN_FLIST_FLD_GET(r_flistp, PIN_FLD_PENDING_RECV, 0, ebufp); PIN_FLIST_FLD_SET(*o_flistpp, PIN_FLD_PENDING_RECV, vp, ebufp); vp = PIN_FLIST_FLD_GET(r_flistp, PIN_FLD_LAST_BILL_OBJ, 0, ebufp); PIN_FLIST_FLD_SET(*o_flistpp, PIN_FLD_LAST_BILL_OBJ, vp, ebufp); PIN_FLIST_DESTROY_EX(&a_flistp, NULL); PIN_FLIST_DESTROY_EX(&r_flistp, NULL); /*********************************************************** * Error? ***********************************************************/ if (PIN_ERR_IS_ERR(ebufp)) { PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR, "fm_pymt_pol_collect_config", ebufp); } return; }
/******************************************************************* * Multi search. * * Performs a read-fields search to get the poid, merchant * and status of all non-billable accounts in the database. * We walk the results array and display each individually. * * The "one arg equal" search for /account is 201. * *******************************************************************/ void sample_read_flds_search( pcm_context_t *ctxp, u_int64 database, pin_errbuf_t *ebufp) { pin_cookie_t cookie = NULL; pin_flist_t *flistp = NULL; pin_flist_t *a_flistp = NULL; pin_flist_t *r_flistp = NULL; poid_t *objp = NULL; u_int64 id; u_int vp; int32 rec_id; /*********************************************************** * Check the error buffer. ***********************************************************/ if (PIN_ERR_IS_ERR(ebufp)) return; PIN_ERR_CLEAR_ERR(ebufp); /*********************************************************** * Allocate the flist for searching. ***********************************************************/ flistp = PIN_FLIST_CREATE(ebufp); /*********************************************************** * Allocate the search poid and give it to the flist. ***********************************************************/ id = (u_int64)201; objp = PIN_POID_CREATE(database, "/search", id, ebufp); PIN_FLIST_FLD_PUT(flistp, PIN_FLD_POID, (void *)objp, ebufp); /*********************************************************** * Add a search arguments array. ***********************************************************/ a_flistp = PIN_FLIST_ELEM_ADD(flistp, PIN_FLD_ARGS, 1, ebufp); /*********************************************************** * Add non-billable (= undefined) as the argument. ***********************************************************/ vp = PIN_BILL_TYPE_UNDEFINED; PIN_FLIST_FLD_SET(a_flistp, PIN_FLD_BILL_TYPE, (void *)&vp, ebufp); /*********************************************************** * Add a search results array. ***********************************************************/ a_flistp = PIN_FLIST_ELEM_ADD(flistp, PIN_FLD_RESULTS, 0, ebufp); /*********************************************************** * Add markers for the fields we want to read. ***********************************************************/ PIN_FLIST_FLD_SET(a_flistp, PIN_FLD_POID, (void *)NULL, ebufp); PIN_FLIST_FLD_SET(a_flistp, PIN_FLD_MERCHANT, (void *)NULL, ebufp); PIN_FLIST_FLD_SET(a_flistp, PIN_FLD_STATUS, (void *)NULL, ebufp); /*********************************************************** * Call the DM to do the search. ***********************************************************/ PCM_OP(ctxp, PCM_OP_SEARCH, 0, flistp, &r_flistp, ebufp); /*********************************************************** * Walk the results array. ***********************************************************/ a_flistp = PIN_FLIST_ELEM_GET_NEXT(r_flistp, PIN_FLD_RESULTS, &rec_id, 1, &cookie, ebufp); while (a_flistp != (pin_flist_t *)NULL) { /*************************************************** * Show this result. ***************************************************/ fprintf(stdout,"\nMulti Search Result(%d) Flist:\n", rec_id); PIN_FLIST_PRINT(a_flistp, stdout, ebufp); /*************************************************** * Get the next result. ***************************************************/ a_flistp = PIN_FLIST_ELEM_GET_NEXT(r_flistp, PIN_FLD_RESULTS, &rec_id, 1, &cookie, ebufp); } /*********************************************************** * Clean up. ***********************************************************/ /* Free local memory */ PIN_FLIST_DESTROY(r_flistp, NULL); PIN_FLIST_DESTROY(flistp, NULL); /* Error? */ if (PIN_ERR_IS_ERR(ebufp)) { PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR, "sample_read_flds_search error", ebufp); } return; }
/******************************************************************** * fm_cust_pol_get_poplist() * * Obtains a list of pops and adds to the given outflistp. * If no PIN_FLD_ANI is found on the input flist, then the * entire pop list is returned. Otherwise, only the POP * matching the ANI is returned. * ********************************************************************/ static void fm_cust_pol_get_poplist( pcm_context_t *ctxp, /* Connection context */ pin_flist_t *in_flistp, /* Client's input flist */ pin_flist_t *out_flistp, /* Search results flist */ pin_errbuf_t *ebufp) /* Error buff */ { u_int64 database; /* Requested database */ poid_t *poidp = NULL; /* Input poid */ poid_t *objp = NULL; /* New search poid */ poid_t *type_poidp; /* Used for full poplist*/ pin_cookie_t cookie = NULL; /* For getting results */ pin_cookie_t cookie2 = NULL; /* For getting anis */ pin_flist_t *flistp = NULL; /* Search flist created */ pin_flist_t *ani_flistp = NULL; /* ANI array flist */ pin_flist_t *a_flistp = NULL; /* New element pointer */ pin_flist_t *e_flistp = NULL; /* Element ptr 4 pop arr*/ pin_flist_t *r_flistp = NULL; /* Search return flist */ pin_flist_t *sort_flistp = NULL; /* Sort flist */ u_int64 id; /* Search id */ u_int type = POP_PRIMARY; /* Only return prime pop*/ int32 rec_id; /* PIN_FLD_RESULTS elem */ int32 rec_id2; /* ANI results elem */ void *vp; /* PIN_FLD_ANI value */ void *vp2; /* Returned fields ptr */ /*********************************************************** * Check the error buffer. ***********************************************************/ if (PIN_ERR_IS_ERR(ebufp)) return; PIN_ERR_CLEAR_ERR(ebufp); /*********************************************************** * Allocate the flist for searching. ***********************************************************/ flistp = PIN_FLIST_CREATE(ebufp); /*********************************************************** * Get the database number. ***********************************************************/ poidp = (poid_t *)PIN_FLIST_FLD_GET(in_flistp, PIN_FLD_POID, 0, ebufp); database = PIN_POID_GET_DB(poidp); /*********************************************************** * Allocate the search poid and give it to the flist. Use * the 2 arg search id if args are found, otherwise use * the 1 arg search which returns all the pops ordered. ***********************************************************/ vp = PIN_FLIST_FLD_GET(in_flistp, PIN_FLD_ANI, 1, ebufp); if (vp == NULL) { id = (u_int64)300; } else { id = (u_int64)301; } objp = PIN_POID_CREATE(database, "/search/pin", id, ebufp); PIN_FLIST_FLD_PUT(flistp, PIN_FLD_POID, (void *)objp, ebufp); /*********************************************************** * Add a search arguments array. ***********************************************************/ a_flistp = PIN_FLIST_ELEM_ADD(flistp, PIN_FLD_ARGS, 1, ebufp); /*********************************************************** * Determine whether the entire poplist should be returned * or an ani to pop match should be done. The rule is if * there's a PIN_FLD_ANI field, return the entire list, * otherwise, do a ani to pop match but only return the * primary one. ***********************************************************/ type_poidp = PIN_POID_CREATE(database, "/pop", (int64)-1, ebufp); if (vp == NULL) { PIN_FLIST_FLD_PUT(a_flistp, PIN_FLD_POID, (void *)type_poidp, ebufp); } else { /* ** 2 arg search, return pop that matches ani and is a ** primary pop. */ ani_flistp = PIN_FLIST_CREATE(ebufp); /* ** PIN_FLD_ANI for our first arg. */ PIN_FLIST_FLD_SET(ani_flistp, PIN_FLD_ANI, vp, ebufp ); PIN_FLIST_ELEM_SET(a_flistp, ani_flistp, PIN_FLD_ANIS, 0, ebufp ); /* ** PIN_FLD_TYPE for our second arg. */ a_flistp = PIN_FLIST_ELEM_ADD(flistp, PIN_FLD_ARGS, 2, ebufp); ani_flistp = PIN_FLIST_CREATE(ebufp); PIN_FLIST_FLD_SET(ani_flistp, PIN_FLD_TYPE, (void *)&type, ebufp); PIN_FLIST_ELEM_SET(a_flistp, ani_flistp, PIN_FLD_ANIS, 1, ebufp); } /*********************************************************** * Put on the PIN_FLD_RESULTS array for our results. ***********************************************************/ a_flistp = PIN_FLIST_ELEM_ADD(flistp, PIN_FLD_RESULTS, 0, ebufp); /* ** Return the pop, city, state and zip fields if the entire poplist ** was requested, otherwise return the same fields including ** the flags if pop matching was requested. */ PIN_FLIST_FLD_SET(a_flistp, PIN_FLD_PHONE, (void *)NULL, ebufp); PIN_FLIST_FLD_SET(a_flistp, PIN_FLD_CITY, (void *)NULL, ebufp); PIN_FLIST_FLD_SET(a_flistp, PIN_FLD_STATE, (void *)NULL, ebufp); PIN_FLIST_FLD_SET(a_flistp, PIN_FLD_ZIP, (void *)NULL, ebufp); if (vp != NULL) { /* ** Add the ANIS array if PIN_FLD_ANI arg was passed in. */ ani_flistp = PIN_FLIST_CREATE(ebufp); PIN_FLIST_FLD_SET(ani_flistp, PIN_FLD_ANI, (void *)NULL, ebufp); PIN_FLIST_FLD_SET(ani_flistp, PIN_FLD_TYPE, (void *)NULL, ebufp); PIN_FLIST_FLD_SET(ani_flistp, PIN_FLD_FLAGS, (void *)NULL, ebufp); PIN_FLIST_ELEM_SET(a_flistp, ani_flistp, PIN_FLD_ANIS, 0, ebufp); } /*********************************************************** * Call the DM to do the search. ***********************************************************/ PCM_OP(ctxp, PCM_OP_SEARCH, 0, flistp, &r_flistp, ebufp); /*********************************************************** * Walk the search results array adding each to the * PIN_FLD_POP's array flist to pass back to the caller. ***********************************************************/ a_flistp = PIN_FLIST_ELEM_GET_NEXT(r_flistp, PIN_FLD_RESULTS, &rec_id, 1, &cookie, ebufp); while (a_flistp != (pin_flist_t *)NULL) { e_flistp = PIN_FLIST_ELEM_ADD(out_flistp, PIN_FLD_POP, rec_id, ebufp); /* ** Take the PIN_FLD_PHONE and put it on the PIN_FLD_POP array. */ vp2 = PIN_FLIST_FLD_TAKE(a_flistp, PIN_FLD_PHONE, 0, ebufp); PIN_FLIST_FLD_PUT(e_flistp, PIN_FLD_PHONE, vp2, ebufp); /* ** Take the PIN_FLD_CITY and put it on the PIN_FLD_POP array. */ vp2 = PIN_FLIST_FLD_TAKE(a_flistp, PIN_FLD_CITY, 0, ebufp); PIN_FLIST_FLD_PUT(e_flistp, PIN_FLD_CITY, vp2, ebufp); /* ** Take the PIN_FLD_STATE and put it on the PIN_FLD_POP array. */ vp2 = PIN_FLIST_FLD_TAKE(a_flistp, PIN_FLD_STATE, 0, ebufp); PIN_FLIST_FLD_PUT(e_flistp, PIN_FLD_STATE, vp2, ebufp); /* ** Take the PIN_FLD_ZIP and put it on the PIN_FLD_POP array. */ vp2 = PIN_FLIST_FLD_TAKE(a_flistp, PIN_FLD_ZIP, 0, ebufp); PIN_FLIST_FLD_PUT(e_flistp, PIN_FLD_ZIP, vp2, ebufp); /* ** Walk the ani array (if we're pop matching) to get the ** PIN_FLD_FLAGS field, should only be one. */ if (vp != NULL) { ani_flistp = (pin_flist_t *)NULL; ani_flistp = PIN_FLIST_ELEM_GET_NEXT(a_flistp, PIN_FLD_ANIS, &rec_id2, 0, &cookie2, ebufp); while (ani_flistp != (pin_flist_t *)NULL) { vp2 = PIN_FLIST_FLD_TAKE(ani_flistp, PIN_FLD_FLAGS, 0, ebufp); PIN_FLIST_FLD_PUT(e_flistp, PIN_FLD_FLAGS, vp2, ebufp); ani_flistp = PIN_FLIST_ELEM_GET_NEXT(a_flistp, PIN_FLD_ANIS, &rec_id2, 1, &cookie2, ebufp); } } /*************************************************** * Get the next result. ***************************************************/ a_flistp = PIN_FLIST_ELEM_GET_NEXT(r_flistp, PIN_FLD_RESULTS, &rec_id, 1, &cookie, ebufp); } /*********************************************************** * Clean up. ***********************************************************/ PIN_FLIST_DESTROY(flistp, NULL); PIN_FLIST_DESTROY(r_flistp, NULL); if (PIN_ERR_IS_ERR(ebufp)) { PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR, "fm_cust_pol_read_poplist error", ebufp); } return; } /* fm_cust_pol_read_poplist */
/******************************************************************* * Simple search. * * Performs a read-object search for the master account * object and displays the results with PIN_FLIST_PRINT. * * The "one arg equal" search for /account is 201. * * Note: In real life, this isn't particularly useful * since we could use the poid of the account to do a * read-object op directly. * *******************************************************************/ void sample_read_obj_search( pcm_context_t *ctxp, u_int64 database, pin_errbuf_t *ebufp) { pin_flist_t *flistp = NULL; pin_flist_t *a_flistp = NULL; pin_flist_t *r_flistp = NULL; poid_t *objp = NULL; u_int64 id; /*********************************************************** * Check the error buffer. ***********************************************************/ if (PIN_ERR_IS_ERR(ebufp)) return; PIN_ERR_CLEAR_ERR(ebufp); /*********************************************************** * Allocate the flist for searching. ***********************************************************/ flistp = PIN_FLIST_CREATE(ebufp); /*********************************************************** * Allocate the search poid and give it to the flist. ***********************************************************/ id = (u_int64)201; objp = PIN_POID_CREATE(database, "/search", id, ebufp); PIN_FLIST_FLD_PUT(flistp, PIN_FLD_POID, (void *)objp, ebufp); /*********************************************************** * Add a search arguments array. ***********************************************************/ a_flistp = PIN_FLIST_ELEM_ADD(flistp, PIN_FLD_ARGS, 1, ebufp); /*********************************************************** * Allocate the master account poid and add as the arg. ***********************************************************/ id = (u_int64)1; objp = PIN_POID_CREATE(database, "/account", id, ebufp); PIN_FLIST_FLD_PUT(a_flistp, PIN_FLD_POID, (void *)objp, ebufp); /*********************************************************** * Add a search results marker. * * Making this NULL forces the read-object result we want. ***********************************************************/ a_flistp = (pin_flist_t *)NULL; PIN_FLIST_ELEM_PUT(flistp, a_flistp, PIN_FLD_RESULTS, 0, ebufp); /*********************************************************** * Call the DM to do the search. ***********************************************************/ PCM_OP(ctxp, PCM_OP_SEARCH, 0, flistp, &r_flistp, ebufp); /*********************************************************** * Get (and show) the results. ***********************************************************/ a_flistp = PIN_FLIST_ELEM_GET(r_flistp, PIN_FLD_RESULTS, 0, 0, ebufp); fprintf(stdout,"\nSimple Search Result Flist:\n"); PIN_FLIST_PRINT(a_flistp, stdout, ebufp); /*********************************************************** * Clean up. ***********************************************************/ /* Free local memory */ PIN_FLIST_DESTROY(r_flistp, NULL); PIN_FLIST_DESTROY(flistp, NULL); /* Error? */ if (PIN_ERR_IS_ERR(ebufp)) { PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR, "sample_read_obj_search error", ebufp); } return; }
/******************************************************************* * Main routine for the PCM_OP_CUST_POL_GET_POPLIST operation. *******************************************************************/ void op_cust_pol_get_poplist( cm_nap_connection_t *connp, /* Connection pointer */ u_int opcode, /* Opcode in question */ u_int flags, /* Standard flags if any*/ pin_flist_t *in_flistp, /* Input flist */ pin_flist_t **ret_flistpp, /* Results flist */ pin_errbuf_t *ebufp) /* Error buffer */ { pcm_context_t *ctxp = connp->dm_ctx; /* Connection */ pin_flist_t *r_flistp = NULL; /* Local flist */ void *vp = NULL; /*********************************************************** * Null out results until we have some. ***********************************************************/ *ret_flistpp = NULL; PIN_ERR_CLEAR_ERR(ebufp); /*********************************************************** * Insanity check. ***********************************************************/ if (opcode != PCM_OP_CUST_POL_GET_POPLIST) { pin_set_err(ebufp, PIN_ERRLOC_FM, PIN_ERRCLASS_SYSTEM_DETERMINATE, PIN_ERR_BAD_OPCODE, 0, 0, opcode); PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR, "bad opcode in op_cust_pol_get_poplist", ebufp); return; } /*********************************************************** * Debug: what did we get? ***********************************************************/ PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG, "op_cust_pol_get_poplist input flist", in_flistp); /*********************************************************** * Create the pop flist & copy the input poid to it. ***********************************************************/ r_flistp = PIN_FLIST_CREATE(ebufp); vp = PIN_FLIST_FLD_GET(in_flistp, PIN_FLD_POID, 0, ebufp); PIN_FLIST_FLD_SET(r_flistp, PIN_FLD_POID, vp, ebufp); /*********************************************************** * Call a sub-function to actually find the pops. ***********************************************************/ fm_cust_pol_get_poplist(ctxp, in_flistp, r_flistp, ebufp); /*********************************************************** * Result. ***********************************************************/ if (PIN_ERR_IS_ERR(ebufp)) { *ret_flistpp = (pin_flist_t *)NULL; PIN_FLIST_DESTROY(r_flistp, NULL); PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR, "op_cust_pol_get_poplist error", ebufp); } else { *ret_flistpp = r_flistp; PIN_ERR_CLEAR_ERR(ebufp); PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG, "op_cust_pol_get_poplist return flist", r_flistp); } return; } /* op_cust_pol_get_poplist */
/******************************************************************* * fm_act_pol_add_event_bal_impacts(): *******************************************************************/ void fm_act_pol_add_event_bal_impacts( pcm_context_t *ctxp, pin_flist_t *a_flistp, pin_errbuf_t *ebufp) { pin_cookie_t cookie = NULL; pin_flist_t *bi_flistp = NULL; pin_flist_t *flistp = NULL; pin_flist_t *bia_flistp = NULL; poid_t *r_pdp = NULL; void *vp = NULL; int impact_type = 0; int count = 0; int rec_id = 0; pin_decimal_t *dummyp = NULL; if (PIN_ERR_IS_ERR(ebufp)) return; PIN_ERR_CLEAR_ERR(ebufp); dummyp = pbo_decimal_from_str("0.0", ebufp); /*********************************************************** * Set the balance impact type as pre-rated. ***********************************************************/ impact_type = PIN_IMPACT_TYPE_PRERATED; bia_flistp = PIN_FLIST_CREATE(ebufp); /*********************************************************** * Walk the PIN_FLD_TOTALS array in the original event and * add a corresponding balance impact arary for that. ***********************************************************/ while ((flistp = PIN_FLIST_ELEM_GET_NEXT(a_flistp, PIN_FLD_TOTAL, &rec_id, 1, &cookie, ebufp)) != (pin_flist_t *)NULL) { /*************************************************** * Add a new element for this balance impact. ***************************************************/ count = (int)PIN_FLIST_ELEM_COUNT(bia_flistp, PIN_FLD_BAL_IMPACTS, ebufp); bi_flistp = PIN_FLIST_ELEM_ADD(bia_flistp, PIN_FLD_BAL_IMPACTS, count, ebufp); /*************************************************** * Start filling in the standard field values now. ***************************************************/ PIN_FLIST_FLD_SET(bi_flistp, PIN_FLD_IMPACT_TYPE, (void *)&impact_type, ebufp); PIN_FLIST_FLD_SET(bi_flistp, PIN_FLD_RESOURCE_ID, (void *)&rec_id, ebufp); PIN_FLIST_FLD_SET(bi_flistp, PIN_FLD_TAX_CODE, (void *)"", ebufp); PIN_FLIST_FLD_SET(bi_flistp, PIN_FLD_RATE_TAG, (void *)"", ebufp); /*************************************************** * Get and Set the account and item object poids. ***************************************************/ vp = PIN_FLIST_FLD_GET(a_flistp, PIN_FLD_ACCOUNT_OBJ, 0, ebufp); PIN_FLIST_FLD_SET(bi_flistp, PIN_FLD_ACCOUNT_OBJ, vp, ebufp); vp = PIN_FLIST_FLD_GET(a_flistp, PIN_FLD_ITEM_OBJ, 1, ebufp); if (vp) { PIN_FLIST_FLD_SET(bi_flistp, PIN_FLD_ITEM_OBJ, vp, ebufp); } /*************************************************** * Fill in the dummy rate object poid. ***************************************************/ r_pdp = PIN_POID_CREATE(0, "", 0, ebufp); PIN_FLIST_FLD_PUT(bi_flistp, PIN_FLD_RATE_OBJ, (void *)r_pdp, ebufp); /*************************************************** * set the 0 for quantity, discount and percentage ***************************************************/ PIN_FLIST_FLD_SET(bi_flistp, PIN_FLD_DISCOUNT, (void *)dummyp, ebufp); PIN_FLIST_FLD_SET(bi_flistp, PIN_FLD_PERCENT, (void *)dummyp, ebufp); PIN_FLIST_FLD_SET(bi_flistp, PIN_FLD_QUANTITY, (void *)dummyp, ebufp); /*************************************************** * Set the amount deferred to 0.0 ***************************************************/ PIN_FLIST_FLD_SET(bi_flistp, PIN_FLD_AMOUNT_DEFERRED, (void *)dummyp, ebufp); /*************************************************** * Get the amount and set in the bal impact. ***************************************************/ vp = PIN_FLIST_FLD_GET(flistp, PIN_FLD_AMOUNT, 0, ebufp); PIN_FLIST_FLD_SET(bi_flistp, PIN_FLD_AMOUNT, vp, ebufp); } PIN_FLIST_CONCAT(a_flistp, bia_flistp, ebufp); PIN_FLIST_DESTROY_EX(&bia_flistp, NULL); pbo_decimal_destroy(&dummyp); /*********************************************************** * Error? ***********************************************************/ if (PIN_ERR_IS_ERR(ebufp)) { PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR, "fm_act_pol_add_event_bal_impacts error", ebufp); } return; }
static void fm_pymt_pol_spec_collect_get_items( pcm_context_t *ctxp, int32 flags, pin_flist_t *i_flistp, pin_flist_t *o_flistp, pin_errbuf_t *ebufp) { pin_flist_t *items_flistp = NULL; pin_flist_t *r_flistp = NULL; pin_flist_t *flistp = NULL; poid_t *s_pdp = NULL; poid_t *bi_pdp = NULL; int32 status = 0; int64 database = 0; int32 sflags = SRCH_DISTINCT; int32 result = PIN_BOOLEAN_FALSE; void *vp = NULL; pin_decimal_t *zero_decimal = pin_decimal("0.0", ebufp); if (PIN_ERR_IS_ERR(ebufp)) { return; } PIN_ERR_CLEAR_ERR(ebufp); /********************************************************* * Get the ACH details. *********************************************************/ fm_pymt_pol_spec_collect_get_ach(ctxp, flags, i_flistp, o_flistp, ebufp); bi_pdp = PIN_FLIST_FLD_GET(i_flistp, PIN_FLD_BILLINFO_OBJ, 0, ebufp); /********************************************************* * Create the search flist to search in the item objects *********************************************************/ items_flistp = PIN_FLIST_CREATE(ebufp); database = PIN_POID_GET_DB(bi_pdp); s_pdp = PIN_POID_CREATE(database, "/search", -1, ebufp); PIN_FLIST_FLD_PUT(items_flistp, PIN_FLD_POID, (void *)s_pdp, ebufp); PIN_FLIST_FLD_SET(items_flistp, PIN_FLD_TEMPLATE, (void *) "select X from /item where F1 = V1 and ( F2 = V2 or F3 = V3 )" \ " and F4 != V4 order by F5 ", ebufp); PIN_FLIST_FLD_SET(items_flistp, PIN_FLD_FLAGS, (void *)&sflags, ebufp); /********************************************************* * Add the search arguments. *********************************************************/ flistp = PIN_FLIST_ELEM_ADD(items_flistp, PIN_FLD_ARGS, 1, ebufp); PIN_FLIST_FLD_SET(flistp, PIN_FLD_AR_BILLINFO_OBJ, (void *)bi_pdp, ebufp); status = PIN_ITEM_STATUS_PENDING; flistp = PIN_FLIST_ELEM_ADD(items_flistp, PIN_FLD_ARGS, 2, ebufp); PIN_FLIST_FLD_SET(flistp, PIN_FLD_STATUS, (void *)&status, ebufp); status = PIN_ITEM_STATUS_OPEN; flistp = PIN_FLIST_ELEM_ADD(items_flistp, PIN_FLD_ARGS, 3, ebufp); PIN_FLIST_FLD_SET(flistp, PIN_FLD_STATUS, (void *)&status, ebufp); flistp = PIN_FLIST_ELEM_ADD(items_flistp, PIN_FLD_ARGS, 4, ebufp); PIN_FLIST_FLD_SET(flistp, PIN_FLD_DUE, (void *)zero_decimal, ebufp); flistp = PIN_FLIST_ELEM_ADD(items_flistp, PIN_FLD_ARGS, 5, ebufp); PIN_FLIST_FLD_SET(flistp, PIN_FLD_EFFECTIVE_T, (void *)NULL, ebufp); /********************************************************* * Add the results array for the search. *********************************************************/ flistp = PIN_FLIST_ELEM_ADD(items_flistp, PIN_FLD_RESULTS, 0, ebufp); PIN_FLIST_FLD_SET(flistp, PIN_FLD_POID,(void *)NULL, ebufp); PIN_FLIST_FLD_SET(flistp, PIN_FLD_BILL_OBJ, (void *)NULL, ebufp); PIN_FLIST_FLD_SET(flistp, PIN_FLD_AR_BILL_OBJ, (void *)NULL, ebufp); PIN_FLIST_FLD_SET(flistp, PIN_FLD_ACCOUNT_OBJ, (void *)NULL, ebufp); PIN_FLIST_FLD_SET(flistp, PIN_FLD_DUE,(void *) NULL, ebufp); PIN_FLIST_FLD_SET(flistp, PIN_FLD_EFFECTIVE_T, (void *)NULL, ebufp); PIN_FLIST_FLD_SET(flistp, PIN_FLD_ITEM_TOTAL, (void *)NULL, ebufp); PIN_FLIST_FLD_SET(flistp, PIN_FLD_DISPUTED, (void *)NULL, ebufp); PIN_FLIST_FLD_SET(flistp, PIN_FLD_RECVD, (void *)NULL, ebufp); PIN_FLIST_FLD_SET(flistp, PIN_FLD_ADJUSTED, (void *)NULL, ebufp); PIN_FLIST_FLD_SET(flistp, PIN_FLD_TRANSFERED, (void *)NULL, ebufp); PIN_FLIST_FLD_SET(flistp, PIN_FLD_CURRENCY, (void *)NULL, ebufp); PIN_FLIST_FLD_SET(flistp, PIN_FLD_STATUS, (void *)NULL, ebufp); PIN_FLIST_FLD_SET(flistp, PIN_FLD_ITEM_NO, (void *)NULL, ebufp); PIN_FLIST_FLD_SET(flistp, PIN_FLD_BILLINFO_OBJ, (void *)NULL, ebufp); PIN_FLIST_FLD_SET(flistp, PIN_FLD_AR_BILLINFO_OBJ, (void *)NULL, ebufp); PIN_FLIST_FLD_SET(flistp, PIN_FLD_SERVICE_OBJ, (void *)NULL, ebufp); PIN_FLIST_FLD_SET(flistp, PIN_FLD_EVENT_POID_LIST, (void *)NULL, ebufp); /********************************************************** * search ALL Open and Pending items **********************************************************/ PCM_OP(ctxp, PCM_OP_SEARCH, PCM_OPFLG_READ_UNCOMMITTED , items_flistp, &r_flistp,ebufp); if (PIN_FLIST_FLD_COPY(r_flistp, PIN_FLD_RESULTS, o_flistp, PIN_FLD_ITEMS, ebufp) == 1) { result = PIN_BOOLEAN_TRUE; } PIN_FLIST_FLD_SET(o_flistp, PIN_FLD_BOOLEAN, (void *)&result, ebufp); /********************************************************* * Cleanup... *********************************************************/ PIN_FLIST_DESTROY_EX(&items_flistp, NULL); PIN_FLIST_DESTROY_EX(&r_flistp, NULL); PIN_DECIMAL_DESTROY_EX(&zero_decimal); /********************************************************* * Errors..? *********************************************************/ if (PIN_ERR_IS_ERR(ebufp)) { PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR, "fm_pymt_pol_spec_collect_get_items error", ebufp); } return; }