Python flask.ext.login 模块，current_user() 实例源码

def new_post():
    """View function for new_port."""

    form = PostForm()

    # Ensure the user logged in.
    # Flask-Login.current_user can be access current user.
    if not current_user:
        return redirect(url_for('main.login'))

    # Will be execute when click the submit in the create a new post page.
    if form.validate_on_submit():
        new_post = Post()
        new_post.title = form.title.data
        new_post.text = form.text.data
        new_post.publish_date = datetime.now()
        new_post.user = current_user

        db.session.add(new_post)
        db.session.commit()
        return redirect(url_for('blog.home'))

    return render_template('new_post.html',
                           form=form)

def post(id):
    # Detail ???
    post = Post.query.get_or_404(id)

    # ????
    form = CommentForm()

    # ????
    if form.validate_on_submit():
        comment = Comment(author=current_user,
                          body=form.body.data,
                          post=post)
        db.session.add(comment)
        db.session.commit()

    return render_template('posts/detail.html',
                           title=post.title,
                           form=form,
                           post=post)

def monitor_required(func):
  @functools.wraps(func)
  def monitor_required_func(*args, **kwargs):
    if login.current_user.is_authenticated() and login.current_user.is_monitor():
      if login.current_user.get_id() != 'monitor':
        logging.info(u'Monitor "%s" accessed "%s"',
          login.current_user.get_id(), flask.request.url)
      return func(*args, **kwargs)
    else:
      logging.warning(u'Unknown user "%s" tried to access monitor page "%s"',
        login.current_user.get_id(), flask.request.url)
      return flask.abort(403)  # forbidden
  return monitor_required_func


# Set function to load a user

def courses_x_download_grades(course_name):
  user = login.current_user
  course = grade_oven.course(course_name)
  instructs_course = user.instructs_course(course_name)
  takes_course = user.takes_course(course_name)
  if instructs_course:
    header_row, table = _make_grades_table(course, instructs_course)
    buf = cStringIO.StringIO()
    writer = csv.writer(buf)
    writer.writerow(header_row)
    for row in table:
      writer.writerow([x.encode('utf-8') for x in row])
    response = flask.make_response(buf.getvalue())
    response.headers['Content-Disposition'] = 'attachment; filename=grades.csv'
    return response
  else:
    return flask.redirect(u'/courses/{}'.format(course_name), code=303)

def courses_x_assignments_x_download(course_name, assignment_name):
  user = login.current_user
  instructs_course = user.instructs_course(course_name)
  if instructs_course:
    stages = executor.Stages(os.path.join(
      '../data/files/courses', course_name, 'assignments', assignment_name))
    buf = cStringIO.StringIO()
    stages.save_zip(buf)
    response = flask.make_response(buf.getvalue())
    response.headers['Content-Disposition'] = (
      'attachment; filename={}.zip'.format(assignment_name))
    return response
  else:
    return flask.redirect(
      u'/courses/{}/assignments/{}'.format(course_name, assignment_name),
      code=303)

def courses_x_assignments_x_download_submissions(course_name, assignment_name):
  user = login.current_user
  instructs_course = user.instructs_course(course_name)
  if instructs_course:
    course = grade_oven.course(course_name)
    assignment = course.assignment(assignment_name)
    buf = cStringIO.StringIO()
    assignment.save_submissions_zip(buf)
    response = flask.make_response(buf.getvalue())
    response.headers['Content-Disposition'] = (
      'attachment; filename={} submissions.zip'.format(assignment_name))
    return response
  else:
    return flask.redirect(
      u'/courses/{}/assignments/{}'.format(course_name, assignment_name),
      code=303)

def courses_x_assignments_x_submissions(course_name, assignment_name):
  user = login.current_user
  course = grade_oven.course(course_name)
  assignment = course.assignment(assignment_name)
  instructs_course = user.instructs_course(course.name)
  student_submissions = []
  if instructs_course:
    form = flask.request.form
    student_username = form.get('_student_username')
    manual_score = form.get('manual_score')
    if student_username and manual_score is not None:
      submission = assignment.student_submission(student_username)
      try:
        submission.set_manual_score_portion(int(manual_score))
      except ValueError:
        flask.flash('Manual score "{}" is not an integer.'.format(manual_score))
    for student_username in course.student_usernames():
      student_submissions.append(assignment.student_submission(student_username))
  return flask.render_template(
    'courses_x_assignments_x_submissions.html',
    username=login.current_user.get_id(),
    instructs_course=instructs_course,
    course_name=course.name,
    assignment_name=assignment.name,
    student_submissions=student_submissions)

def login_():
  form = flask.request.form
  username = escape_lib.safe_entity_name(form.get('username'))
  password = form.get('password')
  if username and password:
    user = grade_oven_lib.GradeOvenUser.load_and_authenticate_user(
      data_store, username, password)
    if user is None:
      monitor_variables['login_failures'] += 1
      return flask.abort(401)
    else:
      monitor_variables['login_successes'] += 1
      login.login_user(user, remember=True)
      redirect = flask.request.args.get('redirect', '/')
      return flask.redirect(redirect, code=303)
  return flask.render_template(
    'login.html', username=login.current_user.get_id())

def rate_search():
        try:
            # FIXME: Verify user has yet to rate the entry
            # Using back button on front-end gets around front-end validation
            data = request.get_json(force=True) #request.form
            sid = data['id']
            s = Search.query.get(int(sid))
            user = flask_login.current_user
            if s is not None:
                rate_val = float(data['rating'])
                rating = Rating(user, rate_val)
                db.session.add(rating)
                json_dict = {'rating': rating.dictify() }
                s.add_rating(rating)
                db.session.commit()
                return flask.jsonify(**json_dict)
            else:
                abort(404)
        except (Exception) as e:
            # print("EXCEPTION: "+str(e))
            abort(422)

def room_show(room_id):
    room = Room.q.get(room_id)
    form = RoomLogEntry()

    if form.validate_on_submit():
        lib.logging.create_room_log_entry(message=form.message.data,
                                          timestamp=datetime.now(),
                                          author=current_user,
                                          room=room)
        flash(u'Kommentar hinzugefügt', 'success')

    room_log_list = room.room_log_entries[::-1]

    return render_template('dormitories/room_show.html',
        page_title=u"Raum " + str(room.dormitory.short_name) + u" " + \
                   str(room.level) + u"-" + str(room.number),
        room=room,
        room_log=room_log_list,
        form=form)

def create():
    form = UserCreateForm()
    if form.validate_on_submit():
        try:
            new_user = lib.user.move_in(name=form.name.data,
                login=form.login.data,
                dormitory=form.dormitory.data, level=form.level.data,
                room_number=form.room_number.data,
                host_name=form.host.data, mac=form.mac.data,
                current_semester=form.semester.data, processor=current_user,
                email=form.email.data)

            flash(u'Benutzer angelegt', 'success')
            return redirect(url_for('.user_show', user_id = new_user.id))

        except host.MacExistsException, error:
            flash(u'Duplicate MAC address (already present on one of the connected subnets)', 'error')

        except host.SubnetFullException, error:
            flash(u'Subnetz voll', 'error')

    return render_template('user/user_create.html', form = form)

def edit_name(user_id):
    user = User.q.get(user_id)
    if user is None:
        flash(u"Nutzer mit ID %s existiert nicht!" % (user_id,), 'error')
        abort(404)

    form = UserEditNameForm()

    if not form.is_submitted():
        form.name.data = user.name

    if form.validate_on_submit():
        edited_user = lib.user.edit_name(user, form.name.data, current_user)

        flash(u'Benutzername geändert', 'success')
        return redirect(url_for('.user_show', user_id=edited_user.id))

    return render_template('user/user_edit_name.html', user_id=user_id,
        form=form)

def edit_email(user_id):
    user = User.q.get(user_id)
    if user is None:
        flash(u"Nutzer mit ID %s existiert nicht!" % (user_id,), 'error')
        abort(404)

    form = UserEditEMailForm()

    if not form.is_submitted():
        form.email.data = user.email

    if form.validate_on_submit():
        edited_user = lib.user.edit_email(user, form.email.data, current_user)

        flash(u'E-Mail-Adresse geändert', 'success')
        return redirect(url_for('.user_show', user_id=edited_user.id))

    return render_template('user/user_edit_email.html', user_id=user_id,
        form=form)

def block(user_id):
    form = UserBlockForm()
    myUser = User.q.get(user_id)
    if form.validate_on_submit():
        end_date = datetime.combine(form.date.data, time(0))
        if form.unlimited.data:
            end_date = None

        try:
            blocked_user = lib.user.block(
                user=myUser,
                date=end_date,
                reason=form.reason.data,
                processor=current_user)
        except ValueError as e:
            flash(e.message, 'error')
        else:
            flash(u'Nutzer gesperrt', 'success')
            return redirect(url_for('.user_show', user_id=user_id))
    return render_template('user/user_block.html', form=form, user_id=user_id)

def move_out(user_id):
    form = UserMoveOutForm()
    myUser = User.q.get(user_id)
    if myUser is None:
        flash(u"Nutzer mit ID %s existiert nicht!" % (user_id,), 'error')
        abort(404)
    if form.validate_on_submit():
        lib.user.move_out(
            user=myUser,
            date=datetime.combine(form.date.data, time(0)),
            processor=current_user,
            comment=form.comment.data
        )
        flash(u'Nutzer wurde ausgezogen', 'success')
        return redirect(url_for('.user_show', user_id=myUser.id))
    return render_template('user/user_moveout.html', form=form, user_id=user_id)

def move_out_tmp(user_id):
    form = UserMoveOutForm()
    my_user = User.q.get(user_id)
    if my_user is None:
        flash(u"Nutzer mit ID %s existiert nicht!" % (user_id,), 'error')
        abort(404)
    if form.validate_on_submit():
        changed_user = lib.user.move_out_tmp(
            user=my_user,
            date=datetime.combine(form.date.data,time(0)),
            comment=form.comment.data,
            processor=current_user
        )
        flash(u'Nutzer zieht am %s vorübegehend aus' % form.date.data,
            'success')
        return redirect(url_for('.user_show', user_id=changed_user.id))
    return render_template('user/user_moveout.html', form=form, user_id=user_id)

def check_user():
    """Check the user whether logged in."""

    if 'username' in session:
        g.current_user = User.query.filter_by(
            username=session['username']).first()
    else:
        g.current_user = None

def edit(id=0):
    form = PostForm()
    post = None
    if id == 0:
        post = Post(author=current_user)
    else:
        post = Post.query.get_or_404(id)

    if form.validate_on_submit():
        post.body = form.body.data
        post.title = form.title.data
        # print "post.title=%s \n post.body=%s" % (post.title,post.body)

        db.session.add(post)
        db.session.commit()

        return redirect(url_for('.post', id=post.id))

    form.title.data = post.title
    form.body.data = post.body

    title = u'?????'
    if id > 0:
        # title = _(u'?? - %(title)', title=post.title)
        title = u'?? - %' % post.title

    if post.title == None and   post.body == None:
        return render_template('posts/edit.html',
                           title=title,
                           form=form)

    return render_template('posts/edit.html',
                           title=title,
                           form=form,
                           post=post)

def nothing_required(func):
  @functools.wraps(func)
  def nothing_required_func(*args, **kwargs):
    logging.info(u'User "%s" accessed public page "%s"',
      login.current_user.get_id(), flask.request.url)
    return func(*args, **kwargs)
  return nothing_required_func

def login_required(func):
  @functools.wraps(func)
  def login_required_func(*args, **kwargs):
    if login.current_user.is_authenticated():
      logging.info(u'User "%s" accessed "%s"',
        login.current_user.get_id(), flask.request.url)
      return func(*args, **kwargs)
    else:
      logging.info(u'Unknown user "%s" tried to access "%s"',
        login.current_user.get_id(), flask.request.url)
      return flask.redirect(
        u'/login?redirect={}'.format(flask.request.path), code=303)
  return login_required_func

def admin_required(func):
  @functools.wraps(func)
  def admin_required_func(*args, **kwargs):
    if login.current_user.is_authenticated() and login.current_user.is_admin():
      logging.info(u'Admin "%s" accessed "%s"',
        login.current_user.get_id(), flask.request.url)
      return func(*args, **kwargs)
    else:
      logging.warning(u'Unknown user "%s" tried to access admin page "%s"',
        login.current_user.get_id(), flask.request.url)
      return flask.abort(403)  # forbidden
  return admin_required_func

def about():
  return flask.render_template(
    'about.html', username=login.current_user.get_id())

def admin_edit_user():
  form = flask.request.form
  usernames = form.get('usernames')
  if usernames:
    usernames = [escape_lib.safe_entity_name(u)
                 for u in re.split('\s|,|;', usernames) if u]
  else:
    usernames = []
  password = form.get('password')
  password2 = form.get('password2')
  is_admin = _select_to_bool(form.get('is_admin'))
  is_monitor = _select_to_bool(form.get('is_monitor'))
  is_instructor = _select_to_bool(form.get('is_instructor'))
  course = form.get('course')
  instructs_course = _select_to_bool(form.get('instructs_course'))
  takes_course = _select_to_bool(form.get('takes_course'))
  errors = []
  msgs = []
  passwords = []
  if not password and not password2:
    if usernames:
      msgs.append('"Username","Generated Password"')
    for username in usernames:
      user = grade_oven.user(username)
      if not user.has_password():
        generated_password = bcrypt.gensalt()[7:]
        passwords.append(generated_password)
        msgs.append('"{}","{}"'.format(username, generated_password))
      else:
        passwords.append(None)
  elif password != password2:
    errors.append('Password and password confirmation do not match.')
  else:  # password == password2:
    passwords = [password for _ in xrange(len(usernames))]
  for username, password_ in itertools.izip(usernames, passwords):
    _add_edit_user(username, password_, is_admin, is_monitor, is_instructor,
                   course, instructs_course, takes_course, True, msgs)
  return flask.render_template(
    'admin_edit_user.html', username=login.current_user.get_id(), errors=errors, msgs=msgs)

def admin_db(key):
  key = key.split('/')
  key_parts = []
  parts_so_far = []
  for part in key:
    parts_so_far.append(part)
    key_parts.append(('/'.join(parts_so_far), part))
  data = repr(data_store.get(key))
  sub_dirs = data_store.get_all(key)
  return flask.render_template(
    'admin_db.html', username=login.current_user.get_id(), key=key_parts,
    data=data, sub_dirs=sub_dirs)

def monitor_logs():
  log_names = os.listdir('../data/logs')
  return flask.render_template(
    'monitor_logs.html', username=login.current_user.get_id(),
    log_names=log_names)

def monitor_logs_x(log_name):
  errors = []
  safe_log_name = escape_lib.safe_entity_name(log_name)
  if safe_log_name != log_name:
    logging.error(u'User "%s" requsted bad log name "%s".',
      login.current_user.get_id(), log_name)
    return flask.redirect('/monitor/logs/' + safe_log_name)

  log_data = '<COULD NOT READ LOG>'
  max_bytes = flask.request.args.get('max_bytes', 100 * 1024)
  try:
    max_bytes = int(max_bytes)
  except ValueError as e:
    errors.append(u'max_bytes "{}" is not an int: {}'.fomrat(max_bytes, e))
    logging.error(errors[-1])
    max_bytes = 100 * 1024
  line_regex = flask.request.args.get('line_regex', '')
  try:
    with open(os.path.join('../data/logs', log_name)) as f:
      f.seek(0, os.SEEK_END)
      f_size = f.tell()
      f.seek(max(0, f_size - max_bytes), os.SEEK_SET)
      log_data = f.read(max_bytes)
      if line_regex:
        compiled_line_regex = re.compile(line_regex)  # This may raise an exception.
        log_data = '\n'.join(
          line for line in log_data.split('\n') if compiled_line_regex.match(line))
  except (OSError, IOError) as e:
    errors.append(u'Could not read log:\n{!r}\n{}'.format(e, e))
    log_data = ''
  return flask.render_template(
    'monitor_logs_x.html', username=login.current_user.get_id(),
    log_name=log_name, log_data=log_data, errors=errors, max_bytes=max_bytes,
    line_regex=line_regex)

def debug_logged_in():
  return u'Logged in as {}.'.format(cgi.escape(login.current_user.get_id()))

def courses_x_assignments(course_name):
  user = login.current_user
  course = grade_oven.course(course_name)
  instructs_course = user.instructs_course(course_name)
  takes_course = user.takes_course(course_name)
  assignment_names = course.assignment_names()
  return flask.render_template(
    'courses_x_assignments.html', username=login.current_user.get_id(),
    instructs_course=instructs_course,
    takes_course=takes_course, assignments=assignment_names,
    course_name=course.name)

def courses_x_assignments_x_edit(course_name, assignment_name):
  user = login.current_user
  instructs_course = user.instructs_course(course_name)
  if instructs_course:
    stages = executor.Stages(os.path.join(
      '../data/files/courses', course_name, 'assignments', assignment_name))
    form = flask.request.form
    for error in _edit_assignment(form, course_name, assignment_name, stages):
      flask.flash(error)
  return flask.redirect(
    u'/courses/{}/assignments/{}'.format(course_name, assignment_name),
    code=303)

def courses_x_assignments_x_submit(course_name, assignment_name):
  user = login.current_user
  takes_course = user.takes_course(course_name)
  if takes_course:
    files = flask.request.files.getlist('submission_files[]')
    if files:
      _enqueue_student_submission(course_name, assignment_name, user.username, files)
  return flask.redirect(
    u'/courses/{}/assignments/{}'.format(course_name, assignment_name),
    code=303)

# TODO: This is very specific to Canvas as of 2017-03. Make it generic.
# TODO: This function exposes too many internals. Encapsulate them.
# TODO: This function reimplements logic that is elsewhere. Reuse code.

def courses_x_assignments_x_resubmit_all(course_name, assignment_name):
  user = login.current_user
  instructs_course = user.instructs_course(course_name)
  files = None
  if instructs_course:
    for username in grade_oven.course(course_name).student_usernames():
      _enqueue_student_submission(course_name, assignment_name, username, files)
  return flask.redirect(
    u'/courses/{}/assignments/{}'.format(course_name, assignment_name),
    code=303)

def courses_x_assignments_x(course_name, assignment_name):
  user = login.current_user
  course = grade_oven.course(course_name)
  assignment = course.assignment(assignment_name)
  student_submission = assignment.student_submission(user.username)
  instructs_course = user.instructs_course(course.name)
  takes_course = user.takes_course(course.name)
  stages = executor.Stages(os.path.join(
    '../data/files/courses', course.name, 'assignments', assignment.name))
  if takes_course:
    due_date = assignment.due_date()
    if due_date is None:
      formatted_due_date = ''
    else:
      formatted_due_date = time.strftime('%Y-%m-%d %H:%M',
                                         time.localtime(due_date))
    submission_output = student_submission.output()
    submission_has_output_html = bool(student_submission.output_html())
    submission_errors = student_submission.errors().strip()
  else:
    formatted_due_date = ''
    submission_output, submission_errors = '', ''
    submission_has_output_html = False
  header_row, table = _make_grade_table(
    course, assignment, show_real_names=instructs_course)
  return flask.render_template(
    'courses_x_assignments_x.html',
    username=login.current_user.get_id(),
    instructs_course=instructs_course,
    takes_course=takes_course,
    course_name=course.name,
    assignment_name=assignment.name,
    formatted_due_date=formatted_due_date,
    stages=stages.stages.values(),
    submission_output=submission_output,
    submission_has_output_html=submission_has_output_html,
    submission_errors=submission_errors,
    stages_desc=stages.description,
    header_row=header_row,
    table=table)

def settings():
  user = login.current_user
  errors = []

  form = flask.request.form
  real_name = form.get('real_name')
  if real_name:
    real_name = real_name[:256]
    user.set_real_name(real_name)
  display_name = form.get('display_name')
  if display_name:
    display_name = display_name[:30]
    user.set_display_name(display_name)
  prefers_anonymity = form.get('prefers_anonymity')
  if prefers_anonymity:
    user.set_prefers_anonymity(True)
  else:
    user.set_prefers_anonymity(False)
  password = form.get('password')
  password2 = form.get('password2')
  if password or password2:
    if password == password2:
      user.set_password(password)
    else:
      errors.append('Passwords do not match.')

  return flask.render_template(
    'settings.html', username=login.current_user.get_id(),
    real_name=user.real_name(), display_name=user.display_name(),
    prefers_anonymity=user.prefers_anonymity(), errors=errors)

def index():
  if login.current_user.is_authenticated():
    if login.current_user.is_admin():
      return flask.redirect('/admin')
    else:
      return flask.redirect('/courses')
  else:
    return flask.redirect('/login')

def hello():
    loggedIn = False
    if flask_login.current_user.is_authenticated:
        loggedIn = True
    return render_template('index.html',loggedIn=loggedIn)

def me():
    user = flask_login.current_user
    rated = set()
    for search in user.searches:
        for rating in search.ratings:
            if rating.user_id == user.id:
                rated.add(search.id)
                break
    return render_template('user.html',user=user, rated=rated)


# Look at file 'sample_json_search_request.json' to see sample json data in post request this function accepts
# Though it wouldn't be difficult to change the format of the json data if needed to interact with the front-end

def delete_account():
    user = flask_login.current_user
    if request.method == 'GET':
        return render_template('delete-account.html',
                               user=user)
    else:
        dbu = User.query.get(user.id)
        logout_user()
        db.session.delete(dbu)
        db.session.commit()
        return redirect('/', code=303)

def add_membership(user_id):

    user = User.q.get(user_id)
    if user is None:
        flash(u"Nutzer mit ID %s existiert nicht!" % (user_id,), 'error')
        abort(404)

    form = UserAddGroupMembership()
    if form.validate_on_submit():
        if form.begin_date.data is not None:
            start_date = datetime.combine(form.begin_date.data, time(0))
        else:
            start_date = datetime.now()
        if not form.unlimited.data:
            end_date = datetime.combine(form.end_date.data, time(0))
        else:
            end_date=None
        lib.property.create_membership(
            user=user,
            group=form.group_id.data,
            start_date=start_date,
            end_date=end_date)
        lib.logging.create_user_log_entry(author=current_user,
                message=u"hat Nutzer zur Gruppe '%s' hinzugefügt." %
                form.group_id.data.name,
                timestamp=datetime.now(),
                user=user)

        flash(u'Nutzer wurde der Gruppe hinzugefügt.', 'success')

        return redirect(url_for(".user_show", user_id=user_id))

    return render_template('user/add_membership.html',
        page_title=u"Neue Gruppenmitgliedschaft für Nutzer %s" % user_id,
        user_id=user_id, form=form)

def end_membership(membership_id):
    membership = Membership.q.get(membership_id)
    membership.disable()

    # ToDo: Make the log messages not Frontend specific (a helper?)
    lib.logging.create_user_log_entry(author=current_user,
            message=u"hat die Mitgliedschaft des Nutzers"
                u" in der Gruppe '%s' beendet." %
                membership.group.name,
            timestamp=datetime.now(),
            user=membership.user)

    flash(u'Mitgliedschaft in Gruppe beendet', 'success')
    return redirect(url_for(".user_show", user_id=membership.user_id))

def edit_membership(membership_id):
    membership = Membership.q.get(membership_id)

    if membership is None:
        flash(u"Gruppenmitgliedschaft mit ID %s existiert nicht!" % (
        membership_id), 'error')
        abort(404)

    form = UserEditGroupMembership()
    if request.method == 'GET':
        form.begin_date.data = membership.start_date
        if membership.start_date < datetime.now():
            form.begin_date.disabled = True

        if membership.end_date is not None:
            form.end_date.data = membership.end_date

    if form.validate_on_submit():
        membership.start_date = datetime.combine(form.begin_date.data, datetime.min.time())
        if form.unlimited.data:
            membership.end_date = None
        else:
            membership.end_date = datetime.combine(form.end_date.data, datetime.min.time())

        session.commit()
        flash(u'Gruppenmitgliedschaft bearbeitet', 'success')
        lib.logging.create_user_log_entry(author=current_user,
            message=u"hat die Mitgliedschaft des Nutzers"
                u" in der Gruppe '%s' bearbeitet." %
                membership.group.name,
            timestamp=datetime.now(),
            user=membership.user)
        return redirect(url_for('.user_show', user_id=membership.user_id))

    return render_template('user/user_edit_membership.html',
                           page_title=u"Mitgliedschaft %s für %s bearbeiten" % (membership.group.name, membership.user.name),
                           membership_id=membership_id,
                           user = membership.user,
                           form = form)

def is_back(user_id):
    my_user = User.q.get(user_id)
    changed_user = lib.user.is_back(user=my_user, processor=current_user)
    flash(u'Nutzer ist zurück', 'success')
    return redirect(url_for('.user_show', user_id=changed_user.id))

def login():
    if request.method == 'POST':
        email = request.form['email']
        pw = request.form['pw']
        user = User.query.filter_by(email=email).first()
        if user is not None:
            if sha256_crypt.verify(pw, user.hash):
                # flask_login.login_user(user) #call is not working
                flask_login.current_user = user
                flask_login.remember_me = True
                return redirect(url_for('index'))
        return redirect(url_for('login'))
    elif request.method == 'GET':
        return render_template('login.html')

def index(name=None):
    return render_template('index.html', current_user=flask_login.current_user, tasks = twl.get_tables())

def add_package():
    """
    add a new Package
    :return: "1"
    """

    i = 0
    paths = json.loads(request.form["paths"])
    for path in paths:
        paths[i] = html.unescape(path)
        path = paths[i]
        if not os.path.isfile(path):
            print(path + " does not exist..")
            return "not_existing"

        i += 1

    last_package = Package.query.filter_by(queue=True).order_by(Package.position.desc()).limit(1).first()
    if not last_package:
        position = 0
    else:
        position = last_package.position + 1

    package = Package(user=current_user, title=request.form["title"], queue=(request.form["queue"] == "1"),
                      position=position)
    db.session.add(package)

    file_pos = 0
    for path in paths:
        file = File(filename=path, size=os.path.getsize(path), status=StatusMap.queued.value, position=file_pos)
        package.files.append(file)
        file_pos += 1

    db.session.commit()

    # after adding, see if we have to start processes
    ProcessRepository.check_and_start_processes()
    return "1"

def the_user(self):
        """Get the user object associated with this form.  Default is
        :data:`~flask.ext.login.current_user`.
        """
        return getattr(self, '_m_the_user', current_user)

def edit_post(id):
    """View function for edit_post."""

    post = Post.query.get_or_404(id)

    # Ensure the user logged in.
    if not current_user:
        return redirect(url_for('main.login'))

    # Only the post onwer can be edit this post.
    if current_user != post.user:
        return redirect(url_for('blog.post', post_id=id))

    # Admin can be edit the post.
    permission = Permission(UserNeed(post.user.id))
    if permission.can() or admin_permission.can():
        form = PostForm()

        # if current_user != post.user:
        #    abort(403)

        if form.validate_on_submit():
            post.title = form.title.data
            post.text = form.text.data
            post.publish_date = datetime.now()

            # Update the post
            db.session.add(post)
            db.session.commit()

            return redirect(url_for('blog.post', post_id=post.id))
    else:
        abort(403)

    # Still retain the original content, if validate is false.
    form.title.data = post.title
    form.text.data = post.text
    return render_template('edit_post.html', form=form, post=post)


# NOTE(Jmilk Fan): Use the Flask-Login's current_user object to replace
#                  g.current_user
# @blog_blueprint.before_request

def courses_x(course_name):
  user = login.current_user
  course = grade_oven.course(course_name)
  instructs_course = user.instructs_course(course_name)
  takes_course = user.takes_course(course_name)
  if instructs_course:
    form = flask.request.form
    # Add/Edit assignment
    assignment_name = escape_lib.safe_entity_name(form.get('assignment_name'))
    if assignment_name:
      assignment_zips = flask.request.files.getlist('assignment_zips[]')
      if assignment_zips:
        for file_obj in assignment_zips:
          course.add_assignment_from_zip(
            file_obj,
            assignment_name,
            '../data/files/courses/{}/assignments'.format(course_name))
      else:
        course.add_assignment(assignment_name)
      return flask.redirect(
        u'/courses/{}/assignments/{}'.format(course_name, assignment_name))
    # Enroll students
    add_students = escape_lib.safe_entity_name(form.get('add_students'))
    if add_students:
      course.add_students(add_students.split())
    # Unenroll students
    remove_students = escape_lib.safe_entity_name(form.get('remove_students'))
    if remove_students:
      course.remove_students(remove_students.split())
    student_usernames = course.student_usernames()
    psuedo_usernames = []
    for student_username in student_usernames:
      u = grade_oven.user(student_username)
      psuedo_usernames.append(
        u'{} ({})'.format(student_username, u.display_name()))
    student_usernames = psuedo_usernames
  else:
    student_usernames = None
  grades_header_row, grades_table = _make_grades_table(course, show_real_names=instructs_course)
  assignment_names = course.assignment_names()
  return flask.render_template(
    'courses_x.html', username=login.current_user.get_id(),
    instructs_course=instructs_course,
    takes_course=takes_course,
    assignments=assignment_names, course_name=course.name,
    grades_header_row=grades_header_row, grades_table=grades_table)

def courses_x_assignments_x_submit_all(course_name, assignment_name):
  user = login.current_user
  instructs_course = user.instructs_course(course_name)
  files = None
  if instructs_course:
    student_usernames = frozenset(
      grade_oven.course(course_name).student_usernames())
    # Build map of normalized_student_real_names to potential student_usernames
    normalized_student_real_names = collections.defaultdict(set)
    for student_username in student_usernames:
      student_user = grade_oven.user(student_username)
      real_name = student_user.real_name()
      normalized_student_real_names[real_name].add(student_username)
      real_name_parts = real_name.lower().split()
      for name_parts in itertools.permutations(
          real_name_parts, min(4, len(real_name_parts))):
        normalized_student_real_names[''.join(name_parts)].add(student_username)
    files = flask.request.files.getlist('all_submission_files[]')
    temp_dirname = tempfile.mkdtemp()
    if 1:
      for f in files:
        with zipfile.ZipFile(f.stream, 'r') as zf:
          for filename in zf.namelist():
            normalized_real_name = filename.split('_', 1)[0]
            student_usernames = normalized_student_real_names[normalized_real_name]
            if len(student_usernames) == 0:
              flask.flash(
                'Zipped file "{}" could not be associated with any student.'.format(
                  filename))
            elif len(student_usernames) > 1:
              flask.flash(
                'Zipped file "{}" associated with multiple students: {}.'.format(
                  filename, ', '.join(student_usernames)))
            else:
              student_username = student_usernames.pop()
              submission_dir = os.path.join(
                '../data/files/courses', course_name, 'assignments',
                assignment_name, 'submissions', student_username)
              try:
                shutil.rmtree(submission_dir)
              except OSError as e:
                if e.errno != errno.ENOENT:
                  raise e
              try:
                os.makedirs(submission_dir)
              except OSError as e:
                if e.errno != errno.EEXIST:
                  raise e
              _enqueue_student_submission(
                course_name, assignment_name, student_username, None)
    shutil.rmtree(temp_dirname)
  return flask.redirect(
    u'/courses/{}/assignments/{}'.format(course_name, assignment_name),
    code=303)

def create_search():
    if request.method == "POST":
        try:
            data = request.get_json(force=True)

            lat = data['latitude']
            lon = data['longitude']
            radius = data['radius']
            sources = data['sources']
            name = data['name']

            data_searches = []

            for source in sources:
                source_id = source['id']
                data_source = db.session.query(DataSource).filter(DataSource.id == source_id).one()
                limit = source['limit']
                filters_dict = source['filters']
                filters = []

                for filter_temp in filters_dict:
                    # Check to see if this filter value is valid for this filter and DataSource
                    new_filter = Filter(filter_temp['name'], filter_temp['value'])
                    filters.append(new_filter)

                data_search = DataSearch(data_source, filters, limit)
                db.session.add(data_search)
                data_searches.append(data_search)

            search = Search(data_searches, lat, lon, radius, name)
            db.session.add(search)

            flask_login.current_user.add_search(search)

            db.session.commit()

            # return search_results(search.id)
            json_dict = {"id": search.id}
            return flask.jsonify(**json_dict) #Save time not fetching results

        except (Exception) as e:
            #print("Exception: ")
            #print(e)
            abort (422)
    elif request.method == "GET":
        return render_template('create.html')

def user_show(user_id):

    user = User.q.get(user_id)
    if user is None:
        flash(u"Nutzer mit ID %s existiert nicht!" % (user_id,), 'error')
        abort(404)

    room = Room.q.get(user.room_id)
    form = UserLogEntry()

    if form.validate_on_submit():
        lib.logging.create_user_log_entry(message=form.message.data,
            timestamp=datetime.now(),
            author=current_user,
            user=user)
        flash(u'Kommentar hinzugefügt', 'success')

    log_list = user.user_log_entries + room.room_log_entries
    log_list.sort(key=lambda LogEntry: LogEntry.timestamp, reverse=True)
    user_log_list = user.user_log_entries[::-1]
    room_log_list = room.room_log_entries[::-1]

    memberships = Membership.q.filter(Membership.user_id == user.id)
    memberships_active = memberships.filter(
        # it is important to use == here, "is" does NOT work
        or_(Membership.start_date == None,
            Membership.start_date <= datetime.now())
    ).filter(
        # it is important to use == here, "is" does NOT work
        or_(Membership.end_date == None,
            Membership.end_date > datetime.now())
    )

    return render_template('user/user_show.html',
        user=user,
        all_log=log_list,
        user_log=user_log_list,
        room_log=room_log_list,
        room=room,
        form=form,
        memberships=memberships.all(),
        memberships_active=memberships_active.all())