def open_mouth(mouth_id: object = None) -> object: try: global last_open_mouth_id, last_mouth_number if mouth_id is None: logger.info(("open mouth again!", last_open_mouth_id)) mouth_id = last_open_mouth_id else: logger.info(("open mouth id :", mouth_id)) last_open_mouth_id = mouth_id mouth_list = BoxDao.get_mouth_by_id({"id": mouth_id}) if len(mouth_list) != 1: logger.warn("mouth list error!") return _mouth = mouth_list[0] cabinet_list = BoxDao.get_cabinet_by_id({"id": _mouth["cabinet_id"]}) if len(cabinet_list) != 1: logger.warn("cabinet list error!") return cabinet = cabinet_list[0] last_mouth_number = _mouth["number"] result = LockMachine.open_door(int(cabinet["number"]), int(_mouth["numberInCabinet"])) logger.debug(("LockMachine.open_door result is : ", result)) except Exception as e: logger.warn(("open_mouth error :", e))
def manager_set_mouth(mouth_id, box_status): set_mouth_param = {"id": mouth_id, "status": box_status, "syncFlag": 0} BoxDao.manage_set_mouth(set_mouth_param) box_signal_handler.manager_set_mouth_signal.emit("Success") message, status_code = HttpClient.post_message("box/mouth/sync", set_mouth_param) if status_code == 200: BoxDao.mark_sync_success(set_mouth_param)
def get_free_mouth_num(): __result = {} __mouth_type_list = BoxDao.get_all_mouth_type({"deleteFlag": 0}) for __mouth_type in __mouth_type_list: param = {"status": "ENABLE", "mouthType_id": __mouth_type["id"], "deleteFlag": 0} __free_mouth_count = BoxDao.get_count_by_status_and_mouth_type_id(param)[0] __result[__mouth_type["name"]] = __free_mouth_count["mouth_count"] box_signal_handler.free_mouth_num_signal.emit(json.dumps(__result))
def update_free_time(param): box_list = BoxDao.get_box_by_order_no({"orderNo": param["orderNo"], "deleteFlag": 0}) if len(box_list) == 0: logger.warn("box not found!") return False param["overdueType"] = ClientTools.get_value("overdueType", param) param["freeDays"] = ClientTools.get_value("freeDays", param) param["freeHours"] = ClientTools.get_value("freeHours", param) BoxDao.update_free_time(param) return True
def get_free_mouth_by_size(mouth_size): mouth_type_param = {"name": mouth_size} mouth_type_list = BoxDao.get_mouth_type(mouth_type_param) if len(mouth_type_list) != 1: return False mouth_type = mouth_type_list[0] mouth_param = {"mouthType_id": mouth_type['id'], "deleteFlag": 0, "status": "ENABLE"} mouth_list = BoxDao.get_free_mouth_by_type(mouth_param) if len(mouth_list) == 0: return False return mouth_list[0]
def free_mouth_by_size(mouth_size): mouth_type_param = {"name": mouth_size} mouth_type_list = BoxDao.get_mouth_type(mouth_type_param) if len(mouth_type_list) != 1: box_signal_handler.free_mouth_by_size_result.emit("Failure") mouth_type = mouth_type_list[0] mouth_param = {"mouthType_id": mouth_type['id'], "deleteFlag": 0, "status": "ENABLE"} mouth_list = BoxDao.get_free_mouth_by_type(mouth_param) if len(mouth_list) == 0: box_signal_handler.free_mouth_by_size_result.emit("Failure") box_signal_handler.free_mouth_by_size_result.emit("Success")
def init_client(): try: message, status_code = HttpClient.get_message('box/init') if status_code != 200: return message['statusMessage'] ClientDatabase.init_database() box_param = {'id': message['id'], 'name': message['name'], 'orderNo': message['orderNo'], 'validateType': message['validateType'], 'operator_id': message['operator']['id'], 'syncFlag': message['syncFlag'], 'currencyUnit': message['currencyUnit'], "overdueType": message['overdueType'], "freeHours": ClientTools.get_value("freeHours", message), "freeDays": ClientTools.get_value("freeDays", message), "holidayType": ClientTools.get_value("holidayType", message, None), "receiptNo": ClientTools.get_value("receiptNo", message, 0)} CompanyService.init_company(message['operator']) BoxDao.init_box(box_param) cabinets = message['cabinets'] for cabinet in cabinets: BoxDao.init_cabinet(cabinet) mouths = cabinet['mouths'] for m in mouths: __mouth = {'id': m['id'], 'deleteFlag': m['deleteFlag'], 'number': m['number'], 'usePrice': m['usePrice'], 'overduePrice': m['overduePrice'], 'status': m['status'], 'box_id': message['id'], 'cabinet_id': cabinet['id'], 'numberInCabinet': m['numberInCabinet'], 'syncFlag': m['syncFlag'], 'openOrder': ClientTools.get_value("openOrder", m)} if 'express' in m.keys(): __mouth['express_id'] = m['express']['id'] express.service.ExpressService.init_express(m['express'], __mouth, box_param) else: __mouth['express_id'] = None __mouth['mouthType_id'] = m['mouthType']['id'] mouth_type_param = m['mouthType'] mouth_type = {'id': mouth_type_param['id'], 'name': mouth_type_param['name'], 'defaultUsePrice': mouth_type_param['defaultUsePrice'], 'defaultOverduePrice': mouth_type_param['defaultOverduePrice'], 'deleteFlag': mouth_type_param['deleteFlag']} BoxDao.init_mouth_type(mouth_type) BoxDao.init_mouth(__mouth) if "holidays" in message.keys(): holidays = message["holidays"] for holiday in holidays: holiday_param = {'id': holiday['id'], 'startTime': holiday['startTime'], 'endTime': holiday['endTime'], 'delayDay': holiday['delayDays'], 'holidayType': holiday['holidayType']} BoxDao.init_holiday(holiday_param) box_signal_handler.init_client_signal.emit("Success") except Exception as e: logger.error(("init_client ERROR :", e)) box_signal_handler.init_client_signal.emit("ERROR")
def update_mouth_status(message_result): try: logger.info(("update_mouth_status:", message_result)) mouth_result = BoxDao.get_mouth_by_id({"id": message_result["mouth"]["id"]}) logger.debug(("mouth_result is :", mouth_result)) if len(mouth_result) == 0: box_post_message(message_result["id"], "no the mouth", "ERROR") else: mouth_param = {"id": message_result["mouth"]["id"], "status": message_result["mouth"]["status"]} BoxDao.update_mouth_status(mouth_param) box_post_message(message_result["id"], "update successful", "SUCCESS") except Exception as e: logger.warn(("update_mouth_status ERROR!!", e)) box_post_message(message_result["id"], "update_mouth_status ERROR:", "ERROR")
def get_box(): order_no = Configurator.get_value("ClientInfo", "OrderNo") param = {"orderNo": order_no, "deleteFlag": 0} box_list = BoxDao.get_box_by_order_no(param) if len(box_list) != 1: return False return box_list[0]
def get_free_mouth_by_enable(): mouth_param = {"deleteFlag": 0, "status": "ENABLE"} mouth_list = BoxDao.get_free_mouth_by_type_enable(mouth_param) if len(mouth_list) == 0: return False return mouth_list[0]
def update_box(message_result): logger.info(("init_box_info:", message_result)) try: box_param = {'id': message_result['box']['id'], 'name': message_result['box']['name'], 'orderNo': message_result['box']['orderNo'], 'validateType': message_result['box']['validateType'], 'currencyUnit': message_result['box']['currencyUnit'], "overdueType": message_result['box']['overdueType'], "freeHours": ClientTools.get_value("freeHours", message_result['box']), "freeDays": ClientTools.get_value("freeDays", message_result['box']), "holidayType": ClientTools.get_value("holidayType", message_result['box'])} BoxDao.update_box(box_param) box_post_message(message_result["id"], "update successful", "SUCCESS") except Exception as e: logger.warn(("update_box ERROR :", e)) box_post_message(message_result["id"], "update error", "ERROR")
def delete_holiday(message_result): logger.info(("update_holiday : ", message_result)) try: count = 0 for _holiday in message_result['box']['holidays']: databases_holiday = BoxDao.get_holiday_by_id({'id': _holiday['id']}) if len(databases_holiday) == 0: count += 1 else: BoxDao.delete_holiday({'id': _holiday['id']}) if count == len(message_result['box']['holidays']): box_post_message(message_result["id"], "all not find", "ERROR") elif count == 0: box_post_message(message_result["id"], "delete_holiday SUCCESS", "SUCCESS") else: box_post_message(message_result["id"], "same not find " + count, "ERROR") except Exception as e: logger.warn(("delete_holiday ERROR!!", e)) box_post_message(message_result["id"], "except error", "ERROR")
def get_mouth_status(): result = "" for name in ["MINI", "L", "M", "S"]: param = {"status": "ENABLE", "name": name, "deleteFlag": 0} free_mouth_count = BoxDao.get_free_mouth_count_by_mouth_type_name(param)[0] if free_mouth_count["count"] > 0: result += "T" else: result += "F" box_signal_handler.mouth_status_signal.emit(result)
def update_holiday(message_result): try: logger.info(("update_holiday : ", message_result)) for _holiday in message_result['box']['holidays']: databases_holiday = BoxDao.get_holiday_by_id({'id': _holiday['id']}) if len(databases_holiday) != 0: holiday_param = {'id': _holiday['id'], 'startTime': _holiday['startTime'], 'endTime': _holiday['endTime'], 'delayDay': _holiday['delayDays'], 'holidayType': _holiday['holidayType']} BoxDao.update_holiday(holiday_param) else: holiday_param = {'id': _holiday['id'], 'startTime': _holiday['startTime'], 'endTime': _holiday['endTime'], 'delayDay': _holiday['delayDays'], 'holidayType': _holiday['holidayType']} BoxDao.init_holiday(holiday_param) box_post_message(message_result["id"], "update SUCCESS", "SUCCESS") except Exception as e: logger.warn(("update_holiday ERROR!!", e)) box_post_message(message_result["id"], "except error", "ERROR")
def pull_open_mouth(message_result): global last_pull_open_mouth_id, last_pull_mouth_number if message_result["mouth"]["id"] is None: box_post_message(message_result["id"], "mouth_id is None", "ERROR") return else: logger.info(("Server_pull open mouth id :", message_result["mouth"]["id"])) last_pull_open_mouth_id = message_result["mouth"]["id"] mouth_list = BoxDao.get_mouth_by_id({"id": message_result["mouth"]["id"]}) if len(mouth_list) != 1: box_post_message(message_result["id"], "mouth list error!", "ERROR") return _mouth = mouth_list[0] cabinet_list = BoxDao.get_cabinet_by_id({"id": _mouth["cabinet_id"]}) if len(cabinet_list) != 1: box_post_message(message_result["id"], "cabinet list error!", "ERROR") return cabinet = cabinet_list[0] last_pull_mouth_number = _mouth["number"] result = LockMachine.open_door(int(cabinet["number"]), int(_mouth["numberInCabinet"])) if result is True: box_post_message(message_result["id"], "the mouth opened!", "SUCCESS") else: box_post_message(message_result["id"], "the mouth not opened!", "ERROR")
def load_manager_mouth_count(): count_list = BoxDao.get_all_mouth_count({"deleteFlag": 0}) logger.debug(("load_manager_mouth_count : ", len(count_list))) box_signal_handler.manager_mouth_count_signal.emit(count_list[0]["count"])
def get_mouth(express__: object) -> object: return BoxDao.get_mouth(express__)
def mark_box_sync_success(): return BoxDao.mark_box_sync_success({"deleteFlag": 0})
def mark_sync_success(mouth_info): return BoxDao.mark_sync_success(mouth_info)
def get_scan_not_sync_mouth_list(): return BoxDao.get_not_sync_mouth_list({"syncFlag": 0})
def free_mouth(mouth__): BoxDao.free_mouth(mouth__)
def use_mouth(mouth_param__): BoxDao.use_mouth(mouth_param__)
def manager_open_all_mouth(): mouth_list = BoxDao.get_all_mouth({'deleteFlag': 0}) for _mouth in mouth_list: manager_open_mouth(_mouth["id"]) box_signal_handler.manager_open_all_mouth_signal.emit("Success")
def parsing_message(push_message_list): if len(push_message_list) == 0: return for message_result in push_message_list: if message_result["pushMessageType"] == "BOX_START_TIME_CHANGE": if not box.service.BoxService.update_free_time( message_result["value"]): continue message_result["value"] = message_result["value"]["id"] HttpClient.post_message("box/finish", message_result) if message_result["pushMessageType"] == "MOUTH_STATUS_CHANGE": BoxDao.update_mouth_status(message_result["value"]) message_result["value"] = message_result["value"]["id"] HttpClient.post_message("box/finish", message_result) if message_result["pushMessageType"] == "INIT_CLIENT": box.service.BoxService.start_init_client() message_result["value"] = message_result["value"]["id"] HttpClient.post_message("box/finish", message_result) if message_result["pushMessageType"] == "STORE_EXPRESS": express.service.ExpressService.start_service_pull_store_express( message_result["value"], message_result["timestamp"]) message_result["value"] = message_result["value"]["id"] HttpClient.post_message("box/finish", message_result) if message_result["pushMessageType"] == "ASYNC_TASK": timeout = ClientTools.get_value("timeout", message_result["value"]) if timeout is not None and timeout < ClientTools.now(): result = { "id": message_result["value"]["id"], "result": "TimeOut", "statusType": "ERROR" } HttpClient.post_message("task/finish", result) continue if message_result["value"]["taskType"] == "RESET_EXPRESS": express.service.ExpressService.start_reset_express( message_result["value"]) if message_result["value"]["taskType"] == "REMOTE_UNLOCK": box.service.BoxService.pull_open_mouth(message_result["value"]) if message_result["value"]["taskType"] == "UPDATE_BOX": box.service.BoxService.start_update_box( message_result["value"]) if message_result["value"]["taskType"] == "MOUTH_STATUS_CHANGE": box.service.BoxService.start_update_mouth_status( message_result["value"]) if message_result["value"]["taskType"] == "UPDATE_ADVERT": download.service.DownloadService.pre_download_source( message_result["value"]) if message_result["value"]["taskType"] == "DELETE_ADVERT": download.service.DownloadService.start_delete_source( message_result["value"]) if message_result["value"]["taskType"] == "UPDATE_HOLIDAY": box.service.BoxService.start_update_holiday( message_result["value"]) if message_result["value"]["taskType"] == "DELETE_HOLIDAY": box.service.BoxService.start_delete_holiday( message_result["value"]) if message_result["value"]["taskType"] == "INIT_BOX": sync.PushMessage.init_client_task = True sync.PushMessage.init_task_id = message_result["value"]["id"] reset_express_result = { "id": message_result["value"]["id"], "result": "init finish", "statusType": "SUCCESS" } HttpClient.post_message("task/finish", reset_express_result) if message_result["value"]["taskType"] == "UPGRADE_BOX": download.service.DownloadService.pre_download_source( message_result["value"])
def manager_load_mouth_list(page): __user = user.service.UserService.get_user() get_mouth_param = {"deleteFlag": 0, "startLine": (int(page) - 1) * 25} if __user['role'] == "OPERATOR_USER" or __user['role'] == "OPERATOR_ADMIN": mouth_list_ = BoxDao.get_mouth_list(get_mouth_param) box_signal_handler.mouth_list_signal.emit(json.dumps(mouth_list_))