/*******************************************************************
* Main routine for the PCM_OP_CUST_POL_VALID_STATUS operation.
*******************************************************************/
void
op_cust_pol_valid_status(
cm_nap_connection_t *connp,
u_int opcode,
u_int flags,
pin_flist_t *i_flistp,
pin_flist_t **ret_flistpp,
pin_errbuf_t *ebufp)
{
pcm_context_t *ctxp = connp->dm_ctx;
pin_flist_t *r_flistp = NULL;
/*
* Null out results until we have some.
*/
*ret_flistpp = NULL;
PIN_ERR_CLEAR_ERR(ebufp);
/*
* Insanity check.
*/
if (opcode != PCM_OP_CUST_POL_VALID_STATUS) {
pin_set_err(ebufp, PIN_ERRLOC_FM,
PIN_ERRCLASS_SYSTEM_DETERMINATE,
PIN_ERR_BAD_OPCODE, 0, 0, opcode);
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"bad opcode in op_cust_pol_valid_status", ebufp);
return;
}
/*
* Debug: what did we get?
*/
PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
"op_cust_pol_valid_status input flist", i_flistp);
/*
* Call main function to do it
*/
fm_cust_pol_valid_status(ctxp, i_flistp, &r_flistp, ebufp);
/*
* Results.
*/
if (PIN_ERR_IS_ERR(ebufp)) {
*ret_flistpp = (pin_flist_t *)NULL;
PIN_FLIST_DESTROY(r_flistp, NULL);
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"op_cust_pol_valid_status error", ebufp);
} else {
*ret_flistpp = r_flistp;
PIN_ERR_CLEAR_ERR(ebufp);
PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
"op_cust_pol_valid_status return flist", r_flistp);
}
return;
}
/*******************************************************************
* Main routine for the PCM_OP_CUST_POL_PRE_COMMIT command
*******************************************************************/
void
op_cust_pol_pre_commit(
cm_nap_connection_t *connp,
u_int opcode,
u_int flags,
pin_flist_t *in_flistp,
pin_flist_t **ret_flistpp,
pin_errbuf_t *ebufp)
{
pcm_context_t *ctxp = connp->dm_ctx;
pin_flist_t *r_flistp = NULL;
/***********************************************************
* Null out results until we have some.
***********************************************************/
*ret_flistpp = NULL;
PIN_ERR_CLEAR_ERR(ebufp);
/***********************************************************
* Insanity check.
***********************************************************/
if (opcode != PCM_OP_CUST_POL_PRE_COMMIT) {
pin_set_err(ebufp, PIN_ERRLOC_FM,
PIN_ERRCLASS_SYSTEM_DETERMINATE,
PIN_ERR_BAD_OPCODE, 0, 0, opcode);
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"bad opcode in op_cust_pol_pre_commit", ebufp);
return;
}
/***********************************************************
* We will not open any transactions with Policy FM
* since policies should NEVER modify the database.
***********************************************************/
/***********************************************************
* Call main function to do it
***********************************************************/
fm_cust_pol_pre_commit(ctxp, flags, in_flistp, &r_flistp, ebufp);
/***********************************************************
* Results.
***********************************************************/
if (PIN_ERR_IS_ERR(ebufp)) {
*ret_flistpp = (pin_flist_t *)NULL;
PIN_FLIST_DESTROY(r_flistp, NULL);
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"op_cust_pol_pre_commit error", ebufp);
} else {
*ret_flistpp = r_flistp;
PIN_ERR_CLEAR_ERR(ebufp);
PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
"op_cust_pol_pre_commit return flist", r_flistp);
}
return;
}
/*******************************************************************
* Main routine for the PCM_OP_CUST_POL_GET_CONFIG operation.
*******************************************************************/
void
op_cust_pol_get_config(
cm_nap_connection_t *connp,
u_int opcode,
u_int flags,
pin_flist_t *in_flistp,
pin_flist_t **ret_flistpp,
pin_errbuf_t *ebufp)
{
pcm_context_t *ctxp = connp->dm_ctx;
pin_flist_t *r_flistp = NULL;
if (PIN_ERR_IS_ERR(ebufp))
return;
PIN_ERR_CLEAR_ERR(ebufp);
/***********************************************************
* Insanity check.
***********************************************************/
if (opcode != PCM_OP_CUST_POL_GET_CONFIG) {
pin_set_err(ebufp, PIN_ERRLOC_FM,
PIN_ERRCLASS_SYSTEM_DETERMINATE,
PIN_ERR_BAD_OPCODE, 0, 0, opcode);
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"bad opcode in op_cust_pol_get_config", ebufp);
return;
}
/***********************************************************
* Debug: What did we get?
***********************************************************/
PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
"op_cust_pol_get_config input flist", in_flistp);
/***********************************************************
* Call main function to do it
***********************************************************/
fm_cust_pol_get_config(ctxp, in_flistp, &r_flistp, ebufp);
/***********************************************************
* Results.
***********************************************************/
if (PIN_ERR_IS_ERR(ebufp)) {
*ret_flistpp = (pin_flist_t *)NULL;
PIN_FLIST_DESTROY(r_flistp, NULL);
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"op_cust_pol_get_config error", ebufp);
} else {
*ret_flistpp = r_flistp;
PIN_ERR_CLEAR_ERR(ebufp);
PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
"op_cust_pol_get_config return flist", r_flistp);
}
return;
}
/*******************************************************************
* Main routine for the PCM_OP_PRICE_POL_PREP_DEPENDENCY command
*******************************************************************/
EXPORT_OP void
op_price_pol_prep_dependency(
cm_nap_connection_t *connp,
u_int32 opcode,
u_int32 flags,
pin_flist_t *i_flistp,
pin_flist_t **o_flistpp,
pin_errbuf_t *ebufp)
{
pcm_context_t *ctxp = connp->dm_ctx;
pin_flist_t *r_flistp = NULL;
if (PIN_ERR_IS_ERR(ebufp))
return;
PIN_ERR_CLEAR_ERR(ebufp);
/*
* Null out results until we have some.
*/
*o_flistpp = NULL;
/*
* Insanity check.
*/
if (opcode != PCM_OP_PRICE_POL_PREP_DEPENDENCY) {
pin_set_err(ebufp, PIN_ERRLOC_FM,
PIN_ERRCLASS_SYSTEM_DETERMINATE,
PIN_ERR_BAD_OPCODE, 0, 0, opcode);
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"bad opcode in op_price_pol_prep_dependency", ebufp);
return;
}
/*
* Do the actual prep in a lower routine
*/
fm_price_pol_prep_dependency(ctxp, flags, i_flistp, &r_flistp, ebufp);
/*
* Results.
*/
if (PIN_ERR_IS_ERR(ebufp)) {
*o_flistpp = (pin_flist_t *)NULL;
PIN_FLIST_DESTROY(r_flistp, NULL);
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"op_price_pol_prep_dependency error", ebufp);
} else {
*o_flistpp = r_flistp;
PIN_ERR_CLEAR_ERR(ebufp);
PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
"op_price_pol_prep_dependency return flist", r_flistp);
}
return;
}
/*******************************************************************
* Main
*
* This sets up the parameters and then calls the FM.
*
*******************************************************************/
int main(
int argc,
char *argv[])
{
pcm_context_t *ctxp;
pin_flist_t *flistp = NULL;
pin_flist_t *a_flistp = NULL;
pin_flist_t *r_flistp = NULL;
poid_t *acct_pdp = NULL;
poid_t *srvc_pdp = NULL;
u_int opcode;
int64 database;
void *vp;
char logfile[256];
char *c_ptr = (char *)NULL;
char *program;
int32 err;
pin_errbuf_t ebuf;
PIN_ERR_CLEAR_ERR(&ebuf);
/*
* Logging initialization
*/
program = basename(argv[0]);
PIN_ERR_SET_PROGRAM(program);
PIN_ERR_SET_LEVEL(PIN_ERR_LEVEL_WARNING);
strcpy(logfile, "default.pinlog");
pin_conf(program, "logfile", PIN_FLDT_STR, (caddr_t *)&(c_ptr), &err);
if (c_ptr != (char *)NULL) {
pin_strlcpy(logfile, c_ptr, sizeof(logfile));
pin_free(c_ptr);
c_ptr = (char *)NULL;
}
PIN_ERR_SET_LOGFILE(logfile);
/*
* Check the input.
*/
if (argc != 3) {
usage(argv[0]);
PIN_ERR_LOG_MSG(PIN_ERR_LEVEL_ERROR, "bad # of arguments");
exit(1);
}
/*
* Initialize PCM connection.
*/
PCM_CONNECT(&ctxp, &database, &ebuf);
if (PIN_ERR_IS_ERR(&ebuf)) {
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"pcm_connect error", &ebuf);
exit(2);
}
/*
* Create the poid prototype.
*/
srvc_pdp = PIN_POID_CREATE(database, argv[1], 0, &ebuf);
/*
* Look up the account.
*/
flistp = PIN_FLIST_CREATE(&ebuf);
vp = (void *)srvc_pdp;
PIN_FLIST_FLD_SET(flistp, PIN_FLD_POID, vp, &ebuf);
vp = (void *)argv[2];
PIN_FLIST_FLD_SET(flistp, PIN_FLD_LOGIN, vp, &ebuf);
opcode = PCM_OP_ACT_FIND;
PCM_OP(ctxp, opcode, 0, flistp, &a_flistp, &ebuf);
/*
* Did we find anything?
*/
acct_pdp = PIN_FLIST_FLD_GET(a_flistp, PIN_FLD_ACCOUNT_OBJ, 0, &ebuf);
if (!PIN_POID_IS_NULL(acct_pdp)) {
/*
* Advisory (or add confirm?)
*/
fprintf(stdout, "Deleting Account:\t");
pin_poid_print(acct_pdp, 0, &ebuf);
fprintf(stdout, "\n");
/*
* Put the real account poid on the flist
* (The account_obj field will just be ignored)
*/
vp = (void *)acct_pdp;
PIN_FLIST_FLD_SET(a_flistp, PIN_FLD_POID, vp, &ebuf);
/*
* Delete the account.
*/
opcode = PCM_OP_CUST_DELETE_ACCT;
PCM_OP(ctxp, opcode, 0, a_flistp, &r_flistp, &ebuf);
/*
* Did we delete or not?
*/
if (PIN_ERR_IS_ERR(&ebuf)) {
fprintf(stdout, "Account Deletion Error Occurred.\n");
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"op_cust_delete_acct error", &ebuf);
} else {
fprintf(stdout, "Account Deleted.\n");
}
} else {
/*
* FIND error.
*/
fprintf(stdout, "Unable to locate Account.\n");
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"op_act_find error", &ebuf);
}
/*
* Close the PCM context.
*/
PCM_CONTEXT_CLOSE(ctxp, 0, &ebuf);
/*
* Clean up.
*/
/* Free local memory. */
PIN_FLIST_DESTROY(flistp, NULL);
PIN_FLIST_DESTROY(a_flistp, NULL);
PIN_FLIST_DESTROY(r_flistp, NULL);
/* No errors. */
return(0);
}
/*******************************************************************
* 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;
}
/*******************************************************************
* 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;
}
/*******************************************************************
* 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;
}
//****************************************************
// 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;
}
/*******************************************************************
* Main routine for the PCM_OP_CUST_POL_GET_POPLIST operation.
*******************************************************************/
void
op_cust_pol_get_poplist(
cm_nap_connection_t *connp, /* Connection pointer */
u_int opcode, /* Opcode in question */
u_int flags, /* Standard flags if any*/
pin_flist_t *in_flistp, /* Input flist */
pin_flist_t **ret_flistpp, /* Results flist */
pin_errbuf_t *ebufp) /* Error buffer */
{
pcm_context_t *ctxp = connp->dm_ctx; /* Connection */
pin_flist_t *r_flistp = NULL; /* Local flist */
void *vp = NULL;
/***********************************************************
* Null out results until we have some.
***********************************************************/
*ret_flistpp = NULL;
PIN_ERR_CLEAR_ERR(ebufp);
/***********************************************************
* Insanity check.
***********************************************************/
if (opcode != PCM_OP_CUST_POL_GET_POPLIST) {
pin_set_err(ebufp, PIN_ERRLOC_FM,
PIN_ERRCLASS_SYSTEM_DETERMINATE,
PIN_ERR_BAD_OPCODE, 0, 0, opcode);
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"bad opcode in op_cust_pol_get_poplist", ebufp);
return;
}
/***********************************************************
* Debug: what did we get?
***********************************************************/
PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
"op_cust_pol_get_poplist input flist", in_flistp);
/***********************************************************
* Create the pop flist & copy the input poid to it.
***********************************************************/
r_flistp = PIN_FLIST_CREATE(ebufp);
vp = PIN_FLIST_FLD_GET(in_flistp, PIN_FLD_POID, 0, ebufp);
PIN_FLIST_FLD_SET(r_flistp, PIN_FLD_POID, vp, ebufp);
/***********************************************************
* Call a sub-function to actually find the pops.
***********************************************************/
fm_cust_pol_get_poplist(ctxp, in_flistp, r_flistp, ebufp);
/***********************************************************
* Result.
***********************************************************/
if (PIN_ERR_IS_ERR(ebufp)) {
*ret_flistpp = (pin_flist_t *)NULL;
PIN_FLIST_DESTROY(r_flistp, NULL);
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"op_cust_pol_get_poplist error", ebufp);
} else {
*ret_flistpp = r_flistp;
PIN_ERR_CLEAR_ERR(ebufp);
PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
"op_cust_pol_get_poplist return flist", r_flistp);
}
return;
} /* op_cust_pol_get_poplist */
/********************************************************************
* fm_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 */
//****************************************************
// 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;
}
/*******************************************************************
* Main routine for the PCM_OP_SUBSCRIPTION_POL_SNOWBALL_DISCOUNT operation.
*******************************************************************/
void
op_subscription_pol_snowball_discount(
cm_nap_connection_t *connp,
u_int opcode,
u_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 *r_flistp = NULL;
pin_flist_t *flistp = NULL;
poid_t *a_pdp = NULL;
char *action;
char *cp;
u_int rec_id;
u_int done = 0;
if (PIN_ERR_IS_ERR(ebufp))
return;
PIN_ERR_CLEAR_ERR(ebufp);
/***********************************************************
* Insanity check.
***********************************************************/
if (opcode != PCM_OP_SUBSCRIPTION_POL_SNOWBALL_DISCOUNT) {
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_subscription_pol_snowball_discount opcode error",
ebufp);
return;
}
/***********************************************************
* Debug: What we got.
***********************************************************/
PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
"op_subscription_pol_snowball_discount input flist",
in_flistp);
/***********************************************************
* Get the policy return flist.
***********************************************************/
fm_subs_pol_snowball_discount(ctxp, flags, in_flistp, &r_flistp, ebufp);
/***********************************************************
* Errors?
***********************************************************/
if (PIN_ERR_IS_ERR(ebufp)) {
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"op_subscription_pol_snowball_discount error",
ebufp);
PIN_FLIST_DESTROY(r_flistp, NULL);
*ret_flistpp = NULL;
} else {
/***************************************************
* Point the real return flist to the right thing.
***************************************************/
PIN_ERR_CLEAR_ERR(ebufp);
*ret_flistpp = r_flistp;
PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
"op_subscription_pol_snowball_discount return flist",
*ret_flistpp);
}
return;
}
//****************************************************
// adjust_CashBalance
// Pre:
// Post:
//
bool bs_AdjustCashBalance::adjust_CashBalance(
pin_Session * pinp,
poid_t * account_pdp,
pin_decimal_t * amountp,
string source,
string description,
string service_str,
string reason_id,
pin_flist_t **return_flistpp,
pin_errbuf_t *ebufp )
{
pin_flist_t *input_flistp = NULL;
poid_t *bal_pdp = NULL;
int dollar_currency = 840;
int iversion = DEFAULT_CASH_ADJUSTMENT_VER;
ostringstream os;
bool rc = false;
char *service_code = (char *)NULL;
service_code = (char *)calloc(256, sizeof(char));
strcpy(service_code,(const char *)GENERIC_SERVICE_ADJUSTMENT_CODE);
strcat(service_code,reason_id.c_str());
int id = atoi(service_code);
PIN_ERR_CLEAR_ERR(ebufp);
//--- setup --------------------------
/* source / desc name */
const string this_program("adjust_CashBalance");
if ( description.empty() )
{
ostringstream os;
os << DEFAULT_CASH_ADJUSTMENT_DESCR << "." << getuser(ENV_USER) << "." << this_program;
description.assign(os.str());
}
if ( source.empty() )
{
source.assign(this_program);
}
PIN_ERR_LOG_MSG(PIN_ERR_LEVEL_DEBUG, (char*)description.c_str() );
/* retrieving the bal_grp poid associated with a service
* if the service_str is NULL, then account level bal_grp will be used
*/
pin_flist_t *r_flistp = NULL;
r_flistp = bs_AccountInfo::getService_and_BalGrpPoids(pinp, account_pdp, service_str);
bal_pdp = PIN_FLIST_FLD_TAKE(r_flistp,PIN_FLD_BAL_GRP_OBJ, 1, ebufp);
if(r_flistp) PIN_FLIST_DESTROY(r_flistp,ebufp);
if(PIN_POID_IS_NULL(bal_pdp)) {
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,(char*)"/balance_group poid is NULL", ebufp );
return false;
}
//--- adjust------------------------------
input_flistp = PIN_FLIST_CREATE(ebufp);
PIN_FLIST_FLD_SET(input_flistp, PIN_FLD_PROGRAM_NAME, (void*)source.c_str(), ebufp);
PIN_FLIST_FLD_SET(input_flistp, PIN_FLD_POID,(void *) account_pdp, ebufp);
PIN_FLIST_FLD_SET(input_flistp, PIN_FLD_DESCR, (void *)description.c_str(), ebufp);
PIN_FLIST_FLD_SET(input_flistp, PIN_FLD_CURRENCY, (void *) &dollar_currency,ebufp);
PIN_FLIST_FLD_SET(input_flistp, PIN_FLD_AMOUNT, amountp, ebufp);
PIN_FLIST_FLD_SET(input_flistp, PIN_FLD_STR_VERSION, (void *) &iversion, ebufp);
PIN_FLIST_FLD_SET(input_flistp, PIN_FLD_STRING_ID, (void *) &id, ebufp);
/*** Inserting BAL_GRP poid ***/
PIN_FLIST_FLD_PUT(input_flistp, PIN_FLD_BAL_GRP_OBJ, (void *) bal_pdp, ebufp);
/*
* Call opcode
*/
rc = pinp->call_opcode( PCM_OP_AR_ACCOUNT_ADJUSTMENT, 0, input_flistp,
return_flistpp, ebufp);
PIN_FLIST_DESTROY(input_flistp, ebufp);
return rc;
}
