/*******************************************************************
* fm_pymt_pol_collect_clear_pending():
*******************************************************************/
static void
fm_pymt_pol_collect_clear_pending(
pin_flist_t *r_flistp,
pin_decimal_t *amount,
char *descr,
pin_errbuf_t *ebufp)
{
pin_flist_t *flistp = NULL;
char *action;
int count;
if (PIN_ERR_IS_ERR(ebufp))
return;
PIN_ERR_CLEAR_ERR(ebufp);
/***********************************************************
* Don't bother with zero amounts.
***********************************************************/
if (pbo_decimal_sign(amount, ebufp) == 0) {
return;
/*****/
}
/***********************************************************
* What elemid to add.
***********************************************************/
count = PIN_FLIST_ELEM_COUNT(r_flistp, PIN_FLD_ACTIVITIES, ebufp);
/***********************************************************
* Add our element.
***********************************************************/
flistp = PIN_FLIST_ELEM_ADD(r_flistp, PIN_FLD_ACTIVITIES, count, ebufp);
/***********************************************************
* Fill in our values.
***********************************************************/
action = "clear_pending";
PIN_FLIST_FLD_SET(flistp, PIN_FLD_ACTION, (void *)action, ebufp);
PIN_FLIST_FLD_SET(flistp, PIN_FLD_AMOUNT, (void *)amount, ebufp);
PIN_FLIST_FLD_SET(flistp, PIN_FLD_DESCR, (void *)descr, ebufp);
return;
}
/*******************************************************************
* fm_pymt_pol_collect_set_status():
*******************************************************************/
static void
fm_pymt_pol_collect_set_status(
pin_flist_t *r_flistp,
pin_status_t status,
int flags,
char *descr,
pin_errbuf_t *ebufp)
{
pin_flist_t *flistp = NULL;
char *action;
int count;
if (PIN_ERR_IS_ERR(ebufp))
return;
PIN_ERR_CLEAR_ERR(ebufp);
/***********************************************************
* What elemid to add.
***********************************************************/
count = PIN_FLIST_ELEM_COUNT(r_flistp, PIN_FLD_ACTIVITIES, ebufp);
/***********************************************************
* Add our element.
***********************************************************/
flistp = PIN_FLIST_ELEM_ADD(r_flistp, PIN_FLD_ACTIVITIES, count, ebufp);
/***********************************************************
* Fill in our values.
***********************************************************/
action = "set_status";
PIN_FLIST_FLD_SET(flistp, PIN_FLD_ACTION, (void *)action, ebufp);
PIN_FLIST_FLD_SET(flistp, PIN_FLD_STATUS, (void *)&status, ebufp);
PIN_FLIST_FLD_SET(flistp, PIN_FLD_STATUS_FLAGS, (void *)&flags, ebufp);
PIN_FLIST_FLD_SET(flistp, PIN_FLD_DESCR, (void *)descr, 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);
}
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);
}
}
/*
* 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);
}
/**********************************************************************
* 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;
}
//****************************************************
// 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;
}
/************************************************************************
* fm_cust_pol_valid_add_fail():
*
* Add a field validation failure element to the given flist
* using the info passed in. We assume the flist has N field
* failures on it already with element ids of 0 to (N-1) so
* we add a new element with an element id of N.
*
* No error checking is done on the values passed in, but we
* do allow for some values to be optional according to the
* PCM_OP_CUST_POL_VALID_* return flist specs.
*
* We return a pointer to the element we add to facilitate
* layering (by the caller) of the validation failures within
* substruct and array fields.
*
************************************************************************/
pin_flist_t *
fm_cust_pol_valid_add_fail(
pin_flist_t *r_flistp,
u_int field,
u_int elemid,
u_int result,
char *descr,
void *val,
pin_errbuf_t *ebufp)
{
pin_flist_t *flistp = NULL;
u_int my_id = 0;
u_int type = 0;
u_int fail = 0;
if (PIN_ERR_IS_ERR(ebufp))
return(flistp);
PIN_ERR_CLEAR_ERR(ebufp);
/****************************************************************
* Create the field failure element.
****************************************************************/
my_id = PIN_FLIST_ELEM_COUNT(r_flistp, PIN_FLD_FIELD, ebufp);
flistp = PIN_FLIST_ELEM_ADD(r_flistp, PIN_FLD_FIELD, my_id, ebufp);
/****************************************************************
* If this is the first time, mark the main result as _FAILED.
****************************************************************/
if (my_id == 0) {
fail = PIN_CUST_VERIFY_FAILED;
PIN_FLIST_FLD_SET(r_flistp, PIN_FLD_RESULT,
(void *)&fail, ebufp);
}
/****************************************************************
* The required fields.
****************************************************************/
/*
** PIN_FLD_FIELD_NUM.
*/
PIN_FLIST_FLD_SET(flistp, PIN_FLD_FIELD_NUM, (void *)&field, ebufp);
/*
** PIN_FLD_RESULT.
*/
PIN_FLIST_FLD_SET(flistp, PIN_FLD_RESULT, (void *)&result, ebufp);
/****************************************************************
* The optional fields.
****************************************************************/
/*
** PIN_FLD_ELEMENT_ID
*/
if (elemid != (u_int)NULL) {
PIN_FLIST_FLD_SET(flistp, PIN_FLD_ELEMENT_ID,
(void *)&elemid, ebufp);
}
/*
** PIN_FLD_DESCR.
*/
if (descr != (char *)NULL) {
PIN_FLIST_FLD_SET(flistp, PIN_FLD_DESCR, (void *)descr, ebufp);
}
/*
** The actual field value.
*/
type = PIN_FIELD_GET_TYPE(field);
switch (type) {
case PIN_FLDT_ARRAY:
case PIN_FLDT_SUBSTRUCT:
break;
default:
/* Val reqd on list - even if NULL */
PIN_FLIST_FLD_SET(flistp, field, (void *)val, ebufp);
}
/* Error? */
if (PIN_ERR_IS_ERR(ebufp)) {
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"error", ebufp);
}
return(flistp);
}
//****************************************************
// createRecourse
// Pre:
// Post:
//
void bs_CreateLECRecourse::createRecourse(
pin_Session * pinp,
const char * sRecordType,
const char * sBtn,
const char * sAuthDate,
const char * sReasonCode,
const char * sAmount,
const char * sVersion,
const char * file_name,
pin_flist_t **return_flistpp,
pin_errbuf_t *ebufp )
{
pin_flist_t * x_flistp = NULL;
pin_flist_t * c_flistp = NULL;
int lec_db = 5; //WIP: hard coded
int command = 9;
poid_t * pdp = NULL;
pin_decimal_t * amtp = NULL;
void * vp = NULL;
int impact_type = 0;
int version = 0;
PIN_ERR_CLEAR_ERR(ebufp);
//--enter function--------------
PIN_ERR_LOG_MSG(PIN_ERR_LEVEL_DEBUG, "bs_CreateLECRecourse::createRecourse: enter" );
/*--- Convert ---*/
if (sVersion && strlen(sVersion)> 0 )
version = atoi(sVersion);
amtp = pbo_decimal_from_str(sAmount,ebufp);
if(amtp && !PIN_ERR_IS_ERR(ebufp)
&& pbo_decimal_sign(amtp, ebufp) == -1 )
{
pbo_decimal_abs_assign(amtp, ebufp);
impact_type = 1;
}
/*--- Create set_status ---*/
x_flistp = PIN_FLIST_CREATE(ebufp);
pdp = pin_poid_create((int64)lec_db,"/_lec_db", (int64)1, ebufp);
PIN_FLIST_FLD_PUT(x_flistp, PIN_FLD_POID, pdp, ebufp);
PIN_FLIST_FLD_SET(x_flistp, PIN_FLD_COMMAND, (void*)&command, ebufp);
c_flistp = PIN_FLIST_ELEM_ADD( x_flistp, PIN_FLD_CHARGES, PIN_ELEMID_ASSIGN, ebufp );
PIN_FLIST_FLD_SET(c_flistp, PIN_FLD_PHONE, (void*)sBtn, ebufp);
PIN_FLIST_FLD_SET(c_flistp, PIN_FLD_AUTH_DATE, (void*)sAuthDate, ebufp);
PIN_FLIST_FLD_SET(c_flistp, PIN_FLD_RECORD_TYPE, (void*)sRecordType, ebufp);
PIN_FLIST_FLD_SET(c_flistp, PIN_FLD_REASON_CODE, (void*)sReasonCode, ebufp);
PIN_FLIST_FLD_SET(c_flistp, PIN_FLD_IMPACT_TYPE, (void*)&impact_type, ebufp);
PIN_FLIST_FLD_SET(c_flistp, PIN_FLD_VERSION_ID, (void*)&version, ebufp);
PIN_FLIST_FLD_PUT(c_flistp, PIN_FLD_AMOUNT_ADJUSTED, (void*)amtp, ebufp);
if (file_name != NULL ) {
c_flistp = PIN_FLIST_ELEM_ADD( x_flistp, PIN_FLD_BATCH_INFO, PIN_ELEMID_ASSIGN, ebufp );
PIN_FLIST_FLD_SET(c_flistp, PIN_FLD_FILENAME, (void*)file_name, ebufp);
}
/*----* Connect to the LEC DM *---*/
// pcm_context_t *my_ctxp = NULL;
// PCM_CONTEXT_OPEN(&my_ctxp, (pin_flist_t *)0, ebufp);
PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,"dm search input flist", x_flistp);
pinp->call_opcode(
PCM_OP_SEARCH, 0, x_flistp, return_flistpp, ebufp);
if (return_flistpp) PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG, "dm search output flist", *return_flistpp);
// if ( PIN_ERR_IS_ERR(ebufp) )
// {
// PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,"Failed connecting to DM_LEC...", ebufp );
// }
// PCM_CONTEXT_CLOSE(my_ctxp, 0, NULL);
PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,(char*)"leaving bs_CreateLECRecourse::createRecourse" , *return_flistpp );
PIN_FLIST_DESTROY_EX(&x_flistp,NULL);
return;
}
/*******************************************************************
* fm_pymt_pol_charge_set_reason_id()
* This function sets the PIN_FLD_REASON_ID
*******************************************************************/
static void
fm_pymt_pol_charge_set_reason_id(
pcm_context_t *ctxp,
pin_flist_t *i_flistp,
pin_errbuf_t *ebufp)
{
pin_flist_t *res_flistp = NULL;
pin_flist_t *reason_flistp = NULL;
pin_flist_t *p_flistp = NULL;
pin_flist_t *iinfo_flistp = NULL;
pin_cookie_t cookie = NULL;
int32 domain_id = PIN_PYMT_REASON_DOMAIN_ID;
int32 reason_id = 0;
int32 elem_id = 0;
void *vp = NULL;
if (PIN_ERR_IS_ERR(ebufp))
{
return ;
}
PIN_ERR_CLEAR_ERR(ebufp);
vp = (int32 *) PIN_FLIST_FLD_GET(i_flistp,
PIN_FLD_STR_VERSION, 1, ebufp);
if(vp){
domain_id = * (int32 *) vp;
}
while ((res_flistp = PIN_FLIST_ELEM_GET_NEXT(i_flistp, PIN_FLD_RESULTS,
&elem_id, 1, &cookie, ebufp)) != NULL) {
p_flistp = PIN_FLIST_SUBSTR_GET(res_flistp,
PIN_FLD_PAYMENT, 1, ebufp);
if(p_flistp)
{
iinfo_flistp = PIN_FLIST_SUBSTR_GET(p_flistp,
PIN_FLD_INHERITED_INFO, 1, ebufp);
if (iinfo_flistp) {
fm_pymt_pol_charge_process_result(ctxp,
iinfo_flistp,
&reason_id,
&domain_id,
ebufp);
reason_flistp = PIN_FLIST_ELEM_ADD(res_flistp,
PIN_FLD_PAYMENT_REASONS,
0, ebufp);
PIN_FLIST_FLD_SET(reason_flistp,
PIN_FLD_REASON_ID,
(void *) &reason_id, ebufp);
fm_pymt_pol_charge_set_domain_id(ctxp,
p_flistp,
reason_flistp,
&domain_id,
ebufp);
}
}
}
if (PIN_ERR_IS_ERR(ebufp)) {
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_DEBUG,
"fm_pymt_pol_charge_set_reason_id", ebufp);
}
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;
}
/*******************************************************************
* fm_cust_pol_get_plans_search():
*******************************************************************/
static void
fm_cust_pol_get_plans_search(
pcm_context_t *ctxp,
int64 database,
char *name,
char *type,
pin_flist_t **o_flistpp,
pin_errbuf_t *ebufp)
{
pin_cookie_t cookie = NULL;
pin_flist_t *s_flistp = NULL;
pin_flist_t *r_flistp = NULL;
pin_flist_t *flistp = NULL;
poid_t *pdp = NULL;
poid_t *brand_poidp = NULL;
int32 cred = 0;
int32 element_id;
u_int uint_val;
/*
* Safety check.
*/
if ((name == (char *)NULL) || (type == (char *)NULL)) {
return;
}
/*
* Create the search flist
*
* In a branding configuration, it is possible that the
* account A belonging to a brand B might reside in a non-primary
* database. This implies that DM does not have information about
* the brand B owner to do the appropriate scoping. Therefore, we
* should disable the scoping temporarily for this search.
*
* Since we disable scoping, we need explicitly filter out the
* plan lists that do not belong to this brand using the brand owner
* in the query.
*
*/
s_flistp = PIN_FLIST_CREATE(ebufp);
pdp = PIN_POID_CREATE(database, "/search", (int64)-1, ebufp);
PIN_FLIST_FLD_PUT(s_flistp, PIN_FLD_POID, (void *)pdp, ebufp);
uint_val = SRCH_DISTINCT;
PIN_FLIST_FLD_SET(s_flistp, PIN_FLD_FLAGS, (void *)&uint_val, ebufp);
PIN_FLIST_FLD_SET(s_flistp, PIN_FLD_TEMPLATE,
(void *) "select X from /group/$1 where "
"F1 = V1 and F2 = V2 and F3 = V3 and F4 = V4", ebufp);
PIN_FLIST_FLD_SET(s_flistp, PIN_FLD_PARAMETERS, (void *)"plan_list",
ebufp);
flistp = PIN_FLIST_ELEM_ADD(s_flistp, PIN_FLD_ARGS, 1, ebufp);
PIN_FLIST_FLD_SET(flistp, PIN_FLD_NAME, (void *)name, ebufp);
flistp = PIN_FLIST_ELEM_ADD(s_flistp, PIN_FLD_ARGS, 2, ebufp);
PIN_FLIST_FLD_SET(flistp, PIN_FLD_TYPE_STR, (void *)type, ebufp);
flistp = PIN_FLIST_ELEM_ADD(s_flistp, PIN_FLD_ARGS, 3, ebufp);
pdp = PIN_POID_CREATE(database, "/group/plan_list", (int64)-1, ebufp);
PIN_FLIST_FLD_PUT(flistp, PIN_FLD_POID, (void *)pdp, ebufp);
flistp = PIN_FLIST_ELEM_ADD(s_flistp, PIN_FLD_ARGS, 4, ebufp);
brand_poidp = cm_fm_perm_get_brand_account(ebufp);
if(PIN_POID_IS_NULL(brand_poidp)) {
brand_poidp = fm_utils_lineage_root_poid(database, ebufp);
} else {
if (PIN_POID_GET_ID(brand_poidp) == 1) {
brand_poidp = PIN_POID_CREATE(database,
PIN_POID_GET_TYPE(brand_poidp),
PIN_POID_GET_ID(brand_poidp), ebufp);
} else {
brand_poidp = PIN_POID_COPY(brand_poidp, ebufp);
}
}
PIN_FLIST_FLD_PUT(flistp, PIN_FLD_ACCOUNT_OBJ, (void *)brand_poidp,
ebufp);
flistp = PIN_FLIST_ELEM_ADD(s_flistp, PIN_FLD_RESULTS, 0, ebufp);
PIN_FLIST_FLD_SET(flistp, PIN_FLD_POID, (void *)NULL, ebufp);
PIN_FLIST_ELEM_SET(flistp, (pin_flist_t *)NULL, PIN_FLD_MEMBERS,
PIN_ELEMID_ANY, ebufp);
PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
"op_cust_pol_get_plans search flist", s_flistp);
/*
* Do the search
*/
cred = CM_FM_BEGIN_OVERRIDE_SCOPE(CM_CRED_SCOPE_OVERRIDE_ROOT);
PCM_OP(ctxp, PCM_OP_SEARCH, 0, s_flistp, &r_flistp, ebufp);
CM_FM_END_OVERRIDE_SCOPE(cred);
/*
* We want what is in the result element (assume only one)
*/
cookie = NULL;
*o_flistpp = PIN_FLIST_ELEM_TAKE_NEXT(r_flistp, PIN_FLD_RESULTS,
&element_id, 1, &cookie, ebufp);
/*
* Clean up.
*/
PIN_FLIST_DESTROY_EX(&s_flistp, NULL);
PIN_FLIST_DESTROY_EX(&r_flistp, NULL);
if (PIN_ERR_IS_ERR(ebufp)) {
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"fm_cust_pol_get_plans_search error", ebufp);
}
return;
}
/*******************************************************************
* 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;
}
/******************************************************
* Stuff a config parameter into outgoing flist,
* depending on string value
******************************************************/
static void
fm_cust_pol_get_config_stuff(
pin_flist_t *r_flistp,
char *key,
char *val,
pin_errbuf_t *ebufp)
{
pin_errbuf_t errbuf;
u_int type;
pin_flist_t *flistp = NULL;
u_int port = 0;
if(ebufp == NULL) ebufp = &errbuf;
PIN_ERR_CLEAR_ERR(ebufp);
if(key == NULL) {
return;
}
/*
* If DNS Address param, then create host array entry
*/
else if( strcmp( key, "dns_address_1")==0) {
flistp = PIN_FLIST_ELEM_ADD(r_flistp, PIN_FLD_HOST, 1, ebufp);
PIN_FLIST_FLD_SET(flistp, PIN_FLD_HOSTNAME, (void *)val, ebufp);
type = PIN_HOST_DNS;
PIN_FLIST_FLD_SET(flistp, PIN_FLD_TYPE, (void *)&type, ebufp);
}
else if (strcmp(key, "dns_address_2") == 0) {
flistp = PIN_FLIST_ELEM_ADD(r_flistp, PIN_FLD_HOST, 2, ebufp);
PIN_FLIST_FLD_SET(flistp, PIN_FLD_HOSTNAME, (void *)val, ebufp);
type = PIN_HOST_DNS;
PIN_FLIST_FLD_SET(flistp, PIN_FLD_TYPE, (void *)&type, ebufp);
}
/*
* If SMTP Hostname, then look to see if already a
* host array elem yet or not. We will count on it
* being in elemid 3, although this is not a hard
* and fast rule except for only within this policy
* call. It may have already been setup if the smtp_port
* parameter was previously found.
*/
else if (strcmp(key, "smtp_hostname") == 0) {
flistp = PIN_FLIST_ELEM_GET(r_flistp,
PIN_FLD_HOST, 3, 1, ebufp);
if (flistp == (pin_flist_t *)NULL) {
flistp = PIN_FLIST_ELEM_ADD( r_flistp,
PIN_FLD_HOST, 3, ebufp);
type = PIN_HOST_SMTP;
PIN_FLIST_FLD_SET(flistp, PIN_FLD_TYPE,
(void *)&type, ebufp);
}
PIN_FLIST_FLD_SET(flistp, PIN_FLD_HOSTNAME, (void *)val, ebufp);
}
/*
* If SMTP port, then look to see if already a
* host array elem yet or not. We will count on it
* being in elemid 3, although this is not a hard
* and fast rule except for only within this policy
* call. It may have already been setup if the smtp_host
* parameter was previously found.
*/
else if (strcmp(key, "smtp_port") == 0) {
flistp = PIN_FLIST_ELEM_GET(r_flistp,
PIN_FLD_HOST, 3, 1, ebufp);
if (flistp == (pin_flist_t *)NULL) {
flistp = PIN_FLIST_ELEM_ADD(r_flistp,
PIN_FLD_HOST, 3, ebufp);
type = PIN_HOST_SMTP;
PIN_FLIST_FLD_SET(flistp, PIN_FLD_TYPE,
(void *)&type, ebufp);
}
port = atoi(val);
PIN_FLIST_FLD_SET(flistp, PIN_FLD_PORT, (void *)&port, ebufp);
}
/*
* NNTP Hostname
*/
else if (strcmp(key, "nntp_hostname") == 0) {
flistp = PIN_FLIST_ELEM_ADD(r_flistp, PIN_FLD_HOST, 4, ebufp);
PIN_FLIST_FLD_SET(flistp, PIN_FLD_HOSTNAME, (void *)val, ebufp);
type = PIN_HOST_NNTP;
PIN_FLIST_FLD_SET(flistp, PIN_FLD_TYPE, (void *)&type, ebufp);
}
/*
* Pop Host
*/
else if (strcmp(key, "pop_hostname") == 0) {
flistp = PIN_FLIST_ELEM_ADD(r_flistp, PIN_FLD_HOST, 5, ebufp);
PIN_FLIST_FLD_SET(flistp, PIN_FLD_HOSTNAME, (void *)val, ebufp);
type = PIN_HOST_POP;
PIN_FLIST_FLD_SET(flistp, PIN_FLD_TYPE, (void *)&type, ebufp);
}
/*
* Http URL
*/
else if (strcmp(key, "http_url") == 0) {
PIN_FLIST_FLD_SET(r_flistp, PIN_FLD_HTTP_URL,
(void *)val, ebufp);
}
/*
* Support number
*/
else if (strcmp(key, "support_number") == 0) {
PIN_FLIST_FLD_SET(r_flistp, PIN_FLD_SUPPORT_PHONE,
(void *)val, ebufp);
}
return;
/*ErrOut:
return;*/
}
//****************************************************
// update_contactinfo
// Pre:
// Post:
//
bool bs_UpdateContactInfo::updateContactInfo(
pin_Session * pinp,
poid_t * account_pdp,
bs_SignupRec * bsrp,
string source,
pin_flist_t **return_flistpp,
pin_errbuf_t *ebufp )
{
pin_flist_t * c_outflistp = NULL;
pin_flist_t * c_flistp = NULL;
pin_flist_t * t1_flistp = NULL;
pin_flist_t * t2_flistp = NULL;
pin_flist_t * outflistp = NULL;
void * vp = NULL;
int32 flags = 0;
/* source name */
/* source / desc name */
const string this_program("bs_UpdateContactInfo::updateContactInfo");
if ( source.empty() )
{
source.assign(this_program);
}
PIN_ERR_LOG_MSG(PIN_ERR_LEVEL_DEBUG, (char*)this_program.c_str() );
//--- get appropriate fields ----------
char * firstname = bsrp->s_firstName;
char * lastname = bsrp->s_lastName;
char * address = bsrp->s_caddress;
char * city = bsrp->s_ccity;
char * state = bsrp->s_cstate;
char * zip = bsrp->s_czip;
char * email_addr = bsrp->s_cemail_addr;
int32 contact_type = PIN_NAMEINFO_BILLING;
const char * country = "USA";
const char * program_name = source.c_str();
PIN_ERR_CLEAR_ERR(ebufp);
/* create flist */
c_flistp = PIN_FLIST_CREATE( ebufp );
/* top level fields */
PIN_FLIST_FLD_SET(c_flistp, PIN_FLD_POID,(void *)account_pdp, ebufp);
PIN_FLIST_FLD_SET(c_flistp, PIN_FLD_PROGRAM_NAME,(void *)program_name, ebufp);
/* nameinfo */
t1_flistp = PIN_FLIST_ELEM_ADD(c_flistp, PIN_FLD_NAMEINFO, contact_type, ebufp);
PIN_FLIST_FLD_SET(t1_flistp, PIN_FLD_FIRST_NAME,(void *)firstname, ebufp);
PIN_FLIST_FLD_SET(t1_flistp, PIN_FLD_LAST_NAME,(void *)lastname, ebufp);
PIN_FLIST_FLD_SET(t1_flistp, PIN_FLD_ADDRESS,(void *)address, ebufp);
PIN_FLIST_FLD_SET(t1_flistp, PIN_FLD_CITY,(void *)city, ebufp);
PIN_FLIST_FLD_SET(t1_flistp, PIN_FLD_STATE,(void *)state, ebufp);
PIN_FLIST_FLD_SET(t1_flistp, PIN_FLD_ZIP,(void *)zip, ebufp);
PIN_FLIST_FLD_SET(t1_flistp, PIN_FLD_COUNTRY,(void *)country, ebufp);
PIN_FLIST_FLD_SET(t1_flistp, PIN_FLD_EMAIL_ADDR,(void *)email_addr, ebufp);
PIN_ERR_CLEAR_ERR(ebufp);
bool rc = pinp->call_opcode(
PCM_OP_CUST_POL_UOL_SET_NAMEINFO, flags, c_flistp, &c_outflistp, ebufp);
if (c_flistp) PIN_FLIST_DESTROY(c_flistp,ebufp);
if (c_outflistp) PIN_FLIST_DESTROY_EX(&c_outflistp,ebufp);
return rc;
}
void
fm_cust_pol_valid_login_check_uniquiness_service(
pcm_context_t *ctxp,
int64 db_no,
int msexchange_service_type,
pin_flist_t *i_flistp,
pin_flist_t *r_flistp,
pin_errbuf_t *ebufp)
{
pin_flist_t *a_flistp = NULL;
pin_flist_t *l_flistp = NULL;
pin_flist_t *n_flistp = NULL;
pin_flist_t *s1_flistp = NULL;
pin_flist_t *s2_flistp = NULL;
pin_flist_t *flistp = NULL;
poid_t *objp = NULL;
poid_t *s_pdp = NULL;
void *vp = NULL;
const char *subtype = NULL;
char *login = NULL;
int32 result = PIN_CUST_VERIFY_PASSED;
int32 elemid = 0;
int32 count1 = 0;
int32 count2 = 0;
int32 search_flag = SRCH_DISTINCT;
pin_cookie_t cookie = NULL;
pin_cookie_t cookie2 = NULL;
int count = 0;
int32 cred = 0;
/***********************************************************
* Return immediately if there's an error in ebufp.
***********************************************************/
if (PIN_ERR_IS_ERR(ebufp))
return;
PIN_ERR_CLEAR_ERR(ebufp);
s_pdp = (poid_t *)PIN_FLIST_FLD_GET(i_flistp, PIN_FLD_POID, 0, ebufp);
/*********************************************************
* Create the search flist
********************************************************/
s1_flistp = PIN_FLIST_CREATE(ebufp);
s2_flistp = PIN_FLIST_CREATE(ebufp);
objp = PIN_POID_CREATE(db_no, "/search", -1, ebufp);
PIN_FLIST_FLD_SET(s1_flistp, PIN_FLD_POID, (void *)objp, ebufp);
PIN_FLIST_FLD_PUT(s2_flistp, PIN_FLD_POID, (void *)objp, ebufp);
/******************************************************************
* Set the search template.
******************************************************************/
/**********************************************************************
* If Service type is /service/msexchange/user or
* /service/msexchange/user/firstadmin
* search login name in both /service/msexchange/user and
* /service/msexchange/user/firstadmin objects
**********************************************************************/
if( msexchange_service_type != PIN_MSEXCHANGE_SERVICE_NONE ){
vp = (void*)"select X from /service where "
"F1 = V1 AND ( F2 = V2 OR F3 = V3 ) ";
}
else {
vp = (void*)"select X from /service where "
" F1 = V1 AND F2 = V2 ";
}
PIN_FLIST_FLD_SET(s1_flistp, PIN_FLD_TEMPLATE, vp, ebufp);
PIN_FLIST_FLD_SET(s2_flistp, PIN_FLD_TEMPLATE, vp, ebufp);
PIN_FLIST_FLD_SET(s1_flistp, PIN_FLD_FLAGS, &search_flag, ebufp);
PIN_FLIST_FLD_SET(s2_flistp, PIN_FLD_FLAGS, &search_flag, ebufp);
/* Add the search criteria. */
login = PIN_FLIST_FLD_GET( i_flistp, PIN_FLD_LOGIN, 1, ebufp );
/* Look for PIN_FLD_LOG = login */
l_flistp = PIN_FLIST_ELEM_ADD(s1_flistp, PIN_FLD_ARGS, 1, ebufp);
PIN_FLIST_FLD_SET(l_flistp, PIN_FLD_LOGIN, (void *)login, ebufp);
/* Look for PIN_FLD_ALIAS_LIST - PIN_FLD_NAME = login */
n_flistp = PIN_FLIST_ELEM_ADD(s2_flistp, PIN_FLD_ARGS, 1, ebufp);
n_flistp = PIN_FLIST_ELEM_ADD(n_flistp, PIN_FLD_ALIAS_LIST,
PIN_ELEMID_ANY, ebufp);
PIN_FLIST_FLD_SET(n_flistp, PIN_FLD_NAME, (void *)login, ebufp);
/**********************************************************************
* If service is /service/msexchange/user type, search login name also
* in /service/msexchange/user/firstadmin for unique login name and
* vice versa.
* Add F3 and V3 Parameters in search template with service type
**********************************************************************/
if( msexchange_service_type == PIN_MSEXCHANGE_SERVICE_USER ||
msexchange_service_type == PIN_MSEXCHANGE_SERVICE_FIRSTADMIN ){
a_flistp = PIN_FLIST_ELEM_ADD(s1_flistp, PIN_FLD_ARGS,2, ebufp);
objp = PIN_POID_CREATE(db_no,
PIN_MSEXCHANGE_SERVICE_TYPE_FIRSTADMIN,
(int64)-1, ebufp);
PIN_FLIST_FLD_PUT(a_flistp, PIN_FLD_POID, (void *)objp, ebufp);
PIN_FLIST_ELEM_SET(s2_flistp, a_flistp, PIN_FLD_ARGS, 2, ebufp);
a_flistp = PIN_FLIST_ELEM_ADD(s1_flistp, PIN_FLD_ARGS,3, ebufp);
objp = PIN_POID_CREATE(db_no, PIN_MSEXCHANGE_SERVICE_TYPE_USER,
(int64)-1, ebufp);
PIN_FLIST_FLD_PUT(a_flistp, PIN_FLD_POID, (void *)objp, ebufp);
PIN_FLIST_ELEM_SET(s2_flistp, a_flistp, PIN_FLD_ARGS, 3, ebufp);
} else {
subtype = PIN_POID_GET_TYPE( s_pdp );
a_flistp = PIN_FLIST_ELEM_ADD(s1_flistp, PIN_FLD_ARGS,2, ebufp);
objp = PIN_POID_CREATE(db_no, subtype, (int64)-1, ebufp);
PIN_FLIST_FLD_PUT(a_flistp, PIN_FLD_POID, (void *)objp, ebufp);
PIN_FLIST_ELEM_SET(s2_flistp, a_flistp, PIN_FLD_ARGS, 2, ebufp);
}
PIN_FLIST_ELEM_PUT(s1_flistp, NULL, PIN_FLD_RESULTS, 0, ebufp);
PIN_FLIST_ELEM_PUT(s2_flistp, NULL, PIN_FLD_RESULTS, 0, ebufp);
/************************************************************
* we only search if there was a login
* otherwise this was all setup for the alias list searches.
************************************************************/
if( login ) {
cred = CM_FM_BEGIN_OVERRIDE_SCOPE(CM_CRED_SCOPE_OVERRIDE_ROOT);
PCM_OP(ctxp, PCM_OP_SEARCH, PCM_OPFLG_COUNT_ONLY,
s1_flistp, &a_flistp, ebufp);
cookie = NULL;
(void) PIN_FLIST_ELEM_GET_NEXT(a_flistp, PIN_FLD_RESULTS,
&count1, 0, &cookie, ebufp);
PIN_FLIST_DESTROY_EX( &a_flistp, NULL );
PCM_OP(ctxp, PCM_OP_SEARCH, PCM_OPFLG_COUNT_ONLY,
s2_flistp, &a_flistp, ebufp);
CM_FM_END_OVERRIDE_SCOPE(cred);
cookie = NULL;
(void) PIN_FLIST_ELEM_GET_NEXT(a_flistp, PIN_FLD_RESULTS,
&count2, 0, &cookie, ebufp);
PIN_FLIST_DESTROY_EX( &a_flistp, NULL );
if (count1 > 0 || count2 > 0 ) {
(void)fm_cust_pol_valid_add_fail(r_flistp,
PIN_FLD_LOGIN, (u_int)NULL,
PIN_CUST_VAL_ERR_DUPE,
PIN_CUST_DUPE_VALUE_ERR_MSG,
(void *)login, ebufp);
result = PIN_CUST_VERIFY_FAILED;
}
}
/***********************************************************
* Try to validate all of the alias list
***********************************************************/
cookie = NULL;
for (
flistp = PIN_FLIST_ELEM_GET_NEXT( i_flistp, PIN_FLD_ALIAS_LIST,
&elemid, 0, &cookie, ebufp );
ebufp->pin_err == PIN_ERR_NONE;
flistp = PIN_FLIST_ELEM_GET_NEXT( i_flistp, PIN_FLD_ALIAS_LIST,
&elemid, 0, &cookie, ebufp )
) {
if ( !flistp ) continue;
login = PIN_FLIST_FLD_GET( flistp, PIN_FLD_NAME, 0, ebufp );
/**************************************************************
* the search flist is still set up we just need to replace
* the login value with an alias value.
**************************************************************/
PIN_FLIST_FLD_SET(l_flistp, PIN_FLD_LOGIN, (void *)login, ebufp);
PIN_FLIST_FLD_SET(n_flistp, PIN_FLD_NAME, (void *)login, ebufp);
cred = CM_FM_BEGIN_OVERRIDE_SCOPE(CM_CRED_SCOPE_OVERRIDE_ROOT);
PCM_OP(ctxp, PCM_OP_SEARCH, PCM_OPFLG_COUNT_ONLY,
s1_flistp, &a_flistp, ebufp);
cookie2 = NULL;
(void) PIN_FLIST_ELEM_GET_NEXT(a_flistp, PIN_FLD_RESULTS,
&count1, 0, &cookie2, ebufp);
PIN_FLIST_DESTROY_EX( &a_flistp, NULL );
PCM_OP(ctxp, PCM_OP_SEARCH, PCM_OPFLG_COUNT_ONLY,
s2_flistp, &a_flistp, ebufp);
CM_FM_END_OVERRIDE_SCOPE(cred);
cookie2 = NULL;
(void) PIN_FLIST_ELEM_GET_NEXT(a_flistp, PIN_FLD_RESULTS,
&count2, 0, &cookie2, ebufp);
PIN_FLIST_DESTROY_EX( &a_flistp, NULL );
if (count1 > 0 || count2 > 0) {
pin_fld_num_t field = PIN_FLD_ALIAS_LIST;
/***************************************************
* There is a validation error so normalize it to
* the input flist
***************************************************/
result = PIN_CUST_VERIFY_FAILED;
count = PIN_FLIST_ELEM_COUNT(r_flistp, PIN_FLD_FIELD,
ebufp);
a_flistp = PIN_FLIST_ELEM_ADD(r_flistp, PIN_FLD_FIELD,
count, ebufp);
PIN_FLIST_FLD_SET(a_flistp, PIN_FLD_FIELD_NUM,
(void *)&field, ebufp);
PIN_FLIST_FLD_SET(a_flistp, PIN_FLD_ELEMENT_ID,
(void *)&elemid, ebufp);
PIN_FLIST_FLD_SET(a_flistp, PIN_FLD_RESULT,
(void *)&result, ebufp);
(void)fm_cust_pol_valid_add_fail(a_flistp,
PIN_FLD_NAME, (u_int)NULL,
PIN_CUST_VAL_ERR_DUPE,
PIN_CUST_DUPE_VALUE_ERR_MSG,
(void *)login, ebufp);
a_flistp = NULL;
}
}
if ( ebufp->pin_err == PIN_ERR_NOT_FOUND ) {
PIN_ERR_CLEAR_ERR( ebufp );
}
if ( result == PIN_CUST_VERIFY_FAILED ) {
PIN_FLIST_FLD_SET(r_flistp, PIN_FLD_RESULT,
(void *)&result, ebufp);
}
PIN_FLIST_DESTROY_EX( &s1_flistp, NULL );
PIN_FLIST_DESTROY_EX( &s2_flistp, NULL );
}
/*******************************************************************
* Main routine for the PCM_OP_PYMT_POL_PRE_COLLECT command
*******************************************************************/
void
op_pymt_pol_pre_collect(
cm_nap_connection_t *connp,
int opcode,
int flags,
pin_flist_t *in_flistp,
pin_flist_t **ret_flistpp,
pin_errbuf_t *ebufp)
{
pcm_context_t *ctxp = connp->dm_ctx;
pin_cookie_t cookie = NULL;
pin_flist_t *flistp = NULL;
pin_flist_t *c_flistp = NULL;
pin_flist_t *chkpt_flistp = NULL;
pin_flist_t *rc_flistp = NULL;
pin_charge_cmd_t *cmdp = NULL;
pin_decimal_t *amtp = NULL;
poid_t *a_pdp = NULL;
double *d_ptr = NULL;
char *descr = NULL;
int32 *selectp = NULL;
int32 elemid = 0;
int32 result = 0;
int32 err = 0;
int32 flag = 0;
int32 sflag = 0;
int32 rec_id = 0;
pin_decimal_t *minimum_pay = NULL;
pin_decimal_t *minimum_ref = NULL;
pin_flist_t *s_flistp = NULL;
pin_flist_t *a_flistp = NULL;
pin_flist_t *b_flistp = NULL;
pin_flist_t *r_flistp = NULL;
poid_t *s_pdp = NULL;
int32 *mandate_status = 0;
pin_pymt_result_t *statusp = NULL;
int32 *resultp = NULL;
char vendor_name[256] = {" "};
void *vp = NULL;
char *dd_vendorp = NULL;
if (PIN_ERR_IS_ERR(ebufp))
return;
PIN_ERR_CLEAR_ERR(ebufp);
/***********************************************************
* Null out results until we have some.
***********************************************************/
*ret_flistpp = (pin_flist_t *)NULL;
/***********************************************************
* Insanity check.
***********************************************************/
if (opcode != PCM_OP_PYMT_POL_PRE_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,
"bad opcode in op_pymt_pol_pre_collect", ebufp);
return;
}
/***********************************************************
* Debug: What did we get?
***********************************************************/
PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
"op_pymt_pol_pre_collect input flist", in_flistp);
/***********************************************************
* Get command from very first element of array
* note: we cannot rely that it has index [0] or [1] or ...
***********************************************************/
flistp = PIN_FLIST_ELEM_GET_NEXT(in_flistp, PIN_FLD_CHARGES,
&elemid, 0, &cookie, ebufp);
cmdp = (pin_charge_cmd_t *)PIN_FLIST_FLD_GET(flistp,
PIN_FLD_COMMAND, 0, ebufp);
/***********************************************************
* Select the list of outstanding checkpoint events.
* Checkpoints' existance has sense for following commands only:
* authorization, deposit, conditional deposit and refund
***********************************************************/
if (cmdp &&
((*cmdp == PIN_CHARGE_CMD_CONDITION) ||
(*cmdp == PIN_CHARGE_CMD_REFUND) ||
(*cmdp == PIN_CHARGE_CMD_AUTH_ONLY) ||
(*cmdp == PIN_CHARGE_CMD_DEPOSIT))) {
/***********************************************************
* New algorithm is to search for checkpoint upfront and
* pass a flag that indicates that search is done
***********************************************************/
pin_flist_t *b_flistp = NULL;
int32 *b_flags = 0;
/***********************************************************
* Get checkpoints' flag from very first element of array
* note: we cannot rely that it has index [0] or [1] or ...
***********************************************************/
elemid = 0;
cookie = NULL;
b_flistp = PIN_FLIST_ELEM_GET_NEXT(in_flistp,PIN_FLD_BATCH_INFO,
&elemid, 1, &cookie, ebufp);
if (b_flistp != 0) {
b_flags = (int32*)PIN_FLIST_FLD_GET(b_flistp,
PIN_FLD_STATUS_FLAGS, 1, ebufp);
}
/***********************************************************
* 1. If no flags do checkpoints selection
* 2. If flag is not set do checkpoint selection
* 3. If flag is set don't perform checkpoint selection
***********************************************************/
if(!((b_flags != 0)&&(*b_flags & PIN_PAYMENT_BATCH_CHKPTS))){
fm_pymt_pol_find_outstanding_chkpts(ctxp, in_flistp,
&chkpt_flistp, ebufp);
}
}
/***********************************************************
* Get the minimum charge amount from the pin.conf. If the
* entry is missing from the pin.conf assume the default
* minimum value of 2.00
***********************************************************/
pin_conf("fm_pymt_pol", "minimum_payment", PIN_FLDT_NUM,
(caddr_t *)&d_ptr, &err);
if (d_ptr) {
minimum_pay = pbo_decimal_from_double(*d_ptr, ebufp);
free(d_ptr);
} else {
minimum_pay = pbo_decimal_from_str("2.00", ebufp);
}
/***********************************************************
* Get the minimum refund amount from the pin.conf. If the
* entry is missing from the pin.conf assume the default
* minimum value of -2.00
***********************************************************/
pin_conf("fm_pymt_pol", "minimum_refund", PIN_FLDT_NUM,
(caddr_t *)&d_ptr, &err);
if (d_ptr) {
minimum_ref = pbo_decimal_from_double(*d_ptr, ebufp);
free(d_ptr);
} else {
minimum_ref = pbo_decimal_from_str("2.00", ebufp);
}
/***********************************************************
* Get the dd_vendor value from the pin.conf.
***********************************************************/
pin_conf("cm", "dd_vendor", PIN_FLDT_STR,
(caddr_t *)&dd_vendorp, &err);
c_flistp = PIN_FLIST_COPY(in_flistp, ebufp);
/***********************************************************
* Walk the charges array and check each element.
***********************************************************/
elemid = 0;
cookie = NULL;
while ((flistp = PIN_FLIST_ELEM_GET_NEXT(c_flistp, PIN_FLD_CHARGES,
&elemid, 1, &cookie, ebufp)) != (pin_flist_t *)NULL) {
statusp = (pin_pymt_result_t *) PIN_FLIST_FLD_GET(flistp,
PIN_FLD_STATUS, 1, ebufp);
resultp = (int32 *) PIN_FLIST_FLD_GET(flistp,PIN_FLD_RESULT, 1, ebufp);
if((statusp && *statusp >= PIN_PYMT_SUSPENSE
&& *statusp < PIN_PYMT_FAILED)
|| (resultp && *resultp == PIN_PAYMENT_RES_FAIL)){
/*******************************************
* Do nothing if a payment in suspense
*******************************************/
continue;
}
amtp = (pin_decimal_t *)PIN_FLIST_FLD_GET(flistp,
PIN_FLD_AMOUNT, 1, ebufp);
cmdp = (pin_charge_cmd_t *)PIN_FLIST_FLD_GET(flistp,
PIN_FLD_COMMAND, 0, ebufp);
a_pdp = (poid_t *)PIN_FLIST_FLD_GET(flistp,
PIN_FLD_ACCOUNT_OBJ,0,ebufp);
selectp = (int *)PIN_FLIST_FLD_GET(flistp,
PIN_FLD_SELECT_RESULT, 1, ebufp);
/***************************************************
* Did PCM_OP_PYMT_SELECT_ITEMS retured OK?
***************************************************/
if (selectp && (*selectp != PIN_SELECT_RESULT_PASS)){
result = PIN_CHARGE_RES_FAIL_SELECT_ITEMS;
PIN_FLIST_FLD_SET(flistp, PIN_FLD_RESULT,
(void *)&result, ebufp);
descr = "Select Items Failed";
PIN_FLIST_FLD_SET(flistp, PIN_FLD_DESCR,
(void *)descr, ebufp);
continue;
}
/***************************************************
* Get the amount for this charge. If the amount to
* be charged is 0.0, then don't even bother dealing
* with this element.
***************************************************/
if ((amtp &&
pbo_decimal_compare(amtp, minimum_pay, ebufp) < 0) &&
(cmdp && ((*cmdp == PIN_CHARGE_CMD_CONDITION) ||
(*cmdp == PIN_CHARGE_CMD_AUTH_ONLY) ||
(*cmdp == PIN_CHARGE_CMD_DEPOSIT)))) {
result = PIN_CHARGE_RES_FAIL_NO_MIN;
PIN_FLIST_FLD_SET(flistp, PIN_FLD_RESULT,
(void *)&result, ebufp);
descr = "Below Minimum";
PIN_FLIST_FLD_SET(flistp, PIN_FLD_DESCR,
(void *)descr, ebufp);
continue;
}
/***************************************************
* Set the minimum refund to compare.
***************************************************/
if (cmdp && ((*cmdp == PIN_CHARGE_CMD_NONE) &&
(pbo_decimal_sign(amtp, ebufp) < 0))) {
pbo_decimal_negate_assign(minimum_ref, ebufp);
}
/***************************************************
* If command and amount are not NULL and if the
* command is refund or if the commnd is none, but
* has a negative amount, check the amount with
* the minimum refund.
***************************************************/
if (cmdp && amtp && (((*cmdp == PIN_CHARGE_CMD_REFUND) &&
(pbo_decimal_compare(amtp, minimum_ref, ebufp) < 0)) ||
((*cmdp == PIN_CHARGE_CMD_NONE) &&
(pbo_decimal_sign(amtp, ebufp) < 0) &&
(pbo_decimal_compare(amtp, minimum_ref, ebufp) > 0)))) {
result = PIN_CHARGE_RES_FAIL_NO_MIN;
PIN_FLIST_FLD_SET(flistp, PIN_FLD_RESULT,
(void *)&result, ebufp);
descr = "Below Minimum";
PIN_FLIST_FLD_SET(flistp, PIN_FLD_DESCR,
(void *)descr, ebufp);
continue;
}
/***************************************************
* If command and amount are not NULL and if the
* command is REFUND or if the command is NONE and
* its a negative amount, make sure that the account
* has sufficient credit balance. If not, set the
* RESULT code to be NO_CREDIT_BALANCE.
***************************************************/
if (cmdp && amtp && ((*cmdp == PIN_CHARGE_CMD_REFUND) ||
((*cmdp == PIN_CHARGE_CMD_NONE) &&
(pbo_decimal_sign(amtp, ebufp) < 0)))) {
flag = fm_pymt_pol_pre_collect_validate_refund(ctxp,
amtp, flistp, ebufp);
if (flag == PIN_BOOLEAN_FALSE) {
result = PIN_CHARGE_RES_NO_CREDIT_BALANCE;
PIN_FLIST_FLD_SET(flistp, PIN_FLD_RESULT,
(void *)&result, ebufp);
descr = "No credit available";
PIN_FLIST_FLD_SET(flistp, PIN_FLD_DESCR,
(void *)descr, ebufp);
}
}
/***************************************************
* Is there a outstanding checkpoint for this acct?
***************************************************/
if ((chkpt_flistp != (pin_flist_t *)NULL) && cmdp &&
((*cmdp == PIN_CHARGE_CMD_CONDITION) ||
(*cmdp == PIN_CHARGE_CMD_REFUND) ||
(*cmdp == PIN_CHARGE_CMD_AUTH_ONLY) ||
(*cmdp == PIN_CHARGE_CMD_DEPOSIT))) {
if (fm_pymt_pol_is_chkpt_outstanding(a_pdp,
chkpt_flistp, ebufp)) {
result = PIN_CHARGE_RES_CHECKPOINT;
PIN_FLIST_FLD_SET(flistp, PIN_FLD_RESULT,
(void *)&result, ebufp);
descr = "Checkpoint Outstanding";
PIN_FLIST_FLD_SET(flistp, PIN_FLD_DESCR,
(void *)descr, ebufp);
continue;
}
}
s_flistp = PIN_FLIST_CREATE(ebufp);
vp = PIN_FLIST_FLD_GET(flistp, PIN_FLD_ACH, 1, ebufp);
if (vp) {
vp = PIN_FLIST_FLD_GET(in_flistp, PIN_FLD_POID, 0,
ebufp);
PIN_FLIST_FLD_SET(s_flistp, PIN_FLD_POID,
vp, ebufp);
vp = PIN_FLIST_FLD_GET(flistp, PIN_FLD_ACH, 0,
ebufp);
if (vp) {
rec_id = *(int32 *)vp;
}
PIN_FLIST_FLD_SET(s_flistp, PIN_FLD_ACH,
&rec_id, ebufp);
PCM_OP(ctxp, PCM_OP_PYMT_GET_ACH_INFO, sflag,
s_flistp, &r_flistp, ebufp);
rc_flistp = PIN_FLIST_ELEM_GET(r_flistp, PIN_FLD_RESULTS,
0, 0, ebufp);
vp = PIN_FLIST_FLD_GET(rc_flistp,
PIN_FLD_NAME, 0, ebufp);
memset(vendor_name, 0, sizeof(vendor_name));
if ((vp != (void *)NULL) && strlen(vp)) {
strcpy(vendor_name, (char *)vp);
}
}
PIN_FLIST_DESTROY_EX(&s_flistp, NULL);
PIN_FLIST_DESTROY_EX(&r_flistp, NULL);
/*************************************************************
* If Bertelsmann then check the mandate status.
*************************************************************/
if (dd_vendorp && !strcasecmp(dd_vendorp,
"Bertelsmann") && cmdp && *cmdp != PIN_CHARGE_CMD_RFR
&& vendor_name && !strcasecmp(vendor_name,
"bertelsmann")) {
s_flistp = PIN_FLIST_CREATE(ebufp);
s_pdp = PIN_POID_CREATE(PIN_POID_GET_DB(a_pdp),
"/search/pin", 0, ebufp);
PIN_FLIST_FLD_PUT(s_flistp, PIN_FLD_POID,
(void *)s_pdp, ebufp);
PIN_FLIST_FLD_SET(s_flistp, PIN_FLD_FLAGS,
(void *)&sflag, ebufp);
PIN_FLIST_FLD_SET(s_flistp, PIN_FLD_TEMPLATE,
"select X from /payinfo where F1 = V1 ", ebufp);
a_flistp = PIN_FLIST_ELEM_ADD(s_flistp, PIN_FLD_ARGS,
1, ebufp);
PIN_FLIST_FLD_SET(a_flistp, PIN_FLD_ACCOUNT_OBJ,
a_pdp, ebufp);
a_flistp = PIN_FLIST_ELEM_ADD(s_flistp,
PIN_FLD_RESULTS, 0, ebufp);
b_flistp = PIN_FLIST_ELEM_ADD(a_flistp,
PIN_FLD_DD_INFO, 0, ebufp);
PIN_FLIST_FLD_SET(b_flistp, PIN_FLD_MANDATE_STATUS,
(void *)0, ebufp);
PCM_OP(ctxp, PCM_OP_SEARCH, 0, s_flistp, &r_flistp,
ebufp);
if (r_flistp != (pin_flist_t *)NULL) {
a_flistp = PIN_FLIST_ELEM_GET(r_flistp,
PIN_FLD_RESULTS, 0, 1, ebufp);
b_flistp = PIN_FLIST_ELEM_GET(a_flistp,
PIN_FLD_DD_INFO, 0, 1, ebufp);
/***********************************************
* Do not allow accounts with the following
* mandate_statuses to go to collection.
***********************************************/
mandate_status = PIN_FLIST_FLD_GET(b_flistp,
PIN_FLD_MANDATE_STATUS, 1, ebufp);
if (!mandate_status ||
((*mandate_status != PIN_MANDATE_RECEIVED) &&
(*mandate_status != PIN_MANDATE_NOT_REQUIRED)))
{
result = PIN_CHARGE_RES_FAIL_SELECT_ITEMS;
PIN_FLIST_FLD_SET(flistp, PIN_FLD_RESULT,
(void *)&result, ebufp);
descr = "Mandate Outstanding";
PIN_FLIST_FLD_SET(flistp, PIN_FLD_DESCR,
(void *)descr, ebufp);
}
}
/***********************************************
* Clean up.
***********************************************/
PIN_FLIST_DESTROY_EX(&s_flistp, NULL);
PIN_FLIST_DESTROY_EX(&r_flistp, NULL);
}
/***************************************************
* Check the command for this element.
***************************************************/
if (cmdp == NULL) {
pin_set_err(ebufp, PIN_ERRLOC_FM,
PIN_ERRCLASS_APPLICATION,
PIN_ERR_MISSING_ARG,
PIN_FLD_COMMAND, elemid, 0);
continue;
}
/***************************************************
* Is it ok?
***************************************************/
switch (*cmdp) {
case PIN_CHARGE_CMD_NONE:
case PIN_CHARGE_CMD_AUTH_ONLY:
case PIN_CHARGE_CMD_CONDITION:
case PIN_CHARGE_CMD_DEPOSIT:
case PIN_CHARGE_CMD_REFUND:
case PIN_CHARGE_CMD_RFR:
case PIN_CHARGE_CMD_RESUBMIT:
break;
default:
result = PIN_CHARGE_RES_INVALID_CMD;
PIN_FLIST_FLD_SET(flistp, PIN_FLD_RESULT,
(void *)&result, ebufp);
descr = "Invalid Command";
PIN_FLIST_FLD_SET(flistp, PIN_FLD_DESCR,
(void *)descr, ebufp);
}
}
/***********************************************************
* Clean up.
***********************************************************/
PIN_FLIST_DESTROY_EX(&chkpt_flistp, NULL);
pbo_decimal_destroy(&minimum_pay);
pbo_decimal_destroy(&minimum_ref);
if (dd_vendorp != (char *)NULL) {
free(dd_vendorp);
dd_vendorp = NULL;
}
/***********************************************************
* Results.
***********************************************************/
if (PIN_ERR_IS_ERR(ebufp)) {
PIN_FLIST_DESTROY_EX(&c_flistp, NULL);
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"op_pymt_pol_pre_collect error", ebufp);
} else {
*ret_flistpp = c_flistp;
PIN_ERR_CLEAR_ERR(ebufp);
PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
"op_pymt_pol_pre_collect return flist",
*ret_flistpp);
}
return;
}
/*******************************************************************
* This function gets pending items to be included in the Bill.
*******************************************************************/
static void
fm_bill_pol_get_pending_items(
pcm_context_t *ctxp,
pin_flist_t *i_flistp,
pin_flist_t **r_flistpp,
pin_errbuf_t *ebufp)
{
pin_flist_t *s_flistp = NULL;
pin_flist_t *temp_flistp = NULL;
pin_flist_t *o_flistp = NULL;
pin_cookie_t cookie = NULL;
poid_t *s_pdp = NULL;
poid_t *bi_pdp = NULL;
poid_t *acc_pdp = NULL;
poid_t *srv_pdp = NULL;
poid_t *srv_pdp1 = NULL;
int32 rec_id = 0;
int32 s_flags = 0;
void *vp = NULL;
int64 database = 0;
int32 status = 0;
int srv_cnt = 0;
int first_srv_flag = 0;
char s_template[BUFSIZ] = {0};
char tmp_s_template[BUFSIZ] = {0};
if (PIN_ERR_IS_ERR(ebufp))
return;
PIN_ERR_CLEAR_ERR(ebufp);
/**************************************************************
* Check whether the input flist contains the list of pendning
* items. If so, prepare output flist for the policy, and return
**************************************************************/
if (PIN_FLIST_ELEM_GET_NEXT(i_flistp, PIN_FLD_ITEMS,
&rec_id, 1, &cookie, ebufp)) {
fm_bill_pol_prepare_pending_items(ctxp, i_flistp, r_flistpp,
ebufp);
return;
}
/*********************************************************
* Get billinfo poid
*********************************************************/
bi_pdp = (poid_t *)PIN_FLIST_FLD_GET(i_flistp, PIN_FLD_BILLINFO_OBJ, 0,
ebufp);
/*********************************************************
* Get account poid
*********************************************************/
acc_pdp = (poid_t *)PIN_FLIST_FLD_GET(i_flistp, PIN_FLD_POID, 0,
ebufp);
/*********************************************************
* Create the search flist to search for the item objects
*********************************************************/
s_flistp = PIN_FLIST_CREATE(ebufp);
database = pin_poid_get_db(bi_pdp);
s_pdp = (poid_t *)PIN_POID_CREATE(database, "/search", -1, ebufp);
PIN_FLIST_FLD_PUT(s_flistp, PIN_FLD_POID, (void *)s_pdp, ebufp);
PIN_FLIST_FLD_SET(s_flistp, PIN_FLD_FLAGS, (void *)&s_flags, ebufp);
/***********************************************************
* Start with the base search template. Add the search for list of
* services if they are presented in the input flist.
***********************************************************/
strcpy(s_template, "select X from /item where F1 = V1 and F2 = V2 ");
srv_pdp = (poid_t *)PIN_FLIST_FLD_GET(i_flistp,
PIN_FLD_SERVICE_OBJ, 1, ebufp);
if (srv_pdp) {
/***********************************************
* Get all services from the service group
***********************************************/
fm_utils_bill_get_service_group(ctxp, srv_pdp,acc_pdp,&o_flistp,
ebufp);
/***********************************************************
* Different 'where' clauses will be used depending on
* whether the services array contains a single service or
* multiple ones.
***********************************************************/
srv_cnt = PIN_FLIST_ELEM_COUNT(o_flistp, PIN_FLD_SERVICES,
ebufp);
if (1 == srv_cnt) {
strncpy(tmp_s_template, s_template,
sizeof(tmp_s_template)-1);
pin_snprintf(s_template, sizeof(s_template), "%s %s",
tmp_s_template, "and F3 = V3");
cookie = NULL;
temp_flistp = PIN_FLIST_ELEM_GET_NEXT(o_flistp,
PIN_FLD_SERVICES, &rec_id, 0,
&cookie, ebufp);
srv_pdp1 = (poid_t *)PIN_FLIST_FLD_GET(temp_flistp,
PIN_FLD_SERVICE_OBJ, 0, ebufp);
/* Add ARG 3 - SERVICE_OBJ */
temp_flistp = PIN_FLIST_ELEM_ADD(s_flistp,PIN_FLD_ARGS,
3, ebufp);
PIN_FLIST_FLD_SET(temp_flistp,
PIN_FLD_SERVICE_OBJ, (void *)srv_pdp1, ebufp);
} else { /* Multiple services */
/******************************************************
* SEARCH CONDITION: service_obj_id0 in
* (poid_id_1, poid_id_2, ... poid_id_n)
*****************************************************/
/******************************************************
* Append the initial part of 'in' clause to search
* template
*****************************************************/
strncpy(tmp_s_template, s_template,
sizeof(tmp_s_template)-1);
pin_snprintf(s_template, sizeof(s_template), "%s %s",
tmp_s_template, "and service_obj_id0 in (");
cookie = NULL;
while ((temp_flistp = PIN_FLIST_ELEM_GET_NEXT(o_flistp,
PIN_FLD_SERVICES, &rec_id, 1, &cookie, ebufp))) {
vp = (poid_t *)PIN_FLIST_FLD_GET(temp_flistp,
PIN_FLD_SERVICE_OBJ, 0, ebufp);
if (first_srv_flag == 0) { /* First iteration */
/*************************************
* NOTE: NO 'comma' before first poid ID
* in 'in' clause
*************************************/
first_srv_flag = 1;
}
else { /* NOT the first iteration */
/*************************************
* Add 'comma' before adding this poid
* ID to 'in' clause
************************************/
strncpy(tmp_s_template, s_template,
sizeof(tmp_s_template)-1);
pin_snprintf(s_template, sizeof(s_template),
"%s%s", tmp_s_template, ", ");
}
/* Add this poid ID to 'in' clause */
strncpy(tmp_s_template, s_template,
sizeof(tmp_s_template)-1);
pin_snprintf(s_template, sizeof(s_template),
"%s%" I64_PRINTF_PATTERN "d",
tmp_s_template,
PIN_POID_GET_ID((poid_t *)vp));
}
/*************************************
* Append the last part of 'in' clause
* to search template
************************************/
strncpy(tmp_s_template, s_template,
sizeof(tmp_s_template)-1);
pin_snprintf(s_template, sizeof(s_template), "%s%s",
tmp_s_template, ")");
} /* end else (multiple services) */
}
PIN_FLIST_FLD_SET(s_flistp, PIN_FLD_TEMPLATE, (void *)s_template,
ebufp);
/*********************************************************
* Add the search arguments. This is a 2 arg =, = search
*********************************************************/
temp_flistp = PIN_FLIST_ELEM_ADD(s_flistp, PIN_FLD_ARGS, 1, ebufp);
PIN_FLIST_FLD_SET(temp_flistp, PIN_FLD_BILLINFO_OBJ, (void *)bi_pdp,
ebufp);
status = PIN_ITEM_STATUS_PENDING;
temp_flistp = PIN_FLIST_ELEM_ADD(s_flistp, PIN_FLD_ARGS, 2, ebufp);
PIN_FLIST_FLD_SET(temp_flistp, PIN_FLD_STATUS, (void *)&status, ebufp);
/*********************************************************
* Add the results array for the search.
*********************************************************/
temp_flistp = PIN_FLIST_ELEM_ADD(s_flistp, PIN_FLD_RESULTS, 0, ebufp);
PIN_FLIST_FLD_SET(temp_flistp, PIN_FLD_POID, NULL, ebufp);
PIN_FLIST_FLD_SET(temp_flistp, PIN_FLD_ITEM_TOTAL, NULL, ebufp);
PIN_FLIST_FLD_SET(temp_flistp, PIN_FLD_ADJUSTED, NULL, ebufp);
PIN_FLIST_FLD_SET(temp_flistp, PIN_FLD_DISPUTED, NULL, ebufp);
PIN_FLIST_FLD_SET(temp_flistp, PIN_FLD_WRITEOFF, NULL, ebufp);
PIN_FLIST_FLD_SET(temp_flistp, PIN_FLD_RECVD, NULL, ebufp);
PIN_FLIST_FLD_SET(temp_flistp, PIN_FLD_TRANSFERED, NULL, ebufp);
PIN_FLIST_FLD_SET(temp_flistp, PIN_FLD_SERVICE_OBJ, NULL, ebufp);
PIN_FLIST_FLD_SET(temp_flistp, PIN_FLD_BILL_OBJ, NULL, ebufp);
/**********************************************************
* do real search
**********************************************************/
PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
"fm_bill_pol_get_pending_items search flist", s_flistp);
PCM_OP(ctxp, PCM_OP_SEARCH, 0, s_flistp, r_flistpp, ebufp);
PIN_FLIST_DESTROY_EX(&s_flistp, NULL);
PIN_FLIST_DESTROY_EX(&o_flistp, NULL);
/*********************************************************
* Errors..?
*********************************************************/
if (PIN_ERR_IS_ERR(ebufp)) {
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"fm_bill_pol_get_pending_items error",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;
}
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;
}
/*******************************************************************
* 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;
}
/*******************************************************************
* fm_cust_pol_tax_init()
*
* Use this policy to load any custom user tax data into an internal
* data structure you may have declared in this file. In this default
* implementation, the structure will be the Tax_Table global flist.
*
*******************************************************************/
void
fm_cust_pol_tax_init(
pcm_context_t *ctxp,
pin_flist_t *in_flistp,
pin_flist_t **out_flistpp,
pin_errbuf_t *ebufp)
{
int32 errp = 0;
void *vp = NULL;
char *taxfile = NULL;
FILE *fp = NULL;
char buf[STR_LEN];
char code[STR_LEN];
char pkg[STR_LEN];
char rate[STR_LEN];
char start_t[STR_LEN];
char end_t[STR_LEN];
char j_level[STR_LEN];
char j_list[STR_LEN];
char descr[STR_LEN];
char rule[STR_LEN];
pin_decimal_t *pct = NULL;
pin_decimal_t *npct=NULL;
pin_decimal_t *dpct=NULL;
int32 len = 0;
int32 lvl = 0;
int32 trl = 0;
int32 elemid = 0;
int32 precision = 6;
time_t startTm = 0;
time_t endTm = 0;
pin_flist_t *flistp = NULL;
if (PIN_ERR_IS_ERR(ebufp))
return;
PIN_ERR_CLEAR_ERR(ebufp);
/* Create the return flist */
*out_flistpp = PIN_FLIST_CREATE(ebufp);
/* Set the account POID */
vp = PIN_FLIST_FLD_GET(in_flistp, PIN_FLD_POID, 0, ebufp);
PIN_FLIST_FLD_SET(*out_flistpp, PIN_FLD_POID, (void *)vp, ebufp);
if (Tax_Table == (pin_flist_t*)NULL) {
/* Create the flist to hold the tax rates */
Tax_Table = (pin_flist_t*)PIN_FLIST_CREATE(ebufp);
PIN_ERR_LOG_MSG(PIN_ERR_LEVEL_DEBUG,
"Creating the Tax_Table");
} else {
/* the tax table has been initialized */
PIN_ERR_LOG_MSG(PIN_ERR_LEVEL_WARNING,
"The Tax_Table has already been created!");
return;
/*****/
}
/*
* Build Tax_Table from external table, which in this
* implementation happens to be the same taxcodes_map
* file specified in the cm/pin.conf
*/
/* get the taxcodes_map path from the pin.conf */
pin_conf("fm_rate", "taxcodes_map", PIN_FLDT_STR,
(caddr_t*)&taxfile, &errp);
if (errp != PIN_ERR_NONE) {
PIN_ERR_LOG_MSG(PIN_ERR_LEVEL_ERROR,
"taxcodes_map table config error!");
return;
/*****/
}
/* Let's redefine the taxcodes_map table so that the following
* columns:
*
* # Taxcode Pkg Code1 Code2 Si Wt_code Cmdty_code
* # ------- --- ----- ----- ------ ------- ----------
* usage : Q : 01 : 01 : S : :
* VAT : U : 4.5 : : : :
*
* will now become these:
*
* # Taxcode Pkg Rate Start End Lvl List Desc Rule
* # ------- ---- ---- -------- -------- --- ----- ------ ----
* VAT : U : 5.0 : 02/01/01 : 01/31/02 : Fed : GB;FR : VAT-EU : Std
* VAT : U : 4.5 : 02/01/02 : 01/31/08 : Fed : GB : VAT-GB : Std
* VAT : U : 4.0 : 02/01/02 : 01/31/08 : Fed : FR : VAT-FR : Std
*/
fp = (FILE*) fopen(taxfile, "r");
free(taxfile);
if (fp == (FILE*)NULL) {
PIN_ERR_LOG_MSG(PIN_ERR_LEVEL_ERROR,
"Failed to open taxcodes_map file!");
goto Done;
/********/
}
while (fgets(buf, STR_LEN, fp) != NULL) {
if (strchr(buf, '#') || *buf == '\n') {
/* skip comments and blank lines*/
continue;
}
/* Strip newline, if it is there */
len = strlen(buf);
if (buf[len-1] == '\n') {
buf[len-1] = '\0';
}
code[0] = pkg[0] = rate[0] = start_t[0] = end_t[0] = '\0';
j_level[0] = j_list[0] = descr[0] = rule[0] = '\0';
/* Parse the line in the taxcodes_map */
fm_cust_pol_parse_map_file(buf, code, pkg, rate,
start_t, end_t, j_level, j_list, descr, rule);
if (strncmp(pkg, "U", 1) != 0) {
/* skip entries other than "user" */
continue;
/*******/
}
/* Start of validity date */
fm_cust_pol_str_to_time_t(start_t, &startTm, 0);
/* End of validity date */
fm_cust_pol_str_to_time_t(end_t, &endTm, 1);
/* Jurisdiction level */
if (strncmp("Federal", j_level, 3) == 0) {
lvl = PIN_RATE_TAX_JUR_FED;
} else if (strncmp("State", j_level, 3) == 0) {
lvl = PIN_RATE_TAX_JUR_STATE;
} else if (strncmp("County", j_level, 3) == 0) {
lvl = PIN_RATE_TAX_JUR_COUNTY;
} else if (strncmp("City", j_level, 3) == 0) {
lvl = PIN_RATE_TAX_JUR_CITY;
} else {
lvl = PIN_RATE_TAX_JUR_FED;
}
/* Tax rule (how to tax) */
if (strncmp(rule, "Std", 3) == 0) {
trl = 0; /* standard tax */
} else if (strncmp(rule, "Tax", 3) == 0) {
trl = 1; /* tax on tax */
} else if (strncmp(rule, "Fee", 3) == 0) {
trl = 2; /* flat fee */
} else if (strncmp(rule, "Inc", 3) == 0) {
trl = 3; /* inclusive tax */
} else if (strncmp(rule, "NCS", 3) == 0) {
trl = 4; /* non-cumulative standard tax */
} else if (strncmp(rule, "NCT", 3) == 0) {
trl = 5; /* non-cumulative tax on tax */
} else if (strncmp(rule, "NCF", 3) == 0) {
trl = 6; /* non-cumulative flat fee */
} else if (strncmp(rule, "NCI", 3) == 0) {
trl = 7; /* non-cumulative inclusive */
} else {
trl = 0; /* default */
}
/* Tax rate */
if (trl == 2 || trl == 6) {
/* 'rate' is a flat fee */
pct = pbo_decimal_from_str(rate,ebufp);
} else {
/* 'rate' is a percentage */
npct = pbo_decimal_from_str(rate,ebufp);
dpct = pbo_decimal_from_str("100.0",ebufp);
pct = pbo_decimal_divide( npct, dpct ,ebufp);
}
/* Set some defaults */
if (!*j_list) {
strcpy(j_list, "*");
}
if (!*descr) {
strcpy(descr, "No Tax Description");
}
flistp = PIN_FLIST_ELEM_ADD(Tax_Table, PIN_FLD_TAXES,
elemid++, ebufp);
PIN_FLIST_FLD_SET(flistp, PIN_FLD_TAX_CODE,
(void*)code, ebufp);
PIN_FLIST_FLD_PUT(flistp, PIN_FLD_PERCENT,(void*)pbo_decimal_round(pct,
(int32)precision,ROUND_HALF_UP,ebufp), ebufp);
PIN_FLIST_FLD_SET(flistp, PIN_FLD_START_T,
(void*)&startTm, ebufp);
PIN_FLIST_FLD_SET(flistp, PIN_FLD_END_T, (void*)&endTm, ebufp);
PIN_FLIST_FLD_SET(flistp, PIN_FLD_TYPE, (void*)&lvl, ebufp);
PIN_FLIST_FLD_SET(flistp, PIN_FLD_NAME, (void*)j_list, ebufp);
PIN_FLIST_FLD_SET(flistp, PIN_FLD_DESCR, (void*)descr, ebufp);
PIN_FLIST_FLD_SET(flistp, PIN_FLD_TAX_WHEN, (void*)&trl, ebufp);
pbo_decimal_destroy(&npct);
pbo_decimal_destroy(&dpct);
pbo_decimal_destroy(&pct);
} /* end while */
fclose(fp);
Done:
PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
"Tax Table from taxcodes_map file", Tax_Table);
return;
}
