def test_run_exists(self): class R(object): def __init__(self, id=None, flow=None, contact=None, responded=None, path=None, values=None): self.id = id self.flow = flow self.contact = contact self.responded = responded self.path = path self.values = values #created_on = models.DatetimeField() #modified_on = models.DatetimeField() #exited_on = models.DatetimeField() #exit_type = SimpleField() rapidpro_mock_run = R(id='001A', flow='Axx', contact='Allan', path=None, values=None) self.assertEquals(Run.group_exists(rapidpro_mock_run), False) Run.objects.create(id='001A', flow='Axx', contact='Allan', path=None, values=None) self.assertEquals(Run.group_exists(rapidpro_mock_run), True)
def mobile_syncrun(): if request.headers["Content-Type"] == "application/json": runjson = request.get_json() else: return redirect(url_for("home")) try: print "Run JSON Request", runjson if "id" in runjson: run = Run.query.filter_by(id=runjson["id"]).first() run.time = runjson["time"] else: run = Run(runjson["time"]) person = get_person(runjson["person"]) run.person = person.id run.fetcher = person run.time = runjson["time"] run.cafe = runjson["cafe"] run.pickup = runjson["pickup"] run.is_open = runjson["is_open"] run.statusobj = Status.query.filter_by(id=runjson["status"]).first() if "id" not in runjson: db.session.add(run) db.session.commit() return jsonify(msg="success", id=run.id, modified=run.jsondatetime("modified")) except: return jsonify(msg="error")
def martingale(self, run_parent): log.info('Martingale: loss for {0}'.format(run_parent.binary_ref)) # a child is born run_child_key = ndb.Key('Run', str(dt.datetime.utcnow())) run_child = Run( key=run_child_key, currency=run_parent.currency, time_frame=run_parent.time_frame, trade_base=run_parent.trade_base, trade_aim=run_parent.trade_aim, parent_run=run_parent.key, profit_parent=run_parent.profit_net, stake_parent=run_parent.stake, step=run_parent.step + 1, payout=run_parent.payout * 2, ended_at=dt.datetime.utcnow() + dt.timedelta(minutes=int(run_parent.time_frame)), ) # a child is registered if self.binary.createNew(run_child): run_child.put() log.info('New martingale run: {0}'.format(run_child)) log.info('Martingale: created new run') return run_child
def post(): print(request.json['fitness']) new_fit = request.json['fitness'] new_date = request.json['date'] new_model = request.json['model'] new_run = Run(date=new_date, modelName=new_model, fitness=new_fit) new_run.save() return response
def run_pep8(git_url, path, name, rev): """Check out the git project, run pep8, store the results""" # Do not allow duplicates of the same project/rev old_run = Run.objects.filter(project_name=name, git_revision=rev) if not old_run: run = Run(project_name=name, project_url=git_url, git_revision=rev) run.save() pep8_pipe = os.popen("pep8 -r %s" % path) parse_pep8(run, path, pep8_pipe) pep8_pipe.close() os.system("rm -rf %s" % os.path.dirname(path))
def test_green(self): r = Run() r.id = 1 rv = showrun(r) ok_(isinstance(rv, SafeString)) frag = parseFragment(rv) eq_(len(frag.childNodes), 1) a = frag.childNodes[0] eq_(a.attributes, {'data-errors': '0', 'data-total': '0', 'data-missing': '0', 'href': '/dashboard/compare?run=1', 'data-warnings': '0'}) text = a.childNodes[0].value ok_('green' in text)
def testRunResoures(self): # Do the whole healthcheck for all Resources for now resources = Resource.query.all() for resource in resources: result = run_test_resource(resource) print('resource: %s result=%s' % (resource.url, result.success)) run = Run(resource, result) print('Adding Run: success=%s, response_time=%ss\n' % (str(run.success), run.response_time)) self.db.session.add(run) self.db.session.commit() self.db.session.close() # Verify resources = Resource.query.all() for resource in resources: # Each Resource should have one Run self.assertEqual(resource.runs.count(), 1, 'RunCount should be 1 for %s' % resource.url) self.assertEqual( resource.runs[0].success, True, 'Run should be success for %s report=%s' % (resource.url, str(resource.runs[0])))
def run_resource(resourceid): resource = Resource.query.filter_by(identifier=resourceid).first() if not resource.active: # Exit test of resource if it's not active return # Get the status of the last run, # assume success if there is none last_run_success = True last_run = resource.last_run if last_run: last_run_success = last_run.success # Run test result = run_test_resource(resource) run1 = Run(resource, result, datetime.utcnow()) DB.session.add(run1) # commit or rollback each run to avoid long-lived transactions # see https://github.com/geopython/GeoHealthCheck/issues/14 db_commit() if APP.config['GHC_NOTIFICATIONS']: # Attempt notification try: notify(APP.config, resource, run1, last_run_success) except Exception as err: # Don't bail out on failure in order to commit the Run msg = str(err) logging.warn('error notifying: %s' % msg) if not __name__ == '__main__': DB.session.remove()
def add(): if not g.user.is_authenticated(): return render_template('add.html') if request.method == 'GET': return render_template('add.html') resource_type = request.form['resource_type'] url = request.form['url'].strip() resource = Resource.query.filter_by(resource_type=resource_type, url=url).first() if resource is not None: flash('service already registered (%s, %s)' % (resource_type, url), 'danger') if 'resource_type' in request.args: rtype = request.args.get('resource_type') return redirect(url_for('add', resource_type=rtype)) return redirect(url_for('add')) [title, success, response_time, message, start_time] = run_test_resource(resource_type, url) resource_to_add = Resource(current_user, resource_type, title, url) run_to_add = Run(resource_to_add, success, response_time, message, start_time) DB.session.add(resource_to_add) DB.session.add(run_to_add) try: DB.session.commit() flash('service registered (%s, %s)' % (resource_type, url), 'success') except Exception, err: DB.session.rollback() flash(str(err), 'danger')
def CreateRuns(key): runs = [] item = stocks[key][0] data = stocks[key][1] while item != None: if abs(data['Delta'].iloc[item.index])<runThreshold and data['Delta'].iloc[ item.index -1 ]*data['Delta'].iloc[item.index+1]>0: if item._next !=None: if item._prev !=None: item._prev._next = item._next._next if item._next._next!=None: item._next._next.prev = item._prev item._next = item._next._next elif item._prev !=None: item._prev._next = None item = item._next item = stocks[key][0] while item != None: inflections = [] inflections.append(item) n=0 start = item while n<runLength-1 and item!=None: n=n+1 inflections.append(item._next) item = item._next finish = item if finish !=None: _run = Run(key, inflections) runs.append(_run) j=0 item = start while j<deltaJ and item!=None: j=j+1 item = item._next return runs
def test_obsolete(self): r = Run(obsolete=3) r.id = 1 rv = showrun(r) ok_(isinstance(rv, SafeString)) frag = parseFragment(rv) childNodes = list(frag) eq_(len(childNodes), 1) a = childNodes[0] eq_(a.attrib, {'data-errors': '0', 'data-total': '0', 'data-missing': '0', 'href': '/dashboard/compare?run=1', 'data-warnings': '0'}) text = a.text ok_('3' in text and 'obsolete' in text)
def test_run_exists(self): class S(object): def __init__(self, run_id=None, flow=None, contact=None, responded=None, path=None, values=None, created_on=None, modified_on=None, exited_on=None, exit_type=None): self.id = run_id self.flow = flow self.contact = contact self.responded = responded self.path = path self.values = values self.created_on = created_on self.modified_on = modified_on self.exited_on = exited_on self.exit_type = exit_type rapidpro_mock_run = S(run_id=1, flow='Test flow', contact='Test contact', responded=1, path='Test path', values='Test Values', created_on=timezone.now(), modified_on=None, exited_on=None, exit_type='Test exit_type') self.assertEquals(Run.run_exists(rapidpro_mock_run), False) Run.objects.create(id=1, flow='Test flow', contact='Test contact', responded=1, path='Test path', values='Test Values', created_on=timezone.now(), modified_on=None, exited_on=None, exit_type='Test exit_type') self.assertEquals(Run.run_exists(rapidpro_mock_run), True)
def __init__(self, site, name=None): self.site = site name = name or str( localtime( now() ) ) self.run = Run( name=name, site = site ) self.run.save() self.br = M.Browser() self.br.set_handle_robots(False)
def test_obsolete(self): r = Run(obsolete=3) r.id = 1 rv = showrun(r) ok_(isinstance(rv, SafeString)) frag = parseFragment(rv) childNodes = list(frag) eq_(len(childNodes), 1) a = childNodes[0] eq_( a.attrib, { 'data-errors': '0', 'data-total': '0', 'data-missing': '0', 'href': '/dashboard/compare?run=1', 'data-warnings': '0' }) text = a.text ok_('3' in text and 'obsolete' in text)
def search(): get_response = [] for run in Run.select(): print(run.date, run.fitness) response_obj = { "date": run.date, "fitness": run.fitness, "model": run.modelName } get_response.append(response_obj) return get_response
def new(self): '''Create new iteration''' log.info('Main new started') currency, time_frame, trade_base, trade_aim = self.rl.selectNew(self.q) run_key = ndb.Key('Run', str(dt.datetime.utcnow())) run = Run( key=run_key, currency=currency, time_frame=time_frame, trade_base=trade_base, trade_aim=trade_aim, step=1, payout=1., ended_at=dt.datetime.utcnow() + dt.timedelta(minutes=int(time_frame)), ) if self.binary.createNew(run): run.put() log.info('New run: {0}'.format(run)) log.info('Main new ended')
def existing(self): '''Go through all existing iterations''' log.info('Main existing started') runs = Run.query(Run.is_finished == False).fetch() log.info('{0} runs found'.format(len(runs))) if len(runs): profit_table = self.binary.getProfitTable() # continue every run for run in runs: log.info('Run: finding profit for {0}'.format(run.binary_ref)) # time frame ending? if run.ended_at > dt.datetime.utcnow() + dt.timedelta(seconds=60): log.info('Run: skipping till {0}'.format(run.ended_at)) continue # wait for result profit_table_update_delay = dt.timedelta(seconds=15) to_sleep = max(0, int((run.ended_at - dt.datetime.utcnow() + profit_table_update_delay).total_seconds())) if to_sleep > 0: log.info('Run: waiting for {0} seconds'.format(to_sleep)) time.sleep(to_sleep + 5) log.info('Run: refreshing profit table...') profit_table = self.binary.getProfitTable() # get result if run.binary_ref in profit_table: parent_stake = run.stake_parent if run.stake_parent else 0. run.profit = profit_table[run.binary_ref] run.profit_net = run.profit + run.profit_parent run.stake_net = run.stake + parent_stake run.is_win = True if run.profit > 0 else False run.is_finished = True run.put() log.info('Run: finished with profit {0:.2f}'.format(run.profit)) # continue to cancel loss? if not run.is_win: run_child = self.martingale(run) else: # update q self.q = self.rl.updateQ(self.q, run) else: log.error('{0} has no profit/loss in table'.format(run.binary_ref)) log.info('Main existing ended')
def add_run(cafeid=None): form = RunForm(request.form) users = User.query.all() form.person.choices = [(user.id, user.name) for user in users] statuses = Status.query.all() form.statusid.choices = [(s.id, s.description) for s in statuses] cafes = Cafe.query.all() if not cafes: flash("There are no cafes currently configured. Please add one before creating a run", "warning") return redirect(url_for("home")) form.cafeid.choices = [(cafe.id, cafe.name) for cafe in cafes] if request.method == "GET": if cafeid: form.cafe.data = cafeid form.person.data = current_user.id form.time.data = sydney_timezone_now()#.strftime("%Y/%m/%d %H:%M:%S") form.deadline.data = sydney_timezone_now() return render_template("runform.html", form=form, formtype="Add", current_user=current_user) if form.validate_on_submit(): # Add run print form.data run = Run(form.data["time"]) person = User.query.filter_by(id=form.data["person"]).first() run.person = person.id run.fetcher = person run.deadline = form.data["deadline"] run.cafeid = form.data["cafeid"] run.pickup = form.data["pickup"] run.statusid = form.data["statusid"] #run.modified = sydney_timezone_now() run.modified = sydney_timezone_now() db.session.add(run) db.session.commit() write_to_events("created", "run", run.id) flash("Run added", "success") return redirect(url_for("view_run", runid=run.id)) else: for field, errors in form.errors.items(): flash("Error in %s: %s" % (field, "; ".join(errors)), "danger") return render_template("runform.html", form=form, formtype="Add", current_user=current_user)
def loadQ(self): log.info('Q loading...') q_key = ndb.Key(Q, 'main') self.q = q_key.get() if not self.q: self.q = Q(key=q_key) # validate properties if not self.q.data: self.q.data = {} if not self.q.visits: self.q.visits = {} runs = Run.query().fetch() for run in runs: if run.getState() not in self.q.visits: self.q.visits[run.getState()] = 0 self.q.visits[run.getState()] += 1 log.info('Q loaded {0}'.format(len(self.q.data)))
def test(resource_identifier): resource = Resource.query.filter_by(identifier=resource_identifier).first() if resource is None: flash('resource not found', 'danger') return redirect(request.referrer) [title, success, response_time, message, start_time] = run_test_resource(resource.resource_type, resource.url) run_to_add = Run(resource, success, response_time, message, start_time) if message not in ['OK', None, 'None']: flash('ERROR: %s' % message, 'danger') else: flash('Resource tested successfully', 'success') DB.session.add(run_to_add) try: DB.session.commit() except Exception, err: DB.session.rollback() flash(str(err), 'danger')
def create_run(session, test): # Run(test=test) requires the same session as test for adding it run = Run(test_id=test.id) session.add(run) session.commit() return run
# (c) Facebook, Inc. and its affiliates. Confidential and proprietary. import os if __name__ == "__main__": try: os.remove("database.sqlite3") except IOError: pass from models import engine, session, Base, Run, Issue Base.metadata.create_all(bind=engine) session.add(Run(run_id=0)) session.add(Run(run_id=1)) session.add( Issue(issue_id=0, source="UserControlled", sink="RemoteCodeExecution", run=1) ) session.add(Issue(issue_id=1, source="UserControlled", sink="Logging", run=1)) session.add(Issue(issue_id=2, source="UserControlled", sink="SqlInjection", run=1)) session.add(Issue(issue_id=3, source="Filesystem", sink="ReturnedToUser", run=0)) session.commit()
def main(): n_experiments, n_samples, n_runs = 0, 0, 0 db = get_database() # clear pre-existing data print("--- dropping existing data") db.drop_tables([Sample, Experiment, Run]) print("--- migrating up!") db.create_tables([Experiment, Sample, Run]) batch_size = 1000 with tarfile.open(TAR_PATH, "r:gz") as tar: for n, member in enumerate(tar): print(f"--- loading {member.name}") h = tar.extractfile(member) experiments_batch = [] samples_batch = [] runs_batch = [] if h is not None: if "experiment" in member.name: # experiment alias -> biosample identifier with tar.extractfile(member) as handle: root = xml.etree.ElementTree.parse(handle) for _id, experiment_data in load_experiment_data(root): experiments_batch.append({ "id": _id, **experiment_data }) n_experiments += 1 if len(experiments_batch) >= batch_size: print("--- inserting batch of experiments") print(len(experiments_batch)) Experiment.insert_many( experiments_batch).execute() print( f"--- n_experiments={n_experiments}; row count={Experiment.select().count()}" ) experiments_batch = [] if len(experiments_batch) > 0: try: Experiment.insert_many(experiments_batch).execute() except peewee.DataError: pprint(experiments_batch) quit(-1) if "sample" in member.name: with tar.extractfile(member) as handle: root = xml.etree.ElementTree.parse(handle) for _id, sample_data in load_sample_data(root): row = {"id": _id, **sample_data} samples_batch.append(row) n_samples += 1 if len(samples_batch) >= batch_size: print(len(samples_batch)) print("--- inserting batch of samples") Sample.insert_many(samples_batch).execute() print( f"--- n_samples={n_samples}; row count={Sample.select().count()}" ) samples_batch = [] if len(samples_batch) > 0: Sample.insert_many(samples_batch).execute() if "run" in member.name: with tar.extractfile(member) as handle: root = xml.etree.ElementTree.parse(handle) for _id, run_data in load_run_data(root): runs_batch.append({"id": _id, **run_data}) n_runs += 1 if len(runs_batch) >= batch_size: print(len(runs_batch)) print("--- inserting batch of runs") Run.insert_many(runs_batch).execute() print( f"--- n_runs={n_runs}; row count={Run.select().count()}" ) runs_batch = [] if len(runs_batch) > 0: Run.insert_many(runs_batch).execute() else: pass
def test_add_runs(self): run_count = Run.objects.count() added_runs = Run.add_runs() self.assertEquals(Run.objects.count(), run_count + added_runs)
def afficher_challenge(request, id): error=False if request.method == 'POST': # S'il s'agit d'une requête POST form = AddRunForm(request.POST) # Nous reprenons les données if form.is_valid(): # Nous vérifions que les données envoyées sont valides # Ici nous pouvons traiter les données du formulaire date = form.cleaned_data['date'] score=form.cleaned_data['score'] user=request.user challenge = get_object_or_404(Challenge, id=id) run=Run(date=date,score=score,challenge=challenge,user=user) run.save() print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!CREATION RUN!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!") else: # Si ce n'est pas du POST, c'est probablement une requête GET form = AddRunForm() # Nous créons un formulaire vide challenge = get_object_or_404(Challenge, id=id) member=challenge.team.filter(id=request.user.id).exists() #Creation du graphique #Create the data #Voir highcharts pour les options series=[] series_options_terms={} for joueur in challenge.team.all(): serie_joueur= {'options': {'source': Run.objects.filter(user=joueur,challenge=challenge)}} serie_joueur['terms']=[{''.join(["score_",joueur.username]):'score'},{''.join(["date_",joueur.username]):'date'}] series.append(serie_joueur) series_options_terms[''.join(["date_",joueur.username])]=[''.join(["score_",joueur.username])] #Ajouter l'objectif serie_obj= {'options': {'source': Challenge.objects.filter(id=challenge.id),'colors': 'red'},'terms':['goal_date','goal']} series_options_terms['goal_date']=['goal'] series.append(serie_obj) challengeData =DataPool(series) print(series_options_terms) #Step 2: Create the Chart object series_options0 =[{'options':{ 'type': 'spline', 'stacking': False}, 'terms':series_options_terms }] cht = Chart( datasource = challengeData, series_options=series_options0, chart_options = {'title': {'text': 'Performances'}, 'xAxis': {'title': {'text': 'Date'}}, 'yAxis': {'title': {'text': 'Scores'}} }) return render(request, 'challenges/challenge_page.html', locals())
released_pile = simpy.Store(env) progress_pile = simpy.Store(env) # Create named piles for specific work types, i.e., work that needs to be done to get the case to the Done pile work_piles = { wt.WORK_ANALYSIS: simpy.Store(env, len(sizes)), wt.WORK_QA: simpy.Store(env, MAX_QA_PILE), wt.WORK_DEV: simpy.Store(env, MAX_DEV_PILE), wt.WORK_REVIEW: simpy.FilterStore(env, MAX_REVIEW_PILE), wt.WORK_MERGE: simpy.FilterStore(env) } # Create a Run to store params run = Run( params={ 'dev_strategy': dev_strategy, 'ba_strategy': ba_strategy, 'dev_review_choice_strategy': dev_review_choice_strategy }) # Create a pile of all remaining source cases for case in standard_cases[NUM_INITIAL_CASES:len(standard_cases)]: _case = copy.deepcopy(case) _case.set_env(env) source_pile.put(_case) # Create a pile of cases to get the system to a steady state. We will start by putting the first workflow step # for each case on the dispatcher's pile and let them allocate work based on the workflow step properties. for case in standard_cases[:NUM_INITIAL_CASES]: _case = copy.deepcopy(case) _case.set_env(env) dispatch_new_case_work(_case)
class Crawler(object): def __init__(self, site, name=None): self.site = site name = name or str( localtime( now() ) ) self.run = Run( name=name, site = site ) self.run.save() self.br = M.Browser() self.br.set_handle_robots(False) def crawl(self,result ,force=False): if result.link.available == False or result.status != None: if not force: return [] #: get page res=self.br.open(result.link.url,timeout=2.0) result.status = res.code result.content_type = res.info()['Content-Type'] if not result.content_type or result.content_type.find('text/') <0: #: PDF ... result.save() return [] result.set_output(res.get_data()) result.save() #: page links next_links=result.children() #: page has cases for c in result.link.case_set.all(): case_result, case_result_created= LinkResult.objects.get_or_create( run=self.run, link=result.link, case = c ) #: TOOD: this implementation expect only 1 depth if case_result.status == None: if c.form_index >= 0 : self.br.select_form( nr = c.form_index ) for k,v in c.form_params.items(): self.br[ k ] = v res = self.br.submit() case_result.status = res.code case_result.content_type=res.info()['Content-Type'] if result.content_type or result.content_type.find('text/') >=0: case_result.set_output(res.get_data() ) case_result.save() self.br.open(result.link.url,timeout=2.0,) #: access original page return next_links def start(self,url=None,parent=None,follow=True ,force=False): #: parent : parent Link instance self.br.clear_history() time.sleep(0.01 ) url = url or self.site.start_url result =None try: result = self.run.provide_result( url, parent ) if result == None: return next_links = self.crawl( result,force=force) except: if result: result.errors = traceback.format_exc() result.save() return if not follow: return for path in next_links: self.start( path ,result.link)
def __init__(self): log.info('Stat init started') self.loadQ() self.runs = Run.query().order(Run.ended_at).fetch() log.info('Main init ended')
def add(): """add resource""" if not g.user.is_authenticated(): return render_template('add.html') if request.method == 'GET': return render_template('add.html') resource_type = request.form['resource_type'] tags = request.form.getlist('tags') url = request.form['url'].strip() resources_to_add = [] from healthcheck import sniff_test_resource, run_test_resource sniffed_resources = sniff_test_resource(CONFIG, resource_type, url) if not sniffed_resources: msg = gettext("No resources detected") LOGGER.exception() flash(msg, 'danger') for ( resource_type, resource_url, title, success, response_time, message, start_time, resource_tags, ) in sniffed_resources: # sniffed_resources may return list of resource # types different from initial one # so we need to test each row separately resource = Resource.query.filter_by(resource_type=resource_type, url=url).first() if resource is not None: msg = gettext('Service already registered') flash('%s (%s, %s)' % (msg, resource_type, url), 'danger') if len(sniffed_resources) == 1 and 'resource_type' in request.args: return redirect(url_for('add', lang=g.current_lang)) tags_to_add = [] for tag in chain(tags, resource_tags): tag_obj = tag if not isinstance(tag, Tag): tag_obj = Tag.query.filter_by(name=tag).first() if tag_obj is None: tag_obj = Tag(name=tag) tags_to_add.append(tag_obj) resource_to_add = Resource(current_user, resource_type, title, resource_url, tags=tags_to_add) resources_to_add.append(resource_to_add) probe_to_add = None checks_to_add = [] # Always add a default Probe and Check(s) # from the GHC_PROBE_DEFAULTS conf if resource_type in CONFIG['GHC_PROBE_DEFAULTS']: resource_settings = CONFIG['GHC_PROBE_DEFAULTS'][resource_type] probe_class = resource_settings['probe_class'] if probe_class: # Add the default Probe probe_obj = Factory.create_obj(probe_class) probe_to_add = ProbeVars( resource_to_add, probe_class, probe_obj.get_default_parameter_values()) # Add optional default (parameterized) # Checks to add to this Probe checks_info = probe_obj.get_checks_info() checks_param_info = probe_obj.get_plugin_vars()['CHECKS_AVAIL'] for check_class in checks_info: check_param_info = checks_param_info[check_class] if 'default' in checks_info[check_class]: if checks_info[check_class]['default']: # Filter out params for Check with fixed values param_defs = check_param_info['PARAM_DEFS'] param_vals = {} for param in param_defs: if param_defs[param]['value']: param_vals[param] = \ param_defs[param]['value'] check_vars = CheckVars(probe_to_add, check_class, param_vals) checks_to_add.append(check_vars) result = run_test_resource(resource_to_add) run_to_add = Run(resource_to_add, result) DB.session.add(resource_to_add) # prepopulate notifications for current user resource_to_add.set_recipients('email', [g.user.email]) if probe_to_add: DB.session.add(probe_to_add) for check_to_add in checks_to_add: DB.session.add(check_to_add) DB.session.add(run_to_add) try: DB.session.commit() msg = gettext('Services registered') flash('%s (%s, %s)' % (msg, resource_type, url), 'success') except Exception as err: DB.session.rollback() flash(str(err), 'danger') return redirect(url_for('home', lang=g.current_lang)) if len(resources_to_add) == 1: return edit_resource(resources_to_add[0].identifier) return redirect(url_for('home', lang=g.current_lang))
def notifyMe(self): log.info('Main Notifying me') log.info('Main waiting for trading to finish') time.sleep(60) log.info('Main waiting finished') started_at = dt.datetime.utcnow() + dt.timedelta(hours=-1) ended_at = dt.datetime.utcnow() runs = Run.query(Run.ended_at >= started_at, Run.ended_at <= ended_at, Run.is_finished == True, Run.is_win == True).fetch() log.info('Fetched {0} runs from {1} till {2}'.format(len(runs), started_at, ended_at)) # exit if nothing if not runs: log.warn('Exiting as there is no runs!') return net_profit = 0. stakes = 0. runs_size = len(runs) + 0. fields = ['binary_ref', 'time_frame', 'trade_base', 'trade_aim', 'step', 'profit_parent', 'stake_parent', 'stake', 'probability', 'payout', 'profit_net'] # table header table = '<table width=100%" border="1"><thead><tr>' for field in fields: table += '<th>{0}</th>'.format(field) table += '</tr></thead>' # table body table += '<tbody>' for run in runs: # update results net_profit += run.profit_net stakes += run.stake row = '<tr>' for field in fields: row += '<td>{0}</td>'.format(getattr(run, field)) row += '</tr>' log.info('Row: {0}'.format(row)) table += row while run.step > 1: run = run.parent_run.get() stakes += run.stake row = '<tr><td> </td>' for field in fields[1:-1]: row += '<td>{0}</td>'.format(getattr(run, field)) row += '<td> </td></tr>' log.info('Row: {0}'.format(row)) table += row table += '</tbody></table>' # pprint(table) subject = '[{0:.2f}] {1} runs totalling {2:.2f} profit with {3:.2f} stakes'.format( net_profit / stakes, runs_size, net_profit, stakes, ) log.info('Subject: {0}'.format(subject)) msg = mail.EmailMessage( sender='*****@*****.**', subject=subject, to='*****@*****.**', ) msg.body = table msg.html = '<html><body>' + table + '</body></html>' msg.send() log.info('Main Me notified')
def add(): """add resource""" if not g.user.is_authenticated(): return render_template('add.html') if request.method == 'GET': return render_template('add.html') tag_list = [] resource_type = request.form['resource_type'] tags = request.form.getlist('tags') url = request.form['url'].strip() resource = Resource.query.filter_by(resource_type=resource_type, url=url).first() if resource is not None: msg = gettext('Service already registered') flash('%s (%s, %s)' % (msg, resource_type, url), 'danger') if 'resource_type' in request.args: rtype = request.args.get('resource_type') return redirect( url_for('add', lang=g.current_lang, resource_type=rtype)) return redirect(url_for('add', lang=g.current_lang)) [title, success, response_time, message, start_time] = sniff_test_resource(APP.config, resource_type, url) if not success: flash(message, 'danger') return redirect( url_for('add', lang=g.current_lang, resource_type=resource_type)) if tags: for tag in tags: tag_found = False for tag_obj in Tag.query.all(): if tag == tag_obj.name: # use existing tag_found = True tag_list.append(tag_obj) if not tag_found: # add new tag_list.append(Tag(name=tag)) resource_to_add = Resource(current_user, resource_type, title, url, tags=tag_list) probe_to_add = None checks_to_add = [] # Always add a default Probe and Check(s) from the GHC_PROBE_DEFAULTS conf if resource_type in APP.config['GHC_PROBE_DEFAULTS']: resource_settings = APP.config['GHC_PROBE_DEFAULTS'][resource_type] probe_class = resource_settings['probe_class'] if probe_class: # Add the default Probe probe_obj = Factory.create_obj(probe_class) probe_to_add = ProbeVars(resource_to_add, probe_class, probe_obj.get_default_parameter_values()) # Add optional default (parameterized) Checks to add to this Probe checks_info = probe_obj.get_checks_info() checks_param_info = probe_obj.get_plugin_vars()['CHECKS_AVAIL'] for check_class in checks_info: check_param_info = checks_param_info[check_class] if 'default' in checks_info[check_class]: if checks_info[check_class]['default']: # Filter out params for Check with fixed values param_defs = check_param_info['PARAM_DEFS'] param_vals = {} for param in param_defs: if param_defs[param]['value']: param_vals[param] = param_defs[param]['value'] check_vars = CheckVars(probe_to_add, check_class, param_vals) checks_to_add.append(check_vars) result = run_test_resource(resource_to_add) run_to_add = Run(resource_to_add, result) DB.session.add(resource_to_add) if probe_to_add: DB.session.add(probe_to_add) for check_to_add in checks_to_add: DB.session.add(check_to_add) DB.session.add(run_to_add) try: DB.session.commit() msg = gettext('Service registered') flash('%s (%s, %s)' % (msg, resource_type, url), 'success') except Exception as err: DB.session.rollback() flash(str(err), 'danger') return redirect(url_for('home', lang=g.current_lang)) else: return edit_resource(resource_to_add.identifier)
class MyPDFView(View): template = 'qcreports/test.html' # the template groups = Group.get_sms_maama_groups() contacts = Contact.get_sms_maama_weekly_contacts() sms_maama_contacts = Contact.get_sms_maama_contacts() sent_messages = Message.get_sms_maama_sent_messages() delivered_messages = Message.get_sms_maama_delivered_messages() failed_messages = Message.get_sms_maama_failed_messages() failed_messages_count = Message.get_sms_maama_failed_messages_count() contacts_count = Contact.get_sms_maama_contacts_count() weekly_contacts_count = Contact.get_sms_maama_weekly_contacts_count() messages_count = Message.get_sms_maama_sent_messages_count() read_messages_count = Message.get_sms_maama_read_messages_count() unread_messages = Message.get_sms_maama_unread_messages() flow_responses_count = Message.get_sms_maama_flow_responses_count() baby_responses = Message.get_sms_maama_flow_responses_baby() baby_responses_count = Message.get_sms_maama_flow_responses_baby_count() stops = Message.get_sms_maama_opted_out() stops_count = Message.get_sms_maama_opted_out_count() flows = Run.sms_maama_contact_flows() antenatal_responses = Run.sms_maama_contact_flows_antenatal() start_date = datetime.datetime.now() - datetime.timedelta(days=7) end_date = datetime.datetime.now() this_day = now() context = { 'groups': groups, 'contacts': contacts, 'sms_maama_contacts': sms_maama_contacts, 'sent_messages': sent_messages, 'delivered_messages': delivered_messages, 'failed_messages': failed_messages, 'failed_messages_count': failed_messages_count, 'contacts_count': contacts_count, 'weekly_contacts_count': weekly_contacts_count, 'messages_count': messages_count, 'read_messages_count': read_messages_count, 'unread_messages': unread_messages, 'flow_responses_count': flow_responses_count, 'baby_responses': baby_responses, 'baby_responses_count': baby_responses_count, 'stops': stops, 'stops_count': stops_count, 'flows': flows, 'antenatal_responses': antenatal_responses, 'start_date': start_date, 'end_date': end_date, 'this_day': this_day } # data that has to be renderd to pdf templete def get(self, request): response = PDFTemplateResponse( request=request, template=self.template, filename="sms_maama_weekly_report.pdf", context=self.context, show_content_in_browser=False, # cmd_options={'margin-top': 10, # "zoom": 1, # "viewport-size": "1366 x 513", # 'javascript-delay': 1000, # 'footer-center': '[page]/[topage]', # "no-stop-slow-scripts": True}, ) return response