Ejemplo n.º 1
0
    def get(self, boker_id):

        boker = Boker.get_by_id(int(boker_id))
        if boker:
            deferred.defer(update_num_view, str(boker.key()))

            # Check post type, Video or Photo
            if boker.video_id and boker.video_source:
                self.template = 'video.html'
                if self.current_user is not None:
                    user = User.get_by_key_name(self.current_user['id'])
                    can_like = not Like.already_like(user, boker)
                else:
                    can_like = False
            else:
                active_contest = Contest.active_contest()
                if active_contest:
                    is_nominee = Contest.is_nominee(boker)

                if self.current_user is not None:
                    user = User.get_by_key_name(self.current_user['id'])
                    can_vote = not Vote.already_vote(user)
                    can_like = not Like.already_like(user, boker)
                else:
                    can_vote = False
                    can_like = False
                    
                querystring = self.request.GET

            return self.render_response(self.template, locals())
        else:
            self.abort(404)
Ejemplo n.º 2
0
    def post(self):
        contests = Contest.all().order('-created')
        today = datetime.datetime.now()
        c = self.request.get('c')
        
        if c:
            upload_url = blobstore.create_upload_url('/administration/contest?c='+c)
            try:
                ct = Contest.get(c)
                form = ContestForm(self.request.POST, instance=ct)
            except:
                form = ContestForm(self.request.POST)
        else:
            upload_url = blobstore.create_upload_url('/administration/contest')
            form = ContestForm(self.request.POST)

        if form.is_valid():
            contest = form.save(commit=False)
            upload_files = self.get_uploads('file')
            if upload_files:
                contest.banner = upload_files[0]
            contest.put()

            self.redirect(self.uri_for('admin_contest')+'?success=1')

        return self.render_response(self.template, locals())
Ejemplo n.º 3
0
    def get(self):
        page = 'contest'
        tab = self.request.get('tab', 'kontes')

        active_contest = Contest.active_contest()

        contests = Contest.all().order('-created')
        return self.render_response(self.template, locals())
Ejemplo n.º 4
0
 def get(self, contest_id):
     page = 'contest'
     contest = Contest.get_by_id(int(contest_id))
     if contest:
         if not contest.active:
             winners = Contest.get_winners(contest)
         return self.render_response(self.template, locals())
     self.abort(404)
Ejemplo n.º 5
0
def new_contest():
    form = ContestForm(request.form)

    if request.method == 'POST' and form.validate():
        contest = Contest(form.name.data, form.start.data, form.duration.data, g.user.user_id)
        contest.save()
        os.makedirs(DEST_FOLDER.format(contest.contest_id)) 
        return redirect(url_for('contest_overview', contest_id=contest.contest_id))
    
    return render_template('contest_form.html', form=form)
Ejemplo n.º 6
0
def add(request):
	if(request.method == 'POST'):
		try:
			contest = Contest.objects.get(name=request.POST['name'])
			return render(request, "add.html", {'user': request.user, 'error': '竞赛已经存在'})
		except ObjectDoesNotExist, e:
			is_active = True
			if(request.POST['active'] == 'no'):
				is_active = False
			contest = Contest(name=request.POST['name'], description=request.POST['description'], active=is_active, owner=request.user)
			contest.save()
			return redirect('/contest/entry')
Ejemplo n.º 7
0
    def get(self):
        contests = Contest.all().order('-created')
        querystring = self.request.GET
        today = datetime.datetime.now()

        c = self.request.get('c')
        if c:
            upload_url = blobstore.create_upload_url('/administration/contest?c='+c)
            try:
                ct = Contest.get(c)

                # Interrupt form when delete action available
                if self.request.get('action') == 'delete':
                    ct.delete()
                    self.redirect(self.uri_for('admin_contest')+'?success=2')

                form = ContestForm(instance=ct)
            except:
                form = ContestForm()
        else:
            upload_url = blobstore.create_upload_url('/administration/contest')
            form = ContestForm()

        return self.render_response(self.template, locals())
Ejemplo n.º 8
0
def refresh_contest():
    key = request.json["secret_key"]
    if not check_secret_key(key):
        return "Key doesnt match"
    list_of_contest = request.json['contests']
    try:
        num_rows_deleted = db.session.query(Contest).delete()
        for contest in list_of_contest:
            new_contest = Contest(title=contest['title'],
                                  link=contest['link'],
                                  status=contest['status'])
            db.session.add(new_contest)
        db.session.commit()
        return 'OK'
    except:
        db.session.rollback()
        return 'ERROR DB'
Ejemplo n.º 9
0
def get_contests(deleted_contests=False, name=None, id=None):
    tmp = db_select(
        "dmob_contest",
        where_condition="1 {0} {1} {2}".format(
            "AND deleted = 0" if not deleted_contests else "",
            "AND name = %s" if name is not None else "",
            "AND id = %s" if id is not None else "",
        ),
        values=parse_args(name, id),
        extra="ORDER BY id DESC",
    )
    from models import Contest
    contests = []
    for x in tmp:
        problems = db_select(
            "dmob_contest_problem",
            where_condition="contest_id = %s",
            values=(x[0],),
        )
        contests.append(Contest(*x[0:2], [y[3] for y in problems], *x[2:]))
    return contests
Ejemplo n.º 10
0
    def post(self, boker_id):
        action = self.request.get('action')
        boker = Boker.get_by_id(int(boker_id))
        user = User.get_by_key_name(self.current_user['id'])

        if boker and user and action == 'vote':
            # Avoid multi votes
            if not Vote.already_vote(user):
                vote = Vote(contest=Contest.active_contest(), user=user, boker=boker)
                vote.put()

                # Upate boker vote score
                boker.num_vote += 1
                boker.save()

                # Trigger post action
                user_access_token = self.current_user['access_token']
                boker_url = settings.APP_DOMAIN + self.uri_for('boker_view', boker_id=boker_id)
                deferred.defer(publish_vote_action, user_access_token, boker_url)

                self.redirect(self.uri_for('boker_view', boker_id=boker_id)+'?vote=1')
        self.redirect(self.uri_for('boker_view', boker_id=boker_id))
Ejemplo n.º 11
0
    def scrape(self, scrape_id):
        opener = urllib2.build_opener()
        opener.addheaders = [('User-agent', 'Mozilla/5.0')]
        response = opener.open('https://www.draftkings.com/contest/index')
        json_data = response.read()
        contests = json.loads(json_data)
        guranteed = [
            c for c in contests if (c['attr'].has_key('IsGuaranteed')
                                    and c['attr']['IsGuaranteed'] == 'true')
        ]
        for contest in guranteed[:-1]:

            contest_args = {
                'site':
                'DraftKings',
                'url':
                'https://www.draftkings.com/contest/draftteam/%s' %
                (contest['id']),
                'title':
                contest['n'],
                'sport':
                'todo',
                'size':
                int(contest['m']),
                'entries':
                int(contest['nt']),
                'buyin':
                int(contest['a']),
                'payout':
                int(contest['po']),
                'start':
                datetime.fromtimestamp(
                    int(self.find_between(contest['sd'], '(', ')')) / 1000),
                'scrape_id':
                scrape_id,
            }

            self.contests.append(Contest(**contest_args))
Ejemplo n.º 12
0
    def post(self):
        '''
        Create new contest with problems
        '''
        data = request.json
        name = data.get('name')
        start_date = data.get('start_date')[:10] + " " + data.get('start_date')[11:19]
        end_date = data.get('end_date')[:10] + " " + data.get('end_date')[11:19]
        group_id = data.get('group_id')
        print("GROUP ID")
        print(group_id)
        # Convert to type datetime to compare values
        # 2018-04-13T00:13:20.134Z <- 2018-04-13 00:13:20 
        start = datetime.datetime(int(start_date[:4]), int(start_date[5:7]), int(start_date[8:10]), \
                                    int(start_date[11:13]), int(start_date[14:16]), int(start_date[17:]))     
        end = datetime.datetime(int(end_date[:4]), int(end_date[5:7]), int(end_date[8:10]), \
                                   int(end_date[11:13]), int(end_date[14:16]), int(end_date[17:]))
        timezone = pytz.timezone("America/Monterrey")
        start_aware = timezone.localize(start)
        end_aware = timezone.localize(end)

        if end < start:
            # The end date is before the start date 
            return None, 404
        # get teams of the group
        teams = Team.query.filter(Team.group_id == group_id).all()
        ids = data.get('problems')
        uniqueIDs = list(set(ids))

        new_contest = Contest(name=name, start_date=start_date,
                                end_date=end_date, group_id=group_id, teams=teams,
                                e_date=end_aware, s_date=start_aware)
        new_contest = add_problems(uniqueIDs, new_contest)

        db.session.add(new_contest)
        db.session.commit()

        return new_contest
Ejemplo n.º 13
0
    def scrape(self):
        #check cookie expiration here

        response = self.browser.open(self.url)
        html = response.read()
        soup = BeautifulSoup(html)
        rows = soup.find_all('tr', class_='lobby_row')

        for row in rows[:-1]:

            contest_args = {
                'site':
                'FanThrowdown',
                'url':
                'https://fanthrowdown.com/league/player_select/' +
                row['data-league-id'],
                'title':
                row.find('a', class_='league_info').text,
                'sport':
                row['data-sport'],
                'size':
                int(row['data-size']),
                'entries':
                int(row['data-entries']),
                'buyin':
                float(row['data-entry-fee']),
                'payout':
                self.format_prize_amount(
                    row.find('a',
                             class_='payout_modal_btn')['data-total-prizes']),
                'start':
                datetime.fromtimestamp(int(row['data-start-time'])),
            }

            self.results_queue.put(Contest(**contest_args))

        self.results_queue.put(None)
Ejemplo n.º 14
0
    def scrape(self):
        json_data = urllib2.urlopen(
            'https://www.draftkings.com/contest/index').read()
        contests = json.loads(json_data)
        guranteed = [
            c for c in contests if (c['attr'].has_key('IsGuaranteed')
                                    and c['attr']['IsGuaranteed'] == 'true')
        ]
        for contest in guranteed[:-1]:

            contest_args = {
                'site':
                'DraftKings',
                'url':
                'https://www.draftkings.com/contest/draftteam/%s' %
                (contest['id']),
                'title':
                contest['n'],
                'sport':
                'todo',
                'size':
                int(contest['m']),
                'entries':
                int(contest['nt']),
                'buyin':
                int(contest['a']),
                'payout':
                int(contest['po']),
                'start':
                datetime.fromtimestamp(
                    int(self.find_between(contest['sd'], '(', ')')) / 1000),
            }

            self.results_queue.put(Contest(**contest_args))

        self.results_queue.put(None)  #add sentinel
Ejemplo n.º 15
0
    def scrape(self, scrape_id):
        #check cookie expiration here
        html = self.browser.open(self.url).read()

        regex = re.compile(
            'LobbyConnection.initialData = (.*?)LobbyConnection', re.DOTALL)
        json_data = string.strip(regex.search(html).groups()[0])[:-1]
        data = json.loads(json_data)
        contests = data['additions']
        for contest in contests:
            contest_args = {
                'site': 'Fanduel',
                'url': 'https://fanduel.com' + contest['entryURL'],
                'title': contest['title'],
                'sport': contest['sport'],
                'size': int(contest['size']),
                'entries': self.get_entries(contest['entriesData']),
                'buyin': float(contest['entryFee']),
                'payout': float(contest['prizes']),
                'start': datetime.fromtimestamp(int(contest['startTime'])),
                'scrape_id': scrape_id,
            }

            self.contests.append(Contest(**contest_args))
Ejemplo n.º 16
0
    ],
                     batch_size=10000)

print(User.select().count(), 'users in db')

# %%
contest_list = api_get('contest.list')
data = []
for c in contest_list:
    data.append(
        dict(
            id=c['id'],
            name=c['name'],
            start_time=dt.datetime.utcfromtimestamp(c['startTimeSeconds']),
        ))
Contest.insert_many(data).on_conflict_ignore().execute()

print(Contest.select().count(), 'contests in db')

# %%
done = set()

# %%
known = [
    (158, 'r_hero'),
    (158, 'hashlife'),
    (172, 'pepela'),
    (447, 'kasim'),
    (472, 'yuki2006'),
    (472, 'a00920'),
    (615, 'InnocentFool'),
Ejemplo n.º 17
0
def remote_judge_get_problem_info(problem_id: str,
                                  contest_id: int = -1,
                                  contest_problem_id: int = -1):
    """
    {
        "code":0,
        "data":{
            "isContest":"是否在比赛中",
            "problemData":{
                "title":"题目名",
                "content":"题目内容",
                "background":"题目背景",
                "inputFormat":"输入格式",
                "outputFormat":'输出格式',
                "examples":[{"input":"样例输入","output":"样例输出"}],
                "createTime":"创建时间",
                "uploaderProfile":{
                    "uid":"用户ID",
                    "username":"******"
                },
                "remoteProblemID":"远程题目ID",
                "remoteOJ":{
                    "id":"远程OJID",
                    "display":"远程OJ显示名",
                    "availableLanguages":[
                        {"id":"0","display":"C++"}
                    ]
                },
                "public":"是否公开",
                "hint":"提示",
                "recentDiscussions":[
                    {
                        "id":123,
                        "title":"qw"
                    }
                ],
                "acceptedCount":"",
                "submissionCount":""
            },
            "userData":{
                "lastCode":"上次提交的代码",
                "lastLanguage":"上次选择的语言",
                "status":"qwq",
                "id":"",
                "accounts":{
                    "id":{
                        "username":"******",
                        "oj":"OJ",
                        "accountID":"ID"
                    }
                }
            }
        }

    }
    """
    # in_contest = contest_id != -1
    contest: Contest = Contest.by_id(contest_id)

    if contest:
        # pass
        if not contest.running() and not permission_manager.has_permission(
                session.get("uid"), "contest.manage"):
            return make_response(-1, message="你没有权限查看此题目")
        print(contest_problem_id, "contest_problem_id")
        problem: Problem = db.session.query(Problem).filter(
            Problem.id == contest.problems[contest_problem_id]
            ["id"]).one_or_none()
    else:
        problem: Problem = db.session.query(Problem).filter(
            Problem.id == problem_id).one_or_none()
        if not permission_manager.has_permission(
                session.get("uid"),
                "remote_judge.use") and problem.uploader_id != int(
                    session.get("uid")):
            return make_response(-1, message="你没有权限查看该题目")

    if not problem:
        return make_response(-1, message="未知题目ID")
    if problem.problem_type != "remote_judge":
        return make_response(-1, message="此题目非远程评测题目")
    uploader: User = db.session.query(
        User.id, User.username).filter(User.id == problem.uploader_id).one()
    last_submission: Submission = db.session.query(Submission).filter(
        and_(Submission.problem_id == problem.id,
             Submission.uid == session.get("uid"))).order_by(
                 Submission.score.desc()).order_by(Submission.id.desc())
    last_code, last_language, submission_id, status = "", next(
        iter(config.REMOTE_JUDGE_OJS[problem.remote_judge_oj]
             ["availableLanguages"].keys())), -1, None
    if last_submission.count():
        last_submission = last_submission.first()
        last_code = last_submission.code
        last_language = last_submission.language
        status = last_submission.status
        submission_id = last_submission.id
    discussions = []
    discussions_query = db.session.query(
        Discussion.id, Discussion.title).filter(
            Discussion.path == f"discussion.problem.{problem.id}").order_by(
                Discussion.id.desc()).limit(5)
    for item in discussions_query:
        discussions.append({"id": item.id, "title": item.title})
    accounts = {}
    for item in db.session.query(
            RemoteAccount.account_id, RemoteAccount.username,
            RemoteAccount.oj).filter(
                and_(RemoteAccount.uid == session.get("uid", -1),
                     RemoteAccount.oj == problem.remote_judge_oj)):
        accounts[item.account_id] = {
            "username": item.username,
            "oj": config.REMOTE_JUDGE_OJS[item.oj]["display"],
            "accountID": item.account_id
        }
    return make_response(
        0,
        data={
            "isContest": contest is not None,
            "problemData": {
                "title":
                problem.title,
                "content":
                problem.content,
                "background":
                problem.background,
                "inputFormat":
                problem.input_format,
                "outputFormat":
                problem.output_format,
                "examples":
                problem.example,
                "createTime":
                problem.create_time,
                "uploaderProfile": {
                    "uid": uploader.id,
                    "username": uploader.username
                } if not contest else None,
                "remoteProblemID":
                problem.remote_problem_id if not contest else None,
                "remoteOJ": {
                    "id": problem.remote_judge_oj,
                    **config.REMOTE_JUDGE_OJS[problem.remote_judge_oj]
                },
                "public":
                problem.public if not contest else None,
                "hint":
                problem.hint,
                "recentDiscussions":
                discussions if not contest else None,
                "acceptedCount":
                db.session.query(Submission).filter(
                    Submission.problem_id == problem.id).filter(
                        Submission.status == "accepted").count()
                if not contest else None,
                "submissionCount":
                db.session.query(Submission).filter(
                    Submission.problem_id == problem.id).count()
                if not contest else None,
                "id":
                problem.id
            },
            "userData": {
                "lastCode":
                last_code,
                "lastLanguage":
                last_language,
                "status":
                status,
                "id":
                submission_id,
                "managable":
                permission_manager.has_permission(session.get("uid", None),
                                                  "problem.manage"),
                "accounts":
                accounts
            }
        })
Ejemplo n.º 18
0
def contest_from_data ( data ) :
    return Contest(data['id'], data["name"], data.get('startTimeSeconds', 0))
Ejemplo n.º 19
0
def create_contest(db, name='Sorteio de pamohna', description='Sorteio de 6 pamonhas doces com queijo'):
    contest = Contest(name=name, description=description)
    add_and_commit(db, contest)
    return contest