Example #1
0
 def _process_house_item(self, item):
     item['area'] = int(item['area'][:-1])
     item['rent'] = int(item['rent'])
     session.add(House(**item))
     session.commit()
     session.close()
     return item
Example #2
0
    def reduction_started(self):
        logger.info("Run %s has started reduction" %
                    self._data_dict['run_number'])

        reduction_run = self.find_run()

        if reduction_run:
            if str(reduction_run.status.value) == "Error" or str(
                    reduction_run.status.value) == "Queued":
                reduction_run.status = StatusUtils().get_processing()
                reduction_run.started = datetime.datetime.now()
                session.add(reduction_run)
                session.commit()
            else:
                logger.error(
                    "An invalid attempt to re-start a reduction run was captured. Experiment: %s, "
                    "Run Number: %s, Run Version %s" %
                    (self._data_dict['rb_number'],
                     self._data_dict['run_number'],
                     self._data_dict['run_version']))
        else:
            logger.error(
                "A reduction run started that wasn't found in the database. Experiment: %s, Run Number: %s, "
                "Run Version %s" %
                (self._data_dict['rb_number'], self._data_dict['run_number'],
                 self._data_dict['run_version']))
    def _create_variables(self, instrument, script, variable_dict,
                          is_advanced):
        variables = []
        for key, value in variable_dict.iteritems():
            str_value = str(value).replace('[', '').replace(']', '')
            if len(str_value) > 300:
                raise DataTooLong

            variable = Variable(name=key,
                                value=str_value,
                                type=VariableUtils().get_type_string(value),
                                is_advanced=is_advanced,
                                help_text=self._get_help_text(
                                    'standard_vars', key, instrument.name,
                                    script))

            instrument_variable = InstrumentVariable(start_run=0,
                                                     instrument=instrument,
                                                     variable=variable,
                                                     tracks_script=1)

            session.add(variable)
            session.add(instrument_variable)
            session.commit()

            variables.append(instrument_variable)
        return variables
Example #4
0
    def to_html(self):

        # not good to have imports here...
        from queries import get_question, get_last_question_response, get_peer_tasks_for_grader, get_self_tasks_for_student 
        from auth import validate_user
        self.set_metadata()
        user = validate_user()
        if user.type == "guest":
            return "Sorry, but only students can view peer assessment questions."

        vars = {"question": get_question(self.question_id)}

        # if peer assessment was assigned
        if len(self.peer_pts):
            peer_tasks = get_peer_tasks_for_grader(self.question_id, user.stuid)
            vars['peer_responses'] = [get_last_question_response(self.question_id, task.student) for task in peer_tasks]

        # if self assessment was assigned
        if self.self_pts is not None:
            # add the task if it hasn't been already
            response = get_last_question_response(self.question_id, user.stuid)
            if response and not get_self_tasks_for_student(self.question_id, user.stuid):
                session.add(GradingTask(grader=user.stuid, 
                                        student=user.stuid, 
                                        question_id=self.question_id))
                session.commit()
            vars['self_response'] = response

        # jinja2 to get template for peer review questions
        from jinja2 import Environment, PackageLoader
        env = Environment(autoescape=True, loader=PackageLoader("ohms", "templates"))
        template = env.get_template("peer_review_question.html")

        return template.render(**vars)
Example #5
0
def createUser(login_session):
    newUser = User(name=login_session['username'],
                   email=login_session['email'],
                   picture=login_session['picture'])
    session.add(newUser)
    session.commit()
    user = session.query(User).filter_by(email=login_session['email']).one()
    return user.id
def delete_category(category_id):
    """
    Deleting category by id
    """
    category_to_delete = session.query(Category)\
                                .filter(Category.id == category_id).first()
    session.delete(category_to_delete)
    session.commit()
Example #7
0
def delete_movie(id):
    session.query(Movie)\
        .filter(Movie.id == id)\
        .delete()
    session.commit()
    message = 'Movie {} was deleted!'.format(id)
    dic = {'message': message}
    return jsonify(dic)
Example #8
0
    def update_from_xml(self, xml):
        node = ET.fromstring(xml)
        for i, q in enumerate(node.iter('question')):
            q_object = Question.from_xml(q)
            q_object.homework = self
            self.questions.append(q_object)

        session.commit()
Example #9
0
    def submit_response(self, stuid, responses):

        from queries import get_peer_tasks_for_grader, get_self_tasks_for_student
        self.set_metadata()

        if pdt_now() <= self.homework.due_date:

            # helper function that validates and then updates a task
            def check_and_update_task(task):
                if task.grader != stuid:
                    raise Exception("You are not authorized to grade this response.")
                try:
                    assert(0 <= float(responses[2*i]) <= task.question.points)
                except:
                    raise Exception("Please enter a score between %f and %f." % (0, task.question.points))
                if not responses[2*i+1].strip():
                    raise Exception("Please enter comments for all responses.")

                task.time = pdt_now()
                task.score = responses[2*i]
                task.comments = responses[2*i+1]

                return task

            i = 0
            score = 0.

            # peer tasks should be first
            while i < len(self.peer_pts):
                tasks = get_peer_tasks_for_grader(self.question_id, stuid)
                task = check_and_update_task(tasks[i])
                if task.comments is not None: score += self.peer_pts[i]
                i += 1

            # then we have self tasks
            if self.self_pts is not None:
                tasks = get_self_tasks_for_student(self.question_id, stuid)
                if tasks:
                    task = check_and_update_task(tasks[0])
                    if task.comments is not None: score += self.self_pts

            comments = "Watch this space for your peers' judgment of your feedback. "
            if self.rate_pts:
                comments += "Your peers' judgment is worth %f points, so you cannot earn all %s points yet." % (self.rate_pts, self.points)

            session.commit()
            
            return {
                'locked': (pdt_now() > self.homework.due_date),
                'submission': QuestionResponse(
                    time=pdt_now(),
                    score=score,
                    comments=comments
                    )
            }

        else:
            raise Exception("The deadline for submitting this homework has passed.")
Example #10
0
 def _process_job_item(self, item):
     item['salary_lower'] = int(item['salary_lower'][:-1])
     item['salary_upper'] = int(item['salary_upper'][:-1])
     item['experience_lower'] = int(item['experience_lower'])
     item['experience_upper'] = int(item['experience_upper'])
     session.add(Job(**item))
     session.commit()
     session.close()
     return item
Example #11
0
 def save_run_variables(self, instrument_vars, reduction_run):
     logger.info('Saving run variables for ' +
                 str(reduction_run.run_number))
     run_variables = map(
         lambda ins_var: self.derive_run_variable(ins_var, reduction_run),
         instrument_vars)
     for run_variable in run_variables:
         session.add(run_variable)
     session.commit()
     return run_variables
Example #12
0
def signup():
    form = RegisterForm()
    if form.validate_on_submit():
        new_user = User(form.username.data, form.email.data,
                        form.password.data)
        session.add(new_user)
        session.commit()
        flash('Thanks for registrering, You are a registered user now !!')
        return redirect('/login')
    return render_template('register.html', titles='Register', form=form)
Example #13
0
def add_category():
    """
    Adding new category to DB with fields from request form
    * better replace with arguments, to make method more independent
    """
    name = flask.request.form['name']
    owner = user_info()['id']
    new_category = Category(name, owner)

    session.add(new_category)
    session.commit()
Example #14
0
def update_category(category_id):
    """
    Updating category in DB with fields from request form
    * better replace with arguments, to make method more independent
    """
    name = flask.request.form['name']
    category_to_update = session.query(Category).get(category_id)
    category_to_update.name = name

    session.add(category_to_update)
    session.commit()
 def log_error_and_notify(message):
     """
     Helper method to log an error and save a notifcation
     """
     logger.error(message)
     notification = Notification(is_active=True,
                                 is_staff_only=True,
                                 severity='e',
                                 message=message)
     session.add(notification)
     session.commit()
Example #16
0
def update(_id):
    content = request.get_json()
    nom = content['nom']
    email = content['email']
    password = content['password']
    updated_user = Data.User(nom, email, password, kwargs={'id': _id})
    updated_user.id = _id
    session.merge(updated_user)
    session.flush()
    session.commit()

    return "user updated "
Example #17
0
def post():
    print(request.is_json)
    content = request.get_json()
    nom = content['nom']
    email = content['email']
    password = content['password']
    user = Data.User(nom, email, password)
    session.add(user)
    session.flush()
    session.commit()

    return 'User added'
Example #18
0
def newCategory():
    if not userIsLoggedIn():
        return redirect(url_for('showLogin'))
    if request.method == 'POST':
        newCategory = Category(name=request.form['name'])
        newCategory.user_id = login_session['user_id']
        session.add(newCategory)
        flash('New Category %s Successfully Created' % newCategory.name)
        session.commit()
        return redirect(url_for('showCategories'))
    else:
        return render_template('newCategory.html')
Example #19
0
 def _get_status(status_value):
     """
     Helper method that will try to get a status matching the given name or create one if it doesn't yet exist
     """
     status = session.query(Status).filter_by(value=status_value)[0]
     if status is None:
         new_status = Status(value=status_value)
         session.add(new_status)
         session.commit()
         status = session.query(InstrumentVariable).filter_by(value=status_value)[0]
         logger.warn("%s status was not found, created it." % status_value)
     return status
Example #20
0
 def add_user(self, user_id):
     """
     Добавляем пользователя в БД.
     """
     candidate_user = User(user_id=user_id, green_points=0, green_tickets=0)
     session.add(candidate_user)
     try:
         session.commit()
         return True
     except sqlalchemy.exc.IntegrityError:
         session.rollback()
         return False
Example #21
0
    def reduction_complete(self):
        try:
            logger.info("Run %s has completed reduction" %
                        self._data_dict['run_number'])
            reduction_run = self.find_run()

            if reduction_run:
                if reduction_run.status.value == "Processing":
                    reduction_run.status = StatusUtils().get_completed()
                    reduction_run.finished = datetime.datetime.now()
                    for name in ['message', 'reduction_log', 'admin_log']:
                        setattr(reduction_run, name,
                                self._data_dict.get(name, ""))
                    if 'reduction_data' in self._data_dict:
                        for location in self._data_dict['reduction_data']:
                            reduction_location = ReductionLocation(
                                file_path=location,
                                reduction_run=reduction_run)
                            session.add(reduction_location)
                            session.commit()

                            # Get any .png files and store them as base64 strings
                            # Currently doesn't check sub-directories
                            graphs = glob.glob(location + '*.[pP][nN][gG]')
                            for graph in graphs:
                                with open(graph, "rb") as image_file:
                                    encoded_string = 'data:image/png;base64,' + base64.b64encode(
                                        image_file.read())
                                    if reduction_run.graph is None:
                                        reduction_run.graph = [encoded_string]
                                    else:
                                        reduction_run.graph.append(
                                            encoded_string)
                    session.add(reduction_run)
                    session.commit()

                else:
                    logger.error(
                        "An invalid attempt to complete a reduction run that wasn't processing has been "
                        "captured. Experiment: %s, Run Number: %s, Run Version %s"
                        % (self._data_dict['rb_number'],
                           self._data_dict['run_number'],
                           self._data_dict['run_version']))
            else:
                logger.error(
                    "A reduction run completed that wasn't found in the database. Experiment: %s, Run Number: "
                    "%s, Run Version %s" % (self._data_dict['rb_number'],
                                            self._data_dict['run_number'],
                                            self._data_dict['run_version']))

        except BaseException as e:
            logger.error("Error: %s" % e)
Example #22
0
 def insert_member(member):
     """
     Persists member data into database
     :param member: the member data
     :return:
     """
     assert member is not None, 'Member not specified'
     try:
         session.add(member)
         # Commit session
         session.commit()
     except (exc.SQLAlchemyError, exc.DBAPIError) as e:
         logging.error("Failed to insert member: [" + member.to_string() + "]: " + str(e))
Example #23
0
def add_item(category_id):
    """
    Adding item to DB with fields from request form
    * better replace with arguments, to make method more independent
    """
    name = flask.request.form['name']
    owner = user_info()['id']
    description = flask.request.form['description']
    new_item = Item(name, description, owner)
    new_item.category_id = category_id

    session.add(new_item)
    session.commit()
Example #24
0
def update_item(item_id):
    """
    Updating item in DB with fields from request form
    * better replace with arguments, to make method more independent
    """
    name = flask.request.form['name']
    description = flask.request.form['description']

    item_to_update = session.query(Item).get(item_id)
    item_to_update.name = name
    item_to_update.description = description

    session.add(item_to_update)
    session.commit()
Example #25
0
def deleteCategory(category_id):
    categoryToDelete = session.query(
        Category).filter_by(id=category_id).one()

    if not userIsOwner(categoryToDelete.user_id):
        return redirect(url_for('showLogin'))

    if request.method == 'POST':
        session.delete(categoryToDelete)
        flash('%s Successfully Deleted' % categoryToDelete.name)
        session.commit()
        return redirect(url_for('showCategories', category_id=category_id))
    else:
        return render_template('deleteCategory.html', category=categoryToDelete)
Example #26
0
def deleteItem(category_id, item_id):
    category = session.query(Category).filter_by(id=category_id).one()
    itemToDelete = session.query(Item).filter_by(id=item_id).one()

    if not userIsOwner(itemToDelete.user_id):
        return redirect(url_for('showLogin'))

    if request.method == 'POST':
        session.delete(itemToDelete)
        session.commit()
        flash('Menu Item Successfully Deleted')
        return redirect(url_for('showItems', category_id=category_id))
    else:
        return render_template('deleteItem.html', item=itemToDelete)
Example #27
0
 def insert_location(location):
     """
     Persists location data into database
     :param location: the location data
     :return:
     """
     assert location is not None, 'Location not specified'
     try:
         session.add(location)
         # Commit session
         session.commit()
     except (exc.SQLAlchemyError, exc.DBAPIError) as e:
         logging.error("Failed to insert location: [" +
                       location.to_string() + "]: " + str(e))
Example #28
0
 def add_points(self, user_id, item_id):
     """
     Дабавляем бонусы за переработку/утилизация
     Если ранее пользователь не пользовался приложением
     он заносится в БД.
     """
     user_id = session.query(User).filter(User.user_id == user_id).all()
     item_green_point = 12.5
     User.green_points += item_green_point
     try:
         session.commit()
         return True
     except sqlalchemy.exc.IntegrityError:
         return False
Example #29
0
    def reduction_error(self):
        if 'message' in self._data_dict:
            logger.info(
                "Run %s has encountered an error - %s" %
                (self._data_dict['run_number'], self._data_dict['message']))
        else:
            logger.info(
                "Run %s has encountered an error - No error message was found"
                % (self._data_dict['run_number']))

        reduction_run = self.find_run()

        if not reduction_run:
            logger.error(
                "A reduction run that caused an error wasn't found in the database. Experiment: %s, "
                "Run Number: %s, Run Version %s" %
                (self._data_dict['rb_number'], self._data_dict['run_number'],
                 self._data_dict['run_version']))
            return

        reduction_run.status = StatusUtils().get_error()
        #  TODO : Here, and in other places where datetime is used, need to make sure we are using GMT.
        reduction_run.finished = datetime.datetime.now()
        for name in ['message', 'reduction_log', 'admin_log']:
            setattr(reduction_run, name, self._data_dict.get(name, ""))
        session.add(reduction_run)
        session.commit()

        if 'retry_in' in self._data_dict:
            experiment = session.query(Experiment).filter_by(
                reference_number=self._data_dict['rb_number']).first()
            previous_runs = session.query(ReductionRun).filter_by(
                run_number=self._data_dict['run_number'],
                experiment=experiment).all()
            max_version = -1
            for previous_run in previous_runs:
                current_version = previous_run.run_version
                if current_version > max_version:
                    max_version = current_version

            # If we have already tried more than 5 times, we want to give up and we don't want to retry the run
            if max_version <= 4:
                self.retry_run(reduction_run, self._data_dict["retry_in"])
            else:
                # Need to delete the retry_in entry from the dictionary so that the front end doesn't report a false
                # retry instance.
                del self._data_dict['retry_in']

        self.notify_run_failure(reduction_run)
Example #30
0
def get_new_yaks():
  yaks = client.get_new_yaks(config['lat'], config['long'])
  for yak in yaks:
    cur_yak = session.query(db.Yak).filter_by(yid=yak.message_id).first()
    if not cur_yak:
      cur_yak = db.Yak(yid=yak.message_id, time=yak.time, text=yak.message, score=yak.number_of_likes, handle=yak.nickname or '')
      print(' NEW:', repr(cur_yak))
      session.add(cur_yak)
    else:
      if cur_yak.score != yak.number_of_likes:
        diff = yak.number_of_likes - cur_yak.score
        cur_yak.score = yak.number_of_likes
        print('{: =+4}:'.format(diff), repr(cur_yak))

  session.commit()
Example #31
0
 def delete_member(member):
     """
     Delete the member data from database
     :param member:
     :return:
     """
     assert member is not None, 'Member not specified'
     try:
         session.query(Member)\
             .filter(Member.member_id == member.member_id)\
             .delete()
         # Commit session
         session.commit()
     except (exc.SQLAlchemyError, exc.DBAPIError) as e:
         logging.error("Failed to delete member [" + member.to_string() + "]: " + str(e))
Example #32
0
    def from_xml(node):
        # if question already has ID assigned, fetch it
        if 'id' in node.attrib:
            question = session.query(Question).get(node.attrib['id'])
        # otherwise, create a new one
        else:
            if 'review' in node.attrib and 't' in node.attrib['review'].lower():
                question = PeerReview()
            else:
                question = Question()
            session.add(question)
            session.flush()

        question.sync_from_node(node)
        session.commit()

        return question
Example #33
0
 def submit_response(self, stuid, responses):
     from queries import get_last_question_response
     last_submission = get_last_question_response(self.id, stuid)
     if not self.check_if_locked(last_submission):
         item_responses = [ItemResponse(item_id=item.id, response=response) \
                               for item, response in zip(self.items, responses)]
         score, comments = self.check(responses)
         question_response = QuestionResponse(
             stuid=stuid,
             time=pdt_now(),
             question_id=self.id,
             item_responses=item_responses,
             score=score,
             comments=comments
             )
         session.add(question_response)
         session.commit()
         return {
             'submission': self.delay_feedback(question_response),
             'locked': self.check_if_locked(question_response),
         }
     else:
         raise Exception("The deadline for submitting this homework has passed.")
Example #34
0
def assign_tasks(hw_id, due_date, send_emails=False):

    homework = session.query(Homework).get(hw_id)
    
    users = session.query(User).filter(User.type == "student").order_by(User.stuid).all()

    for q in homework.questions:
        # only if this is a peer graded question
        if not isinstance(q.items[0], LongAnswerItem):
            continue

        random.seed(q.id)  # setting a seed will be useful for debugging

        responsible_kids = list()   # did the homework!
        irresponsible_kids = list() # didn't do the homework!

        # Figure out who did the homework
        for user in users:
            if get_last_question_response(q.id, user.stuid):
                responsible_kids.append(user.stuid)
            else:
                irresponsible_kids.append(user.stuid)

        # Make the assignments for the responsible kids
        n = len(responsible_kids)
        random.shuffle(responsible_kids)
        for i, stuid in enumerate(responsible_kids):

            # Make the assignments for this responsible student
            for offset in [1, 3, 6]:
                j = (i + offset) % n
                gt = GradingTask(grader=stuid,
                                 student=responsible_kids[j],
                                 question_id=q.id)
                session.add(gt)

        # Make the assignments for the irresponsible kids:
        # Do so in round robin order, shuffling the responsible students again
        # to minimize the number of pairs of students grading together.
        random.shuffle(responsible_kids)
        for i, stuid in enumerate(irresponsible_kids):

            # Make the assignments for this irresponsible student
            for offset in range(3):
                j = (i * 3 + offset) % n
                gt = GradingTask(grader=stuid,
                                 student=responsible_kids[j],
                                 question_id=q.id)
                session.add(gt)

        # Make all self-assignments
        for stuid in (responsible_kids + irresponsible_kids):
            gt = GradingTask(grader=stuid,
                             student=stuid,
                             question_id=q.id)
            session.add(gt)

    session.commit()

    if not send_emails:
        return "Successfully assigned %d students"

    # Send email notifications to all the students
    send_all(users, "Peer Assessment for %s is Ready" % homework.name[:-1],
r"""Dear %s,

We've made the peer-grading assignments for this week. The assessments
are due {due_date}, and you can start after lecture today at 11:00AM.

You will be able to view your peer's comments on your answers as they 
are submitted, but your score will not be available until {due_date}. 
At that time, please log in to view and respond to the comments you 
received from your peers.

Best,
STATS 60 Staff""".format(due_date=due_date.strftime("%A, %b %d at %I:%M %p")))

    # Send email to the course staff
    admins = session.query(User).filter_by(type="admin").all()
    send_all(admins, "Peer Assessment for %s is Ready" % homework.name[:-1],
r"""Dear %s (and other members of the STATS 60 Staff),

Just letting you know that the peer assessment for this week was just released. 
It is due at {due_date}.

Sincerely,
OHMS

P.S. This is an automatically generated message ;-)
""".format(due_date=due_date.strftime("%A, %b %d at %I:%M %p")))

    return r'''Successfully assigned %d students. You should have received an 
e-mail confirmation.''' % len(users)
Example #35
0
def add_grade(student, homework, score, excused=False):
    grade = Grade(student=student, homework=homework, 
                  score=score, excused=excused)
    session.add(grade)
    session.commit()
Example #36
0
File: admin.py Project: dlsun/ohms
    @app.errorhandler(Exception)
    def handle_exceptions(error):
        return make_response(error.message, 403)

    stuid = auth_stuid()
    if not stuid:
        raise Exception("You are no longer logged in. Please refresh the page.")
    try:
        user = get_user(stuid)
    except:
        user = User(stuid=stuid,
                    name=auth_student_name(),
                    type="student")
        session.add(user)
        session.commit()

@app.route("/")
def index():
    return render_template("admin/index.html", options=options, user=user)


@app.route("/reminder_email/<int:hw_id>", methods=['POST'])
def reminder_email(hw_id):

    homework = session.query(Homework).get(hw_id)

    # get users who haven't completed peer grading
    users = set()
    for question in homework.questions:
        tasks = session.query(GradingTask).join(QuestionResponse).\