def __log_something(priority, objct, message, request = False):
if request:
if request.user:
username = request.user.username
else:
username = '******'
if 'REMOTE_ADDR' in request.META:
message += ' [%(username)s@%(remoteAdd)s]' % {'username': username, 'remoteAdd': request.META['REMOTE_ADDR']}
else:
message += ' [%(username)s@testing by django\'s client' % {'username': username, }
if 'HTTP_USER_AGENT' in request.META:
message += ' %s' % request.META['HTTP_USER_AGENT']
if type(objct) is types.FunctionType:
message = '(%(objName)s) %(message)s' % {'objName': objct.__name__, 'message': message}
elif type(objct) is types.ClassType:
message = '(%(type)s) %(message)s' % {'type': type(objct), 'message': message}
else:
message = '(%(objct)s) %(message)s' % {'objct': objct, 'message': message}
_logger.log(priority, message)
if priority != DEBUG:
# We shrink the message to fit the model datatype
l = Log(priority = priority, text = message[:255])
l.save()
if settings.LOG_TO_SYSLOG and priority != DEBUG:
syslog.syslog(syslog.LOG_LOCAL4 | priority, "[singularms] %(message)s " %{'message': message.encode('utf-8')} )
def main_page(request):
"""главная вьюха
Arguments:
- `request`:
"""
if request.method == 'POST':
radioform = SetPassForm(request.POST)
radioform.is_valid()
num_passwords = int(radioform.cleaned_data['num_pass'])
passwords = gen_passwords(os.path.dirname(__file__) + '/dicts/' + radioform.cleaned_data['language'],
num=num_passwords,
lenth=int(radioform.cleaned_data['lenth_pass']),
upper=radioform.cleaned_data['upper_pass'],
numbers=radioform.cleaned_data['string_replace_num'])
else:
passwords = gen_passwords(os.path.dirname(__file__) + '/dicts/italian')
num_passwords = 10
radioform = SetPassForm({'num_pass':'******', 'lenth_pass':'******', 'language':'italian', 'upper_pass': True, 'string_replace_num': True})
count = Counter()
log = Log()
counter = count.get_counter(num_passwords)
log.save_log_note(request.META['HTTP_USER_AGENT'], request.META['REMOTE_ADDR'])
return render_to_response('index.html', {
'counter':counter,
'passwords':passwords,
'radioform':radioform,
'browser':request.META['HTTP_USER_AGENT'],
'ip':request.META['REMOTE_ADDR']
}, context_instance = RequestContext(request))
def request(self, flow):
self.l = Log()
self.l.request_body = flow.request.get_text()
self.l.method = flow.request.method
self.l.url = flow.request.url
self.l.request_headers = json.dumps(dict(flow.request.headers))
self.l.save()
def makeLog(number, full, box_ID):
box = Box.objects.get(id = box_ID)
log = Log(Box = box)
log.NumberOfCaps = number
log.isFull = full
log.save()
def solve_order(request):
rNumber = request.GET["rNumber"]
ID = rNumber
orderlist = Order.objects.filter(Receiver=rNumber, State="0")
if "yes" in request.POST:
post = request.POST
sNumber = post["yes"]
ord = Order.objects.filter(Sender=sNumber, Receiver=rNumber, State="0")
for order in ord:
order.State = "1"
order.save()
new_event = Log(
Number=ID,
Time=order.Time,
Event=order.Event,
)
new_event.save()
return HttpResponseRedirect("/search_event/?id=" + ID)
break
if "no" in request.POST:
post = request.POST
sNumber = post["no"]
ord = Order.objects.filter(Sender=sNumber, Receiver=rNumber, State="0")
for order in ord:
order.State = "2"
order.save()
break
return render_to_response(
"solve_order.html",
RequestContext(request, {
"ID": ID,
"orderlist": orderlist,
}))
def last(self, args):
"""Display a dialog to verify the change to undo
Parameters
----------
redo : stre
The id of the current change history to work forward from
Returns
-------
str - the response messages string array
"""
messages = []
undos = None
if self.user.history_id:
current_history = Log.get_by_id(self.user.history_id)
if current_history:
undos = list(
Log.filter(updated__lt=current_history.updated,
category__ne='Log').order_by('-created').all())
if not undos:
undos = list(
Log.get_by_page({
'user_id': str(self.user.id),
'category__ne': 'Log'
}))
if not undos:
raise Exception('You have no undo history')
undo = undos[0]
changes, item, undo_changes_str = self.get_undo(undo)
command = 'undo ' + ' '.join(args)
if undo and changes and item and 'confirm' in ' '.join(args):
self.user.answer = 'YES'
self.user.command = command
question = ''.join([
f'Are you sure you want to undo changes to this {undo.category}?\n\n{item.get_string()}\n\n',
f'***Changes to Undo:***\n' + '\n'.join(undo_changes_str),
'```css\n.d YES /* to confirm the command */\n.d NO /* to reject the command */\n.d CANCEL /* to cancel the command */```'
])
if self.user.command == command:
answer = self.user.answer
if answer:
if answer.lower() in ['yes', 'y']:
messages.append(self.undo_changes(undo))
self.set_dialog()
elif answer.lower() in ['no', 'n', 'cancel', 'c']:
messages.append(f'Command ***"{command}"*** canceled')
self.set_dialog()
else:
messages.append(
f'Please answer the question regarding ***"{command}"***:\n\n{question}'
)
else:
messages.append(
f'No answer was received for command ***"{command}"***')
else:
self.set_dialog(command, question)
messages.extend([question])
return messages
def addSite(request):
"""添加需要抓取的网站，包括网站名称，地址，抓取的起始地址"""
if request.method=='POST': #如果request的方法为POST，即有表单提交
form=AddSiteForm(request.POST)
if form.is_valid(): #验证提交的数据，如果通过验证，往下执行
siteName=form.cleaned_data['siteName'] #网站名称
siteUrl=form.cleaned_data['siteUrl'] #网站地址
startUrl=form.cleaned_data['startUrl'] #抓取的起始URL
site=SiteInfo(siteName=siteName,siteUrl=siteUrl,startUrl=startUrl)
site.save() #保存到数据库
#日志初始化#
siteId=site.id #记录当前网站id
breakSubId='1' #初始化断点分类id为1
breakSubTitle='nothing' #初始化断点分类名称为nonthing
breakPageId=1 #初始化断点分页为1
breakItemId=0 #初始化断点书籍序号为1
errorInfo='No Exception Raise' #初始化错误信息为'No Exception Raise'
currentEvent='Log Initialization' #初始化当前时间为'Log Initialization'
log=Log(siteId=siteId,breakSubId=breakSubId,breakSubTitle=breakSubTitle,
breakPageId=breakPageId,breakItemId=breakItemId,errorInfo=errorInfo,currentEvent=currentEvent)
log.save()
return HttpResponse('网站信息添加成功，日志初始化成功，请<a href="/bookcatch/addsites/">返回</a>') #显示添加成功信息，提供返回到添加页面
else:
form=AddSiteForm() #如果无表单提交，显示空白表单
allsite=SiteInfo.objects.all() #得到所有的siteInfo
alllog=Log.objects.all() #得到所有Log
return render_to_response('books/addsite.html',{'allsite':allsite,'form':form,'alllog':alllog}) #返回经过渲染的addsite.html
def add_event(request):
ID = request.GET["id"]
if request.POST:
post = request.POST
new_event = Log(Number=ID, Time=post["time"], Event=post["event"])
new_event.save()
return HttpResponseRedirect("/search_event/?id=" + ID)
return render_to_response("add_event.html")
def test_edit_log3(self, mock_validate_minutes):
expected = 45
new_viewer = Viewer(Log.select())
with patch('viewer.input', return_value='c'):
new_viewer.edit_log()
log = Log.select()
actual = log[0].task_time
self.assertEqual(actual, expected)
def write_log(date, title, time, notes):
"""Write the work log to the database."""
username = get_username()
Log.create(username=username,
task_date=date,
task_title=title,
task_time=time,
task_notes=notes)
def clean_trash(request):
file_list = File.objects.filter(trashed=True)
print "CLEAN ALL"
for a in file_list:
os.remove(os.path.realpath(os.path.dirname(__file__)) + "/media/" + a.file.name)
a.delete()
Log.create(request.user, "Permanently deleted a file", a, None).save()
return HttpResponseRedirect("/trash/")
def save_logs_of_logging_call_xml(call_str, change_type, file_path,
head_commit_db, method_name, component):
Log.create(commit_id=head_commit_db.hexsha,
file_path=file_path,
embed_method=method_name,
change_type=change_type,
content_update_to=call_str,
component=component)
def test_edit_log1(self, mock_get_date):
expected = datetime.datetime(2010, 11, 11, 0, 0)
new_viewer = Viewer(Log.select())
with patch('viewer.input', return_value='a'):
new_viewer.edit_log()
log = Log.select()
actual = log[0].task_date
self.assertEqual(actual, expected)
def setUp(self):
test_db.bind(MODELS, bind_refs=False, bind_backrefs=False)
test_db.connect()
test_db.create_tables(MODELS)
Log.create(username='******',
task_date=datetime.datetime(2011, 11, 11, 0, 0),
task_title='Test',
task_time=60,
task_notes='Notes')
def test_build_username_list(self):
expected = ['Adam', 'Bernard', 'Charles']
logs = [
Log(username='******'),
Log(username='******'),
Log(username='******')
]
actual = build_username_list(logs)
self.assertEqual(actual, expected)
def test_search_username_term2(self):
Log.create(username='******',
task_date=datetime.datetime(2011, 11, 11, 0, 0),
task_title='Test',
task_time=60,
task_notes='Notes')
expected = 1
with patch('search.input', side_effect=['user', '1']):
actual = search_username_term()
self.assertEqual(actual.select().count(), expected)
def api_log_new(*, userid, taskid, logcontent):
'new log'
if not userid:
raise APIValueError('userid')
if not taskid:
raise APIValueError('taskid')
id = next_id()
log = Log(id=id, userid=userid, taskid=taskid, logcontent=logcontent)
affected = yield from log.save()
return {'affected': affected}
def info(msg):
try:
log = Log(parent=ndb.Key('Python Algorithms', 'scrap'))
log.msg = msg
log.put()
except Exception as e:
pass # print 'Could not log info "%s" due to %s' % (msg, e)
try:
logging.info(msg)
except Exception as e:
pass # print 'Could not log info "%s" due to %s' % (msg, e)
def test_view_logs3(self):
Log.create(username='******',
task_date=datetime.datetime(2011, 11, 11, 0, 0),
task_title='Test',
task_time=60,
task_notes='Notes')
new_viewer = Viewer(Log.select())
expected = 'neds'
with patch('viewer.input', return_value='s'):
new_viewer.view_logs()
actual = new_viewer.menu_options
self.assertEqual(actual, expected)
def trash(request):
if request.method=="POST":
file_list = File.objects.filter(trashed=True)
for a in file_list:
if request.POST.get(str(a.id))!=None:
a.trashed=False
a.save()
Log.create(request.user, "Restored a file", a, None).save()
return HttpResponseRedirect("/trash/")
else:
is_admin = request.user.is_staff
file_list = File.objects.filter(trashed=True)
return render_to_response('trash.html', {'user': request.user, 'file_list':file_list, 'is_admin':is_admin}, context_instance=RequestContext(request))
def log(self, project, trace_info, extended_info, status, records_imported=0):
if project == None:
return
log = Log(
parent=project.key,
filename=trace_info.filename,
date=datetime.today(),
status=status,
records_imported=records_imported,
)
log.put()
def get(self):
id = int(self.request.get('id'))
secret = int(self.request.get('secret'))
user = db.get(db.Key.from_path("User", id))
if user.secret == secret:
level = self.request.get('level')
step = int(self.request.get('step'))
correct = self.request.get('correct') == '1'
log = Log(user=user, level=level, step=step, correct=correct)
log.put()
user.level = level
user.step = step
user.put()
self.response.out.write("ok")
def demo_logs(dog, food, run, walk):
from models import Log, ExerciseLog, FoodLog
logs = Log.query.filter(Log.dog_id==dog.id).order_by(desc(Log._date)).all() or [None] * 10
d = today
index = 1
weight = 25
calories = randint(400, 600)
for log in logs:
daily_calories = round(getMER(weight, dog._metric))
filename = 'Pluto' + str(index) + '.jpg'
url = 'static/img/demo/' + filename
thumbnail_url = 'static/img/demo/Pluto' + str(index) + '-thumbnail.jpg'
if log is None:
log = Log(d, dog.id, weight, daily_calories, calories, None, filename, url, thumbnail_url)
db.session.add(log)
db.session.commit()
else:
log._date = d
log._weight = weight
log._daily_calories = daily_calories
log._calories = calories
log._image_filename = filename
log._image_url = url
food_log = FoodLog.query.filter(FoodLog.food_id==food.id, FoodLog.log_id==log.id).first()
if food_log is None:
food_log = FoodLog(round((calories * food._serving) / food._calories, 1), food.id, log.id)
db.session.add(food_log)
duration = randint(10, 100)
run_log = ExerciseLog.query.filter(ExerciseLog.exercise_id==run.id, ExerciseLog.log_id==log.id).first()
if run_log is None:
run_log = ExerciseLog(duration, run.id, log.id)
db.session.add(run_log)
db.session.commit()
total_duration = duration
duration = randint(10, 100)
walk_log = ExerciseLog.query.filter(ExerciseLog.exercise_id==walk.id, ExerciseLog.log_id==log.id).first()
if walk_log is None:
walk_log = ExerciseLog(duration, walk.id, log.id)
db.session.add(walk_log)
db.session.commit()
total_duration += duration
log._total_duration = total_duration
db.session.add(log)
db.session.commit()
logs[index - 1] = log
d -= timedelta(days=1)
weight += randint(-1, 1)
index += 1
calories += randint(10, 50)
return logs
def fresh(request):
"""
定时刷新人品请求
"""
users = User.objects.all()
for userObj in users:
username = userObj.username
password = userObj.password
result = action.login_renren(username, password)
logObj = Log()
logObj.user = userObj
logObj.log_info = result
logObj.save()
return HttpResponse('Fresh rp success!')
def request_delete(request, document_number):
if request.method=="POST":
doc= Dokument.objects.get(id= int(document_number))
for k in doc.files.filter(trashed=False):
if request.POST.get(str(k.id))!=None:
k.trashed=1
# else:
# k.trashed=0
k.save()
Log.create(request.user, "Deleted a file", k, doc).save()
return HttpResponseRedirect("/records")
else:
doc= Dokument.objects.get(id= int(document_number))
return render_to_response('request_delete.html', {'doc':doc})
def test_delete_log(self):
Log.create(username='******',
task_date=datetime.datetime(2011, 11, 11, 0, 0),
task_title='Test',
task_time=60,
task_notes='Notes')
expected = 1
new_viewer = Viewer(Log.select())
with patch('viewer.input', side_effect=['n', 'y', '']):
new_viewer.delete_log()
new_viewer.delete_log()
logs = Log.select()
actual = logs.select().count()
self.assertEqual(actual, expected)
def register(request):
data = request.data
logpath = data.get('logpath', None)
logserver = data.get('logserver', None)
if not (logpath and logserver):
return HttpResponseBadRequest("Not enough information provided")
logs = Log.objects.filter(logpath = logpath, logserver = logserver)
if len(logs) == 0:
log = Log(**data)
log.save()
else:
# there could be more than one (logs identified by ids,
# just grab first one
log = logs[0]
return HttpResponse(content = log.id, status = 201)
class Logger:
def response(self, flow):
self.l.response_body = flow.response.get_text()
self.l.response_headers = json.dumps(dict(flow.response.headers))
self.l.rtt = flow.response.timestamp_end - flow.request.timestamp_start
self.l.code = flow.response.status_code
self.l.save()
def request(self, flow):
self.l = Log()
self.l.request_body = flow.request.get_text()
self.l.method = flow.request.method
self.l.url = flow.request.url
self.l.request_headers = json.dumps(dict(flow.request.headers))
self.l.save()
def register(request):
data = request.data
logpath = data.get('logpath', None)
logserver = data.get('logserver', None)
if not (logpath and logserver):
return HttpResponseBadRequest("Not enough information provided")
logs = Log.objects.filter(logpath=logpath, logserver=logserver)
if len(logs) == 0:
log = Log(**data)
log.save()
else:
# there could be more than one (logs identified by ids,
# just grab first one
log = logs[0]
return HttpResponse(content=log.id, status=201)
def test_edit_log2(self):
expected = 'Testing'
new_viewer = Viewer(Log.select())
with patch('viewer.input', side_effect=['b', 'Testing', '']):
new_viewer.edit_log()
log = Log.select()
actual = log[0].task_title
self.assertEqual(actual, expected)
expected = 'More notes'
new_viewer = Viewer(Log.select())
with patch('viewer.input', side_effect=['d', 'More notes', '']):
new_viewer.edit_log()
log = Log.select()
actual = log[0].task_notes
self.assertEqual(actual, expected)
def upload(request):
if request.POST:
userid = request.POST.get('userid')
# Queries all non-expired sessions
sessions = Session.objects.filter(expire_date__gte=datetime.now())
# Checks if session is active
for session in sessions:
data = session.get_decoded()
found_userid=data.get('_auth_user_id')
# Prceeds when user id is validated
if found_userid!=None and long(userid)==found_userid:
user = User.objects.filter(id=userid)[0]
faculty=None
faculty=Faculty.objects.filter(id=request.POST.get('fid'))[0]
transaction = Transaction.objects.get(id=request.POST.get('transaction'))
document = Dokument()
document.faculty= faculty
document.transaction= transaction
document.save()
#Generates a random alphanum string for filename template
while True:
fnameTemplate=''
fnameTemplate = ''.join(random.choice(string.ascii_lowercase))
fnameTemplate += ''.join(random.choice(string.ascii_lowercase + string.digits) for x in range(4)) + '_'
if len(File.objects.filter(filename__startswith = fnameTemplate))==0: break
#Processes uploaded files, page by page
for key in request.FILES:
files = request.FILES[key]
filename = fnameTemplate + key.split('_')[1] + '.bmp'
with open('DCSArchivingSystem/testapp/media/files/' + filename, 'wb+') as destination:
for chunk in files.chunks():
destination.write(chunk)
file = File()
file.filename = filename
file.file = 'files/' + filename
file.save()
document.files.add(file)
Log.create(user, "Uploaded file", file, document).save()
Log.create(user, "Created Document", None, document).save()
return HttpResponseRedirect("/dashboard/")
else:
return render_to_response('upload.html', context_instance=RequestContext(request))
def get(self):
# get user ip
if self.request.remote_addr:
# query geo-location of IP
query_args = {
'token': 'dWEF43tHwFfgG51ASeFg5087rtRBR',
'ip': self.request.remote_addr
}
encoded_args = urllib.urlencode(query_args)
url = 'http://52.34.94.166:3000/get_ip_geo'
result = json.loads(urllib2.urlopen(url, encoded_args).read())
print result
lat_lng = result['geo']['ll']
# store data
custom_index_log.ip_address = self.request.remote_addr
custom_index_log.lat = lat_lng[0].__str__()
custom_index_log.lng = lat_lng[1].__str__()
custom_index_log.put()
# set template
template = JINJA_ENVIRONMENT.get_template('index.html')
# get ip addresses of visitors
ip_logs = Log.query().order(-Log.access_time)
# values to pass to front-end
template_values = {
'title': 'Bay Technology',
'greeting': 'Hello Bay Tecnology',
'ip_logs': ip_logs
}
# dispatch template and values to front-end
self.response.write(template.render(template_values))
def cant_play_on_saturdays():
email = request.json['email']
weeks = int(request.json['weeks'])
future = bool(request.json['future'])
if weeks <= 0 or weeks > 520:
abort(400)
user = User.query.get(email)
if not user:
abort(404)
if user.group is not current_user.group:
abort(404)
if user.email is not email and not current_user.isGroupOwner:
abort(401)
if future:
user.futureSaturdayAbsentWeeks = weeks
else:
user.isSaturdayAbsent = True
user.saturdayAbsentWeeks = weeks
db.session.commit()
""""Insert a log"""
description = 'Successfully registered Saturday absence for - ' + str(weeks) + ' weeks' + \
' for user - ' + user.firstname + ' ' + user.lastname
log = Log(current_user.email, description)
db.session.add(log)
db.session.commit()
schema = UserSchema()
json_result = schema.dumps(user)
return json_result.data
def adhoc_charge():
if not current_user.isSuperUser:
abort(401)
amount = request.json['amount']
subject = request.json['subject']
message = request.json['message']
users = User.query.order_by(User.firstname.asc()).all()
cost_per_player = float("{0:.2f}".format(float(amount) / float(len(users))))
"""Add expense entry"""
expense_entry = Expense(amount, cost_per_player, "Deduction_AdHoc", len(users))
db.session.add(expense_entry)
db.session.commit()
email_ids = []
for user in users:
email_ids.append(user.email)
user.balance = float("{0:.2f}".format(user.balance - cost_per_player))
transaction = Transaction(user.email, cost_per_player, user.balance, "Deduct_AdHoc")
db.session.add(transaction)
db.session.commit()
SendGrid.send_email(email_ids, "*****@*****.**", subject, message)
"""Insert a log"""
description = 'An AdHoc amount of $' + str(amount) + ' is charged for reason: ' + subject
log = Log(current_user.email, description)
db.session.add(log)
db.session.commit()
return "Success"
def process_request(self, request):
# print(request.META['REMOTE_HOST'])
# if request.path.find('admin') == -1 and not request.user.is_authenticated():
# if request.GET.get('mobile', None) == 'authenticate':
if not request.user.is_authenticated():
user = authenticate(username='******', password='******')
if user and user.is_active:
login(request, user)
# check for lost devices when web interface is opened...
for d in Device.objects.filter(ip=request.META.get('REMOTE_ADDR'), authorized=True, is_home=False):
d.is_home = True
d.save()
l = Log(device=d, status=True, log_type='DE', text='(django)')
l.save()
def post(self, application_name):
sender = self.request.get("sender")
if not sender:
sender = self.request.get("email")
if not sender:
sender = self.request.get("username")
if not sender:
sender = self.request.get("facebookId")
if not sender:
sender = self.request.get("fullname")
log = Log.create(
application_name,
sender,
self.request.get("body"),
email=self.request.params.get("email"),
facebookId=self.request.params.get("facebookId"),
fullname=self.request.params.get("fullname"),
username=self.request.params.get("username"))
log.links = list(enum_request_files(log, self.get_file_infos()))
log.put()
def make_someone_sunday_absent():
if not current_user.isSuperUser:
abort(401)
email = request.json['email']
numberOfWeeks = int(request.json['numberOfWeeks'])
if numberOfWeeks <= 0:
abort(400)
user = User.query.get(email)
if not user:
abort(404)
"""Insert a log"""
description = 'User, ' + user.firstname + ' ' + user.lastname + ' (' + user.email + ') has been marked absent on Sundays by Admin for ' + str(numberOfWeeks) + ' weeks'
log = Log(current_user.email, description)
db.session.add(log)
db.session.commit()
user.futureSundayAbsentWeeks = 0
user.isSundayAbsent = True
user.sundayAbsentWeeks = numberOfWeeks
db.session.commit()
return "Success"
def test_write_log(self):
User.create(username='******')
expected = 'username'
write_log(datetime.datetime(2011, 11, 11, 0, 0), 'Test', 60, 'Notes')
log = Log.select()
actual = log[0].username
self.assertEqual(actual, expected)
def user_log(user_id, text):
row = Log(user_id=user_id, text=text.strip(
), date=datetime.datetime.now().strftime("%Y-%m-%d "
"%H:%M:%S"))
session.add(row)
session.commit()
def test_view_logs2(self):
new_viewer = Viewer(Log.select())
expected = 'eds'
with patch('viewer.input', return_value='s'):
new_viewer.view_logs()
actual = new_viewer.menu_options
self.assertEqual(actual, expected)
def get(self):
# get user ip
if self.request.remote_addr:
# query geo-location of IP
query_args = { 'token' : 'dWEF43tHwFfgG51ASeFg5087rtRBR', 'ip' : self.request.remote_addr }
encoded_args = urllib.urlencode(query_args)
url = 'http://52.34.94.166:3000/get_ip_geo'
result = json.loads(urllib2.urlopen(url, encoded_args).read())
print result
lat_lng = result['geo']['ll']
# store data
custom_index_log.ip_address = self.request.remote_addr
custom_index_log.lat = lat_lng[0].__str__()
custom_index_log.lng = lat_lng[1].__str__()
custom_index_log.put()
# set template
template = JINJA_ENVIRONMENT.get_template('index.html')
# get ip addresses of visitors
ip_logs = Log.query().order(-Log.access_time)
# values to pass to front-end
template_values = { 'title' : 'Bay Technology',
'greeting' : 'Hello Bay Tecnology',
'ip_logs' : ip_logs}
# dispatch template and values to front-end
self.response.write(template.render(template_values))
def do(self):
decryptedFile = ExportTask.format_filename()
encryptedFile = ExportTask.format_filename_processed(decryptedFile)
dataset = self._get_data()
datafile = helper.SHPDDataFile(encryptedFile, decryptedFile, dataset=dataset, file_type=helper.SHPDDataFile.TYPE_UPDATE)
dataset = datafile.process()
self._send_email(decryptedFile)
'save log'
info_dict={}
info_dict.update(dataset.get('header'));
info_dict.update({'decryptedfile':decryptedFile, 'encryptedfile':self.encryptedFile})
log = Log()
log.info = json.dumps(info_dict)
log.identitiy = encryptedFile
log.status = ExportTask.STATUS_DATA_LOADED
log.op_id = self.operator_id
log.save()
'archive file'
datafile.archive()
def logs(req):
"""
Creates an entity in the log
:param req:
:return: 201, and the log object
"""
if req.method == 'GET':
logs = Log.query().fetch(1)
return logs[0]
else:
try:
j_req = json.loads(req.body)
except (TypeError, ValueError) as e:
raise BadRequest("Invalid JSON")
log = Log()
log.data = j_req
log.put()
return 201, log.data
def book_borrow(request):
if request.method == "POST":
id = request.POST.get("id")
username = request.POST.get("username", "")
next = request.POST.get("next", "")
book = Book.objects.get(id=int(id))
if book.available:
log = Log()
log.username = username
log.book = book
log.save()
book.available = False
book.username = username
book.save()
messages.success(request, "借阅成功！")
return HttpResponseRedirect(next)
else:
return HttpResponseForbidden()
else:
return HttpResponseForbidden()
def read_to_db(self, multiple_data):
for email_digest, encryptedFile in multiple_data:
'read data from file'
decryptedFile = EmailTask.format_filename_processed(encryptedFile)
datafile = helper.SHPDDataFile(encryptedFile, decryptedFile, helper.SHPDDataFile.TYPE_RECEIVE)
dataset = datafile.process()
'save details'
self.save2db(dataset.get('details'))
'save log'
info = json.dumps(dict(status=EmailTask.STATUS_DOWNLOADED, encryptedfile=encryptedFile, decryptedfile=decryptedFile, header=dataset.get('header')))
log = Log(identitiy=email_digest, type=Log.TYPE_CHOICES[1], info=info, status=0, op_id=0)
log.status = EmailTask.STATUS_DATA_LOADED
log.save()
'archive file'
datafile.archive()
def get(self, category):
"""
Grab the category, and return the number of an available doctor
"""
exotel_response = {field:self.request.get(field) for field in EXOTEL_RESPONSE_FIELDS}
today = datetime.datetime.now(IST())
day = str(today.weekday())
hour = str(today.hour) + str(today.minutes)
doctor = User.fetch_available_users(category, day, hour)
if doctor:
#put logging in taskqueue with URL-safe key
Log.log_call_pre(call_sid=exotel_response['CallSid'],
from_number=exotel_response['From'],
doctor=doctor)
self.response.out.write(doctor.mobile)
def change_money(people, money, action):
for person in people:
person.money += money
person.save()
assert action and action <> ''
try:
a = Action.objects.get(name=action)
except:
a = Action(name=action)
a.save()
if len(people) == 1:
content = "{0}元".format(money)
else:
content = "每人{0:.3f}元".format(money)
log = Log(action=a, content=content)
log.save()
for person in people:
log.people.add(person)
log.save()
def post(self):
# init models object
custom_index_log = Log()
custom_index_log.ip_address = self.request.remote_addr
custom_index_log.alarm_id = self.request.get("SENSOR_ID")
custom_index_log.alarm_status = self.request.get("SENSOR_STATUS")
custom_index_log.alarm_count = self.request.get("SENSOR_COUNT")
custom_index_log.put()
self.response.headers['Content-Type'] = 'text/plain'
self.response.write('return successful')
def log_in(request):
if request.user.is_authenticated():
return render_to_response('dashboard.html', {'user': request.user})
state = ""
username = password = ''
if request.POST:
username = request.POST.get('username')
password = request.POST.get('password')
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
login(request, user)
state = "Login ok!"
Log.create(user, "Logged in", None, None).save()
return HttpResponseRedirect("/dashboard/")
else:
state = "Account not active."
else:
state = "* Wrong username or password."
return render_to_response('login.html',RequestContext(request, {'state':state}))
def change(request, document_number):
doc= Dokument.objects.get(id=int(document_number))
prevfaculty = doc.faculty
users_list= Faculty.objects.all()
if request.method=='POST':
faculty= request.POST.get('faculty')
current_faculty = faculty
faculty_name= faculty
faculty= faculty.replace(',', "")
for person in users_list:
if faculty.split(' ')[0]==person.last_name:
for k in faculty.split(' '):
if k== person.last_name: continue
elif k not in person.first_name: break
doc.faculty_id=person.id
doc.save()
Log.create(request.user, "Changed owenership of a record owned by " + str(prevfaculty) + " to " + str(current_faculty), None, doc).save()
return HttpResponseRedirect("/records")
else:
print 'hi'
faculty_list= Faculty.objects.all()
return render_to_response('change.html', {'doc':doc, 'faculty_list':faculty_list})
def Log(self, channel, body, person=None, system=False):
"""Log a message.
Args:
channel: The channel object the message was sent to.
body: The body of the message.
person: The person who sent the message. Defaults to self.person.
system: Whether this is a system log (i.e. not a chat).
You should not use person and system at the same time.
"""
if person and system:
raise RuntimeError('You can\'t use person and system here')
if not system:
if not person: person = self.person
log = Log(channel=channel.name,
user=person.user.email(),
body=body)
else:
log = Log(channel=channel.name,
system=True,
body=body)
log.put()
def get():
"""
Log the post-call data
"""
call_sid = self.request.get('CallSid')
call = Log.query(Log.call_sid==call_sid).fetch()
if call:
call_duration = self.request.get('DialCallDuration')
start_time = self.request.get('StartTime')
end_time = self.request.get('EndTime')
call.put()
def emit(self, record):
from models import Log
try:
request = record.request
filter = get_exception_reporter_filter(request)
request_repr = filter.get_request_repr(request)
except Exception:
request = None
request_repr = "Request repr() unavailable."
if record.exc_info:
exc_info = record.exc_info
stack_trace = '\n'.join(traceback.format_exception(*record.exc_info))
else:
exc_info = (None, record.getMessage(), None)
stack_trace = "No stack trace available"
rec = Log(level = record.levelname,
message = record.getMessage(),
request = request_repr,
traceback = stack_trace
)
rec.save()
def RenderTranscript(self):
channel = self.request.get('channel', '')
values = {
'channel': channel,
}
# Query for the correct set of logs.
query = Log.all().filter('channel =', channel)
if 'start_time' in self.request.GET:
# Followed a 'next page' link
query.order('timestamp')
t = time.strptime(self.request.GET['start_time'], '%Y%m%d%H%M%S')
query.filter('timestamp >=', datetime.datetime(*t[0:6]))
# Fetch N+1 to check for a next page
logs = query.fetch(self._TRANSCRIPT_LINES + 1)
values['first_time'] = logs[0].timestamp.strftime('%Y%m%d%H%M%S')
if len(logs) > self._TRANSCRIPT_LINES:
logs = logs[0:self._TRANSCRIPT_LINES]
values['last_time'] = logs[-1].timestamp.strftime('%Y%m%d%H%M%S')
else:
query.order('-timestamp')
reversed = True
if 'end_time' in self.request.GET:
# Followed a 'prev page' link
t = time.strptime(self.request.GET['end_time'], '%Y%m%d%H%M%S')
t = list(t[0:6])
t[5] += 1 # round up so we ignore fractional seconds
query.filter('timestamp <=', datetime.datetime(*t))
# Fetch N+1 to check for a prev page
logs = query.fetch(self._TRANSCRIPT_LINES + 1)
values['last_time'] = logs[0].timestamp.strftime('%Y%m%d%H%M%S')
else:
# No 'prev/next' links followed, so no filter
# Fetch N+1 to check for a prev page
logs = query.fetch(self._TRANSCRIPT_LINES + 1)
if len(logs) > self._TRANSCRIPT_LINES:
logs = logs[0:self._TRANSCRIPT_LINES]
values['first_time'] = logs[-1].timestamp.strftime('%Y%m%d%H%M%S')
logs.reverse()
values['logs'] = logs
# Adjust timezone if requested.
if 'tz' in self.request.GET:
tz = FixedOffsetZone(int(self.request.get('tz')))
for log in logs:
t = log.timestamp + tz.utcoffset(log.timestamp)
log.timestamp = t.replace(tzinfo=tz)
self.Render('transcript.html', values)
def get(self):
# set template
template = JINJA_ENVIRONMENT.get_template('index.html')
# get ip addresses of visitors
ip_logs = Log.query().order(-Log.access_time)
# values to pass to front-end
template_values = { 'title' : 'COEN296 IoT',
'greeting' : 'Door Alarm Demo',
'ip_logs' : ip_logs}
# dispatch template and values to front-end
self.response.write(template.render(template_values))
def save_log(request):
'''记录收到的警告记录'''
level = request.POST.get('level', '')
msg = request.POST.get('msg', '')
if not level or not msg:
return HttpResponse(u'参数错误')
try:
level = int(level)
except:
return HttpResponse(u'参数错误')
ip = request.META.get('REMOTE_ADDR', '')
settings = ServerSettings.objects.filter(server_ip=ip)
if settings:
'''找到服务器设置'''
setting = settings[0]
#记录
log = Log()
log.server = setting
log.level = level
log.content = msg
log.save()
print 'log: ', msg
#检查是否推送
push_logs = setting.pushlog_set.order_by('-submit_date')
is_push = False
if push_logs:
#计算时间
push_log = push_logs[0]
now = datetime.datetime.now()
interval = now - push_log.submit_date
if interval.days > 0 or interval.seconds > 30*60:
'''推送间隔要大于30分钟'''
is_push = True
else:
'''没有记录，则要记录'''
is_push = True
if is_push:
'''需要推送'''
print '!!!!!!!!!!!!!!push msg: ', msg
push_log = PushLog()
push_log.server = setting
push_log.content = msg
push_log.save()
return HttpResponse('log ok')
else:
'''没有这个服务器设置'''
return HttpResponse('fail, not setting about this server')
