642 lines
17 KiB
Python
642 lines
17 KiB
Python
import os
|
|
import xbmc
|
|
|
|
from pathlib import Path
|
|
from datetime import datetime
|
|
from concurrent.futures import ThreadPoolExecutor
|
|
|
|
from . import config
|
|
from . import utils
|
|
from . import conv
|
|
|
|
class Main():
|
|
|
|
### MAIN
|
|
def __init__(self, locid, mode='kodi'):
|
|
|
|
if utils.monitor.abortRequested():
|
|
return
|
|
|
|
# Import API only when needed
|
|
if mode == 'download' or mode == 'geoip' or locid.startswith('loc'):
|
|
global api
|
|
from . import api
|
|
|
|
# GeoIP
|
|
if mode == 'geoip':
|
|
api.getloc(locid)
|
|
return
|
|
|
|
# Search
|
|
if locid.startswith('loc'):
|
|
api.setloc(locid[3])
|
|
return
|
|
|
|
# Init
|
|
self.init(locid, mode)
|
|
|
|
if not config.loc.lat or not config.loc.lon:
|
|
utils.log(f'[LOC{locid}] Not configured', 1)
|
|
return
|
|
|
|
# Download
|
|
if self.mode == 'download':
|
|
|
|
# Weather
|
|
if utils.lastupdate(f'loc{locid}data') >= 3600:
|
|
with ThreadPoolExecutor(3) as pool:
|
|
pool.map(self.getdata, config.map)
|
|
|
|
if api.network():
|
|
utils.setupdate(f'loc{locid}data')
|
|
|
|
# Map
|
|
if utils.lastupdate(f'loc{locid}map') >= 604800:
|
|
self.getmap('osm')
|
|
|
|
if api.network():
|
|
utils.setupdate(f'loc{locid}map')
|
|
|
|
# Rv
|
|
if utils.lastupdate(f'loc{locid}rv') >= 3600:
|
|
with ThreadPoolExecutor(2) as pool:
|
|
pool.map(self.getmap, config.map_rv)
|
|
|
|
if api.network():
|
|
utils.setupdate(f'loc{locid}rv')
|
|
|
|
# Gc
|
|
if utils.lastupdate(f'loc{locid}gc') >= 10800:
|
|
with ThreadPoolExecutor(2) as pool:
|
|
pool.map(self.getmap, config.map_gc)
|
|
|
|
if api.network():
|
|
utils.setupdate(f'loc{locid}gc')
|
|
|
|
# Update
|
|
elif self.mode == 'update' or self.mode == 'kodi':
|
|
|
|
# Wait for service thread
|
|
if self.mode == 'kodi':
|
|
utils.monitor.waitForService()
|
|
|
|
# KODI
|
|
if not config.addon.full:
|
|
for map in config.map:
|
|
self.setdata(map)
|
|
|
|
self.setother()
|
|
utils.setprops()
|
|
|
|
# SKIN
|
|
if config.addon.skin:
|
|
config.addon.api = True
|
|
config.loc.prop = {}
|
|
|
|
for map in config.map:
|
|
self.setdata(map)
|
|
|
|
self.setother()
|
|
utils.setprops()
|
|
|
|
# Update locs
|
|
elif self.mode == 'updatelocs':
|
|
|
|
# KODI
|
|
self.setlocs()
|
|
utils.setprops()
|
|
|
|
# SKIN
|
|
if config.addon.skin:
|
|
config.addon.api = True
|
|
config.loc.prop = {}
|
|
|
|
self.setlocs()
|
|
utils.setprops()
|
|
|
|
# Notification (Queue)
|
|
elif self.mode == 'msgqueue':
|
|
for map in config.map:
|
|
self.msgqueue(map)
|
|
|
|
# Notification (Send)
|
|
elif self.mode == 'msgsend':
|
|
self.notification()
|
|
|
|
### INIT
|
|
def init(self, locid, mode):
|
|
|
|
if mode == 'download':
|
|
utils.log(f'[LOC{locid}] Initialising: mode={mode}, neterr={config.neterr}, net={api.network()}, dnscache={len(config.dnscache)}', 3)
|
|
else:
|
|
utils.log(f'[LOC{locid}] Initialising: mode={mode}', 3)
|
|
|
|
# Location
|
|
config.loc(locid)
|
|
|
|
# Vars
|
|
self.mode = mode
|
|
self.data = {}
|
|
self.today = utils.dt('nowloc').strftime('%Y-%m-%d')
|
|
|
|
# Directory
|
|
p = Path(f'{config.addon_cache}/{locid}')
|
|
p.mkdir(parents=True, exist_ok=True)
|
|
|
|
### GET DATA
|
|
def getdata(self, type):
|
|
utils.log(f'[LOC{config.loc.id}] Downloading data: {type}', 3)
|
|
api.getdata(type, config.loc.id, [ config.loc.lat, config.loc.lon, self.today ])
|
|
|
|
### SET DATA
|
|
def setdata(self, type):
|
|
|
|
# Data
|
|
self.data[type] = utils.getfile(f'{config.loc.id}/{type}.json')
|
|
if not self.data[type]:
|
|
utils.log(f'No {type} data for location {config.loc.id}', 2)
|
|
return
|
|
|
|
# Index
|
|
indexnow = utils.index("now", self.data[type])
|
|
indexmid = utils.index("mid", self.data[type])
|
|
indexday = utils.index("day", self.data[type])
|
|
|
|
# Update data
|
|
utils.log(f'[LOC{config.loc.id}] Updating data: {type}', 3)
|
|
|
|
for map in config.map.get(type):
|
|
|
|
# Current (Compatibility)
|
|
if map[0] == 'current':
|
|
self.setmap(type, map)
|
|
|
|
# Current (Advanced)
|
|
elif map[0] == 'currentskin' and config.addon.api:
|
|
self.setmap(type, map)
|
|
|
|
# Current (KODI)
|
|
elif map[0] == 'currentkodi' and self.mode == 'kodi':
|
|
self.setmap(type, map)
|
|
|
|
# Hourly (Compatibility)
|
|
elif map[0] == 'hourly':
|
|
self.setmulti(type, [ map, 'hourly', indexnow, config.maxhours, config.minhours, 'hourly' ])
|
|
|
|
if config.addon.enablehour:
|
|
self.setmulti(type, [ map, 'hourly', indexmid, config.maxhours, config.minhours, 'hour' ])
|
|
|
|
# Hourly (Advanced)
|
|
elif map[0] == 'hourlyskin' and config.addon.api:
|
|
self.setmulti(type, [ map, 'hourly', indexnow, config.maxhours, config.minhours, 'hourly' ])
|
|
|
|
if config.addon.enablehour:
|
|
self.setmulti(type, [ map, 'hourly', indexmid, config.maxhours, config.minhours, 'hour' ])
|
|
|
|
# Daily (Compatibility)
|
|
elif map[0] == 'daily':
|
|
self.setmulti(type, [ map, 'daily', indexday, config.maxdays, config.mindays, 'daily' ])
|
|
|
|
if not config.addon.api:
|
|
self.setmulti(type, [ map, 'daily', indexday, config.maxdays, config.mindays, 'day' ])
|
|
|
|
# Daily (Advanced)
|
|
elif map[0] == 'dailyskin' and config.addon.api:
|
|
self.setmulti(type, [ map, 'daily', indexday, config.maxdays, config.mindays, 'daily' ])
|
|
|
|
# Daily (KODI)
|
|
elif map[0] == 'dailykodi' and self.mode == 'kodi':
|
|
self.setmulti(type, [ map, 'daily', indexday, config.maxdays, config.mindays, 'daily' ])
|
|
self.setmulti(type, [ map, 'daily', indexday, config.maxdays, config.mindays, 'day' ])
|
|
|
|
# TimeOfDay
|
|
elif map[0] == 'timeofday':
|
|
self.setmap(type, map)
|
|
|
|
# Graph
|
|
elif map[0] == 'graph':
|
|
self.setmap(type, map)
|
|
|
|
# Alert
|
|
if map[3] == 'graph':
|
|
self.setalert(type, [ map, indexnow ])
|
|
|
|
### SET CURRENT
|
|
def setcurrent(self, type, locid):
|
|
|
|
# Data
|
|
self.data[type] = utils.getfile(f'{locid}/{type}.json')
|
|
if not self.data[type]:
|
|
utils.log(f'No {type} data for location {locid}', 2)
|
|
return
|
|
|
|
# Update data
|
|
utils.log(f'[LOC{locid}] Updating current: {type}', 3)
|
|
|
|
for map in config.map.get(type):
|
|
|
|
# Current (Compatibility)
|
|
if map[0] == 'current':
|
|
self.setmap(type, map, locid=locid)
|
|
|
|
# Current (Advanced)
|
|
elif map[0] == 'currentskin' and config.addon.api:
|
|
self.setmap(type, map, locid=locid)
|
|
|
|
### SET LOCATIONS
|
|
def setlocs(self):
|
|
locs = 0
|
|
for locid in range(1, config.addon.maxlocs):
|
|
loc = utils.setting(f'loc{locid}')
|
|
locuser = utils.setting(f'loc{locid}user')
|
|
|
|
if loc:
|
|
locs += 1
|
|
|
|
# Set "Current.X" only if called from service
|
|
if self.mode != 'kodi':
|
|
for map in config.map:
|
|
self.setcurrent(map, locid)
|
|
|
|
if locuser:
|
|
utils.addprop(f'location{locid}', locuser)
|
|
else:
|
|
utils.addprop(f'location{locid}', loc)
|
|
else:
|
|
utils.addprop(f'location{locid}', '')
|
|
|
|
utils.addprop('locations', locs)
|
|
|
|
## SET ALERT
|
|
def setalert(self, src, map):
|
|
winprops = [ 'name', 'value', 'icon', 'unit', 'time', 'hours', 'status' ]
|
|
|
|
data = self.data[src]
|
|
type = map[0][2][1]
|
|
idx = map[1]
|
|
prop = config.alert.map[type]['type']
|
|
unit = config.alert.map[type]['unit']
|
|
icon = config.alert.map[type]['icon']
|
|
name = utils.locaddon(config.alert.map[type]['loc'])
|
|
hours = 0
|
|
code = 0
|
|
value = 0
|
|
|
|
# Invalid index
|
|
if not idx:
|
|
utils.log('Index invalid, weather data is not up to date ...', 3)
|
|
return
|
|
|
|
# Alert disabled
|
|
if not utils.setting(f'alert_{prop}_enabled', 'bool', True):
|
|
utils.log(f'Disabled alert: {prop}', 3)
|
|
|
|
utils.addprop(f'alert.{prop}', '')
|
|
for winprop in winprops:
|
|
utils.addprop(f'alert.{prop}.{winprop}', '')
|
|
|
|
return
|
|
|
|
# Checking alert
|
|
utils.log(f'Checking alert: {prop}', 3)
|
|
l = []
|
|
ll = []
|
|
|
|
for index in range(idx, idx + config.addon.alerthours):
|
|
|
|
try:
|
|
v = int(data[map[0][1][0]][map[0][1][1]][index])
|
|
vv = int(data[map[0][1][0]]['time'][index])
|
|
except:
|
|
if not self.mode == 'msgqueue':
|
|
utils.addprop(f'alert.{prop}', 0)
|
|
for winprop in winprops:
|
|
utils.addprop(f'alert.{prop}.{winprop}', '')
|
|
return
|
|
else:
|
|
l.append(v)
|
|
ll.append(vv)
|
|
|
|
for c, d in [(x, y) for x in [ 3, 2, 1 ] for y in [ 'high', 'low', 'wmo' ] ]:
|
|
alert = f'alert_{prop}_{d}_{c}'
|
|
last = False
|
|
|
|
try:
|
|
if d == 'wmo':
|
|
limit = list(config.alert.map[type][alert].split(' '))
|
|
else:
|
|
limit = int(config.alert.map[type][alert])
|
|
except:
|
|
continue
|
|
|
|
for idx, v in enumerate(l):
|
|
|
|
if d == 'high':
|
|
if v >= limit:
|
|
hours += 1
|
|
if last and v > last:
|
|
code, value, last, stamp = c, v, v, ll[idx]
|
|
elif not last:
|
|
code, value, last, stamp = c, v, v, ll[idx]
|
|
elif d == 'low':
|
|
if v <= limit:
|
|
hours += 1
|
|
if last and v < last:
|
|
code, value, last, stamp = c, v, v, ll[idx]
|
|
elif not last:
|
|
code, value, last, stamp = c, v, v, ll[idx]
|
|
elif d == 'wmo':
|
|
for wmo in limit:
|
|
if v == int(wmo):
|
|
hours += 1
|
|
if last and v > last:
|
|
code, value, last, stamp = c, v, v, ll[idx]
|
|
elif not last:
|
|
code, value, last, stamp = c, v, v, ll[idx]
|
|
if hours:
|
|
break
|
|
|
|
# Check alert code
|
|
if code != 0:
|
|
icon = f'{icon}{code}'
|
|
time = conv.time('time', stamp)
|
|
|
|
if prop == 'condition':
|
|
icon = f'{config.map_alert_condition.get(value)}{code}'
|
|
value = config.localization.wmo.get(f'{value}d')
|
|
else:
|
|
value, unit = conv.item(value, unit)
|
|
|
|
# Notification Queue
|
|
if self.mode == 'msgqueue':
|
|
if code == 1 and utils.setting(f'alert_{prop}_notice', 'bool'):
|
|
config.addon.msgqueue.append([ f'{config.loc.short} - {utils.locaddon(32340)} ({hours} {utils.locaddon(32288)})', f'({time}) {name}: {value}{unit}', f'{config.addon_icons}/alert/{icon}.png' ])
|
|
elif code == 2 and utils.setting(f'alert_{prop}_caution', 'bool'):
|
|
config.addon.msgqueue.append([ f'{config.loc.short} - {utils.locaddon(32341)} ({hours} {utils.locaddon(32288)})', f'({time}) {name}: {value}{unit}', f'{config.addon_icons}/alert/{icon}.png' ])
|
|
elif code == 3 and utils.setting(f'alert_{prop}_danger', 'bool'):
|
|
config.addon.msgqueue.append([ f'{config.loc.short} - {utils.locaddon(32342)} ({hours} {utils.locaddon(32288)})', f'({time}) {name}: {value}{unit}', f'{config.addon_icons}/alert/{icon}.png' ])
|
|
|
|
return
|
|
|
|
# Set alert properties
|
|
utils.log(f'Updating alert: {prop} = {code}', 3)
|
|
config.addon.alerts += 1
|
|
|
|
utils.addprop(f'alert.{prop}', code)
|
|
utils.addprop(f'alert.{prop}.name', name)
|
|
utils.addprop(f'alert.{prop}.time', time)
|
|
utils.addprop(f'alert.{prop}.hours', hours)
|
|
utils.addprop(f'alert.{prop}.icon', f'{config.addon_icons}/alert/{icon}.png')
|
|
utils.addprop(f'alert.{prop}.value', value)
|
|
utils.addprop(f'alert.{prop}.unit', unit)
|
|
|
|
if code == 1:
|
|
utils.addprop(f'alert.{prop}.status', utils.locaddon(32340))
|
|
elif code == 2:
|
|
utils.addprop(f'alert.{prop}.status', utils.locaddon(32341))
|
|
elif code == 3:
|
|
utils.addprop(f'alert.{prop}.status', utils.locaddon(32342))
|
|
|
|
else:
|
|
if self.mode == 'msgqueue':
|
|
return
|
|
|
|
utils.addprop(f'alert.{prop}', 0)
|
|
for winprop in winprops:
|
|
utils.addprop(f'alert.{prop}.{winprop}', '')
|
|
|
|
### SET QUEUE
|
|
def msgqueue(self, type):
|
|
|
|
# Data
|
|
self.data[type] = utils.getfile(f'{config.loc.id}/{type}.json')
|
|
if not self.data[type]:
|
|
utils.log(f'No {type} data for location {config.loc.id}', 2)
|
|
return
|
|
|
|
# Index
|
|
indexnow = utils.index("now", self.data[type])
|
|
|
|
# Update msgqueue
|
|
for map in config.map.get(type):
|
|
|
|
# Alert
|
|
if map[3] == 'graph':
|
|
self.setalert(type, [ map, indexnow ])
|
|
|
|
### SET MULTI
|
|
def setmulti(self, src, map):
|
|
data = self.data[src]
|
|
time = map[1]
|
|
idx = map[2]
|
|
max = map[3]
|
|
min = map[4]
|
|
prop = map[5]
|
|
|
|
if config.addon.api is False and ( prop == 'hourly' or prop == 'daily' ):
|
|
count = 1
|
|
else:
|
|
count = 0
|
|
|
|
if not idx:
|
|
utils.log('Index invalid, weather data is not up to date ...', 3)
|
|
return
|
|
|
|
for index in range(idx, idx + max, 1):
|
|
map[0][2][0] = prop
|
|
self.setmap(src, map[0], index, count)
|
|
count += 1
|
|
|
|
count = -1
|
|
for index in range(idx - 1, idx - min, -1):
|
|
map[0][2][0] = prop
|
|
self.setmap(src, map[0], index, count)
|
|
count -= 1
|
|
|
|
### SET MAP
|
|
def setmap(self, src, map, idx=None, count=None, locid=None):
|
|
data = self.data[src]
|
|
|
|
# Property
|
|
if idx is not None:
|
|
if map[2][0] == 'day':
|
|
property = f'{map[2][0]}{count}.{map[2][1]}'
|
|
else:
|
|
property = f'{map[2][0]}.{count}.{map[2][1]}'
|
|
else:
|
|
if locid:
|
|
property = f'{map[2][0]}.{locid}.{map[2][1]}'
|
|
else:
|
|
property = f'{map[2][0]}.{map[2][1]}'
|
|
|
|
# Content
|
|
try:
|
|
content = utils.getprop(data, map, idx, count)
|
|
except TypeError as e:
|
|
utils.log(f'{property}: {type(e).__name__} {e}', 4)
|
|
utils.addprop(property, '')
|
|
except Exception as e:
|
|
utils.log(f'{property}: {type(e).__name__} {e}', 3)
|
|
utils.addprop(property, '')
|
|
else:
|
|
utils.addprop(property, content)
|
|
|
|
### GET MAP
|
|
def getmap(self, type):
|
|
|
|
# Layers disabled
|
|
if not type == 'osm':
|
|
if not utils.setting(f'map{type}', 'bool') or not utils.setting(f'loc{config.loc.id}maps', 'bool'):
|
|
return
|
|
|
|
# Check connectivity
|
|
if not api.network():
|
|
utils.log(f'[LOC{config.loc.id}] No network connectivity, maps not available ...', 3)
|
|
return
|
|
|
|
# Download
|
|
utils.log(f'[LOC{config.loc.id}] Downloading map: {type}', 3)
|
|
|
|
map = []
|
|
x, y = utils.lat2coords(config.loc.lat, config.loc.lon, config.addon.mapzoom)
|
|
tiles = [ [ x-1, y-1, 0, 0 ], [ x, y-1, 256, 0 ], [ x+1, y-1, 512, 0 ], [ x-1, y, 0, 256 ], [ x, y, 256, 256 ], [ x+1, y, 512, 256 ], [ x-1, y+1, 0, 512 ], [ x, y+1, 256, 512 ], [ x+1, y+1, 512, 512 ] ]
|
|
|
|
config.mapcache[type] = {}
|
|
|
|
# RV Index
|
|
if type.startswith('rv'):
|
|
time, path = api.getrvindex(type)
|
|
|
|
if time is None or path is None:
|
|
utils.log(f'[LOC{config.loc.id}] RVIndex {type} currently not available ...', 3)
|
|
return
|
|
|
|
# Other
|
|
else:
|
|
time = utils.dt('nowutcstamp')
|
|
path = None
|
|
|
|
# Queue
|
|
for count in range(0,9):
|
|
s, w, n, e = utils.coords2bbox(tiles[count][0], tiles[count][1], config.addon.mapzoom)
|
|
map.append([ config.loc.id, type, count, config.addon.mapzoom, tiles[count][0], tiles[count][1], tiles[count][2], tiles[count][3], path, time, s, w, n, e ])
|
|
|
|
# Download
|
|
with ThreadPoolExecutor(3) as pool:
|
|
pool.map(api.getmap, map)
|
|
|
|
# Merge
|
|
api.mapmerge(map)
|
|
|
|
# Cleanup
|
|
config.mapcache[type] = {}
|
|
|
|
dir = f'{config.addon_cache}/{config.loc.id}'
|
|
files = sorted(list(Path(dir).glob(f'{type}_*')), reverse=True)
|
|
history = config.addon.maphistory
|
|
|
|
for idx in range(0,100):
|
|
|
|
try:
|
|
file = files[idx]
|
|
except:
|
|
break
|
|
else:
|
|
if idx >= history:
|
|
utils.log(f'[LOC{config.loc.id}] Removing old map: {file.stem}', 3)
|
|
os.remove(file)
|
|
|
|
### PROPERTIES
|
|
def setother(self):
|
|
|
|
# Maps
|
|
if config.addon.api:
|
|
index = 0
|
|
else:
|
|
index = 1
|
|
|
|
for layer in config.map_layers:
|
|
|
|
# Layers disabled
|
|
if not utils.setting(f'map{layer}', 'bool') or not utils.setting(f'loc{config.loc.id}maps', 'bool'):
|
|
for item in [ 'area', 'layer', 'heading', 'time', 'legend' ]:
|
|
utils.addprop(f'Map.{index}.{item}', '')
|
|
|
|
index += 1
|
|
continue
|
|
|
|
# Files
|
|
dir = f'{config.addon_cache}/{config.loc.id}'
|
|
files = sorted(list(Path(dir).glob(f'{layer}_*')), reverse=True)
|
|
history = config.addon.maphistory
|
|
|
|
# Area
|
|
if files:
|
|
ut = int(files[0].stem.split('_')[1])
|
|
tz = utils.dt('stamploc', ut)
|
|
date = tz.strftime(config.kodi.date)
|
|
time = tz.strftime(config.kodi.time)
|
|
|
|
utils.addprop(f'Map.{index}.Area', f'{dir}/osm.png')
|
|
utils.addprop(f'Map.{index}.Layer', f'{dir}/{layer}_{ut}.png')
|
|
utils.addprop(f'Map.{index}.Heading', config.localization.layers.get(layer))
|
|
utils.addprop(f'Map.{index}.Time', f'{date} {time}')
|
|
utils.addprop(f'Map.{index}.Legend', '')
|
|
else:
|
|
for item in [ 'area', 'layer', 'heading', 'time', 'legend' ]:
|
|
utils.addprop(f'Map.{index}.{item}', '')
|
|
|
|
# Layers
|
|
for idx in range(0, history):
|
|
|
|
try:
|
|
file = files[idx]
|
|
except:
|
|
utils.addprop(f'Map.{index}.Layer.{idx}', '')
|
|
utils.addprop(f'Map.{index}.Time.{idx}', '')
|
|
else:
|
|
ut = int(file.stem.split('_')[1])
|
|
tz = utils.dt('stamploc', ut)
|
|
date = tz.strftime(config.kodi.date)
|
|
time = tz.strftime(config.kodi.time)
|
|
|
|
utils.addprop(f'Map.{index}.Layer.{idx}', f'{dir}/{layer}_{ut}.png')
|
|
utils.addprop(f'Map.{index}.Time.{idx}', f'{date} {time}')
|
|
|
|
index += 1
|
|
|
|
# Locations
|
|
utils.addprop('current.location', config.loc.name)
|
|
utils.addprop('location', config.loc.name)
|
|
self.setlocs()
|
|
|
|
# Fetched
|
|
for prop in [ 'current', 'weather', 'hourly', 'daily', 'timeofday', 'map' ]:
|
|
utils.addprop(f'{prop}.isfetched', 'true')
|
|
|
|
# Other
|
|
utils.addprop('alerts', config.addon.alerts)
|
|
|
|
if config.addon.api:
|
|
utils.addprop('icons', config.addon.icons)
|
|
utils.addprop('iconsdir', config.addon_icons)
|
|
utils.addprop('Provider', 'open-meteo.com, rainviewer.com, weather.gc.ca, met.no')
|
|
utils.addprop('ProviderLogo', f'{config.addon_path}/resources/banner.png')
|
|
else:
|
|
utils.addprop('WeatherProvider', 'open-meteo.com, rainviewer.com, weather.gc.ca, met.no')
|
|
utils.addprop('WeatherProviderLogo', f'{config.addon_path}/resources/banner.png')
|
|
|
|
### NOTIFICATION
|
|
def notification(self):
|
|
queue = config.addon.msgqueue
|
|
duration = utils.setting('alert_duration', 'int')
|
|
|
|
if queue:
|
|
for alert in queue:
|
|
utils.notification(alert[0], alert[1], alert[2], config.loc.id)
|
|
utils.monitor.waitForAbort(duration)
|
|
if utils.monitor.abortRequested():
|
|
utils.log(f'Abort requested ...', 3)
|
|
break
|
|
|