/*******************************************************************
* 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;
}
/*******************************************************************
* Main routine for the PCM_OP_ACT_POL_SPEC_GLID operation.
*******************************************************************/
void
op_act_pol_spec_glid(
cm_nap_connection_t *connp,
int opcode,
int flags,
pin_flist_t *i_flistp,
pin_flist_t **r_flistpp,
pin_errbuf_t *ebufp)
{
pin_cookie_t cookie = NULL;
pcm_context_t *ctxp = connp->dm_ctx;
pin_flist_t *e_flistp = NULL;
pin_flist_t *s_flistp = NULL;
pin_flist_t *flistp = NULL;
const char *event_type = NULL;
poid_t *e_pdp = NULL;
int rec_id = 0;
int *glid = NULL;
if (PIN_ERR_IS_ERR(ebufp))
return;
PIN_ERR_CLEAR_ERR(ebufp);
*r_flistpp = (pin_flist_t *)NULL;
/*******************************************************************
* Insanity check.
*******************************************************************/
if (opcode != PCM_OP_ACT_POL_SPEC_GLID) {
pin_set_err(ebufp, PIN_ERRLOC_FM,
PIN_ERRCLASS_SYSTEM_DETERMINATE,
PIN_ERR_BAD_OPCODE, 0, 0, opcode);
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"op_act_pol_spec_glid bad opcode error", ebufp);
return;
}
/*******************************************************************
* Debug: What we got.
*******************************************************************/
PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
"op_act_pol_spec_glid input flist", i_flistp);
/*******************************************************************
* Our action will depend on the type of event
* Get the event substruct to get all the needed data
*******************************************************************/
*r_flistpp = PIN_FLIST_COPY(i_flistp, ebufp);
e_flistp = PIN_FLIST_SUBSTR_GET(*r_flistpp, PIN_FLD_EVENT, 0, ebufp);
e_pdp = (poid_t *)PIN_FLIST_FLD_GET(e_flistp, PIN_FLD_POID, 0, ebufp);
event_type = PIN_POID_GET_TYPE(e_pdp);
/******************************************************************
* Check PIN_FLD_RATES_USED array, add a dummy one if not.
******************************************************************/
if (PIN_FLIST_ELEM_COUNT(e_flistp, PIN_FLD_BAL_IMPACTS, ebufp) == 0) {
/**********************************************************
* Add the bal impacts array for this pre-rates event.
**********************************************************/
fm_act_pol_add_event_bal_impacts(ctxp, e_flistp, ebufp);
}
/******************************************************************
* Now walk the PIN_FLD_RATES_USED array and check for G/L ID.
******************************************************************/
while ((flistp = PIN_FLIST_ELEM_GET_NEXT(e_flistp, PIN_FLD_BAL_IMPACTS,
&rec_id, 1, &cookie, ebufp)) != (pin_flist_t *)NULL) {
/**********************************************************
* G/L id is inside the PIN_FLD_SUBTOTAL array.
**********************************************************/
glid = (int *)PIN_FLIST_FLD_GET(flistp,
PIN_FLD_GL_ID, 1, ebufp);
/**********************************************************
* We need to fill in the G/L id now.
**********************************************************/
if (glid == (int *)NULL) {
fm_act_pol_spec_glid(connp, i_flistp,
event_type, flistp, ebufp);
}
}
/*******************************************************************
* Error?
*******************************************************************/
if (PIN_ERR_IS_ERR(ebufp)) {
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"op_act_pol_spec_glid error", ebufp);
} else {
PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
"op_act_pol_spec_glid return flist", *r_flistpp);
}
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_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);
}
void
fm_cust_pol_create_metafield_obj(
pcm_context_t *ctxp,
int32 flags,
pin_flist_t *in_flistp,
pin_flist_t **ret_flistpp,
pin_errbuf_t *ebufp)
{
void *vp = NULL;
int count =0;
int64 database = pcm_get_current_db_no(ctxp);
pin_flist_t *i_flist = NULL;
pin_flist_t *sub_flistp = NULL;
pin_flist_t *r_flistp = NULL;
char *program_name = NULL;
char *class_name= NULL;
char *default_value= NULL;
int fld_type=0;
if(PIN_ERRBUF_IS_ERR(ebufp))
return;
PIN_ERR_CLEAR_ERR(ebufp);
*ret_flistpp = NULL;
//Count FIELDS array
count = PIN_FLIST_ELEM_COUNT(in_flistp,PIN_FLD_VALUES,ebufp);
if (count==0)
return;
if(count==1)
{
i_flist= PIN_FLIST_CREATE(ebufp);
vp = PIN_FLIST_FLD_GET(in_flistp,PIN_FLD_POID,1,ebufp);
PIN_FLIST_FLD_SET(i_flist,PIN_FLD_POID,(void*)vp,ebufp);
sub_flistp = PIN_FLIST_ELEM_GET(in_flistp, PIN_FLD_VALUES,PIN_ELEMID_ANY, 1, ebufp);
program_name = PIN_FLIST_FLD_GET(sub_flistp,PIN_FLD_NAME,1,ebufp);
PIN_FLIST_FLD_SET(i_flist,PIN_FLD_NAME,program_name,ebufp);
fld_type =*(int*) PIN_FLIST_FLD_GET(sub_flistp,PIN_FLD_TYPE,1,ebufp);
PIN_FLIST_FLD_SET(i_flist,PIN_FLD_TYPE,&fld_type,ebufp);
class_name=PIN_FLIST_FLD_GET(sub_flistp,PIN_FLD_CLASS_NAME,1,ebufp);
PIN_FLIST_FLD_SET(i_flist,PIN_FLD_CLASS_NAME,class_name,ebufp);
default_value=PIN_FLIST_FLD_GET(sub_flistp,PIN_FLD_DEFAULT_VALUE,1,ebufp);
if(default_value)
PIN_FLIST_FLD_SET(i_flist,PIN_FLD_DEFAULT_VALUE,default_value,ebufp);
if (PIN_ERRBUF_IS_ERR(ebufp))
{
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,"Error Occured while creating the input flist",ebufp);
return;
}
PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,"input flist for metafield obj ",i_flist);
//Call pcm_op_create_obj
PCM_OP(ctxp,PCM_OP_CREATE_OBJ,0,i_flist,ret_flistpp,ebufp);
if(PIN_ERRBUF_IS_ERR(ebufp))
{
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,"Error Occured while calling PCM_OP_CREATE_OBJ",ebufp);
return;
}
}
else if (count >1)
{
//Call pcm_op_bulk_create_obj
PCM_OP(ctxp,PCM_OP_BULK_CREATE_OBJ ,0,in_flistp,ret_flistpp,ebufp);
if(PIN_ERRBUF_IS_ERR(ebufp))
{
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,"Error Occured while calling PCM_OP_BULK_CREATE_OBJ" ,ebufp);
return;
}
}
if(ret_flistpp)
PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,"Output flist for metafield obj ",*ret_flistpp);
return;
}
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);
}
}
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 );
}
/*******************************************************************
* fm_cust_pol_valid_login()
*
* Validate the given login according to the given poid type.
*
* For now, logins are required (ie they can't be NULL) and
* must be less than the maximum length (currently 255).
*
*******************************************************************/
static void
fm_cust_pol_valid_login(cm_nap_connection_t *connp,
pin_flist_t *i_flistp,
int32 flags,
pin_flist_t **o_flistpp,
pin_errbuf_t *ebufp)
{
pin_cookie_t cookie = NULL;
pin_flist_t *r_flistp = NULL;
pin_flist_t *s_flistp = NULL;
pin_flist_t *a_flistp = NULL;
pin_flist_t *flistp = NULL;
poid_t *o_pdp = NULL;
char *login = NULL;
void *vp = NULL;
pcm_context_t *ctxp = connp->dm_ctx;
const char *subtype = NULL;
int32 result = PIN_CUST_VERIFY_PASSED;
int32 elemid;
int64 db_no;
int count = 0;
int msexchange_service_type =
PIN_MSEXCHANGE_SERVICE_NONE;
/***********************************************************
* Return immediately if there's an error in ebufp.
***********************************************************/
if (PIN_ERR_IS_ERR(ebufp))
return;
PIN_ERR_CLEAR_ERR(ebufp);
/***********************************************************
* Create outgoing flist
***********************************************************/
r_flistp = PIN_FLIST_CREATE(ebufp);
*o_flistpp = r_flistp;
/***********************************************************
* Get (and add) the object poid.
***********************************************************/
o_pdp = (poid_t *)PIN_FLIST_FLD_GET(i_flistp, PIN_FLD_POID, 0, ebufp);
PIN_FLIST_FLD_SET(r_flistp, PIN_FLD_POID, (void *)o_pdp, ebufp);
/***********************************************************
* Get the input login.
***********************************************************/
login = (char *)PIN_FLIST_FLD_GET(i_flistp, PIN_FLD_LOGIN, 1, ebufp);
/*
* LOGIN could be NULL if SET_LOGIN is called to set an alias entry
* during SERVICE creation
*/
if (login != NULL) {
count = PIN_FLIST_ELEM_COUNT(i_flistp, PIN_FLD_ALIAS_LIST,
ebufp);
/***************************************************
* Try to validate based on /config/fld_validate
* (Login) obj, if it is a new service with alias
* list or modifying a login with no alias list
**************************************************/
if ((count < 1) || (fm_utils_op_is_ancestor(
connp->coip, PCM_OP_CUST_CREATE_SERVICE))) {
fm_cust_pol_validate_fld_value( ctxp, i_flistp,
i_flistp, r_flistp,
PIN_FLD_LOGIN,
0, "Login", 1, ebufp);
}
}
/***********************************************************
* Try to validate all of the alias list
***********************************************************/
a_flistp = 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 )
) {
/***********************************************************
* Prep the return flist
***********************************************************/
if ( !a_flistp ) {
a_flistp = PIN_FLIST_CREATE(ebufp);
}
if ( !flistp ) continue;
/***********************************************************
* Try to validate based on /config/fld_validate
* (name) obj. but since we cannot validate a value in
* PIN_FLD_NAME due to the facte we have to pass PIN_FLD_NAME
* as the name of the validation rule. I will cady the
* the PIN_FLD_NAME in a PIN_FLD_LOGIN and then manipulate
* the error output if there is one.
***********************************************************/
vp = PIN_FLIST_FLD_GET( flistp, PIN_FLD_NAME, 0, ebufp );
PIN_FLIST_FLD_SET( flistp, PIN_FLD_LOGIN, vp, ebufp );
fm_cust_pol_validate_fld_value( ctxp, i_flistp, flistp,
a_flistp, PIN_FLD_LOGIN, 0, "Login", 1, ebufp);
PIN_FLIST_FLD_DROP( flistp, PIN_FLD_LOGIN, ebufp );
if (PIN_FLIST_ELEM_COUNT(a_flistp, PIN_FLD_FIELD, ebufp) != 0) {
/***************************************************
* There is a validation error so normalize it to
* the input flist
***************************************************/
pin_fld_num_t field = PIN_FLD_ALIAS_LIST;
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);
result = PIN_CUST_VERIFY_FAILED;
PIN_FLIST_FLD_SET(a_flistp, PIN_FLD_RESULT,
(void *)&result, ebufp);
count = PIN_FLIST_ELEM_COUNT(r_flistp, PIN_FLD_FIELD,
ebufp);
PIN_FLIST_ELEM_PUT(r_flistp, a_flistp, PIN_FLD_FIELD,
count, ebufp);
a_flistp = PIN_FLIST_ELEM_GET( a_flistp, PIN_FLD_FIELD,
PIN_ELEMID_ANY, 0, ebufp );
field = PIN_FLD_NAME;
PIN_FLIST_FLD_SET( a_flistp, PIN_FLD_FIELD_NUM,
(void *)&field, ebufp );
a_flistp = NULL;
}
}
if ( ebufp->pin_err == PIN_ERR_NOT_FOUND ) {
PIN_ERR_CLEAR_ERR( ebufp );
}
/***************************************************************
* clean up any last unused a_flistp
***************************************************************/
PIN_FLIST_DESTROY_EX( &a_flistp, NULL );
if (PIN_FLIST_ELEM_COUNT(r_flistp, PIN_FLD_FIELD, ebufp) != 0) {
result = PIN_CUST_VERIFY_FAILED;
goto Done;
}
/***************************************************************
* Get the poid type to check service type. Used for E2K service
***************************************************************/
db_no = PIN_POID_GET_DB(o_pdp);
subtype = PIN_POID_GET_TYPE(o_pdp);
if ( subtype &&
(strcmp(subtype, PIN_MSEXCHANGE_SERVICE_TYPE_USER) == 0)){
msexchange_service_type = PIN_MSEXCHANGE_SERVICE_USER;
}
if ( subtype &&
(strcmp(subtype, PIN_MSEXCHANGE_SERVICE_TYPE_FIRSTADMIN) == 0)){
msexchange_service_type = PIN_MSEXCHANGE_SERVICE_FIRSTADMIN;
}
/***********************************************************
* Reject login change for /service/gsm type and subtype
***********************************************************/
if (subtype &&
(!(strncmp(subtype, "/service/gsm", 12)))) {
/***************************************************
* if user try to change the login and it's not allowed
***************************************************/
char * login = NULL;
login = (char *)PIN_FLIST_FLD_GET(i_flistp, PIN_FLD_LOGIN,
1, ebufp);
if (login == NULL) {
goto Done;
} else {
if (!(fm_utils_op_is_ancestor(connp->coip,
PCM_OP_CUST_COMMIT_CUSTOMER))&&
!(fm_utils_op_is_ancestor(connp->coip,
PCM_OP_CUST_MODIFY_CUSTOMER))&&
!(flags & PCM_OPFLG_CUST_REGISTRATION)) {
(void)fm_cust_pol_valid_add_fail(r_flistp,
PIN_FLD_LOGIN, (u_int)NULL,
PIN_CUST_VAL_ERR_REJECT,
PIN_CUST_REJECT_VALUE_ERR_MSG,
(void *)login, ebufp);
result = PIN_CUST_VERIFY_FAILED;
goto Done;
}
}
}
/***********************************************************
* Reject login change for /service/telco type and subtype
***********************************************************/
if (subtype &&
((!(strncmp(subtype, "/service/telco/", 15))) ||
(!(strcmp(subtype, "/service/telco"))))) {
/***************************************************
* if user try to change the login and it's not allowed
***************************************************/
char * login = NULL;
login = (char *)PIN_FLIST_FLD_GET(i_flistp, PIN_FLD_LOGIN,
1, ebufp);
if (login == NULL) {
goto Done;
} else {
if (!(fm_utils_op_is_ancestor(connp->coip,
PCM_OP_CUST_COMMIT_CUSTOMER))&&
!(fm_utils_op_is_ancestor(connp->coip,
PCM_OP_CUST_MODIFY_CUSTOMER))&&
!(flags & PCM_OPFLG_CUST_REGISTRATION)) {
(void)fm_cust_pol_valid_add_fail(r_flistp,
PIN_FLD_LOGIN, (u_int)NULL,
PIN_CUST_VAL_ERR_REJECT,
PIN_CUST_REJECT_VALUE_ERR_MSG,
(void *)login, ebufp);
result = PIN_CUST_VERIFY_FAILED;
goto Done;
}
}
}
/***********************************************************
* If we're still ok, check uniqueness, in case of multi_db
* and single-schema TT env.
* In case of multi-db approach and single-schema TT env, we
* need to check in the uniqueness table, otherwise proceed
* as before.
* We need to use both the service type and the login.
***********************************************************/
if (cm_fm_is_multi_db() || cm_fm_is_timesten()) {
int64 primary_db_no = 0;
int64 trans_db_no = 0;
pcm_context_t *vctxp = NULL;
poid_t *trans_poidp = NULL;
pin_flist_t *trans_flistp = NULL;
/***************************************************
* Put in all the fields we need to insert the
* entry into the uniqueness table
***************************************************/
cm_fm_get_primary_db_no(&primary_db_no, ebufp);
trans_flistp = pcm_get_trans_flist(ctxp);
if ( trans_flistp ) {
trans_poidp = PIN_FLIST_FLD_GET(trans_flistp,
PIN_FLD_POID, 0, ebufp);
trans_db_no = PIN_POID_GET_DB( trans_poidp );
} else {
trans_db_no = primary_db_no;
}
PIN_FLIST_DESTROY_EX( &trans_flistp, NULL );
/*
*if we are looking at a different db then we currently have a
* transaction in then we need a new context
*/
if ( primary_db_no != trans_db_no ) {
PCM_CONTEXT_OPEN(&vctxp, (pin_flist_t *)0, ebufp);
} else {
vctxp = ctxp;
}
fm_cust_pol_valid_login_check_uniquiness_table( vctxp,
primary_db_no,
msexchange_service_type,
i_flistp, r_flistp, ebufp );
if ( primary_db_no != trans_db_no ) {
PCM_CONTEXT_CLOSE(vctxp, 0, NULL);
}
} else {
/*********************************************************
* This happens only for a single db installation
* where we don't have to search in the uniqueness table.
********************************************************/
fm_cust_pol_valid_login_check_uniquiness_service( ctxp,
db_no, msexchange_service_type,
i_flistp, r_flistp, ebufp );
}
if (PIN_FLIST_ELEM_COUNT(r_flistp, PIN_FLD_FIELD, ebufp) != 0) {
result = PIN_CUST_VERIFY_FAILED;
goto Done;
}
Done:
PIN_FLIST_DESTROY_EX(&s_flistp, NULL);
PIN_FLIST_DESTROY_EX(&a_flistp, NULL);
/***********************************************************
* Set the overall result and return.
***********************************************************/
PIN_FLIST_FLD_SET(r_flistp, PIN_FLD_RESULT, (void *)&result, ebufp);
/***********************************************************
* Error?
***********************************************************/
if (PIN_ERR_IS_ERR(ebufp)) {
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"fm_cust_pol_valid_login error", ebufp);
}
return;
}
static void
fm_bill_pol_prepare_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 *o_flistp = NULL;
pin_flist_t *temp_flistp = NULL;
pin_cookie_t cookie = NULL;
int32 rec_id = 0;
int32 rec_id1 = 0;
void *vp = NULL;
int64 database = 0;
int32 count = 0;
int32 *status = NULL;
if (PIN_ERR_IS_ERR(ebufp))
return;
PIN_ERR_CLEAR_ERR(ebufp);
*r_flistpp = PIN_FLIST_CREATE(ebufp);
count = PIN_FLIST_ELEM_COUNT(i_flistp, PIN_FLD_ITEMS, ebufp);
if (count == 1) {
temp_flistp = PIN_FLIST_ELEM_GET_NEXT(i_flistp, PIN_FLD_ITEMS,
&rec_id, 1, &cookie, ebufp);
vp = PIN_FLIST_FLD_GET(temp_flistp, PIN_FLD_ITEM_OBJ, 1, ebufp);
if (PIN_POID_IS_NULL((poid_t *)vp)) {
goto cleanup;
}
}
s_flistp = PIN_FLIST_CREATE(ebufp);
PIN_FLIST_FLD_SET(s_flistp, PIN_FLD_ITEM_TOTAL, NULL, ebufp);
PIN_FLIST_FLD_SET(s_flistp, PIN_FLD_ADJUSTED, NULL, ebufp);
PIN_FLIST_FLD_SET(s_flistp, PIN_FLD_DISPUTED, NULL, ebufp);
PIN_FLIST_FLD_SET(s_flistp, PIN_FLD_WRITEOFF, NULL, ebufp);
PIN_FLIST_FLD_SET(s_flistp, PIN_FLD_RECVD, NULL, ebufp);
PIN_FLIST_FLD_SET(s_flistp, PIN_FLD_TRANSFERED, NULL, ebufp);
PIN_FLIST_FLD_SET(s_flistp, PIN_FLD_SERVICE_OBJ, NULL, ebufp);
PIN_FLIST_FLD_SET(s_flistp, PIN_FLD_BILL_OBJ, NULL, ebufp);
PIN_FLIST_FLD_SET(s_flistp, PIN_FLD_STATUS, NULL, ebufp);
cookie = NULL;
while ((temp_flistp = PIN_FLIST_ELEM_GET_NEXT(i_flistp, PIN_FLD_ITEMS,
&rec_id, 1, &cookie, ebufp))) {
vp = PIN_FLIST_FLD_GET(temp_flistp, PIN_FLD_ITEM_OBJ, 1, ebufp);
if (PIN_POID_IS_NULL((poid_t *)vp)) {
pin_set_err(ebufp, PIN_ERRLOC_FM,
PIN_ERRCLASS_SYSTEM_DETERMINATE,
PIN_ERR_BAD_VALUE, 0, 0, 0);
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"fm_bill_pol_prepare_pending_items error:"
" Item Poid is NULL", ebufp);
goto cleanup;
}
PIN_FLIST_FLD_SET(s_flistp, PIN_FLD_POID, vp, ebufp);
PCM_OP(ctxp, PCM_OP_READ_FLDS, 0, s_flistp, &o_flistp, ebufp);
/***********************************************************
* If the item status is pending add it to the results .
* Otherwise return.
**********************************************************/
status = (int32 *)PIN_FLIST_FLD_GET(o_flistp, PIN_FLD_STATUS, 1,
ebufp);
if ((!status) || (*status != PIN_ITEM_STATUS_PENDING)) {
vp = PIN_FLIST_FLD_GET(o_flistp, PIN_FLD_BILL_OBJ, 1,
ebufp);
if (!status || PIN_POID_IS_NULL((poid_t *)vp)){
pin_set_err(ebufp, PIN_ERRLOC_FM,
PIN_ERRCLASS_SYSTEM_DETERMINATE,
PIN_ERR_BAD_VALUE, 0, 0, 0);
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"fm_bill_pol_prepare_pending_items error:"
"Item Status is not pending", ebufp);
goto cleanup;
}
PIN_FLIST_DESTROY_EX(&o_flistp, NULL);
continue;
}
PIN_FLIST_FLD_DROP(o_flistp, PIN_FLD_STATUS, ebufp);
PIN_FLIST_ELEM_PUT (*r_flistpp, o_flistp, PIN_FLD_RESULTS,
rec_id1++, ebufp);
o_flistp = NULL;
}
cleanup:
if (PIN_ERR_IS_ERR(ebufp)) {
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"fm_bill_pol_prepare_pending_items error ", ebufp);
PIN_FLIST_DESTROY_EX(r_flistpp, NULL);
}
PIN_FLIST_DESTROY_EX(&s_flistp, NULL);
PIN_FLIST_DESTROY_EX(&o_flistp, NULL);
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;
}
