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 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 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 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 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 getS3Info(uuid):
endPoint = construct.constructUrl('s3info', module='arya').format(uuid)
response = Utils.makeRequest(endPoint,
'',
CampaignShardHelper.constructHeader(),
'GET',
timeout=120)
return response.json()
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 replyMessage(self):
getReplyMessasgeListConstructedEndPoint = construct.constructUrl('getreplymessagelist').format(str(self.campaignId))
skippedErrorIds = []
response = Utils.makeRequest(url=getReplyMessasgeListConstructedEndPoint, data='', auth=construct.constructAuthenticate(), headers=construct.constructHeaders(), method='GET')
responseEntity = construct.constructResponse(response)['json']['entity']
for error in responseEntity:
messageId = error['messageId']
if self.commDetailsId == messageId:
for errorDetails in error['errorDetails']:
skippedErrorIds.append(errorDetails['errorId'])
Logger.log('Error Details Id: {}, Description: {}, Count: {}: '.format(errorDetails['errorId'],errorDetails['errorDescription'],errorDetails['errorCount']))
replyMessasgeConstructedEndPoint = construct.constructUrl('replymessage').format(str(self.campaignId), str(messageId))
payloadData = {'skippedErrors' : skippedErrorIds}
response = Utils.makeRequest(url=replyMessasgeConstructedEndPoint, data=payloadData, auth=construct.constructAuthenticate(), headers=construct.constructHeaders(), method='POST')
Logger.log('Response of MessageId {} Replied and Response : {}'.format(messageId, construct.constructResponse(response)))
return construct.constructResponse(response)
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 approveWithCampaignAndMessageId(campaignId, messageId):
endPoint = IrisHelper.constructUrl('approvemessage').replace(
'{campaignId}', str(campaignId)).replace('{msgId}', messageId)
return IrisHelper.constructResponse(
Utils.makeRequest(url=endPoint,
data=None,
auth=IrisHelper.constructAuthenticate(),
headers=IrisHelper.constructHeaders(),
method='POST'))
def checkExists(campaignName):
checkExistsEndpoint = IrisHelper.constructUrl(
'checkcampaignexists').replace('{name}', campaignName)
response = Utils.makeRequest(url=checkExistsEndpoint,
data='',
auth=IrisHelper.constructAuthenticate(),
headers=IrisHelper.constructHeaders(),
method='GET')
return IrisHelper.constructResponse(response)
def getOnboardingStatus(orgId):
orgOnboardingStatusEndpoint = IrisHelper.constructUrl(
'orgonboadringstatus').replace('{orgId}', orgId)
response = Utils.makeRequest(url=orgOnboardingStatusEndpoint,
data='',
auth=IrisHelper.constructAuthenticate(),
headers=IrisHelper.constructHeaders(),
method='GET')
return {'RESPONSE': IrisHelper.constructResponse(response)}
def getOrgV2Status():
orgStatusEndpoint = IrisHelper.constructUrl('orgv2status')
response = Utils.makeRequest(url=orgStatusEndpoint,
data='',
auth=IrisHelper.constructAuthenticate(),
headers=IrisHelper.constructHeaders(),
method='GET')
return {'RESPONSE': IrisHelper.constructResponse(response)}
def getAll(queryParam):
endpoint = IrisHelper.constructUrl('getById',
queryParam=queryParam).replace(
'{group_id}', '')
response = Utils.makeRequest(url=endpoint,
data='',
auth=IrisHelper.constructAuthenticate(),
headers=IrisHelper.constructHeaders(),
method='GET')
return IrisHelper.constructResponse(response)
def start(campaignId, messageId):
endpoint = IrisHelper.constructUrl('startmessage').replace(
'{campaignId}', str(campaignId)).replace('{msgId}', messageId)
response = IrisHelper.constructResponse(
Utils.makeRequest(url=endpoint,
data='',
auth=IrisHelper.constructAuthenticate(),
headers=IrisHelper.constructHeaders(),
method='POST'))
return response
def makeAuthorizeRequest(campaignId, messageId):
authorizeConstructedEndPoint = construct.constructUrl(
'authorize').replace('{campaignId}', str(campaignId)).replace(
'{messageId}', str(messageId))
response = Utils.makeRequest(url=authorizeConstructedEndPoint,
data='',
auth=construct.constructAuthenticate(),
headers=construct.constructHeaders(),
method='POST')
return construct.constructResponse(response)
def getLevelsForDimension(category):
endpoint = IrisHelper.constructUrl('productcategory').replace(
'{category}', category)
response = IrisHelper.constructResponse(
Utils.makeRequest(url=endpoint,
data='',
auth=IrisHelper.constructAuthenticate(),
headers=IrisHelper.constructHeaders(),
method='GET'))
return response
def executePrecheck(campaignId, messageId, checkVariant=True):
if checkVariant: PreCheck.checkVariantIsClosed(messageId)
endpoint = IrisHelper.constructUrl('precheck').replace(
'{campaignId}', str(campaignId)).replace('{messageId}', messageId)
response = Utils.makeRequest(url=endpoint,
data='',
auth=IrisHelper.constructAuthenticate(),
headers=IrisHelper.constructHeaders(),
method='GET')
return IrisHelper.constructResponse(response)
def getLevelValuesForDimension(urlSubstringForDimension, levelName):
endpoint = IrisHelper.constructUrl('productlevel').replace(
'{urlSubstringForDimension}',
urlSubstringForDimension).replace('{levelName}', levelName)
response = IrisHelper.constructResponse(
Utils.makeRequest(url=endpoint,
data='',
auth=IrisHelper.constructAuthenticate(),
headers=IrisHelper.constructHeaders(),
method='GET'))
return response
def getWeCRMTemplates():
response = Utils.makeRequest(constant.config['wecrm_details']['url'], {}, campaignMessage.constructWecrmHeader(), 'GET')
data = json.loads(response.content)
length = 0
for k in data['template_list']:
countOfkeyword = len(re.findall(r'keyword', k['content'], re.M | re.I))
if length < countOfkeyword:
length = countOfkeyword
constant.config['templateId'] = k['template_id']
constant.config['templateTitle'] = k['title']
constant.config['templateSize'] = length
def edit(campaignInfo,editInfo):
payload = copy.deepcopy(campaignInfo['PAYLOAD'])
payload.update(editInfo)
endpoint = IrisHelper.constructUrl('editcampaign').replace('{campaignId}',str(campaignInfo['ID']))
response = IrisHelper.constructResponse(
Utils.makeRequest(url=endpoint, data=payload, auth=IrisHelper.constructAuthenticate(),
headers=IrisHelper.constructHeaders(), method='PUT')
)
return {
'PAYLOAD':payload,
'RESPONSE' : response
}
def edit(campaignId, messageId, payload, editInfo=None):
endpoint = IrisHelper.constructUrl('editmessage').replace(
'{campaignId}', str(campaignId)).replace('{msgId}', messageId)
if editInfo is not None:
payload.update(editInfo)
response = IrisHelper.constructResponse(
Utils.makeRequest(url=endpoint,
data=payload,
auth=IrisHelper.constructAuthenticate(),
headers=IrisHelper.constructHeaders(),
method='PUT'))
return {'RESPONSE': response, 'PAYLOAD': payload}
def updateSettings(self, updateInfo={}):
campaignSettingsEndpoint = IrisHelper.constructUrl('campaignSettings')
payload = CampaignSetting.constructUploadPayload(updateInfo)
response = Utils.makeRequest(
url=campaignSettingsEndpoint,
data=payload,
auth=IrisHelper.constructAuthenticate(),
headers=IrisHelper.constructHeadersPatch(),
method='PATCH')
return {
'RESPONSE': IrisHelper.constructResponse(response),
'PAYLOAD': payload
}
def savetestData(module, value):
endPoint = 'http://apitester.capillary.in/apitest_app/testData'
data = {
'orgId': constant.config['orgId'],
'cluster': constant.config['cluster'],
'module': module,
'value': value
}
response = Utils.makeRequest(url=endPoint,
headers='',
body=data,
method='POST')
return response['message']
def makeAjaxCall(couponSeriedId, isSkuUpdate=False):
header = {
'accept': 'application/json',
'content-type': 'application/x-www-form-urlencoded',
'cookie': constant.config['intouchCookie']
}
if isSkuUpdate:
Logger.log('Making Ajax call to Update SKU')
postData = "sku_values=ONEPLUS1,ONEPLUS2,ONEPLUS3"
skuUpdateURL = constant.config['intouchUrl'] + constant.config[
'SkuUrl'] + str(couponSeriedId)
Utils.makeRequest(skuUpdateURL, postData, header, 'POST', '')
else:
Logger.log('Making Ajax call to get Brands Ids')
brandUrl = constant.config['intouchUrl'] + constant.config[
'brandUrl'] + str(couponSeriedId)
result = Utils.makeRequest(brandUrl, "", header, 'GET', '').json()
brandIds = result['items'].keys()
constant.config['categoryIds'] = []
brands = []
for b in range(0, len(brandIds)):
brands.append({"value": int(brandIds[b]), "status": "ADDED"})
Logger.log('Making Ajax call to get Categories Ids')
rootCategoryUrl = constant.config['intouchUrl'] + constant.config[
'categoryUrl'] + 'root'
rootCategoryResponse = Utils.makeRequest(rootCategoryUrl, "",
header, 'GET', '').json()
categoryParentIds = rootCategoryResponse['members'].keys()
category = []
for b in range(0, len(categoryParentIds)):
categoryUrl = constant.config['intouchUrl'] + constant.config[
'categoryUrl'] + categoryParentIds[b]
categoryIdResponse = Utils.makeRequest(categoryUrl, "", header,
'GET', '').json()
categoryIds = categoryIdResponse['members'].keys()
for c in range(0, len(categoryIds)):
constant.config['categoryIds'].append(int(categoryIds[c]))
category.append({
"value": int(categoryIds[c]),
"status": "ADDED"
})
Logger.log(
'Making Ajax call to update Brands & Category for voucher series'
)
constructPostData = {'brand': brands, 'category': category}
saveDetailsUrl = constant.config['intouchUrl'] + constant.config[
'saveUrl'] + str(couponSeriedId)
data = 'params=' + json.dumps(constructPostData)
Utils.makeRequest(saveDetailsUrl, data, header, 'POST', '')
def settings(self, settingInfo={}, popField=None):
Logger.log('Setting Info :', settingInfo)
campaignSettingsEndpoint = IrisHelper.constructUrl('campaignSettings')
payload = CampaignSetting.constructPayloadSetting(
settingInfo, popField)
response = Utils.makeRequest(url=campaignSettingsEndpoint,
data=payload,
auth=IrisHelper.constructAuthenticate(),
headers=IrisHelper.constructHeaders(),
method='POST')
return {
'RESPONSE': IrisHelper.constructResponse(response),
'PAYLOAD': payload
}
def createFilterList(campaignId, listName, loyaltyType='loyalty'):
response = None
try:
endPoint = construct.constructUrl('filterlist',
module='arya').format(
str(int(time.time())))
response = Utils.makeRequest(endPoint,
CampaignShardHelper.constructPayload(
campaignId, listName,
loyaltyType),
CampaignShardHelper.constructHeader(),
'POST',
timeout=300)
except Exception, exp:
Logger.log(
"Exception Occured while Creating Filter List :{}".format(exp))
def mergeList(payloadData={},
campaignId=None,
campaignType=['LIVE', 'ORG', 'List', 'TAGS', 0],
userType='mobile',
numberOfUsers=1,
numberOfCustomTags=0,
newUser=True,
process='update'):
campaignList.updateRechabilityBeforeEachRun()
campaignDefault = constant.campaignDefaultValues
if campaignId == None:
campaignIdValue = constant.campaignDefaultValues[campaignType[0]][
campaignType[1]]['Value']
if len(campaignIdValue['response']) == 0 and len(
campaignIdValue['payload']) == 0:
response, payload = campaigns.createCampaign(
{}, campaignTypeParams=[campaignType[0], campaignType[1]])
if response['statusCode'] == 200:
campaignId = response['json']['entity']['campaignId']
else:
Assertion.constructAssertion(
False,
'Error : While Creating Campaign , Status Code : {}'.
format(response['statusCode']))
else:
campaignId = campaignIdValue['response']['json']['entity'][
'campaignId']
Logger.log('CamapaignId getting used to create list :', campaignId)
createListConstructedEndPoint = construct.constructUrl(
'mergelist').replace('{campaignId}', str(campaignId))
payload = {}
if len(payloadData) == 0:
payload = construct.constructMergeListBody(userType, numberOfUsers,
numberOfCustomTags,
newUser)
else:
payload = construct.constructBody(payloadData, process,
'mergelist')
response = Utils.makeRequest(url=createListConstructedEndPoint,
data=payload,
auth=construct.constructAuthenticate(),
headers=construct.constructHeaders(),
method='POST')
return construct.constructResponse(response), payload, campaignId
def getCampaignById(campaignId=None, queryParam=[]):
getCampaignConstructedEndPoint = None
if len(queryParam) > 0:
getCampaignConstructedEndPoint = construct.constructUrl(
'getCampaign',
queryParam=queryParam).replace('{campaignId}', '')
else:
Assertion.constructAssertion(
campaignId != None, 'CampaignId and Query param both are None')
getCampaignConstructedEndPoint = construct.constructUrl(
'getCampaign').replace('{campaignId}', str(campaignId))
response = Utils.makeRequest(url=getCampaignConstructedEndPoint,
data='',
auth=construct.constructAuthenticate(),
headers=construct.constructHeaders(),
method='GET')
return construct.constructResponse(response)
def s3FileDownload(self, s3FileName):
url = constant.config['intouchUrl'] + constant.downloadS3File + str(
Utils.getTime(milliSeconds=True))
param = {'fileName': s3FileName}
header = {
'Cookie': constant.config['intouchCookie'],
'Content-Type': 'application/json'
}
try:
response = Utils.makeRequest(url=url,
data=param,
headers=header,
method='POST')
return response.content
except Exception, exp:
raise Exception(
's3File upload failed because of errorMessage: {} and NodeAPI: {}'
.format(exp, url))
