def sync_total_progress(dev, tol, cur, session_key=""):
d_server = start_dict_server()
d_server.set_to_dict("DEV_COMM_SYNC_%s" % session_key,
"%d,%d" % (tol, cur))
d_server.set_to_dict("DEV_COMM_PROGRESS_%s" % session_key,
"%s,0" % dev.encode("gb18030"))
d_server.close()
def clear_progress_cache(devs, session_key=""):
d_server = start_dict_server()
d_server.set_to_dict("DEV_COMM_SYNC_%s" % session_key,
"%d,0" % (len(devs) * 2))
if devs:
d_server.set_to_dict("DEV_COMM_PROGRESS_%s" % session_key,
"%s,0" % devs[0].alias.encode("gb18030"))
else:
d_server.set_to_dict("DEV_COMM_PROGRESS_%s" % session_key, ",0")
d_server.close()
def check_acc_device(request, d_server, allow_create=False):
from mysite.iclock.models import Device
from base.cached_model import STATUS_PAUSED, STATUS_STOP
from mysite.iaccess.dev_comm_center import DEVOPT
import time
import datetime
from mysite.iclock.models.model_device import DEVICE_ACCESS_CONTROL_PANEL
from redis_self.server import start_dict_server
from mysite.iclock.cache_cmds import check_and_init_cmds_cache
#print '---request=',request
device = None
global g_monitor_server
if not g_monitor_server:
#print '--rtlog--first time=',g_monitor_server
g_monitor_server = start_dict_server()
if not d_server:
d_server = g_monitor_server
try:
sn = request.GET["SN"]
#print '---sn=',sn
except:
sn = request.raw_post_data.split("SN=")[1].split("&")[0]
dev_info = d_server.get_from_dict("PUSH_DEV_INFO")#暂没有加设备的同步.....darcy20110803锦湖轮胎
len = d_server.llen_dict(DEVOPT)
#print '--len=',len
# print '-----!!dev_info=',dev_info
if not dev_info or len > 0:#设备信息初始化 len > 0意味着有新增、编辑或者删除操作的（任意一个）
#{"PUSH_DEVICE_INFO", {"1234",:{"dev_obj":<>,"push_status":1, "pull_status":0},{"23455":{}}}
devs = Device.objects.filter(device_type=DEVICE_ACCESS_CONTROL_PANEL)
dev_dict = {}
for dev in devs:
dev_dict[dev.sn] = dev
d_server.set_to_dict("PUSH_DEV_INFO", dev_dict)
dev_info = dev_dict
#print '----dev_info=',dev_info
#print sn, dev_info.keys()
if sn in dev_info.keys():#设备存在
device = dev_info[sn]
#print '--sn==',sn
if device.status in (STATUS_STOP, STATUS_PAUSED):
return None
#初始化设备的在线状态（此处仅更新push的在线状态）--darcy20110803锦湖轮胎
#push_state = d_server.get_from_dict("PUSH_STATE_" + sn)
#if push_state <= 0:#等于0的话为在线--darcy20110803锦湖轮胎
d_server.set_to_dict("PUSH_STATE_%s"%sn, time.mktime(datetime.datetime.now().timetuple()))
#print '-key=',"PUSH_STATE_%s"%sn
#print '--get_push_state=',d_server.get_from_dict("PUSH_STATE_%s"%sn), "PUSH_STATE_%s"%sn
#device.last_activity = datetime.datetime.now()?????
check_and_init_cmds_cache(device)
return device
def option(request, usr, catalog):
from base.options import OptionForm
from django.core.cache import cache
from django.utils.translation import get_language
if usr.is_anonymous():
return HttpResponse(_(u'没有权限'))
if request.method == 'POST':
from django.conf import settings
if "mysite.iaccess" in settings.INSTALLED_APPS:
from redis_self.server import start_dict_server
import dict4ini
is_contain_att = request.POST.get("is_contain_att")
d_server = start_dict_server()
att_dict = d_server.get_from_dict("IS_CONTAINS_ATT")
if att_dict != None:
att_dict = int(att_dict)
cfg = dict4ini.DictIni(os.getcwd() + "/appconfig.ini",
values={"iaccess": {
"is_contain_att": 0
}})
if is_contain_att == "on":
if att_dict != 1:
d_server.set_to_dict("IS_CONTAINS_ATT", '1')
cfg.iaccess.is_contain_att = 1
cfg.save()
elif is_contain_att == None:
if att_dict == 1:
d_server.set_to_dict("IS_CONTAINS_ATT", '0')
cfg.iaccess.is_contain_att = 0
cfg.save()
f = OptionForm(catalog, usr, request.POST)
if f.is_valid(
): # All validation rules pass Process the data in form.cleaned_data
try:
f.save()
k = "user_id_%s" % usr.pk
cache.delete(k)
except Exception, e: #保存失败
import traceback
traceback.print_exc()
from data_edit import NON_FIELD_ERRORS
f.errors[
NON_FIELD_ERRORS] = u'<ul class="errorlist"><li>%s</li></ul>' % e
else:
lng = get_language()
cache.delete(u"%s_%s_%s" % (lng, usr.username, "menu_list"))
if request.is_ajax():
return getJSResponse('{ Info:"OK" }')
else:
return HttpResponse(u"%s" % f.errors)
def action(self):
if self.object.device_type == DEVICE_ACCESS_CONTROL_PANEL:
if not self.object.enabled:
raise Exception(_(u'设备已被禁用！'))
ret = self.object.set_acc_push_params(enable=1)
if ret >= 0:
self.object.accdevice.iclock_server_on = 1
self.object.accdevice.save(force_update=True)
d_server = start_dict_server()
d_server.set_to_dict(ACCDEVICE_PUSH_ON % self.object.sn, 1)
d_server.close()
raise Exception(_(u"操作成功！"))
else:
raise Exception(_(u"操作失败！"))
def ClearCmdCache(request):
dev_id = request.GET.get("devid", 0)
if dev_id:
dev = Device.objects.get(id=dev_id)
q_server = queqe_server()
q_server.delete_file(dev.new_command_list_name()) #手动删除新命令
q_server.connection.disconnect()
d_server = start_dict_server()
d_server.delete_dict(dev.command_temp_list_name())
d_server.delete_dict(dev.command_count_key())
d_server.close()
return HttpResponse(smart_str({'ret': 1}))
else:
return HttpResponse(smart_str({'ret': 0}))
def is_contain_att(site): #site变量暂无实际意义。
import dict4ini
from django.conf import settings
from redis_self.server import start_dict_server
current_path = settings.APP_HOME
if 'mysite.iaccess' in settings.INSTALLED_APPS:
d_server = start_dict_server()
is_contain_att = d_server.get_key('IS_CONTAINS_ATT')
if is_contain_att == None:
#print '*******read is_att from file***'
app = dict4ini.DictIni(current_path + "/appconfig.ini")
is_contain_att = app["iaccess"].has_key(
"is_contain_att") and app["iaccess"]["is_contain_att"] or "0"
d_server.set_to_dict('IS_CONTAINS_ATT', is_contain_att)
d_server.close()
return settings.ZKACCESS_ATT and int(is_contain_att)
return True
def downdata_progress(request): #进度条后台控制
global g_monitor_server
if not g_monitor_server:
g_monitor_server = start_dict_server()
cdatas = []
skey = request.session.session_key
#print "downdata_progress=", skey
cur_gress = g_monitor_server.get_from_dict("DEV_COMM_PROGRESS_%s" % skey)
tol_gress = g_monitor_server.get_from_dict("DEV_COMM_SYNC_%s" % skey)
if cur_gress and tol_gress:
cur_strs = cur_gress.split(",", 2)
tol_gress = tol_gress.split(",", 2)
try:
icur = int(cur_strs[1])
except:
icur = 0
try:
itol = (int(tol_gress[1]) * 100) / int(tol_gress[0])
except:
itol = 0
cdata = {
'dev': cur_strs[0].decode("gb18030"),
'progress': icur,
'tolprogress': itol,
}
cdatas.append(cdata)
#g_monitor_server.close()
cc = {
'index': 1,
'data': cdatas,
}
else:
cdata = {
'dev': "",
'progress': 0,
'tolprogress': 0,
}
cdatas.append(cdata)
#g_monitor_server.close()
cc = {
'index': 0,
'data': cdatas,
}
rtdata = simplejson.dumps(cc)
return HttpResponse(smart_str(rtdata))
def comm_error_msg(request):
global g_monitor_server
if not g_monitor_server:
#print '--error--first time=',g_monitor_server
g_monitor_server = start_dict_server()
cdatas = []
cc = {}
global g_dev_comm_error_list
if g_dev_comm_error_list:
#print '---dev_list exist'
dev_list = g_dev_comm_error_list
else:
#print '---dev_list not exist'
dev_list = filterdata_by_user(
Device.objects.filter(device_type=DEVICE_ACCESS_CONTROL_PANEL),
request.user)
g_dev_comm_error_list = dev_list
#print '----dev_list=',dev_list, dev_list.count()
#print '-----dev_list=', dev_list
icount = 0
for dev in dev_list:
if not dev.enabled: #不监控已禁用的设备
continue
key = dev.command_temp_list_name()
ucmd = g_monitor_server.get_from_dict(key)
if ucmd is None:
continue
ret = ucmd['CmdReturn']
#print ret
if (-400 < ret < -200) or (ret < -10000) or (ret == -1001):
icount += 1
cdata = {
'devname': ucmd['SN'].alias,
}
cdatas.append(cdata)
cc = {
'cnt': icount,
'data': cdatas,
}
#g_monitor_server.close()
rtdata = simplejson.dumps(cc)
return HttpResponse(smart_str(rtdata))
def action(self, get_records, sd_file):
if self.object.device_type == DEVICE_ACCESS_CONTROL_PANEL:
if not self.object.enabled:
raise Exception(_(u'设备已被禁用！'))
from mysite.iaccess.devcomm import TDevComm
from mysite.iaccess.dev_comm_center import process_event_log
#获取事件记录时先检查数据中心是否开启
d_server = start_dict_server()
if not d_server.get_from_dict("CENTER_RUNING"):
ret = -1003
raise Exception(_(u"获取事件记录失败，错误码：%s") % ret)
d_server.close()
if get_records == "1":
ret = self.object.upload_acclog(True)
elif get_records == "2":
if not self.request.FILES.has_key('sd_file'):
raise Exception(_(u"请选择目标文件"))
file = self.request.FILES['sd_file']
if not file:
raise Exception(_(u"目标文件不存在"))
# try:
# if not file.name.endswith(".dat"):
# raise Exception(_(u"目标文件格式错误"))
# except:
# raise Exception(_(u"目标文件格式错误"))
file_buffer = file.read()
tdev = TDevComm({})
result = tdev.get_transaction("SD", file_buffer, file.size)
ret = result["result"]
sn = result["data"][0].split(',')[0]
if sn != self.object.sn:
raise Exception(_(u"当前文件里的记录不属于该设备！"))
#result["data"].pop(0)
process_event_log(self.object, result)
else:
ret = self.object.upload_acclog(False)
if ret >= 0:
raise Exception(
_(u"<font color='blue'>获取事件记录成功，共 %d 条</font>") % ret)
else:
raise Exception(_(u"获取事件记录失败，错误码：%s") % ret)
def acc_cdata(request, response):
from redis_self.server import start_dict_server
from mysite.iclock.devview import cdata_get_options
# print '====innini=--acc_cdata'
resp = ''
try:
global g_monitor_server
if not g_monitor_server:
#print '--rtlog--first time=',g_monitor_server
g_monitor_server = start_dict_server()
#检测设备是否存在，存在的话，检测设备的在线和离线状态。
device = check_acc_device(request, g_monitor_server, True)
print '----device=',device
if device is None:
return "UNKNOWN DEVICE"
# print '---request.method=',request.method
g_monitor_server.set_to_dict(device.get_last_activity(), datetime.datetime.now())
if request.REQUEST.has_key('action'):
resp += "OK\n"
elif request.method == 'GET':
#if request.REQUEST.has_key('PIN'):
# resp+=cdata_get_pin(request, device)
# else:
print '----request---get'
alg_ver = "1.0"
if request.REQUEST.has_key('pushver'):
alg_ver = request.REQUEST.get('pushver') #2010-8-25 device字段alg_ver用来区分新老固件 >=2.0为新固件，默认为旧固件
device.alg_ver = alg_ver
device.save()
resp += cdata_get_options(device)
elif request.method == 'POST':#处理设备上传上来的数据，如实时监控记录等。-darcy0803锦湖轮胎
# print '---cdata post'
try:
resp += acc_cdata_post(request, device, g_monitor_server)
# print '---!!!!!---resp=',resp
except Exception, e:
resp = u"ERROR: %s" % e
print e
#errorLog(request)
else:
def acd_getreq(request, resp, device):
from mysite.iclock.models.model_device import MAX_COMMAND_TIMEOUT_SECOND
from mysite.iclock.cache_cmds import get_request_cmds, check_pre_request, get_pre_request_cmds, TEMP_CMD_KEY
from redis_self.server import start_dict_server
print '=======acd_getreq=='
global g_monitor_server
if not g_monitor_server:
#print '--rtlog--first time=',g_monitor_server
g_monitor_server = start_dict_server()
g_monitor_server.set_to_dict(device.get_last_activity(), datetime.datetime.now())
try:
sn = request.GET["SN"]
except:
sn = request.raw_post_data.split("SN=")[1].split("&")[0]
# temp_cmd_list = cache.get(TEMP_CMD_KEY%device.pk)
# print temp_cmd_list,'======temp_cmd_list==key=',TEMP_CMD_KEY%device.pk
# if temp_cmd_list:
# temp_cmd_obj = temp_cmd_list.pop()
# cache.set(TEMP_CMD_KEY%device.pk, temp_cmd_list)
# return process_next_cmd(request, resp, device, temp_cmd_obj, sn, False)#处理紧急命令，不需要更新cache中的命令index，紧急命令单独存储、优先处理
pre_cmd_obj = cache.get("PROCESSING_CMD_OBJ_%s"%sn)
# timeout = CMD_RETURN_TIMEOUT
if pre_cmd_obj and not pre_cmd_obj.CmdImmediately:
check_ret = check_pre_request(device)#确认上次下发命令，机器是否成功接收到
if not check_ret:
devcmd = get_pre_request_cmds(device) #返回上一次下发的命令
print devcmd,'----precmdcmdmdm'
return process_next_cmd(request, resp, device, devcmd, sn, False)
else:
devcmd = get_request_cmds(device)
print devcmd, '========nextdevcmdddd'
return process_next_cmd(request, resp, device, devcmd, sn, True)
else:
devcmd = get_request_cmds(device)
print '---------devcmd=',devcmd
ret = process_next_cmd(request, resp, device, devcmd, sn, True)
return ret
def update_cache(visitor_pin=None, state=None, visit_time=None):
#print '--------update----cache=====', visitor_pin, '----state--', state, '---', visit_time
d_server = start_dict_server()
visitor_alarm_info = d_server.get_from_dict("visitor_alarm_info")
if visitor_alarm_info:
alarm_pin_list = d_server.get_from_dict("visitor_alarm_info")[0]
alarm_time_list = d_server.get_from_dict("visitor_alarm_info")[1]
alarm_time_length = d_server.get_from_dict("visitor_alarm_info")[2]
visitor_pin = int(visitor_pin)
try:
if state == "in":
if alarm_pin_list.count(
visitor_pin) > 0: #如果访客已在缓存中，更新进入的时间，放到缓存中最后一位
#print '---if----already ----here----'
index = alarm_pin_list.index(visitor_pin)
alarm_time_list.pop(index)
alarm_pin_list.remove(visitor_pin)
time = visit_time + datetime.timedelta(hours=alarm_time_length)
# print '--------time---', time
# print '-----visit_time---',visit_time
# print '-----hours-----', datetime.timedelta(hours=alarm_time_length)
alarm_pin_list.append(visitor_pin)
alarm_time_list.append(time)
elif state == "out": #离开,删除访客在缓存中的信息
#print '-----out----'
index = alarm_pin_list.index(visitor_pin)
alarm_time_list.pop(index)
alarm_pin_list.remove(visitor_pin)
d_server.set_to_dict(
"visitor_alarm_info",
[alarm_pin_list, alarm_time_list, alarm_time_length])
except Exception, e:
print '====update_cache===eeee===', e
finally:
def run(self):
init_Email()
d_server = start_dict_server()
q_server = FileQueue()
email_count = q_server.get_from_file("EMAILS")
if email_count:
d_server.set_to_dict("EMAIL_COUNT", 1)
# try:
while True:
#修改邮件参数不需要重启服务。-darcy20120220
change_args = d_server.get_from_dict("CHANGE_IACCESS_EMAIL_ARGS")
# print '-------change_iaccess_argument-----',change_args
if change_args:
cfg = dict4ini.DictIni(os.getcwd() + "/appconfig.ini",
values={
"iaccess": {
"down_newlog": 0,
"realtime_forever": 0
}
})
realtime_forever = int(cfg.iaccess.realtime_forever)
down_log_time = cfg.iaccess.down_newlog
init_Email(cfg)
d_server.set_to_dict("CHANGE_IACCESS_EMAIL_ARGS", 0)
email_info = d_server.get_from_dict("EMAIL_INFO")
# print "EMAIL_INFO:---",email_info
d_server.set_to_dict("EMAIL_INFO", "")
process_send_email(email_info, q_server, d_server)
# print "one round"
time.sleep(10)
# except:
# pass
# finally:
q_server.connection.disconnect()
d_server.close()
def get_redis_rtlog(request):
rtdata = {}
try:
#print '----in here request=',request
changed_value = request.GET.get(
"change",
"") #默认情况下为“”。决定是否需要重新获取所有有效设备，避免将设备缓存后前段无效。--darcy20110731
#print '-----changed_value=',changed_value
global g_area_dev_door_change
logid = int(request.GET.get('logid', FIRSTVISIT_OR_DELBACKEND))
step = int(request.GET.get('step', 0)) #步长：即要log的最大条数
rt_type = request.GET.get('type', '') #all alarm
devid = request.REQUEST.get("devid", 0) #默认为0，表示监控所有设备的所有门的状态
doors_id = request.GET.get("door_id", '0')
#再获取实时监控记录
#print '----before g_monitor_server'
#print '----00001'
global g_monitor_server
#print '----after g_monitor_server'
if not g_monitor_server:
#print '--rtlog--first time=',g_monitor_server
g_monitor_server = start_dict_server()
#控制后台是否需要开启实时监控
rtmonitor_stamp = datetime.datetime.now()
g_monitor_server.set_to_dict("RTMONITOR_STAMP", rtmonitor_stamp)
rtid_all = 0 #缓存里所有的记录条数
rtid_alarm = 0 #缓存里所有的报警事件记录
log_count = 0 #返回的有效记录条数
valid_devices_dict = {}
deleted = g_monitor_server.get_from_dict(
"MONITOR_RT_DEL") #没有该值时返回None，如果为True,实时监控需要重新取
g_monitor_server.delete_dict("MONITOR_RT_DEL")
#print '----deleted=',deleted
#print '----00003'
rtlog = []
if rt_type == "all":
#rtid_all = g_monitor_server.lock_rlen("MONITOR_RT")#被锁住时以及文件缓存为空时都返回-1，即该值不可能为0 此时前端继续使用原来的logid取数据
rtid_all = g_monitor_server.llen_dict("MONITOR_RT")
#print '-REALLOG--deleted=',deleted,' -rtid_all=',rtid_all, '---logid=',logid
#from mysite.utils import printf
#printf("---deleted=%s, rtid_all=%s, logid=%s"%(deleted, rtid_all, logid))
#获取门状态door_states
#为提高监控页面的用户体验，降低该页面的数据库查询，使用全局变量，避免查询数据库，这样就要求，用户添加或者修改设备信息后必须手动刷新页面，由于对于设备的操作不会过于频繁，所以可以接受--darcy20110728
#print '----00004'
global g_monitor_devices
changed_break = False
device_added = g_monitor_server.get_from_dict("DEVICE_ADDED") #新增
device_delete = g_monitor_server.get_from_dict(
"DEVICE_DELETE") #删除和编辑
check_enable = g_monitor_server.get_from_dict(
ACCDEVICE_ENABLE_CHANGED
) #禁用或者启用任何一台设备，实时监控都需要重新获取设备。--darcy20111012
last_doors_id = g_monitor_server.get_from_dict("VALID_DOORS")
valid_door_changed = (doors_id != last_doors_id
) #前端门改变了重新获取g_monitor_devices
#print '=======$$$$$valid_door_changed=%s'%valid_door_changed
if (not g_monitor_devices) or (
changed_value != g_area_dev_door_change
) or device_added or device_delete or check_enable or valid_door_changed:
#printf('=======$$$$$valid_door_changed=%s'%valid_door_changed, True)
#print '--- not exist or get again'
g_area_dev_door_change = changed_value
try:
valid_devices_dict = obtain_valid_devices(request)
except Exception, e:
print '-----e=', e
#print '---valid_devices_dict=',valid_devices_dict
g_monitor_devices = valid_devices_dict
changed_break = True
if device_added:
g_monitor_server.set_to_dict("DEVICE_ADDED", 0)
if device_delete:
g_monitor_server.set_to_dict("DEVICE_DELETE", 0)
else:
valid_devices_dict = g_monitor_devices
#sprint '--- exist'
#print '----00012'
global g_monitor_doors
if not g_monitor_doors or device_added or device_delete: #只用到id，没有用到其他的设备或者门的属性
#print '--g_monitor_doors not exist=',g_monitor_doors
for door in AccDoor.objects.all():
g_monitor_doors[int(door.id)] = door
#print '----00013'
#print '---g_dev_door_id=',g_dev_door_id
#print '----00005'
if deleted == True or rtid_all < logid:
logid = -1
if logid != -1:
#print '----00006'
if logid == FIRSTVISIT_OR_DELBACKEND: #监控全部时获取报警记录的初始id值
rtid_alarm = g_monitor_server.llen_dict("ALARM_RT")
#rtid_alarm = g_monitor_server.llen("ALARM_RT")
#rtlog = g_monitor_server.lrange_from_file("MONITOR_RT", logid, logid + step)
#print '--all real log-rtlog=',g_monitor_server.get_from_dict("MONITOR_RT")
#取出来的是列表
timeout = 0
# print '----000061'
while True:
rtlog = g_monitor_server.lrange_from_dict(
"MONITOR_RT", logid, logid + step)
if not rtlog:
doorstate_changed = g_monitor_server.get_from_dict(
"GET_DOORSTATE_AGAIN"
) #接受到后台通知，实时监控线程立即返回门状态数据--darcy20110805
#print '----doorstate_changed=',doorstate_changed
if doorstate_changed:
g_monitor_server.set_to_dict(
"GET_DOORSTATE_AGAIN", 0)
break
check_enable = g_monitor_server.get_from_dict(
ACCDEVICE_ENABLE_CHANGED)
if check_enable:
try:
valid_devices_dict = obtain_valid_devices(
request)
except Exception, e:
print '-----e2=', e
#print '---valid_devices_dict=',valid_devices_dict
g_monitor_devices = valid_devices_dict
g_monitor_server.delete_dict(
ACCDEVICE_ENABLE_CHANGED)
break
#print '----changed_break=',changed_break
if changed_break:
break
timeout += 1
# print '--timeout=',timeout
if timeout > 30: #60
#g_monitor_server.set_to_dict("GET_DOORSTATE_AGAIN", 0)
break #超时后HttpResponse
time.sleep(0.3)
continue
else:
g_monitor_server.set_to_dict("GET_DOORSTATE_AGAIN", 0)
break
#print '----000062'
#print '---valid_devices_dict=',valid_devices_dict
door_states = door_state_monitor(
valid_devices_dict.values(),
g_monitor_server) #门状态不涉及辅助输入点，故不需调整
def end_sync_userinfo(session_key=""):
d_server = start_dict_server()
d_server.delete_dict("DEV_COMM_SYNC_%s" % session_key)
d_server.delete_dict("DEV_COMM_PROGRESS_%s" % session_key)
d_server.close()
def trigger_cmd_device(cmd_obj):
#写入新命令队列
old_cmd = 0
write_log('---------in trigger_cmd_device cmd_obj=%s' % cmd_obj)
try:
q_server = queqe_server()
d_server = start_dict_server()
cln = cmd_obj.SN.new_command_list_name() #NEWCMD_*
#向文件缓存和dict中同时写入新命令
dev = cmd_obj.SN
#命令总数
cntkey = dev.command_count_key()
#print '---cntkey=',cntkey
cnt = d_server.get_from_dict(cntkey) #从dict中取
old_cmd = q_server.llen_file(cln)
write_log('---cmd_obj=%s,---cnt=%s,-----old_cmd=%s' %
(cmd_obj, cnt, old_cmd))
if cnt is None:
cnt = str(old_cmd)
write_log('------devcmd get length from file-cnt=%s' % cnt)
if cnt.find('\x00'):
cnt = cnt.strip('\x00')
#q_server.set(cntkey, "%d"%(int(cnt)+1))
if dev.device_type == DEVICE_ACCESS_CONTROL_PANEL and cmd_obj.CmdImmediately:
timeout = 0
while True:
temp_cmd_lock = d_server.get_from_dict("TEMP_CMD_LOCK")
if temp_cmd_lock: #如果当前其他线程或者进程在进行同样的操作，等待
write_log(
'--------!cmd_obj=%s temp_cmd_lock=%s timeout=%s' %
(cmd_obj, temp_cmd_lock, timeout))
timeout += 1
if timeout > 300:
break #超时后不放入缓存
time.sleep(0.5)
continue
else:
d_server.set_to_dict("TEMP_CMD_LOCK", 1)
immed_cmd_dict = d_server.get_from_dict("TEMP_CMD")
write_log('-devcmd-before immed_cmd_dict=%s, cmd_obj=%s' %
(immed_cmd_dict, cmd_obj))
if not immed_cmd_dict:
immed_cmd_dict = {}
immed_cmd_dict.setdefault(dev.id, [cmd_obj])
else:
devcmds = immed_cmd_dict.get(dev.id) or [
] #获取到当前设备对应的所有的紧急命令
# if devcmds:
# devcmds.append(cmd_obj)
# else:
# devcmds = []
devcmds.append(cmd_obj)
immed_cmd_dict[dev.id] = devcmds
write_log(
'-devcmd-before set_to_dict cmd_obj=%s,immed_cmd_dict=%s'
% (cmd_obj, immed_cmd_dict))
d_server.set_to_dict("TEMP_CMD", immed_cmd_dict)
d_server.set_to_dict("TEMP_CMD_LOCK", 0)
#immed_cmd_dict = d_server.get_from_dict("TEMP_CMD")
#write_log('-devcmd-after cmd_obj=%s,immed_cmd_dict=%s'%(cmd_obj, immed_cmd_dict))
#time.sleep(1)
#immed_cmd_dict = d_server.get_from_dict("TEMP_CMD")
#printf('-devcmd-after 5s cmd_obj=%s, immed_cmd_dict=%s'%(cmd_obj, immed_cmd_dict), True)
break
#print d_server.get_from_dict("TEMP_CMD"),'-----------devcmds'
else:
write_log('-------------------file catch')
q_server.lpush_to_file(cln, pickle.dumps(cmd_obj))
if not cmd_obj.CmdImmediately:
d_server.set_to_dict(cntkey, "%d" % (int(cnt) + 1)) #命令总数写入dict
write_log('---cmd_obj=%s--cnt========%s' %
(cmd_obj, d_server.get_from_dict(cntkey)))
q_server.connection.disconnect()
except:
print_exc()
if not (dev.comm_type == COMMU_MODE_PUSH_HTTP): #门禁设备不须通知
return
pass
#UDP 广播通知设备来读取命令
if old_cmd: #若新命令队列不空，说明设备上次的命令还没有执行，不需要再次通知设备
return
try:
ip = cmd_obj.SN.ipaddress
sNotify = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
if ip: sNotify.sendto("R-CMD", (ip, 4374))
except:
print_exc()
def get_visitor_monitor(request):
from view import get_visitor_option, get_visitor_in, get_visitor_by_pin, add_recode_to_report
d_server = start_dict_server()
current_time = datetime.datetime.now() #当前的时间
time_length = get_visitor_option() #来访的时长
visitor_alarm_info = d_server.get_from_dict(
"visitor_alarm_info") #获取缓存中访客来访需要监控的访客信息
#print '---------visitor_alarm_info=', visitor_alarm_info
alarm_visitor_info = [] #传到前端的访客信息
if visitor_alarm_info:
alarm_time_length = d_server.get_from_dict("visitor_alarm_info")[
2] #获取来访时长
#print '-----------alarm_time_length=', alarm_time_length
#如果来访时长修改了，更新缓存中的信息
if alarm_time_length != time_length:
#print '------update lai fang shi chang------'
visitor_in = get_visitor_in()
alarm_pin_set = visitor_in["alarm_pin_set"]
alarm_time_list = visitor_in["alarm_time_list"]
d_server.set_to_dict("visitor_alarm_info",
[alarm_pin_set, alarm_time_list, time_length])
#访客超过来访时长，将信息传到前端, 更新缓存
alarm_pin_set = d_server.get_from_dict("visitor_alarm_info")[0]
alarm_time_list = d_server.get_from_dict("visitor_alarm_info")[
1] #取缓存中的报警时间
alarm_info = {} #报警的信息
begin_length = len(alarm_pin_set) #缓存alarm_pin_set开始时的长度
end_length = 0 #缓存alarm_pin_set循环结束后的长度
for alarm_time in alarm_time_list:
# print '--------current_time==', current_time
# print '--------alarm_time====', alarm_time
if current_time < alarm_time: #当前时间小于报警时间，跳出
break
else:
index = alarm_time_list.index(alarm_time)
pin = alarm_pin_set[index] #获取来访超时的访客的编号
#print '-----pin=', pin
alarm_visitor = get_visitor_by_pin(pin) #获取来访超时的访客信息
#传到前端的访客信息
alarm_info["name"] = alarm_visitor[0]
#print '--------name=',alarm_info["name"]
alarm_info["pin"] = alarm_visitor[1]
alarm_info["card"] = alarm_visitor[2]
#print '--------card=', alarm_info["card"]
alarm_info["visitor_company"] = alarm_visitor[3]
alarm_info["visit_reason"] = alarm_visitor[4]
alarm_info["visitor_number"] = alarm_visitor[5]
alarm_info["exit"] = alarm_visitor[6]
alarm_info["visit_time"] = str(alarm_visitor[7])
alarm_visitor_info.append(alarm_info)
#往报表插入记录
#print '----begin add to report-------'
add_recode_to_report(alarm_info)
#print '---------end add to report----'
#更新缓存
alarm_pin_set.remove(pin)
alarm_time_list.remove(alarm_time)
end_length = len(alarm_pin_set)
#有变化，更新缓存
if begin_length > end_length:
d_server.set_to_dict("visitor_alarm_info",
[alarm_pin_set, alarm_time_list, time_length])
#重启系统后
else:
try:
visitor_in = get_visitor_in()
if visitor_in:
alarm_pin_set = visitor_in["alarm_pin_set"]
alarm_time_list = visitor_in["alarm_time_list"]
d_server.set_to_dict(
"visitor_alarm_info",
[alarm_pin_set, alarm_time_list, time_length])
except Exception, e:
print '---else--e=', e
def action(self, firmware_file):
if self.object.device_type == DEVICE_ACCESS_CONTROL_PANEL: #门禁
if not self.object.enabled:
raise Exception(_(u'设备已被禁用！'))
if not self.request.FILES.has_key('firmware_file'):
raise Exception(_(u"目标文件不存在"))
file = self.request.FILES['firmware_file']
if not file:
raise Exception(_(u"目标文件不存在"))
if file.name != "emfw.cfg":
raise Exception(_(u"目标文件名错误"))
#for chunk in file.chunks():
#buffer.write(chunk)
buffer = file.read()
from mysite.iaccess.devcomm import TDevComm
devcomm = TDevComm(self.object.getcomminfo())
d_server = None
service_running = True #门禁后台服务
from mysite.iaccess.dev_comm_center import check_service_commcenter
d_server = start_dict_server()
#print '--------before wait_com_pause'
service_running = check_service_commcenter(d_server)
if service_running:
if self.object.comm_type == COMMU_MODE_PULL_RS485: #485通讯
from mysite.iaccess.dev_comm_center import wait_com_pause
if wait_com_pause(d_server, self.object.com_port,
60) == False: #等待后台停止进程
#print '------wait_com_pause failed'
d_server.close()
raise Exception(_(u"升级固件失败，原因：后台串口进程忙"))
else:
os.system("taskkill /im plrscagent.* /f")
elif self.object.comm_type == COMMU_MODE_PULL_TCPIP:
from mysite.iaccess.dev_comm_center import wait_thread_pause
if wait_thread_pause(d_server, self.object.id,
60) == False: #等待后台停止进程
#print '------wait_com_pause failed'
d_server.close()
raise Exception(_(u"升级固件失败，原因：后台设备线程忙"))
cret = devcomm.connect()
#print '----cret = ',cret
#print '------after connect the device cret=',cret
if cret['result'] > 0:
#print '----before upgrade_firmware'
ret = devcomm.upgrade_firmware(file.name, buffer, file.size)
#print '---after upgrade firmware'
#无论成功与否，先让后台进程继续
if self.object.comm_type == COMMU_MODE_PULL_RS485 and service_running:
from mysite.iaccess.dev_comm_center import set_comm_run
#print '-set_comm_run-=',set_comm_run
set_comm_run(d_server, self.object.com_port) #后台进程继续
elif self.object.comm_type == COMMU_MODE_PULL_TCPIP and service_running:
from mysite.iaccess.dev_comm_center import set_thread_run
#print '---set_thread_run time=',datetime.datetime.now()
set_thread_run(d_server, self.object.id) #后台线程继续
d_server.close()
if ret['result'] >= 0: #
devcomm.reboot()
devcomm.disconnect()
raise Exception(_(u"<font color='blue'>操作成功</font>"))
else:
devcomm.disconnect()
raise Exception(_(u"升级固件失败，错误码：%d") % ret['result'])
else:
from mysite.iaccess.dev_comm_center import DEVICE_COMMAND_RETURN
#print '----connect failed'
try:
reason = unicode(
dict(DEVICE_COMMAND_RETURN)[str(cret["result"])])
raise Exception(_(u"连接设备失败（原因：%s），无法升级固件。") % reason)
except:
raise Exception(
_(u"设备连接失败（错误码：%d），无法升级固件。") % cret['result'])
def action(self, **kwargs):
d_server = start_dict_server()
self.object.set_dev_enabled(d_server)
d_server.close()
def obtain_valid_devices(request):
u = request.user
aa = u.areaadmin_set.all() #如果新增用户时设定区域，那么aa不为空，否则为空代表全部（包含普通用户和超级管理员）
a_limit = aa and [int(a.area_id) for a in aa] or [
int(area.pk) for area in Area.objects.all()
] #非超级管理员且没有配置有效区域（默认全部）的有效区域id列表（即用户手动配置过用户区域的）
area_id = int(request.GET.get("area_id", 0)) #不为0.前端随已经过过滤，但是考虑用户可以手动修改url
#print '----area_id=',area_id
if area_id and area_id in a_limit:
#devices = Device.objects.filter(area__pk=area_id)#权限范围内的全部
devices = Device.objects.filter(
Q(area__pk=area_id) | Q(area__in=Area.objects.get(
id=area_id).area_set.all())) #权限范围内的全部,且要处理区域的上下级
else:
device_id = int(request.GET.get("device_id", 0))
#print '----device_id=',device_id
dev_limit = [
int(d.pk) for d in Device.objects.filter(area__pk__in=a_limit)
] #权限范围内的设备
if device_id and device_id in dev_limit:
devices = Device.objects.filter(pk=device_id)
else:
door_limit = [
int(door.id) for door in AccDoor.objects.filter(
device__area__pk__in=a_limit)
] #所有有效的
doors_id = request.GET.get("door_id",
'0') #此处可能是单个数字也可以能是多个 0代表默认情况（全部门）
global g_monitor_server
if not g_monitor_server:
g_monitor_server = start_dict_server()
g_monitor_server.set_to_dict(
"VALID_DOORS",
doors_id) #前端获取到的需要监控的门，若此值改变需重新获取g_monitor_devices
#print '--first--doors_id=',doors_id ,'type=',type(doors_id)
is_many_doors = doors_id.__contains__(',')
if is_many_doors: #多门
doors_id = doors_id.split(",") #默认0，取全部
#print '----doors_id=',doors_id
doors_id_left = [
int(id) for id in doors_id if int(id) in door_limit
] #当前需要的---不过滤也可以
devices = Device.objects.filter(
accdoor__pk__in=doors_id_left).distinct()
#print '---devices=',devices
elif doors_id == '0': #没有area_id,device_id,door_id的请求--door_id实际不可能为0
#print '----none----'
devices = Device.objects.filter(area__pk__in=a_limit)
else: #单门
devices = Device.objects.filter(
accdoor__pk=int(doors_id)).distinct()
valid_devices_dict = {}
valid_devices = devices.filter(device_type=DEVICE_ACCESS_CONTROL_PANEL)
for dev in valid_devices:
valid_devices_dict[int(dev.id)] = dev
#print '--@@@@@valid_devices_dict values=', valid_devices_dict.values()
global g_dev_door_id #记录dev和door id的关系
for dev in valid_devices_dict.values():
ids = dev.accdoor_set.values_list("id")
g_dev_door_id[int(dev.id)] = [int(id[0]) for id in ids
] #[(12L,), (11L,), (9L,), (10L,)]
return valid_devices_dict
def get_device_monitor(request):
try:
global g_monitor_server
if not g_monitor_server:
g_monitor_server = start_dict_server()
service_enable = check_service_commcenter(g_monitor_server)
dev_monitor_list = g_monitor_server.get_from_dict("DEV_MONITOR_LIST")
device_added = g_monitor_server.get_from_dict(
"DEVICE_ADDED_MONITOR") #新增
device_delete = g_monitor_server.get_from_dict(
"DEVICE_DELETE_MONITOR") #删除和编辑
#print '------dev_monitor_list=',dev_monitor_list
if not dev_monitor_list or device_added or device_delete: #意味着有新增、编辑或者删除操作的（任意一个）
#print '---monitor device not exist'
u = request.user
aa = u.areaadmin_set.all()
a_limit = aa and [int(a.area_id) for a in aa] or [
int(area.pk) for area in Area.objects.all()
] #非超级管理员且没有配置有效区域（默认全部）的有效区域id列表（即用户手动配置过用户区域的）
dev_monitor_list = Device.objects.filter(
area__pk__in=a_limit).filter(
device_type=DEVICE_ACCESS_CONTROL_PANEL).order_by(
'id') #当前用户授权范围内的门禁控制器
#g_dev_monitor_list = dev_list
g_monitor_server.set_to_dict(
"DEV_MONITOR_LIST",
[dev for dev in dev_monitor_list]) #QuerySet无法直接pickle
if device_added:
g_monitor_server.set_to_dict("DEVICE_ADDED_MONITOR", 0)
if device_delete:
g_monitor_server.set_to_dict("DEVICE_DELETE_MONITOR", 0)
cdatas = []
for dev in dev_monitor_list:
ret = 0
op_type = ""
op_state = ""
key = dev.command_temp_list_name() #ICLOCK_%s_TMP#
#print '-!!!!!!!!!!!-key=',key
ucmd = g_monitor_server.get_from_dict(key) #tmp 获取设备通讯状态
#print '-----get device monitor =',g_monitor_server.llen_file(key)
#print '--------get-device-monitor====ucmd====',ucmd
q_server = queqe_server()
#cmdcount = q_server.llen_file(dev.new_command_list_name())#新命令NEWCMDS_%scmdcount = g_monitor_server.llen(dev.new_command_list_name())#NEWCMDS_%s
q_server.connection.disconnect()
cntkey = dev.command_count_key() #ICLOCK_%s_CMD
#print '---------cntkey=',cntkey
cnt = g_monitor_server.get_from_dict(cntkey) #从缓存dict中获取命令总条数
if cnt is None:
cnt = "0"
if cnt.find('\x00'):
cnt = cnt.strip('\x00')
try:
cnt = int(cnt)
except:
cnt = 0
reason = ""
if service_enable:
if ucmd is None: #ucmd为None代表没有其他状态
if not dev.enabled: #设备被禁用
#g_monitor_server.set_to_dict()
op_type = get_cmd_content("CONNECT") #
ret = '-1002' #警告 <-1000
op_state = unicode(DEVICE_COMMAND_RETURN[ret])
else: #没有其他状态时的默认状态
op_type = get_cmd_content("CONNECT") #
ret = '1001' # 正在连接
op_state = unicode(DEVICE_COMMAND_RETURN[ret])
else:
#print '----ucmd=',ucmd,'----type=',type(ucmd)
#print '---ret=',ret
ret = ucmd['CmdReturn']
op_type = get_cmd_content(ucmd['CmdContent'])
if ret >= 0:
op_state = unicode(DEVICE_COMMAND_RETURN["0"])
else:
try:
op_state = unicode(DEVICE_COMMAND_RETURN[str(ret)])
except:
op_state = _(u"%(f)s:错误代码%(ff)d") % {
"f": DEVICE_COMMAND_RETURN["-1001"],
"ff": ret
}
else:
op_type = get_cmd_content("CHECK_SERVICE")
ret = '-1003' #警告 <-1000
op_state = unicode(DEVICE_COMMAND_RETURN[ret])
cdata = {
'id': dev.id,
'devname': dev.alias,
'sn': dev.sn,
'op_type': op_type, #操作类型
'op_state': op_state, #当前操作状态
'retmemo': reason,
'ret': ret,
'CmdCount': cnt,
}
cdatas.append(cdata)
cc = {'data': cdatas}
#g_monitor_server.close()
#g_monitor_server.connection.disconnect()
rtdata = simplejson.dumps(cc)
return HttpResponse(smart_str(rtdata))
except Exception, e:
print '---e=', e