def extract(self): logger.info("starting extraction for {} ---->".format(self.company_id)) for dates in self.custom_dates: time.sleep(1) logger.info( f"Downloading data from {dates['from']} to {dates['to']}") created_to = dates["to"] created_from = dates["from"] list_orders = [] next_page = True payload = { "source_name": self.platform, "data": { "orders": list_orders }, "client_id": self.company_id, "store_name": self.store_name, } if self.connector_id is not None: payload.update({"internal_id": self.connector_id}) try: orders = shopify.Order.find( created_at_min=created_from, created_at_max=created_to, status="any", limit=250, ) while next_page is not False: formatted_orders = list( map(lambda order: order.to_dict(), orders)) list_orders += formatted_orders if not list_orders: payload["data"] = "" all_ok = self.send(payload) if all_ok: logger.info("successfully extracted {} orders".format( len(list_orders))) next_page = orders.has_next_page() orders = orders.next_page() if next_page else None list_orders.clear() time.sleep(3) time.sleep(2) except Exception as e: logger.error( e, extra={ "store_name": self.store_name, "client_id": self.company_id, }, )
def set_up(self): try: shop_url = "https://%s:%s@%s.myshopify.com/admin/api/%s" % ( self.store_token, self.password, self.store_name, self.API_VERSION, ) shopify.ShopifyResource.set_site(shop_url) logger.info("successful setup for {}".format(self.company_id)) return True except Exception as e: logger.error( e, extra={ "store_name": self.store_name, "client_id": self.company_id, }, )
async def on_raw_reaction_remove(self, payload): async with session_lock: with Session() as session: server = server_crud.get_by_discord(session, payload.guild_id) if server and str(payload.message_id) == server.role_message: db_player = player_crud.get_by_discord( session, payload.user_id ) # Stop if player not registered if db_player is None: logger.error( f"Player not found for {payload.user_id}." ) return db_member = member_crud.get_by_ids( session, db_player.uuid, server.uuid ) # Stop if member not registered if db_member is None: logger.error( f"Member not found for {payload.user_id}." ) return e = payload.emoji.name emoji = emoji_crud.get_by_identifier(session, e) if not emoji: logger.error( f"Emoji requested with {e} not " f"found on {server.name}." ) return found, d_id = remove_from_role( session, db_member.uuid, role_uuid=emoji.role_uuid ) # Stop if wasn't found if not found: logger.error( f"Role not found for emoji {emoji.identifier} " f"on {server.name}." ) return try: guild = self.__bot.get_guild(payload.guild_id) role = guild.get_role(int(d_id)) await guild.get_member(payload.user_id).remove_roles( role, reason="Removed through role reaction." ) except Forbidden: logger.error( "Forbidden: Not enough permissions to manage roles." ) except HTTPException: logger.error( "HTTPException: Something went wrong while changing roles" )
async def role_update(self): """ Update roles stored every 30 minutes :return: """ await self.__bot.wait_until_ready() logger.info("Updating role messages...") async with session_lock: with Session() as session: # Go through all visible guilds for guild in self.__bot.guilds: server = server_crud.get_by_discord(session, guild.id) # Skip if server is not found if server is None: continue # Get all roles for server roles = role_crud.get_multi_by_server_uuid( session, server.uuid ) temp_roles = {} for r in roles: temp_roles[r.discord_id] = r # Go through all roles of a guild for r in guild.roles: # Skip roles that are default or premium if r.is_default or r.is_premium_subscriber: continue # Check that role is registered, otherwise skip if r.id not in temp_roles: continue # If the name is the same, then skip if r.name == temp_roles[r.id].name: continue role_update = UpdateRole(**{ "name": r.name }) # Update role role_crud.update( session, temp_roles[r.id], role_update ) # Update role message if it exists if server.role_message is not None and \ server.role_channel is not None: channel = self.__bot.get_channel( int(server.role_channel) ) # Continue if channel wasn't found if channel is None: logger.info(f"No channel found for {server.name}.") continue # Channel must not be bloated with messages message = utils.find( lambda m: (m.id == int(server.role_message)), await channel.history(limit=10).flatten() ) # Continue if message wasn't found if message is None: logger.info(f"No message found for {server.name}.") continue # Get context ctx = await self.__bot.get_context(message) embed = Embed() embed.title = f"Assignable roles for " \ f"**{message.guild.name}**" embed.description = "Use reactions inorder to get " \ "roles assigned to you, or use " \ "`!role add roleName`" converter = commands.EmojiConverter() pconverter = commands.PartialEmojiConverter() # Get all roles of a server roles = role_crud.get_multi_by_server_uuid( session, server.uuid ) # Gather all used emojis for future reactions emojis = [] for ro in roles: emoji = emoji_crud.get_by_role(session, ro.uuid) try: # Convert into actual emoji e = await converter.convert( ctx, emoji.identifier ) except commands.EmojiNotFound: # Try partial emoji instead try: e = await pconverter.convert( ctx, emoji.identifier ) except commands.PartialEmojiConversionFailure: # Assume that it is an unicode emoji e = emoji.identifier # Add to message embed.add_field( name=f"{str(e)} == {ro.name}", value=ro.description, inline=False ) emojis.append(e) await message.edit(embed=embed) # Check old reactions old_emojis = [] for r in message.reactions: old_emojis.append(r.emoji) # Add new reactions to message for e in emojis: if isinstance(e, discord.partial_emoji.PartialEmoji): logger.error(f"Emoji not cannot be used! Emoji: {e}") elif e not in old_emojis: await message.add_reaction(e) logger.info(f"Message updated for {server.name}.")
def run(max_cpu_time, max_real_time, max_memory, max_stack, max_output_size, max_process_number, exe_path, input_path, output_path, error_path, args, env, log_path, seccomp_rule_name, uid, gid, memory_limit_check_only=0): str_list_vars = ["args", "env"] int_vars = [ "max_cpu_time", "max_real_time", "max_memory", "max_stack", "max_output_size", "max_process_number", "uid", "gid", "memory_limit_check_only" ] str_vars = [ "exe_path", "input_path", "output_path", "error_path", "log_path" ] proc_args = ["ddlc"] for var in str_list_vars: value = vars()[var] if not isinstance(value, list): raise ValueError("{} must be a list".format(var)) for item in value: if not isinstance(item, str): raise ValueError("{} item must be a string".format(var)) proc_args.append("--{}={}".format(var, item)) for var in int_vars: value = vars()[var] if not isinstance(value, int): raise ValueError("{} must be a int".format(var)) if value != UNLIMITED: proc_args.append("--{}={}".format(var, value)) for var in str_vars: value = vars()[var] if not isinstance(value, str): raise ValueError("{} must be a string".format(var)) proc_args.append("--{}={}".format(var, value)) if not isinstance(seccomp_rule_name, str) and seccomp_rule_name is not None: raise ValueError("seccomp_rule_name must be a string or None") if seccomp_rule_name: proc_args.append("--seccomp_rule={}".format(seccomp_rule_name)) logger.debug(' ||| '.join(proc_args)) proc = subprocess.Popen(proc_args, stdout=subprocess.PIPE, stderr=subprocess.PIPE) out, err = proc.communicate() logger.debug(out) if err: logger.error(err) return json.loads(out.decode("utf-8"))