def update_harvest_projects(request):
"""
Update all projects from harvest.
sequence 2/3
"""
response = []
h = Harvest( settings.HARVEST_ADDRESS, settings.HARVEST_USER, settings.HARVEST_PASS )
for hproject in h.projects():
existing = False
try:
p = Project.objects.get(harvest_id=hproject.id)
response.append({'harvest_id':hproject.id,'name':p.name,'status':'skipped'})
existing = True
except:
p = Project(harvest_id=hproject.id,name=hproject.name, notes=hproject.notes, client=Client.objects.get(harvest_id=hproject.client_id))
response.append({'harvest_id':hproject.id,'name':hproject.name,'status':'added'})
p.save()
if not existing:
# get task assignments per project
for assignment in hproject.task_assignments:
try:
t = TaskType.objects.get(harvest_id=assignment.task_id)
except:
t = TaskType(harvest_id=assignment.task_id)
t.save()
t.projects.add(p)
response.append({"tasktype":assignment.task_id, "created":True})
#time.sleep(5)
return HttpResponse(simplejson.dumps(response,indent=2, ensure_ascii=False),mimetype='application/json')
def setUp(self):
personal_access_token = PersonalAccessToken('ACCOUNT_NUMBER',
'PERSONAL_ACCESS_TOKEN')
self.harvest = Harvest('https://api.harvestapp.com/api/v2',
personal_access_token)
warnings.filterwarnings(
"ignore", category=ResourceWarning,
message="unclosed.*") # There's a bug in httpretty ATM.
httpretty.enable()
def __init__(self):
self.harvest = Harvest(scratch.url, scratch.username, scratch.password)
self.statusIcon = gtk.StatusIcon()
self.statusIcon.set_from_stock(gtk.STOCK_ABOUT)
self.statusIcon.set_visible(True)
self.statusIcon.set_tooltip("Hello World")
self.menu = gtk.Menu()
sep = gtk.SeparatorMenuItem()
self.menu.append(sep)
project_menu = gtk.Menu()
for client, projects in self.harvest.get_project_in_categories(
).iteritems():
client_item = gtk.MenuItem(client)
project_menu.append(client_item)
for project in projects:
task_menu = gtk.Menu()
p = gtk.MenuItem(project['name'])
for task in project['tasks']:
t = gtk.MenuItem(task['name'])
t.connect('activate', self.task_cb, self.menu, {
"project": project,
"task": task
})
task_menu.append(t)
p.set_submenu(task_menu)
project_menu.append(p)
sep = gtk.SeparatorMenuItem()
project_menu.append(sep)
self.menuItem = gtk.MenuItem('Projects')
self.menuItem.set_submenu(project_menu)
self.menu.append(self.menuItem)
self.menuItem = gtk.ImageMenuItem(gtk.STOCK_QUIT)
self.menuItem.connect('activate', self.quit_cb, self.statusIcon)
self.menu.append(self.menuItem)
self.statusIcon.connect('popup-menu', self.popup_menu_cb, self.menu)
self.statusIcon.set_visible(1)
gtk.main()
def get_client():
credentials = get_credentials()
app, email, password = (credentials[key]
for key in ("app", "email", "password"))
url = "https://{0}.harvestapp.com".format(app)
logger.info(msg="url is {0}".format(url))
return Harvest(url, email, password)
def get_timesheet():
try:
URI, USERNAME, PASSWORD = get_credentials()
except ConfigParser.NoSectionError:
URI, USERNAME, PASSWORD = set_credentials()
harvest = Harvest(URI, USERNAME, PASSWORD)
return harvest
def get_harvest_clients(request):
"""
Import new clients from harvest
sequence 1/3
"""
h = Harvest( settings.HARVEST_ADDRESS, settings.HARVEST_USER, settings.HARVEST_PASS )
response = []
for hclient in h.clients():
try:
c = Client.objects.get(harvest_id=hclient.id)
response.append({'harvest_id':hclient.id,'name':c.name,'status':'skipped'})
except:
c = Client(harvest_id=hclient.id,name=hclient.name, details=hclient.details)
response.append({'harvest_id':hclient.id,'name':hclient.name,'status':'added'})
c.save()
return HttpResponse(simplejson.dumps(response,indent=2, ensure_ascii=False),mimetype='application/json')
def __init__(self, path, url):
self.document = Document()
self.session = Session(name=url, root_url=url)
#self.session = Session('load_from_config=False')
self.session.use_doc('crawler_dashboard')
self.session.load_document(self.document)
#self.harvest_source = ColumnDataSource(data=dict())
#self.domain_relevant_source = ColumnDataSource(data=dict())
#self.domain_crawled_source = ColumnDataSource(data=dict())
#self.domain_frontier_source = ColumnDataSource(data=dict())
#self.handson_source = ColumnDataSource(data=dict())
#self.termite_source = ColumnDataSource(data=dict())
self.harvest = Harvest(path)
self.domain = Domain(path)
#handson = Handson()
#self.termite = Termite()
self.document.add(self.create_layout())
self.session.store_document(self.document)
def __init__(self):
self.document = Document()
self.session = Session()
self.session.use_doc('crawler_dashboard')
self.session.load_document(self.document)
#self.harvest_source = ColumnDataSource(data=dict())
#self.domain_relevant_source = ColumnDataSource(data=dict())
#self.domain_crawled_source = ColumnDataSource(data=dict())
#self.domain_frontier_source = ColumnDataSource(data=dict())
#self.handson_source = ColumnDataSource(data=dict())
#self.termite_source = ColumnDataSource(data=dict())
self.harvest = Harvest()
self.domain = Domain()
#handson = Handson()
self.termite = Termite()
self.document.add(self.create_layout())
self.session.store_document(self.document)
def update_harvest_tasks(request):
"""
Update all tasks from harvest.
This isn't particularly big or clever,
needs to watch out for api rate limit
(15 reqs per 40 secs)
sequence 3/3
"""
response = []
h = Harvest( settings.HARVEST_ADDRESS, settings.HARVEST_USER, settings.HARVEST_PASS )
for htask in h.tasks():
try:
t = TaskType.objects.get(harvest_id=htask.id)
t.name = htask.name
response.append({'harvest_id':htask.id,'name':htask.name,'status':'updated'})
except:
TaskType(harvest_id=htask.id,name=htask.name)
response.append({'harvest_id':htask.id,'name':htask.name,'status':'added'})
t.save()
return HttpResponse(simplejson.dumps(response,indent=2, ensure_ascii=False),mimetype='application/json')
class TestHarvest(unittest.TestCase):
def setUp(self):
self.harvest = Harvest(URL, USER, PWD)
def test_00_isinstance(self):
self.assertIsInstance(self.harvest,Harvest)
def test_01_connect_fail(self):
bad_harvest = Harvest(URL, "bogus_user","badpassword")
self.assertRaises(Exception,bad_harvest._request, URL + "/people")
def test_02_get_users(self):
for user in self.harvest.users():
self.assertIsInstance(user, User)
def test_03_get_invoices(self):
for inv in self.harvest.invoices():
self.assertIsInstance(inv, Invoice)
def test_04_get_clients(self):
for client in self.harvest.clients():
self.assertIsInstance(client, Client)
def worked_hours(request):
h = Harvest( os.environ['HARVEST_URL'], os.environ['HARVEST_USERNAME'], os.environ['HARVEST_PASSWORD'] )
users = (
{'firstname': 'Luca', 'lastname': 'Bravo', 'hours': 0},
{'firstname': 'Antonio', 'lastname': 'Molinari', 'hours': 0},
)
for u in users:
user = h.find_user( u['firstname'], u['lastname'] )
if user:
start = datetime.today()
end = start + timedelta(7)
total = 0
for entry in user.entries( start, end ):
total += entry.hours
u['hours'] = total
#return HttpResponse('Reports')
return render_to_response('worked_hours.html', {
'version': 1,
'users': users,
},
RequestContext(request)
)
def __init__(self):
self.harvest = Harvest(scratch.url, scratch.username, scratch.password)
self.statusIcon = gtk.StatusIcon()
self.statusIcon.set_from_stock(gtk.STOCK_ABOUT)
self.statusIcon.set_visible(True)
self.statusIcon.set_tooltip("Hello World")
self.menu = gtk.Menu()
sep = gtk.SeparatorMenuItem()
self.menu.append(sep)
project_menu = gtk.Menu()
for client, projects in self.harvest.get_project_in_categories().iteritems():
client_item = gtk.MenuItem(client)
project_menu.append(client_item)
for project in projects:
task_menu = gtk.Menu()
p = gtk.MenuItem(project['name'])
for task in project['tasks']:
t = gtk.MenuItem(task['name'])
t.connect('activate', self.task_cb, self.menu, {"project": project, "task": task})
task_menu.append(t)
p.set_submenu(task_menu)
project_menu.append(p)
sep = gtk.SeparatorMenuItem()
project_menu.append(sep)
self.menuItem = gtk.MenuItem('Projects')
self.menuItem.set_submenu(project_menu)
self.menu.append(self.menuItem)
self.menuItem = gtk.ImageMenuItem(gtk.STOCK_QUIT)
self.menuItem.connect('activate', self.quit_cb, self.statusIcon)
self.menu.append(self.menuItem)
self.statusIcon.connect('popup-menu', self.popup_menu_cb, self.menu)
self.statusIcon.set_visible(1)
gtk.main()
class AcheDashboard(object):
def __init__(self, crawl):
self.crawl = crawl
if self.crawl.crawler != "ache":
raise ValueError("Crawl must be using the Ache crawler.")
self.harvest = Harvest(crawl)
self.domain = Domain(crawl)
def get_harvest_plot(self):
# TODO: Remove Pokemon exception catching
try:
script, div = self.harvest.create()
except:
return [None, None]
return [script, div]
def get_domain_plot(self):
# TODO: Remove Pokemon exception catching
try:
script, div = self.domain.create()
except Exception:
return [None, None]
return [script, div]
def get_relevant_seeds(self):
# Converts string to StringIO to allow pandas to read it as a file
seeds = pd.read_csv(StringIO(self.domain.get_relevant_data()),
delimiter='\t',
header=None,
names=['url', 'timestamp'])
return seeds['url'].to_dict().values()
def get_plots(self):
harvest_plot = self.get_harvest_plot()
domain_plot = self.get_domain_plot()
if harvest_plot != [None, None]:
return {
'scripts': [domain_plot[0], harvest_plot[0]],
'divs': [domain_plot[1], harvest_plot[1]],
}
else:
return {
'scripts': None,
'divs': None,
}
def __init__(self):
self.document = Document()
self.session = Session()
self.session.use_doc('crawler_dashboard')
self.session.load_document(self.document)
#self.harvest_source = ColumnDataSource(data=dict())
#self.domain_relevant_source = ColumnDataSource(data=dict())
#self.domain_crawled_source = ColumnDataSource(data=dict())
#self.domain_frontier_source = ColumnDataSource(data=dict())
#self.handson_source = ColumnDataSource(data=dict())
#self.termite_source = ColumnDataSource(data=dict())
self.harvest = Harvest()
self.domain = Domain()
#handson = Handson()
self.termite = Termite()
self.document.add(self.create_layout())
self.session.store_document(self.document)
def __init__(self, path, url):
self.document = Document()
self.session = Session(name=url, root_url=url)
#self.session = Session('load_from_config=False')
self.session.use_doc('crawler_dashboard')
self.session.load_document(self.document)
#self.harvest_source = ColumnDataSource(data=dict())
#self.domain_relevant_source = ColumnDataSource(data=dict())
#self.domain_crawled_source = ColumnDataSource(data=dict())
#self.domain_frontier_source = ColumnDataSource(data=dict())
#self.handson_source = ColumnDataSource(data=dict())
#self.termite_source = ColumnDataSource(data=dict())
self.harvest = Harvest(path)
self.domain = Domain(path)
#handson = Handson()
#self.termite = Termite()
self.document.add(self.create_layout())
self.session.store_document(self.document)
class AcheDashboard(object):
def __init__(self, crawl):
self.crawl = crawl
if self.crawl.crawler != "ache":
raise ValueError("Crawl must be using the Ache crawler.")
self.harvest = Harvest(crawl)
self.domain = Domain(crawl)
def get_harvest_plot(self):
# TODO: Remove Pokemon exception catching
try:
script, div = self.harvest.create()
except:
return [None, None]
return [script, div]
def get_domain_plot(self):
# TODO: Remove Pokemon exception catching
try:
script, div = self.domain.create()
except Exception:
return [None, None]
return [script, div]
def get_relevant_seeds(self):
# Converts string to StringIO to allow pandas to read it as a file
seeds = pd.read_csv(StringIO(self.domain.get_relevant_data()),
delimiter='\t', header=None,
names=['url', 'timestamp'])
return seeds['url'].to_dict().values()
def get_plots(self):
harvest_plot = self.get_harvest_plot()
domain_plot = self.get_domain_plot()
return {
'scripts': [domain_plot[0], harvest_plot[0]],
'divs': [domain_plot[1], harvest_plot[1]],
}
def __init__(self):
self.load_config()
self.harvest = Harvest(self.url, self.email, self.password)
if self.oncall:
self.hours_worked = random.randrange(self.oncall_min_hours, self.oncall_max_hours)
self.work_sat = True
self.work_sun = True
else:
self.hours_worked = random.randrange(self.min_hours, self.max_hours)
self.work_sat = random.randrange(0,2)
self.work_sun = random.randrange(0,2)
self.num_days_worked = 5
if self.work_sat:
self.num_days_worked += 1
if self.work_sun:
self.num_days_worked += 1
if self.oncall:
self.daily_incident_hours = floor((self.hours_worked * self.oncall_incident_percent) / self.num_days_worked)
self.daily_automation_hours = floor((self.hours_worked * (1 - self.oncall_incident_percent)) / self.num_days_worked)
else:
self.daily_incident_hours = floor((self.hours_worked * self.incident_percent) / self.num_days_worked)
self.daily_automation_hours = floor((self.hours_worked * (1 - self.incident_percent)) / self.num_days_worked)
def __init__(self, num_harvests=3):
self.num_harvests = num_harvests
self.harvests = [Harvest(i) for i in range(num_harvests)]
self.cost = sys.maxsize
import json
from harvest import Harvest
harvester = Harvest()
# Official ABI copied verbatim from the ETH Wiki at https://github.com/ethereum/wiki/wiki/Contract-ERC20-ABI
officialERC20Abi = '''[
{
"constant": true,
"inputs": [],
"name": "name",
"outputs": [
{
"name": "",
"type": "string"
}
],
"payable": false,
"stateMutability": "view",
"type": "function"
},
{
"constant": false,
"inputs": [
{
"name": "_spender",
"type": "address"
},
{
"name": "_value",
"type": "uint256"
class DashBoard(object):
def __init__(self, path, url):
self.document = Document()
self.session = Session(name=url, root_url=url)
#self.session = Session('load_from_config=False')
self.session.use_doc('crawler_dashboard')
self.session.load_document(self.document)
#self.harvest_source = ColumnDataSource(data=dict())
#self.domain_relevant_source = ColumnDataSource(data=dict())
#self.domain_crawled_source = ColumnDataSource(data=dict())
#self.domain_frontier_source = ColumnDataSource(data=dict())
#self.handson_source = ColumnDataSource(data=dict())
#self.termite_source = ColumnDataSource(data=dict())
self.harvest = Harvest(path)
self.domain = Domain(path)
#handson = Handson()
#self.termite = Termite()
self.document.add(self.create_layout())
self.session.store_document(self.document)
def render(self):
self.create_layout()
self.document.add(self.layout)
self.update_data()
def create_layout(self):
#button = Button(label="Randomize data", type="success")
#button.on_click(update_data)
#top_panel = HBox(children=[button, self.harvest.plot, self.harvest.rate_plot])
top_panel = HBox(children=[self.harvest.plot, self.harvest.rate_plot])
domains = VBox(children=[
self.domain.sort_relevant_plot, self.domain.sort_crawled_plot,
self.domain.sort_frontier_plot
],
width=200)
#middle_panel = HBox(children=[domains, handson.plot])
middle_panel = HBox(children=[domains])
layout = VBox(children=[top_panel, middle_panel])
self.layout = layout
return layout
def update_data(self):
self.harvest.source = self.harvest.update_source()
self.domain.sort_relevant_source, self.domain.sort_crawled_source, self.domain.sort_frontier_source = self.domain.update_source(
)
#self.termite.data, self.termite.source = self.termite.update_source()
#self.session.store_objects(ds)
self.session.store_document(self.document)
def run(self, poll_interval=0.5):
#link = self.session.object_link(self.document.context)
#print("Please visit %s to see the plots (press ctrl-C to exit)" % link)
try:
while True:
self.update_data()
self.session.load_document(self.document)
time.sleep(poll_interval)
except KeyboardInterrupt:
print()
except ConnectionError:
print("Connection to bokeh-server was terminated")
class TestHarvest(unittest.TestCase):
def setUp(self):
personal_access_token = PersonalAccessToken('ACCOUNT_NUMBER',
'PERSONAL_ACCESS_TOKEN')
self.harvest = Harvest('https://api.harvestapp.com/api/v2',
personal_access_token)
warnings.filterwarnings(
"ignore", category=ResourceWarning,
message="unclosed.*") # There's a bug in httpretty ATM.
httpretty.enable()
def teardown(self):
httpretty.reset()
httpretty.disable()
def test_HTTP_500(self):
user_1782884_dict = {
"id":
1782884,
"first_name":
"Bob",
"last_name":
"Powell",
"email":
"*****@*****.**",
"telephone":
"",
"timezone":
"Mountain Time (US & Canada)",
"has_access_to_all_future_projects":
False,
"is_contractor":
False,
"is_admin":
True,
"is_project_manager":
False,
"can_see_rates":
True,
"can_create_projects":
True,
"can_create_invoices":
True,
"is_active":
True,
"created_at":
"2017-06-26T20:41:00Z",
"updated_at":
"2017-06-26T20:42:25Z",
"weekly_capacity":
126000,
"default_hourly_rate":
100.0,
"cost_rate":
75.0,
"roles": ["Founder", "CEO"],
"avatar_url":
"https://cache.harvestapp.com/assets/profile_images/allen_bradley_clock_tower.png?1498509661"
}
me = from_dict(data_class=User, data=user_1782884_dict)
# get_currently_authenticated_user
httpretty.register_uri(httpretty.GET,
"https://api.harvestapp.com/api/v2/users/me",
body=json.dumps(user_1782884_dict),
status=500)
with self.assertRaises(HarvestError) as context:
self.harvest.get_currently_authenticated_user()
self.assertTrue('There was a server error for your request.' in str(
context.exception))
httpretty.reset()
def test_HTTP_429(self):
user_1782884_dict = {
"id":
1782884,
"first_name":
"Bob",
"last_name":
"Powell",
"email":
"*****@*****.**",
"telephone":
"",
"timezone":
"Mountain Time (US & Canada)",
"has_access_to_all_future_projects":
False,
"is_contractor":
False,
"is_admin":
True,
"is_project_manager":
False,
"can_see_rates":
True,
"can_create_projects":
True,
"can_create_invoices":
True,
"is_active":
True,
"created_at":
"2017-06-26T20:41:00Z",
"updated_at":
"2017-06-26T20:42:25Z",
"weekly_capacity":
126000,
"default_hourly_rate":
100.0,
"cost_rate":
75.0,
"roles": ["Founder", "CEO"],
"avatar_url":
"https://cache.harvestapp.com/assets/profile_images/allen_bradley_clock_tower.png?1498509661"
}
me = from_dict(data_class=User, data=user_1782884_dict)
# get_currently_authenticated_user
httpretty.register_uri(httpretty.GET,
"https://api.harvestapp.com/api/v2/users/me",
body=json.dumps(user_1782884_dict),
status=429)
with self.assertRaises(HarvestError) as context:
self.harvest.get_currently_authenticated_user()
self.assertTrue(
'Your request has been throttled.' in str(context.exception))
httpretty.reset()
def test_HTTP_422(self):
user_1782884_dict = {
"id":
1782884,
"first_name":
"Bob",
"last_name":
"Powell",
"email":
"*****@*****.**",
"telephone":
"",
"timezone":
"Mountain Time (US & Canada)",
"has_access_to_all_future_projects":
False,
"is_contractor":
False,
"is_admin":
True,
"is_project_manager":
False,
"can_see_rates":
True,
"can_create_projects":
True,
"can_create_invoices":
True,
"is_active":
True,
"created_at":
"2017-06-26T20:41:00Z",
"updated_at":
"2017-06-26T20:42:25Z",
"weekly_capacity":
126000,
"default_hourly_rate":
100.0,
"cost_rate":
75.0,
"roles": ["Founder", "CEO"],
"avatar_url":
"https://cache.harvestapp.com/assets/profile_images/allen_bradley_clock_tower.png?1498509661"
}
me = from_dict(data_class=User, data=user_1782884_dict)
# get_currently_authenticated_user
httpretty.register_uri(httpretty.GET,
"https://api.harvestapp.com/api/v2/users/me",
body=json.dumps(user_1782884_dict),
status=422)
with self.assertRaises(HarvestError) as context:
self.harvest.get_currently_authenticated_user()
self.assertTrue('There were errors processing your request.' in str(
context.exception))
httpretty.reset()
def test_HTTP_404(self):
user_1782884_dict = {
"id":
1782884,
"first_name":
"Bob",
"last_name":
"Powell",
"email":
"*****@*****.**",
"telephone":
"",
"timezone":
"Mountain Time (US & Canada)",
"has_access_to_all_future_projects":
False,
"is_contractor":
False,
"is_admin":
True,
"is_project_manager":
False,
"can_see_rates":
True,
"can_create_projects":
True,
"can_create_invoices":
True,
"is_active":
True,
"created_at":
"2017-06-26T20:41:00Z",
"updated_at":
"2017-06-26T20:42:25Z",
"weekly_capacity":
126000,
"default_hourly_rate":
100.0,
"cost_rate":
75.0,
"roles": ["Founder", "CEO"],
"avatar_url":
"https://cache.harvestapp.com/assets/profile_images/allen_bradley_clock_tower.png?1498509661"
}
me = from_dict(data_class=User, data=user_1782884_dict)
# get_currently_authenticated_user
httpretty.register_uri(httpretty.GET,
"https://api.harvestapp.com/api/v2/users/me",
body=json.dumps(user_1782884_dict),
status=404)
with self.assertRaises(HarvestError) as context:
self.harvest.get_currently_authenticated_user()
self.assertTrue('The object you requested can’t be found.' in str(
context.exception))
httpretty.reset()
def test_HTTP_403(self):
user_1782884_dict = {
"id":
1782884,
"first_name":
"Bob",
"last_name":
"Powell",
"email":
"*****@*****.**",
"telephone":
"",
"timezone":
"Mountain Time (US & Canada)",
"has_access_to_all_future_projects":
False,
"is_contractor":
False,
"is_admin":
True,
"is_project_manager":
False,
"can_see_rates":
True,
"can_create_projects":
True,
"can_create_invoices":
True,
"is_active":
True,
"created_at":
"2017-06-26T20:41:00Z",
"updated_at":
"2017-06-26T20:42:25Z",
"weekly_capacity":
126000,
"default_hourly_rate":
100.0,
"cost_rate":
75.0,
"roles": ["Founder", "CEO"],
"avatar_url":
"https://cache.harvestapp.com/assets/profile_images/allen_bradley_clock_tower.png?1498509661"
}
me = from_dict(data_class=User, data=user_1782884_dict)
# get_currently_authenticated_user
httpretty.register_uri(httpretty.GET,
"https://api.harvestapp.com/api/v2/users/me",
body=json.dumps(user_1782884_dict),
status=403)
with self.assertRaises(HarvestError) as context:
self.harvest.get_currently_authenticated_user()
self.assertTrue(
'The object you requested was found but you don’t have authorization to perform your request.'
in str(context.exception))
httpretty.reset()
def test_assemble_query_string_bool_lower(self):
target_query_string = "is_active=false&is_billed=true&page=1&per_page=100"
key_words = {"is_active": False, "is_billed": True}
query_string = assemble_query_string(**key_words)
self.assertEqual(query_string, target_query_string)
def test_assemble_query_string_page(self):
target_query_string = "page=10&per_page=100"
key_words = {'page': 10}
query_string = assemble_query_string(**key_words)
self.assertEqual(query_string, target_query_string)
def test_assemble_query_string_per_page(self):
target_query_string = "per_page=10&page=1"
key_words = {'per_page': 10}
query_string = assemble_query_string(**key_words)
self.assertEqual(query_string, target_query_string)
def __init__(self, crawl):
self.crawl = crawl
if self.crawl.crawler != "ache":
raise ValueError("Crawl must be using the Ache crawler.")
self.harvest = Harvest(crawl)
self.domain = Domain(crawl)
import re
import json
import requests
from harvest import Harvest
harvester = Harvest()
# RAW text of ABIs for sorting and hashing
abiUrls = []
abiUrls.append(
"https://raw.githubusercontent.com/tpmccallum/test_endpoint2/master/erc20abi.txt"
)
abiUrls.append(
"https://raw.githubusercontent.com/tpmccallum/test_endpoint2/master/erc20Abi2.txt"
)
def listAbiLength(_abi):
print("The ABI has " + str(len(_abi)) + " items.")
print("\n")
# List outputs
def listWholeKeysAndValues(_abi):
for listItem in _abi:
for k, v in listItem.items():
print(str(k) + ": " + str(v))
print("\n")
print("\n")
# List types
import re
import json
import time
import requests
from harvest import Harvest
from web3.auto import w3
harvester = Harvest()
abiUrl1 = "https://raw.githubusercontent.com/Uniswap/contracts-vyper/master/abi/uniswap_exchange.json"
abiData1 = requests.get(abiUrl1).content
abiData1JSON = json.loads(abiData1)
theDeterministicHash1 = harvester.shaAnAbi(abiData1JSON)
print("The Uniswap exchange contract ABI SHA is: " + theDeterministicHash1)
cleanedAndOrderedAbiText1 = harvester.cleanAndConvertAbiToText(abiData1JSON)
data2 = {}
data2['indexInProgress'] = "false"
data2['epochOfLastUpdate'] = int(time.time())
data2['abi'] = cleanedAndOrderedAbiText1
#harvester.es.index(index=harvester.abiIndex, id=theDeterministicHash1, body=data2)
# Get the events
abi = [{
"name":
"NewExchange",
"inputs": [{
"type": "address",
"name": "token",
"indexed": True
}, {
import time
#import simplejson as json
import json
import mysql.connector
from mysql.connector import errorcode
#import pprint
# Harvest Setup
harvest_creds = {'uri': os.getenv("HARVEST_URI"),
'email': os.getenv("HARVEST_EMAIL"),
'password': os.getenv("HARVEST_PASSWORD")}
URI = harvest_creds['uri']
EMAIL = harvest_creds['email']
PASS = harvest_creds['password']
h = Harvest(URI,EMAIL,PASS)
# Var Setup
user_hours={}
user_names={}
project_hours={}
timesheet_punches={}
email_html=""
# Yesterday - adjust to your liking
end = datetime.today().replace( hour=0, minute=0, second=0 )
start = end + timedelta(-1)
#mysql_creds = json.loads(open('mysql.json').read())
#mysql_creds = json.loads(os.getenv("MYSQL"))
mysql_creds = {'user': os.getenv("MYSQL_USER"),
import re
import json
import time
import math
import requests
from harvest import Harvest
import elasticsearch.helpers
from flask import Flask, jsonify, request
harvester = Harvest()
app = Flask(__name__)
def logApi(_request):
data = {}
timestamp = math.floor(time.time())
data["timestamp"] = timestamp
callingIp = _request.headers.get('X-Forwarded-For', request.remote_addr)
data["callingIp"] = callingIp
endpoint = _request.endpoint
data["endpoint"] = endpoint
harvester.processApiAccessLog(data)
@app.route("/api/get_block_interval", methods=['GET', 'POST'])
def get_block_interval():
blockInterval = harvester.getBlockInterval()
logApi(request)
return jsonify(blockInterval)
if args.date == 'today':
min_date = today
elif re.match(r'[+-][0-9]*$', args.date):
min_date = today + timedelta(int(args.date))
elif re.match(r'[0-9]{8}$', args.date):
min_date = datetime.strptime(args.date, '%Y%m%d')
else:
print('error: unrecognized date format: {0}'.format(args.date))
exit(1)
else:
min_date = today - timedelta(60)
searchterm = args.search
harvest = Harvest(
config.get('harvest', 'url'),
config.get('harvest', 'user'),
config.get('harvest', 'pass'))
entries = reduce(lambda l1, l2: l1 + l2,
[harvest.get_day(
day_of_the_year=day, year=year)['day_entries']
for day, year in harvest_date_range(min_date, today)])
matches = filter(lambda entry: searchterm in entry['notes'], entries)
total_hours = sum([entry['hours'] for entry in matches])
pprint(matches)
print('Total hours: ' + str(total_hours))
old_tasks = set([entry['task'] for entry in matches])
print('Booked tasks: {0}.'.format(', '.join(old_tasks)))
if args.new_task:
import os
from datetime import datetime, timedelta
from harvest import Harvest, HarvestError
from spreadsheets_util import *
h = Harvest( os.environ['HARVEST_URL'], os.environ['HARVEST_EMAIL'], os.environ['HARVEST_PASSWORD'] )
end = datetime.today()
start = end - timedelta(720) # 2 Years in the past
gd_client = gdata.spreadsheet.service.SpreadsheetsService()
gd_client.email = os.environ['GDOCS_EMAIL']
gd_client.password = os.environ['GDOCS_PASSWORD']
gd_client.source = 'opengeo-solutions_dashboard-1'
gd_client.ProgrammaticLogin()
#gd_client.debug = True
key = '0AgQ7XY0Atfx5dERpQ2VDcEtGUVpOQVRvVng4Tm1DMGc'
worksheet = 'od6'
def update_project(row, name, client, total, billable, non_billable):
CellsUpdateAction(gd_client, key, worksheet, row, 1, name)
CellsUpdateAction(gd_client, key, worksheet, row, 2, client)
CellsUpdateAction(gd_client, key, worksheet, row, 3, str(total))
CellsUpdateAction(gd_client, key, worksheet, row, 4, str(billable))
CellsUpdateAction(gd_client, key, worksheet, row, 5, str(non_billable))
project_count = 1
for project in h.projects():
total = 0
tasks = {}
import re
import json
import time
import eth_abi
import requests
from itertools import chain
from harvest import Harvest
# import functools
# from web3.contract import get_event_data
harvester = Harvest()
latestBlockNumber = harvester.web3.eth.getBlock('latest').number
# Iterate through the individual blocks looking for a transaction which involves event log emit
# TESTING SINGLE EVENT AT BLOCK 6328976
while True:
latestBlockNumber = harvester.web3.eth.getBlock('latest').number
for b in range(latestBlockNumber - 10, latestBlockNumber):
transactionCount = harvester.web3.eth.getBlockTransactionCount(b)
#transactionCount = harvester.web3.eth.getBlockTransactionCount(6509882)
if (transactionCount >= 1):
for singleTransactionInt in range(0, transactionCount):
transaction = harvester.web3.eth.getTransactionByBlock(
b, singleTransactionInt)
# transaction = harvester.web3.eth.getTransactionByBlock(6509882, singleTransactionInt)
transactionHash = transaction.hash
# Check to see if this TxHash is indexed
transactionReceipt = harvester.web3.eth.getTransactionReceipt(
transaction.hash)
transactionLogs = transactionReceipt.logs
def sync_hours_for_date(password, date_str):
in_date = strptime(date_str, '%d/%m/%Y')
doy = in_date.tm_yday
print "Syncing %d/%d/%d (%s)" % (in_date.tm_mday, in_date.tm_mon, in_date.tm_year, doy)
h = Harvest(HARVEST_URL_ROOT, HARVEST_USER_EMAIL, password)
rm = redmine.Redmine(REDMINE_URL_ROOT, key=REDMINE_API_KEY)
rm_date = date(*in_date[:3])
rm_users = rm.users
rm_user = rm_users[6]
day = h.get_day(doy, 2016)
activities = rm.time_entry_activities
development = None
meeting = None
proj_man = None
for activity in activities:
if activity.name == 'Development':
development = activity
elif activity.name == 'Meeting':
meeting = activity
if activity.name == 'Project Management':
proj_man = activity
if development is None or meeting is None or proj_man is None:
raise ValueError('Cant find all activity types')
at_map = {'Coding': development, 'Meeting': meeting, 'Project Management': proj_man}
for day_entry in day['day_entries']:
if day_entry['client'] != CLIENT_NAME:
continue
activity = at_map.get(day_entry['task'])
if not activity:
print "Can't map activity '%s'" % day_entry['task']
continue
if day_entry['notes'] is not None and 'logged' in day_entry['notes'].lower():
continue
elif day_entry['notes'] is None:
day_entry['notes'] = ''
if activity == development or day_entry['notes'].startswith('#'):
if day_entry['notes'].startswith('#'):
try:
ticket_id = int(day_entry['notes'][1:])
except (TypeError, ValueError):
print "Can't parse ID on %s" % day_entry['notes']
continue
entry_notes = ''
else:
print "Not logging {}".format(day_entry['notes'])
continue
issue = rm.issues[ticket_id]
try:
te = rm.time_entries.new(issue=issue, activity=activity, spent_on=rm_date.strftime('%Y-%m-%d'), user=rm_user, hours=day_entry['hours'], comments=entry_notes)
except Exception as e:
print e.read()
return
if day_entry['notes'] == '':
day_entry['notes'] = 'Logged'
else:
day_entry['notes'] += ' Logged'
try:
h.update(day_entry['id'], day_entry)
except Exception as e:
print "Failed to save time for %d. Delete manually" % ticket_id
return
print "Logged %02f hours for #%d" % (day_entry['hours'], ticket_id)
import re
import json
import requests
from harvest import Harvest
harvester = Harvest()
# RAW text of ABIs for sorting and hashing
abiUrls = []
abiUrls.append(
"https://raw.githubusercontent.com/tpmccallum/mixed_ordered_cmt_abis_for_testing/master/vanilla.txt"
)
abiUrls.append(
"https://raw.githubusercontent.com/tpmccallum/mixed_ordered_cmt_abis_for_testing/master/increaseApproval_inputs_reversed.txt"
)
abiUrls.append(
"https://raw.githubusercontent.com/tpmccallum/mixed_ordered_cmt_abis_for_testing/master/random.txt"
)
outputHashes = []
for singleAbiUrl in abiUrls:
print("Processing: " + singleAbiUrl)
singleAbiString = requests.get(singleAbiUrl).content
singleAbiJSON = json.loads(singleAbiString)
singleHash = harvester.shaAnAbi(singleAbiJSON)
outputHashes.append(singleHash)
print("Output hashes are as follows, these should all be exactly the same")
for singleHash in outputHashes:
print(singleHash)
import json
import requests
from harvest import Harvest
harvester = Harvest()
source = '''{
"TxHash": "0x233e6634b6e713fae69799305794cb679c9a3a89181a3f391d5971df5beaf7d6",
"abiShaList": [
"0x50d9155267cb10b61afba8628bdc6181de9af836918d7987c2c421512256ab82"
],
"blockNumber": 4964970,
"creator": "0xb156929f55c48265607fd87b9e2d6fcceee6726a",
"contractAddress": "0xA362e5Bc203AEA01C398B74aA6e36d144E96712f",
"functionDataList": {
"0": [
{
"functionDataId": "0x3a851ba992dd5464cc247cb21fb0a92a11dd417fc2a028fcbede22ef693efc6d",
"functionData": {
"name": "Arcblock Token",
"totalSupply": "1000000000000000000000000000",
"decimals": "18",
"symbol": "ABT"
},
"uniqueAbiAndAddressHash": "0x54040994221542e1ce9fdfc9c7396d02de07a2b7df065865b8a404a5498c6fef"
}
]
},
"requiresUpdating": "yes",
"quality": "50",
"indexInProgress": "false"
}'''
class Timecard():
def __init__(self):
self.load_config()
self.harvest = Harvest(self.url, self.email, self.password)
if self.oncall:
self.hours_worked = random.randrange(self.oncall_min_hours, self.oncall_max_hours)
self.work_sat = True
self.work_sun = True
else:
self.hours_worked = random.randrange(self.min_hours, self.max_hours)
self.work_sat = random.randrange(0,2)
self.work_sun = random.randrange(0,2)
self.num_days_worked = 5
if self.work_sat:
self.num_days_worked += 1
if self.work_sun:
self.num_days_worked += 1
if self.oncall:
self.daily_incident_hours = floor((self.hours_worked * self.oncall_incident_percent) / self.num_days_worked)
self.daily_automation_hours = floor((self.hours_worked * (1 - self.oncall_incident_percent)) / self.num_days_worked)
else:
self.daily_incident_hours = floor((self.hours_worked * self.incident_percent) / self.num_days_worked)
self.daily_automation_hours = floor((self.hours_worked * (1 - self.incident_percent)) / self.num_days_worked)
def load_config(self):
with open(config_file, 'r') as fd:
config = yaml.load(fd)
self.url = config['url']
self.email = config['email']
self.password = config['password']
self.oncall = config['oncall']
self.min_hours = config['min_hours']
self.max_hours = config['max_hours']
self.oncall_min_hours = config['oncall_min_hours']
self.oncall_max_hours = config['oncall_max_hours']
self.incident_project_id = config['incident_project_id']
self.incident_task_id = config['incident_task_id']
self.automation_project_id = config['automation_project_id']
self.automation_task_id = config['automation_task_id']
self.incident_percent = config['incident_percent']
self.oncall_incident_percent = config['oncall_incident_percent']
def load_weeks(self):
with open('weeks.yaml', 'r') as fd:
self.weeks = yaml.load(fd)
def build_weeks(self):
self.timecard = []
for week in self.weeks:
ret = {}
if self.weeks[week]['oncall']:
self.oncall = True
else:
self.oncall = False
ret['Sunday'] = {'date': datetime.strftime(self.weeks[week]['start_date'], '%Y-%m-%d')}
ret['Monday'] = {'date': datetime.strftime(self.weeks[week]['start_date'] + timedelta(days=1), '%Y-%m-%d')}
ret['Tuesday'] = {'date': datetime.strftime(self.weeks[week]['start_date'] + timedelta(days=2), '%Y-%m-%d')}
ret['Wednesday'] = {'date': datetime.strftime(self.weeks[week]['start_date'] + timedelta(days=3), '%Y-%m-%d')}
ret['Thursday'] = {'date': datetime.strftime(self.weeks[week]['start_date'] + timedelta(days=4), '%Y-%m-%d')}
ret['Friday'] = {'date': datetime.strftime(self.weeks[week]['start_date'] + timedelta(days=5), '%Y-%m-%d')}
ret['Saturday'] = {'date': datetime.strftime(self.weeks[week]['start_date'] + timedelta(days=6), '%Y-%m-%d')}
week_hours = self.build_week()
for day in week_hours:
ret[day]['incident_hours'] = week_hours[day]['incident_hours']
ret[day]['automation_hours'] = week_hours[day]['automation_hours']
self.timecard.append(ret)
def get_hours_worked(self):
incident_hours_worked = random.randrange((self.daily_incident_hours - 2), (self.daily_incident_hours + 2))
automation_hours_worked = random.randrange((self.daily_automation_hours - 2), (self.daily_automation_hours + 2))
return [incident_hours_worked, automation_hours_worked]
def build_week(self):
days = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
week = {}
for day in days:
if day == 'Sunday':
if self.work_sun:
incident_hours, automation_hours = self.get_hours_worked()
week[day] = {'incident_hours': incident_hours, 'automation_hours': automation_hours}
if day == 'Saturday':
if self.work_sat:
incident_hours, automation_hours = self.get_hours_worked()
week[day] = {'incident_hours': incident_hours, 'automation_hours': automation_hours}
else:
incident_hours, automation_hours = self.get_hours_worked()
week[day] = {'incident_hours': incident_hours, 'automation_hours': automation_hours}
return week
def post_timecard(self):
for week in self.timecard:
for day in week:
if 'incident_hours' in week[day]:
if week[day]['incident_hours'] != 0:
data = {'spent_at': week[day]['date'],
'hours': week[day]['incident_hours'],
'project_id': self.incident_project_id,
'task_id': self.incident_task_id}
response = self.harvest.add(data)
print json.dumps(response(), indent=4)
if 'automation_hours' in week[day]:
if week[day]['automation_hours'] != 0:
data = {'spent_at': week[day]['date'],
'hours': week[day]['automation_hours'],
'project_id': self.automation_project_id,
'task_id': self.automation_task_id}
response = self.harvest.add(data)
print json.dumps(response(), indent=4)
class HarvestNotifier:
timer_running = False
current_project = None
current_task = None
def __init__(self):
self.harvest = Harvest(scratch.url, scratch.username, scratch.password)
self.statusIcon = gtk.StatusIcon()
self.statusIcon.set_from_stock(gtk.STOCK_ABOUT)
self.statusIcon.set_visible(True)
self.statusIcon.set_tooltip("Hello World")
self.menu = gtk.Menu()
sep = gtk.SeparatorMenuItem()
self.menu.append(sep)
project_menu = gtk.Menu()
for client, projects in self.harvest.get_project_in_categories(
).iteritems():
client_item = gtk.MenuItem(client)
project_menu.append(client_item)
for project in projects:
task_menu = gtk.Menu()
p = gtk.MenuItem(project['name'])
for task in project['tasks']:
t = gtk.MenuItem(task['name'])
t.connect('activate', self.task_cb, self.menu, {
"project": project,
"task": task
})
task_menu.append(t)
p.set_submenu(task_menu)
project_menu.append(p)
sep = gtk.SeparatorMenuItem()
project_menu.append(sep)
self.menuItem = gtk.MenuItem('Projects')
self.menuItem.set_submenu(project_menu)
self.menu.append(self.menuItem)
self.menuItem = gtk.ImageMenuItem(gtk.STOCK_QUIT)
self.menuItem.connect('activate', self.quit_cb, self.statusIcon)
self.menu.append(self.menuItem)
self.statusIcon.connect('popup-menu', self.popup_menu_cb, self.menu)
self.statusIcon.set_visible(1)
gtk.main()
def task_cb(self, widget, event, data=None):
if self.timer_running:
self.menu.remove(self.menu.get_children()[0])
self.harvest.timer_toggle(data['project'], data['task'])
# button showing what timer we're running
timer = gtk.MenuItem(data['project']['name'] + " - " +
data['task']['name'])
timer.connect('activate', self.timer_click_cb, self.menu, data)
self.menu.prepend(timer)
self.timer_running = True
self.current_project = data['project']
self.current_task = data['task']
def timer_click_cb(self, widget, event, data=None):
""" Event triggered if a timer is running and someone clicks on the timer """
if not self.timer_running:
# we shouldn't get here, but just in case
return
self.harvest.timer_toggle(data['project'], data['task'])
# remove the timer button
self.menu.remove(widget)
self.timer_running = False
self.current_project = None
self.current_task = None
def quit_cb(self, widget, data=None):
if self.timer_running:
self.harvest.timer_toggle(self.current_project, self.current_task)
gtk.main_quit()
def popup_menu_cb(self, widget, button, time, data=None):
if button == 3:
if data:
data.show_all()
data.popup(None, None, gtk.status_icon_position_menu, 3, time,
self.statusIcon)
class DashBoard(object):
def __init__(self):
self.document = Document()
self.session = Session()
self.session.use_doc('crawler_dashboard')
self.session.load_document(self.document)
#self.harvest_source = ColumnDataSource(data=dict())
#self.domain_relevant_source = ColumnDataSource(data=dict())
#self.domain_crawled_source = ColumnDataSource(data=dict())
#self.domain_frontier_source = ColumnDataSource(data=dict())
#self.handson_source = ColumnDataSource(data=dict())
#self.termite_source = ColumnDataSource(data=dict())
self.harvest = Harvest()
self.domain = Domain()
#handson = Handson()
self.termite = Termite()
self.document.add(self.create_layout())
self.session.store_document(self.document)
def render(self):
self.create_layout()
self.document.add(self.layout)
self.update_data()
def create_layout(self):
#button = Button(label="Randomize data", type="success")
#button.on_click(update_data)
#top_panel = HBox(children=[button, self.harvest.plot, self.harvest.rate_plot])
top_panel = HBox(children=[self.harvest.plot, self.harvest.rate_plot])
domains = VBox(children=[self.domain.sort_relevant_plot, self.domain.sort_crawled_plot, self.domain.sort_frontier_plot], width=200)
#middle_panel = HBox(children=[domains, handson.plot])
middle_panel = HBox(children=[domains])
layout = VBox(children=[top_panel, middle_panel, self.termite.plot])
self.layout = layout
return layout
def update_data(self):
self.harvest.source = self.harvest.update_source()
self.domain.sort_relevant_source, self.domain.sort_crawled_source, self.domain.sort_frontier_source = self.domain.update_source()
self.termite.data, self.termite.source = self.termite.update_source()
#self.session.store_objects(ds)
self.session.store_document(self.document)
def run(self, poll_interval=0.5):
#link = self.session.object_link(self.document.context)
#print("Please visit %s to see the plots (press ctrl-C to exit)" % link)
try:
while True:
self.update_data()
self.session.load_document(self.document)
time.sleep(poll_interval)
except KeyboardInterrupt:
print()
except ConnectionError:
print("Connection to bokeh-server was terminated")
class HarvestNotifier:
timer_running = False
current_project = None
current_task = None
def __init__(self):
self.harvest = Harvest(scratch.url, scratch.username, scratch.password)
self.statusIcon = gtk.StatusIcon()
self.statusIcon.set_from_stock(gtk.STOCK_ABOUT)
self.statusIcon.set_visible(True)
self.statusIcon.set_tooltip("Hello World")
self.menu = gtk.Menu()
sep = gtk.SeparatorMenuItem()
self.menu.append(sep)
project_menu = gtk.Menu()
for client, projects in self.harvest.get_project_in_categories().iteritems():
client_item = gtk.MenuItem(client)
project_menu.append(client_item)
for project in projects:
task_menu = gtk.Menu()
p = gtk.MenuItem(project['name'])
for task in project['tasks']:
t = gtk.MenuItem(task['name'])
t.connect('activate', self.task_cb, self.menu, {"project": project, "task": task})
task_menu.append(t)
p.set_submenu(task_menu)
project_menu.append(p)
sep = gtk.SeparatorMenuItem()
project_menu.append(sep)
self.menuItem = gtk.MenuItem('Projects')
self.menuItem.set_submenu(project_menu)
self.menu.append(self.menuItem)
self.menuItem = gtk.ImageMenuItem(gtk.STOCK_QUIT)
self.menuItem.connect('activate', self.quit_cb, self.statusIcon)
self.menu.append(self.menuItem)
self.statusIcon.connect('popup-menu', self.popup_menu_cb, self.menu)
self.statusIcon.set_visible(1)
gtk.main()
def task_cb(self, widget, event, data = None):
if self.timer_running:
self.menu.remove(self.menu.get_children()[0])
self.harvest.timer_toggle(data['project'], data['task'])
# button showing what timer we're running
timer = gtk.MenuItem(data['project']['name'] + " - " + data['task']['name'])
timer.connect('activate', self.timer_click_cb, self.menu, data)
self.menu.prepend(timer)
self.timer_running = True
self.current_project = data['project']
self.current_task = data['task']
def timer_click_cb(self, widget, event, data = None):
""" Event triggered if a timer is running and someone clicks on the timer """
if not self.timer_running:
# we shouldn't get here, but just in case
return
self.harvest.timer_toggle(data['project'], data['task'])
# remove the timer button
self.menu.remove(widget)
self.timer_running = False
self.current_project = None
self.current_task = None
def quit_cb(self, widget, data = None):
if self.timer_running:
self.harvest.timer_toggle(self.current_project, self.current_task)
gtk.main_quit()
def popup_menu_cb(self, widget, button, time, data = None):
if button == 3:
if data:
data.show_all()
data.popup(None, None, gtk.status_icon_position_menu,
3, time, self.statusIcon)
import re
import json
import random
import requests
from harvest import Harvest
harvester = Harvest()
def compareItems(a, b):
list = []
list.append(True)
list.append(False)
try:
#print("Comparing " + str(a['type']) + " and " + str(b['type']))
if str(a['type']) > str(b['type']) or str(a['type']) == str(b['type']) and str(a['name']) > str(b['name']) :
#print("Returning True")
return random.choice(list)
else:
#print("Returning ?")
return random.choice(list)
except:
# Caters for cases where the name is not present i.e. a fallback function
#print("Comparing " + str(a['type']) + " and " + str(b['type']))
if str(a['type']) > str(b['type']):
#print("Returning ?")
return True
else:
#print("Returning ?")
return random.choice(list)
def sortJson(_json):
#print(_json)
def sync_hours_for_date(password, date_str):
in_date = strptime(date_str, '%d/%m/%Y')
doy = in_date.tm_yday
print "Syncing %d/%d/%d (%s)" % (in_date.tm_mday, in_date.tm_mon,
in_date.tm_year, doy)
h = Harvest(HARVEST_URL_ROOT, HARVEST_USER_EMAIL, password)
rm = redmine.Redmine(REDMINE_URL_ROOT, key=REDMINE_API_KEY)
rm_date = date(*in_date[:3])
rm_users = rm.users
rm_user = rm_users[6]
day = h.get_day(doy, 2016)
activities = rm.time_entry_activities
development = None
meeting = None
proj_man = None
for activity in activities:
if activity.name == 'Development':
development = activity
elif activity.name == 'Meeting':
meeting = activity
if activity.name == 'Project Management':
proj_man = activity
if development is None or meeting is None or proj_man is None:
raise ValueError('Cant find all activity types')
at_map = {
'Coding': development,
'Meeting': meeting,
'Project Management': proj_man
}
for day_entry in day['day_entries']:
if day_entry['client'] != CLIENT_NAME:
continue
activity = at_map.get(day_entry['task'])
if not activity:
print "Can't map activity '%s'" % day_entry['task']
continue
if day_entry['notes'] is not None and 'logged' in day_entry[
'notes'].lower():
continue
elif day_entry['notes'] is None:
day_entry['notes'] = ''
if activity == development or day_entry['notes'].startswith('#'):
if day_entry['notes'].startswith('#'):
try:
ticket_id = int(day_entry['notes'][1:])
except (TypeError, ValueError):
print "Can't parse ID on %s" % day_entry['notes']
continue
entry_notes = ''
else:
print "Not logging {}".format(day_entry['notes'])
continue
issue = rm.issues[ticket_id]
try:
te = rm.time_entries.new(issue=issue,
activity=activity,
spent_on=rm_date.strftime('%Y-%m-%d'),
user=rm_user,
hours=day_entry['hours'],
comments=entry_notes)
except Exception as e:
print e.read()
return
if day_entry['notes'] == '':
day_entry['notes'] = 'Logged'
else:
day_entry['notes'] += ' Logged'
try:
h.update(day_entry['id'], day_entry)
except Exception as e:
print "Failed to save time for %d. Delete manually" % ticket_id
return
print "Logged %02f hours for #%d" % (day_entry['hours'], ticket_id)
def from_solution(self, solution):
for i, harvest in enumerate(solution.harvests):
self.harvests[i] = Harvest(i)
self.harvests[i].from_harvest(harvest)
def setUp(self):
self.harvest = Harvest(URL, USER, PWD)
def __init__(self, crawl):
self.crawl = crawl
if self.crawl.crawler != "ache":
raise ValueError("Crawl must be using the Ache crawler.")
self.harvest = Harvest(crawl)
self.domain = Domain(crawl)
import re import json import time import requests from harvest import Harvest harvester = Harvest() # This is an address from devchain.secondstate.io blockhain address = "0x3cb71a43c6d9d08b35b48236b759ee201de27679" # This is a simple parent contract which we are using for demonstrations abiUrl1 = "https://raw.githubusercontent.com/tpmccallum/test_endpoint2/master/parent_abi.txt" abiData1 = requests.get(abiUrl1).content abiData1JSON = json.loads(abiData1) harvester.updateStateOfContractAddress(abiData1JSON, address) harvester.getDataUsingAddressHash(address)
import json
import requests
from harvest import Harvest
harvester = Harvest()
#BAT
abiUrl = "http://api.etherscan.io/api?module=contract&action=getabi&address=0x0d8775f648430679a709e98d2b0cb6250d2887ef&format=raw"
abiData = requests.get(abiUrl).content
officialAbiJSON = json.loads(abiData)
theDeterministicHash = harvester.shaAnAbi(officialAbiJSON)
cleanedAndOrderedAbiText = harvester.cleanAndConvertAbiToText(officialAbiJSON)
erc20Hashes = harvester.createUniqueAbiComparisons(json.loads(cleanedAndOrderedAbiText))
# print("\nThe original ABI is as follows:")
# print(officialAbiJSON)
# print("\nThe cleaned and ordered ABI is as follows:")
# print(cleanedAndOrderedAbiText)
# print("\nThe Sha3 of this ABI is as follows:")
print(theDeterministicHash)
# print("\nThe unique function hashes for this official ERC20 ABI are as follows:")
# print(erc20Hashes)
txReceipt = harvester.web3.eth.getTransactionReceipt("0xcceb1fd34dcc4b18defa4ff29d51a225b20af8ed179db37da72ec5d5a4e8d385")
tx = harvester.web3.eth.getTransaction("0xcceb1fd34dcc4b18defa4ff29d51a225b20af8ed179db37da72ec5d5a4e8d385")
#print("Transaction is as follows:")
#print(tx)
print(officialAbiJSON)
import json import requests from harvest import Harvest harvester = Harvest() #abiUrl = "http://api.etherscan.io/api?module=contract&action=getabi&address=0xcb97e65f07da24d46bcdd078ebebd7c6e6e3d750&format=raw" #abiUrl = "http://api.etherscan.io/api?module=contract&action=getabi&address=0x255aa6df07540cb5d3d297f0d0d4d84cb52bc8e6&format=raw" # CMT abiUrl = "http://api.etherscan.io/api?module=contract&action=getabi&address=0xf85feea2fdd81d51177f6b8f35f0e6734ce45f5f&format=raw" #txHash = "0xd4dc35a1fe48db820b9a5b24f278c732cd624971dd1279dabbd24e347649ba2b" #txHash = "0xa1d92948229a76e4c386d070355e0adec2736e68ff939ce2c77c65d2e702e3d1" txHash = "0x4e950082ac6360c6f8152331a30cbad0c7d08525c4c3914d5236d6fc15f684e8" abiData = requests.get(abiUrl).content abiJSON = json.loads(abiData) harvester.processSingleTransaction(abiJSON, txHash)
import re
import json
import time
import requests
from harvest import Harvest
harvester = Harvest()
# ERC20 Transfer Only
abiUrl1 = "https://raw.githubusercontent.com/tpmccallum/test_endpoint2/master/erc20_transfer_function_only_abi.txt"
abiData1 = requests.get(abiUrl1).content
abiData1JSON = json.loads(abiData1)
theDeterministicHash1 = harvester.shaAnAbi(abiData1JSON)
cleanedAndOrderedAbiText1 = harvester.cleanAndConvertAbiToText(abiData1JSON)
data1 = {}
data1['indexInProgress'] = "false"
data1['epochOfLastUpdate'] = int(time.time())
data1['abi'] = cleanedAndOrderedAbiText1
harvester.es.index(index=harvester.abiIndex, id=theDeterministicHash1, body=data1)
#v1
abiUrl1 = "https://raw.githubusercontent.com/CyberMiles/smart_contracts/master/FairPlay/v1/dapp/FairPlay.abi"
abiData1 = requests.get(abiUrl1).content
abiData1JSON = json.loads(abiData1)
theDeterministicHash1 = harvester.shaAnAbi(abiData1JSON)
cleanedAndOrderedAbiText1 = harvester.cleanAndConvertAbiToText(abiData1JSON)
from datetime import datetime, timedelta
from harvest import Harvest
h = Harvest( 'https://enjrolas.harvestapp.com', '*****@*****.**', 'planeman' )
user = h.find_user( 'Test', 'Guy' )
if user:
print "The user ID = %d" % user.id
start = datetime.today()-timedelta(365);
end = datetime.today();
total = 0
for entry in user.unbilled_entries( start, end ):
print entry
total += entry.hours
total=0
for expense in user.unbilled_expenses(start,end):
print expense
total+=
print 'Total hours worked = %f' % total
