NovaBryan/EVE_Dump
Log | Files | 📦 下载最新源码 (.zip) | Refs | README

shipSkinLicensesSvc.py (8818B)

      1 #Embedded file name: C:\BuildAgent\work\20d73f1b24eed06e\eve\release\V24.01\packages\cosmetics\client\shipSkinLicensesSvc.py
      2 import uthread
      3 import logging
      4 from carbon.common.script.sys.serviceConst import ROLE_PROGRAMMER
      5 from cosmetics.client.messengers.cosmetics.ship.shipSkinLicenseNoticeMessenger import PublicShipSkinLicenseNoticeMessenger
      6 from cosmetics.client.messengers.cosmetics.ship.shipSkinLicenseRequestMessenger import PublicShipSkinLicenseRequestMessenger
      7 from cosmetics.client.ships import ship_skin_signals
      8 from cosmetics.client.ships import ship_skin_svc_signals
      9 from cosmetics.client.ships.skins.errors import GetSkinLicensesFailed
     10 from cosmetics.client.ships.skins.live_data.skin_license import SkinLicense
     11 logger = logging.getLogger(__name__)
     12 _instance = None
     13 
     14 def get_ship_skin_license_svc():
     15     global _instance
     16     if _instance is None:
     17         _instance = _ShipSkinLicensesController()
     18     return _instance
     19 
     20 
     21 class _ShipSkinLicensesController(object):
     22     __notifyevents__ = ['OnSessionChanged']
     23 
     24     def __init__(self):
     25         self._cache = {}
     26         self._owned_license_ids = []
     27         self._my_licenses_fetched_already = False
     28         self._licenses_flagged_as_new = set()
     29         public_gateway = sm.GetService('publicGatewaySvc')
     30         self._request_messenger = PublicShipSkinLicenseRequestMessenger(public_gateway)
     31         self._notice_messenger = PublicShipSkinLicenseNoticeMessenger(public_gateway)
     32         sm.RegisterNotify(self)
     33         ship_skin_svc_signals.on_skin_license_added_internal.connect(self._on_license_added)
     34         ship_skin_svc_signals.on_skin_license_updated_internal.connect(self._on_license_updated)
     35         ship_skin_svc_signals.on_skin_license_deleted_internal.connect(self._on_license_deleted)
     36 
     37     def __del__(self):
     38         ship_skin_svc_signals.on_skin_license_added_internal.disconnect(self._on_license_added)
     39         ship_skin_svc_signals.on_skin_license_updated_internal.disconnect(self._on_license_updated)
     40         ship_skin_svc_signals.on_skin_license_deleted_internal.disconnect(self._on_license_deleted)
     41 
     42     def OnSessionChanged(self, _isRemote, _sess, change):
     43         if 'charid' in change:
     44             self._clear_cache()
     45 
     46     def _clear_cache(self):
     47         self._cache = {}
     48         self._owned_license_ids = []
     49         self._my_licenses_fetched_already = False
     50         self._licenses_flagged_as_new.clear()
     51 
     52     def get_my_licenses(self, force_refresh = False):
     53         owner_character_id = session.charid
     54         if force_refresh or not self._my_licenses_fetched_already:
     55             self._owned_license_ids = self._request_messenger.get_owned_request()
     56             exc = self._get_licenses_parallel(self._owned_license_ids, owner_character_id)
     57             if exc is None:
     58                 self._my_licenses_fetched_already = True
     59             else:
     60                 logger.exception(exc)
     61         return self._cache.get(owner_character_id, {})
     62 
     63     def get_my_activated_licenses(self, ship_type_id = None):
     64         licenses = self.get_my_licenses().values()
     65         if ship_type_id:
     66             return [ l for l in licenses if l.activated and l.skin_design.ship_type_id == ship_type_id ]
     67         return [ l for l in licenses if l.activated ]
     68 
     69     def get_my_unactivated_licenses(self):
     70         licenses = self.get_my_licenses().values()
     71         return [ l for l in licenses if l.nb_unactivated > 0 ]
     72 
     73     def get_my_licenses_that_are_available_to_use_or_sell(self):
     74         licenses = self.get_my_licenses().values()
     75         return [ l for l in licenses if l.nb_unactivated > 0 or l.activated ]
     76 
     77     def get_license(self, license_id, owner_character_id, force_refresh = False):
     78         if license_id not in self._cache.get(owner_character_id, {}) or force_refresh:
     79             license = self._request_messenger.get_request(license_id, owner_character_id)
     80             self._load_license_skin_data(license)
     81             if owner_character_id not in self._cache:
     82                 self._cache[owner_character_id] = {}
     83             self._cache[owner_character_id][license_id] = license
     84         return self._cache.get(owner_character_id, {}).get(license_id, None)
     85 
     86     def activate_license(self, license_id):
     87         owner_character_id = session.charid
     88         self._request_messenger.activate_request(license_id, owner_character_id)
     89         if owner_character_id in self._cache and license_id in self._cache[owner_character_id]:
     90             self._cache[owner_character_id][license_id].activated = True
     91         ship_skin_signals.on_skin_license_activated(license_id)
     92 
     93     def admin_grant_license(self, skin_hex, nb_licenses):
     94         if session and session.role & ROLE_PROGRAMMER:
     95             self._request_messenger.admin_grant_request(skin_hex, nb_licenses)
     96 
     97     def admin_revoke_license(self, skin_hex):
     98         if session and session.role & ROLE_PROGRAMMER:
     99             self._request_messenger.admin_revoke_request(skin_hex, session.charid)
    100 
    101     def set_license_is_new_flag(self, license_id, is_new):
    102         if is_new:
    103             self._licenses_flagged_as_new.add(license_id)
    104         else:
    105             self._licenses_flagged_as_new.discard(license_id)
    106 
    107     def is_license_new(self, license_id):
    108         return license_id in self._licenses_flagged_as_new
    109 
    110     def apply_internal(self, license_id, ship_id, apply_license = True):
    111         if apply_license:
    112             self._request_messenger.apply_request(license_id, ship_id, session.charid)
    113         else:
    114             self._request_messenger.unapply_request(license_id, ship_id, session.charid)
    115 
    116     def _get_licenses_parallel(self, license_ids, owner_character_id, force_refresh = False):
    117         parallel_calls = []
    118         for license_id in license_ids:
    119             parallel_calls.append((self._get_license_no_exc, (license_id, owner_character_id, force_refresh)))
    120 
    121         results = uthread.parallel(parallel_calls)
    122         failed_licenses = [ (license_id, err_msg) for license_id, err_msg in results if err_msg is not None ] if results else []
    123         if len(failed_licenses) > 0:
    124             return GetSkinLicensesFailed(failed_licenses)
    125 
    126     def _get_license_no_exc(self, license_id, owner_character_id, force_refresh = False):
    127         try:
    128             self.get_license(license_id, owner_character_id, force_refresh)
    129             return (license_id, None)
    130         except Exception as e:
    131             return (license_id, e.message)
    132 
    133     def _load_license_skin_data(self, license):
    134         if license:
    135             license.load_skin_design()
    136 
    137     def _on_license_added(self, license_id, license_data):
    138         if license_data.owner_character_id not in self._cache:
    139             self._cache[license_data.owner_character_id] = {}
    140         self._cache[license_data.owner_character_id][license_id] = license_data
    141         self._load_license_skin_data(license_data)
    142         if license_data.owner_character_id == session.charid:
    143             self._owned_license_ids.append(license_id)
    144             self.set_license_is_new_flag(license_id, is_new=True)
    145         logger.info('SKIN LICENSES - License %s added, license data is %s' % (license_id, license_data))
    146         ship_skin_signals.on_skin_license_added(license_id, license_data)
    147 
    148     def _on_license_updated(self, license_id, license_data, previous_license_data):
    149         if license_data.owner_character_id not in self._cache:
    150             self._cache[license_data.owner_character_id] = {}
    151         self._load_license_skin_data(license_data)
    152         if license_id in self._cache[license_data.owner_character_id]:
    153             self._cache[license_data.owner_character_id][license_id].copy_from_other(license_data)
    154         else:
    155             self._cache[license_data.owner_character_id][license_id] = license_data
    156         if license_data.owner_character_id == session.charid:
    157             self._owned_license_ids.append(license_id)
    158             self._set_license_is_new_flag(license_id, license_data, previous_license_data)
    159         logger.info('SKIN LICENSES - License %s updated to %s' % (license_id, license_data))
    160         ship_skin_signals.on_skin_license_updated(license_id, license_data)
    161 
    162     def _set_license_is_new_flag(self, license_id, license_data, previous_license_data):
    163         did_aquire_unactivated_license = license_data.nb_unactivated > previous_license_data.nb_unactivated
    164         if did_aquire_unactivated_license:
    165             self.set_license_is_new_flag(license_id, is_new=True)
    166 
    167     def _on_license_deleted(self, license_id, owner_character_id):
    168         if owner_character_id in self._cache and license_id in self._cache[owner_character_id]:
    169             self._cache[owner_character_id].pop(license_id)
    170         if license_id in self._owned_license_ids:
    171             self._owned_license_ids.remove(license_id)
    172         logger.info('SKIN LICENSES - License %s deleted' % license_id)
    173         ship_skin_signals.on_skin_license_deleted(license_id)