コード例 #1
0
ファイル: thread.py プロジェクト: fi-ksi/web-backend
	def on_post(self, req, resp):
		try:
			user = req.context['user']
			if not user.is_logged_in():
				resp.status = falcon.HTTP_400
				return

			if req.context['year_obj'].sealed:
				resp.status = falcon.HTTP_403
				req.context['result'] = { 'errors': [ { 'status': '403', 'title': 'Forbidden', 'detail': u'Ročník zapečetěn.' } ] }
				return

			data = json.loads(req.stream.read())
			pblic = data['thread']['public'] if data['thread'].has_key('public') else True

			thread = model.Thread(title=data['thread']['title'], public=pblic, year = req.context['year'])
			session.add(thread)
			session.commit()

			req.context['result'] = { 'thread': util.thread.to_json(thread, user.id) }
		except SQLAlchemyError:
			session.rollback()
			raise
		finally:
			session.close()
コード例 #2
0
ファイル: thread.py プロジェクト: fi-ksi/web-backend
	def on_get(self, req, resp, id):
		try:
			user = req.context['user']
			user_id = req.context['user'].id if req.context['user'].is_logged_in() else None
			thread = session.query(model.Thread).get(id)

			if not thread:
				req.context['result'] = { 'errors': [ { 'status': '404', 'title': 'Not Found', 'detail': u'Toto vlákno neexistuje.' } ] }
				resp.status = falcon.HTTP_404
				return

			if (not thread) or (not thread.public and not (user.is_org() or util.thread.is_eval_thread(user.id, thread.id))):
				req.context['result'] = { 'errors': [ { 'status': '401', 'title': 'Unauthorized', 'detail': u'Přístup k vláknu odepřen.' } ] }
				resp.status = falcon.HTTP_400
				return

			# Pocet vsech prispevku
			posts_cnt = session.query(model.Post).filter(model.Post.thread == thread.id).count()
			# Pocet neprectenych prispevku
			if not user.is_logged_in():
				unread_cnt = posts_cnt
			else:
				visit = session.query(model.ThreadVisit).filter(model.ThreadVisit.user == user.id, model.ThreadVisit.thread == thread.id).first()
				if visit:
					unread_cnt = session.query(model.Post).filter(model.Post.thread == thread.id, model.Post.published_at > visit.last_visit).count()
				else:
					unread_cnt = posts_cnt

			req.context['result'] = { 'thread': util.thread.to_json(thread, user_id, unread_cnt, posts_cnt) }
		except SQLAlchemyError:
			session.rollback()
			raise
		finally:
			session.close()
コード例 #3
0
    def on_delete(self, req, resp, id):
        user = req.context['user']
        try:
            user_db = session.query(model.User).get(id)
        except SQLAlchemyError:
            session.rollback()
            raise

        if (not user.is_logged_in()) or (not user.is_admin()):
            resp.status = falcon.HTTP_400
            return

        if not user_db:
            resp.status = falcon.HTTP_404
            return

        profile = session.query(model.Profile).get(id)

        try:
            if profile:
                session.delete(profile)
            session.delete(user_db)
            session.commit()
        except SQLAlchemyError:
            session.rollback()
            raise
        finally:
            session.close()

        req.context['result'] = {}
コード例 #4
0
    def post(self):
        args = classParser.parse_args()
        existingCourse = session.query(CourseModel).filter(
            CourseModel.crn == args['crn']).one_or_none()
        if (existingCourse):
            abort(400,
                  message="Course with the crn {} already exists".format(
                      args['crn']))

        newCourse = CourseModel(args['crn'], args['faculty_id'],
                                args['course_number'], args['course_name'],
                                args['course_type'], args['semester'],
                                args['course_year'])

        validSLOs = []
        for sloObject in args['assigned_slos']:
            slo = session.query(SLOModel).filter(
                SLOModel.slo_id == sloObject['slo_id']).one_or_none()

            if slo:
                validSLOs.append(
                    AssignedSLOModel(args['crn'], sloObject['slo_id'],
                                     sloObject['comments']))
            else:
                abort(404,
                      message="SLO with this slo_id {} does not exist.".format(
                          slo['slo_id']))

        session.add(newCourse)
        newCourse.assigned_slos = validSLOs
        session.commit()  #commits to a database
        session.close()
        return session.query(CourseModel).filter(
            CourseModel.crn == args['crn']).first()
コード例 #5
0
ファイル: wave.py プロジェクト: fi-ksi/web-backend
	def on_put(self, req, resp, id):
		try:
			user = req.context['user']

			if (not user.is_logged_in()) or (not user.is_org()):
				resp.status = falcon.HTTP_400
				return

			data = json.loads(req.stream.read())['wave']

			wave = session.query(model.Wave).get(id)
			if wave is None:
				resp.status = falcon.HTTP_404
				return

			# Menit vlnu muze jen ADMIN nebo aktualni GARANT vlny.
			if not user.is_admin() and user.id != wave.garant:
				resp.status = falcon.HTTP_400
				return

			wave.index = data['index']
			wave.caption = data['caption']
			if data['time_published']: wave.time_published = data['time_published']
			wave.garant = data['garant']

			session.commit()
		except SQLAlchemyError:
			session.rollback()
			raise
		finally:
			session.close()

		self.on_get(req, resp, id)
コード例 #6
0
ファイル: wave.py プロジェクト: fi-ksi/web-backend
	def on_delete(self, req, resp, id):
		try:
			user = req.context['user']

			# Vlnu mohou smazat jen admini
			if (not user.is_logged_in()) or (not user.is_admin()):
				resp.status = falcon.HTTP_400
				return

			wave = session.query(model.Wave).get(id)
			if wave is None:
				resp.status = falcon.HTTP_404
				return

			# Smazat lze jen neprazdnou vlnu.
			tasks_cnt = session.query(model.Task).filter(model.Task.wave == wave.id).count()
			if tasks_cnt > 0:
				resp.status = falcon.HTTP_403
				return

			session.delete(wave)
			session.commit()
			req.context['result'] = {}
		except SQLAlchemyError:
			session.rollback()
			raise
		finally:
			session.close()
コード例 #7
0
ファイル: user.py プロジェクト: fi-ksi/web-backend
	def on_delete(self, req, resp, id):
		user = req.context['user']
		try:
			user_db = session.query(model.User).get(id)
		except SQLAlchemyError:
			session.rollback()
			raise

		if (not user.is_logged_in()) or (not user.is_admin()):
			resp.status = falcon.HTTP_400
			return

		if not user_db:
			resp.status = falcon.HTTP_404
			return

		profile = session.query(model.Profile).get(id)

		try:
			if profile: session.delete(profile)
			session.delete(user_db)
			session.commit()
		except SQLAlchemyError:
			session.rollback()
			raise
		finally:
			session.close()

		req.context['result'] = {}
コード例 #8
0
ファイル: wave.py プロジェクト: fi-ksi/web-backend
	def on_post(self, req, resp):
		try:
			user = req.context['user']
			year = req.context['year']

			# Vytvorit novou vlnu mohou jen admini.
			if (not user.is_logged_in()) or (not user.is_admin()):
				resp.status = falcon.HTTP_400
				return

			data = json.loads(req.stream.read())['wave']

			wave = model.Wave(
				year = year,
				index = data['index'],
				caption = data['caption'],
				garant = data['garant'],
				time_published = data['time_published']
			)

			session.add(wave)
			session.commit()
			req.context['result'] = { 'wave': util.wave.to_json(wave) }
		except SQLAlchemyError:
			session.rollback()
			raise
		finally:
			session.close()
コード例 #9
0
    def insert(company_name, company_group_name, language_code):
        success = True
        error_msg = None

        company_group_id = CompanyGroupModel.select_company_group_id_by_company_group_name(
            company_group_name)
        if not company_group_id:
            success = False
            error_msg = "No record found for the company group name: {}".format(
                company_group_name)
            return success, error_msg

        language_id = LanguageModel.select_language_id_by_code(language_code)
        if not language_id:
            success = False
            error_msg = "No record found for the language code: {}".format(
                language_code)
            return success, error_msg

        company = CompanyModel(name=company_name,
                               company_group_id=company_group_id,
                               language_id=language_id)
        try:
            session.add(company)
            session.commit()

        except (connector.Error, SQLAlchemyError) as e:
            session.rollback()
            success = False
            error_msg = e.__cause__

        finally:
            session.close()

        return success, error_msg
コード例 #10
0
ファイル: user.py プロジェクト: fi-ksi/web-backend
	def on_post(self, req, resp):
		email = json.loads(req.stream.read())['email']
		try:
			user = session.query(model.User).filter(model.User.email == email).first()
		except SQLAlchemyError:
			session.rollback()
			raise

		if not user:
			resp.status = falcon.HTTP_400
			req.context['result'] = { 'result': 'error' }
			return

		new_password = ''.join(random.SystemRandom().choice(string.ascii_uppercase + string.digits + string.ascii_lowercase) for _ in range(8))

		user.password = auth.get_hashed_password(new_password)

		try:
			session.add(user)
			session.commit()
		except SQLAlchemyError:
			session.rollback()
			raise

		try:
			util.mail.send(user.email, '[KSI] Nové heslo', u'Ahoj,<br/>na základě tvé žádosti ti bylo vygenerováno nové heslo: %s<br/><br/>KSI' % new_password)
		except SQLAlchemyError:
			exc_type, exc_value, exc_traceback = sys.exc_info()
			traceback.print_exception(exc_type, exc_value, exc_traceback, file=sys.stderr)

		session.close()

		req.context['result'] = { 'result': 'ok' }
コード例 #11
0
ファイル: corrections.py プロジェクト: fi-ksi/web-backend
	def _process_achievements(self, corr):
		a_old = util.achievement.ids_list(util.achievement.per_task(corr['user'], corr['task_id']))
		a_new = corr['achievements']
		if a_old != a_new:
			# achievementy se nerovnaji -> proste smazeme vsechny dosavadni a pridame do db ty, ktere nam prisly
			for a_id in a_old:
				try:
					ach = session.query(model.UserAchievement).get((corr['user'], a_id))
					if ach.task_id == corr['task_id']:
						session.delete(ach)
					session.commit()
				except:
					session.rollback()
					raise

			for a_id in a_new:
				try:
					ua = model.UserAchievement(user_id=corr['user'], achievement_id=a_id, task_id=corr['task_id'])
					session.add(ua)
					session.commit()
				except:
					session.rollback()
					raise
				finally:
					session.close()
コード例 #12
0
    def on_delete(self, req, resp, id):
        user = req.context['user']
        if (not user.is_logged_in()) or (not user.is_org()):
            req.context['result'] = {
                'errors': [{
                    'status': '401',
                    'title': 'Unauthorized',
                    'detail': 'Smazat článek může pouze organizátor.'
                }]
            }
            resp.status = falcon.HTTP_400
            return

        try:
            article = session.query(model.Article).get(id)
            if article is None:
                req.context['result'] = {
                    'errors': [{
                        'status': '404',
                        'title': 'Not Found',
                        'detail': 'Článek s tímto ID neexistuje.'
                    }]
                }
                resp.status = falcon.HTTP_404
                return

            session.delete(article)
            session.commit()
            req.context['result'] = {}
        except SQLAlchemyError:
            session.rollback()
            raise
        finally:
            session.close()
コード例 #13
0
ファイル: correctionsInfo.py プロジェクト: fi-ksi/web-backend
	def on_get(self, req, resp):
		try:
			user = req.context['user']
			year = req.context['year']

			if (not user.is_logged_in()) or (not user.is_org()):
				req.context['result'] = { 'errors': [ { 'status': '401', 'title': 'Unauthorized', 'detail': u'Přístup k opravovátku mají pouze organizátoři.' } ] }
				resp.status = falcon.HTTP_400
				return

			tasks = session.query(model.Task).\
				join(model.Wave, model.Wave.id == model.Task.wave).\
				filter(model.Wave.year == year).all()

			waves = session.query(model.Wave).\
				filter(model.Wave.year == year).\
				join(model.Task, model.Task.wave == model.Wave.id).all()

			users = session.query(model.User)
			users = set(util.user.active_in_year(users, year).all())
			users |= set(session.query(model.User).\
				join(model.Task, model.Task.author == model.User.id).all())

			req.context['result'] = {
				'correctionsInfos': [ util.correctionInfo.task_to_json(task) for task in tasks ],
				'waves': [ util.wave.to_json(wave) for wave in waves ],
				'users': [ util.correctionInfo.user_to_json(user) for user in users ]
			}
		except SQLAlchemyError:
			session.rollback()
			raise
		finally:
			session.close()
コード例 #14
0
ファイル: article.py プロジェクト: fi-ksi/web-backend
	def on_put(self, req, resp, id):
		user = req.context['user']
		if (not user.is_logged_in()) or (not user.is_org()):
			req.context['result'] = { 'errors': [ { 'status': '401', 'title': 'Unauthorized', 'detail': u'Upravit článek může pouze organizátor.' } ] }
			resp.status = falcon.HTTP_400
			return

		data = json.loads(req.stream.read())['article']

		try:
			article = session.query(model.Article).get(id)
			if article is None:
				req.context['result'] = { 'errors': [ { 'status': '404', 'title': 'Not Found', 'detail': u'Článek s tímto ID neexistuje.' } ] }
				resp.status = falcon.HTTP_404
				return

			article.title = data['title']
			article.body = data['body']
			article.published = data['published']
			article.time_created = data['time_published']
			article.picture = data['picture']

			session.commit()
		except SQLAlchemyError:
			session.rollback()
			raise
		finally:
			session.close()

		self.on_get(req, resp, id)
コード例 #15
0
ファイル: year.py プロジェクト: fi-ksi/web-backend
	def on_delete(self, req, resp, id):
		try:
			user = req.context['user']

			if (not user.is_logged_in()) or (not user.is_admin()):
				resp.status = falcon.HTTP_400
				return

			year = session.query(model.Year).get(id)
			if year is None:
				resp.status = falcon.HTTP_404
				return

			# Odstranit lze jen neprazdny rocnik
			waves_cnt = session.query(model.Wave).filter(model.Wave.year == year.id).count()
			if waves_cnt > 0:
				resp.status = falcon.HTTP_403
				return

			session.delete(year)
			session.commit()
			req.context['result'] = {}
		except SQLAlchemyError:
			session.rollback()
			raise
		finally:
			session.close()
コード例 #16
0
ファイル: article.py プロジェクト: fi-ksi/web-backend
	def on_post(self, req, resp):
		user = req.context['user']
		if (not user.is_logged_in()) or (not user.is_org()):
			req.context['result'] = { 'errors': [ { 'status': '401', 'title': 'Unauthorized', 'detail': u'Přidat článek může pouze organizátor.' } ] }
			resp.status = falcon.HTTP_400
			return

		data = json.loads(req.stream.read())['article']

		try:
			article = model.Article(
				author = user.id,
				title = data['title'],
				body = data['body'],
				published = data['published'],
				year = req.context['year'],
				time_created = dateutil.parser.parse(data['time_published']),
				picture = data['picture']
			)

			session.add(article)
			session.commit()

			article.resource = 'articles/' + str(article.id)
			session.commit()
		except SQLAlchemyError:
			session.rollback()
			raise

		req.context['result'] = { 'article': _artice_to_json(article) }

		session.close()
コード例 #17
0
    def on_get(self, req, resp, id):
        try:
            user = session.query(model.User).get(id)
        except SQLAlchemyError:
            session.rollback()
            raise

        if user is None:
            req.context['result'] = {
                'errors': [{
                    'status': '404',
                    'title': 'Not found',
                    'detail': 'Uživatel s tímto ID neexistuje.'
                }]
            }
            resp.status = falcon.HTTP_404
            return

        try:
            req.context['result'] = {
                'user':
                util.user.to_json(user,
                                  req.context['year_obj'],
                                  admin_data=req.context['user'].is_org())
            }
        except SQLAlchemyError:
            session.rollback()
            raise
        finally:
            session.close()
コード例 #18
0
ファイル: post.py プロジェクト: fi-ksi/web-backend
	def on_put(self, req, resp, id):
		try:
			user = req.context['user']

			if (not user.is_logged_in()) or (not user.is_org()):
				# Toto tady musi byt -- jinak nefunguje frontend.
				self.on_get(req, resp, id)
				return

			data = json.loads(req.stream.read())['post']

			post = session.query(model.Post).get(id)
			if post is None:
				resp.status = falcon.HTTP_404
				return

			post.author = data['author']
			post.body = data['body']

			session.commit()
		except SQLAlchemyError:
			session.rollback()
			raise
		finally:
			session.close()

		self.on_get(req, resp, id)
コード例 #19
0
ファイル: achievement.py プロジェクト: fi-ksi/web-backend
	def on_delete(self, req, resp, id):
		user = req.context['user']
		try:
			achievement = session.query(model.Achievement).get(id)
		except SQLAlchemyError:
			session.rollback()
			raise

		if (not user.is_logged_in()) or (not user.is_admin()):
			req.context['result'] = { 'errors': [ { 'status': '401', 'title': 'Unauthorized', 'detail': u'Smazání trofeje může provést pouze administrátor.' } ] }
			resp.status = falcon.HTTP_400
			return

		if not achievement:
			req.context['result'] = { 'errors': [ { 'status': '404', 'title': 'Not Found', 'detail': u'Trofej s tímto ID neexsituje.' } ] }
			resp.status = falcon.HTTP_404
			return

		try:
			session.delete(achievement)
			session.commit()
		except SQLAlchemyError:
			session.rollback()
			raise
		finally:
			session.close()

		req.context['result'] = {}
コード例 #20
0
ファイル: achievement.py プロジェクト: fi-ksi/web-backend
	def on_post(self, req, resp):
		user = req.context['user']

		# Vytvoret novou trofej mohou jen orgove
		if (not user.is_logged_in()) or (not user.is_org()):
			req.context['result'] = { 'errors': [ { 'status': '401', 'title': 'Unauthorized', 'detail': u'Přidání trofeje může provést pouze organizátor.' } ] }
			resp.status = falcon.HTTP_400
			return

		data = json.loads(req.stream.read())['achievement']

		achievement = model.Achievement(
			title = data['title'],
			picture = data['picture'],
			description = data['description'],
		)
		if not data['persistent']: achievement.year = req.context['year']
		else: achievement.year = None

		try:
			session.add(achievement)
			session.commit()
		except SQLAlchemyError:
			session.rollback()
			raise

		req.context['result'] = { 'achievement': util.achievement.to_json(achievement) }

		session.close()
コード例 #21
0
def add_test():
    data = request.json
    t_obj = test(name=data['name'])
    session.add(t_obj)
    session.commit()
    session.close()
    return json.dumps({"data": "{} Added Succesfully".format(data['name'])})
コード例 #22
0
    def on_put(self, req, resp, id):
        try:
            user_id = req.context['user'].id \
                      if req.context['user'].is_logged_in() else None

            if not user_id:
                return

            if session.query(model.Thread).get(id) is None:
                status = falcon.HTTP_400
                return

            visit = util.thread.get_visit(user_id, id)

            if visit:
                visit.last_last_visit = visit.last_visit
                visit.last_visit = text('CURRENT_TIMESTAMP')
            else:
                visit = model.ThreadVisit(thread=id,
                                          user=user_id,
                                          last_visit=text('CURRENT_TIMESTAMP'))
                session.add(visit)

            session.commit()
            req.context['result'] = {}
        except SQLAlchemyError:
            session.rollback()
            raise
        finally:
            session.close()
コード例 #23
0
ファイル: task.py プロジェクト: fi-ksi/web-backend
    def on_get(self, req, resp, id):
        try:
            user = req.context['user']
            task = session.query(model.Task).get(id)

            # task_admin mohou ziskat jen orgove
            if (not user.is_logged_in()) or (not user.is_org()):
                req.context['result'] = {
                    'errors': [{
                        'status': '401',
                        'title': 'Unauthorized',
                        'detail': 'Přístup odepřen.'
                    }]
                }
                resp.status = falcon.HTTP_400
                return

            if task is None:
                req.context['result'] = {
                    'errors': [{
                        'status': '404',
                        'title': 'Not Found',
                        'detail': 'Úloha s tímto ID neexistuje.'
                    }]
                }
                resp.status = falcon.HTTP_404
                return

            req.context['result'] = {'atask': util.task.admin_to_json(task)}
        except SQLAlchemyError:
            session.rollback()
            raise
        finally:
            session.close()
コード例 #24
0
    def on_post(self, req, resp, id):
        """
        Params:
            - ?token=auth_token
            - ?type=eval|response|ksi|events|all
        """
        try:
            resp.content_type = 'text/html; charset=utf-8'

            notify = util.user_notify.get(id)
            if req.get_param('token') != notify.auth_token:
                resp.body = 'Chyba 403: špatný autorizační token!'
                resp.status = falcon.HTTP_403
                return

            valid_types = ['eval', 'response', 'ksi', 'events', 'all']
            u_type = req.get_param('type')

            if u_type not in valid_types:
                resp.body = 'Chyba 400: neplatný typ zprávy!'
                resp.status = falcon.HTTP_400
                return

            if u_type == 'eval':
                notify.notify_eval = False
            elif u_type == 'response':
                notify.notify_response = False
            elif u_type == 'ksi':
                notify.notify_ksi = False
            elif u_type == 'events':
                notify.notify_events = False
            elif u_type == 'all':
                notify.notify_eval = False
                notify.notify_response = False
                notify.notify_ksi = False
                notify.notify_events = False

            session.commit()
            resp.body = 'Úspěšně odhlášeno.'

            resp.body += '<br><br>Aktuální stav notifikací pro adresu: %s:' % (
                session.query(model.User).get(id).email)
            resp.body += '<ul>'
            resp.body += '<li>Notifikovat o opravení mého řešení: %s.</li>' % (
                'ano' if notify.notify_eval else 'ne')
            resp.body += '<li>Notifikovat o reakci na můj komentář: %s.</li>' % (
                'ano' if notify.notify_response else 'ne')
            resp.body += '<li>Notifikovat o průběhu semináře (vydání nové vlny, ...): %s.</li>' % (
                'ano' if notify.notify_ksi else 'ne')
            resp.body += '<li>Zasílat pozvánky na spřátelené akce (InterLoS, InterSoB, ...): %s.</li>' % (
                'ano' if notify.notify_events else 'ne')
            resp.body += '</ul>'
            resp.body += 'Další změny je možné provést v nastavení tvého profilu na KSI webu.'

        except SQLAlchemyError:
            resp.body = 'Chyba 500: nastala výjimka, kontaktuj orga!'
            session.rollback()
            raise
        finally:
            session.close()
コード例 #25
0
ファイル: post.py プロジェクト: fi-ksi/web-backend
    def on_get(self, req, resp, id):
        try:
            user = req.context['user']
            user_id = req.context['user'].get_id()\
                if req.context['user'].is_logged_in() else None

            post = session.query(model.Post).get(id)

            if post is None:
                resp.status = falcon.HTTP_404
                return

            thread = session.query(model.Thread).get(post.thread)

            if thread is None:
                resp.status = falcon.HTTP_404
                return

            # Kontrola pristupu k prispevkum:
            # a) K prispevkum v eval vlakne mohou pristoupit jen orgove a
            #    jeden resitel
            # b) K ostatnim neverejnym prispevkum mohou pristoupit jen orgove.
            if (not thread.public and
                ((not user.is_logged_in()) or
                 (not user.is_org()
                  and not util.thread.is_eval_thread(user.id, thread.id)))):
                resp.status = falcon.HTTP_400
                return

            req.context['result'] = {'post': util.post.to_json(post, user_id)}
        except SQLAlchemyError:
            session.rollback()
            raise
        finally:
            session.close()
コード例 #26
0
ファイル: task.py プロジェクト: fi-ksi/web-backend
	def on_get(self, req, resp):
		try:
			user = req.context['user']
			wave = req.get_param_as_int('wave')

			# Zobrazovat task_admin mohou jen orgove
			if (not user.is_logged_in()) or (not user.is_org()):
				req.context['result'] = { 'errors': [ { 'status': '401', 'title': 'Unauthorized', 'detail': u'Přístup odepřen.' } ] }
				resp.status = falcon.HTTP_400
				return

			tasks = session.query(model.Task, model.Wave).join(model.Wave, model.Task.wave == model.Wave.id)
			if wave is None:
				tasks = tasks.filter(model.Wave.year == req.context['year'])
			else:
				tasks = tasks.filter(model.Wave.id == wave)
			tasks = tasks.all()

			max_points = util.task.max_points_dict()

			req.context['result'] = { 'atasks': [ util.task.admin_to_json(task.Task, max_points[task.Task.id]) for task in tasks ] }
		except SQLAlchemyError:
			session.rollback()
			raise
		finally:
			session.close()
コード例 #27
0
def add_choice():
    data = request.json
    c_obj = choice(name=data['name'])
    session.add(c_obj)
    session.commit()
    session.close()
    return json.dumps({"data": "{} - Added Succesfully ".format(data['name'])})
コード例 #28
0
def test_sumbission():
    """
    This function accepts question id and selected choice id
    and test id and teacher id who creates the test and pupil 
    id who writes the test
    
    input format:
    {
    "question_ans": {"1": 2, "2": 3, "4":1},
    "test_id": 1,
    "teacher_id": 1
    "pupil_id": 1
    }
    
    """
    data = request.json


    if isinstance(data['question_ans'], dict) and isinstance(data['test_id'], int) and isinstance(data['teacher_id'], int)\
        and isinstance(data['pupil_id'], int):
        for que, ans in data['question_ans'].items():
            test_submission_obj = test_submission(
                pupil_id=data['pupil_id'],
                ques_id=int(que),
                test_id=data['test_id'],
                teacher_id=data['teacher_id'],
                choice_id=ans)
            session.add(test_submission_obj)
        session.commit()
        session.close()
        return json.dumps({"data": "Test  Succesfully submitted"})
    else:
        return json.dumps({"data": "Invalid data format"})
コード例 #29
0
    def on_delete(self, req, resp, id):
        try:
            user = req.context['user']

            # Vlnu mohou smazat jen admini
            if (not user.is_logged_in()) or (not user.is_admin()):
                resp.status = falcon.HTTP_400
                return

            wave = session.query(model.Wave).get(id)
            if wave is None:
                resp.status = falcon.HTTP_404
                return

            # Smazat lze jen neprazdnou vlnu.
            tasks_cnt = session.query(model.Task).\
                filter(model.Task.wave == wave.id).\
                count()

            if tasks_cnt > 0:
                resp.status = falcon.HTTP_403
                return

            session.delete(wave)
            session.commit()
            req.context['result'] = {}

        except SQLAlchemyError:
            session.rollback()
            raise
        finally:
            session.close()
コード例 #30
0
    def delete(tag_name, tag_group_name, language_code):
        success = True
        error_msg = None
        tag_group_id = TagGroupModel.select_tag_group_id_by_tag_group_name(
            tag_group_name)
        language_id = LanguageModel.select_language_id_by_code(language_code)

        try:
            tag = session.\
                query(TagModel).\
                filter(TagModel.name == tag_name,
                       TagModel.tag_group_id == tag_group_id,
                       TagModel.language_id == language_id).\
                one()
            session.delete(tag)
            session.commit()

        except (connector.Error, SQLAlchemyError) as e:
            session.rollback()
            success = False
            error_msg = e.__cause__

        finally:
            session.close()

        return success, error_msg
コード例 #31
0
    def on_get(self, req, resp, id):
        """
        GET pozadavek na konkretni correction se spousti prevazne jako odpoved
        na POST.
        id je umele id, konstrukce viz util/correction.py
        Parametry: moduleX_version=Y (X a Y jsou cisla)

        """

        try:
            user = req.context['user']

            if (not user.is_logged_in()) or (not user.is_org()):
                resp.status = falcon.HTTP_400
                return

            evaluation = session.query(model.Evaluation).get(id)
            if evaluation is None:
                resp.status = falcon.HTTP_404
                return

            module = session.query(model.Module).get(evaluation.module)

            req.context['result'] = {
                'evaluation':
                util.correction.corr_eval_to_json(module, evaluation)
            }
        except SQLAlchemyError:
            session.rollback()
            raise
        finally:
            session.close()
コード例 #32
0
ファイル: taskDeploy.py プロジェクト: fi-ksi/web-backend
	def on_get(self, req, resp, id):
		try:
			user = req.context['user']

			# Kontrola opravneni
			if (not user.is_logged_in()) or (not user.is_org()):
				resp.status = falcon.HTTP_400
				return

			status = {}

			task = session.query(model.Task).get(id)
			if task is None:
				resp.status = falcon.HTTP_404
				return

			log = None
			if os.path.isfile(util.admin.taskDeploy.LOGFILE):
				with open(util.admin.taskDeploy.LOGFILE, 'r') as f:
					data = f.readlines()
				if re.search(r"^(\d*)", data[0]).group(1) == str(id): log = ''.join(data[1:])

			status = {
				'id': task.id,
				'log': log,
				'deploy_date': task.deploy_date.isoformat() if task.deploy_date else None,
				'deploy_status': task.deploy_status
			}

			req.context['result'] = status
		except SQLAlchemyError:
			session.rollback()
			raise
		finally:
			session.close()
コード例 #33
0
ファイル: year.py プロジェクト: fi-ksi/web-backend
    def on_post(self, req, resp):
        try:
            user = req.context['user']

            # Vytvoret novy rocnik mohou jen ADMINI
            if (not user.is_logged_in()) or (not user.is_admin()):
                resp.status = falcon.HTTP_400
                return

            data = json.loads(req.stream.read().decode('utf-8'))['year']

            year = model.Year(
                id=data['index'],
                year=data['year'],
                sealed=data['sealed'] if data['sealed'] else False,
                point_pad=data['point_pad'])

            session.add(year)
            session.commit()

            if 'active_orgs' in data:
                for user_id in data['active_orgs']:
                    org = model.ActiveOrg(org=user_id, year=year.id)
                    session.add(org)

            session.commit()

            req.context['result'] = {'year': util.year.to_json(year)}

        except SQLAlchemyError:
            session.rollback()
            raise
        finally:
            session.close()
コード例 #34
0
ファイル: taskMerge.py プロジェクト: fi-ksi/web-backend
	def on_post(self, req, resp, id):
		try:
			user = req.context['user']

			# Kontrola existence ulohy
			task = session.query(model.Task).get(id)
			if task is None:
				req.context['result'] = 'Neexistujici uloha'
				resp.status = falcon.HTTP_404
				return

			# Kontrola existence git_branch a git_path
			if (task.git_path is None) or (task.git_branch is None):
				req.context['result'] = 'Uloha nema zadanou gitovskou vetev nebo adresar'
				resp.status = falcon.HTTP_400
				return

			if task.git_branch == "master":
				req.context['result'] = 'Uloha je j*z ve vetvi master'
				resp.status = falcon.HTTP_400
				return

			wave = session.query(model.Wave).get(task.wave)

			# Merge mohou provadet pouze administratori a garant vlny
			if (not user.is_logged_in()) or ((not user.is_admin()) and (user.id != wave.garant)):
				req.context['result'] = 'Nedostatecna opravneni'
				resp.status = falcon.HTTP_400
				return

			# Kontrola zamku
			lock = util.lock.git_locked()
			if lock:
				req.context['result'] = 'GIT uzamcen zámkem '+lock + "\nNekdo momentalne provadi akci s gitem, opakujte prosim akci za 20 sekund."
				resp.status = falcon.HTTP_409
				return

			try:
				mergeLock = LockFile(util.admin.taskMerge.LOCKFILE)
				mergeLock.acquire(60) # Timeout zamku je 1 minuta

				# Fetch repozitare
				repo = git.Repo(util.git.GIT_SEMINAR_PATH)

				if task.git_branch in repo.heads:
					# Cannot delete branch we are on
					repo.git.checkout("master")
					repo.git.branch('-D', task.git_branch)

				task.git_branch = 'master'

				session.commit()
				resp.status = falcon.HTTP_200
			finally:
				mergeLock.release()
		except SQLAlchemyError:
			session.rollback()
			raise
		finally:
			session.close()
コード例 #35
0
ファイル: submFilesEval.py プロジェクト: fi-ksi/web-backend
	def on_get(self, req, resp, eval_id):
		try:
			user = req.context['user']

			if (not user.is_logged_in()) or (not user.is_org()):
				resp.status = falcon.HTTP_400
				return

			inMemoryOutputFile = StringIO()
			zipFile = ZipFile(inMemoryOutputFile, 'w')

			files = [ r for (r, ) in session.query(model.SubmittedFile.path).\
				filter(model.SubmittedFile.evaluation == eval_id).distinct() ]

			for fname in files:
				if os.path.isfile(fname):
					zipFile.write(fname, os.path.basename(fname))

			zipFile.close()

			resp.set_header('Content-Disposition', "inline; filename=\"eval_" + str(eval_id) + ".zip\"")
			resp.content_type = "application/zip"
			resp.stream_len = inMemoryOutputFile.len
			resp.body = inMemoryOutputFile.getvalue()

			inMemoryOutputFile.close()
		except SQLAlchemyError:
			session.rollback()
			raise
		finally:
			session.close()
コード例 #36
0
ファイル: year.py プロジェクト: fi-ksi/web-backend
	def on_post(self, req, resp):
		try:
			user = req.context['user']

			# Vytvoret novy rocnik mohou jen ADMINI
			if (not user.is_logged_in()) or (not user.is_admin()):
				resp.status = falcon.HTTP_400
				return

			data = json.loads(req.stream.read())['year']

			year = model.Year(
				id = data['index'],
				year = data['year'],
				sealed = data['sealed'] if data['sealed'] else False,
				point_pad = data['point_pad']
			)

			session.add(year)
			session.commit()

			if 'active_orgs' in data:
				for user_id in data['active_orgs']:
					org = model.ActiveOrg(org=user_id, year=year.id)
					session.add(org)

			session.commit()

			req.context['result'] = { 'year': util.year.to_json(year) }

		except SQLAlchemyError:
			session.rollback()
			raise
		finally:
			session.close()
コード例 #37
0
ファイル: thread.py プロジェクト: fi-ksi/web-backend
	def on_put(self, req, resp, id):
		try:
			user_id = req.context['user'].id if req.context['user'].is_logged_in() else None

			if not user_id:
				return

			if session.query(model.Thread).get(id) is None:
				status = falcon.HTTP_400
				return

			visit = util.thread.get_visit(user_id, id)

			if visit:
				visit.last_last_visit = visit.last_visit
				visit.last_visit = text('CURRENT_TIMESTAMP')
			else:
				visit = model.ThreadVisit(thread=id, user=user_id, last_visit=text('CURRENT_TIMESTAMP'))
				session.add(visit)

			session.commit()
			req.context['result'] = "{}"
		except SQLAlchemyError:
			session.rollback()
			raise
		finally:
			session.close()
コード例 #38
0
ファイル: post.py プロジェクト: fi-ksi/web-backend
	def on_get(self, req, resp, id):
		try:
			user = req.context['user']
			user_id = req.context['user'].get_id() if req.context['user'].is_logged_in() else None

			post = session.query(model.Post).get(id)

			if post is None:
				resp.status = falcon.HTTP_404
				return

			thread = session.query(model.Thread).get(post.thread)

			if thread is None:
				resp.status = falcon.HTTP_404
				return

			# Kontrola pristupu k prispevkum:
			# a) K prispevkum v eval vlakne mohou pristoupit jen orgove a jeden resitel
			# b) K ostatnim neverejnym prispevkum mohou pristoupit jen orgove.
			if not thread.public and ((not user.is_logged_in()) or (not user.is_org() and not util.thread.is_eval_thread(user.id, thread.id))):
				resp.status = falcon.HTTP_400
				return

			req.context['result'] = { 'post': util.post.to_json(post, user_id) }
		except SQLAlchemyError:
			session.rollback()
			raise
		finally:
			session.close()
コード例 #39
0
    def on_get(self, req, resp, id):
        """
        Specifikace GET pozadavku:
        ?public=(1|0)
            tento argument je nepovinny, pokud neni vyplnen, dojde ke
            zverejneni

        """
        try:
            user = req.context['user']
            public = req.get_param_as_bool('public')

            if (not user.is_logged_in()) or (not user.is_org()):
                resp.status = falcon.HTTP_400
                return

            if public is None:
                public = True

            task = session.query(model.Task).get(id)
            if task is None:
                resp.status = falcon.HTTP_404
                return
            task.evaluation_public = public
            session.commit()
            req.context['result'] = {}
        except SQLAlchemyError:
            session.rollback()
            raise
        finally:
            session.close()
コード例 #40
0
ファイル: runcode.py プロジェクト: fi-ksi/web-backend
	def on_post(self, req, resp, id):
		try:
			user = req.context['user']
			if not user.is_logged_in():
				resp.status = falcon.HTTP_400
				return

			data = json.loads(req.stream.read())['content']
			module = session.query(model.Module).get(id)

			if not module:
				resp.status = falcon.HTTP_400
				return

			task_status = util.task.status(session.query(model.Task).get(module.task), user)

			if task_status == util.TaskStatus.LOCKED:
				resp.status = falcon.HTTP_400
				return

			req.context['result'] = util.programming.run(module, user.id, data)
		except SQLAlchemyError:
			session.rollback()
			raise
		finally:
			session.close()
コード例 #41
0
ファイル: year.py プロジェクト: fi-ksi/web-backend
    def on_delete(self, req, resp, id):
        try:
            user = req.context['user']

            if (not user.is_logged_in()) or (not user.is_admin()):
                resp.status = falcon.HTTP_400
                return

            year = session.query(model.Year).get(id)
            if year is None:
                resp.status = falcon.HTTP_404
                return

            # Odstranit lze jen neprazdny rocnik
            waves_cnt = session.query(model.Wave).\
                filter(model.Wave.year == year.id).\
                count()

            if waves_cnt > 0:
                resp.status = falcon.HTTP_403
                return

            session.delete(year)
            session.commit()
            req.context['result'] = {}

        except SQLAlchemyError:
            session.rollback()
            raise
        finally:
            session.close()
コード例 #42
0
ファイル: corrections.py プロジェクト: fi-ksi/web-backend
    def _process_achievements(self, corr):
        """ PUT: pridavani a mazani achievementu """

        a_old = util.achievement.ids_list(
            util.achievement.per_task(corr['user'], corr['task_id']))
        a_new = corr['achievements']
        if a_old != a_new:
            # achievementy se nerovnaji -> proste smazeme vsechny dosavadni
            # a pridame do db ty, ktere nam prisly.
            for a_id in a_old:
                try:
                    ach = session.query(model.UserAchievement).\
                        get((corr['user'], a_id))
                    if ach.task_id == int(corr['task_id']):
                        session.delete(ach)
                    session.commit()
                except SQLAlchemyError:
                    session.rollback()
                    raise

            for a_id in a_new:
                try:
                    ua = model.UserAchievement(user_id=corr['user'],
                                               achievement_id=a_id,
                                               task_id=corr['task_id'])
                    session.add(ua)
                    session.commit()
                except SQLAlchemyError:
                    session.rollback()
                    raise
                finally:
                    session.close()
コード例 #43
0
    def on_post(self, req, resp):
        try:
            user = req.context['user']
            year = req.context['year']

            # Vytvorit novou vlnu mohou jen admini.
            if (not user.is_logged_in()) or (not user.is_admin()):
                resp.status = falcon.HTTP_400
                return

            data = json.loads(req.stream.read().decode('utf-8'))['wave']

            wave = model.Wave(year=year,
                              index=data['index'],
                              caption=data['caption'],
                              garant=data['garant'],
                              time_published=dateutil.parser.parse(
                                  data['time_published']))

            session.add(wave)
            session.commit()
            req.context['result'] = {'wave': util.wave.to_json(wave)}
        except SQLAlchemyError:
            session.rollback()
            raise
        finally:
            session.close()
コード例 #44
0
    def on_delete(self, req, resp, id):
        """Delete feedback"""
        try:
            user = req.context['user']

            if not user.is_logged_in():
                resp.status = falcon.HTTP_400
                return

            feedback = session.query(model.Feedback).get((user.get_id(), id))
            if feedback is None:
                req.context['result'] = {
                    'errors': [{
                        'status': '404',
                        'title': 'Not found',
                        'detail': 'Feedback s tímto ID neexistuje.'
                    }]
                }
                resp.status = falcon.HTTP_404
                return

            session.delete(feedback)
            session.commit()
            req.context['result'] = {}

        except SQLAlchemyError:
            session.rollback()
            raise
        finally:
            session.close()
コード例 #45
0
    def on_put(self, req, resp, id):
        try:
            user = req.context['user']

            if (not user.is_logged_in()) or (not user.is_org()):
                resp.status = falcon.HTTP_400
                return

            data = json.loads(req.stream.read().decode('utf-8'))['wave']

            wave = session.query(model.Wave).get(id)
            if wave is None:
                resp.status = falcon.HTTP_404
                return

            # Menit vlnu muze jen ADMIN nebo aktualni GARANT vlny.
            if not user.is_admin() and user.id != wave.garant:
                resp.status = falcon.HTTP_400
                return

            wave.index = data['index']
            wave.caption = data['caption']
            if data['time_published']:
                wave.time_published = dateutil.parser.parse(
                    data['time_published'])
            wave.garant = data['garant']

            session.commit()
        except SQLAlchemyError:
            session.rollback()
            raise
        finally:
            session.close()

        self.on_get(req, resp, id)
コード例 #46
0
ファイル: task.py プロジェクト: fi-ksi/web-backend
    def on_delete(self, req, resp, id):
        """ Smazani ulohy """

        try:
            user = req.context['user']

            # Ulohu mohou smazat jen admini
            if (not user.is_logged_in()) or (not user.is_admin()):
                resp.status = falcon.HTTP_400
                return

            task = session.query(model.Task).get(id)
            if task is None:
                resp.status = falcon.HTTP_404
                return

            # Ulohu lze smazat jen pred casem zverejneni vlny
            wave = session.query(model.Wave).get(task.wave)
            if datetime.datetime.utcnow() > wave.time_published:
                resp.status = falcon.HTTP_403
                return

            execs = session.query(model.CodeExecution).\
                join(
                    model.Module,
                    model.Module.id == model.CodeExecution.module
                ).\
                filter(model.Module.task == id).all()
            for _exec in execs:
                session.delete(_exec)

            evals = session.query(model.Evaluation).\
                join(model.Module, model.Module.id == model.Evaluation.module).\
                filter(model.Module.task == id).all()
            for _eval in evals:
                session.delete(_eval)

            session.query(model.Module).\
                filter(model.Module.task == id).delete()

            thread = session.query(model.Thread).get(task.thread)
            prer = task.prerequisite_obj
            if prer is not None:
                session.delete(task.prerequisite_obj)

            session.delete(task)
            session.commit()

            if thread is not None:
                session.delete(thread)

            session.commit()

            req.context['result'] = {}
        except SQLAlchemyError:
            session.rollback()
            raise
        finally:
            session.close()
コード例 #47
0
    def on_post(self, req, resp):
        """Create new feedback"""
        try:
            user = req.context['user']

            if not user.is_logged_in():
                resp.status = falcon.HTTP_400
                return

            data = json.loads(req.stream.read().decode('utf-8'))['feedback']

            if session.query(model.Task).get(int(data['taskId'])) is None:
                req.context['result'] = {
                    'errors': [{
                        'status': '404',
                        'title': 'Not found',
                        'detail': 'Úloha s tímto ID neexistuje.'
                    }]
                }
                resp.status = falcon.HTTP_404
                return

            content = json.dumps(
                util.feedback.parse_feedback(data['categories']),
                indent=2,
                ensure_ascii=False,
            )

            feedback = model.Feedback(
                user=user.get_id(),
                task=int(data['taskId']),
                content=content,
                lastUpdated=datetime.datetime.utcnow(),
            )

            session.add(feedback)
            session.commit()

            req.context['result'] = {
                'feedback': util.feedback.to_json(feedback)
            }

        except (EForbiddenType, EUnmatchingDataType, EMissingAnswer,
                EOutOfRange) as e:
            req.context['result'] = {
                'errors': [{
                    'status': '400',
                    'title': 'Bad Request',
                    'detail': str(e)
                }]
            }
            resp.status = falcon.HTTP_400
            return
        except SQLAlchemyError:
            session.rollback()
            raise
        finally:
            session.close()
コード例 #48
0
    def on_post(self, req, resp, id):
        try:
            user = req.context['user']

            if (not user.is_logged_in()) or (not user.is_org()):
                resp.status = falcon.HTTP_400
                return

            # Kontrola zamku
            lock = util.lock.git_locked()
            if lock:
                req.context['result'] = ('GIT uzamcen zamkem ' + lock +
                                         '\nNekdo momentalne provadi akci s '
                                         'gitem, opakujte prosim akci za 20 '
                                         'sekund.')
                resp.status = falcon.HTTP_409
                return

            pullLock = LockFile(util.admin.waveDiff.LOCKFILE)
            pullLock.acquire(60)  # Timeout zamku je 1 minuta

            # Fetch
            repo = git.Repo(util.git.GIT_SEMINAR_PATH)
            repo.remotes.origin.fetch()

            # Ulohy ve vlne
            tasks = session.query(model.Task).\
                filter(model.Task.wave == id).all()

            # Diffujeme adresare uloh task.git_commit oproti HEAD
            for task in tasks:
                if ((not task.git_branch) or (not task.git_path)
                        or (not task.git_commit)):
                    task.deploy_status = 'default'
                    continue

                # Checkout && pull vetve ve ktere je uloha
                repo.git.checkout(task.git_branch)
                repo.remotes.origin.pull()

                # Kontrola existence adresare ulohy
                if os.path.isdir(util.git.GIT_SEMINAR_PATH + task.git_path):
                    hcommit = repo.head.commit
                    diff = hcommit.diff(task.git_commit, paths=[task.git_path])
                    if len(diff) > 0:
                        task.deploy_status = 'diff'
                else:
                    task.deploy_status = 'default'

            session.commit()
            req.context['result'] = {}
        except SQLAlchemyError:
            session.rollback()
            req.context['result'] = 'Nastala vyjimka backendu'
            raise
        finally:
            pullLock.release()
            session.close()
コード例 #49
0
def add_question():
    data = request.json
    if isinstance(data['name'], str):
        return json.dumps({"data": "Submit questions must be in valid format"})
    q_obj = question(name=data['name'])
    session.add(q_obj)
    session.commit()
    session.close()
    return json.dumps({"data": "{} - Added Succesfully ".format(data['name'])})
コード例 #50
0
def create_test_record():
    person = Person.Person()
    person.name = 'test user 2'
    person.gender = False
    person.date_of_birth = datetime.utcnow()
    session.add(person)
    session.commit()
    session.close()
    print('data saved')
コード例 #51
0
ファイル: profile.py プロジェクト: fi-ksi/web-backend
	def on_post(self, req, resp):
		try:
			userinfo = req.context['user']

			if not userinfo.is_logged_in():
				resp.status = falcon.HTTP_400
				return

			user = session.query(model.User).filter(model.User.id == userinfo.get_id()).first()

			files = multipart.MultiDict()
			content_type, options = multipart.parse_options_header(req.content_type)
			boundary = options.get('boundary','')

			if not boundary:
				raise multipart.MultipartError("No boundary for multipart/form-data.")

			for part in multipart.MultipartParser(req.stream, boundary, req.content_length):
				files[part.name] = part

			file = files.get('file')
			user_id = req.context['user'].get_id()
			tmpfile = tempfile.NamedTemporaryFile(delete = False)

			file.save_as(tmpfile.name)

			mime = magic.Magic(mime=True).from_file(tmpfile.name)

			if mime not in ALLOWED_MIME_TYPES:
				resp.status = falcon.HTTP_400
				return

			if not os.path.isdir(UPLOAD_DIR):
				try:
					os.makedirs(UPLOAD_DIR)
				except OSError:
					print 'Unable to create directory for profile pictures'
					resp.status = falcon.HTTP_500
					return

			new_picture = os.path.join(UPLOAD_DIR, 'user_%d.%s' % (user_id, ALLOWED_MIME_TYPES[mime]))

			self._crop(tmpfile.name, new_picture)
			try:
				os.remove(tmpfile.name)
			except OSError:
				print 'Unable to remove temporary file %s' % tmpfile.name

			user.profile_picture = new_picture

			session.add(user)
			session.commit()
		except SQLAlchemyError:
			session.rollback()
			raise
		finally:
			session.close()
コード例 #52
0
def contact():
    if request.method == 'POST':
        g_recaptcha_response = request.form.get('g-recaptcha-response')
        secret = config.reCaptcha.secret
        url = config.reCaptcha.uri
        if request.headers.getlist("X-Forwarded-For"):
            ip = request.headers.getlist("X-Forwarded-For")[0]
        else:
            ip = request.remote_addr
        site_key = config.reCaptcha.site_key
        data = {
            'secret': secret,
            'response': g_recaptcha_response,
            'remoteip': ip
        }
        r = requests.post(url, data=data)
        if r.status_code != 200:
            errors.append('reCAPTCHA service failure')
            return render_template('error.html', errors=errors), 400
        result = r.json()
        success = result.get('success')
        if success is not True:
            errors.append('reCAPTCHA failure')
            for error in result.get('error-codes'):
                errors.append(error)
            return render_template('error.html', errors=errors), 429
        contact = Contact()
        contact.name = request.form.get('name')
        contact.email = request.form.get('email')
        contact.message = request.form.get('message')
        contact.ip = ip
        session.add(contact)
        session.commit()
        session.close()

        date = datetime.datetime.now(
            timezone('US/Mountain')).strftime('%Y-%m-%d %I:%M:%S %p')
        msg = MIMEText("Date/Time: {}\nName: {}\nEmail: {}\n\n{}".format(
            date, contact.name, contact.email, contact.message))
        msg['Subject'] = "Website Comment {}".format(date)
        msg['Reply-To'] = '"{}" <{}>'.format(contact.name, contact.email)
        msg['From'] = "*****@*****.**"
        msg['To'] = "[email protected], [email protected]"
        server = smtplib.SMTP(config.mail.host, config.mail.port)
        server.ehlo()
        server.starttls()
        server.login(config.mail.user, config.mail.password)
        server.sendmail("*****@*****.**",
                        ["*****@*****.**", "*****@*****.**"],
                        msg.as_string())
        server.quit()

        return render_template('contact_thanks.html')
    else:
        site_key = config.reCaptcha.site_key
        return render_template('contact.html', site_key=site_key)
コード例 #53
0
def pupil_register():
    data = request.json
    p_obj = pupil(first_name=data['first_name'],
                  sur_name=data['sur_name'],
                  email_add=data['email_add'])
    session.add(p_obj)
    session.commit()
    session.close()
    return json.dumps(
        {"data": "{} - Added Succesfully ".format(data['first_name'])})
コード例 #54
0
ファイル: taskDeploy.py プロジェクト: fi-ksi/web-backend
	def on_post(self, req, resp, id):
		try:
			user = req.context['user']

			# Kontrola opravneni
			if (not user.is_logged_in()) or (not user.is_org()):
				req.context['result'] = 'Nedostatecna opravneni'
				resp.status = falcon.HTTP_400
				return

			# Kontrola existence ulohy
			task = session.query(model.Task).get(id)
			if task is None:
				req.context['result'] = 'Neexistujici uloha'
				resp.status = falcon.HTTP_404
				return

			# Zverejnene ulohy mohou deployovat pouze admini
			wave = session.query(model.Wave).get(task.wave)
			if (datetime.datetime.utcnow() > wave.time_published) and (not user.is_admin()):
				req.context['result'] = 'Po zverejneni ulohy muze deploy provest pouze administrator'
				resp.status = falcon.HTTP_404
				return

			# Kontrola existence gitovske vetve a adresare v databazi
			if (task.git_branch is None) or (task.git_path is None):
				req.context['result'] = 'Uloha nema zadanou gitovskou vetev nebo adresar'
				resp.status = falcon.HTTP_400
				return

			# Kontrola zamku
			lock = util.lock.git_locked()
			if lock:
				req.context['result'] = 'GIT uzamcen zamkem ' + lock + "\nNekdo momentalne provadi akci s gitem, opakujte prosim akci za 20 sekund."
				resp.status = falcon.HTTP_409
				return

			# Stav na deploying je potreba nastavit v tomto vlakne
			task.deploy_status = 'deploying'
			session.commit()

			try:
				deployLock = LockFile(util.admin.taskDeploy.LOCKFILE)
				deployLock.acquire(60) # Timeout zamku je 1 minuta
				deployThread = threading.Thread(target=util.admin.taskDeploy.deploy, args=(task.id, deployLock, scoped_session(_session)), kwargs={})
				deployThread.start()
			finally:
				deployLock.release()

			resp.status = falcon.HTTP_200
		except SQLAlchemyError:
			session.rollback()
			raise
		finally:
			session.close()
コード例 #55
0
ファイル: achievement.py プロジェクト: fi-ksi/web-backend
    def on_put(self, req, resp, id):
        user = req.context['user']

        # Upravovat trofeje mohou jen orgove
        if (not user.is_logged_in()) or (not user.is_org()):
            req.context['result'] = {
                'errors': [{
                    'status':
                    '401',
                    'title':
                    'Unauthorized',
                    'detail':
                    'Úpravu trofeje může provést pouze organizátor.'
                }]
            }
            resp.status = falcon.HTTP_400
            return

        data = json.loads(req.stream.read().decode('utf-8'))['achievement']

        try:
            achievement = session.query(model.Achievement).get(id)
        except SQLAlchemyError:
            session.rollback()
            raise

        if achievement is None:
            req.context['result'] = {
                'errors': [{
                    'status': '404',
                    'title': 'Not Found',
                    'detail': 'Trofej s tímto ID neexistuje.'
                }]
            }
            resp.status = falcon.HTTP_404
            return

        achievement.title = data['title']
        achievement.picture = data['picture']
        achievement.description = data['description']
        if not data['persistent']:
            achievement.year = req.context['year']
        else:
            achievement.year = None

        try:
            session.commit()
        except SQLAlchemyError:
            session.rollback()
            raise
        finally:
            session.close()

        self.on_get(req, resp, id)
コード例 #56
0
ファイル: year.py プロジェクト: fi-ksi/web-backend
	def on_get(self, req, resp):
		try:
			years = session.query(model.Year).all()

			sum_points = util.task.max_points_year_dict()

			req.context['result'] = { 'years': [ util.year.to_json(year, sum_points[year.id]) for year in years ] }
		except SQLAlchemyError:
			session.rollback()
			raise
		finally:
			session.close()
コード例 #57
0
ファイル: module.py プロジェクト: fi-ksi/web-backend
	def on_delete(self, req, resp, id):
		try:
			submittedFile = self._get_submitted_file(req, resp, id)
			if submittedFile:
				# Kontrola casu (soubory lze mazat jen pred deadline)
				eval_id = submittedFile.evaluation
				task = session.query(model.Task).\
					join(model.Module, model.Module.task == model.Task.id).\
					join(model.Evaluation, model.Evaluation.module == model.Module.id).\
					filter(model.Evaluation.id == submittedFile.evaluation).first()

				if task.time_deadline < datetime.datetime.utcnow():
					req.context['result'] = { 'result': 'error', 'error': u'Nelze smazat soubory po termínu odevzdání úlohy' }
					return

				try:
					os.remove(submittedFile.path)

					evaluation = session.query(model.Evaluation).get(eval_id)
					if evaluation:
						evaluation.full_report += str(datetime.datetime.now()) + " : removed file " + submittedFile.path + '\n'

					session.delete(submittedFile)
					session.commit()

					# Pokud resitel odstranil vsechny soubory, odstranime evaluation
					if evaluation:
						files_cnt = session.query(model.SubmittedFile).filter(model.SubmittedFile.evaluation == eval_id).count()
						if files_cnt == 0:
							session.delete(evaluation)
							session.commit()

					req.context['result'] = { 'status': 'ok' }

				except OSError:
					req.context['result'] = { 'status': 'error', 'error': u'Soubor se nepodařilo odstranit z filesystému' }
					return
				except exc.SQLAlchemyError:
					req.context['result'] = { 'status': 'error', 'error': u'Záznam o souboru se nepodařilo odstranit z databáze' }
					return
			else:
				if resp.status == falcon.HTTP_404:
					req.context['result'] = { 'status': 'error', 'error': u'Soubor nenalezen na serveru' }
				elif resp.status == falcon.HTTP_403:
					req.context['result'] = { 'status': 'error', 'error': u'K tomuto souboru nemáte oprávnění' }
				else:
					req.context['result'] = { 'status': 'error', 'error': u'Soubor se nepodařilo získat' }
				resp.status = falcon.HTTP_200
		except SQLAlchemyError:
			session.rollback()
			raise
		finally:
			session.close()
コード例 #58
0
ファイル: waveDiff.py プロジェクト: fi-ksi/web-backend
	def on_post(self, req, resp, id):
		try:
			user = req.context['user']

			if (not user.is_logged_in()) or (not user.is_org()):
				resp.status = falcon.HTTP_400
				return

			# Kontrola zamku
			lock = util.lock.git_locked()
			if lock:
				req.context['result'] = 'GIT uzamcen zamkem ' + lock + "\nNekdo momentalne provadi akci s gitem, opakujte prosim akci za 20 sekund."
				resp.status = falcon.HTTP_409
				return

			pullLock = LockFile(util.admin.waveDiff.LOCKFILE)
			pullLock.acquire(60) # Timeout zamku je 1 minuta

			# Fetch
			repo = git.Repo(util.git.GIT_SEMINAR_PATH)
			repo.remotes.origin.fetch()

			# Ulohy ve vlne
			tasks = session.query(model.Task).\
				filter(model.Task.wave == id).all()

			# Diffujeme adresare uloh task.git_commit oproti HEAD
			for task in tasks:
				if (not task.git_branch) or (not task.git_path) or (not task.git_commit):
					task.deploy_status = 'default'
					continue

				# Checkout && pull vetve ve ktere je uloha
				repo.git.checkout(task.git_branch)
				repo.remotes.origin.pull()

				# Kontrola existence adresare ulohy
				if os.path.isdir(util.git.GIT_SEMINAR_PATH+task.git_path):
					hcommit = repo.head.commit
					diff = hcommit.diff(task.git_commit, paths=[task.git_path])
					if len(diff) > 0: task.deploy_status = 'diff'
				else:
					task.deploy_status = 'default'

			session.commit()
		except SQLAlchemyError:
			session.rollback()
			req.context['result'] = 'Nastala vyjimka backendu'
			raise
		finally:
			pullLock.release()
			session.close()
コード例 #59
0
ファイル: email.py プロジェクト: fi-ksi/web-backend
	def on_post(self, req, resp):
		try:
			user = req.context['user']

			if (not user.is_logged_in()) or (not user.is_org()):
				resp.status = falcon.HTTP_400
				return

			data = json.loads(req.stream.read())['e-mail']

			# Filtrovani uzivatelu
			if data['To'] != []:
				active = util.user.active_years_all()
				active = [ user for (user,year) in filter(lambda (user,year): (user.role == 'participant') and (year.id in data['To']), active) ]
				if ('Gender' in data) and (data['Gender'] != 'both'): active = filter(lambda user: user.sex == data['Gender'], active)
				to = active
			else:
				query = session.query(model.User).filter(model.User.role == 'participant')
				if ('Gender' in data) and (data['Gender'] != 'both'): query = query.filter(model.User.sex == data['Gender'])
				to = query.all()

			if ("Successful" in data) and (data['Successful']):
				succ = set()
				for year in data['To']:
					year_obj = session.query(model.Year).get(year)
					succ |= set(map(lambda (user,points): user.id, util.user.successful_participants(year_obj)))
				to = filter(lambda user: user.id in succ, to)

			to = set([ user.email for user in to ])

			params = {
				'Reply-To': data['Reply-To'],
				'Sender': data['Sender']
			}

			body = data['Body']
			if ('KarlikSign' in data) and (data['KarlikSign']): body = body + util.config.karlik_img()
			if ('Easteregg' in data) and (data['Easteregg']): body = body + util.mail.easteregg()

			try:
				util.mail.send_multiple(to, data['Subject'], body, params, data['Bcc'])
				req.context['result'] = { 'count': len(to) }
			except Exception as e:
				req.context['result'] = { 'error': str(e) }
				resp.status = falcon.HTTP_500
		except SQLAlchemyError:
			session.rollback()
			raise
		finally:
			session.close()
コード例 #60
0
ファイル: wave.py プロジェクト: fi-ksi/web-backend
	def on_get(self, req, resp):
		try:
			user = req.context['user']
			waves = session.query(model.Wave).\
				filter(model.Wave.year == req.context['year']).all()

			max_points = util.task.max_points_wave_dict()

			req.context['result'] = { 'waves': [ util.wave.to_json(wave, max_points[wave.id]) for wave in waves ] }
		except SQLAlchemyError:
			session.rollback()
			raise
		finally:
			session.close()