def getConfiguration():
config = json.loads(global_configuration)
config = Objectifier(config)
env_config = json.loads(os.environ.get(sys.argv[1]))
env_config = Objectifier(env_config)
config = {**config, **env_config}
return config
def __call__(self, method='GET', base=None, **kwargs):
resource = "/".join(self.endpoint_components)
if base is None:
base = self.base
if 'oauth_verifier' in kwargs or 'oauth_callback' in kwargs:
url = "{}{}".format(base, resource)
else:
url = "{}1/{}.json".format(base, resource)
signing_params = PARAMS()
signing_params.update(kwargs)
if self.token:
signing_params['oauth_token'] = self.token
base_string = generate_base_string(method, url, signing_params)
header_params = {}
query_params = {}
for key, value in signing_params.iteritems():
if key.startswith("oauth_"):
header_params[key] = urllib.quote(value, safe='')
else:
query_params[key] = urllib.quote(value, safe='')
signature = generate_signature(base_string, self.secret)
header_params['oauth_signature'] = urllib.quote_plus(signature)
auth_string = ', '.join(
['%s="%s"' % (k, v) for k, v in header_params.iteritems()])
headers = {'Authorization': 'OAuth {}'.format(auth_string)}
kwargs = {'headers': headers}
if method == 'POST':
request_method = requests.post
kwargs['data'] = "&".join(
["{}={}".format(k, v) for k, v in query_params.iteritems()])
else:
request_method = requests.get
kwargs['params'] = query_params
response = request_method(url, **kwargs)
if 'text/html' in response.headers['content-type']:
return Objectifier(urlparse.parse_qsl(response.text))
response = Objectifier(response.text)
if 'error' in response:
raise TwitterError(response.error)
return response
def test_list_of_tuples(self):
obj = Objectifier([('a', 1), ('b', 2)])
self.assertTrue('<Objectifier#dict' in repr(obj))
self.assertTrue('a=int' in repr(obj))
self.assertTrue('b=int' in repr(obj))
self.assertEqual(obj.a, 1)
self.assertEqual(obj.b, 2)
def register_client():
"""
{
"host":"",
"user":"",
"password":"",
"domain":""
}
"""
data_object = Objectifier(request.get_json())
conn = sqlite3.connect("data.db")
cur = conn.cursor()
cur.execute("select id from hosts where HostName = ?", (data_object.host,) )
id = cur.fetchall()
if(id.__len__()==0):
id = str (uuid1())
cur.execute("insert into hosts values(?,?,?)",(id, data_object.host , datetime.now() ) )
conn.commit()
cur.execute("insert into cred values (?,?,?,?)",( id , data_object.domain , data_object.user , data_object.password) )
conn.commit()
conn.close()
return jsonify({"id":id})
else:
query_data = request.get_json()
query_data.pop('host')
for items in query_data.keys():
cur.execute("update cred set "+items+"=? where id = ?", (str(query_data[items]) , id[0][0]) )
if(cur.rowcount ==0):
cur.execute("insert into cred values (?,?,?,?)",( id[0][0] , data_object.domain , data_object.user , data_object.password) )
conn.commit()
conn.close()
return jsonify({"id":id[0][0]})
def test_dict_2(self):
obj = Objectifier({'a': 1, 'b': 'c'})
self.assertTrue('<Objectifier#dict' in repr(obj))
self.assertTrue('a=int' in repr(obj))
self.assertTrue('b=str' in repr(obj))
self.assertEqual(obj.a, 1)
self.assertEqual(obj.b, 'c')
def test_list_of_dicts_2(self):
obj = Objectifier([{'a': 1, 'b': 2}, {'c': 3, 'd': 4}])
self.assertEqual(repr(obj), '<Objectifier#list elements:2>')
self.assertEqual(obj[0].a, 1)
self.assertEqual(obj[0].b, 2)
self.assertEqual(obj[1].c, 3)
self.assertEqual(obj[1].d, 4)
def test_tuple_of_tuples(self):
obj = Objectifier((('abc', 'def'), ('ghi', 'jkl')))
self.assertEqual(repr(obj), '<Objectifier#list elements:2>')
self.assertEqual(obj[0][0], 'abc')
self.assertEqual(obj[0][1], 'def')
self.assertEqual(obj[1][0], 'ghi')
self.assertEqual(obj[1][1], 'jkl')
def run():
config = json.load(open('satellite_config.json'))
config = Objectifier(config)
config.RMQ.queue = socket.gethostname()
DB = file_db(config.database)
credentials = pika.PlainCredentials(config.RMQ.user, config.RMQ.password)
logger = satlog.get_logger("SATELLITE")
return config, DB, credentials, logger
def test_dict_3(self):
obj = Objectifier({'a': 1, 'b': {'c': 2, 'd': {'e': [3, {'f': 4}]}}})
self.assertTrue('<Objectifier#dict' in repr(obj))
self.assertTrue('a=int' in repr(obj))
self.assertTrue('b=dict' in repr(obj))
self.assertEqual(obj.a, 1)
self.assertEqual(obj.b.c, 2)
self.assertEqual(obj.b.d.e[0], 3)
self.assertEqual(obj.b.d.e[1].f, 4)
def test_json_2(self):
people_json = """
{
"People": {
"Person": [
{ "Name": "Marc", "Age": 37 },
{ "Name": "Zach", "Age": 3 }
]
}
}
""".strip()
obj = Objectifier(people_json)
self.assertEqual(repr(obj), '<Objectifier#dict People=dict>')
self.assertEqual(obj.People.Person[0].Name, 'Marc')
def main():
config_selector= sys.argv[1]
config= json.loads(os.environ.get(config_selector))
os.environ['config']=os.environ.get(config_selector)
print(os.environ['config'])
config=Objectifier(config)
import releases
import aha_zen_adapter
import aha_zen_master_feature_importer
releases.main()
feature_update=aha_zen_adapter.main()
slack_sender.send_message('Features Sync happened @ '+str(datetime.now())+ ' logs @ ' +upload_to_storage(feature_update), config.slack_channel)
master_feature_update=aha_zen_master_feature_importer.main()
slack_sender.send_message('Master Features Sync happened @ '+str(datetime.now())+ ' logs @ ' +upload_to_storage(master_feature_update), config.slack_channel)
def get_token_by_session():
cookies = {
'session_id_sharebox':
'171.78.173.132-bfa1076e-d6e8-403a-a5c9-00e05785185d',
}
headers = {
'Connection': 'keep-alive',
'Pragma': 'no-cache',
'Cache-Control': 'no-cache',
'Accept': 'application/json, text/javascript, */*; q=0.01',
'X-Requested-With': 'XMLHttpRequest',
'User-Agent':
'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.88 Safari/537.36',
'Sec-Fetch-Site': 'same-origin',
'Sec-Fetch-Mode': 'cors',
'Referer':
'https://ec2-13-232-224-131.ap-south-1.compute.amazonaws.com/sharebox/token/generate_token',
'Accept-Encoding': 'gzip, deflate, br',
'Accept-Language': 'en-US,en;q=0.9,ta-IN;q=0.8,ta;q=0.7',
}
response = rq.get(
'https://ec2-13-232-224-131.ap-south-1.compute.amazonaws.com/sharebox/api/token',
headers=headers,
cookies=cookies,
verify=False)
if (response.status_code == 200):
token_data = json.loads(response.text)
token_data = json.loads(token_data)
token = token_data[0]['token']
config_data = json.load(open('testconfig.json'))
config_data['token'] = token
json.dump(config_data, open('testconfig.json', 'w+'))
global test_configs
test_configs = Objectifier(json.load(open('testconfig.json')))
return True
return False
def test_list_of_dicts_1(self):
obj = Objectifier([{'a': 1}, {'b': 2}])
self.assertEqual(repr(obj), '<Objectifier#list elements:2>')
self.assertEqual(obj[0].a, 1)
self.assertEqual(obj[1].b, 2)
def test_str_1(self):
obj = Objectifier('abc')
self.assertEqual(repr(obj), '<Objectifier#list elements:3>')
self.assertEqual(obj[0], 'a')
self.assertEqual(obj[1], 'b')
self.assertEqual(obj[2], 'c')
def test_list_of_strings(self):
obj = Objectifier(['a', 'b'])
self.assertEqual(repr(obj), '<Objectifier#list elements:2>')
self.assertEqual(obj[0], 'a')
self.assertEqual(obj[1], 'b')
class FacebookCall(object):
"""
Abstract object that helps create a clean object-based interface to the
Facebook Graph API.
"""
def __init__(self, token, endpoint_components, use_objectifier=False):
self.token = token
self.endpoint_components = endpoint_components
self.use_objectifier = use_objectifier
def __getattr__(self, k):
self.endpoint_components.append(k)
return FacebookCall(self.token, self.endpoint_components)
def __getitem__(self, k):
self.endpoint_components.append(str(k))
return FacebookCall(self.token, self.endpoint_components)
def __call__(self, method='GET', **kwargs):
endpoint = "/".join(self.endpoint_components)
if self.token is None:
kwargs.update(settings.ACCESS_TOKEN_PARAMS)
else:
kwargs['access_token'] = self.token
# Format dats with Unix timestamps instead of ISO-8601.
# kwargs['date_format'] = 'U'
encoded_params = urllib.urlencode(kwargs)
url = API_BASE + endpoint
if method == 'GET':
url += "?" + encoded_params
request = urllib2.Request(url)
elif method == 'POST':
request = urllib2.Request(url, encoded_params)
elif method == 'DELETE':
request = urllib2.Request(url, encoded_params)
request.get_method = lambda: 'DELETE'
try:
response = urllib2.urlopen(request)
except urllib2.HTTPError, e:
data = json.load(e)
if 'error' in data:
err = data['error']['type']
message = data['error']['message']
elif 'error_code' in data:
err = data['error_code']
message = data['error_msg']
raise FacebookError(message=message, err=err, code=e.code)
data = response.read()
if 'text/plain' in response.headers['content-type']:
if self.use_objectifier:
return Objectifier(cgi.parse_qsl(data))
else:
return dict(cgi.parse_qsl(data))
try:
if self.use_objectifier:
response_obj = Objectifier(data)
else:
response_obj = json.loads(data)
except ValueError:
return data
try:
if 'error' in response_obj:
if self.use_objectifier:
raise FacebookError(message=response_obj.error.message,
err=response_obj.error.type, code=response.code)
else:
raise FacebookError(message=response_obj['error']['message'],
err=response_obj['error']['type'], code=response['code'])
except TypeError:
# Response was probably a bool
pass
return response_obj
def test_list_of_ints(self):
obj = Objectifier([1, 2])
self.assertEqual(repr(obj), '<Objectifier#list elements:2>')
self.assertEqual(obj[0], 1)
self.assertEqual(obj[1], 2)
import aha_zen_adapter
import aha_zen_master_feature_importer
import slack_sender
import requests
from datetime import datetime
import sys
from objectifier import Objectifier
import json
import os
config = json.loads(os.environ.get('config'))
config = Objectifier(config)
import releases
def upload_to_storage(data):
rs = requests.post('https://funteam.herokuapp.com/insertresults',
data=str(data) + ' \n This Ran @ : ' +
str(datetime.now()))
if (rs.status_code == 200):
return 'https://funteam.herokuapp.com/getautomationresults?key=' + str(
rs.text)
else:
return ''
releases.main()
feature_update = aha_zen_adapter.main()
slack_sender.send_message(
'Features Sync happened @ ' + str(datetime.now()) + ' logs @ ' +
def test_dict_3(self):
obj = Objectifier({'a': 1, 'b': {'c': 2}})
self.assertEqual(repr(obj), '<Objectifier#dict a=int b=dict>')
self.assertEqual(obj.a, 1)
self.assertEqual(obj.b.c, 2)
def test_tuple_empty(self):
obj = Objectifier(())
self.assertEqual(repr(obj), '<Objectifier#list elements:0>')
import pytest
import transactions as txn
from objectifier import Objectifier
import json
from filehash import FileHash
from uuid import uuid4
import csv
from datetime import datetime
import os
import socket
config = Objectifier(json.load(open('Test/testconfig.json')))
class TestMilestone1():
def setup_method(self):
self.test_suite_name = os.environ['test_selector']
self.status = 'Fail'
self.status = 'Fail'
md5 = FileHash('sha1')
self.chksum = md5.hash_file('Test/Milestone1BTests.py')
location_of_config = config.TEST_DATA.milestone_1b.app_config_location
server_side_conf = json.load(open(location_of_config))
self.servers = server_side_conf['peers']
if (self.servers.__len__() != set(self.servers).__len__()):
assert 1 == 0, """The configured Peers in your config are not unique.
Each entry of the configured peer must be unique
{0}
""".format(self.servers)
raise """The configured Peers in your config are not unique.
Each entry of the configured peer must be unique
def test_str_empty(self):
obj = Objectifier('')
self.assertEqual(repr(obj), '<Objectifier#list elements:0>')
def test_objectify_books_xml(self):
obj = Objectifier(self.get_books_xml())
self.assertEqual(repr(obj), '<Objectifier#dict Books=dict>')
self.assertEqual(obj.Books.Items.Item[0].ISBN, '0321558235')
self.assertEqual(obj.Books.Items.Item[1].ISBN, '9780321558237')
def test_objectify_people_xml(self):
obj = Objectifier(self.get_people_xml())
self.assertEqual(repr(obj), '<Objectifier#dict People=dict>')
self.assertEqual(obj.People.Person[0].Name, 'Marc')
def test_tuple_1(self):
obj = Objectifier(('abc', 'def'))
self.assertEqual(repr(obj), '<Objectifier#list elements:2>')
self.assertEqual(obj[0], 'abc')
self.assertEqual(obj[1], 'def')
def generatediff(Aha_feature, Zen_issue, Git_issue=None, repo_id=None):
zen = Objectifier(Zen_issue)
Aha = Objectifier(Aha_feature)
changes = []
try:
if (Aha.workflow_status.name != getTranslationData(
map_data, zen.pipeline.name) and getTranslationData(
map_data, zen.pipeline.name) is not None):
changes.append({
'workflow_status': {
"name": getTranslationData(map_data, zen.pipeline.name)
}
})
if (zen.estimate is not None):
if (Aha.original_estimate != zen.estimate.value):
changes.append({'original_estimate':
zen.estimate.value}) # Update Estimate
if (zen.is_epic == False):
try:
Aha_Epic = Aha.master_feature.reference_num
except:
Aha_Epic = None
try:
Zen_Epic = ENDURANCE[str(EPIC_MAP[zen.id])]['aha_ref_num']
except:
Zen_Epic = None
try:
if (Aha_Epic != Zen_Epic and Zen_Epic is not None):
changes.append({'master_feature': Zen_Epic})
except:
logger.error(
"Error occured during processing Master feature update")
####Updating start and end date as per release date:
try:
if (Aha.release is not None
and config.features_source_of_release_date.lower()
== 'zenhub'):
if (Aha.release.start_date != Aha.start_date):
changes.append({'start_date': Aha.release.start_date})
if (Aha.release.release_date != Aha.due_date):
changes.append({'due_date': Aha.release.release_date})
elif (config.features_source_of_release_date.lower()
== 'github' and Git_issue is not None
and Git_issue.milestone is not None):
start_date_from_Zen = get_milestone_start_date_from_zen(
repo_id, Git_issue.milestone.number).split('T')[0]
due_date_from_Zen = str(Git_issue.milestone.due_on.date())
if (Aha.start_date != start_date_from_Zen):
changes.append({'start_date': start_date_from_Zen})
if (Aha.due_date != due_date_from_Zen):
changes.append({
'due_date':
str(Git_issue.milestone.due_on.date())
})
except:
logger.error(
"Error occured during start date and due date update")
############################################
###### Handle Releases######################
try:
Release_in_ZH = ZH_ISSUE_RELEASE_MAP[
zen.id] # ZH's Release ID for this Issue
Release_in_AHA = Aha.release.id # Aha's Release ID
Translation = ENDURANCE_RELEASES[Release_in_ZH]
if (Release_in_AHA != Translation['aha_release_id']):
changes.append({'release': Translation['aha_release_id']})
except KeyError:
logger.error(
"Unable to Find respective ZH release on the Endurance or the release is not mapped to the feature on ZH"
)
######################
except Exception as e:
logger.error("Error was encountered during update ")
return changes
def test_objectify_chegg_xml(self):
obj = Objectifier(self.get_chegg_xml())
self.assertEqual(repr(obj), '<Objectifier#dict CheggProductPricing=dict>')
self.assertEqual(obj.CheggProductPricing.Items.Item[0].BiblioId, '15536985')
self.assertEqual(obj.CheggProductPricing.Items.Item[1].BiblioId, '16432444')
import json
from objectifier import Objectifier
import requests as rq
import os
test_configs = Objectifier(json.load(open('testconfig.json')))
def upload_a_file(file, token=test_configs.token):
rs = rq.post(url=test_configs.SHAREBOX_URL + '/upload?token=' +
test_configs.token,
json=file,
verify=False)
return rs
def get_upload_status(file_id, token=test_configs.token):
rs = rq.get(url=test_configs.SHAREBOX_URL + '/upload?token=' +
test_configs.token + "&fileId=" + file_id,
verify=False)
return rs
def update_upload_status(data, token=test_configs.token):
rs = rq.put(url=test_configs.SHAREBOX_URL + '/upload?token=' +
test_configs.token,
data=data,
verify=False)
return rs
