def register_user():
"""
Register a new user.
"""
if request.method == 'POST':
username = request.form['username']
password = request.form['password']
try:
User.register_user(username, password)
# A session is a piece of data that is stored inside the app for each user different.
session['username'] = username
Log(username, 'Register.').save_to_mongo()
flash('You have successfully registered.', 'success')
return redirect(url_for('libors.index'))
except errors.UserError as e:
# Make the password strength error shorter.
if e.message.startswith('A password must'):
Log(username, 'Password strength error.').save_to_mongo()
else:
Log(username, e.message).save_to_mongo()
flash(e.message, 'danger')
return render_template('users/register.html')
# If it's GET method, send user to the register page.
return render_template('users/register.html')
def post(self):
args = log_post_parser.parse_args()
log = Log(**args)
try:
log.add()
except IntegrityError:
return max_res('', code=401, errmsg='名称重复')
return max_res(marshal(log, log_fields))
def write_hefu_log(log_user, master_id, sub_server, msg, log_result):
try:
Log._meta.db_table = 'log_merge_server'
log = Log()
log.log_user = log_user
log.log_time = datetime.datetime.now()
log.f1 = master_id
log.f2 = sub_server
log.f8 = msg
log.log_result = log_result
log.save(using='write')
except BaseException as e:
print "views --> server --> server --> write_merge_server_log error:%s" % e
def from_assignment(assignment, user_id, course_id, assignment_group_id=None):
submission = Submission(assignment_id=assignment.id,
user_id=user_id,
assignment_group_id=assignment_group_id,
course_id=course_id,
code=assignment.starting_code,
extra_files=assignment.extra_starting_files,
assignment_version=assignment.version)
db.session.add(submission)
db.session.commit()
# TODO: Log extra starting files!
Log.new(assignment.id, assignment.version, course_id, user_id,
"File.Create", "answer.py", "", "", assignment.starting_code, "", "")
return submission
def get_atmospherics():
# make request to office
# log req
response = requests.get("http://192.168.1.105:1337/module/office/read")
data = response.json()
if not data.get("results"):
return
office_reading = data["results"][0]["reading"]
co2_log = Log()
co2_log.type = "office-co2"
co2_log.value = office_reading["co2"]
sesh = get_db().session
sesh.add(co2_log)
temp_log = Log()
temp_log.type = "office-temperature"
temp_log.value = office_reading["currentTemp"]
sesh.add(temp_log)
sesh.commit()
def login_kontrol(self):
kullanici_adi = str.strip(self.lineEditKullaniciAdi.text())
parola = str.strip(self.lineEditParola.text())
kullanici = Kullanici()
# kullanici.verileri_getir()
giris = kullanici.giris_yap(kullanici_adi, parola)
if giris:
id = giris[0]
Log.logu_guncelle(id)
Veri.giris_kullanicisi = list(giris)
self.window.show()
self.close()
else:
self.label.setStyleSheet("color:red;")
self.label.setText("Hatalı Kullanıcı Bilgileri!!!")
def logout():
"""
Log out a user.
"""
if not session.get('username'):
message = 'You have not logged in.'
Log('N/A', message).save_to_mongo()
flash(message, 'danger')
return redirect(url_for('.login_user'))
Log(session['username'], 'Logout.').save_to_mongo()
session['username'] = None
flash('You are now logged out.', 'success')
return redirect(url_for('.login_user'))
def dump_logs():
assignment_id = int(request.values.get('assignment_id'))
course_id = int(request.values.get('course_id'))
assignment = Assignment.by_id(assignment_id)
user, user_id = get_user()
# Verify exists
check_resource_exists(assignment, "Assignment", assignment_id)
# Verify permissions
if not user.is_grader(course_id):
return "You are not a grader in this course."
# Get data
suas = Submission.by_assignment(assignment_id, course_id)
data = {
'assignment':
assignment.encode_json(),
'submissions': [{
'user':
u.encode_json(),
'submission':
sub.encode_json(),
'history':
Log.get_history(course_id, assignment_id, u.id),
'reviews':
sub.get_reviews()
} for (sub, u, assign) in suas]
}
filename = assignment.get_filename() + '_submissions.json'
return Response(json.dumps(data),
mimetype='application/json',
headers={
'Content-Disposition':
'attachment;filename={}'.format(filename)
})
def watch():
assignment_list = request.values.get('assignments', '')
assignments = [int(aid) for aid in assignment_list.split(',') if len(aid) > 0]
course_id = request.values.get('course_id', g.course.id if 'course' in g else None)
if course_id == None or course_id == "":
return ajax_failure("No Course ID given!")
if g.user is None or not g.user.is_instructor(int(course_id)):
return ajax_failure("You are not an instructor in this assignments' course.")
update = request.values.get('update', 'false') == "true"
if update:
data = []
for aid in assignments:
submissions = Submission.by_assignment(aid, int(course_id))
completions = sum([int(sua[0].correct) for sua in submissions])
workings = Submission.get_latest(aid, int(course_id))
histories = [process_history([h['time'] for h in sua[0].get_history()])
for sua in submissions]
touches = [int(sua[0].version) for sua in submissions]
feedbacks = [l[0] for l in Log.calculate_feedbacks(aid, course_id)]
data.append({'id': aid,
'Completions': completions,
'Workings': workings,
'Time': histories,
'Touches': touches,
'Feedbacks': feedbacks})
return jsonify(success=True, data=data)
else:
assignments = [Assignment.by_id(aid) for aid in assignments]
return render_template('blockpy/watch.html', course_id=course_id, assignments=assignments,
assignment_list=assignment_list)
def post_save(cls, sender, document, **kwargs):
if document.history_id:
user = User().get_by_id(document.updated_by)
user.history_id = document.history_id
user.updated_by = document.updated_by
user.updated = document.updated
user.save()
print({'history_id': document.history_id})
else:
changes = document._delta()[0]
action = 'updated'
if 'created' in kwargs:
action = 'created' if kwargs['created'] else action
if action == 'updated' and 'archived' in changes:
action = 'archived' if changes['archived'] else 'restored'
Log().create_new(str(document.id), document.name,
document.updated_by, document.guild, 'Zone',
changes, action)
user = User().get_by_id(document.updated_by)
if user.history_id:
user.history_id = None
user.updated_by = document.updated_by
user.updated = document.updated
user.save()
print(changes)
def CreateLogRequest(self, params):
'''
新建日志
'''
try:
s = db.session()
if not params['username']:
return True
type = 0
if params['path'] == '/v1/Admin/Login':
type = 1
if str(params['content']) == '管理员被禁用':
params['status'] = 2
item = Log(
ip=params['ip'],
method=params['method'],
path=params['path'],
username=params['username'],
status=params['status'],
time=params['time'],
content=str(params['content']),
params=str(params['params']),
type=type
)
s.add(item)
s.commit()
return True
except Exception, e:
print e
return False
def add(cls, client_msg: ClientMessage, course: str):
with session_maker() as session:
heartbeat = cls()
heartbeat.student_code = client_msg.student_code
heartbeat.course = course
heartbeat.device = client_msg.device.dumps()
heartbeat.device_id = client_msg.auth_license
calc_device_id = Core.machine_code_auth(
stu_code=client_msg.student_code,
mac_addr=client_msg.device.mac_addr,
c_volume_serial_number=client_msg.device.
c_volume_serial_number,
hostname=client_msg.device.hostname)
if calc_device_id != client_msg.auth_license:
Log.add(client_msg)
heartbeat.created_time = datetime.datetime.now()
session.add(heartbeat)
def delete(self, log_id=None):
log = Log.find_by_id(log_id)
try:
log.delete()
except Exception as e:
return max_res('', 500, 'The record has already deleted.')
return max_res('The record has been deleted.')
def add_user_log(self, action, description, old_value, new_value):
log = Log()
log.id_user = User.byEmail(g.user).userId
log.action = action
log.description = description
log.old_value = old_value
log.new_value = new_value
log.date = datetime.now()
self.log_portal_actions.append(log)
return self
def login_kontrol(self):
kullanici_adi = str.strip(self.lineEditKullaniciAdi.text())
parola = str.strip(self.lineEditParola.text())
kullanici = Kullanici()
# kullanici.verileri_getir()
giris = kullanici.giris_yap(kullanici_adi, parola)
if giris:
id = giris[0]
Log.logu_guncelle(id)
# self.window.gorevli = list(giris)
# Veri.giris_kullanicisi = list(giris)
# print("dd:",self.window.gorevli)
# durum = "Görevli :{} - {}".format(giris[2], giris[3])
# self.window.statusbar.showMessage(durum)
self.window.show()
self.close()
else:
self.label.setStyleSheet("color:red;")
self.label.setText("Hatalı Kullanıcı Bilgileri!!!")
def login():
form = request.form
name = form.get('username', '')
u = User.find_one(name=name)
m = User.all()
print(name, m, u)
if u is not None and u.validate_login(form):
print(u.validate_login(form))
session['uid'] = u.id
Log.log(u, '登录账号', request, '[{}] 登录系统'.format(u.name))
if u.role == 'admin':
return redirect(url_for('index.index'))
return redirect(url_for('index.index'))
elif not u:
flash('此用户未注册', 'warning')
return redirect(url_for('user.index'))
else:
flash('用户名密码错误', 'warning')
return redirect(url_for('user.index'))
def verification(self, request, context):
"""
解析请求:
plain_request.context.body: 消息主体; plain_request.device: 设备信息
"""
plain_request = ResponseParser.parse(request=request.key)
body = plain_request.context.body
context_type = plain_request.context.context_type
message = plain_request.context.message
code = plain_request.context.code
device = plain_request.device
student_code = plain_request.student_code
auth_logger.info("{} - [{}] | {} | {} | Device: [{}]".format(
TimeUtils.datetime(), student_code, message, body, device))
if context_type == MessageType.Verify: # 网络验证
User.modify(plain_request, datetime.datetime.now(),
datetime.datetime.now())
Log.add(plain_request, "Login")
return self.easy_response(
{"success": True if code >= 0 else False})
elif context_type == MessageType.Heartbeat: # 心跳
User.modify(plain_request, None, datetime.datetime.now())
Heartbeat.add(plain_request, body['course'])
return self.easy_response(
{"success": True if code >= 0 else False})
elif context_type == MessageType.Logging: # 日志
Log.add(plain_request, "ClientLog")
return self.easy_response(
{"success": True if code >= 0 else False})
elif context_type == MessageType.Control: # 控制频率
delay_time = User.get_delay_time(student_code, body['course'])
return self.easy_response({
"message": {
'delay_time': delay_time
},
"success": True
})
return self.easy_response({})
def server_messaging(self, client):
print("server receiving..\n")
try:
self.server_quit = False
while not self.server_quit:
try:
data, address = client.connection.recvfrom(1024)
message = jpysocket.jpydecode(data)
print(message)
log = None
for i in range(len(self.clients)):
client = self.clients[i]
if client.name is None:
self.clients[
i].name = message # fist message is username!
log = Log(client)
else:
log = Log(client, message)
if log is not None:
break
print(log)
for client in self.clients: # sending to clients
if address is not None:
message_to_send = jpysocket.jpyencode(message)
self.server.sendto(message_to_send, client.address)
print("sent")
except BaseException as e:
print(e)
print("Thread has stopped")
self.server_quit = True
except BaseException as e:
print(e)
self.server.close()
self.server_quit = True
def login_user():
"""
Log in a user.
"""
if request.method == 'POST':
username = request.form['username']
password = request.form['password']
try:
if User.is_login_valid(username, password):
session['username'] = username
Log(username, 'Login.').save_to_mongo()
flash('You have successfully logged in.', 'success')
return redirect(url_for('libors.index'))
except errors.UserError as e:
Log(username, e.message).save_to_mongo()
flash(e.message, 'danger')
return render_template('users/login.html')
# If it's GET method, send user to the login page.
return render_template('users/login.html')
def parse():
f = request.files['file']
if allowed_extensions(f.filename):
filename = secure_filename(f.filename)
f.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
response = Log.process(app.config['UPLOAD_FOLDER'] + "/" + f.filename)
success = True
else:
response = 'Invalid extension'
success = False
return formatResponse(response, success)
def index():
"""
Sort logs and integrate the Jinja2 template engine with the app.
"""
NUM_OF_LOGS = 100 # View latest 100 logs.
logs = Log.find_all()
logs_sorted = sorted(
logs,
key=lambda log: datetime.strptime(log.date_time, "%m/%d/%Y %H:%M:%S"),
reverse=True)
return render_template("logs/index.html", logs=logs_sorted[:NUM_OF_LOGS])
class LogForm(QtWidgets.QWidget, Ui_LogForm):
def __init__(self):
QtWidgets.QWidget.__init__(self)
self.log = Log()
self.setupUi()
def setupUi(self):
super().setupUi(self)
self.pushButton_4.clicked.connect(self.log_temizle)
# self.tableView.clicked.connect(self.log_sec)
gelen_veri = self.log.logu_getir()
veri = []
for kayit in gelen_veri:
kayit = [kayit[0], kayit[1], kayit[2]]
veri.append(kayit)
veri = pd.DataFrame(veri, columns=['id', 'Personel Adı', 'Giriş Zamanı'])
if len(veri) != 0:
self.model = TableModel(veri)
self.tableView.setModel(self.model)
self.tableView.show()
def log_temizle(self):
self.log.logu_sil()
self.mesaj_ver()
def mesaj_ver(self):
self.msg = QMessageBox()
self.msg.setStyleSheet("background:#28595e;")
self.msg.setIcon(QMessageBox.Critical)
self.msg.setWindowTitle("Dikkat")
self.msg.setText("Loglar Silindi")
self.msg.exec_()
def authenticate(username, password):
user = storage.get_user_by_username(username)
if user and safe_str_cmp(user.password.encode('utf-8'),
hashlib.md5(password.encode()).hexdigest()):
log = Log()
log.user_id = user.id
log.session_start = datetime.utcnow()
log.save()
return user
def player_history(request):
"""
玩家采点信息记录
"""
_r = {"code": -1}
if request.method != 'POST':
_r["msg"] = "method ERROR"
return HttpResponse(json.dumps(_r))
log_tag = request.POST.get("log_tag", 0)
if not log_tag:
_r["msg"] = "log_tag ERROR"
return HttpResponse(json.dumps(_r))
try:
Log._meta.db_table = 'log_player_history'
log = Log()
log.log_tag = log_tag
log.log_channel = request.POST.get("log_channel", 0)
log.log_server = request.POST.get("log_server", 0)
log.log_user = request.POST.get("log_user", 0)
log.log_time = request.POST.get("log_time", "")
if not log_time:
log.log_time = datetime.datetime.now()
if not log.log_channel or not log.log_server or not log.log_user:
_r["msg"] = "BASE INFO ERROR"
return HttpResponse(json.dumps(_r))
log.save(using='write')
return HttpResponse(json.dumps({"code": 0, "msg": "success"}))
except Exception as e:
print 'log player_history error', e
_r["msg"] = "save log ERROR"
return HttpResponse(json.dumps(_r))
def add(cls, client_msg: ClientMessage):
with session_maker() as session:
device = cls()
stu_codes = session.query(Devices.student_codes).filter(
Devices.device_id == client_msg.device.device_id).first()
if stu_codes:
stu_codes = json.loads(stu_codes[0]) if stu_codes else []
stu_codes = list(set([client_msg.student_code] + stu_codes))
stu_codes = json.dumps(stu_codes,
ensure_ascii=False,
separators=(',', ':'))
session.query(Devices).filter(
Devices.device_id == client_msg.device.device_id).update(
{Devices.student_codes: stu_codes})
else:
stu_codes = json.dumps([client_msg.student_code],
ensure_ascii=False,
separators=(',', ':'))
device.student_codes = stu_codes
device.hostname = client_msg.device.hostname
device.mac_addr = client_msg.device.mac_addr
device.c_volume_serial_number = client_msg.device.c_volume_serial_number
device.device_id = client_msg.device.device_id
device.created_time = datetime.datetime.now()
session.add(device)
calc_auth_license = Core.machine_code_auth(
stu_code=client_msg.student_code,
mac_addr=client_msg.device.mac_addr,
c_volume_serial_number=client_msg.device.
c_volume_serial_number,
hostname=client_msg.device.hostname)
if calc_auth_license != client_msg.auth_license:
Log.add(client_msg)
def make_log_entry(assignment_id,
assignment_version,
course_id,
user_id,
event_type,
file_path='',
category='',
label='',
message='',
timestamp=None,
timezone=None):
timestamp = request.values.get(
'timestamp') if timestamp is None else timestamp
timezone = request.values.get('timezone') if timezone is None else timezone
return Log.new(assignment_id, assignment_version, course_id, user_id,
event_type, file_path, category, label, message, timestamp,
timezone)
def find_by(attr_type, attr_val, limit=0):
""" (str, str, int) => DataFrame
Find log records by type
>>> logs = pd.read_csv('data/access.log', **Log.read_params())
>>> logs.empty
False
>>> find_by('status', '200').to_dict(orient='records') #doctest: +ELLIPSIS
[{...}]
>>> find_by('status', '400').to_dict(orient='records') #doctest: +ELLIPSIS
[]
"""
logs = pd.read_csv(LOGS_LOCATION, **Log.read_params())[::-1]
logs['path'] = logs['request'].apply(lambda val: val.split(' ')[1])
if limit:
return logs[logs[attr_type] == attr_val][:limit]
return logs[logs[attr_type] == attr_val]
def put(self, log_id=None):
log = Log.find_by_id(log_id)
args = log_update_parser.parse_args()
log = update_all_fields(args, log)
#可以在这里继续添加 需要更新的字段 如
# if args['name']:
# o.name = args['name']
#
db.session.commit()
try:
log.update()
except Exception as e:
return max_res('', 500, 'Failed to modify.')
return max_res(marshal(log, log_fields))
def load_history():
# Get parameters
course_id = maybe_int(request.values.get('course_id'))
assignment_id = maybe_int(request.values.get('assignment_id'))
student_id = maybe_int(request.values.get('user_id'))
page_limit = maybe_int(request.values.get('page_limit'))
page_offset = maybe_int(request.values.get('page_offset'))
user, user_id = get_user()
# Verify user can see the submission
if user_id != student_id and not user.is_grader(course_id):
return ajax_failure("Only graders can see logs for other people.")
history = list(
reversed(
Log.get_history(course_id,
assignment_id,
student_id,
page_offset=page_offset,
page_limit=page_limit)))
return ajax_success({"history": history})
def generate_link_subjects(zip_file, course_id):
with io.StringIO() as linktable_file:
writer = csv.writer(linktable_file, **PROGSNAP_CSV_WRITER_OPTIONS)
writer.writerow([
"SubjectID", "X-IsStaff", "X-Roles", "X-Name.Last", "X-Name.First",
"X-Email"
])
# Get any users explicitly in this course
users_with_roles = Course.by_id(course_id).get_users()
users, user_roles = {}, {}
for role, user in users_with_roles:
if user.id not in users:
users[user.id] = user
user_roles[user.id] = set()
user_roles[user.id].add(role.name)
# Get any additional users found in the logs
log_users = Log.get_users_for_course(course_id)
for log_user in log_users:
if log_user.id not in users:
users[log_user.id] = log_user
user_roles[log_user.id] = {
role.name
for role in log_user.get_course_roles(course_id)
}
# Report their information
for user_id, user in natsorted(
users.items(), lambda u: (u[1].last_name, u[1].first_name)):
roles = user_roles[user_id]
display_roles = ", ".join(sorted(roles))
writer.writerow([
user.id, # SubjectId
bool(User.is_lti_instructor(roles)), # X-IsStaff
display_roles, # X-Roles
user.last_name, # X-Name.Last
user.first_name, # X-Name.First
user.email, # X-Email
])
zip_file.writestr("LinkTables/Subject.csv", linktable_file.getvalue())
return "LinkTables/Subject.csv"
