def authenticate(self, qr_reload):
qr_callback = getattr(self, qr_reload, self.master_qr_code)
with coordinator.mutex:
self.bot: wxpy.Bot = wxpy.Bot(cache_path=os.path.join(efb_utils.get_data_path(self.channel_id), "wxpy.pkl"),
qr_callback=qr_callback,
logout_callback=self.exit_callback)
self.bot.enable_puid(os.path.join(efb_utils.get_data_path(self.channel_id), "wxpy_puid.pkl"))
self.done_reauth.set()
def authenticate(self, qr_reload):
qr_callback = getattr(self, qr_reload, self.master_qr_code)
with coordinator.mutex:
self.bot: wxpy.Bot = wxpy.Bot(cache_path=str(efb_utils.get_data_path(self.channel_id) / "wxpy.pkl"),
qr_callback=qr_callback,
logout_callback=self.exit_callback)
self.bot.enable_puid(
efb_utils.get_data_path(self.channel_id) / "wxpy_puid.pkl",
self.flag('puid_logs')
)
self.done_reauth.set()
if hasattr(self, "slave_message"):
self.slave_message.bot = self.bot
self.slave_message.wechat_msg_register()
def __init__(self, instance_id: Optional[InstanceID] = None):
super().__init__(instance_id)
# load config
self.yaml = YAML()
conf_path = utils.get_config_path(self.middleware_id)
if not conf_path.exists():
conf_path.touch()
self.config = self.yaml.load(conf_path)
self.filters = [self.chat_id_based_filter]
# Mapping
self.FILTER_MAPPING = {
"chat_name_contains": self.chat_name_contains_filter,
"chat_name_matches": self.chat_name_matches_filter,
"message_contains": self.message_contains_filter,
"ews_mp": self.ews_mp_filter
}
# Chat ID based filter init
shelve_path = str(
utils.get_data_path(self.middleware_id) / "chat_id_filter.db")
self.chat_id_filter_db = shelve.open(shelve_path)
atexit.register(self.atexit)
# load other filters
if isinstance(self.config, Mapping):
for i in self.config.keys():
f = self.FILTER_MAPPING.get(i)
if f:
self.filters.append(f)
def __init__(self, master: str):
# self.db = SqliteDatabase(str(base_path / 'ftdata.db'))
base_path: str = utils.get_data_path(master)
self.db: SqliteDatabase = SqliteDatabase(
os.path.join(base_path, 'tgdata.db'))
self.db.connect()
class BaseModel(Model):
class Meta:
database = self.db
class MsgLog(BaseModel):
master_msg_id = TextField(unique=True, primary_key=True)
master_msg_id_alt = TextField(null=True)
slave_message_id = TextField()
text = TextField()
slave_origin_uid = TextField()
slave_origin_display_name = TextField(null=True)
slave_member_uid = TextField(null=True)
slave_member_display_name = TextField(null=True)
media_type = TextField(null=True)
mime = TextField(null=True)
file_id = TextField(null=True)
msg_type = TextField()
sent_to = TextField()
time = DateTimeField(default=datetime.datetime.now, null=True)
self.MsgLog = MsgLog
def __init__(self, instance_id: InstanceID = None):
super().__init__(instance_id)
session_path = efb_utils.get_data_path(
self.channel_id) / "session.pickle"
try:
data = pickle.load(session_path.open('rb'))
self.client = EFMSClient(self, None, None, session_cookies=data)
except FileNotFoundError:
raise EFBException(
self._("Session not found, please authorize your account.\n"
"To do so, run: efms-auth"))
except FBchatUserError as e:
message = str(e) + "\n" + \
self._("You may need to re-authorize your account.\n" +
"To do so, run: efms-auth")
raise EFBException(message)
self.load_config()
self.chat_manager: EFMSChatManager = EFMSChatManager(self)
self.flag: ExperimentalFlagsManager = ExperimentalFlagsManager(self)
self.master_message: MasterMessageManager = MasterMessageManager(self)
self.extra_functions: ExtraFunctionsManager = ExtraFunctionsManager(
self)
# Initialize list of chat from server
self.get_chats()
# Monkey patching
Thread.__eq__ = lambda a, b: a.uid == b.uid
def wizard(profile, instance_id):
data = {}
config_path = efb_utils.get_config_path(TelegramChannel.channel_id)
if Path(config_path).exists():
with config_path.open() as f:
data = yaml.full_load(f)
data['api_id'] = int(input("API id: "))
data['api_hash'] = input("API hash: ")
data['proxy'] = {}
data['proxy']['protocol'] = input("Proxy protocol (http or socks5): ")
data['proxy']['host'] = input("Proxy host: ")
data['proxy']['port'] = int(input("Proxy port: "))
loop = asyncio.get_event_loop()
data_path = efb_utils.get_data_path(TelegramChannel.channel_id)
proxy = (data['proxy']['protocol'], data['proxy']['host'],
data['proxy']['port'])
client = TelegramClient(f'{data_path}/{instance_id}',
data['api_id'],
data['api_hash'],
loop=loop,
proxy=proxy)
client.start()
print(data)
with open(config_path, 'w') as f:
yaml.dump(data, f)
def __init__(self, channel: 'TelegramChannel'):
base_path = utils.get_data_path(channel.channel_id)
self.logger.debug("Loading database...")
database.init(str(base_path / 'tgdata.db'))
database.connect()
self.logger.debug("Database loaded.")
self.task_queue: 'Queue[Optional[Tuple[Callable, Sequence[Any], Dict[str, Any]]]]' = Queue(
)
self.worker_thread = Thread(target=self.task_worker,
name="ETM database worker thread")
self.worker_thread.start()
self.logger.debug("Checking database migration...")
if not ChatAssoc.table_exists():
self._create()
else:
msg_log_columns = {i.name for i in database.get_columns("msglog")}
slave_chat_info_columns = {
i.name
for i in database.get_columns("slavechatinfo")
}
if "file_id" not in msg_log_columns:
self._migrate(0)
elif "pickle" not in msg_log_columns:
self._migrate(1)
elif "slave_chat_group_id" not in slave_chat_info_columns:
self._migrate(2)
self.logger.debug("Database migration finished...")
def __init__(self, channel: EFBChannel):
base_path = utils.get_data_path(channel.channel_id)
database.init(str(base_path / 'tgdata.db'))
database.connect()
if not ChatAssoc.table_exists():
self._create()
elif "file_id" not in {i.name for i in database.get_columns("MsgLog")}:
self._migrate(0)
def authenticate(self, qr_reload, first_start=False):
self.master_qr_picture_id = None
qr_callback = getattr(self, qr_reload, self.master_qr_code)
if getattr(self, 'bot', None): # if a bot exists
self.bot.cleanup()
with coordinator.mutex:
self.bot: wxpy.Bot = wxpy.Bot(cache_path=str(efb_utils.get_data_path(self.channel_id) / "wxpy.pkl"),
qr_callback=qr_callback,
logout_callback=self.exit_callback,
user_agent=self.flag('user_agent'),
start_immediately=not first_start)
self.bot.enable_puid(
efb_utils.get_data_path(self.channel_id) / "wxpy_puid.pkl",
self.flag('puid_logs')
)
self.done_reauth.set()
if hasattr(self, "slave_message"):
self.slave_message.bot = self.bot
self.slave_message.wechat_msg_register()
def __init__(self, profile: str, instance_id: str):
coordinator.profile = profile
self.profile = profile
self.instance_id = instance_id
self.channel_id = FBMessengerChannel.channel_id
if instance_id:
self.channel_id = ModuleID(self.channel_id + "#" + instance_id)
self.config_path = utils.get_config_path(self.channel_id)
self.session_path = utils.get_data_path(
self.channel_id) / "session.pickle"
self.yaml = YAML()
if not self.config_path.exists():
self.build_default_config()
else:
self.data = self.yaml.load(self.config_path.open())
def reauth(self, command=False):
# Remove wxpy.pkl if last edited earlier than 5 minutes ago.
last_session = efb_utils.get_data_path(self.channel_id) / "wxpy.pkl"
if (time.time() - last_session.stat().st_mtime) < (5 * 60):
last_session.unlink()
msg = self._("Preparing to log in...")
qr_reload = self.flag("qr_reload")
if command and qr_reload == "console_qr_code":
msg += "\n" + self._("Please check your log to continue.")
threading.Thread(target=self.authenticate,
args=(qr_reload, ),
name="EWS reauth thread").start()
return msg
def __init__(self, channel: EFBChannel):
base_path = utils.get_data_path(channel.channel_id)
self.db = SqliteDatabase(str(base_path / 'tgdata.db'))
self.db.connect()
class BaseModel(Model):
class Meta:
database = self.db
class ChatAssoc(BaseModel):
master_uid = TextField()
slave_uid = TextField()
class MsgLog(BaseModel):
master_msg_id = TextField(unique=True, primary_key=True)
master_msg_id_alt = TextField(null=True)
slave_message_id = TextField()
text = TextField()
slave_origin_uid = TextField()
slave_origin_display_name = TextField(null=True)
slave_member_uid = TextField(null=True)
slave_member_display_name = TextField(null=True)
media_type = TextField(null=True)
mime = TextField(null=True)
file_id = TextField(null=True)
msg_type = TextField()
sent_to = TextField()
time = DateTimeField(default=datetime.datetime.now, null=True)
class SlaveChatInfo(BaseModel):
slave_channel_id = TextField()
slave_channel_emoji = CharField()
slave_chat_uid = TextField()
slave_chat_name = TextField()
slave_chat_alias = TextField(null=True)
slave_chat_type = CharField()
self.BaseModel = BaseModel
self.ChatAssoc = ChatAssoc
self.MsgLog = MsgLog
self.SlaveChatInfo = SlaveChatInfo
if not ChatAssoc.table_exists():
self._create()
elif "file_id" not in {i.name for i in self.db.get_columns("MsgLog")}:
self._migrate(0)
def __init__(self, instance_id: InstanceID = None):
super().__init__(instance_id)
self.load_config()
self.loop = asyncio.get_event_loop()
data_path = efb_utils.get_data_path(self.channel_id)
proxy = (self.config['proxy']['protocol'],
self.config['proxy']['host'], self.config['proxy']['port'])
self.client: TelegramClient = TelegramClient(
f'{data_path}/{instance_id}',
self.config['api_id'],
self.config['api_hash'],
loop=self.loop,
proxy=proxy).start()
self.get_chat_cache: Dict[str, ChatID] = {}
self.task = None
self._main_thread_name = threading.current_thread().name
def __init__(self, channel: EFBChannel):
base_path = utils.get_data_path(channel.channel_id)
database.init(str(base_path / 'tgdata.db'))
database.connect()
self.task_queue: 'Queue[Optional[Tuple[Callable, Sequence[Any], Dict[str, Any]]]]' = Queue()
self.worker_thread = Thread(target=self.task_worker)
self.worker_thread.start()
if not ChatAssoc.table_exists():
self._create()
else:
msg_log_columns = {i.name for i in database.get_columns("MsgLog")}
if "file_id" not in msg_log_columns:
self._migrate(0)
elif "pickle" not in msg_log_columns:
self._migrate(1)
def run(instance, profile):
coordinator.profile = profile
channel_id = FBMessengerChannel.channel_id
if instance:
channel_id += f"#{instance}"
path = utils.get_data_path(channel_id)
print(
_("EFB Facebook Messenger Slave Session Updater\n"
"============================================"))
print()
print(_("You are running EFMS {0}.").format(__version__))
print()
print(
_("This will update and overwrite your EFMS token by\n"
"log into your account again manually."))
print()
print(
_("You usually need to do this when you want to log into\n"
"a new account, or when the previous session is expired."))
print()
print(_("This session is written to\n" "{0}").format(path))
print()
print(_("To continue, press Enter/Return."))
input()
email = input(_("Email: "))
password = getpass.getpass(_("Password: "******"Log in failed. Please check the information above and try again."
))
exit(1)
session_path = path / "session.pickle"
with session_path.open('wb') as f:
pickle.dump(client.getSession(), f)
print(
_("Your session has been successfully updated. It's stored at\n"
"{0}").format(session_path))
print(
_("Your session cookies is as valuable as your account credential.\n"
"Please keep them with equal care."))
def __init__(self, instance_id: str = None):
super().__init__(instance_id)
storage_path = utils.get_data_path(self.middleware_id)
config_path = utils.get_config_path(self.middleware_id)
if not os.path.exists(storage_path):
os.makedirs(storage_path)
if not os.path.exists(config_path):
raise EFBException("Filter middleware is not configured.")
else:
config = yaml.safe_load(open(config_path, encoding="UTF-8"))
self.config_version = 0
self.match_mode = config.get("match_mode") # fuzz and exact
if self.match_mode is None:
self.match_mode = "fuzz"
self.logger = logging.getLogger("xzsk2.filter")
hdlr = logging.FileHandler('./xzsk2.filter.log', encoding="UTF-8")
formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
hdlr.setFormatter(formatter)
self.logger.addHandler(hdlr)
self.logger.setLevel(logging.ERROR)
def init_client_manager(self):
self.Helper = Helper(self, efb_utils.get_data_path(self.channel_id),
self.hostname, self.port)
self.Helper.start_polling()
def __init__(self, instance_id: str = None):
super().__init__(instance_id)
storage_path = utils.get_data_path(self.middleware_id)
config_path = utils.get_config_path(self.middleware_id)
if not os.path.exists(storage_path):
os.makedirs(storage_path)
if not os.path.exists(config_path):
# raise EFBException(self._("GnuPG middleware is not configured."))
pass
else:
pass
# config = yaml.load(open(config_path))
# # self.key = config['key']
# # self.always_trust = config.get('always_trust', self.always_trust)
# # self.binary = config.get('binary', self.binary)
# # self.password = config.get('password', self.password)
# # self.server = config.get('server', self.server)
# self.apikey = config.get('apikey', self.apikey).strip()
# self.mappings_path = os.path.join(storage_path, "keymap.pkl")
# if os.path.exists(self.mappings_path):
# self.mappings = pickle.load(open(self.mappings_path, 'rb'))
self.chat = efbchat.SystemChat(
middleware=self,
# channel_name=self.middleware_name,
module_name=self.middleware_name,
# channel_id=self.middleware_id,
module_id=self.middleware_id,
channel_emoji="🤖",
uid="__trysh.trysh__",
# chat_name=self.middleware_name,
) # EFBChat()
self.chat.channel_name = self.middleware_name
self.chat.module_name = self.middleware_name
self.chat.channel_id = self.middleware_id
self.chat.module_id = self.middleware_id
self.chat.channel_emoji = "🤖"
self.chat.uid = "__trysh.trysh__"
self.chat.chat_name = self.middleware_name
# self.chat.chat_type = ChatType.System
# self.chatMember = efbchat.ChatMember(
# chat=self.chat,
# middleware=self,
# # channel_name=self.middleware_name,
# # module_name=self.middleware_name,
# # channel_id=self.middleware_id,
# # module_id=self.middleware_id,
# # channel_emoji="🤖",
# uid="__trysh.trysh__",
# # chat_name=self.middleware_name,
# ) # EFBChat()
self.chat.channel_name = self.middleware_name
self.chat.module_name = self.middleware_name
self.chat.channel_id = self.middleware_id
self.chat.module_id = self.middleware_id
self.chat.channel_emoji = "🤖"
self.chat.uid = "__trysh.trysh__"
self.chat.chat_name = self.middleware_name
self.logger = logging.getLogger("trysh.trysh")
self.logger.log(99, f"trysh init ok v:{version}")
# self.logger.setLevel(99)
self.t1: threading.Thread = None
self.t2: threading.Thread = None
self.t1q: queue.Queue = None
self.t2q: queue.Queue = queue.Queue()
