class Graph(Common): """Class for Graph""" # INITIALIZE def __init__(self): """The Constructor for Graph class""" self.postgres = PostgreSQL() self._couch_db = CouchDatabase() self.couch_query = Queries() super(Graph, self).__init__() def graph(self): """ This API is for Getting Graph --- tags: - Graph produces: - application/json parameters: - name: token in: header description: Token required: true type: string - name: userid in: header description: User ID required: true type: string - name: vessel_id in: query description: Vessel ID required: true type: string - name: device_id in: query description: Device ID required: true type: string - name: hours in: query description: Hours required: false type: integer - name: keys in: query description: Keys required: true type: string - name: combine in: query description: combine required: true type: boolean - name: start_time in: query description: Epoch start required: false type: string - name: end_time in: query description: Epoch end required: false type: string responses: 500: description: Error 200: description: Vessel Device Info """ data = {} # VESSEL ID vessel_id = request.args.get('vessel_id') device_id = request.args.get('device_id') keys = request.args.get('keys') combine = request.args.get('combine') hours = request.args.get('hours') start_time = request.args.get('start_time') end_time = request.args.get('end_time') # GET DATA token = request.headers.get('token') userid = request.headers.get('userid') # CHECK TOKEN token_validation = self.validate_token(token, userid) if not token_validation: data["alert"] = "Invalid Token" data['status'] = 'Failed' # RETURN ALERT return self.return_data(data) if not vessel_id: data["alert"] = "Please complete parameters!" data['status'] = 'Failed' # RETURN ALERT return self.return_data(data) if device_id in ['COREVALUES', 'FAILOVER', 'NTWPERF1']: all_devices = self.couch_query.get_all_devices(vessel_id) for dev in all_devices: if dev['doc']['device'] == device_id: device = dev['doc'] break else: device = self.couch_query.get_by_id(device_id) # hours_ago_epoch_ts = int(hours_ago.timestamp()) # current_time = int(ctime.timestamp()) if not start_time and not end_time: ctime = datetime.datetime.now() hours_ago = ctime - datetime.timedelta(hours=int(hours)) start_time = int(hours_ago.timestamp()) end_time = int(ctime.timestamp()) values = self.couch_query.get_complete_values( vessel_id, device['device'], str(start_time), str(end_time), 'all' ) # temp_available_options = [] # str_available_options = [] # available_options = [] opt = [] parameters = self.couch_query.get_complete_values( vessel_id, "PARAMETERS" ) if device['device'] == "COREVALUES": device_type = "COREVALUES" elif device['device'] == "NTWPERF1": device_type = "NTWPERF1" elif device['device'] == 'FAILOVER': device_type = 'FAILOVER' else: device_type = parameters['PARAMETERS'][device['device']]['TYPE'] if combine.upper() == 'TRUE': final_data = [] for value in values: timestamp = float(value['timestamp']) dev_value = value['value'][device['device']] # if re.findall(r'VDR\d', device['device']): # print("ALP ", dev_value) # pass if re.findall(r'NMEA\d', device['device']): nmea_data = self.get_nmea_data(dev_value) opt = list(set(self.get_graph_options(nmea_data))) options = self.get_device_options(nmea_data) if keys: final_data.append(self.set_values(options, keys, timestamp)) else: opt = list(set(self.get_graph_options(dev_value))) options = self.get_device_options(dev_value) if keys: final_data.append(self.set_values(options, keys, timestamp)) final_data = sorted(final_data, key=lambda i: i['name']) for fdata in final_data: fdata['name'] = time.strftime('%d/%m/%Y %H:%M:%S', time.localtime( float(fdata['name']))) data['data'] = final_data data['statistics'] = self.get_stat(final_data, flag=True) else: # FINAL DATA fnl_data = {} # SET DYNAMIC VARIABLE if keys: for key in keys.split(","): fnl_data[key] = [] for value in values: timestamp = float(value['timestamp']) dev_value = value['value'][device['device']] # if re.findall(r'VDR\d', device['device']): # print("ALP ", dev_value) # pass if re.findall(r'NMEA\d', device['device']): nmea_data = self.get_nmea_data(dev_value) opt = list(set(self.get_graph_options(nmea_data))) options = self.get_device_options(nmea_data) for key in keys.split(","): fnl_data[key].append(self.set_values(options, key, timestamp)) else: opt = list(set(self.get_graph_options(dev_value))) options = self.get_device_options(dev_value) for key in keys.split(","): fnl_data[key].append(self.set_values(options, key, timestamp)) for key in keys.split(","): fnl_data[key] = sorted(fnl_data[key], key=lambda i: i['name']) for fdata in fnl_data[key]: fdata['name'] = time.strftime('%d/%m/%Y %H:%M:%S', time.localtime(float( fdata['name']))) data['data'] = fnl_data data['statistics'] = self.get_stat(fnl_data, flag=False) # SET SQL QUERY sql_str = "SELECT * FROM selected_label" sql_str += " WHERE device_type='{0}' and select_type != 'combine'".format(device_type) default_selected = self.postgres.query_fetch_all(sql_str) # SET SQL QUERY sql_str = "SELECT * FROM selected_label" sql_str += " WHERE device_type='{0}' and select_type = 'combine'".format(device_type) default_selected_combine = self.postgres.query_fetch_all(sql_str) data['default_selected_combine'] = self.set_select_values(default_selected_combine) data['default_selected'] = self.set_select_values(default_selected) data['available_options'] = self.format_filter(opt) data['status'] = 'ok' return self.return_data(data) def set_values(self, options, keys, timestamp): """Set Values""" temp_data = {} for key in keys.split(","): if key in options.keys(): if key in ['AntennaStatus', 'TxMode']: if options[key].upper() in ['TRACKING', 'ON']: temp_data[key] = 1 else: temp_data[key] = 0 elif key == 'error': if options[key] is True: temp_data[key] = 1 else: temp_data[key] = 0 else: temp_data[key] = options[key] else: temp_data[key] = None temp_data['name'] = timestamp return temp_data def get_available_options(self, options, temp_available_options, str_available_options): """Return Available Options""" # print("Options --------------------------- >>") # print(options) # print("Options --------------------------- >>") available_options = [] for opt in options.keys(): if opt not in temp_available_options and opt not in str_available_options: if not options[opt]: continue if type(options[opt]) == 'str': if options[opt].isdigit(): options[opt] = float(options[opt]) if self.isfloat(options[opt]) or self.isint(options[opt]) or opt in [ 'AntennaStatus', 'TxMode']: temp_available_options.append(opt) temp = {} temp['value'] = opt temp['label'] = opt available_options.append(temp) # else: # str_available_options.append(op) return available_options def get_nmea_data(self, datas): """ Return NMEA Data """ temp_data = {} # keys = [data for data in datas.keys()] # No need for key in list(datas.keys()): temp_data.update(datas[key]) return temp_data def get_graph_options(self, datas): """Return Options for Graph""" options = [] # modules = [data for data in datas] # No need for mod in list(datas): options += self.get_opt_available(datas[mod]) return options def get_opt_available(self, options): """Return Available Options""" available_options = [] for opt in options.keys(): if not options[opt]: continue if type(options[opt]) == 'str': if options[opt].isdigit(): options[opt] = float(options[opt]) if self.isfloat(options[opt]) or self.isint(options[opt]) or opt in [ 'AntennaStatus', 'TxMode']: available_options.append(opt) return available_options def get_device_options(self, datas): """ Return All Device Options Data """ tmp = [] temp = {} # modules = [data for data in datas] # No need for mod in list(datas): tmp.append(datas[mod]) for dta in tmp: temp.update(dta) return temp def set_select_values(self, datas): """Set Select Values""" final_data = [] for data in datas: temp = {} temp['value'] = data['label'] temp['label'] = data['label'] final_data.append(temp) return final_data def get_stat(self, datas, flag): """ Return Min and Max """ temp = {} tmp = [] if datas: if flag is True: temp_data = {} for data in datas[0].keys(): if data != "name": temp_data[data] = tuple(dta[data] for dta in datas) # keys = [data for data in temp_data.keys()] # for key in keys: # if all(res is None for res in temp_data[key]): # pass # else: # data = self.get_stat_range(temp_data, key) # temp.update({ # key : data # }) for dta in temp_data.values(): tmp += dta if tmp: tmp = [dta for dta in tmp if dta is not None] tmp = sorted(tmp, key=float) data = self.get_stat_range(tmp) temp.update({ "combine" : data }) else: # keys = [data for data in datas.keys()] for key in list(datas.keys()): result = [data[key] for data in datas[key] if data[key] is not None] result = sorted(result, key=float) # if all(res is None for res in result): # pass # else: if result: data = self.get_stat_range(result) temp.update({ key : data }) return temp def get_stat_range(self, data): """ Return Stat Range """ tmp = {} tmp['min'] = data[0] tmp['max'] = data[-1] # tmp['min'] = min(data) # tmp['max'] = max(data) return tmp
class CalculateAlarmValue(Common): """Class for CalculateAlarmValue""" # INITIALIZE def __init__(self): """The Constructor for CalculateAlarmValue class""" self.postgres = PostgreSQL() self.couch_query = Queries() super(CalculateAlarmValue, self).__init__() def calculate_value(self, alarm_value_id, start, end, vessel_id=None, device_id=None): """Calculate Alarm Value""" if alarm_value_id: results = [] alarm_value = self.get_alarm_value(alarm_value_id) if alarm_value: vessels = alarm_value['vessel'] devices = alarm_value['device'] device_types = alarm_value['device_type'] modules = alarm_value['module'] options = alarm_value['option'] #VALIDATE VESSEL IF EXISTS IN ALARM VALUE if vessel_id: vessel = self.validate_alarm_vessel(vessels, vessel_id) if vessel: vessel_list = [vessel] else: #RETURN NO DATA TO SHOW return 0 else: vessel_list = self.get_all_vessels(vessels, options) #GET DATA for vessel in vessel_list: #VALIDATE DEVICE IF EXISTS IN ALARM VALUE if device_id: device = self.validate_alarm_device( vessel, devices, device_id) if device: device_list = [device] else: return 0 else: device_list = self.find_device_by_type( vessel, devices, device_types) #GET COREVALUES AND PREVIOUS COREVALUES DATA corevalues = self.couch_query.get_coredata( vessel, start, end) prev_core = self.get_previous_coremarks(vessel, start) for device in device_list: modlist = self.find_alarm_data(vessel, modules, key="module") optlist = self.find_alarm_data(vessel, options, key="option") # GET DATA ON COUCHDB BY VESSEL AND DEVICE datas = self.get_vessel_data(vessel, device, start, end) if datas: mod_data = self.get_mod_data( device, modlist, datas) opt_data = self.get_option_data( device, mod_data, optlist, datas) results += self.set_opt_values( opt_data, vessel, corevalues, prev_core, device) else: mod_option = self.get_mod_opt( vessel, device, corevalues, prev_core, modlist, optlist) results += mod_option return results return 0 def get_previous_coremarks(self, vessel, end): """Get Previous Corevalues Remarks""" data = {} corevalues = self.couch_query.get_coredata(vessel, 0, end, flag="limit") if corevalues: data['timestamp'] = corevalues[0] data['remarks'] = "Unknown" else: data['timestamp'] = "" data['remarks'] = "No Data" return data def find_alarm_data(self, vessel, datas, key): """Find Alarm Values Data""" temp_data = [] if datas: #CHECK INPUTS IF EXIST IN VESSEL for data in datas.split(","): check_data = self.check_data_by_vessel(key, vessel, data) if check_data: for cdata in check_data: temp_data.append(cdata[key]) else: #GET ALL DEVICES IF NO VESSELS datas = self.check_data_by_vessel(key, vessel) for data in datas: temp_data.append(data[key]) return temp_data # GET ALARM VALUE def get_alarm_value(self, alarm_value_id): """Get Alarm Value""" assert alarm_value_id, "Alarm value ID is required." # DATA sql_str = "SELECT * FROM alarm_value" sql_str += " WHERE alarm_value_id={0}".format(alarm_value_id) alarm_value = self.postgres.query_fetch_one(sql_str) if alarm_value: return alarm_value return 0 def get_all_vessels(self, vessels, options): """Get All Vessels""" vessel_list = [] if vessels: tmp_vessel = [] for vessel in vessels.split(","): tmp_vessel.append(vessel) vessel_ids = ','.join(["'{}'".format(tmp) for tmp in tmp_vessel]) sql_str = "SELECT vessel_id FROM vessel" sql_str += " WHERE vessel_id IN ({0})".format(vessel_ids) datas = self.postgres.query_fetch_all(sql_str) vessel_list = [data['vessel_id'] for data in datas] else: #OPTION IS REQUIRED ON ALARM VALUE vessel_list = self.get_vessels_by_option(options) return vessel_list def get_vessels_by_option(self, options): """Get Vessels By Option""" datas = "" if options: tmp_opt = [] for option in options.split(","): tmp_opt.append(option) opt = ','.join(["'{}'".format(tmp) for tmp in tmp_opt]) # OPTION DATA sql_str = "SELECT DISTINCT vessel_id FROM option" sql_str += " WHERE option IN ({0})".format(opt) datas = self.postgres.query_fetch_all(sql_str) if datas: vessel_list = [data['vessel_id'] for data in datas] else: vessel_list = self.vessel_list() return vessel_list def vessel_list(self): """Get Vessel List""" sql_str = "SELECT vessel_id FROM vessel" datas = self.postgres.query_fetch_all(sql_str) if datas: vessel_list = [data['vessel_id'] for data in datas] return vessel_list def get_vessel_data(self, vessel, device, start_time, end_time): """Get Vessel Data""" if vessel: values = self.couch_query.get_complete_values( vessel, device, str(start_time), str(end_time), 'all') if values: return values return 0 # GET DATA DEVICE/MODULE/OPTION def check_data_by_vessel(self, key, vessel_id, value=None): """Check Alarm Data by Vessel""" if key == "device_type": table = "device" else: table = key # DATA sql_str = "SELECT DISTINCT {0} FROM {1}".format(key, table) sql_str += " WHERE vessel_id ='{0}'".format(vessel_id) if value: sql_str += " AND {0} ILIKE '{1}'".format(key, value.strip()) datas = self.postgres.query_fetch_all(sql_str) if datas: return datas return '' def get_mod_data(self, device, modules, datas): """Filter modules by vessel's alarm data""" temp_data = [] for module in modules: alarm_data = [ module for data in datas if module in data['value'][device] ] temp_data += alarm_data return set(temp_data) def get_option_data(self, device, modules, options, datas): """Get option by vessel's alarm data""" temp_data = [] results = [] for module in modules: for option in options: if option in datas[0]['value'][device][module]: message = "ok" for data in datas: temp_data.append({ "timestamp": data['timestamp'], "value": data['value'][device][module][option] }) else: message = "No option {0} found under module".format(option) results.append({ "device": device, "module": module, "option": option, "datas": temp_data, "message": message }) return results def get_mod_opt(self, vessel, device, core, prev_core, modules, options): """Get Module Option if no data found per vessel""" results = [] module = "No Module found" option = "No Option found" for module in modules: if options: # Miss Ly, May something dito. # for option in options: # option = option option = options[-1] results.append({ "vessel_id": vessel, "device": device, "device_id": self.get_device_id(vessel, device), "module": module, "option": option, "datas": [], "message": "No Data", "core": core, "previous": prev_core }) return results def find_device_by_type(self, vessel, devices, device_types): """Find Device""" check_device = self.find_alarm_data(vessel, devices, key="device") if device_types: device_list = [] devicetype_list = self.find_alarm_data(vessel, device_types, key="device_type") if devices: for device in check_device: try: device_index = devicetype_list.index(device) device_list.append(devicetype_list[device_index]) except: device_list.append(device) else: device_list = devicetype_list else: device_list = check_device return device_list def get_device_by_id(self, device_id): """Get Device by ID""" # DATA sql_str = "SELECT DISTINCT device FROM device" sql_str += " WHERE device_id = '{0}'".format(device_id) data = self.postgres.query_fetch_one(sql_str) if data: return data['device'] return '' def get_device_id(self, vessel_id, device): """Get Device ID""" # DATA sql_str = "SELECT DISTINCT device_id FROM device" sql_str += " WHERE device = '{0}'".format(device) sql_str += " AND vessel_id ='{0}'".format(vessel_id) data = self.postgres.query_fetch_one(sql_str) if data: return data['device_id'] return '' def validate_alarm_device(self, vessel, devices, device_id): """Validate Alarm Device""" #IF EMPTY DEVICES IT SELECTED ALL DEVICES device = self.get_device_by_id(device_id) device_list = self.find_alarm_data(vessel, devices, key="device") if device in device_list: return device return 0 def validate_alarm_vessel(self, vessels, vessel_id): """Validate Alarm Vessel""" #IF EMPTY VESSELS IT SELECTED ALL VESSELS if vessels: vessel_list = [] for vessel in vessels.split(","): vessel_list.append(vessel) if vessel_id in vessel_list: return vessel_id return 0 return vessel_id def set_opt_values(self, datas, vessel, corevalues, prev_core, device): """ Set Option values """ res = [] for option in datas: option['vessel_id'] = vessel option['core'] = corevalues option['previous'] = prev_core option['device_id'] = self.get_device_id(vessel, device) res.append(option) return res
class Invite(Common, ShaSecurity): """Class for Invite""" # INITIALIZE def __init__(self): """The Constructor for Invite class""" # INIT CONFIG self.config = ConfigParser() # CONFIG FILE self.config.read("config/config.cfg") self._couch_db = CouchDatabase() self.couch_query = Queries() self.postgres = PostgreSQL() self.epoch_default = 26763 self.vpn_db_build = config_section_parser(self.config, "VPNDB")['build'] super(Invite, self).__init__() if self.vpn_db_build.upper() == 'TRUE': self.my_ip = config_section_parser(self.config, "IPS")['my'] self.my_protocol = config_section_parser(self.config, "IPS")['my_protocol'] self.user_vpn = config_section_parser(self.config, "IPS")['user_vpn'] self.user_protocol = config_section_parser(self.config, "IPS")['user_protocol'] self.vessel_vpn = config_section_parser(self.config, "IPS")['vessel_vpn'] self.vessel_protocol = config_section_parser( self.config, "IPS")['vessel_protocol'] self.vpn_token = '269c2c3706886d94aeefd6e7f7130ab08346590533d4c5b24ccaea9baa5211ec' # GET VESSEL FUNCTION def invitation(self): """ This API is for Sending invitation --- tags: - User produces: - application/json parameters: - name: token in: header description: Token required: true type: string - name: userid in: header description: User ID required: true type: string - name: query in: body description: Invite required: true schema: id: Invite properties: first_name: type: string last_name: type: string middle_name: type: string url: type: string email: type: string companies: types: array example: [] roles: types: array example: [] vessels: types: array example: [] responses: 500: description: Error 200: description: Sending invitaion """ # INIT DATA data = {} # GET DATA token = request.headers.get('token') userid = request.headers.get('userid') # GET JSON REQUEST query_json = request.get_json(force=True) # GET REQUEST PARAMS email = query_json["email"] url = query_json["url"] vessels = query_json['vessels'] # CHECK TOKEN token_validation = self.validate_token(token, userid) if not token_validation: data["alert"] = "Invalid Token" data['status'] = 'Failed' # RETURN ALERT return self.return_data(data) # INIT IMPORTANT KEYS important_keys = {} important_keys['companies'] = [] important_keys['roles'] = [] important_keys['email'] = "string" important_keys['url'] = "string" # CHECK IMPORTANT KEYS IN REQUEST JSON if not self.check_request_json(query_json, important_keys): data["alert"] = "Invalid query, Missing parameter!" data['status'] = 'Failed' # RETURN ALERT return self.return_data(data) # CHECK INVITATION if self.check_invitaion(email): data["alert"] = "Already invited!" data['status'] = 'Failed' # RETURN ALERT return self.return_data(data) password = self.generate_password() # INSERT INVITATION account_id = self.insert_invitation(password, query_json) if not account_id: data = {} data['message'] = "Invalid email!" data['status'] = "Failed" return self.return_data(data) if self.vpn_db_build.upper() == 'TRUE': # FOR USER VPN # JOB DATAS callback_url = self.my_protocol + "://" + self.my_ip + "/vpn/update" data_url = self.my_protocol + "://" + self.my_ip + "/vpn/data" sql_str = "SELECT * FROM account_role where account_id='{0}' ".format( account_id) sql_str += "AND role_id in (SELECT role_id FROM role " sql_str += "WHERE role_name='super admin')" super_admin = self.postgres.query_fetch_one(sql_str) vpn_type = 'VCLIENT' cvpn_type = 'CLIENT' if super_admin: vpn_type = 'VRH' cvpn_type = 'RHADMIN' # INSERT JOB job_id = self.insert_job(callback_url, data_url, self.vpn_token, account_id, self.user_vpn, cvpn_type) # INIT PARAMS FOR CREATE VPN vpn_params = {} vpn_params['callback_url'] = callback_url vpn_params['data_url'] = data_url vpn_params['job_id'] = job_id # CREATE VPN self.create_vpn(vpn_params, self.vpn_token) # FOR VESSEL VPN if vessels or super_admin: allow_access = False for vessel in vessels: if vessel['allow_access']: allow_access = True break if allow_access or super_admin: # INSERT JOB job_id = self.insert_job(callback_url, data_url, self.vpn_token, account_id, self.vessel_vpn, vpn_type) # INIT PARAMS FOR CREATE VPN vpn_params = {} vpn_params['callback_url'] = callback_url vpn_params['data_url'] = data_url vpn_params['job_id'] = job_id # CREATE VPN self.create_vpn(vpn_params, self.vpn_token, True) # SEND INVITATION self.send_invitation(email, password, url) data = {} data['message'] = "Invitation successfully sent!" data['status'] = "ok" return self.return_data(data) def check_invitaion(self, email): """Check Invitation""" sql_str = "SELECT * FROM account WHERE " sql_str += " email = '" + email + "'" res = self.postgres.query_fetch_one(sql_str) if res: return res return 0 def check_username(self, username): """Check Invitation""" sql_str = "SELECT * FROM account WHERE " sql_str += " username = '******'" res = self.postgres.query_fetch_one(sql_str) if res: return res return 0 def insert_invitation(self, password, query_json): """Insert Invitation""" token = self.generate_token() vessels = query_json['vessels'] companies = query_json['companies'] roles = query_json['roles'] data = query_json data = self.remove_key(data, "companies") data = self.remove_key(data, "roles") data = self.remove_key(data, "vessels") # username = query_json["email"].split("@")[0] username = "******".format(int(time.time())) if not self.check_username(username): username += self.random_str_generator(5) data['username'] = username data['token'] = token data['status'] = True data['state'] = False data['password'] = self.string_to_sha_plus(password) data['created_on'] = time.time() account_id = self.postgres.insert('account', data, 'id') if not account_id: return 0 for vessel in vessels: ntwconf = self.couch_query.get_complete_values( vessel['vessel_id'], "NTWCONF") # ACCOUNT VESSEL temp = {} temp['vessel_vpn_ip'] = ntwconf['NTWCONF']['tun1']['IP'] temp['account_id'] = account_id temp['vessel_id'] = vessel['vessel_id'] temp['vessel_vpn_state'] = 'pending' temp['allow_access'] = False if 'allow_access' in vessel.keys(): temp['allow_access'] = vessel['allow_access'] self.postgres.insert('account_vessel', temp) for company in companies: # ACCOUNT COMPANY temp = {} temp['account_id'] = account_id temp['company_id'] = company self.postgres.insert('account_company', temp) for role_id in roles: # ACCOUNT COMPANY temp = {} temp['account_id'] = account_id temp['role_id'] = role_id self.postgres.insert('account_role', temp) return account_id def send_invitation(self, email, password, url): """Send Invitation""" email_temp = Invitation() emailer = Email() message = email_temp.invitation_temp(password, url) subject = "Invitation" emailer.send_email(email, message, subject) return 1 def generate_password(self): """Generate Password""" char = string.ascii_uppercase char += string.ascii_lowercase char += string.digits return self.random_str_generator(8, char) def insert_job(self, callback_url, data_url, vpn_token, account_id, user_vpn, vpn_type): """Insert Job""" update_on = time.time() # INIT NEW JOB temp = {} temp['callback_url'] = callback_url temp['vnp_server_ip'] = user_vpn temp['data_url'] = data_url temp['token'] = vpn_token temp['status'] = 'pending' temp['account_id'] = account_id temp['vpn_type'] = vpn_type temp['action'] = 'CREATE' temp['account_os'] = 'WINDOWS' # LINUX temp['update_on'] = update_on temp['created_on'] = update_on # INSERT NEW JOB job_id = self.postgres.insert('job', temp, 'job_id') return job_id def create_vpn(self, data, vpn_token, flag=False): """Create VPN""" api_endpoint = self.user_protocol + "://" + self.user_vpn + "/ovpn" if flag: api_endpoint = self.vessel_protocol + "://" + self.vessel_vpn + "/ovpn" headers = {'content-type': 'application/json', 'token': vpn_token} req = requests.post(api_endpoint, data=json.dumps(data), headers=headers) res = req.json() return res
class UpdateVesselState(Common): """Class for UpdateVesselState""" # INITIALIZE def __init__(self): """The Constructor for UpdateVesselState class""" self._couch_db = CouchDatabase() self.couch_query = Queries() self.postgres = PostgreSQL() super(UpdateVesselState, self).__init__() def update_vessel_state(self): """Update Vessel State""" vessels = self.couch_query.get_vessels() # JUST TO INDEX # self.couch_query.get_system1() vessel_ids = [x['id'] for x in vessels] # DON'T DELETE FOR SYSTEM INDEXING for vssl_id in vessel_ids: self.couch_query.get_system(vssl_id) # INIT SQL QUERY sql_str = "SELECT * FROM vessel" # FETCH ALL rows = self.postgres.query_fetch_all(sql_str) db_vessel_ids = [x['vessel_id'] for x in rows] vessel_ids = set(vessel_ids) db_vessel_ids = set(db_vessel_ids) vessel_ids.difference_update(db_vessel_ids) if vessel_ids: for vessel_id in vessel_ids: doc = self.couch_query.get_by_id(vessel_id) sql_str = "SELECT * FROM vessel WHERE " sql_str += "number='{0}'".format(doc['number']) vssl_nmbr = self.postgres.query_fetch_one(sql_str) if vssl_nmbr: if vssl_nmbr['vessel_id'] and vssl_nmbr['number']: # INIT CONDITION conditions = [] # CONDITION FOR QUERY conditions.append({ "col": "vessel_id", "con": "=", "val": vssl_nmbr['vessel_id'] }) data = {} data['vessel_id'] = vessel_id self.postgres.update('vessel', data, conditions) else: print("SAME VESSEL NUMBER: {0}!!!".format( vssl_nmbr['number'])) else: data = {} data['number'] = doc['number'] data['vessel_name'] = self.get_vessel_name(vessel_id) data['vessel_id'] = vessel_id data['update_on'] = time.time() data['created_on'] = time.time() self.postgres.insert('vessel', data) sql_str = "SELECT * FROM vessel WHERE number IS NULL OR vessel_name IS NULL" null_vessels = self.postgres.query_fetch_all(sql_str) for vssl in null_vessels: # INIT CONDITION conditions = [] # CONDITION FOR QUERY conditions.append({ "col": "vessel_id", "con": "=", "val": vssl['vessel_id'] }) doc = self.couch_query.get_by_id(vssl['vessel_id']) if 'error' in doc.keys(): number = vssl['vessel_id'] else: number = doc['number'] data = {} data['number'] = number data['vessel_name'] = self.get_vessel_name(vssl['vessel_id']) self.postgres.update('vessel', data, conditions) # RETURN return rows def get_vessel_name(self, vessel_id): """ Return Vessel Name """ assert vessel_id, "Vessel ID is required." # GET VESSEL NAME values = self.couch_query.get_complete_values(vessel_id, "PARAMETERS") if values: vessel_name = values['PARAMETERS']['INFO']['VESSELNAME'] else: vessel_name = "" return vessel_name
class AlarmValueData(Common): """Class for AlarmValueData""" # INITIALIZE def __init__(self): """The Constructor for AlarmValueData class""" self.postgres = PostgreSQL() self.couch_query = Queries() self.device_state = UpdateDeviceState() super(AlarmValueData, self).__init__() def alarm_value_data(self): """ This API is for Getting Alarm Value --- tags: - Alarm Values produces: - application/json parameters: - name: token in: header description: Token required: true type: string - name: userid in: header description: User ID required: true type: string responses: 500: description: Error 200: description: Alarm Value """ data = {} # GET DATA token = request.headers.get('token') userid = request.headers.get('userid') # CHECK TOKEN token_validation = self.validate_token(token, userid) if not token_validation: data['alert'] = "Invalid Token" data['status'] = 'Failed' # RETURN ALERT return self.return_data(data) data['data'] = [] vessels = self.get_all_vessels() keys = ['device', 'device_type', 'module', 'option'] datas = [] for key in keys: alarm_data = self.get_alarm_datas(key) format_data = self.data_filter(alarm_data, key) if key == "device": devices = format_data if key == "device_type": device_types = format_data if key == "module": modules = format_data if key == "option": options = format_data if datas: rows = datas else: rows = [] datas = rows data['vessels'] = vessels data['devices'] = devices data['modules'] = modules data['options'] = options data['device_types'] = device_types data['status'] = 'ok' return self.return_data(data) def get_alarm_datas(self, key): """Get Alarm Datas""" if key: if key == "device_type": table = "device" else: table = key # DATA sql_str = "SELECT DISTINCT {0} FROM {1}".format(key, table) datas = self.postgres.query_fetch_all(sql_str) data = {} k = "{0}s".format(key) temp_data = [temp_data[key] for temp_data in datas] data[k] = temp_data return data def get_all_vessels(self): """Get All Vessels""" vessel_list = [] vessels = self.couch_query.get_vessels() if vessels: for item in vessels: vessel_name = self.couch_query.get_complete_values( item['id'], "PARAMETERS") if vessel_name: vessel_name = vessel_name['PARAMETERS']['INFO'][ 'VESSELNAME'] else: vessel_name = "Vessel Not Found" vessel_list.append({"label": vessel_name, "value": item['id']}) return vessel_list return ''
class ValidateAlarmValue(Common): """Class for ValidateAlarmValue""" # INITIALIZE def __init__(self): """The Constructor for ValidateAlarmValue class""" self.postgres = PostgreSQL() self.couch_query = Queries() super(ValidateAlarmValue, self).__init__() # VALIDATE INPUTS def validate_alarm_value(self, query_json): """Validate Alarm Value""" data = {} if not query_json['name']: data["alert"] = "Name cannot be empty!" return data if not query_json['option']: data["alert"] = "Option cannot be empty!" return data if query_json['vessel']: for vessel in query_json['vessel'].split(","): values = self.couch_query.get_complete_values( vessel, "PARAMETERS") if values: vessel_name = values['PARAMETERS']['INFO']['VESSELNAME'] else: data["alert"] = "No Vessel found." return data if query_json['device']: column = "device" for device in query_json['device'].split(","): validate = self.check_alarm_data( column, device, vessel) if not validate: data[ "alert"] = "No Device found under {0}.".format( vessel_name) return data if query_json['module']: column = "module" for module in query_json['module'].split(","): validate = self.check_alarm_data( column, module, vessel) if not validate: data[ "alert"] = "No Module found under {0}.".format( vessel_name) return data if query_json['option']: column = "option" for option in query_json['option'].split(","): validate = self.check_alarm_data( column, option, vessel) if not validate: data[ "alert"] = "No Option found under {0}.".format( vessel_name) return data if query_json['device']: column = "device" for device in query_json['device'].split(","): validate = self.check_alarm_data(column, device) if not validate: data["alert"] = "No Device found." return data if query_json['device_type']: column = "device_type" for device_type in query_json['device_type'].split(","): validate = self.check_alarm_data(column, device_type) if not validate: data["alert"] = "No Device found." return data if query_json['module']: column = "module" for module in query_json['module'].split(","): validate = self.check_alarm_data(column, module) if not validate: data["alert"] = "No Module found." return data if query_json['option']: column = "option" for option in query_json['option'].split(","): validate = self.check_alarm_data(column, option) if not validate: data["alert"] = "No Option found" return data if query_json['device'] and query_json['device_type']: for device in query_json['device'].split(","): if device in [ 'COREVALUES', 'FAILOVER', 'PARAMETERS', 'NTWCONF' ]: data["alert"] = "No Device Type under {0}".format( query_json['device']) else: for device_type in query_json['device_type'].split(","): if not self.check_device_type(device, device_type): data['alert'] = "No Device Type found on Device" return data return 0 def check_alarm_data(self, column, value, vessel=None): """Validate Alarm Data""" if column == "device_type": table = "device" else: table = column # DATA sql_str = "SELECT * FROM {0}".format(table) sql_str += " WHERE {0} ILIKE '{1}'".format(column, value) if vessel: sql_str += " AND vessel_id ILIKE '{0}'".format(vessel) datas = self.postgres.query_fetch_all(sql_str) data = {} data['rows'] = datas if datas: return data return 0 def check_device_type(self, device, device_type): """Validate Device Type""" # DATA sql_str = "SELECT * FROM device" sql_str += " WHERE device ILIKE '{0}'".format(device) sql_str += " AND device_type ILIKE '{0}'".format(device_type) datas = self.postgres.query_fetch_all(sql_str) data = {} data['rows'] = datas if datas: return data return 0
class GeneralInfo(Common): """Class for GeneralInfo""" # INITIALIZE def __init__(self): """The Constructor for GeneralInfo class""" self._couch_db = CouchDatabase() self.couch_query = Queries() self.epoch_default = 26763 super(GeneralInfo, self).__init__() def general_info(self): """ This API is for getting general info of device --- tags: - Devices produces: - application/json parameters: - name: token in: header description: Token required: true type: string - name: userid in: header description: User ID required: true type: string - name: vessel_id in: query description: Vessel ID required: true type: string responses: 500: description: Error 200: description: Vessel Device List """ # INIT DATA data = {} # VESSEL ID vessel_id = request.args.get('vessel_id') # GET DATA token = request.headers.get('token') userid = request.headers.get('userid') # CHECK TOKEN token_validation = self.validate_token(token, userid) if not token_validation: data["alert"] = "Invalid Token" data['status'] = 'Failed' # RETURN ALERT return self.return_data(data) if not vessel_id: data["alert"] = "No Vessel ID" data['status'] = 'Failed' # RETURN ALERT return self.return_data(data) rows = [] heading = self.get_heading(vessel_id) if heading: row = {} row['option_name'] = 'Heading' row['value'] = "{0}°".format(float(heading['heading'])) row['data_provider'] = heading['heading_source'] rows.append(row) speed = self.get_speed(vessel_id) if speed: row = {} row['option_name'] = 'Speed' row['value'] = speed['speed'] row['data_provider'] = speed['speed_source'] rows.append(row) failover = self.couch_query.get_complete_values(vessel_id, "FAILOVER") if failover: row = {} row['option_name'] = 'Internet provider' row['value'] = failover['FAILOVER']['General']['Description'] row['data_provider'] = 'Failover' rows.append(row) parameters = self.couch_query.get_complete_values( vessel_id, "PARAMETERS") info = parameters['PARAMETERS']['INFO'] if info: row = {} row['option_name'] = 'IMO' row['value'] = info['IMO'] row['data_provider'] = 'PARAMETERS' rows.append(row) if info: row = {} row['option_name'] = 'MMSI' row['value'] = info['MMSI'] row['data_provider'] = 'PARAMETERS' rows.append(row) data['status'] = 'ok' data['rows'] = rows return self.return_data(data) def get_heading(self, vessel_id): """Return Heading""" all_devices = self.couch_query.get_all_devices(vessel_id) source = 'VSAT' devices = self.get_device(all_devices, source) data = {} for device in devices: values = self.couch_query.get_complete_values( vessel_id, device['device']) if values: # GET DEVICE NUMBER number = device['device'].split(source)[1] # GET DEVICE COMPLETE NAME heading_source = self.device_complete_name(source, number) # SET RETURN data['heading'] = values[ device['device']]['General']['Heading'] data['heading_source'] = heading_source # # RETURN # return data source = 'NMEA' devices = self.get_device(all_devices, source) for device in devices: values = self.couch_query.get_complete_values( vessel_id, device['device']) if values: # GET DEVICE NUMBER number = device['device'].split(source)[1] # GET DEVICE COMPLETE NAME heading_source = self.device_complete_name(source, number) gen = values[device['device']].keys() if 'GP0001' in gen: gp0001 = values[device['device']]['GP0001'] # SET RETURN if not data: data['heading'] = gp0001['VTG'][ 'courseOverGroundTrueDegrees'] data['heading_source'] = heading_source # RETURN return data def get_device(self, devices, pattern): """Return Device""" data = [] for device in devices: if re.findall(r'' + pattern + r'\d', device['doc']['device']): data.append(device['doc']) data = sorted(data, key=lambda i: i['device']) return data def get_speed(self, vessel_id): """Return Speed""" all_devices = self.couch_query.get_all_devices(vessel_id) source = 'NMEA' devices = self.get_device(all_devices, source) data = {} speed = None speed_source = "" for device in devices: values = self.couch_query.get_complete_values( vessel_id, device['device']) if values: # GET DEVICE NUMBER number = device['device'].split(source)[1] # GET DEVICE COMPLETE NAME heading_source = self.device_complete_name(source, number) gen = values[device['device']].keys() if 'GP0001' in gen: gp0001 = values[device['device']]['GP0001'] # SET RETURN if not data: data['heading'] = gp0001['VTG'][ 'courseOverGroundTrueDegrees'] data['heading_source'] = heading_source speed = float(gp0001['VTG']['speedOverGroundKnots']) speed_source = device['device'] data['speed'] = str(speed) + " knot(s)" data['speed_source'] = speed_source return data return 0
class UserCompany(Common): """Class for UserCompany""" # INITIALIZE def __init__(self): """The Constructor for UserCompany class""" self.postgresql_query = PostgreSQL() self._couch_db = CouchDatabase() self.couch_query = Queries() super(UserCompany, self).__init__() def user_company(self): """ This API is for Getting User Company --- tags: - User produces: - application/json parameters: - name: token in: header description: Token required: true type: string - name: userid in: header description: User ID required: true type: string - name: account_id in: query description: Account ID required: true type: integer responses: 500: description: Error 200: description: User Company """ data = {} # GET DATA token = request.headers.get('token') userid = request.headers.get('userid') account_id = int(request.args.get('account_id')) # CHECK TOKEN token_validation = self.validate_token(token, userid) if not token_validation: data["alert"] = "Invalid Token" data['status'] = 'Failed' # RETURN ALERT return self.return_data(data) # COMPANY DATA datas = self.get_companies(account_id) datas['status'] = 'ok' return self.return_data(datas) def get_companies(self, account_id): """Return Companies""" # DATA sql_str = "SELECT * FROM account_company WHERE account_id = " + str(account_id) res = self.postgresql_query.query_fetch_all(sql_str) rows = [] # COMPANY'S VESSELS-ID for company in res: company_id = company['company_id'] vessel_res = self.get_company_vessels(company_id) vessels = [] for vessel in vessel_res['rows']: temp = {} temp['vessel_id'] = vessel['vessel_id'] temp['vessel_name'] = self.get_vessel_name(vessel['vessel_id']) temp['allow_access'] = self.get_allow_access(account_id, vessel['vessel_id']) vessels.append(temp) company['vessels'] = vessels rows.append(company) data = {} data['rows'] = rows return data # GET VESSELS OF COMPANY def get_company_vessels(self, company_id): #, user=None): """Return Company Vessels""" assert company_id, "CompanyID is required." # DATA vessels = [] sql_str = "SELECT * FROM company_vessels WHERE company_id={0}".format(company_id) vessels = self.postgres.query_fetch_all(sql_str) data = {} data['rows'] = vessels return data # GET THE VESSEL NAME def get_vessel_name(self, vessel_id): """Return Vessel Name""" values = self.couch_query.get_complete_values( vessel_id, "PARAMETERS" ) if values: return values['PARAMETERS']['INFO']['VESSELNAME'] return '' def get_allow_access(self, account_id, vessel_id): """Return Allow access""" # DATA sql_str = "SELECT * FROM account_vessel" sql_str += " WHERE account_id={0} AND vessel_id='{1}'".format(account_id, vessel_id) vessel = self.postgres.query_fetch_one(sql_str) if vessel: return vessel['allow_access'] return False
class Blockages(Common): """Class for Blockages Library""" # INITIALIZE def __init__(self): """The Constructor for Blockage class""" self.postgres = PostgreSQL() self.couch_query = Queries() super(Blockages, self).__init__() def get_device_type(self, vessel_id, device_id): """Get Device Type""" assert device_id, "Device ID is required." # DATA sql_str = "SELECT * FROM device " sql_str += "WHERE vessel_id='{0}' ".format(vessel_id) sql_str += "AND device_id='{0}'".format(device_id) device = self.postgres.query_fetch_one(sql_str) return device def get_blockage_zones(self, device, device_type, data): """ Return Blockage Zones """ # GET NUMBER OF ZONES zone_number = self.get_zone_number(device_type) dlist = [tmp['timestamp'] for tmp in data] dlist.sort() timestamp = dlist[-1] blockzone = [] blocks = {} if zone_number and dlist: try: time_index = dlist.index(timestamp) az_start_val = None el_start_val = None az_end_val = None el_end_val = None bz_type_val = None bz_val = None for num in range(1, zone_number + 1): bzstatus = "bz{0}Status".format(num) az_start = "bz{0}AzStart".format(num) el_start = "bz{0}ElStart".format(num) az_end = "bz{0}AzEnd".format(num) el_end = "bz{0}ElEnd".format(num) bz_type = "bz{0}Type".format(num) blockzones = "Blockzone{0}".format(num) if bzstatus in data[time_index]['value'][device][ 'General']: bz_val = data[time_index]['value'][device]['General'][ bzstatus] if az_start in data[time_index]['value'][device][ 'General']: az_start_val = data[time_index]['value'][device][ 'General'][az_start] if el_start in data[time_index]['value'][device][ 'General']: el_start_val = data[time_index]['value'][device][ 'General'][el_start] if az_end in data[time_index]['value'][device]['General']: az_end_val = data[time_index]['value'][device][ 'General'][az_end] if el_end in data[time_index]['value'][device]['General']: el_end_val = data[time_index]['value'][device][ 'General'][el_end] if bz_type in data[time_index]['value'][device]['General']: bz_type_val = data[time_index]['value'][device][ 'General'][bz_type] if blockzones.lower() in data[time_index]['value'][device]: tmp_holder = data[time_index]['value'][device][ blockzones.lower()] if not bz_val: bz_val = tmp_holder['Status'] if not az_start_val: az_start_val = tmp_holder['AzStart'] if not el_start_val: az_end_val = tmp_holder['AzEnd'] if not el_end_val: el_end_val = tmp_holder['ElEnd'] bz_item = { bzstatus: bz_val, az_start: az_start_val, az_end: az_end_val, el_start: el_start_val, el_end: el_end_val, bz_type: bz_type_val } blocks[blockzones] = bz_item blockzone.append(blocks) except ValueError: print("No Timestamp found") return blockzone def get_device_data(self, vessel_id, device, start, end): """ Return Device Data """ values = self.couch_query.get_complete_values(vessel_id, device, start, end, 'all') if values: return values return 0 def get_blockage_data(self, device, values): """ Return Blockage Data """ blockage = [] if values: for val in values: blockage.append({ "antenna_status": val['value'][device]['General']['AntennaStatus'], "timestamp": val['timestamp'], "azimuth": val['value'][device]['General']['RelativeAz'], "elevation": val['value'][device]['General']['Elevation'], }) return blockage return 0 def get_current_position(self, vessel_id, device): """ Return Current Position """ data = {} values = self.couch_query.get_complete_values(vessel_id, device) if values: azimuth = None elevation = None if 'RelativeAz' in values[device]['General']: azimuth = values[device]['General']['RelativeAz'] if 'Elevation' in values[device]['General']: elevation = values[device]['General']['Elevation'] data['az'] = azimuth data['el'] = elevation return data return 0 def get_mainloop_time(self, vessel): """ Return Mainloop Time """ values = self.couch_query.get_complete_values(vessel, "PARAMETERS") if values: return values['PARAMETERS']['MAIN_PROGRAM']['MAINLOOPTIME'] return 0 def get_xydata(self, vessel_data, antenna_status, start_time, end_time, remarks): """ Return XY Data """ data = {} tmp = [] for status in antenna_status: if remarks == 'cron': data[status.capitalize()] = self.get_coordinates( vessel_data, status, 1) elif remarks == 'merge': coordinates = [data['coordinates'] for data in vessel_data] data[status.capitalize()] = self.merge_coordinates( coordinates, status, start_time, end_time) else: data[status.capitalize()] = self.get_coordinates( vessel_data, status, 0) tmp.append(data) return data def get_coordinates(self, vessel_data, status, flag=True): """ Return Coordinates """ tmp = [] data = {} for vdata in vessel_data: if vdata['antenna_status'] == status: if flag == 1: tmp.append({ "elevation": float(vdata['elevation']), "azimuth": float(vdata['azimuth']), "timestamp": vdata['timestamp'] }) else: tmp.append({ "x-axis": round(float(vdata['elevation'])), "y-axis": round(float(vdata['azimuth'])) }) data['coordinates'] = tmp # data['count'] = len(tmp) return data def combine_axis(self, data): """ Combine Axis """ seen = set() tmp = [] for dta in data: tup = tuple(dta.items()) if tup not in seen: seen.add(tup) tmp.append(dta) return tmp def merge_coordinates(self, datas, status, start_time, end_time): """ Return Merge Coordinates from PostgreSQL data """ tmp = [] coords = [] data = {} for dta in datas: if status in dta: coords += dta[status]['coordinates'] coordinates = sorted(coords, key=lambda i: i["timestamp"]) for coord in coordinates: if coord['timestamp'] >= float( start_time) and coord['timestamp'] <= float(end_time): tmp.append({ "x-axis": round(float(coord['elevation'])), "y-axis": round(float(coord['azimuth'])) }) data['coordinates'] = tmp return data def antenna_status(self, antennas): """ Antenna Status """ assert antennas, "Antenna is required." # antenna_state_online = map(lambda data:data.upper(), ['tracking']) antenna_state_online = ['TRACKING'] antenna_state_offline = [ 'BLOCKING ZONE', 'ACQUIRING SIGNAL', 'SKYSCAN', 'SEARCH1', 'SEARCH2', 'SEARCH3' ] antenna_state_service = [ 'ANTENNA POST', 'READY', 'INITIALIZE', 'SETUP', 'DIAGNOSTIC' ] antenna_state_invalid = ['ucli:'] antenna_status = [] online_state = [] offline_state = [] service_state = [] invalid_state = [] for antenna in antennas: status = antenna.capitalize() if antenna.upper() in antenna_state_online: online_state.append(status) if antenna.upper() in antenna_state_offline: offline_state.append(status) if antenna.upper() in antenna_state_service: service_state.append(status) if antenna.upper() in antenna_state_invalid: invalid_state.append(status) antenna_status.append({ "Online": online_state, "Offline": offline_state, "Service": service_state, "Invalid": invalid_state }) return antenna_status def get_zone_number(self, device_type): """ Return Zone Number """ assert device_type, "Device Type is required" vsat = [ 'Intellian_V100_E2S', 'Intellian_V110_E2S', 'Intellian_V80_IARM', 'Intellian_V100_IARM', 'Intellian_V100', 'Intellian_V80_E2S' ] zone = 0 # 'Cobham_500' if device_type in vsat: zone = 5 if device_type == "Sailor_900": zone = 8 return zone # CHECK DEVICE TYPE IF ALLOWED def allowed_device_type(self, device_type): """ Check Device Type if map available """ assert device_type, "Device Type is required." allowed_device_type = [ 'Intellian_V100_E2S', 'Intellian_V110_E2S', 'Intellian_V80_IARM', 'Intellian_V100_IARM', 'Intellian_V100', 'Intellian_V80_E2S', 'Sailor_900', 'Cobham_500' ] if device_type in allowed_device_type: return 1 return 0
class DeviceList(Common): """Class for DeviceImages""" # INITIALIZE def __init__(self): """The Constructor for DeviceImages class""" self.postgres = PostgreSQL() self.couch_query = Queries() self.aws3 = AwsS3() super(DeviceList, self).__init__() def get_list(self): """ This API is for Getting All Vessel Device List --- tags: - Devices produces: - application/json parameters: - name: token in: header description: Token required: true type: string - name: userid in: header description: User ID required: true type: string - name: limit in: query description: Limit required: true type: integer - name: page in: query description: Page required: true type: integer responses: 500: description: Error 200: description: Vessel Device List """ data = {} # GET DATA token = request.headers.get('token') userid = request.headers.get('userid') limit = int(request.args.get('limit')) page = int(request.args.get('page')) # CHECK TOKEN token_validation = self.validate_token(token, userid) if not token_validation: data['alert'] = "Invalid Token" data['status'] = 'Failed' # RETURN ALERT return self.return_data(data) # COUNT sql_str = "SELECT COUNT(*) FROM vessel" count = self.postgres.query_fetch_one(sql_str) total_rows = count['count'] offset = int((page - 1) * limit) # DATA sql_str = "SELECT * FROM vessel LIMIT {0} OFFSET {1} ".format( limit, offset) vessels = self.postgres.query_fetch_all(sql_str) rows = [] if vessels: vessel_ids = [x['vessel_id'] for x in vessels] for vessel_id in vessel_ids: vessel_name = self.get_vessel_name(vessel_id) devices = self.get_vessel_devices(vessel_id) rows.append({ "vessel_id": vessel_id, "vessel_name": vessel_name, "devices": devices }) total_page = int(math.ceil(int(total_rows - 1) / limit)) + 1 data['data'] = rows data['total_page'] = total_page data['limit'] = int(limit) data['page'] = int(page) data['total_rows'] = total_rows data['status'] = 'ok' return self.return_data(data) def get_vessel_name(self, vessel_id): """ Return Vessel Name """ assert vessel_id, "Vessel ID is required." values = self.couch_query.get_complete_values(vessel_id, "PARAMETERS") if values: vessel_name = values['PARAMETERS']['INFO']['VESSELNAME'] else: sql_str = "SELECT vessel_name FROM vessel WHERE vessel_id='{0}'".format( vessel_id) vname = self.postgres.query_fetch_one(sql_str) vessel_name = "" if vname: vessel_name = vname['vessel_name'] return vessel_name def get_vessel_devices(self, vessel_id): """ Return Vessel Devices """ assert vessel_id, "Vessel ID is required." sql_str = "SELECT device_id, device FROM device" sql_str += " WHERE vessel_id = '{0}'".format(vessel_id) sql_str += " AND device NOT IN ('PARAMETERS', 'COREVALUES'," sql_str += " 'FAILOVER', 'NTWCONF', 'NTWPERF1')" devices = self.postgres.query_fetch_all(sql_str) if devices: for device in devices: device['image_url'] = self.aws3.get_device_image( vessel_id, device['device_id']) return devices
class CalculateOperatorResult(Common): """Class for CalculateOperatorResult""" # INITIALIZE def __init__(self): """The Constructor for CalculateOperatorResult class""" self.postgres = PostgreSQL() self.couch_query = Queries() super(CalculateOperatorResult, self).__init__() def calculate_operator_result(self, comparator, params): """Calculate Operator Result""" if len(params) == 1: for param in params: result = self.compute_operator(param, comparator) if len(params) == 2: result = self.split_params(params, comparator) if len(params) == 3: params1 = [params[0], params[1]] params2 = [params[0], params[2]] if comparator == "BETWEEN": param_result1 = self.split_params(params1, ">") param_result2 = self.split_params(params2, "<") elif comparator == "BETWEENEQ": param_result1 = self.split_params(params1, ">=") param_result2 = self.split_params(params2, "<=") elif comparator == "!BETWEEN": param_result1 = self.split_params(params1, "<") param_result2 = self.split_params(params2, ">") elif comparator == "!BETWEENQ": param_result1 = self.split_params(params1, "<=") param_result2 = self.split_params(params2, ">=") param_results = [param_result1, param_result2] result = self.split_params(param_results, "AND") return result def check_param_content(self, params): """Check Parameter Content""" temp_data = [] for param in params: if any("datas" in x for x in param) or any("result" in x for x in param): indicator = "datas" else: indicator = "input" temp_data.append({"indicator": indicator, "data": param}) return temp_data def split_params(self, params, comparator): """Split Parameters""" result = [] param_content = self.check_param_content(params) if param_content[0]['indicator'] == "input" and param_content[1][ 'indicator'] == "datas": swap = True result = self.analyze_param(params[1], params[0], comparator, swap) elif param_content[0]['indicator'] == "input" and param_content[1][ 'indicator'] == "input": if not 'No Data to Show' in params: for param1 in params[0]: for param2 in params[1]: results = self.compute_operator( param1, comparator, param2) result.append({ "value": results, "remarks": self.get_remarks(results) }) else: swap = False result = self.analyze_param(params[0], params[1], comparator, swap) return result def analyze_param(self, param1, param2, comparator, swap=None): """Analyze Parameter""" results = [] for param in param1: parameter1 = param['datas'] core = param['core'] previous_core = param['previous'] vessel_name = self.check_vessel_name(param['vessel_id']) vessel_data = self.check_vessel_number(param['vessel_id']) if len(core) > 0: if param['message'] == "ok": parameter2 = "" if any("datas" in x for x in param2): indicator = "multiple" for par2 in param2: if param['vessel_id'] == par2['vessel_id']: if len(par2['datas']) != 0: parameter2 = par2['datas'] else: indicator = "none" parameter2 = param2 if not parameter2: continue parameter = [parameter1, parameter2] # CHECK DEVICE IF FAILOVER if param['device'].upper() == "FAILOVER": result = self.compute_failover_param(parameter, comparator, swap, flag=indicator) else: result = self.compute_param(parameter, comparator, core, previous_core, swap, flag=indicator) datas = sorted(result, key=lambda i: i["timestamp"]) else: datas = [{ "timestamp": previous_core['timestamp'], "value": previous_core['remarks'], "remarks": self.get_remarks(param['message']) }] results.append({ "vessel_id": param['vessel_id'], "vessel_name": vessel_name, "vessel_number": vessel_data, "device": param['device'], "device_id": param['device_id'], "core": param['core'], "previous": previous_core, "message": param['message'], "module": param['module'], "option": param['option'], "datas": datas }) else: datas = [{ "timestamp": previous_core['timestamp'], "value": previous_core['remarks'], "remarks": self.get_remarks(previous_core['remarks']) }] results.append({ "vessel_id": param['vessel_id'], "vessel_name": vessel_name, "vessel_number": vessel_data, "device": param['device'], "device_id": param['device_id'], "core": param['core'], "previous": previous_core, "message": previous_core['remarks'], "module": param['module'], "option": param['option'], "datas": datas }) return results def compute_param(self, params, comparator, cores, prevcore, swap=None, flag=None): """Compute Parameter""" results = [] param1 = params[0] param2 = params[1] for core in cores: if not param1: res = "" if prevcore['remarks'] in ['Unknown', 'ok']: remarks = "Unknown" else: remarks = "No Data" results.append({ "timestamp": core, "value": res, "remarks": self.get_remarks(remarks) }) else: parameter1 = [param['timestamp'] for param in param1] try: check_param1 = parameter1.index(core) timestamp = param1[check_param1]['timestamp'] val1 = param1[check_param1]['value'] if flag == "multiple": parameter2 = [p['timestamp'] for p in param2] try: check_param2 = parameter2.index(core) val2 = param2[check_param2]['value'] if swap is True: res = self.compute_operator( val2, comparator, val1) else: res = self.compute_operator( val1, comparator, val2) except ValueError: res = "Unknown" else: if not param2: res = "Unknown" else: for par2 in param2: val2 = self.check_data_type(par2) if swap is True: res = self.compute_operator( val2, comparator, val1) else: res = self.compute_operator( val1, comparator, val2) results.append({ "timestamp": timestamp, "value": res, "remarks": self.get_remarks(res) }) except ValueError: res = "Unknown" results.append({ "timestamp": core, "value": res, "remarks": "Unknown" }) return results def get_remarks(self, data): """Get Remarks""" if data is True: return "red" if data is False: return "green" if data == "Unknown": return "orange" if data == "No Data": return "blue" return "violet" def check_data_type(self, data): """Check Data Type""" try: if data in ['True', 'False']: formatted = eval(data) elif data.lstrip("-").isdigit(): formatted = float(int(data)) else: formatted = float(data) return formatted except ValueError: return data def check_vessel_name(self, vessel_id): """Check Vessel Name""" if vessel_id: vessel_name = self.couch_query.get_complete_values( vessel_id, "PARAMETERS") if vessel_name: return vessel_name['PARAMETERS']['INFO']['VESSELNAME'] return "Vessel Not Found" return 0 def check_vessel_number(self, vessel_id): """Check Vessel Number""" data = self.couch_query.get_by_id(vessel_id) if data: if "error" in data: return "No Data Found" return data['number'] return "No Data Found" def compute_failover_param(self, params, comparator, swap=None, flag=None): """Compute Failover Parameter""" results = [] param1 = params[0] param2 = params[1] for param in param1: timestamp = param['timestamp'] if param['value'] is None: res = "Unknown" else: val1 = self.check_data_type(param['value']) if flag == "multiple": parameter2 = [p['timestamp'] for p in param2] try: check_param2 = parameter2.index(param) val2 = self.check_data_type( param2[check_param2]['value']) if swap is True: res = self.compute_operator(val2, comparator, val1) else: res = self.compute_operator(val1, comparator, val2) except ValueError: res = "Unknown" else: if not param2: res = "Unknown" else: for par2 in param2: val2 = self.check_data_type(par2) if swap is True: res = self.compute_operator( val2, comparator, val1) else: res = self.compute_operator( val1, comparator, val2) results.append({ "timestamp": timestamp, "value": res, "remarks": self.get_remarks(res) }) return results
class Upload(Common): """Class for Vessels""" # INITIALIZE def __init__(self): """The Constructor for Vessel Upload class""" self.couch_query = Queries() self.postgres = PostgreSQL() self.aws3 = AwsS3() super(Upload, self).__init__() # GET VESSEL FUNCTION def file_upload(self): """ This API is for Uploading Vessel File --- tags: - Vessel produces: - application/json parameters: - name: token in: header description: Token required: true type: string - name: userid in: header description: User ID required: true type: string - name: vessel_id in: query description: Vessel ID required: true type: string responses: 500: description: Error 200: description: Vessel File Upload """ # INIT DATA data = {} # VESSEL ID vessel_id = request.args.get('vessel_id') # # GET DATA token = request.headers.get('token') userid = request.headers.get('userid') # CHECK TOKEN token_validation = self.validate_token(token, userid) if not token_validation: data["alert"] = "Invalid Token" data['status'] = 'Failed' # RETURN ALERT return self.return_data(data) # RH_<VesselIMO>_<ImageID> parameters = self.couch_query.get_complete_values( vessel_id, "PARAMETERS" ) # VESSEL IMO vessel_imo = parameters['PARAMETERS']['INFO']['IMO'] file_upload = [] filenames = request.files.getlist('upfile') for filename in filenames: try: file_name = filename.filename # ext = file_name.split(".")[-1] # if not self.allowed_file_type(file_name): # data["alert"] = "File Type Not Allowed!" # data['status'] = 'Failed' # return self.return_data(data) except ImportError: data["alert"] = "No image!" data['status'] = 'Failed' # RETURN ALERT return self.return_data(data) file_name = self.rename_file(vessel_id, file_name) vimg_data = {} vimg_data['vessel_id'] = vessel_id vimg_data['vessel_imo'] = vessel_imo vimg_data['file_name'] = file_name vimg_data['status'] = "active" vimg_data['created_on'] = time.time() # ADD FILE TO VESSEL FILE TABLE self.postgres.insert('vessel_file', vimg_data, 'vessel_file_id') # FILE NAME # file_name_upload = str(vessel_file_id) + "." + ext # upload_file = 'VesselFiles/' + "RH_" + vessel_imo + "_" + file_name_upload upload_file = 'VesselFiles/' + vessel_imo +"/" + file_name body = request.files['upfile'] # SAVE TO S3 url = "" if self.aws3.save_file(upload_file, body): url = self.aws3.get_url(upload_file) file_upload.append({ "filename": file_name, "url": url }) data["status"] = "ok" data["data"] = file_upload # RETURN return self.return_data(data) def allowed_file_type(self, filename): """ Check Allowed File Extension """ allowed_extensions = set(['txt', 'pdf']) return '.' in filename and filename.rsplit('.', 1)[1].lower() in allowed_extensions def rename_file(self, vessel_id, filename): """ Rename File """ sql_str = "SELECT * FROM vessel_file" sql_str += " WHERE vessel_id='{0}'".format(vessel_id) sql_str += " AND file_name='{0}'".format(filename) vessel_file = self.postgres.query_fetch_one(sql_str) if vessel_file: new_name = self.file_replace(vessel_file['file_name']) return self.rename_file(vessel_id, new_name) return filename
class EmailVesselInfo(Common): """Class for EmailVesselInfo""" # INITIALIZE def __init__(self): """The Constructor for EmailVesselInfo class""" self.postgres = PostgreSQL() self.couch_query = Queries() self.epoch_default = 26763 super(EmailVesselInfo, self).__init__() def email_vessel_info(self): """Email Vessel Information""" # DONE EMAIL ID's email_ids = self.get_done_email_ids() # GET ALL ID's TO EMAIL email_schedules = self.get_email_schedule_ids(email_ids) for email_schedule in email_schedules or []: # SEND EMAIL self.email_sender(email_schedule) return 1 def get_done_email_ids(self): """Return Done Email IDs""" # GET CURRENT UTC DATE utc_date = datetime.utcnow().strftime("%Y%m%d") # INIT SQL QUERY sql_str = "SELECT email_schedule_id FROM email_log" sql_str += " WHERE date_today=" + str(utc_date) # FETCH ALL res = self.postgres.query_fetch_all(sql_str) # RETURN return res def get_email_schedule_ids(self, email_ids): """Return Email Schedule IDs""" # SET TIME FORMAT time_format = '%H:%M:%S' # SET GET UTC DATE utc_date = datetime.now(tz=pytz.utc) # GET UTC TIME new_time = utc_date.strftime(time_format) # SPLIT TIME new_time = new_time.split(":") # SET DELTA TIME tdel = timedelta(hours=int(new_time[0]), minutes=int(new_time[1]), seconds=int(new_time[2])) # GET TOTAL SECONDS td_seconds = tdel.total_seconds() # INIT SQL QUERY cols = 'email_vessel_id, email_schedule_id, schedule' sql_str = "SELECT " + cols + " FROM email_schedule" sql_str += " WHERE utc_time<= " + str(td_seconds) # CHECK IF ANY OLD SEND EMAIL ID's if email_ids: email_ids = [x['email_schedule_id'] for x in email_ids] # CEHCK LENTH OF OLD SEND EMAIL ID's if len(email_ids) == 1: # ADD CONDITION FOR SQL QUERY sql_str += " AND email_schedule_id != " + str(email_ids[0]) else: # ADD CONDITION FOR SQL QUERY sql_str += " AND email_schedule_id NOT IN " + str( tuple(email_ids)) # FETCH ALL res = self.postgres.query_fetch_all(sql_str) # RETURN return res def email_sender(self, email_schedule): """Email Sender""" # INIT SQL QUERY cols = 'vessel_id, email' sql_str = "SELECT " + cols + " FROM email_vessel" sql_str += " WHERE mail_enable=true AND email_vessel_id=" sql_str += str(email_schedule['email_vessel_id']) # FETCH ONE res = self.postgres.query_fetch_one(sql_str) if res: vessel_id = res['vessel_id'] sql_str = "SELECT * FROM report_temp WHERE vessel_id = '" + str( vessel_id) + "'" report_temp_res = self.postgres.query_fetch_one(sql_str) if report_temp_res: report_data = report_temp_res['report_data'] report_data = report_data.splitlines() else: report_data = "General Info: \n" report_data += """VESSEL: *["PARAMETERS"]["INFO"]["VESSELNAME"]*\n""" report_data += "TIME: *TIMESTAMP*\n" report_data = report_data.split("\\n") pattern = r"\*(.*)\*" last_update = self.get_last_update_with_option(vessel_id) epoch_time = int(time.time()) final_data = [] for line in report_data: match = None temp_data = {} str_line = line for match in re.finditer(pattern, line): start_match = match.start() end_match = match.end() pat = r"[a-zA-Z0-9_ ]+" device = re.findall(pat, line[start_match:end_match]) if device[0].upper() in ['TIME', 'TIMESTAMP']: pass else: temp_data['label'] = str_line.split(":")[0] values = self.couch_query.get_complete_values( vessel_id, device[0]) if values: try: temp_data['value'] = values[device[0]][ device[1]][device[2]] except: temp_data['value'] = "" final_data.append(temp_data) else: temp_data['value'] = "" final_data.append(temp_data) if str_line.split(":")[0].upper() == 'STATUS': status = "Offline" if self.check_time_lapse(epoch_time, last_update) == "green": status = "Online" temp_data['label'] = 'STATUS' temp_data['value'] = status final_data.append(temp_data) elif match is None: temp_data['label'] = str_line.split(":")[0] temp_data['value'] = "" final_data.append(temp_data) temp_message = copy.deepcopy(final_data) utc = datetime.utcfromtimestamp(last_update).strftime( '%A, %d %B %Y %I:%M:%S %p') last_date = utc + " UTC" values = self.couch_query.get_complete_values( vessel_id, "PARAMETERS") email = res['email'] email_temp = VesselReport() emailer = Email() message = email_temp.vessel_report_temp(final_data, last_date) subject = "Scheduled Reporting Event - " + values['PARAMETERS'][ 'INFO']['VESSELNAME'] emailer.send_email(email, message, subject) date_today = datetime.utcnow().strftime("%Y%m%d") # INIT NEW VESSEL EMAIL temp = {} temp['email_schedule_id'] = email_schedule['email_schedule_id'] temp['email_vessel_id'] = email_schedule['email_vessel_id'] temp['message'] = json.dumps(temp_message) temp['data_date'] = last_date temp['date_today'] = date_today temp['update_on'] = time.time() temp['created_on'] = time.time() # INSERT NEW VESSEL EMAIL self.postgres.insert('email_log', temp) else: return 0 return 1 # LATE UPDATE WITH OPTION def get_last_update_with_option(self, vessel_id): """Return Last Updated with Option""" values = self.couch_query.get_complete_values(vessel_id, "COREVALUES", flag='one_doc') if values: return values['timestamp'] return 0 def get_device(self, devices, pattern): """Return Device""" data = [] for device in devices: if re.findall(r'' + pattern + r'\d', device['doc']['device']): data.append(device['doc']) data = sorted(data, key=lambda i: i['device']) return data
class Device(Common): """Class for Device""" # INITIALIZE def __init__(self): """The Constructor for Device class""" # INIT CONFIG self.config = ConfigParser() # CONFIG FILE self.config.read("config/config.cfg") self._couch_db = CouchDatabase() self.couch_query = Queries() self.aws3 = AwsS3() self.epoch_default = 26763 self.db_host = config_section_parser(self.config, "COUCHDB")['host'] self.db_port = config_section_parser(self.config, "COUCHDB")['port'] super(Device, self).__init__() # GET VESSEL FUNCTION def device_list(self): """ This API is for Getting Vessel Device List --- tags: - Devices produces: - application/json parameters: - name: token in: header description: Token required: true type: string - name: userid in: header description: User ID required: true type: string - name: vessel_id in: query description: Vessel ID required: true type: string - name: device_id in: query description: Device ID required: false type: string - name: date in: query description: Epoch date required: false type: string responses: 500: description: Error 200: description: Vessel Device List """ # VESSEL ID vessel_id = request.args.get('vessel_id') device_id = request.args.get('device_id') epoch_date = request.args.get('date') # dbs = [] # GET DATA token = request.headers.get('token') userid = request.headers.get('userid') device_list = [] # CHECK TOKEN token_validation = self.validate_token(token, userid) if not token_validation: data = {} data["alert"] = "Invalid Token" data['status'] = 'Failed' # RETURN ALERT return self.return_data(data) if not vessel_id: data = {} data["alert"] = "No Vessel ID" data['status'] = 'Failed' # RETURN ALERT return self.return_data(data) if device_id: value = self.couch_query.get_by_id(device_id) device_list.append(value) else: device_list = self.couch_query.get_device(vessel_id) if epoch_date in ["null", "0", "NaN"]: epoch_date = False # REMOVE DATA data_to_remove = ['PARAMETERS', 'COREVALUES', 'FAILOVER', 'NTWCONF'] device_list = self.remove_data(device_list, data_to_remove) device_info = {} parameters = self.couch_query.get_complete_values( vessel_id, "PARAMETERS") final_data = [] for device in device_list: current_time = time.time() device_type = parameters['PARAMETERS'][device['device']]['TYPE'] row = {} vsat_antenna = {} data_id = "" if device_type in ['Catalyst_2960', 'Catalyst_3750']: device_port, general, all_data, data_id = self.get_switch( vessel_id, device['device'], epoch_date) row['ports'] = device_port row['general'] = general row['device'] = device['device'] row['description'] = "" if 'DESCRIPTION' in parameters['PARAMETERS'][ device['device']].keys(): row['description'] = parameters['PARAMETERS'][ device['device']]['DESCRIPTION'] elif device_type in ['Sentry3', 'Raritan_PX2']: outlet_status, all_data, data_id = self.get_power_s( vessel_id, device['device'], epoch_date) row['outlet_status'] = outlet_status row['description'] = "" if 'DESCRIPTION' in parameters['PARAMETERS'][ device['device']].keys(): row['description'] = parameters['PARAMETERS'][ device['device']]['DESCRIPTION'] gen_data = all_data['value'][device['device']]['General'] if device_type == 'Sentry3': infeed_load_value = gen_data['infeedLoadValue'] infeed_power = gen_data['infeedPower'] row['infeed_load_value'] = str(infeed_load_value) + " A" row['infeed_power'] = str(infeed_power) + " W" if device_type == 'Raritan_PX2': pdu_inlet_currentval = "" if gen_data['pduInletCurrent']: pdu_inlet_currentval = float( gen_data['pduInletCurrent']) / 10 pdu_inlet_current = pdu_inlet_currentval pdu_inlet_voltage = gen_data['pduInletVoltage'] pdu_power = ['pduPower'] row['pdu_inlet_current'] = pdu_inlet_current row['pdu_line_frequency'] = 'L1' # pduLineFrequency row['pdu_inlet_voltage'] = pdu_inlet_voltage row['pdu_power'] = pdu_power row['device'] = device['device'] elif device_type == 'IOP': iop_info, all_data, data_id = self.get_iop( vessel_id, device['device'], epoch_date) row['info'] = iop_info row['description'] = "" if 'DESCRIPTION' in parameters['PARAMETERS'][ device['device']].keys(): row['description'] = parameters['PARAMETERS'][ device['device']]['DESCRIPTION'] row['device'] = device['device'] elif device_type in [ 'Intellian_V80_E2S', 'Intellian_V100_E2S', 'Intellian_V110_E2S', 'Intellian_V80_IARM', 'Intellian_V100_IARM', 'Intellian_V110_IARM', 'Intellian_V100', 'Intellian_V110', 'Sailor_900' ]: general, all_data, data_id = self.get_vsat( vessel_id, device['device'], epoch_date) row['description'] = "" if 'DESCRIPTION' in parameters['PARAMETERS'][ device['device']].keys(): row['description'] = parameters['PARAMETERS'][ device['device']]['DESCRIPTION'] row['device'] = device['device'] row['general'] = general vsat_antenna = self.get_vsat_azimuth(row['general'], device_type) elif device_type in ['Evolution_X5', 'Evolution_X7']: value, all_data, data_id = self.defaul_data( vessel_id, device['device']) row['description'] = "" if 'DESCRIPTION' in parameters['PARAMETERS'][ device['device']].keys(): row['description'] = parameters['PARAMETERS'][ device['device']]['DESCRIPTION'] row['device'] = device['device'] row['general'] = value[device['device']]['General'] elif device_type in ['Cisco_SNMP']: device_port, general, all_data, data_id = self.get_cis_snmp( vessel_id, device['device'], epoch_date) row['ports'] = device_port row['general'] = general row['device'] = device['device'] row['description'] = "" if 'DESCRIPTION' in parameters['PARAMETERS'][ device['device']].keys(): row['description'] = parameters['PARAMETERS'][ device['device']]['DESCRIPTION'] elif device_type in ['Sailor_3027C']: general, all_data, data_id = self.get_sailors_30xxx( vessel_id, device['device'], epoch_date) row['general'] = general row['device'] = device['device'] row['description'] = "" if 'DESCRIPTION' in parameters['PARAMETERS'][ device['device']].keys(): row['description'] = parameters['PARAMETERS'][ device['device']]['DESCRIPTION'] elif device_type in ['Sailor_62xx']: general, all_data, data_id = self.get_sailor_62xx( vessel_id, device['device'], epoch_date) row['general'] = general row['device'] = device['device'] row['description'] = "" if 'DESCRIPTION' in parameters['PARAMETERS'][ device['device']].keys(): row['description'] = parameters['PARAMETERS'][ device['device']]['DESCRIPTION'] elif device_type in ['Sailor_6103']: general, all_data, data_id = self.get_sailor_6103( vessel_id, device['device'], epoch_date) row['general'] = general row['device'] = device['device'] row['description'] = "" if 'DESCRIPTION' in parameters['PARAMETERS'][ device['device']].keys(): row['description'] = parameters['PARAMETERS'][ device['device']]['DESCRIPTION'] elif device_type in ['Cobham_500']: value, all_data, data_id = self.defaul_data( vessel_id, device['device']) row['description'] = "" if 'DESCRIPTION' in parameters['PARAMETERS'][ device['device']].keys(): row['description'] = parameters['PARAMETERS'][ device['device']]['DESCRIPTION'] row['device'] = device['device'] row['general'] = value[device['device']]['General'] _, all_data, data_id = self.defaul_data(vessel_id, device['device']) row['description'] = "" if 'DESCRIPTION' in parameters['PARAMETERS'][ device['device']].keys(): row['description'] = parameters['PARAMETERS'][ device['device']]['DESCRIPTION'] row['device'] = device['device'] if row: data_url = str(self.db_host) + ":" + str(self.db_port) data_url += "/_utils/#database/vessels_db/" + str(data_id) row['status'] = self.check_time_lapse(current_time, all_data['timestamp']) row['device_type'] = device_type row['device_id'] = device['_id'] row['vessel_id'] = vessel_id row['vsat_antenna'] = vsat_antenna row['data_url'] = data_url row['image_url'] = self.aws3.get_device_image( vessel_id, device['_id']) final_data.append(row) device_info['status'] = 'ok' device_info['data'] = final_data return self.return_data(device_info) def get_iop(self, vessel_id, device, epoch_date): """Return IOP""" if epoch_date: data = self.couch_query.get_complete_values( vessel_id, device, str(self.epoch_default), str(epoch_date), flag='one_doc') else: data = self.couch_query.get_complete_values(vessel_id, device, flag='one_doc') value = data['value'] data_id = data['_id'] iop_info = {} iop_info['status'] = value[device]['General']['Status'] iop_info['signal'] = value[device]['General']['Signal'] iop_info['gps'] = value[device]['General']['GPS'] iop_info['data'] = value[device]['General']['Data'] iop_info['handset1'] = value[device]['General']['Handset1'] iop_info['handset2'] = value[device]['General']['Handset2'] iop_info['handset3'] = value[device]['General']['Handset3'] return [iop_info, data, data_id] def get_power_s(self, vessel_id, device, epoch_date): """Return Power Switch""" if epoch_date: data = self.couch_query.get_complete_values( vessel_id, device, str(self.epoch_default), str(epoch_date), flag='one_doc') else: data = self.couch_query.get_complete_values(vessel_id, device, flag='one_doc') value = data['value'] data_id = data['_id'] device_outlets = [] for i in range(1, 9): temp_device_outlets = {} temp_device_outlets['name'] = 'outlet' + str(i) if ('outlet' + str(i)) in value[device].keys(): temp_device_outlets['value'] = value[device]['outlet' + str(i)]['status'] else: temp_device_outlets['value'] = None device_outlets.append(temp_device_outlets) return [device_outlets, data, data_id] def get_sailor_6103(self, vessel_id, device, epoch_date): """Return Sailor 6103""" if epoch_date: data = self.couch_query.get_complete_values( vessel_id, device, str(self.epoch_default), str(epoch_date), flag='one_doc') else: data = self.couch_query.get_complete_values(vessel_id, device, flag='one_doc') value = data['value'][device] data_id = data['_id'] del value['General'] gen = {} for key in value.keys(): gen[key] = "" if not value[key]['IP'] == "0.0.0.0": gen[key] = value[key]['IP'] return [gen, data, data_id] def get_sailors_30xxx(self, vessel_id, device, epoch_date): """Return Sailor 3027C""" if epoch_date: data = self.couch_query.get_complete_values( vessel_id, device, str(self.epoch_default), str(epoch_date), flag='one_doc') else: data = self.couch_query.get_complete_values(vessel_id, device, flag='one_doc') value = data['value'] data_id = data['_id'] lat_dir = value[device]['General']['latitudeDirection'] lon_dir = value[device]['General']['longitudeDirection'] lat = value[device]['General']['latitude'] lon = value[device]['General']['longitude'] lon_val = ''.join(lon.rsplit('.', 1)) if lon_dir == 'W': lon_val = "-" + lon_val lat_val = ''.join(lat.rsplit('.', 1)) if lat_dir == 'S': lat_val = "-" + lat_val gen = {} gen['currentProtocol'] = value[device]['General']['currentProtocol'] gen['currentOceanRegion'] = value[device]['General'][ 'currentOceanRegion'] gen['latitude'] = self.position_converter(lat_val) gen['longitude'] = self.position_converter(lon_val) gen['latitudeDirection'] = lat_dir gen['longitudeDirection'] = lon_dir return [gen, data, data_id] def position_converter(self, val): """ POSITION CONVERTER """ absolute = abs(float(val)) degrees = math.floor(absolute) minutes_not_truncated = (absolute - degrees) * 60 minutes = math.floor(minutes_not_truncated) seconds = math.floor((minutes_not_truncated - minutes) * 60) return str(degrees) + "." + str(minutes) + "." + str(seconds) def get_sailor_62xx(self, vessel_id, device, epoch_date): """Return Sailor 62xx""" if epoch_date: data = self.couch_query.get_complete_values( vessel_id, device, str(self.epoch_default), str(epoch_date), flag='one_doc') else: data = self.couch_query.get_complete_values(vessel_id, device, flag='one_doc') value = data['value'] data_id = data['_id'] gen = {} gen['currentChDesc'] = value[device]['General']['currentChDesc'] gen['currentCh'] = value[device]['General']['currentCh'] gen['transmitMode'] = value[device]['General']['transmitMode'] return [gen, data, data_id] def get_switch(self, vessel_id, device, epoch_date): """Return Switch""" if epoch_date: data = self.couch_query.get_complete_values( vessel_id, device, str(self.epoch_default), str(epoch_date), flag='one_doc') else: data = self.couch_query.get_complete_values(vessel_id, device, flag='one_doc') value = data['value'] data_id = data['_id'] device_port = [] keys = value[device].keys() for i in range(1, (len(keys))): temp_device_port = {} port = 'Fa0/' + str(i) if port in keys: temp_device_port['name'] = port temp_device_port['value'] = value[device][port]['status'] device_port.append(temp_device_port) for i in range(1, 3): temp_device_port = {} port = 'Gi0/' + str(i) if port in keys: temp_device_port['name'] = port temp_device_port['value'] = value[device][port]['status'] device_port.append(temp_device_port) gen = {} gen['port'] = value[device]['General']['port'] gen['serial'] = value[device]['General']['SerialNumber'] gen['mac'] = value[device]['General']['MacAddress'] gen['model'] = value[device]['General']['ModelNumber'] return [device_port, gen, data, data_id] def get_cis_snmp(self, vessel_id, device, epoch_date): """Return Switch""" if epoch_date: data = self.couch_query.get_complete_values( vessel_id, device, str(self.epoch_default), str(epoch_date), flag='one_doc') else: data = self.couch_query.get_complete_values(vessel_id, device, flag='one_doc') value = data['value'] data_id = data['_id'] device_port = [] keys = value[device].keys() for i in range(1, (len(keys))): temp_device_port = {} port = 'fa' + str(i) if port in keys: temp_device_port['name'] = port temp_device_port['value'] = value[device][port]['ifOperStatus'] device_port.append(temp_device_port) for i in range(1, (len(keys))): temp_device_port = {} port = 'gi' + str(i) if port in keys: temp_device_port['name'] = port temp_device_port['value'] = value[device][port]['ifOperStatus'] device_port.append(temp_device_port) gen = {} for gen_key in value[device]['General'].keys(): gen[gen_key] = value[device]['General'][gen_key] return [device_port, gen, data, data_id] def get_vsat(self, vessel_id, device, epoch_date): """Return VSAT""" if epoch_date: data = self.couch_query.get_complete_values( vessel_id, device, str(self.epoch_default), str(epoch_date), flag='one_doc') else: data = self.couch_query.get_complete_values(vessel_id, device, flag='one_doc') value = data['value'] data_id = data['_id'] return [value[device]['General'], data, data_id] def defaul_data(self, vessel_id, device): """Return Default Data""" data = self.couch_query.get_complete_values(vessel_id, device, flag='one_doc') value = data['value'] data_id = data['_id'] return [value, data, data_id] def get_vsat_azimuth(self, general, device_type): """Return VSAT Azimuth and Elevation Value""" data = {} if device_type in [ 'Intellian_V80_E2S', 'Intellian_V100_E2S', 'Intellian_V110_E2S', 'Intellian_V80_IARM', 'Intellian_V100_IARM', 'Intellian_V110_IARM', 'Intellian_V100', 'Intellian_V110', 'Sailor_900' ]: azimuth = [] elev = [] heading = None target_azimuth = None relative_az = None abosulte_az = None if 'Heading' in general: heading = general['Heading'] if 'TargetAzimuth' in general: target_azimuth = general['TargetAzimuth'] if 'RelativeAz' in general: relative_az = general['RelativeAz'] if 'AbsoluteAz' in general: abosulte_az = general['AbsoluteAz'] azimuth.append({ "Heading": heading, "TargetAzimuth": target_azimuth, "RelativeAz": relative_az, "AbsoluteAz": abosulte_az }) elevation = None target_elevation = None if 'Elevation' in general: elevation = general['Elevation'] if 'TargetElevation' in general: target_elevation = general['TargetElevation'] elev.append({ "Elevation": elevation, "TargetElevation": target_elevation }) data['azimuth'] = azimuth data['elevation'] = elev return data
class Upload(Common): """Class for Device Upload""" # INITIALIZE def __init__(self): """The Constructor for Device Upload class""" self.couch_query = Queries() self.postgres = PostgreSQL() self.aws3 = AwsS3() super(Upload, self).__init__() # GET VESSEL FUNCTION def device_upload(self): """ This API is for Device Image Upload --- tags: - Devices produces: - application/json parameters: - name: token in: header description: Token required: true type: string - name: userid in: header description: User ID required: true type: string - name: vessel_id in: query description: Vessel ID required: true - name: device_id in: query description: Device ID required: true type: string - name: upfile in: formData description: Device image required: true type: file consumes: - multipart/form-data responses: 500: description: Error 200: description: Device Image Upload """ # INIT DATA data = {} # VESSEL ID vessel_id = request.args.get('vessel_id') device_id = request.args.get('device_id') # # GET DATA token = request.headers.get('token') userid = request.headers.get('userid') # CHECK TOKEN token_validation = self.validate_token(token, userid) if not token_validation: data["alert"] = "Invalid Token" data['status'] = 'Failed' # RETURN ALERT return self.return_data(data) # RH_<VesselIMO>_<ImageID> parameters = self.couch_query.get_complete_values( vessel_id, "PARAMETERS") # VESSEL IMO vessel_imo = vessel_id if parameters: vessel_imo = parameters['PARAMETERS']['INFO']['IMO'] try: filename = request.files['upfile'].filename ext = filename.split(".")[-1] if not self.allowed_image_type(filename): data["alert"] = "File Type Not Allowed!" data['status'] = 'Failed' return self.return_data(data) except ImportError: data["alert"] = "No image!" data['status'] = 'Failed' # RETURN ALERT return self.return_data(data) filename = self.rename_device_image(vessel_id, device_id, filename) dimg_data = {} dimg_data['vessel_id'] = vessel_id dimg_data['device_id'] = device_id dimg_data['vessel_imo'] = vessel_imo dimg_data['image_name'] = filename dimg_data['status'] = "active" dimg_data['created_on'] = time.time() # VERIFY IF IMAGE EXISTS FOR DEVICE sql_str = "SELECT * FROM device_image" sql_str += " WHERE vessel_id='{0}'".format(vessel_id) sql_str += " AND device_id='{0}'".format(device_id) sql_str += " AND status = 'active'" device = self.postgres.query_fetch_one(sql_str) if device: # INIT CONDITION conditions = [] # CONDITION FOR QUERY conditions.append({ "col": "device_image_id", "con": "=", "val": device['device_image_id'] }) update_column = {} update_column['status'] = "inactive" self.postgres.update('device_image', update_column, conditions) device_image_id = self.postgres.insert('device_image', dimg_data, 'device_image_id') # IMAGE FILE NAME file_name = vessel_imo + "_" + str(device_id) + str( device_image_id) + "." + ext img_file = 'Device/' + "RH_" + str(file_name) body = request.files['upfile'] # SAVE TO S3 image_url = "" if self.aws3.save_file(img_file, body): image_url = self.aws3.get_url(img_file) data["status"] = "ok" data["image_url"] = image_url # RETURN return self.return_data(data) def allowed_image_type(self, filename): """ Check Allowed File Extension """ allowed_extensions = set(['png', 'jpg', 'jpeg', 'gif']) return '.' in filename and filename.rsplit( '.', 1)[1].lower() in allowed_extensions def rename_device_image(self, vessel_id, device_id, filename): """Rename Image""" sql_str = "SELECT * FROM device_image" sql_str += " WHERE vessel_id='{0}'".format(vessel_id) sql_str += " AND device_id='{0}'".format(device_id) sql_str += " AND image_name='{0}'".format(filename) device_image = self.postgres.query_fetch_one(sql_str) if device_image: new_name = self.file_replace(device_image['image_name']) return self.rename_device_image(vessel_id, device_id, new_name) return filename
class UpdateDeviceState(Common): """Class for UpdateDeviceState""" # INITIALIZE def __init__(self): """The Constructor for UpdateDeviceState class""" self._couch_db = CouchDatabase() self.couch_query = Queries() self.postgres = PostgreSQL() super(UpdateDeviceState, self).__init__() def update_device_state(self): """Update Device State""" devices = self.couch_query.get_devices() device_ids = [x['_id'] for x in devices] # INIT SQL QUERY sql_str = "SELECT * FROM device" # FETCH ALL rows = self.postgres.query_fetch_all(sql_str) db_device_ids = [x['device_id'] for x in rows] device_ids = set(device_ids) db_device_ids = set(db_device_ids) device_ids.difference_update(db_device_ids) if device_ids: d_ids = list(device_ids) for device in devices: if device['_id'] in d_ids: parameters = self.couch_query.get_complete_values( device['vessel_id'], "PARAMETERS" ) if device['device'] in ['COREVALUES', 'FAILOVER', 'PARAMETERS', 'NTWCONF']: device_type = device['device'] else: device_type = parameters['PARAMETERS'][device['device']]['TYPE'] data = {} data['device_id'] = device['_id'] data['device'] = device['device'] data['device_type'] = device_type data['vessel_id'] = device['vessel_id'] data['update_on'] = time.time() data['created_on'] = time.time() self.postgres.insert('device', data) # RETURN return rows
class RemoteCommand(Common): """Class for RemoteCommand""" # INITIALIZE def __init__(self): """The Constructor for RemoteCommand class""" # INIT CONFIG self.config = ConfigParser() # CONFIG FILE self.config.read("config/config.cfg") self._couch_db = CouchDatabase() self.couch_query = Queries() self.postgres = PostgreSQL() self.epoch_default = 26763 super(RemoteCommand, self).__init__() # GET VESSEL FUNCTION def remote_command(self): """ This API is for Remote Command --- tags: - Remote Command produces: - application/json parameters: - name: token in: header description: Token required: true type: string - name: userid in: header description: User ID required: true type: string - name: vessel_id in: query description: Vessel ID required: true type: string - name: device_id in: query description: Device ID required: false type: string responses: 500: description: Error 200: description: Remote Command """ # GET DATA token = request.headers.get('token') userid = request.headers.get('userid') # CHECK TOKEN token_validation = self.validate_token(token, userid) if not token_validation: data = {} data["alert"] = "Invalid Token" data['status'] = 'Failed' # RETURN ALERT return self.return_data(data) vessel_id = request.args.get('vessel_id') device_id = request.args.get('device_id') device_info = {} all_devices = self.couch_query.get_all_devices(vessel_id) if device_id: for dev in all_devices: if dev['id'] == device_id: device_info = dev break parameters = self.couch_query.get_complete_values(vessel_id, "PARAMETERS", flag='one_doc') ntwconf = self.couch_query.get_complete_values(vessel_id, "NTWCONF", flag='one_doc') # COREVALUES, FAILOVER, NTWCONF final_data = [] if device_id and not device_info: pass elif device_id and device_info: if device_info['doc']['device'] == "COREVALUES": system = self.get_system() final_data.append(system) if device_info['doc']['device'] == "FAILOVER": failover = self.get_failover(parameters) final_data.append(failover) if device_info['doc']['device'] == "NTWCONF": netconf = self.get_nc(parameters, ntwconf) final_data.append(netconf) devices = self.get_item([device_info], 'MODEM') for device in devices: modem = self.get_modem(vessel_id, device) final_data.append(modem) devices = self.get_item([device_info], 'POWERSWITCH') for device in devices: power = self.get_power_switch(vessel_id, device) final_data.append(power) else: system = self.get_system() final_data.append(system) failover = self.get_failover(parameters) final_data.append(failover) netconf = self.get_nc(parameters, ntwconf) final_data.append(netconf) devices = self.get_item(all_devices, 'MODEM') for device in devices: modem = self.get_modem(vessel_id, device) final_data.append(modem) devices = self.get_item(all_devices, 'POWERSWITCH') for device in devices: power = self.get_power_switch(vessel_id, device) final_data.append(power) if not device_id: tun1 = '' if 'tun1' in ntwconf['value']['NTWCONF'].keys(): tun1 = ntwconf['value']['NTWCONF']['tun1']['IP'] ssh_opt = [] opt = {} opt['description'] = "SSH to Vessel" opt['option'] = "ssh://" + tun1 ssh_opt.append(opt) ssh = {} ssh['icon'] = "CodeIcon" ssh['label'] = "SSH" ssh['options'] = ssh_opt final_data.append(ssh) ret = {} ret['data'] = final_data ret['status'] = "ok" return self.return_data(ret) def get_system(self): """ SYSTEM / CORE VALUES """ system = {} system["label"] = "System" system["icon"] = "Apps" system["options"] = [] option = {} option["option"] = "Load-average" option[ "description"] = 'Gets the number of processor cores and load-average.' system["options"].append(option) option = {} option["option"] = "Uptime" option[ "description"] = 'Get the uptime of the system, aswell as the start-up timestamp.' system["options"].append(option) option = {} option["option"] = "Free RAM and Swap" option["description"] = 'Show the available/used RAM and swap size' system["options"].append(option) option = {} option["option"] = "Hardware info" option[ "description"] = 'Show hardware info (like serial-number, product name, ...)' system["options"].append(option) option = {} option["option"] = "Memory info" option["description"] = 'Show memory info' system["options"].append(option) option = {} option["option"] = "Disk space" option["description"] = 'Check used/available disk space' system["options"].append(option) option = {} option["option"] = "Debian version" option["description"] = 'Get debian and kernel version' system["options"].append(option) option = {} option["option"] = "PWD" option["description"] = 'Get working directory' system["options"].append(option) option = {} option["option"] = "Initiate program cycle" option["description"] = 'Initiate a new program cycle now.' system["options"].append(option) option = {} option["option"] = "Date/Time" option["description"] = 'Show Date & Time' system["options"].append(option) option = {} option["option"] = "Temporary file server" option["others"] = [] # OTHERS other = {} other["name"] = "File-server shuts down after..." other["selected"] = 60 other["type"] = "dropdown" other["values"] = [] value = {} value["1 Minute"] = 60 other["values"].append(value) value = {} value["2 Minute"] = 120 other["values"].append(value) value = {} value["5 Minute"] = 300 other["values"].append(value) option["others"].append(other) # OTHERS other = {} other["name"] = "Directory" other["selected"] = "/home/rh/backendv1/log" other["type"] = "dropdown" other["values"] = [] value = {} value["Log Files"] = "/home/rh/backendv1/log" other["values"].append(value) value = {} value["Ini File"] = "/home/rh/backendv1/ini" other["values"].append(value) option["others"].append(other) option["description"] = 'Opens a temporary file-server' system["options"].append(option) return system def get_failover(self, parameters): """ FAILOVER """ failover = {} failover["label"] = "Failover" failover["icon"] = "ErrorIcon" failover["options"] = [] option = {} option["option"] = "Reset all gateways" option["description"] = 'Reset all gateways' failover["options"].append(option) option = {} option["option"] = "Failover rule" option["description"] = 'Change failover rule.' option["others"] = [] # OTHERS other = {} other["name"] = "Rule" other["type"] = "dropdown" other["selected"] = "allow" other["values"] = [] value = {} value["Allow: Can be used as gateway/internet provider"] = "allow" other["values"].append(value) value = {} value[ "Force: Will be set as highest priority above anything else."] = "force" other["values"].append(value) value = {} value["Forbid: Will be ignored as internet provider"] = "forbid" other["values"].append(value) value = {} value[ "Reset: Reset to default (allow) or configured setting in the ini-files."] = "reset" other["values"].append(value) option["others"].append(other) # OTHERS other = {} other["name"] = "Failover" other["hint"] = "If current rule is not shown for the list items, " other[ "hint"] += "the interface should be currently be defaulted to allowed." other[ "hint"] += "<br><small>Keep in mind that the current rule state only gets " other["hint"] += "updated every 10 minutes (default value).</small>" other["type"] = "dropdown" other["values"] = [] parameter_rows = parameters['value']['PARAMETERS'].copy() failover_array = self.get_parameters_value(parameter_rows, r'FAILOVER\d') failover_array = sorted(failover_array, key=lambda i: i[0]) for f_arr in failover_array: value = {} value["{0} - {1} - {2}".format(f_arr[1]['INTERFACE'], f_arr[1]['DESCRIPTION'], f_arr[1]['GATEWAY'])] = f_arr[0] other["values"].append(value) if failover_array: f_arr = failover_array[0] other["selected"] = "{0}".format(f_arr[0]) option["others"].append(other) failover["options"].append(option) return failover def get_nc(self, parameters, ntwconf): """ NETWORK CONFIGURATION """ parameter_rows = parameters['value']['PARAMETERS'].copy() netconf = {} netconf["label"] = "Network Configuration" netconf["icon"] = "NetworkCheck" netconf["options"] = [] option = {} option["option"] = "Ping" option["description"] = "Ping an IP" option["others"] = [] # OTHERS other = {} other["name"] = "Number of pings" other["type"] = "dropdown" other["selected"] = 1 other["values"] = [] value = {} value['1'] = 1 other["values"].append(value) value = {} value['2'] = 2 other["values"].append(value) value = {} value['3'] = 3 other["values"].append(value) value = {} value['5'] = 5 other["values"].append(value) value = {} value['10'] = 10 other["values"].append(value) option["others"].append(other) # OTHERS other = {} other["name"] = "Destination IP" other["type"] = "input" option["others"].append(other) # OTHERS other = {} other["name"] = "Interface" other["type"] = "groupdropdown" other["selected"] = "" other["values"] = [] value = {} value['Not defined'] = [\ {"value": "", "label": "No specific interface (default)"} ] other["values"].append(value) ntwconf_rows = ntwconf['value']['NTWCONF'].copy() ntwconf_array = self.get_parameters_value(ntwconf_rows, r'enp\w*') ntwconf_array = sorted(ntwconf_array, key=lambda i: i[0]) value = {} value["Untagged"] = [] for ntconf in ntwconf_array: value["Untagged"].append({ "value": '-I ' + ntconf[0], "label": "{0}, {1}, {2}".format(ntconf[0], ntconf[1]['IP'], ntconf[1]['Netmask']) }) other["values"].append(value) ntwconf_array = self.get_parameters_value(ntwconf_rows, r'tun\d') ntwconf_array = sorted(ntwconf_array, key=lambda i: i[0]) value = {} value["Tunnels (VPN)"] = [] for ntconf in ntwconf_array: value["Tunnels (VPN)"].append({ "value": '-I ' + ntconf[0], "label": "{0}, {1}, {2}".format(ntconf[0], ntconf[1]['IP'], ntconf[1]['Netmask']) }) other["values"].append(value) ntwconf_array = self.get_parameters_value(parameter_rows, r'VLAN\d') ntwconf_array = sorted(ntwconf_array, key=lambda i: i[0]) value = {} value["VLAN's"] = [] for ntconf in ntwconf_array: description = "" if 'DESCRIPTION' in ntconf[1].keys(): description = ntconf[1]['DESCRIPTION'] value["VLAN's"].append({ "value": '-I' + ntconf[0], "label": "{0}, {1}, {2}".format(ntconf[0], description, ntconf[1]['IP']) }) other["values"].append(value) option["others"].append(other) netconf["options"].append(option) option = {} option["option"] = "Interfaces" option[ "description"] = "Check network-interfaces of OBU, including IP-addresses." option["others"] = [] # OTHERS other = {} other["name"] = "Method" other["type"] = "dropdown" other["selected"] = 'nmap --iflist' other["values"] = [] value = {} value["Nmap: Including routes"] = 'nmap --iflist' other["values"].append(value) value = {} value["Ip: New debian method"] = 'ip a' other["values"].append(value) value = {} value["Ifconfig: Old debian method"] = '/sbin/ifconfig' other["values"].append(value) option["others"].append(other) netconf["options"].append(option) option = {} option["option"] = "Routes" option["description"] = "Show routes, including gateways and metrics" option["others"] = [] # OTHERS other = {} other["name"] = "Method" other["type"] = "dropdown" other["selected"] = 'ip route' other["values"] = [] value = {} value["IP Route"] = 'ip route' other["values"].append(value) value = {} value["Route"] = '/sbin/route' other["values"].append(value) value = {} value["Nmap: Including interfaces"] = 'nmap --iflist' other["values"].append(value) value = {} value["Netstat: Kernel IP Routing table"] = 'netstat -r' other["values"].append(value) option["others"].append(other) netconf["options"].append(option) option = {} option["option"] = "Connections" option["description"] = "Show internet connections" option["others"] = [] # OTHERS other = {} other["name"] = "Method" other["type"] = "dropdown" other["selected"] = 'netstat -tp' other["values"] = [] value = {} value["Active internet connections"] = 'netstat -tp' other["values"].append(value) option["others"].append(other) netconf["options"].append(option) option = {} option["option"] = "Network statistics" option["description"] = "Show network statistics" option["others"] = [] # OTHERS other = {} other["name"] = "Method" other["type"] = "dropdown" other["selected"] = 'netstat -i' other["values"] = [] value = {} value["Netstat: Network statistics"] = 'netstat -i' other["values"].append(value) option["others"].append(other) netconf["options"].append(option) option = {} option["option"] = "Scan host" option["description"] = "Scan a host." option["others"] = [] # OTHERS other = {} other["name"] = "Host to scan" other["type"] = "input" other[ "hint"] = "Type IP-address (e.g. 192.168.0.1), can also have a subnet to" other["hint"] = " scan whole subnet (e.g. 192.168.0.1/24)" option["others"].append(other) # OTHERS other = {} other["name"] = "Please select an option:" other["type"] = "dropdown" other["selected"] = '-F' other["values"] = [] value = {} value["Fast scan"] = '-F' other["values"].append(value) value = {} value['Normal'] = "" other["values"].append(value) value = {} value["Ping scan"] = '-sP' other["values"].append(value) value = {} value["More output"] = '-v' other["values"].append(value) value = {} value["Even more output"] = '-vv' other["values"].append(value) option["others"].append(other) netconf["options"].append(option) return netconf def get_modem(self, vessel_id, device): """ MODEM """ modem = {} modem["label"] = device['device'] modem["icon"] = "Router" modem["options"] = [] option = {} option["option"] = "Reboot" option["description"] = "Reboot device" modem["options"].append(option) option = {} option["option"] = "Beam Lock" option["description"] = "Lock modem satellite" modem["options"].append(option) option = {} option["option"] = "Beam Switch" option["description"] = "Switch to another VSAT-Beam." option["others"] = [] # OTHERS other = {} other["name"] = "Please select the beam:" other["type"] = "dropdown" other["values"] = [] values = self.couch_query.get_complete_values(vessel_id, device['device'], flag='one_doc') general = values['value'][device['device']]['General'] selected_flag = False for gen in general.keys(): if re.findall(r'Beam\[\d*\]', str(gen)): num = gen[(gen.index('[') + 1):gen.index(']')] opt = str(general[gen]) + "(" + num + ")" value = {} value[opt] = num other["values"].append(value) if not selected_flag: other["selected"] = num selected_flag = True option["others"].append(other) modem["options"].append(option) option = {} option["option"] = "New Map" option["description"] = "Load new map for modem" modem["options"].append(option) option = {} option["option"] = "Remove Map" option["description"] = "Remove map for modem'" modem["options"].append(option) return modem def get_power_switch(self, vessel_id, device): """ POWERSWITCH """ power = {} power["label"] = device['device'] power["icon"] = "PowerInput" power["options"] = [] option = {} option["option"] = "Reboot Outlet" option["description"] = "Reboot outlet" option["others"] = [] # OTHERS other = {} other["name"] = "Outlet number" other["type"] = "dropdown" other["values"] = [] values = self.couch_query.get_complete_values(vessel_id, device['device'], flag='one_doc') outlets = list(values['value'][device['device']].keys()) outlets.remove('General') outlets.sort() selected_flag = False if outlets: for outlet in outlets: if re.findall(r'outlet\d', outlet): num = int(re.search(r'\d+', outlet).group()) val = {} # value[str(num)] = values['value'][device['device']][outlet]['name'] val[str(num) + ' - ' + values['value'][device['device']] [outlet]['name']] = num other["values"].append(val) if not selected_flag: other["selected"] = num selected_flag = True option["others"].append(other) power["options"].append(option) return power def get_item(self, devices, pattern): """Return Item""" data = [] for device in devices: if re.findall(r'' + pattern + r'\d', device['doc']['device']): data.append(device['doc']) data = sorted(data, key=lambda i: i['device']) return data def get_parameters_value(self, parameters, pattern): """Return Parameters Value""" values = [] for key in parameters.keys(): if re.findall(r'' + pattern, key): values.append([key, parameters[key]]) return values
class AlarmValues(Common): """Class for AlarmValues""" def __str__(self): """ test """ # INITIALIZE def __init__(self): """The Constructor for AlarmValues class""" self.postgres = PostgreSQL() self.couch_query = Queries() super(AlarmValues, self).__init__() def alarm_values(self): """ This API is for Getting Alarm Value --- tags: - Alarm Values produces: - application/json parameters: - name: token in: header description: Token required: true type: string - name: userid in: header description: User ID required: true type: string - name: limit in: query description: Limit required: true type: integer - name: page in: query description: Page required: true type: integer - name: sort_type in: query description: Sort Type required: false type: string - name: sort_column in: query description: Sort Column required: false type: string - name: filter_column in: query description: Filter Column required: false type: string - name: filter_value in: query description: Filter Value required: false type: string responses: 500: description: Error 200: description: Alarm Value """ data = {} # GET DATA token = request.headers.get('token') userid = request.headers.get('userid') page = int(request.args.get('page')) limit = int(request.args.get('limit')) sort_type = request.args.get('sort_type') sort_column = request.args.get('sort_column') filter_column = request.args.get('filter_column') filter_value = request.args.get('filter_value') # CHECK TOKEN token_validation = self.validate_token(token, userid) if not token_validation: data["alert"] = "Invalid Token" data['status'] = 'Failed' # RETURN ALERT return self.return_data(data) if filter_column and filter_value: filter_list = [] for col in filter_column.split(","): filter_list.append(col) filter_val = [] for val in filter_value.split(","): filter_val.append(val) filter_value = tuple(filter_val) else: filter_list = filter_column data['data'] = [] total_page = 0 #GET DATA datas = self.get_alarm_values() for dta in datas['rows']: vessels = dta['vessel'] vessel_number = self.get_alarm_vessel_name(vessels) if not vessel_number: dta['vessel_name'] = '' else: dta['vessel_name'] = ", ".join(vessel_number) if datas: rows = self.param_filter(datas['rows'], filter_value, checklist=filter_list) if sort_type and sort_column: sort_column = sort_column.lower() if sort_type.lower() == "desc" and sort_column in [ 'name', 'vessel', 'device', 'device_type', 'module', 'option', 'value' ]: rows = sorted(rows, key=lambda i: i[sort_column], reverse=True) if sort_type.lower() == "asc": rows = sorted(rows, key=lambda i: i[sort_column]) else: rows = [] datas = self.limits(rows, limit, page) #datas = self.get_alarm_vessel_name(datas) total_count = len(rows) total_page = int(math.ceil(int(total_count - 1) / limit)) data = self.common_return(datas, total_page, limit, page, total_count) data['status'] = 'ok' return self.return_data(data) def get_alarm_values(self): """Return Alarm Values""" # DATA sql_str = "SELECT * FROM alarm_value" datas = self.postgres.query_fetch_all(sql_str) data = {} data['rows'] = datas return data # GET ALARM VALUE def get_alarm_value(self, alarm_value_id): """Return Alarm Value""" assert alarm_value_id, "Alarm Value ID is required." # DATA alarm_value = [] sql_str = "SELECT * FROM alarm_value WHERE alarm_value_id={0}".format( alarm_value_id) alarm_value = self.postgres.query_fetch_one(sql_str) data = {} data['rows'] = alarm_value return data def get_alarm_vessel_name(self, vessels): """Return Alarm Vessel Name""" vessel_number = [] if vessels: for vessel in vessels.split(","): values = self.couch_query.get_complete_values( vessel, "PARAMETERS") if values: vessel_name = values['PARAMETERS']['INFO']['VESSELNAME'] else: vessel_name = "Vessel Not Found" vessel_number.append(vessel_name) return vessel_number return 0
class Vessels(Common): """Class for Vessels""" # INITIALIZE def __init__(self): """The Constructor for Vessels class""" self._couch_db = CouchDatabase() self.couch_query = Queries() self.postgres = PostgreSQL() self.epoch_default = 26763 self.vessel_name = "" self.aws3 = AwsS3() # INIT CONFIG self.config = ConfigParser() # CONFIG FILE self.config.read("config/config.cfg") self.vpn_db_build = config_section_parser(self.config, "VPNDB")['build'] super(Vessels, self).__init__() # GET VESSEL FUNCTION def all_vessels(self): """ This API is for Getting Vessels --- tags: - Vessel produces: - application/json parameters: - name: token in: header description: Token required: true type: string - name: userid in: header description: User ID required: true type: string - name: vessel_number in: query description: Vessel Number required: false type: string - name: limit in: query description: Limit required: true type: integer - name: page in: query description: Page required: true type: integer - name: sort_type in: query description: Sort Type required: false type: string - name: sort_column in: query description: Sort Column required: false type: string - name: filter_column in: query description: Filter Column required: false type: string - name: filter_value in: query description: Filter Value required: false type: string responses: 500: description: Error 200: description: Vessel Information """ # INIT DATA data = {} # VESSEL ID vessel_number = request.args.get('vessel_number') limit = int(request.args.get('limit')) page = int(request.args.get('page')) sort_type = request.args.get('sort_type') sort_column = request.args.get('sort_column') filter_column = request.args.get('filter_column') filter_value = request.args.get('filter_value') vessels = [] # GET DATA token = request.headers.get('token') userid = request.headers.get('userid') # CHECK TOKEN token_validation = self.validate_token(token, userid) if not token_validation: data["alert"] = "Invalid Token" data['status'] = 'Failed' # RETURN ALERT return self.return_data(data) sql_str = "SELECT * FROM vessel " if not vessel_number: # COUCH QUERY - GET VESSELS offset = int((page - 1) * limit) # LIMIT TO ONE COLUMN if filter_column and filter_value: sql_str += " WHERE {0}='{1}'".format(filter_column, filter_value) if sort_column and sort_type: if sort_column in ['vessel_name']: sql_str += " ORDER BY {0} {1}".format( sort_column, sort_type.upper()) else: sql_str += " ORDER BY vessel_name ASC" sql_str += " LIMIT {0} OFFSET {1}".format(limit, offset) vessels = self.postgres.query_fetch_all(sql_str) else: # COUCH QUERY - GET VESSEL sql_str += "WHERE number='{0}'".format(vessel_number) vessels = self.postgres.query_fetch_all(sql_str) # CHECK DATABASES rows = [] if vessels: vessel_ids = [x['vessel_id'] for x in vessels] # INIT SQL QUERY if len(vessel_ids) == 1: sql_str = "SELECT * FROM vessel WHERE state ='1'" sql_str += " AND vessel_id IN ('{0}')".format(vessel_ids[0]) else: sql_str = "SELECT * FROM vessel WHERE state ='1'" sql_str += " AND vessel_id IN {0}".format(tuple(vessel_ids)) # FETCH ALL vessels_state = self.postgres.query_fetch_all(sql_str) to_be_install = [x['vessel_id'] for x in vessels_state] # INIT VARIABLES # LOOP DATABASES for item in vessels: row = {} # CONNECT TO DATABASE # GET VESSEL NAME # VESSEL POSIBLE STATE # To be installed = 1 # Installed and etc. = 2 vessel_name = self.get_vessel_name(item['vessel_id'], item['number']) self.vessel_name = vessel_name mail_enable = self.get_email_schedule(item['vessel_id']) last_update = self.get_last_update_with_option( item['vessel_id']) epoch_time = int(time.time()) update_state = 'red' if not item['vessel_id'] == item['number']: update_state = self.check_time_lapse( epoch_time, last_update) vpn_url = self.get_vpn_url(item['number']) version_name, version_id = self.get_version(item['vessel_id']) # SET THE RETURN VALUE row['vessel_id'] = item['vessel_id'] row['vessel_rev'] = self.get_rev_id(item['vessel_id'], item['number']) row['vessel_number'] = item['number'] row['vessel_name'] = vessel_name row['mail_enable'] = mail_enable['mail_enable'] row['schedules'] = mail_enable['schedules'] row['emails'] = mail_enable['emails'] row['update_state'] = update_state row['version_name'] = version_name row['version_id'] = version_id row['vpn_url'] = vpn_url # GET IMAGE URL row['image_url'] = self.aws3.get_vessel_image( item['vessel_id']) if item['vessel_id'] in to_be_install: row['update_state'] = 'white' rows.append(row) sql_str = "SELECT COUNT(*) FROM vessel" count = self.postgres.query_fetch_one(sql_str) total_rows = count['count'] total_page = int(math.ceil(int(total_rows - 1) / limit)) + 1 # SET RETURN data['rows'] = rows data['status'] = 'ok' data['limit'] = int(limit) data['page'] = int(page) data['total_rows'] = total_rows data['total_page'] = total_page data['vessel_names'] = self.get_vessel_names() # RETURN return self.return_data(data) # GET THE VESSEL NAME def get_vessel_name(self, vessel_id, number): """Return Vessel Name""" if vessel_id == number: vessel_name = "" if self.vpn_db_build.upper() == 'TRUE': sql_str = "SELECT vessel_name FROM vessel_vpn_job WHERE imo='{0}' ".format( number) sql_str += "AND vpn_type='VESSEL' ORDER BY created_on DESC LIMIT 1" vname = self.postgres.query_fetch_one(sql_str) vessel_name = vname['vessel_name'] else: sql_str = "SELECT vessel_name FROM vessel WHERE number='{0}'".format( number) vname = self.postgres.query_fetch_one(sql_str) vessel_name = vname['vessel_name'] return vessel_name values = self.couch_query.get_complete_values(vessel_id, "PARAMETERS") if values: return values['PARAMETERS']['INFO']['VESSELNAME'] return '' def get_limits(self, option_ids, limit, page): """Return Limits""" skip = int((page - 1) * limit) limit = skip + limit return option_ids[skip:limit] def get_email_schedule(self, vessel_id): """Return Email Schedule""" # SQL QUERY cols = 'email_vessel_id, mail_enable, email' sql_str = "SELECT " + cols + " FROM email_vessel" sql_str += " WHERE vessel_id='{}'".format(vessel_id) # FETCH ONE email_vessels = self.postgres.query_fetch_all(sql_str) data = {} data['emails'] = [] data['schedules'] = [] data['mail_enable'] = False if email_vessels: mail_enable = email_vessels[0]['mail_enable'] email_vessel_id = email_vessels[0]['email_vessel_id'] # SQL QUERY cols = 'schedule' sql_str = "SELECT " + cols + " FROM email_schedule" sql_str += " WHERE email_vessel_id='{}'".format(email_vessel_id) schedules = self.postgres.query_fetch_all(sql_str) data['emails'] = (list(map(lambda x: x['email'], email_vessels))) data['schedules'] = (list(map(lambda x: x['schedule'], schedules))) data['mail_enable'] = mail_enable return data def get_last_update_with_option(self, vessel_id): """Return Last Update with Option""" values = self.couch_query.get_complete_values(vessel_id, "COREVALUES", flag='one_doc') if values: return values['timestamp'] return '' def get_vpn_url(self, vessel_number): """ GET VPN URL """ vpn_url = "" sql_str = "SELECT * FROM vessel_vpn_job WHERE" sql_str += " imo='{0}' AND status='active'".format(vessel_number) job = self.postgres.query_fetch_one(sql_str) if job: filename = job['directory'].split("/")[-1] created_on = job['created_on'] # vpn_url = "download/vpn/{0}".format(filename) vpn_url = "download/vessel/vpn/{0}_{1}".format( created_on, filename) return vpn_url def get_rev_id(self, vessel_id, vessel_number): """ GET REV ID """ if vessel_id == vessel_number: return vessel_id vessel = self.couch_query.get_vessels(vessel_number=vessel_number) if vessel: return vessel[0]['doc']['_rev'] return 0 def get_vessel_names(self): """ RETURN VESSEL NAMES """ # DATA sql_str = "SELECT array_to_json(array_agg(vessel_name)) as vessel FROM vessel" data = self.postgres.query_fetch_one(sql_str) vessels = [] if data: for vessel in data['vessel']: vessels.append({"label": vessel, "value": vessel}) return vessels def get_version(self, vessel_id): """ GET VESSEL """ sql_str = "SELECT version.version_name, version.version_id FROM version INNER JOIN" sql_str += " vessel_version ON vessel_version.version_id=version.version_id" sql_str += " WHERE vessel_version.vessel_id='{0}'".format(vessel_id) version = self.postgres.query_fetch_one(sql_str) if version: return [version['version_name'], version['version_id']] return ["", ""]
class Vessel(Common): """Class for Vessel""" # INITIALIZE def __init__(self): """The Constructor for Vessel class""" # self._my_db = MySQLDatabase() self._couch_db = CouchDatabase() self.couch_query = Queries() self.postgres = PostgreSQL() self.epoch_default = 26763 self.aws3 = AwsS3() super(Vessel, self).__init__() # # INIT CONFIG # self.config = ConfigParser.ConfigParser() # # CONFIG FILE # self.config.read("config/config.cfg") # GET VESSEL FUNCTION def get_vessels_data(self): """ This API is for Getting Vessel Information --- tags: - Vessel produces: - application/json parameters: - name: token in: header description: Token required: true type: string - name: userid in: header description: User ID required: true type: string - name: vessel_ids in: query description: Vessels IDs required: false type: string responses: 500: description: Error 200: description: Vessel Information """ # INIT DATA data = {} # GET DATA token = request.headers.get('token') userid = request.headers.get('userid') # CHECK TOKEN token_validation = self.validate_token(token, userid) if not token_validation: data["alert"] = "Invalid Token" data['status'] = 'Failed' # RETURN ALERT return self.return_data(data) # GET ADMIN ROLE AND SUPER ADMIN ROLE sql_str = "SELECT role_id FROM role WHERE role_name in ('admin', 'super admin')" l_ids = self.postgres.query_fetch_all(sql_str) role_ids = [x['role_id'] for x in l_ids] str_ids = "" if len(role_ids) == 1: str_ids = "(" + str(role_ids[0]) + ")" else: str_ids = str(tuple(role_ids)) # CREATE SQL QUERY # GET ADMIN ACCOUNT sql_str = "SELECT * FROM account_role where account_id='" + str(userid) sql_str += "' AND role_id in " + str_ids res = self.postgres.query_fetch_one(sql_str) # EXTRACT VESSELS ID extracted_vessel_ids = request.args.get('vessel_ids') vessels = [] if res: if extracted_vessel_ids: for vessel_id in extracted_vessel_ids.split(","): res = self.couch_query.get_by_id(vessel_id) if res: ves = {} ves['id'] = res['_id'] ves['key'] = res['number'] vessels.append(ves) else: vessels = self.couch_query.get_vessels() else: vessel_ids = [] try: if not extracted_vessel_ids: # EMPTY vessel_ids = [] else: vessel_ids = extracted_vessel_ids.split(",") except: data["alert"] = "Invalid Vessel IDs" data['status'] = 'Failed' # RETURN ALERT return self.return_data(data) company_ids = self.get_company_id(userid) if not company_ids: data["message"] = "User Doesn't belong to any company." data['rows'] = [] data['status'] = 'ok' # RETURN ALERT return self.return_data(data) # ACCOUNT'S AVAILABLE VESSELS company_vessel_ids = self.get_company_vessels(company_ids)['rows'] #FILTER VESSELS TO GET vessels_to_get = [] if not vessel_ids: vessels_to_get = company_vessel_ids else: for vessel_id in vessel_ids: # found_vessel = None for company_vessel in company_vessel_ids: if vessel_id == company_vessel['vessel_id']: vessels_to_get.append(company_vessel) break if len(vessels_to_get) != len(vessel_ids): data["alert"] = "Some Vessel are not belong to this user." data['status'] = 'Failed' # RETURN ALERT return self.return_data(data) temp_ids = [] for vessel_id in vessels_to_get: if vessel_id['vessel_id'] not in temp_ids: temp_ids.append(vessel_id['vessel_id']) res = self.couch_query.get_by_id(vessel_id['vessel_id']) if res: ves = {} ves['id'] = res['_id'] ves['key'] = res['number'] vessels.append(ves) # CHECK DATABASES rows = [] if vessels: vessel_ids = [x['id'] for x in vessels] # INIT SQL QUERY if len(vessel_ids) == 1: sql_str = "SELECT * FROM vessel WHERE state ='1'" sql_str += " AND vessel_id IN ('{0}')".format(vessel_ids[0]) else: sql_str = "SELECT * FROM vessel WHERE state ='1'" sql_str += " AND vessel_id IN {0}".format(tuple(vessel_ids)) # FETCH ALL vessels_state = self.postgres.query_fetch_all(sql_str) to_be_install = [x['vessel_id'] for x in vessels_state] # LOOP DATABASES for item in vessels: row = {} # GET VESSEL NAME vessel_name = self.get_vessel_name(item['id']) # self.vessel_name = vessel_name # GET LONGITUDE AND LATITUDE long_lat = self.get_long_lat(item['id']) if long_lat: # get nearest land from ocean to land google map # GET the nearest landmass # https://stackoverflow.com/questions/41539432/google-maps-reverse- # geocoding-api-returns-nearest-land-address-given-a-latlng-in row['long'] = long_lat['long'] row['lat'] = long_lat['lat'] row['position_source'] = long_lat['position_source'] else: row['long'] = 0 row['lat'] = 0 row['position_source'] = "" # GET HEADING heading, speed = self.get_heading(item['id']) if heading: row['heading'] = float(heading['heading']) row['heading_source'] = heading['heading_source'] else: row['heading_source'] = "" row['heading'] = 0 if speed: row['speed'] = float(speed) # GET UPDATE STATE last_update = self.get_last_update_with_option(item['id']) epoch_time = int(time.time()) update_state = self.check_time_lapse(epoch_time, last_update) # SET THE RETURN VALUE row['isOpen'] = False row['vessel_id'] = item['id'] row['vessel_number'] = item['key'] row['vessel_name'] = vessel_name row['company'] = self.get_vessel_company(item['id']) row['update_state'] = update_state # GET IMAGE URL row['image_url'] = self.aws3.get_vessel_image(item['id']) if item['id'] in to_be_install: row['update_state'] = 'white' rows.append(row) # SORT VESSELS ALPHABETICALLY rows = sorted(rows, key=lambda i: i['vessel_name'].upper()) # SET RETURN data['rows'] = rows data['companies'] = self.get_vessels_company() data['status'] = 'ok' # RETURN return self.return_data(data) # GET THE VESSEL NAME def get_vessel_name(self, vessel_id): """Return Vessel Name""" values = self.couch_query.get_complete_values(vessel_id, "PARAMETERS") if values: return values['PARAMETERS']['INFO']['VESSELNAME'] return '' def get_long_lat(self, vessel_id): """Return Longitude Latitude""" all_devices = self.couch_query.get_all_devices(vessel_id) devices = [] source = 'MODEM' if all_devices: devices = self.get_device(all_devices, source) devices_info = 0 if devices: devices_info = self.device_data(source, devices, vessel_id) if not devices_info: source = 'VSAT' devices = self.get_device(all_devices, source) if devices: devices_info = self.device_data(source, devices, vessel_id) if not devices_info: source = 'IOP' devices = self.get_device(all_devices, source) if devices: devices_info = self.device_data(source, devices, vessel_id) if not devices_info: source = 'NMEA' devices = self.get_device(all_devices, source) if devices: devices_info = self.device_data(source, devices, vessel_id) if not devices_info: source = 'SATC' devices = self.get_device(all_devices, source) if devices: devices_info = self.device_data(source, devices, vessel_id) if not devices_info: source = 'VHF' devices = self.get_device(all_devices, source) if devices: devices_info = self.device_data(source, devices, vessel_id) return devices_info return 0 def get_device(self, devices, pattern): """Return Device""" data = [] for device in devices: if re.findall(r'' + pattern + r'\d', device['doc']['device']): data.append(device['doc']) data = sorted(data, key=lambda i: i['device']) return data def get_heading(self, vessel_id): """Return Heading""" all_devices = self.couch_query.get_all_devices(vessel_id) source = 'VSAT' devices = self.get_device(all_devices, source) data = {} speed = 0 for device in devices: values = self.couch_query.get_complete_values( vessel_id, device['device']) if values: # GET DEVICE NUMBER number = device['device'].split(source)[1] # GET DEVICE COMPLETE NAME heading_source = self.device_complete_name(source, number) # SET RETURN data['heading'] = values[ device['device']]['General']['Heading'] data['heading_source'] = heading_source # RETURN # return [data, 0] source = 'NMEA' devices = self.get_device(all_devices, source) for device in devices: values = self.couch_query.get_complete_values( vessel_id, device['device']) if values: # GET DEVICE NUMBER number = device['device'].split(source)[1] # GET DEVICE COMPLETE NAME heading_source = self.device_complete_name(source, number) gen = values[device['device']].keys() if 'GP0001' in gen: gp0001 = values[device['device']]['GP0001'] # SET RETURN if not data: data['heading'] = gp0001['VTG'][ 'courseOverGroundTrueDegrees'] data['heading_source'] = heading_source speed = gp0001['VTG']['speedOverGroundKnots'] # RETURN return [data, speed] def get_last_update_with_option(self, vessel_id): """Return Last Update with option""" values = self.couch_query.get_complete_values(vessel_id, "COREVALUES", flag='one_doc') if values: return values['timestamp'] return '' def get_company_id(self, userid): """Return Company ID""" sql_str = "select company_id from account_company where account_id = {}".format( userid) res = self.postgres.query_fetch_all(sql_str) return res if res else 0 # GET VESSELS OF COMPANY def get_company_vessels(self, company_ids): """Return Company Vessels""" assert company_ids, "CompanyID is required." # DATA vessels = [] for company_id in company_ids: sql_str = "SELECT * FROM company_vessels" sql_str += " WHERE company_id={0}".format(company_id['company_id']) res = self.postgres.query_fetch_all(sql_str) if res: vessels = vessels + res data = {} data['rows'] = vessels return data def device_data(self, source, devices, vessel_id): """Return Device Data""" for device in devices: values = self.couch_query.get_complete_values( vessel_id, device['device']) if values: try: # GET DEVICE NUMBER number = device['device'].split(source)[1] # GET DEVICE COMPLETE NAME position_source = self.device_complete_name(source, number) # SET RETURN data = {} if source == 'NMEA': lnp = values[ device['device']]['GP0001']['GGA']['eastWest'] ltp = values[ device['device']]['GP0001']['GGA']['northSouth'] ln1 = values[ device['device']]['GP0001']['GGA']['longitude'] lt1 = values[ device['device']]['GP0001']['GGA']['latitude'] longitude = float(ln1) lat = float(lt1) lat /= 100. dec_lat, degrees_lat = math.modf(lat) dec_lat *= 100. dev_lat = degrees_lat + dec_lat / 60 longitude /= 100. dec_long, degrees_long = math.modf(longitude) dec_long *= 100. dev_long = degrees_long + dec_long / 60 data['lat'] = "%.4f" % float(dev_lat) data['long'] = "%.4f" % float(dev_long) if ltp == 'S': data['lat'] = "-" + str(data['lat']) if lnp == 'W': data['long'] = "-" + str(data['long']) elif source == 'SATC': lat_dir = values[ device['device']]['General']['latitudeDirection'] lon_dir = values[ device['device']]['General']['longitudeDirection'] lat = values[device['device']]['General']['latitude'] lon = values[device['device']]['General']['longitude'] lon_val = ''.join(lon.rsplit('.', 1)) if lon_dir == 'W': lon_val = "-" + lon_val lat_val = ''.join(lat.rsplit('.', 1)) if lat_dir == 'S': lat_val = "-" + lat_val data['long'] = lon_val data['lat'] = lat_val elif source == 'VHF': lat = values[device['device']]['General']['latitude'] lon = values[device['device']]['General']['longitude'] lon_val = str(lon[1:]) lon_val = lon_val.replace('.', '') lon_val = lon_val.replace(',', '.') if lon[0] == 'W': lon_val = "-" + lon_val lat_val = str(lat[1:]) lat_val = lat_val.replace('.', '') lat_val = lat_val.replace(',', '.') if lat[0] == 'S': lat_val = "-" + lat_val data['long'] = lon_val data['lat'] = lat_val else: data['long'] = values[ device['device']]['General']['Longitude'] data['lat'] = values[ device['device']]['General']['Latitude'] data['position_source'] = position_source # RETURN return data except: continue return 0 def get_vessel_company(self, vessel_id): """Return Company by Vessel ID""" assert vessel_id, "Vessel ID is required." data = [] sql_str = "SELECT * FROM company_vessels cv" sql_str += " LEFT JOIN company c ON cv.company_id = c.company_id" sql_str += " WHERE vessel_id='{0}'".format(vessel_id) result = self.postgres.query_fetch_all(sql_str) if result: for res in result: data.append({ 'company_id': res['company_id'], 'company_name': res['company_name'] }) return data def get_vessels_company(self): """ Return Vessel List by Company """ sql_str = "SELECT v.vessel_id, v.vessel_name, cv.company_id, c.company_name FROM vessel v" sql_str += " LEFT JOIN company_vessels cv ON v.vessel_id=cv.vessel_id" sql_str += " LEFT JOIN company c ON cv.company_id = c.company_id" sql_str += " GROUP BY v.vessel_id, cv.company_id,c.company_id" sql_str += " ORDER BY c.company_name" results = self.postgres.query_fetch_all(sql_str) data = {} if results: for result in results: if result['company_name'] is None: company = "Others" else: company = result['company_name'] formatted = [{ 'vessel_id': result['vessel_id'], 'vessel_name': result['vessel_name'] }] if company in data: data[company].append(formatted) else: data[company] = formatted return data
class UpdateUser(Common): """Class for UpdateUser""" # INITIALIZE def __init__(self): """The Constructor for UpdateUser class""" # INIT CONFIG self.config = ConfigParser() # CONFIG FILE self.config.read("config/config.cfg") self._couch_db = CouchDatabase() self.couch_query = Queries() self.postgres = PostgreSQL() self.vpn_db_build = config_section_parser(self.config, "VPNDB")['build'] super(UpdateUser, self).__init__() if self.vpn_db_build.upper() == 'TRUE': self.my_ip = config_section_parser(self.config, "IPS")['my'] self.my_protocol = config_section_parser(self.config, "IPS")['my_protocol'] self.user_vpn = config_section_parser(self.config, "IPS")['user_vpn'] self.user_protocol = config_section_parser(self.config, "IPS")['user_protocol'] self.vessel_vpn = config_section_parser(self.config, "IPS")['vessel_vpn'] self.vessel_protocol = config_section_parser( self.config, "IPS")['vessel_protocol'] self.vpn_token = '269c2c3706886d94aeefd6e7f7130ab08346590533d4c5b24ccaea9baa5211ec' def update_user(self): """ This API is for Updating User --- tags: - User produces: - application/json parameters: - name: token in: header description: Token required: true type: string - name: userid in: header description: User ID required: true type: string - name: query in: body description: Updating User required: true schema: id: Updating User properties: account_id: type: string username: type: string password: type: string status: type: boolean first_name: type: string last_name: type: string middle_name: type: string url: type: string email: type: string companies: types: array example: [] roles: types: array example: [] vessels: types: array example: [] responses: 500: description: Error 200: description: Updating User """ data = {} # GET JSON REQUEST query_json = request.get_json(force=True) # GET HEADER token = request.headers.get('token') userid = request.headers.get('userid') # CHECK TOKEN token_validation = self.validate_token(token, userid) if not token_validation: data["alert"] = "Invalid Token" data['status'] = 'Failed' # RETURN ALERT return self.return_data(data) if not self.update_users(query_json): data["alert"] = "Please check your query!" data['status'] = 'Failed' # RETURN ALERT return self.return_data(data) data['message'] = "User successfully updated!" data['status'] = "ok" return self.return_data(data) def update_users(self, query_json): """Update Users""" # GET CURRENT TIME query_json['update_on'] = time.time() account_id = query_json['account_id'] # GET SUPER ADMIN ACCOUNT sa_role = self.get_sa_role(account_id) superadmin = self.get_super_admin() roles = [] companies = [] vessels = [] if 'roles' in query_json.keys(): roles = query_json['roles'] if 'companies' in query_json.keys(): companies = query_json['companies'] if 'vessels' in query_json.keys(): vessels = query_json['vessels'] status = self.get_user_status(account_id) if status and self.vpn_db_build.upper() == 'TRUE': # Client -> Super admin if superadmin['role_id'] in roles and not sa_role: self.delete_vpn_allow(account_id) self.create_vpn(account_id, 'super admin') # Super admin -> Client elif not superadmin['role_id'] in roles and sa_role: self.delete_vpn_allow(account_id, 'super admin') self.create_vpn(account_id) # UPDATE # INIT CONDITION conditions = [] # CONDITION FOR QUERY conditions.append({"col": "id", "con": "=", "val": account_id}) # REMOVE KEYS query_json = self.remove_key(query_json, "account_id") query_json = self.remove_key(query_json, "roles") query_json = self.remove_key(query_json, "companies") query_json = self.remove_key(query_json, "vessels") # UPDATE ROLE if self.postgres.update('account', query_json, conditions): # INIT CONDITION conditions = [] # CONDITION FOR QUERY conditions.append({ "col": "account_id", "con": "=", "val": account_id }) # ROLES if roles: # DELETE OLD PERMISSION self.postgres.delete('account_role', conditions) # LOOP NEW PERMISSIONS for role_id in roles: # INIT NEW PERMISSION temp = {} temp['account_id'] = account_id temp['role_id'] = role_id # INSERT NEW PERMISSION OF ROLE self.postgres.insert('account_role', temp) # COMPANIES if companies: # DELETE OLD COMPANY self.postgres.delete('account_company', conditions) # LOOP NEW COMPANIES for company_id in companies: # INIT NEW COMPANY temp = {} temp['account_id'] = account_id temp['company_id'] = company_id # INSERT NEW COMPANY self.postgres.insert('account_company', temp) # VESSELS if vessels: # DELETE OLD VESSELS self.postgres.delete('account_vessel', conditions) # REMOVE VNP ACCESS ON VESSEL FLAG vpn_acces = True # LOOP NEW VESSELS for vessel in vessels: ntwconf = self.couch_query.get_complete_values( vessel['vessel_id'], "NTWCONF") # INIT NEW VESSEL temp = {} temp['vessel_vpn_ip'] = ntwconf['NTWCONF']['tun1']['IP'] temp['account_id'] = account_id temp['vessel_id'] = vessel['vessel_id'] temp['allow_access'] = vessel['allow_access'] temp['vessel_vpn_state'] = 'pending' # INSERT NEW ACCOUNT VESSEL self.postgres.insert('account_vessel', temp) if not vessel['allow_access']: vpn_acces = False if status and self.vpn_db_build.upper() == 'TRUE': if not vpn_acces or sa_role: callback_url = self.my_protocol + "://" + self.my_ip + "/vpn/update" data_url = self.my_protocol + "://" + self.my_ip + "/vpn/data" vpn_type = 'VCLIENT' # INSERT JOB job_id = self.insert_job(callback_url, data_url, self.vpn_token, account_id, self.vessel_vpn, 'REMOVE', vpn_type) # INIT PARAMS FOR REMOVE VPN vpn_params = {} vpn_params['callback_url'] = callback_url vpn_params['data_url'] = data_url vpn_params['job_id'] = job_id self.remove_vpn_ip(vpn_params, self.vpn_token, True) # RETURN return 1 # RETURN return 0 def remove_vpn_ip(self, data, vpn_token, flag=False): """Remove VPN IP""" api_endpoint = self.user_protocol + "://" + self.user_vpn + "/ovpn" if flag: api_endpoint = self.vessel_protocol + "://" + self.vessel_vpn + "/ovpn" headers = {'content-type': 'application/json', 'token': vpn_token} req = requests.post(api_endpoint, data=json.dumps(data), headers=headers) res = req.json() return res def insert_job(self, callback_url, data_url, vpn_token, account_id, user_vpn, action, vpn_type): """Insert Job""" update_on = time.time() # INIT NEW JOB temp = {} temp['callback_url'] = callback_url temp['vnp_server_ip'] = user_vpn temp['data_url'] = data_url temp['token'] = vpn_token temp['status'] = 'pending' temp['account_id'] = account_id temp['vpn_type'] = vpn_type temp['action'] = action temp['account_os'] = 'WINDOWS' # LINUX temp['update_on'] = update_on temp['created_on'] = update_on # INSERT NEW JOB job_id = self.postgres.insert('job', temp, 'job_id') return job_id def get_sa_role(self, account_id): """Return Super Admin Role""" sql_str = "SELECT * FROM account_role where account_id='{0}' ".format( account_id) sql_str += "AND role_id in (SELECT role_id FROM role " sql_str += "WHERE role_name='super admin')" account = self.postgres.query_fetch_one(sql_str) return account def get_super_admin(self): """Return Super Admin""" sql_str = "SELECT * FROM role WHERE role_name='super admin'" super_admin = self.postgres.query_fetch_one(sql_str) return super_admin def delete_vpn_allow(self, account_id, super_admin=False): """Delete VPN Allow""" if self.vpn_db_build.upper() == 'TRUE': callback_url = self.my_protocol + "://" + self.my_ip + "/vpn/update" data_url = self.my_protocol + "://" + self.my_ip + "/vpn/data" vpn_token = '269c2c3706886d94aeefd6e7f7130ab08346590533d4c5b24ccaea9baa5211ec' vpn_type = 'VCLIENT' cvpn_type = 'CLIENT' # SUPER ADMIN TO CLIENT if super_admin: vpn_type = 'VRH' cvpn_type = 'RHADMIN' # CLIENT # INSERT JOB job_id = self.insert_job(callback_url, data_url, vpn_token, account_id, self.user_vpn, 'DELETE', cvpn_type) # INIT PARAMS FOR UPDATE VPN vpn_params = {} vpn_params['callback_url'] = callback_url vpn_params['data_url'] = data_url vpn_params['job_id'] = job_id # UPDATE VPN self.update_vpn(vpn_params, vpn_token) # VESSEL if self.get_user_vessels(account_id) or super_admin: # print("DELETE VCLIENT/VHR VPN") # INSERT JOB job_id = self.insert_job(callback_url, data_url, vpn_token, account_id, self.vessel_vpn, 'DELETE', vpn_type) # INIT PARAMS FOR UPDATE VPN vpn_params = {} vpn_params['callback_url'] = callback_url vpn_params['data_url'] = data_url vpn_params['job_id'] = job_id # UPDATE VPN self.update_vpn(vpn_params, vpn_token, True) conditions = [] conditions.append({"col": "id", "con": "=", "val": account_id}) query_json = {} query_json['status'] = False if self.postgres.update('account', query_json, conditions): return 1 return 0 def create_vpn(self, account_id, super_admin=False): """Create VPN""" query_json = {} query_json['status'] = True if self.vpn_db_build.upper() == 'TRUE': # JOB DATAS callback_url = self.my_protocol + "://" + self.my_ip + "/vpn/update" data_url = self.my_protocol + "://" + self.my_ip + "/vpn/data" vpn_token = '269c2c3706886d94aeefd6e7f7130ab08346590533d4c5b24ccaea9baa5211ec' vpn_type = 'VCLIENT' cvpn_type = 'CLIENT' if super_admin: vpn_type = 'VRH' cvpn_type = 'RHADMIN' # INSERT JOB job_id = self.insert_job(callback_url, data_url, vpn_token, account_id, self.user_vpn, 'CREATE', cvpn_type) # INIT PARAMS FOR CREATE VPN vpn_params = {} vpn_params['callback_url'] = callback_url vpn_params['data_url'] = data_url vpn_params['job_id'] = job_id # CREATE VPN self.new_vpn(vpn_params, vpn_token, False) # VESSEL if self.get_user_vessels(account_id) or super_admin: # INSERT JOB job_id = self.insert_job(callback_url, data_url, vpn_token, account_id, self.vessel_vpn, 'CREATE', vpn_type) # INIT PARAMS FOR CREATE VPN vpn_params = {} vpn_params['callback_url'] = callback_url vpn_params['data_url'] = data_url vpn_params['job_id'] = job_id # CREATE VPN self.update_vpn(vpn_params, vpn_token, True) conditions = [] conditions.append({"col": "id", "con": "=", "val": account_id}) if self.postgres.update('account', query_json, conditions): return 1 return 0 def update_vpn(self, data, vpn_token, flag=False): """Update VPN""" api_endpoint = self.user_protocol + "://" + self.user_vpn + "/ovpn" if flag: api_endpoint = self.vessel_protocol + "://" + self.vessel_vpn + "/ovpn" headers = {'content-type': 'application/json', 'token': vpn_token} req = requests.post(api_endpoint, data=json.dumps(data), headers=headers) res = req.json() return res def new_vpn(self, data, vpn_token, flag=False): """New VPN""" api_endpoint = self.user_protocol + "://" + self.user_vpn + "/ovpn" if flag: api_endpoint = self.vessel_protocol + "://" + self.vessel_vpn + "/ovpn" headers = {'content-type': 'application/json', 'token': vpn_token} req = requests.post(api_endpoint, data=json.dumps(data), headers=headers) res = req.json() return res def get_user_vessels(self, account_id): """Return User Vessels""" sql_str = "SELECT * FROM account_vessel WHERE account_id={0}".format( account_id) avs = self.postgres.query_fetch_all(sql_str) if avs: for acct in avs: if acct['allow_access']: return 1 return 0 def get_user_status(self, account_id): """Return User Status""" sql_str = "SELECT status FROM account WHERE id={0}".format(account_id) account = self.postgres.query_fetch_one(sql_str) return account['status']
class VPNIPUpdate(Common): """Class for VPNIPUpdate""" # INITIALIZE def __init__(self): """The Constructor for VPNIPUpdate class""" # INIT CONFIG self.config = ConfigParser() # CONFIG FILE self.config.read("config/config.cfg") self.couch_query = Queries() self.postgres = PostgreSQL() self.epoch_default = 26763 self.vpn_db_build = config_section_parser(self.config, "VPNDB")['build'] super(VPNIPUpdate, self).__init__() if self.vpn_db_build.upper() == 'TRUE': self.my_ip = config_section_parser(self.config, "IPS")['my'] self.my_protocol = config_section_parser(self.config, "IPS")['my_protocol'] self.user_vpn = config_section_parser(self.config, "IPS")['user_vpn'] self.user_protocol = config_section_parser(self.config, "IPS")['user_protocol'] self.vessel_vpn = config_section_parser(self.config, "IPS")['vessel_vpn'] self.vessel_protocol = config_section_parser( self.config, "IPS")['vessel_protocol'] # self.generate_token() self.vpn_token = '269c2c3706886d94aeefd6e7f7130ab08346590533d4c5b24ccaea9baa5211ec' def vpn_ip_update(self): """VPN IP Update""" if self.vpn_db_build.upper() == 'TRUE': account_vpn_state = self.get_account_vpn_state() if account_vpn_state: self.update_account_vessel(account_vpn_state) account_vessels = self.get_account_vessel(True) for account_vessel in account_vessels or []: self.check_job(account_vessel, 'ADD') account_vessels = self.get_account_vessel(False) disabled_account = self.get_account_vessel( False, 'account_offline_vessel') account_vessels += disabled_account for account_vessel in account_vessels or []: self.check_job(account_vessel, 'REMOVE') return 1 def get_account_vpn_state(self): """Return Account VPN State""" # INIT SQL QUERY sql_str = "SELECT * FROM account WHERE vessel_vpn_state='pending'" # FETCH ALL res = self.postgres.query_fetch_all(sql_str) # RETURN return res def get_account_vessel(self, allow_access, table="account_vessel"): """Return Account Vessel""" # INIT SQL QUERY sql_str = "SELECT DISTINCT (account_id), allow_access FROM {0}".format( table) sql_str += " WHERE vessel_vpn_state='pending' AND allow_access={0}".format( allow_access) # FETCH ALL res = self.postgres.query_fetch_all(sql_str) # RETURN return res def update_account_vessel(self, account_vpn_state): """Update Account Vessel""" for avs in account_vpn_state: account_id = avs['id'] vessel_allow_access = self.get_vessel_allow_access(account_id) self.remove_account_vessel(account_id, vessel_allow_access) # INIT CONDITION conditions = [] # CONDITION FOR QUERY conditions.append({"col": "id", "con": "=", "val": account_id}) updates = {} updates['vessel_vpn_state'] = 'ok' # UPDATE VESSEL VPN STATE self.postgres.update('account', updates, conditions) def check_job(self, account, action): """Check Job""" account_id = account['account_id'] # INIT SQL QUERY sql_str = "SELECT * FROM job" sql_str += " WHERE account_id='{0}' AND status='pending'".format( account_id) sql_str += " AND action='{0}'".format(action) res = self.postgres.query_fetch_one(sql_str) # JOB DATAS callback_url = self.my_protocol + "://" + self.my_ip + "/vpn/update" data_url = self.my_protocol + "://" + self.my_ip + "/vpn/data" if not res: user_vpn = self.get_user_vpn(account_id) if user_vpn: sql_str = "SELECT * FROM account_role where account_id='{0}' ".format( account_id) sql_str += "AND role_id in (SELECT role_id FROM role " sql_str += "WHERE role_name='super admin')" super_admin = self.postgres.query_fetch_one(sql_str) vpn_type = 'VCLIENT' if not super_admin: # vpn_type = 'VRH' update_on = time.time() # INIT NEW JOB temp = {} temp['callback_url'] = callback_url temp['vnp_server_ip'] = user_vpn temp['data_url'] = data_url temp['token'] = self.vpn_token temp['status'] = 'pending' temp['account_id'] = account_id temp['vpn_type'] = vpn_type temp['action'] = action temp['update_on'] = update_on temp['created_on'] = update_on # INSERT NEW JOB job_id = self.postgres.insert('job', temp, 'job_id') # INIT PARAMS FOR CREATE VPN vpn_params = {} vpn_params['callback_url'] = callback_url vpn_params['data_url'] = data_url vpn_params['job_id'] = job_id self.add_vpn_ip(vpn_params, self.vpn_token, True) return job_id return 0 else: job_id = res['job_id'] # INIT PARAMS FOR CREATE VPN vpn_params = {} vpn_params['callback_url'] = callback_url vpn_params['data_url'] = data_url vpn_params['job_id'] = job_id self.add_vpn_ip(vpn_params, self.vpn_token, True) return 0 def get_user_vpn(self, account_id): """Return User VPN""" sql_str = "SELECT * FROM account_role where account_id='{0}' ".format( account_id) sql_str += "AND role_id in (SELECT role_id FROM role " sql_str += "WHERE role_name='super admin')" super_admin = self.postgres.query_fetch_one(sql_str) vpn_type = 'VCLIENT' if super_admin: vpn_type = 'VRH' # INIT SQL QUERY sql_str = "SELECT * FROM account_vpn" sql_str += " WHERE account_id='{0}' AND vpn_type='{1}'".format( account_id, vpn_type) sql_str += " ORDER BY created_on DESC LIMIT 1" res = self.postgres.query_fetch_one(sql_str) if res: return res['vpn_ip'] return 0 def add_vpn_ip(self, data, vpn_token, flag=False): """Add VPN IP""" api_endpoint = self.user_protocol + "://" + self.user_vpn + "/ovpn" if flag: api_endpoint = self.vessel_protocol + "://" + self.vessel_vpn + "/ovpn" headers = {'content-type': 'application/json', 'token': vpn_token} req = requests.post(api_endpoint, data=json.dumps(data), headers=headers) res = req.json() return res def get_vessel_allow_access(self, account_id): """Return Vessel Allow Access""" # DATA sql_str = "SELECT * FROM account_company WHERE account_id = " + str( account_id) res = self.postgres.query_fetch_all(sql_str) rows = [] # COMPANY'S VESSELS-ID for company in res: company_id = company['company_id'] vessel_res = self.get_company_vessels(company_id) vessels = [] for vessel in vessel_res['rows']: temp = {} temp['vessel_id'] = vessel['vessel_id'] temp['allow_access'] = self.get_allow_access( account_id, vessel['vessel_id']) vessels.append(temp) company['vessels'] = vessels rows.append(company) temp_vessels = [] list_vessels = [] for row in rows: for row_vessel in row['vessels'] or []: if row_vessel['vessel_id'] not in list_vessels: list_vessels.append(row_vessel['vessel_id']) temp_vessels.append(row_vessel) # CLOSE CONNECTION self.postgres.close_connection() return temp_vessels # GET VESSELS OF COMPANY def get_company_vessels(self, company_id): """Return Company Vessels""" assert company_id, "CompanyID is required." # DATA vessels = [] sql_str = "SELECT * FROM company_vessels WHERE company_id={0}".format( company_id) vessels = self.postgres.query_fetch_all(sql_str) data = {} data['rows'] = vessels return data def get_allow_access(self, account_id, vessel_id): """Return Allow Access""" # DATA sql_str = "SELECT * FROM account_vessel" sql_str += " WHERE account_id={0} AND vessel_id='{1}'".format( account_id, vessel_id) vessel = self.postgres.query_fetch_one(sql_str) if vessel: return vessel['allow_access'] ntwconf = self.couch_query.get_complete_values(vessel_id, "NTWCONF") # INSERT ACCOUNT VESSEL temp = {} temp['vessel_vpn_ip'] = ntwconf['NTWCONF']['tun1']['IP'] temp['account_id'] = account_id temp['vessel_id'] = vessel_id temp['allow_access'] = False temp['vessel_vpn_state'] = 'ok' self.postgres.insert('account_vessel', temp) return False def remove_account_vessel(self, account_id, vessel_allow_access): """Remove Account Vessel""" vessel_ids = [x['vessel_id'] for x in vessel_allow_access] if vessel_ids: # INIT SQL QUERY sql_str = "SELECT allow_access, vessel_id FROM account_vessel" if len(vessel_ids) == 1: sql_str += " WHERE account_id={0}".format(account_id) sql_str += " AND vessel_id NOT IN ('{0}')".format( vessel_ids[0]) else: sql_str += " WHERE account_id={0}".format(account_id) sql_str += " AND vessel_id NOT IN {0}".format( tuple(vessel_ids)) # FETCH ALL rows = self.postgres.query_fetch_all(sql_str) for row in rows or []: conditions = [] conditions.append({ "col": "vessel_id", "con": "=", "val": row['vessel_id'] }) conditions.append({ "col": "account_id", "con": "=", "val": account_id }) account_vessel_data = {} account_vessel_data['vessel_vpn_state'] = 'pending' account_vessel_data['allow_access'] = False self.postgres.update('account_vessel', account_vessel_data, conditions) # RETURN return 1 return 0
class ObuSummary(Common): """Class for ObuSummary""" # INITIALIZE def __init__(self): """The Constructor for ObuSummary class""" self.postgres = PostgreSQL() self.couch_query = Queries() self.unit_conversion = UnitConversion() super(ObuSummary, self).__init__() def obu_summary(self): """ This API is for Getting OBU Summary per Vessel --- tags: - Alarm OBU Summary produces: - application/json parameters: - name: token in: header description: Token required: true type: string - name: userid in: header description: User ID required: true type: string - name: vessel_id in: query description: Vessel ID required: true type: string responses: 500: description: Error 200: description: Alarm OBU Summary """ data = {} # GET DATA token = request.headers.get('token') userid = request.headers.get('userid') vessel_id = request.args.get('vessel_id') # CHECK TOKEN if not self.validate_token(token, userid): data['alert'] = "Invalid Token" data['status'] = 'Failed' data = {} system = self.couch_query.get_system(vessel_id) system_info = {} if system["rows"]: row = system["rows"][0]["doc"] # START TIME start_time = time.localtime(row["data"]["start_time"]) start_time = time.strftime("%d %b %Y %H:%M:%S %Z", start_time) # END TIME end_time = time.localtime(row["data"]["end_time"]) end_time = time.strftime("%d %b %Y %H:%M:%S %Z", end_time) # TIME DELTA runtime_overall = self.time_span(row["data"]["end_time"], row["data"]["start_time"]) # DEVICE device_list = self.couch_query.get_device(vessel_id) # REMOVE DATA data_to_remove = [ 'PARAMETERS', 'COREVALUES', 'FAILOVER', 'NTWCONF' ] device_list = self.remove_data(device_list, data_to_remove) # COREVALUES corevalues = self.couch_query.get_complete_values(vessel_id, "COREVALUES", flag='one_doc') days = int(row["data"]["end_time"] - row["data"]["start_time"]) // (24 * 3600) + 1 table_size = float(row["data"]["data_size"]) / days table_size = format(table_size, '.4f') database_size = format(row["data"]["data_size"], '.4f') parameters = self.couch_query.get_complete_values( vessel_id, "PARAMETERS") imo = parameters['PARAMETERS']['INFO']['IMO'] system_info["first_timestamp"] = start_time system_info["last_timestamp"] = end_time system_info["runtime_overall"] = runtime_overall system_info["datapoints"] = row["data"]["doc_count"] system_info["devices"] = len(device_list) # 3 IS 'COREVALUES', 'FAILOVER', 'NTWCONF' system_info["monitored_parameters"] = len(device_list) + 3 system_info["database_size"] = str(database_size) + " MB" system_info["table_size"] = str(table_size) + " MB" system_info["main_loop_time"] = str( int( float(corevalues["value"]["COREVALUES"]["CoreInfo"] ["MainLoopTime"]))) + " Seconds" system_info["imo"] = imo if "ui_version" in row["data"].keys(): system_info["ui_version"] = row["data"]["ui_version"] if "api_version" in row["data"].keys(): system_info["api_version"] = row["data"]["api_version"] if "backend_version" in row["data"].keys(): system_info["backend_version"] = row["data"]["backend_version"] data['data'] = system_info self.get_vessel_device(vessel_id) data['status'] = 'ok' return self.return_data(data) def get_vessel_summary(self, vessel): """Return Vessel Summary""" data = {} if vessel: values = self.couch_query.get_complete_values(vessel, "COREVALUES", flag='all') if values: timestamp = [value['timestamp'] for value in values] data['min_timestamp'] = min(timestamp) data['max_timestamp'] = max(timestamp) return data return 0 def get_vessel_device(self, vessel): """Return Vessel Device""" # DATA devices = [] sql_str = "SELECT * FROM device" sql_str += " WHERE vessel_id='{0}'".format(vessel) sql_str += " AND device NOT IN ('PARAMETERS', 'COREVALUES', 'FAILOVER', 'NTWCONF')" devices = self.postgres.query_fetch_all(sql_str) data = {} data['rows'] = devices return data
class MapVessels(Common): """Class for Vessels""" # INITIALIZE def __init__(self): """The Constructor for Vessels class""" self._couch_db = CouchDatabase() self.couch_query = Queries() self.postgres = PostgreSQL() self.epoch_default = 26763 self.vessel_name = "" self.aws3 = AwsS3() # INIT CONFIG self.config = ConfigParser() # CONFIG FILE self.config.read("config/config.cfg") self.vpn_db_build = config_section_parser(self.config, "VPNDB")['build'] super(MapVessels, self).__init__() # GET VESSEL FUNCTION def map_vessels(self): """ This API is for Getting Vessels --- tags: - Map produces: - application/json parameters: - name: token in: header description: Token required: true type: string - name: userid in: header description: User ID required: true type: string - name: vessel_number in: query description: Vessel Number required: false type: string responses: 500: description: Error 200: description: Vessel Information """ # INIT DATA data = {} # VESSEL ID vessel_number = request.args.get('vessel_number') vessels = [] # GET DATA token = request.headers.get('token') userid = request.headers.get('userid') # CHECK TOKEN token_validation = self.validate_token(token, userid) if not token_validation: data["alert"] = "Invalid Token" data['status'] = 'Failed' # RETURN ALERT return self.return_data(data) sql_str = "SELECT * FROM vessel " if not vessel_number: # COUCH QUERY - GET VESSELS sql_str += " ORDER BY created_on DESC" vessels = self.postgres.query_fetch_all(sql_str) else: # COUCH QUERY - GET VESSEL sql_str += "WHERE number='{0}'".format(vessel_number) vessels = self.postgres.query_fetch_all(sql_str) # CHECK DATABASES rows = [] if vessels: vessel_ids = [x['vessel_id'] for x in vessels] # INIT SQL QUERY if len(vessel_ids) == 1: sql_str = "SELECT * FROM vessel WHERE state ='1'" sql_str += " AND vessel_id IN ('{0}')".format(vessel_ids[0]) else: sql_str = "SELECT * FROM vessel WHERE state ='1'" sql_str += " AND vessel_id IN {0}".format(tuple(vessel_ids)) # FETCH ALL vessels_state = self.postgres.query_fetch_all(sql_str) to_be_install = [x['vessel_id'] for x in vessels_state] # INIT VARIABLES # LOOP DATABASES for item in vessels: if not item['number'] == item['vessel_id']: row = {} # CONNECT TO DATABASE # GET VESSEL NAME # VESSEL POSIBLE STATE # To be installed = 1 # Installed and etc. = 2 vessel_name = self.get_vessel_name(item['vessel_id'], item['number']) self.vessel_name = vessel_name mail_enable = self.get_email_schedule(item['vessel_id']) last_update = self.get_last_update_with_option(item['vessel_id']) epoch_time = int(time.time()) update_state = 'red' if not item['vessel_id'] == item['number']: update_state = self.check_time_lapse(epoch_time, last_update) vpn_url = self.get_vpn_url(item['number']) # SET THE RETURN VALUE row['vessel_id'] = item['vessel_id'] row['vessel_rev'] = self.get_rev_id(item['vessel_id'], item['number']) row['vessel_number'] = item['number'] row['vessel_name'] = vessel_name row['mail_enable'] = mail_enable['mail_enable'] row['schedules'] = mail_enable['schedules'] row['emails'] = mail_enable['emails'] row['update_state'] = update_state row['vpn_url'] = vpn_url # GET IMAGE URL row['image_url'] = self.aws3.get_vessel_image(item['vessel_id']) if item['vessel_id'] in to_be_install: row['update_state'] = 'white' rows.append(row) # SET RETURN data['rows'] = rows data['status'] = 'ok' # RETURN return self.return_data(data) # GET THE VESSEL NAME def get_vessel_name(self, vessel_id, number): """Return Vessel Name""" if vessel_id == number: vessel_name = "" if self.vpn_db_build.upper() == 'TRUE': sql_str = "SELECT vessel_name FROM vessel_vpn_job WHERE imo='{0}' ".format(number) sql_str += "AND vpn_type='VESSEL' ORDER BY created_on DESC LIMIT 1" vname = self.postgres.query_fetch_one(sql_str) vessel_name = vname['vessel_name'] else: sql_str = "SELECT vessel_name FROM vessel WHERE number='{0}'".format(number) vname = self.postgres.query_fetch_one(sql_str) vessel_name = vname['vessel_name'] return vessel_name values = self.couch_query.get_complete_values( vessel_id, "PARAMETERS" ) if values: return values['PARAMETERS']['INFO']['VESSELNAME'] return '' def get_email_schedule(self, vessel_id): """Return Email Schedule""" # SQL QUERY cols = 'email_vessel_id, mail_enable, email' sql_str = "SELECT " + cols + " FROM email_vessel" sql_str += " WHERE vessel_id='{}'".format(vessel_id) # FETCH ONE email_vessels = self.postgres.query_fetch_all(sql_str) data = {} data['emails'] = [] data['schedules'] = [] data['mail_enable'] = False if email_vessels: mail_enable = email_vessels[0]['mail_enable'] email_vessel_id = email_vessels[0]['email_vessel_id'] # SQL QUERY cols = 'schedule' sql_str = "SELECT " + cols + " FROM email_schedule" sql_str += " WHERE email_vessel_id='{}'".format(email_vessel_id) schedules = self.postgres.query_fetch_all(sql_str) data['emails'] = (list(map(lambda x: x['email'], email_vessels))) data['schedules'] = (list(map(lambda x: x['schedule'], schedules))) data['mail_enable'] = mail_enable return data def get_last_update_with_option(self, vessel_id): """Return Last Update with Option""" values = self.couch_query.get_complete_values( vessel_id, "COREVALUES", flag='one_doc' ) if values: return values['timestamp'] return '' def get_vpn_url(self, vessel_number): """ GET VPN URL """ vpn_url = "" sql_str = "SELECT * FROM vessel_vpn_job WHERE" sql_str += " imo='{0}' AND status='active'".format(vessel_number) job = self.postgres.query_fetch_one(sql_str) if job: filename = job['directory'].split("/")[-1] created_on = job['created_on'] # vpn_url = "download/vpn/{0}".format(filename) vpn_url = "download/vessel/vpn/{0}_{1}".format(created_on, filename) return vpn_url def get_rev_id(self, vessel_id, vessel_number): """ GET REV ID """ if vessel_id == vessel_number: return vessel_id vessel = self.couch_query.get_vessels(vessel_number=vessel_number) if vessel: return vessel[0]['doc']['_rev'] return 0
class UpdateINIFiles(Common): """Class for UpdateINIFiles""" # INITIALIZE def __init__(self): """The Constructor for UpdateINIFiles class""" # INIT CONFIG self.config = ConfigParser() # CONFIG FILE self.config.read("config/config.cfg") self._couch_db = CouchDatabase() self.couch_query = Queries() self.postgres = PostgreSQL() super(UpdateINIFiles, self).__init__() self.vpn_db_build = config_section_parser(self.config, "VPNDB")['build'] self.vessel_vpn = config_section_parser(self.config, "IPS")['vessel_vpn'] self.vessel_protocol = config_section_parser(self.config, "IPS")['vessel_protocol'] self.vpn_token = '269c2c3706886d94aeefd6e7f7130ab08346590533d4c5b24ccaea9baa5211ec' def update_ini_files(self): """Update INI Files""" # INIT SQL QUERY sql_str = "SELECT * FROM vessel" # FETCH ALL rows = self.postgres.query_fetch_all(sql_str) for row in rows: vessel_id = row['vessel_id'] inifiles = self.couch_query.get_last_ini(vessel_id) if inifiles: vdatas = inifiles[0]["doc"]["data"] vtimestamp = inifiles[0]["doc"]["timestamp"] ini_dir = vdatas[list(vdatas.keys())[0]]['dir'] sql_str = "SELECT * FROM ini_files WHERE " sql_str += "vessel_id='{0}' AND dir='{1}'".format( vessel_id, ini_dir) sdata = self.postgres.query_fetch_one(sql_str) if not sdata: for vdata in vdatas.keys(): newdt = {} newdt['vessel_id'] = vessel_id newdt['dir'] = vdatas[vdata]['dir'] newdt['content'] = json.dumps(vdatas[vdata]['content']) newdt['lastupdate'] = vtimestamp newdt['vessel_lastupdate'] = vtimestamp newdt['created_on'] = time.time() newdt['update_on'] = time.time() self.postgres.insert('ini_files', newdt, 'ini_files_id') else: if int(vtimestamp) > int(sdata['lastupdate']): for vdata in vdatas.keys(): ini_dir = vdatas[vdata]['dir'] conditions = [] conditions.append({ "col": "vessel_id", "con": "=", "val": vessel_id }) conditions.append({ "col": "dir", "con": "=", "val": ini_dir }) updata = {} updata['content'] = json.dumps( vdatas[vdata]['content']) updata['lastupdate'] = vtimestamp updata['vessel_lastupdate'] = vtimestamp self.postgres.update('ini_files', updata, conditions) if int(vtimestamp) < int(sdata['lastupdate']): # UPDATE VESSEL INIFILES self.send_command(vessel_id) vsystem = self.couch_query.get_system(vessel_id) if vsystem["rows"]: vsystem = vsystem["rows"][0]["doc"]["data"] repos = set(["ui_version", "api_version", "backend_version"]) sys_keys = set(vsystem.keys()) if repos.issubset(sys_keys): ui_version = vsystem["ui_version"] api_version = vsystem["api_version"] backend_version = vsystem["backend_version"] ui_version = ui_version.split("\n")[0] api_version = api_version.split("\n")[0] backend_version = backend_version.split("\n")[0] sql_str = "SELECT * FROM vessel_version INNER JOIN version ON" sql_str += " vessel_version.version_id=version.version_id WHERE" sql_str += " (vessel_version.vessel_id='{0}')".format( vessel_id) sql_str += " and (version.web!='{0}'".format(ui_version) sql_str += " or version.api!='{0}'".format(api_version) sql_str += " or version.backend!='{0}')".format( backend_version) vversion = self.postgres.query_fetch_one(sql_str) if vversion: # UPDATE VERSION self.update_version(vessel_id, vversion) return 1 def update_version(self, vessel_id, datas): """UPDATE VESSEL VERSION""" ntwconf_datas = self.couch_query.get_complete_values(vessel_id, "NTWCONF", flag='one_doc') ntwconf = ntwconf_datas['value'] current_time = time.time() ntwconf_timestamp = ntwconf_datas['timestamp'] if self.check_time_lapse(current_time, ntwconf_timestamp) == 'green': host = ntwconf['NTWCONF']['tun1']['IP'] data = {} data['host'] = host data['port'] = 8080 data['ini_data'] = datas api_endpoint = self.vessel_protocol + "://" + self.vessel_vpn + "/update/ini/files" headers = { 'content-type': 'application/json', 'token': self.vpn_token } req = requests.put(api_endpoint, data=json.dumps(data), headers=headers) res = req.json() return res return 0 def send_command(self, vessel_id): """Send Command""" ini_data = self.get_ini_files(vessel_id) ntwconf_datas = self.couch_query.get_complete_values(vessel_id, "NTWCONF", flag='one_doc') ntwconf = ntwconf_datas['value'] current_time = time.time() ntwconf_timestamp = ntwconf_datas['timestamp'] if self.check_time_lapse(current_time, ntwconf_timestamp) == 'green': host = ntwconf['NTWCONF']['tun1']['IP'] data = {} data['host'] = host data['port'] = 8080 data['ini_data'] = ini_data['datas'] api_endpoint = self.vessel_protocol + "://" + self.vessel_vpn + "/update/ini/files" headers = { 'content-type': 'application/json', 'token': self.vpn_token } req = requests.put(api_endpoint, data=json.dumps(data), headers=headers) res = req.json() return res return 0 def get_ini_files(self, vessel_id): """Return INI Files""" # GET SUPER ADMIN ID sql_str = "SELECT * FROM ini_files WHERE vessel_id ='{0}'".format( vessel_id) ini_files = self.postgres.query_fetch_all(sql_str) datas = {} for ini_file in ini_files: datas[ini_file['dir']] = "\n".join(ini_file['content']) final_data = {} final_data['filenames'] = [x['dir'] for x in ini_files] final_data['datas'] = datas return final_data
class AlarmRecord(Common): """Class for AlarmRecord""" def __init__(self): """The Constructor for AlarmRecord class""" self.postgres = PostgreSQL() self.log = Log() self.calc_trigger = calculate_alarm_trigger.CalculateAlarmTrigger() self.calc_value = calculate_alarm_value.CalculateAlarmValue() self.format_alarm = FormatAlarmState() self.couch_query = Queries() self.epoch_default = 26763 super(AlarmRecord, self).__init__() def run(self): """Run Alarm Trigger""" ats = self.get_alarm_trigger() if ats: for atrigger in ats: current_date = self.epoch_day(time.time()) epoch_time = self.days_update(current_date) epoch_time -= 1 at_id = atrigger['alarm_trigger_id'] vessel_ids = self.get_triggered_vessel(at_id) for vessel_id in vessel_ids: # last_update = self.get_last_update(at_id, vessel_id, st, epoch_time) self.update_alarm_data(at_id, vessel_id, epoch_time) else: print("No Alarm Trigger Available") def get_alarm_trigger(self): """Return Alarm Triggers""" sql_str = "SELECT * FROM alarm_trigger WHERE alarm_enabled=true" res = self.postgres.query_fetch_all(sql_str) return res def get_alarm_param(self, condition_id): """ Return Alarm Condition Parameter """ sql_str = "SELECT * FROM alarm_condition" sql_str += " WHERE alarm_condition_id={0}".format(condition_id) param_id = set() alarm_condition = self.postgres.query_fetch_one(sql_str) if alarm_condition: for param in alarm_condition['parameters']: if 'id' in param.keys(): param_id.add(param['id']) return param_id def get_triggered_vessel(self, at_id): """Return Triggered Vessel""" sql_str = "SELECT * FROM alarm_condition WHERE alarm_condition_id IN (" sql_str += " SELECT alarm_condition_id FROM alarm_trigger WHERE" sql_str += " alarm_trigger_id={0})".format(at_id) alarm_condition = self.postgres.query_fetch_one(sql_str) # av_ids = list({x['id'] for x in alarm_condition['parameters'] if 'id' in x.keys()}) prmtr_ids = set() prmtr_conditions = [] for prmtr in alarm_condition['parameters']: if 'id' in prmtr.keys(): if prmtr['id']: if prmtr['type'] == "values": prmtr_ids.add(prmtr['id']) if prmtr['type'] == "conditions": prmtr_conditions += self.get_alarm_param(prmtr['id']) av_ids = list(prmtr_ids) + prmtr_conditions # DATA sql_str = "SELECT * FROM alarm_value" sql_str += " WHERE alarm_value_id in ({0})".format(','.join(map(str, av_ids))) alarm_value = self.postgres.query_fetch_all(sql_str) arr_vessels_id = [] arr_options = [] if alarm_value: for avalue in alarm_value: if arr_vessels_id: for vessel_id in avalue['vessel'].split(","): arr_vessels_id.append(vessel_id) for opt in avalue['option'].split(","): arr_options.append(opt) # options.append(av['option'].split(",")) else: arr_vessels_id = avalue['vessel'].split(",") arr_options = avalue['option'].split(",") vessels_id = ','.join(map(str, arr_vessels_id)) options = ','.join(map(str, arr_options)) vessels_ids = self.calc_value.get_all_vessels(vessels_id, options) return vessels_ids def update_alarm_data(self, at_id, vessel_id, epoch_time): """Update Alarm Data""" sql_str = "SELECT epoch_date FROM alarm_data WHERE " sql_str += "vessel_id='{0}' AND ".format(vessel_id) sql_str += "alarm_trigger_id={0} ".format(at_id) sql_str += "ORDER BY epoch_date DESC LIMIT 1" epoch_date = self.postgres.query_fetch_one(sql_str) timestamp = 0 if epoch_date: timestamp = epoch_date['epoch_date'] else: self.log.low("NEW ALARM RECORD!") values = self.couch_query.get_complete_values( vessel_id, "COREVALUES", start=str(9999999999), end=str(self.epoch_default), flag='one_doc', descending=False ) timestamp = values['timestamp'] late_et = self.days_update(timestamp, 1, True) late_st = self.days_update(late_et, 1) # late_et -= 1 new_et = late_et while int(new_et) <= int(epoch_time): current_time = time.time() late_et = self.days_update(late_et, 1, True) late_st = self.days_update(late_et, 1) if late_st > epoch_time: break new_et = late_et - 1 alarm = self.calc_trigger.calculate_trigger([at_id], late_st, late_et, vessel_id) alarm_index_0 = "" try: alarm_index = alarm[0]['results'] alarm_index_0 = alarm_index[0] vessel_name = alarm_index_0['vessel_name'] vessel_number = alarm_index_0['vessel_number'] alarm_datas = alarm_index_0['datas'] # COMPUTE PERCENTAGE green, orange, red, blue, violet = self.get_alarm_percentage(alarm_datas) average = {} average['green'] = green average['orange'] = orange average['red'] = red average['blue'] = blue average['violet'] = violet module = "" if 'module' in alarm_index_0.keys(): module = alarm_index_0['module'] option = "" if 'option' in alarm_index_0.keys(): option = alarm_index_0['option'] # SAVE TO ALARM DATA data = {} data["alarm_trigger_id"] = at_id data["average"] = json.dumps(average) data["device"] = alarm_index_0['device'] data["module"] = module data["option"] = option data["vessel_id"] = vessel_id data["vessel_name"] = vessel_name data["vessel_number"] = vessel_number data["alarm_type_id"] = alarm[0]['alarm_type_id'] data["epoch_date"] = int(late_st) data["created_on"] = current_time data["update_on"] = current_time data["alarm_description"] = alarm[0]['alarm_description'] data["err_message"] = alarm[0]['err_message'] data["device_id"] = alarm_index_0['device_id'] data["message"] = alarm_index_0['message'] data["alarm_type"] = alarm[0]['alarm_type'] self.postgres.insert('alarm_data', data) late_et += 1 except: return 1 def get_alarm_percentage(self, datas): """Return Alarm Percentage""" green = 0 orange = 0 red = 0 blue = 0 violet = 0 for data in datas: if data['remarks'] == 'green': green += 1 elif data['remarks'] == 'orange': orange += 1 elif data['remarks'] == 'red': red += 1 elif data['remarks'] == 'blue': blue += 1 elif data['remarks'] == 'violet': violet += 1 # COUMPUTE if datas: green = green * 100 / len(datas) orange = orange * 100 / len(datas) red = red * 100 / len(datas) blue = blue * 100 / len(datas) violet = violet * 100 / len(datas) else: violet = 100 return [green, orange, red, blue, violet] def run_current_alarm(self): """ RUN CURRENT ALARM """ self.run_alarm_state() return 1 def run_day_alarm(self): """ RUN 24 HOURS ALARM """ self.run_alarm_state("day") return 1 # ALARM FOR CURRENT STATE AND 24 HOURS def run_alarm_state(self, epoch_format=""): """ RUN ALARM FOR CURRENT STATE """ atriggers = self.get_alarm_trigger() if epoch_format == "day": key = epoch_format start = 1 else: key = "hours" start = 8 end_time = time.time() start_time = self.timediff_update(end_time, start, key=key) late_et = self.days_update(end_time, 1, True) late_st = self.days_update(late_et, 1) for atrigger in atriggers: at_id = atrigger['alarm_trigger_id'] vessel_ids = self.get_triggered_vessel(at_id) for vessel_id in vessel_ids: print("Key: {0} Alarm Vessel ID: {1}".format(key, vessel_id)) datas = self.calc_trigger.calculate_trigger( [at_id], start_time, end_time, vessel_id=vessel_id ) if type(datas) == list: datas = self.get_datas(datas, epoch_format, end_time) if not epoch_format: datas = self.format_alarm.filter_current_status(datas) else: pass # INSERT OR UPDATE TO TABLE if datas[0]['results']: self.add_alarm_state(vessel_id, at_id, late_st, datas, key) else: pass def get_datas(self, datas, epoch_format, end_time): """ Set datas """ for alarm in datas: alarm_result = alarm['results'] if alarm_result and not alarm['err_message']: if not epoch_format: self.format_alarm.get_current_alarm(alarm_result) else: self.format_alarm.get_alarm24(alarm_result, end_time) return datas def add_alarm_state(self, vessel_id, at_id, epoch_date, result, key): """ Add or Insert Alarm State """ # CHECK IF DATA EXIST ON CURRENT DATE sql_str = "SELECT * FROM alarm_state" sql_str += " WHERE alarm_trigger_id='{0}' AND vessel_id='{1}'".format(at_id, vessel_id) sql_str += " AND epoch_date='{0}' AND category='{1}'".format(int(epoch_date), key) state = self.postgres.query_fetch_one(sql_str) current_time = time.time() res = result[0]['results'] data = {} if not state: # INSERT TO ALARM STATE data["alarm_trigger_id"] = at_id data["category"] = key data["results"] = json.dumps(res) data["device"] = res[0]['device'] data["module"] = res[0]['module'] data["option"] = res[0]['option'] data["vessel_id"] = res[0]['vessel_id'] data["vessel_name"] = res[0]['vessel_name'] data["alarm_description"] = result[0]['alarm_description'] data["err_message"] = result[0]['err_message'] data["device_id"] = res[0]['device_id'] data["message"] = res[0]['message'] data["alarm_type"] = result[0]['alarm_type'] data["vessel_number"] = res[0]['vessel_number'] data["alarm_type_id"] = result[0]['alarm_type_id'] data["epoch_date"] = int(epoch_date) data["created_on"] = current_time data["update_on"] = current_time self.postgres.insert('alarm_state', data) else: # UPDATE ALARM STATE data['results'] = json.dumps(res) data['update_on'] = current_time data["err_message"] = result[0]['err_message'] data["message"] = res[0]['message'] conditions = [] conditions.append({ "col": "alarm_state_id", "con": "=", "val": state['alarm_state_id'] }) self.postgres.update('alarm_state', data, conditions) return 1
class PortForwarding(Common): """Class for PortForwarding""" # INITIALIZE def __init__(self): """The Constructor for PortForwarding class""" self._couch_db = CouchDatabase() self.couch_query = Queries() self.epoch_default = 26763 super(PortForwarding, self).__init__() def port_forwarding(self): """ This API is for getting Port Forwarding of device --- tags: - Devices produces: - application/json parameters: - name: token in: header description: Token required: true type: string - name: userid in: header description: User ID required: true type: string - name: vessel_id in: query description: Vessel ID required: true type: string - name: device_id in: query description: Device ID required: false type: string - name: limit in: query description: Limit required: true type: integer - name: page in: query description: Page required: true type: integer responses: 500: description: Error 200: description: Vessel Device Info """ data = {} # VESSEL ID vessel_id = request.args.get('vessel_id') device_id = request.args.get('device_id') limit = int(request.args.get('limit')) page = int(request.args.get('page')) # GET DATA token = request.headers.get('token') userid = request.headers.get('userid') # CHECK TOKEN token_validation = self.validate_token(token, userid) if not token_validation: data["alert"] = "Invalid Token" data['status'] = 'Failed' # RETURN ALERT return self.return_data(data) if not vessel_id: data["alert"] = "Please complete parameters!" data['status'] = 'Failed' # RETURN ALERT return self.return_data(data) # device_list = [] device_name = "" if device_id: device_data = self.couch_query.get_by_id(device_id) dev_name = device_data['device'] # device_list.append(value) # else: # device_list = self.couch_query.get_device(vessel_id) # REMOVE DATA # data_to_remove = ['PARAMETERS', 'COREVALUES', 'FAILOVER', 'NTWCONF', 'NTWPERF1'] # device_list = self.remove_data(device_list, data_to_remove) datas = {} datas['data'] = [] final_data = [] ntwconf = self.couch_query.get_complete_values(vessel_id, "NTWCONF") parameters = self.couch_query.get_complete_values( vessel_id, "PARAMETERS") vpn_ip = ntwconf['NTWCONF']['tun1']['IP'] keys = parameters['PARAMETERS'].keys() for i in range(1, (len(keys))): temp_pf = {} port = 'PORTFORWARDING' + str(i) if port in keys: destination_ip_val = parameters['PARAMETERS'][port][ 'DESTINATIONIP'] destination_port_val = parameters['PARAMETERS'][port][ 'DESTINATIONPORT'] description_val = parameters['PARAMETERS'][port]['DESCRIPTION'] device_name = parameters['PARAMETERS'][port]['DEVICE'] link = description_val.lower() + '://' link += vpn_ip + ':' + parameters['PARAMETERS'][port][ 'SOURCEPORT'] if device_id and dev_name == device_name: temp_pf['destination_ip'] = destination_ip_val temp_pf['destination_port'] = destination_port_val temp_pf['description'] = description_val temp_pf['link'] = link temp_pf['device'] = device_name final_data.append(temp_pf) elif not device_id: temp_pf['destination_ip'] = destination_ip_val temp_pf['destination_port'] = destination_port_val temp_pf['description'] = description_val temp_pf['link'] = link temp_pf['device'] = device_name final_data.append(temp_pf) total_count = len(final_data) - 1 total_page = int(math.ceil(int(total_count) / limit)) + 1 final_data = self.limits(final_data, limit, page) datas['total_rows'] = total_count + 1 datas['total_page'] = total_page datas['limit'] = int(limit) datas['page'] = int(page) datas['data'] = final_data datas['status'] = 'ok' return self.return_data(datas)
class VPNData(Common): """Class for VPNData""" # INITIALIZE def __init__(self): """The Constructor for VPNData class""" self._couch_db = CouchDatabase() self.couch_query = Queries() self.postgres = PostgreSQL() # INIT CONFIG self.config = ConfigParser() # CONFIG FILE self.config.read("config/config.cfg") self.vpn_db_build = config_section_parser(self.config, "VPNDB")['build'] super(VPNData, self).__init__() if self.vpn_db_build.upper() == 'TRUE': self.my_ip = config_section_parser(self.config, "IPS")['my'] self.my_protocol = config_section_parser(self.config, "IPS")['my_protocol'] self.user_vpn = config_section_parser(self.config, "IPS")['user_vpn'] self.user_protocol = config_section_parser(self.config, "IPS")['user_protocol'] self.vessel_vpn = config_section_parser(self.config, "IPS")['vessel_vpn'] self.vessel_protocol = config_section_parser( self.config, "IPS")['vessel_protocol'] self.vpn_token = '269c2c3706886d94aeefd6e7f7130ab08346590533d4c5b24ccaea9baa5211ec' def vpn_data(self): """ This API is for Getting Data for VPN --- tags: - VPN produces: - application/json parameters: - name: token in: header description: Token required: true type: string - name: jobid in: header description: Job ID required: true type: string responses: 500: description: Error 200: description: Role """ data = {} # GET DATA job_id = request.headers.get('jobid') token = request.headers.get('token') # CHECK TOKEN datas = self.validate_job_id_token(job_id, token) if not datas['data']: data["alert"] = "Invalid Token" data['status'] = 'Failed' # RETURN ALERT return self.return_data(data) # datas['data']['vpn_type'] ='CLIENT' # datas['data']['account_os'] ='WINDOWS' # LINUX # datas['data']['action'] ='CREATE' datas['status'] = 'ok' return self.return_data(datas) def validate_job_id_token(self, job_id, token): """Validate Job ID Token""" # print("*"*50," vpn_data ", "*"*50) # print("job_id: ", job_id) # print("token: ", token) # print("*"*50, " vpn_data ", "*"*50) sql_str = "SELECT * FROM job WHERE job_id={0} AND token='{1}'".format( job_id, token) job = self.postgres.query_fetch_one(sql_str) data = {} data['data'] = None if job: vessel_ips = [] account_ip_address = None sql_str = "SELECT username FROM account WHERE id={0}".format( job['account_id']) account = self.postgres.query_fetch_one(sql_str) if account: job['account_name'] = account['username'] data['data'] = job if job['action'] == 'ADD': sql_str = "SELECT a.id, a.status FROM account a INNER JOIN job j" sql_str += " ON a.id=j.account_id WHERE j.job_id={0}".format( job_id) account = self.postgres.query_fetch_one(sql_str) account_id = account['id'] account_status = account['status'] sql_str = "SELECT * FROM account_role where account_id='{0}' ".format( account_id) sql_str += "AND role_id in (SELECT role_id FROM role " sql_str += "WHERE role_name='super admin')" super_admin = self.postgres.query_fetch_one(sql_str) vpn_type = 'VCLIENT' if super_admin: vpn_type = 'VRH' # INIT SQL QUERY sql_str = "SELECT vpn_ip FROM account_vpn WHERE " sql_str += "vpn_type='{0}' AND account_id='{1}' ".format( vpn_type, account_id) sql_str += "AND status = true ORDER BY created_on DESC" account_vpn = self.postgres.query_fetch_one(sql_str) account_ip_address = account_vpn['vpn_ip'] sql_str = "" if account_status: sql_str = "SELECT * FROM account_vessel WHERE account_id={0}".format( account_id) else: sql_str = "SELECT * FROM account_offline_vessel" sql_str += " WHERE account_id={0}".format(account_id) vessels = self.postgres.query_fetch_all(sql_str) for vessel in vessels: if vessel['allow_access']: parameters = self.couch_query.get_complete_values( vessel['vessel_id'], "PARAMETERS") ntwconf = self.couch_query.get_complete_values( vessel['vessel_id'], "NTWCONF") temp = {} temp['ip'] = ntwconf['NTWCONF']['tun1']['IP'] temp['port'] = '22' temp['username'] = parameters['PARAMETERS']['DBOBU'][ 'USER'] temp['password'] = parameters['PARAMETERS']['DBOBU'][ 'PASS'] temp['vessel_name'] = parameters['PARAMETERS']['INFO'][ 'VESSELNAME'] temp['imo'] = parameters['PARAMETERS']['INFO']['IMO'] vessel_ips.append(temp) elif job['action'] == 'REMOVE': sql_str = "SELECT a.id, a.status FROM account a INNER JOIN job j" sql_str += " ON a.id=j.account_id WHERE j.job_id={0}".format( job_id) account = self.postgres.query_fetch_one(sql_str) account_id = account['id'] account_status = account['status'] sql_str = "SELECT * FROM account_role where account_id='{0}' ".format( account_id) sql_str += "AND role_id in (SELECT role_id FROM role " sql_str += "WHERE role_name='super admin')" super_admin = self.postgres.query_fetch_one(sql_str) vpn_type = 'VCLIENT' if super_admin: vpn_type = 'VRH' sql_str = "" if account_status: # INIT SQL QUERY sql_str = "SELECT vpn_ip FROM account_vpn WHERE " sql_str += "vpn_type='{0}' AND account_id='{1}' ".format( vpn_type, account_id) sql_str += "AND status = true ORDER BY created_on DESC" else: # INIT SQL QUERY sql_str = "SELECT vpn_ip FROM account_vpn WHERE " sql_str += "vpn_type='{0}' AND account_id='{1}' ".format( vpn_type, account_id) sql_str += "AND status = false ORDER BY created_on DESC" account_vpn = self.postgres.query_fetch_one(sql_str) # print("-"*100) # print(account_vpn) # print("-"*100) if account_vpn: account_ip_address = account_vpn['vpn_ip'] sql_str = "" # print("-"*100) # print("account_status: ", account_status) # print("-"*100) if account_status: sql_str = "SELECT * FROM account_vessel" sql_str += " WHERE account_id={0}".format(account_id) else: sql_str = "SELECT * FROM account_offline_vessel" sql_str += " WHERE account_id={0}".format(account_id) vessels = self.postgres.query_fetch_all(sql_str) for vessel in vessels: if not vessel['allow_access']: parameters = self.couch_query.get_complete_values( vessel['vessel_id'], "PARAMETERS") ntwconf = self.couch_query.get_complete_values( vessel['vessel_id'], "NTWCONF") temp = {} temp['ip'] = ntwconf['NTWCONF']['tun1']['IP'] temp['port'] = '22' temp['username'] = parameters['PARAMETERS'][ 'DBOBU']['USER'] temp['password'] = parameters['PARAMETERS'][ 'DBOBU']['PASS'] temp['vessel_name'] = parameters['PARAMETERS'][ 'INFO']['VESSELNAME'] temp['imo'] = parameters['PARAMETERS']['INFO'][ 'IMO'] vessel_ips.append(temp) else: pass # print("*"*100) # print("User don't have IP!, Account ID", account_id) # print("*"*100) data['data']['vessel_ips'] = vessel_ips data['data']['account_ip_address'] = account_ip_address return data
class Failover(Common): """Class for Failover""" # INITIALIZE def __init__(self): """The Constructor for Failover class""" self._couch_db = CouchDatabase() self.postgresql_query = PostgreSQL() self.couch_query = Queries() self.epoch_default = 26763 super(Failover, self).__init__() def failover(self): """ This API is for Getting Failover --- tags: - Vessel produces: - application/json parameters: - name: token in: header description: Token required: true type: string - name: userid in: header description: User ID required: true type: string - name: vessel_id in: query description: Vessel ID required: true type: string - name: date in: query description: Epoch date required: false type: string - name: limit in: query description: Limit required: true type: integer - name: page in: query description: Page required: true type: integer - name: sort_type in: query description: Sort Type required: false type: string - name: sort_column in: query description: Sort Column required: false type: string - name: filter_column in: query description: Filter Column required: false type: string - name: filter_value in: query description: Filter Value required: false type: string responses: 500: description: Error 200: description: Vessel Failover """ data = {} # VESSEL ID vessel_id = request.args.get('vessel_id') epoch_date = request.args.get('date') limit = int(request.args.get('limit')) page = int(request.args.get('page')) sort_type = request.args.get('sort_type') sort_column = request.args.get('sort_column') filter_column = request.args.get('filter_column') filter_value = request.args.get('filter_value') # GET DATA token = request.headers.get('token') userid = request.headers.get('userid') # CHECK TOKEN token_validation = self.validate_token(token, userid) if not token_validation: data["alert"] = "Invalid Token" data['status'] = 'Failed' # RETURN ALERT return self.return_data(data) if not vessel_id: data["alert"] = "Please complete parameters!" data['status'] = 'Failed' # RETURN ALERT return self.return_data(data) filter_mod_val = "" filter_subcat = "" filter_option = "" filter_val = "" if filter_column and filter_value: i = 0 for filter_col in filter_column.split(","): if filter_col == "category": filter_mod_val = filter_value.split(",")[i] elif filter_col == "sub_category": filter_subcat = filter_value.split(",")[i] elif filter_col == "option": filter_option = filter_value.split(",")[i] elif filter_col == "value": filter_val = filter_value.split(",")[i] i += 1 data = {} data['data'] = [] total_page = 0 if epoch_date: values = self.couch_query.get_complete_values( vessel_id, "FAILOVER", str(self.epoch_default), str(epoch_date), flag='one_doc' ) else: values = self.couch_query.get_complete_values( vessel_id, "FAILOVER", flag='one_doc' ) if values: all_values = values['value'] timestamp = values['timestamp'] temp_datas, options, categories = self.values_wrapper("FAILOVER", all_values, timestamp ) convert = UnitConversion() temp_datas = convert.check_unit(temp_datas) temp_datas = self.add_device_subcategory(temp_datas) temp_datas = self.add_device_category(temp_datas) rows = self.value_filter(filter_mod_val, filter_subcat, filter_option, filter_val, temp_datas) if sort_type and sort_column: sort_column = sort_column.lower() if sort_type.lower() == "desc" and sort_column in ['category', 'sub_category', 'option', 'value']: rows = sorted(rows, key=lambda i: i[sort_column], reverse=True) if sort_type.lower() == "asc": rows = sorted(rows, key=lambda i: i[sort_column]) else: rows = [] options = [] categories = [] datas = self.limits(rows, limit, page) total_count = len(datas) total_page = int(math.ceil(int(total_count - 1) / limit)) final_data = [] temp_category = '' temp_subcat = '' for item in datas: if temp_category == item['category']: item['category'] = '' else: temp_category = item['category'] if temp_subcat == item['sub_category']: item['sub_category'] = '' else: temp_subcat = item['sub_category'] final_data.append(item) data['data'] = final_data data['total_page'] = total_page data['limit'] = int(limit) data['page'] = int(page) data['total_rows'] = total_count data['options'] = options data['categories'] = categories data['subcategories'] = self.get_device_subcategory(datas) data['status'] = 'ok' return self.return_data(data)
class BlockageData(Common): """Class for BlockageData""" def __init__(self): """The Constructor for BlockageData class""" self.blocks = Blockages() self.postgres = PostgreSQL() self.couch_query = Queries() self.epoch_default = 26763 super(BlockageData, self).__init__() def run(self): """Run Blockage Data""" current_date = self.epoch_day(time.time()) epoch_time = self.days_update(current_date) epoch_time -= 1 datas = self.get_device_type() for data in datas: self.add_blockage_data(data['vessel_id'], data['device_id'], data['device'], data['device_type'], epoch_time) def get_device_type(self): """ Return Device Type """ sql_str = "SELECT DISTINCT vessel_id, device_id, device, device_type" sql_str += " FROM device WHERE device_type IN" sql_str += " ('Intellian_V100_E2S', 'Intellian_V110_E2S'," sql_str += " 'Intellian_V80_IARM', 'Intellian_V100_IARM'," sql_str += " 'Intellian_V100', 'Intellian_V80_E2S'," sql_str += " 'Sailor_900', 'Cobham_500')" # sql_str += " AND vessel_id IN ('be942b8ee9e97f4962258c727c0006bd')" device_type = self.postgres.query_fetch_all(sql_str) return device_type def get_device_data(self, vessel_id, device, start, end): """ Return Device Data """ values = self.couch_query.get_complete_values( vessel_id, device, start=str(start), end=str(end), flag='all') if values: return values return 0 def add_blockage_data(self, vessel_id, device_id, device, dtype, epoch_time): """ Insert to Blockage Data """ sql_str = "SELECT epoch_date FROM blockage_data WHERE " sql_str += "vessel_id='{0}' AND ".format(vessel_id) sql_str += "device_id='{0}' ".format(device_id) sql_str += "ORDER BY epoch_date DESC LIMIT 1" epoch_date = self.postgres.query_fetch_one(sql_str) timestamp = 0 if epoch_date: timestamp = epoch_date['epoch_date'] else: self.log.low("NEW BLOCKAGE DATA!") values = self.couch_query.get_complete_values( vessel_id, device, start=str(9999999999), end=str(self.epoch_default), flag='one_doc', descending=False ) timestamp = values['timestamp'] late_et = self.days_update(timestamp, 1, True) late_st = self.days_update(late_et, 1) new_et = late_et while int(new_et) <= int(epoch_time): late_et = self.days_update(late_et, 1, True) late_st = self.days_update(late_et, 1) if late_st > epoch_time: break new_et = late_et - 1 datas = self.get_device_data(vessel_id, device, late_st, late_et) try: blockage = self.blocks.get_blockage_data(device, datas) block_zone = self.blocks.get_blockage_zones(device, dtype, datas) # GET ANTENNA STATUS antenna = set(data['antenna_status'] for data in blockage) coordinates = self.blocks.get_xydata(blockage, antenna, 0, 0, remarks='cron') antenna_status = ["{}".format(tmp.capitalize()) for tmp in antenna] # INSERT TO BLOCKAGE DATA data = {} data["vessel_id"] = vessel_id data["device_id"] = device_id data["antenna_status"] = json.dumps(antenna_status) data["coordinates"] = json.dumps(coordinates) data["blockzones"] = json.dumps(block_zone) data["epoch_date"] = int(late_st) data["created_on"] = time.time() data["update_on"] = time.time() self.postgres.insert('blockage_data', data) # self.log.medium("datas: {0}".format(data)) late_et += 1 except: pass # print("Start Time: {0} End Time: {1} No Data Found ".format(late_st, late_et)) return 1 def get_blockzones(self, data, zone_number): """ Return Block Zones """ assert data, "Data is required." blockzone = [] blocks = {} if zone_number: try: az_start_val = None el_start_val = None az_end_val = None el_end_val = None bz_type_val = None bz_val = None for num in range(1, zone_number + 1): bzstatus = "bz{0}Status".format(num) az_start = "bz{0}AzStart".format(num) el_start = "bz{0}ElStart".format(num) az_end = "bz{0}AzEnd".format(num) el_end = "bz{0}ElEnd".format(num) bz_type = "bz{0}Type".format(num) blockzones = "Blockzone{0}".format(num) if bzstatus in data['General']: bz_val = data['General'][bzstatus] if az_start in data['General']: az_start_val = data['General'][az_start] if el_start in data['General']: el_start_val = data['General'][el_start] if az_end in data['General']: az_end_val = data['General'][az_end] if el_end in data['General']: el_end_val = data['General'][el_end] if bz_type in data['General']: bz_type_val = data['General'][bz_type] if blockzones.lower() in data: if not bz_val: bz_val = data[blockzones.lower()]['Status'] if not az_start_val: az_start_val = data[blockzones.lower()]['AzStart'] if not el_start_val: az_end_val = data[blockzones.lower()]['AzEnd'] if not el_end_val: el_end_val = data[blockzones.lower()]['ElEnd'] bz_item = {bzstatus: bz_val, az_start: az_start_val, az_end: az_end_val, el_start: el_start_val, el_end: el_end_val, bz_type: bz_type_val} blocks[blockzones] = bz_item blockzone.append({"blockage": blocks}) except ValueError: print("No Timestamp found") return blockzone