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"))