def test_LUCI_CF_018(self, description, couponConfig, claimObject,
validTillDay):
couponConfigObj, couponSeriesId = LuciHelper.saveCouponConfigAndAssertions(
self, couponConfig)
LuciHelper.claimCouponSeries(self, couponSeriesId, claimObject)
couponConfigObj = LuciHelper.getCouponConfigAndAssertion(
self, couponSeriesId, 0, 0)
Assertion.constructAssertion(
long(couponConfigObj['ownerValidity']) > 0,
'Owner Validity is set Actual: {}'.format(
couponConfigObj['ownerValidity']))
couponConfigObj.update({
'valid_till_date':
Utils.getTime(days=validTillDay, milliSeconds=True),
'ownerValidity':
Utils.getTime(days=validTillDay, milliSeconds=True)
})
LuciHelper.saveCouponConfigAndAssertions(self, couponConfigObj)
couponConfigObj = LuciHelper.getCouponConfigAndAssertion(
self, couponSeriesId, 0, 0)
Assertion.constructAssertion(
long(couponConfigObj['valid_till_date']) > 0,
'valid_till_date is set Actual: {}'.format(
couponConfigObj['valid_till_date']))
Assertion.constructAssertion(
long(couponConfigObj['ownerValidity']) > 0,
'Owner Validity is set Actual: {}'.format(
couponConfigObj['ownerValidity']))
def test_executeTierDowngradeForOrgAtTime(self):
billingTime = Utils.getTime(days=-120, dateTimeFormat=True)
txBody = {
"root": {
"transaction": {
"amount": "6000",
"billing_time": billingTime,
"gross_amount": "6000"
}
}
}
txObj = InTouchAPI(Transaction.Add(body=txBody))
custObj = InTouchAPI(Customer.Get({'mobile': txObj.params['mobile']}))
currentSlab = custObj.response['response']['customers']['customer'][0][
'current_slab']
Assertion.constructAssertion(
currentSlab == 'Gold',
'Current Slab Should be Gold before Tier Downgrade')
firstDayofMonth = Utils.getFirstDayofMonth(milliSeconds=True)
self.connObj.executeTierDowngradeForOrgAtTime(self.orgId,
firstDayofMonth, True,
True)
custObj = InTouchAPI(Customer.Get({'mobile': txObj.params['mobile']}))
currentSlab = custObj.response['response']['customers']['customer'][0][
'current_slab']
Assertion.constructAssertion(
currentSlab == 'Silver',
'Current Slab Should be Silver after Tier Downgrade')
def irisv2_message_edit_PARTICULARDATE_upcoming_create_execute_plain_mobile_schedulle_body_Sanity(
self, campaignType, testControlType, listType, channel,
messageInfo):
messageDetails = CreateMessage.create(campaignType,
testControlType,
listType,
channel,
messageInfo,
updateNode=True,
lockNode=True)
CreateMessage.assertResponse(messageDetails['RESPONSE'], 200)
message_calls().waitForJobDetailsStatusToClose(
messageDetails['RESPONSE']['json']['entity']['id'],
'VARIANT_CREATION')
dateTime = Utils.getTime(hours=5, minutes=32, dateTimeFormat=True)
messageDetails['PAYLOAD'].update({
'schedule': {
'startDate':
Utils.getTime(minutes=1, seconds=25, milliSeconds=True),
'endDate':
Utils.getTime(minutes=40, milliSeconds=True),
'repeatOn': [1],
'repeatType':
'DAILY',
'scheduleType':
'RECURRING',
'hour':
int(dateTime[11:13]),
'minute':
int(dateTime[14:16])
}
})
editInfo = CreateMessage.edit(
constant.config['node'][campaignType][testControlType]['CAMPAIGN']
['ID'], messageDetails['RESPONSE']['json']['entity']['id'],
messageDetails['PAYLOAD'])
CreateMessage.assertResponse(editInfo['RESPONSE'], 200)
message_calls().waitForJobDetailsStatusToClose(
editInfo['RESPONSE']['json']['entity']['id'],
'VARIANT_CREATION',
version=1)
approveRespone = AuthorizeMessage.approve(
campaignType,
testControlType,
listType,
channel,
messageInfo,
messageCreateResponse=editInfo)
AuthorizeMessage.assertResponse(approveRespone, 200)
campaignId = constant.config['node'][campaignType][testControlType][
'CAMPAIGN']['ID']
AuthorizeMessageDBAssertion(campaignId,
editInfo['RESPONSE'],
editInfo['PAYLOAD'],
testControlType,
version=1).check()
def emailBody(emailBodyDict={}):
tmpDict = {
'body': 'test body',
'orgId': constant.config['orgId'],
'createdTime': str(Utils.getTime()),
'retrievedTime': str(Utils.getTime()),
'subject': 'test subject'
}
tmpDict.update(emailBodyDict)
return veneno.EmailBody(**tmpDict)
def BulkExpiryReportData(bulkExpiryReportData):
tmpDict = {
'orgId': constant.config['orgId'],
'loggedInUserId': 0,
'fromTimeInMillis': Utils.getTime(days=-1, milliSeconds=True),
'toTimeInMillis': Utils.getTime(milliSeconds=True),
'includeExpired': True,
'includeRedeemed': True
}
tmpDict.update(bulkExpiryReportData)
return peb.BulkExpiryReportData(**tmpDict)
def redeemCoupon(requestDict={}):
tmpDict = {
'orgId': constant.config['orgId'],
'couponCode': None,
'storeUnitId': 1,
'billAmount': 1000,
'billNumber': str(Utils.getTime(milliSeconds=True)),
'eventTimeInMillis': Utils.getTime(milliSeconds=True)
}
tmpDict.update(requestDict)
return luci.RedeemCoupon(**tmpDict)
def getMessageVariantById(campaignId, variantId):
endpoint = IrisHelper.constructUrl('getmessagevariant').replace('{campaignId}', str(campaignId)).replace(
'{variantId}',
variantId)
response = Utils.makeRequest(url=endpoint, data='', auth=IrisHelper.constructAuthenticate(),
headers=IrisHelper.constructHeaders(), method='GET')
return IrisHelper.constructResponse(response)
def test_LUCI_GCD_025(self):
# Save Coupon Config
couponConfigObj, couponSeriesId = LuciHelper.saveCouponConfigAndAssertions(self)
couponConfigObj.update({'allow_multiple_vouchers_per_user': True, 'do_not_resend_existing_voucher': True, 'redeem_at_store' : str([self.tillId])})
LuciHelper.saveCouponConfigAndAssertions(self,couponConfigObj)
couponCode1 = LuciHelper.issueCouponAndAssertions(self,couponSeriesId)[0]
couponCode2 = LuciHelper.issueCouponAndAssertions(self,couponSeriesId)[0]
transNum1 = LuciHelper.redeemCouponAndAssertions(self, couponSeriesId, couponCode1)['transactionNumber']
time.sleep(1)
self.billId = Utils.getTime(milliSeconds=True)
transNum2 = LuciHelper.redeemCouponAndAssertions(self, couponSeriesId, couponCode2)['transactionNumber']
# coupon Search and Assertion
redemptionFiltersObj = LuciObject.redemptionFilters({'transactionNumber': [transNum1]})
issualFilterObj = LuciObject.issualFilters({'redeemableAtStoreId': [self.storeId]})
couponSearchRequest = {'redemptionFilters': redemptionFiltersObj, 'issualFilters': issualFilterObj}
LuciHelper.couponSearchAndAssertion(self, [couponSeriesId], couponSearchRequest, [couponCode1])
redemptionFiltersObj = LuciObject.redemptionFilters({'transactionNumber': [transNum2]})
issualFilterObj = LuciObject.issualFilters({'redeemableAtStoreId': [self.storeId]})
couponSearchRequest = {'redemptionFilters': redemptionFiltersObj, 'issualFilters': issualFilterObj}
LuciHelper.couponSearchAndAssertion(self, [couponSeriesId], couponSearchRequest, [couponCode2])
redemptionFiltersObj = LuciObject.redemptionFilters({'transactionNumber': [transNum1, transNum2]})
issualFilterObj = LuciObject.issualFilters({'redeemableAtStoreId': [self.storeId]})
couponSearchRequest = {'redemptionFilters': redemptionFiltersObj, 'issualFilters': issualFilterObj}
LuciHelper.couponSearchAndAssertion(self, [couponSeriesId], couponSearchRequest, [couponCode1, couponCode2])
def test_LUCI_GCD_016(self):
# Save Coupon Config
couponConfigObj, couponSeriesId = LuciHelper.saveCouponConfigAndAssertions(self)
couponConfigObj.update({'allow_multiple_vouchers_per_user': True, 'do_not_resend_existing_voucher': True,
'same_user_multiple_redeem': True, 'multiple_use': True})
LuciHelper.saveCouponConfigAndAssertions(self,couponConfigObj)
couponCode1 = LuciHelper.issueCouponAndAssertions(self,couponSeriesId)[0]
couponCode2 = LuciHelper.issueCouponAndAssertions(self,couponSeriesId)[0]
redeemedDate1 = LuciHelper.redeemCouponAndAssertions(self, couponSeriesId, couponCode1)['redemptionDate']
time.sleep(2)
self.billId = Utils.getTime(milliSeconds=True)
redeemedDate2 = LuciHelper.redeemCouponAndAssertions(self, couponSeriesId, couponCode2)['redemptionDate']
# coupon Search and Assertion
redemptionFiltersObj = LuciObject.redemptionFilters({'redemptionDateStart': (redeemedDate1 - 1000),'redemptionDateEnd': (redeemedDate1 + 1000)})
redemptionFiltersObj = {'redemptionFilters': redemptionFiltersObj}
LuciHelper.couponSearchAndAssertion(self, [couponSeriesId], redemptionFiltersObj, [couponCode1])
redemptionFiltersObj = LuciObject.redemptionFilters({'redemptionDateStart': (redeemedDate2 - 1000),'redemptionDateEnd': (redeemedDate2 + 1000)})
redemptionFiltersObj = {'redemptionFilters': redemptionFiltersObj}
LuciHelper.couponSearchAndAssertion(self, [couponSeriesId], redemptionFiltersObj, [couponCode2])
redemptionFiltersObj = LuciObject.redemptionFilters({'redemptionDateStart': (redeemedDate1 - 1000),'redemptionDateEnd': (redeemedDate2 + 1000)})
redemptionFiltersObj = {'redemptionFilters': redemptionFiltersObj}
LuciHelper.couponSearchAndAssertion(self, [couponSeriesId], redemptionFiltersObj, [couponCode1, couponCode2])
def create(campaignType, testControlType, payload=None, startDate=None, endDate=None, description=None,
testControlPercentage=None, name=None, updateNode=False, lockNode=False):
if not CreateCampaign.checkCampaignAvialable(campaignType, testControlType) or updateNode:
endpoint = IrisHelper.constructUrl('createcampaign')
payload = CreateCampaign.constructPayload(campaignType, startDate, endDate, description, testControlType,
testControlPercentage, name) if payload is None else payload
response = IrisHelper.constructResponse(
Utils.makeRequest(url=endpoint, data=payload, auth=IrisHelper.constructAuthenticate(),
headers=IrisHelper.constructHeaders(), method='POST')
)
if response['statusCode'] == 200:
CreateCampaign.validateCreateCampaign(response)
if not lockNode: CreateCampaign.updateNodeCampaign(campaignType, testControlType,
response['json']['entity']['campaignId'],
payload['name'], payload)
if campaignType == 'LAPSED': time.sleep(25) # Wait to make Campaign Lapsed
return {
'ID': response['json']['entity']['campaignId'],
'NAME': payload['name'],
'PAYLOAD': payload
}
else:
return {
'RESPONSE': response,
'PAYLOAD': payload
}
else:
return constant.config['node'][campaignType][testControlType]['CAMPAIGN']
def setup_class(self):
Logger.logSuiteName(str(self).split('.')[-1])
self.constructObj = LuciObject()
self.userId = constant.config['usersInfo'][0]['userId']
self.tillId = constant.config['tillIds'][0]
self.storeId = constant.config['storeIds'][0]
self.billId = Utils.getTime(milliSeconds=True)
def generateSmsWhitelistingData(tmpValue, mobile = '918660430751'):
if constant.config['cluster'] in ['nightly', 'staging']:
for i in range(0, 3):
try:
testCol = constant.config['mongoConn']
value = {
"mobile": mobile,
"delivered": 0,
"not_delivered": 0
}
value.update(tmpValue)
value['total'] = value['delivered'] + value['not_delivered']
batchReq = []
batchReq.append(pymongo.ReplaceOne({'mobile': mobile}, value, upsert=True))
testCol.bulk_write(batchReq)
Logger.log(testCol.find({'mobile' : mobile})[0])
return
except pymongo.errors.ConnectionFailure as e:
Logger.log(e)
port = constant.config['INTOUCH_DB_MONGO_MASTER']
if Utils.restartTunnel(port):
DarknightHelper.getMongoConnection('whitelisting', 'mobile_status')
else:
break
except Exception as e:
break
raise Exception(e)
def PointsRedemptionReversalEventData(paramDict={}):
constant.config['uniqueId'] = randValues.randomString(8)
tmpDict = {
'orgID':
constant.config['orgId'],
'storeUnitID':
constant.config['storeIds'][0],
'eventTimeInMillis':
Utils.getTime(seconds=randValues.randomInteger(2),
milliSeconds=True),
'userDetails':
EMFObject.constructUserDetailsObject(0),
'uniqueRedemptionId':
None,
'uniqueId':
constant.config['uniqueId'],
'serverReqId':
constant.config['serverReqId'],
'source':
'INSTORE',
'accountId':
str(constant.config['programId']),
'notes':
'Auto points reversal'
}
tmpDict.update(paramDict)
return emf.PointsRedemptionReversalEventData(**tmpDict)
def ReturnBillLineitemsEventData(paramDict={'returnLineItem': {}}):
constant.config['uniqueId'] = randValues.randomString(8)
tmpDict = {
'orgID':
constant.config['orgId'],
'customerID':
constant.config['usersInfo'][0]['userId'],
'returnBillID':
constant.config['billNumber'],
'storeUnitID':
constant.config['storeIds'][0],
'eventTimeInMillis':
Utils.getTime(milliSeconds=True),
'uniqueId':
constant.config['uniqueId'],
'serverReqId':
constant.config['serverReqId'],
'returnLineItems':
[EMFObject.ReturnLineItem(paramDict['returnLineItem'])],
'userDetails':
EMFObject.constructUserDetailsObject(0),
'source':
'INSTORE',
'accountId':
str(constant.config['programId']),
}
paramDict.pop('returnLineItem')
tmpDict.update(paramDict)
return emf.ReturnBillLineitemsEventData(**tmpDict)
def getObjectives():
campaignObjectivesEndpoint = IrisHelper.constructUrl('campaignobjectives')
response = Utils.makeRequest(url=campaignObjectivesEndpoint, data='',
auth=IrisHelper.constructAuthenticate(),
headers=IrisHelper.constructHeaders(), method='GET')
return {'RESPONSE': IrisHelper.constructResponse(response)}
def test_irisv2_message_edit_upcoming_create_plain_mobile_particulardate_to_immediate(
self, campaignType, testControlType, listType, channel,
messageInfo, statusCode, errorCode, errorDescription):
messageDetails = CreateMessage.create(campaignType,
testControlType,
listType,
channel,
messageInfo,
updateNode=True,
lockNode=True)
CreateMessage.assertResponse(messageDetails['RESPONSE'], 200)
message_calls().waitForJobDetailsStatusToClose(
messageDetails['RESPONSE']['json']['entity']['id'],
'VARIANT_CREATION')
dateTime = Utils.getTime(hours=5, minutes=32, dateTimeFormat=True)
messageDetails['PAYLOAD'].update(
{'schedule': {
'scheduleType': 'IMMEDIATE'
}})
editInfo = CreateMessage.edit(
constant.config['node'][campaignType][testControlType]['CAMPAIGN']
['ID'], messageDetails['RESPONSE']['json']['entity']['id'],
messageDetails['PAYLOAD'])
CreateMessage.assertResponse(editInfo['RESPONSE'],
400,
expectedErrorCode=[errorCode],
expectedErrorMessage=errorDescription)
def Redeem(body={}, mobile='', code=''):
tmpDict = {
'root': {
'coupon': {
'customer': {
'mobile': mobile
},
'code': code,
'transaction': {
'amount': '100',
'number':
'AutomationTest' + str(int(time.time() * 100000))
}
}
}
}
if body == {}:
body = tmpDict
else:
body = Utils.mergeDict(tmpDict, body)
return {
'body': body,
'endPoint': constant.config['couponRedeem'],
'method': 'POST'
}
def test_LUCI_RSC_002(self, description, config):
couponConfigObj, couponSeriesId = LuciHelper.saveCouponConfigAndAssertions(
self, config)
LuciHelper.queuePumpWait(self, couponSeriesId)
# Issue Coupon Code
couponCode = LuciHelper.issueCouponAndAssertions(self,
couponSeriesId)[0]
resendRequest = LuciObject.resendCouponRequest({
'storeUnitId':
self.tillId,
'eventTimeInMillis':
Utils.getTime(milliSeconds=True),
'couponCode':
couponCode,
'userId':
self.userId
})
couponDetails = self.connObj.resendCoupon(resendRequest).__dict__
Assertion.constructAssertion(
couponCode == couponDetails['couponCode'],
'Resend Coupon Code Actual: {} and Expected: {}'.format(
couponCode, couponDetails['couponCode']))
Assertion.constructAssertion(
couponDetails['ex'] == None,
'Resend Coupon No exception occurred : {}'.format(
couponDetails['ex']))
def test_sendMessage_delayScheduledMessage(self, priority, gateway):
self.nsadminHelper.configureGateway(priority, gateway)
scheduledTimestamp = int(time.time() + 180) * 1000 # 2 mins delay
msgDict = {
"messageClass": "SMS",
"priority": priority,
"scheduledTimestamp": scheduledTimestamp,
"message": "test message with delayed schedule"
}
msgId = self.nsadminHelper.createAndSendMessage(msgDict)
self.nsadminHelper.assertWithWaitUntil(msgId, ['DELAYED_SCHEDULED'],
'Messages status', 10)
Utils.sleep(180)
self.nsadminHelper.assertWithWaitUntil(
msgId, ['READ', 'RECEIVED_IN_QUEUE', 'SENT'],
'Messages status after delay', 10)
def PointsRedemptionEventData(paramDict={}):
constant.config['uniqueId'] = randValues.randomString(8)
tmpDict = {
'orgID':
constant.config['orgId'],
'customerID':
0,
'numPointsToBeRedeemed':
constant.config['defaultRedeemPts'],
'redeemedAtStoreUnitId':
constant.config['storeIds'][0],
'redeemedOnBillNumber':
'-1',
'redeemedOnBillId':
constant.config['billNumber'],
'eventTimeInMillis':
Utils.getTime(seconds=(randValues.randomInteger(2)),
milliSeconds=True),
'userDetails':
EMFObject.constructUserDetailsObject(0),
'uniqueId':
constant.config['uniqueId'],
'serverReqId':
constant.config['serverReqId'],
'source':
'INSTORE',
'accountId':
str(constant.config['programId']),
}
constant.config['defaultRedeemPts'] = paramDict[
'numPointsToBeRedeemed'] if paramDict.has_key(
'numPointsToBeRedeemed') else 100
tmpDict.update(paramDict)
return emf.PointsRedemptionEventData(**tmpDict)
def Add(body={}, mobileS='', emailS='', mobileT='', emailT=''):
tmpDict = {
'root': {
'request': [{
'type': 'CHANGE_IDENTIFIER',
'base_type': 'MERGE',
'customer': {
'email': emailS,
'mobile': mobileS
},
'old_value': '',
'new_value': '',
'misc_info': {
'target_customer': {
'email': emailT,
'mobile': mobileT
}
}
}]
}
}
if body == {}:
body = tmpDict
else:
body = Utils.mergeDict(tmpDict, body)
return {
'body': body,
'endPoint': constant.config['requestAdd'],
'method': 'POST'
}
def disableExistingPromotions(programId, orgId):
perConnObj = LoyaltyHelper.getConnObj('pointsEngineRulesPort')
prgInfoList = perConnObj.getPromotionsByProgramId(programId=programId, orgId=orgId)
for pInfo in prgInfoList:
if pInfo.isActive == True:
pInfo.isActive = False
perConnObj.createOrUpdatePromotion(pInfo, programId, orgId, 1, Utils.getTime())
def test_LUCI_GCD_015(self):
# Save Coupon Config
couponConfigObj, couponSeriesId = LuciHelper.saveCouponConfigAndAssertions(self)
couponConfigObj.update({'allow_multiple_vouchers_per_user' : True, 'do_not_resend_existing_voucher' : True,
'same_user_multiple_redeem' : True,'multiple_use' : True})
LuciHelper.saveCouponConfigAndAssertions(self,couponConfigObj)
couponCode1 = LuciHelper.issueCouponAndAssertions(self,couponSeriesId)[0]
couponCode2 = LuciHelper.issueCouponAndAssertions(self,couponSeriesId)[0]
transNum1 = LuciHelper.redeemCouponAndAssertions(self, couponSeriesId, couponCode1)['transactionNumber']
time.sleep(1)
self.billId = Utils.getTime(milliSeconds=True)
transNum2 = LuciHelper.redeemCouponAndAssertions(self, couponSeriesId, couponCode2)['transactionNumber']
time.sleep(1)
# coupon Search and Assertion
redemptionFiltersObj = LuciObject.redemptionFilters({'transactionNumber' : [transNum1]})
redemptionFiltersObj = {'redemptionFilters' : redemptionFiltersObj}
LuciHelper.couponSearchAndAssertion(self, [couponSeriesId], redemptionFiltersObj, [couponCode1])
redemptionFiltersObj = LuciObject.redemptionFilters({'transactionNumber' : [transNum2]})
redemptionFiltersObj = {'redemptionFilters' : redemptionFiltersObj}
LuciHelper.couponSearchAndAssertion(self, [couponSeriesId], redemptionFiltersObj, [couponCode2])
redemptionFiltersObj = LuciObject.redemptionFilters({'transactionNumber' : [transNum1,transNum2]})
redemptionFiltersObj = {'redemptionFilters' : redemptionFiltersObj}
LuciHelper.couponSearchAndAssertion(self, [couponSeriesId], redemptionFiltersObj, [couponCode1, couponCode2])
def updateCampaign(afterUpdatepayload,
campaignType=['LIVE', 'ORG'],
campaignId=None,
process='update'):
beforeUpdateResponse, beforeUpdatePayload = {}, {}
if campaignId == None:
beforeUpdateResponse, beforeUpdatePayload = campaigns.createCampaign(
{'name': 'IRIS_UPDATE_CAMPAIGN' + str(int(time.time()))},
campaignTypeParams=campaignType)
campaignId = beforeUpdateResponse['json']['entity']['campaignId']
Logger.log('CampaignId Recieved : {} for campaignType : {}'.format(
campaignId, campaignType))
updateCampaignConstructedEndPoint = construct.constructUrl(
'updateCampaign').replace('{campaignId}', str(campaignId))
afterUpdateresponse = Utils.makeRequest(
url=updateCampaignConstructedEndPoint,
data=afterUpdatepayload,
auth=construct.constructAuthenticate(),
headers=construct.constructHeaders(),
method='PUT')
if afterUpdateresponse.status_code == 200:
beforeUpdatePayload.update(afterUpdatepayload)
constant.campaignDefaultValues[campaignType[0]][
campaignType[1]]['Value'].update(
{'payload': beforeUpdatePayload})
return construct.constructResponse(
afterUpdateresponse
), beforeUpdateResponse, afterUpdatepayload, beforeUpdatePayload
def addRecipient(payloadData,
campaignId,
listId,
userType='mobile',
numberOfUsers=1,
numberOfCustomTags=0,
process='update',
newUser=True):
campaignList.updateRechabilityBeforeEachRun()
addRecipientConstructedEndPoint = construct.constructUrl(
'addrecipient').replace('{campaignId}', str(campaignId)).replace(
'{listId}', str(listId))
payload = {}
if len(payloadData) == 0:
Logger.log(
'Constructing Payload for userType {}, for numberOfusers {} and customCount {}'
.format(userType, numberOfUsers, numberOfCustomTags))
if newUser == True:
payload = construct.constructAddRecipientPayload(
userType, numberOfUsers, numberOfCustomTags)
else:
payload = construct.constructAddRecipientPayloadForOldUsers(
userType, numberOfUsers, numberOfCustomTags)
else:
Logger.log('Constructing Payload as a Generic Way :', payloadData)
payload = construct.constructBody(payloadData, process,
'addrecipient')
response = Utils.makeRequest(url=addRecipientConstructedEndPoint,
data=payload,
auth=construct.constructAuthenticate(),
headers=construct.constructHeaders(),
method='POST')
return construct.constructResponse(response), payload
def query(query, dbname, port, retry=3):
exceptionList = [1152, 1154, 2003, 2013]
values = dbHelper.getDBCred(port)
for i in range(0, retry):
try:
db = Database(server='127.0.0.1', db=dbname, user=values['DbUsername'], passwd=values['DbPassword'],
port=port)
if query.lower().startswith('insert') or query.lower().startswith('update'):
dboutput = db.writeToDB(query)
else:
dboutput = db.readFromDB(query)
dboutput = map(list, dboutput)
dboutput = dbHelper.convertDataType(dboutput)
db.close()
return dboutput
except Exception as e:
if e[0] in exceptionList:
Logger.log(e)
if not Utils.restartTunnel(port):
break
else:
Logger.log('Ignore DB restart')
break
raise Exception(
"Exception Occured while Querying :{} for Query :{} on DB :{} and port :{}".format(e, query, dbname, port))
def getMessageAll(campaignId, queryParam=[]):
endpoint = IrisHelper.constructUrl('getmessage', queryParam=queryParam).replace('{campaignId}',
str(campaignId)).replace(
'{messageId}',
'')
response = Utils.makeRequest(url=endpoint, data='', auth=IrisHelper.constructAuthenticate(),
headers=IrisHelper.constructHeaders(), method='GET')
return IrisHelper.constructResponse(response)
def getS3Info(uuid):
endPoint = construct.constructUrl('s3info', module='arya').format(uuid)
response = Utils.makeRequest(endPoint,
'',
CampaignShardHelper.constructHeader(),
'GET',
timeout=120)
return response.json()
def gettestData(module):
endPoint = 'http://apitester.capillary.in/apitest_app/testData?module={}&cluster={}&orgId={}'.format(
module, constant.config['cluster'], constant.config['orgId'])
response = Utils.makeRequest(url=endPoint,
headers='',
body='',
method='GET')
return response['message']
def disableTierDowngrade(orgId, programId):
perConnObj = LoyaltyHelper.getConnObj('pointsEngineRulesPort')
tierDowngrad = perConnObj.getAllStrategiesByStrategyTypeId(programId, orgId, 5)
if tierDowngrad != []:
sInfo = tierDowngrad[0]
sInfo.propertyValues = json.dumps({"isActive":"false"})
sInfo.owner = 'LOYALTY'
perConnObj.createOrUpdateStrategy(sInfo, programId, orgId, -1, Utils.getTime())
