def test_1_hour(self):
self.assertEqual(
set_time.calculate_time(3600).hour,
datetime.utcnow().hour + 1)
self.assertEqual(
set_time.calculate_time(3600).minute,
datetime.utcnow().minute)
def enable_preference(self, user_preference, user_row_id):
enable_preference_query = \
"INSERT INTO user_preference (user_row_id, preference_type, communication_type, source, status, " \
"created_on, updated_on) " \
"VALUES(%s, %s, %s, %s, %s, %s, %s) " \
"ON DUPLICATE KEY UPDATE status = %s, updated_on = %s"
query_response = self._repo.execute(enable_preference_query, [
user_row_id, user_preference.preference_type,
user_preference.communication_type, user_preference.source,
user_preference.status,
dt.utcnow(),
dt.utcnow(), user_preference.status,
dt.utcnow()
])
return query_response
def run_tests(self):
iso = Isotope.Schema().load(self.isotope)
iso.name = "{} - test - {}".format(iso.name, str(datetime.utcnow()))
iso.save()
db.session.commit()
self.calibration['isotope']['id'] = iso.id
test_add_calibration(self.client, data=self.calibration)
self.study['isotope']['id'] = iso.id
study = test_add(self.client, data=self.study)
study_id = study['id']
for file in os.listdir(os.getcwd()):
if '.json' not in file:
fp = os.path.join(os.getcwd(), file)
data = {
'study_id': study_id,
'filename': file,
'file_type_id': 2,
'ordinal_value': 1,
'file': (open(fp, "rb"), file)
}
test_upload_file(self.client, data=data)
test_analyze(self.client, _id=study_id)
test_delete(self.client, _id=study_id)
async def check_inactive_channel(self, server_id: str, channel_id: str, timeout: int):
channel = self.bot.get_channel(channel_id)
if channel is None:
print('timeout check: cannot find channel', channel_id)
return
server = channel.server
has_permissions = channel.permissions_for(server.me).manage_channels
if not has_permissions:
print('no manage channel permissions, disabling', channel_id)
self.settings.set_inactivity_monitor_channel(server_id, channel_id, 0)
return
now = datetime.utcnow()
last_spoke_at = self.channel_last_spoke.get(channel.id)
time_delta = (now - last_spoke_at).total_seconds() if last_spoke_at else 9999
time_exceeded = time_delta > timeout
if time_exceeded and not channel.name.endswith(INACTIVE):
new_name = channel.name + INACTIVE
try:
await self.bot.edit_channel(channel, name=new_name)
except Exception as ex:
print('failed to edit channel: ' + str(ex))
def is_container_created(self, containername):
httpVerb = "HEAD"
algorithm = 'AWS4-HMAC-SHA256'
service = "s3"
aws_request = "aws4_request"
aws_access_key_id = self.user #
aws_secret_access_key = self.passwd #
endpoint_url = self.url #
host = self.url.split("/")[-1] #
region = "us-east-1"
# Create a date for headers and the credential string
t = datetime.utcnow()
amzdate = t.strftime('%Y%m%dT%H%M%SZ')
datestamp = t.strftime('%Y%m%d') # Date w/o time, used in credential scope
canonical_uri = "/" + containername
canonical_headers = 'host:' + host + "\n" # + "x-amz-date:"+ amzdate + "\n"
signed_headers = "host" # "host;x-amz-content-sha256;x-amz-date"
credential_scope = datestamp + '/' + region + '/' + service + '/' + aws_request
# canonical_querystring = bucket_name+"/"+object_name
canonical_querystring = 'X-Amz-Algorithm=AWS4-HMAC-SHA256'
canonical_querystring += '&X-Amz-Credential=' + urllib.parse.quote_plus(
aws_access_key_id + '/' + credential_scope)
canonical_querystring += '&X-Amz-Date=' + amzdate
canonical_querystring += '&X-Amz-Expires=' + str(120)
canonical_querystring += '&X-Amz-SignedHeaders=' + signed_headers
payload_hash = "UNSIGNED-PAYLOAD" # ???????? hashlib.sha256(("").encode("utf-8")).hexdigest()
canonical_request = httpVerb + "\n" + canonical_uri + "\n" + canonical_querystring + "\n" + canonical_headers + '\n' + signed_headers + "\n" + payload_hash
string_to_sign = algorithm + "\n" + amzdate + "\n" + credential_scope + "\n" + hashlib.sha256(
canonical_request.encode("utf-8")).hexdigest()
# Create the signing key
signing_key = self.getSignatureKey(aws_secret_access_key, datestamp, region, service)
# Sign the string_to_sign using the signing_key
signature = hmac.new(signing_key, (string_to_sign).encode("utf-8"), hashlib.sha256).hexdigest()
canonical_querystring += '&X-Amz-Signature=' + signature
# print(f"Canonical request: \n{canonical_request}")
# print(f"String to Sign: \n{string_to_sign}")
url = endpoint_url + canonical_uri + "?" + canonical_querystring
try:
response = requests.head(url)
if response.ok:
return True
return False
except requests.exceptions.ConnectionError as ce:
logging.error(ce.strerror)
return False
async def mod_message_watchdog_user(self, message):
user_id = message.author.id
server_id = message.server.id
watchdog_channel_id = self.settings.getWatchdogChannel(server_id)
user_settings = self.settings.getWatchdogUsers(server_id).get(user_id)
if user_settings is None:
return
cooldown = user_settings['cooldown']
if cooldown <= 0:
return
request_user_id = user_settings['request_user_id']
reason = user_settings['reason'] or 'no reason'
request_user = message.server.get_member(request_user_id)
request_user_txt = request_user.mention if request_user else '???'
now = datetime.utcnow()
last_spoke_at = self.server_user_last[server_id].get(user_id)
self.server_user_last[server_id][user_id] = now
time_since = (now - last_spoke_at).total_seconds() if last_spoke_at else 9999
report = time_since > cooldown
if not report:
return
output_msg = '**Watchdog:** {} spoke in {} ({} monitored because [{}])\n{}'.format(
message.author.mention, message.channel.mention,
request_user_txt, reason, box(message.clean_content))
await self._watchdog_print(watchdog_channel_id, output_msg)
class Server(db.Model):
__tablename__ = 'server'
id = db.Column(db.Integer, primary_key=True)
hostname = db.Column(db.String(30), index=True, default='', unique=True)
os = db.Column(db.String(50), index=True, nullable=True, default='')
manufacturer = db.Column(db.String(100), nullable=True, default='')
manufacture_date = db.Column(db.Date)
server_model = db.Column(db.String(50), nullable=True)
sn = db.Column(db.String(50), nullable=True, default='')
uuid = db.Column(db.String(50), index=True, default='')
cpu_count = db.Column(db.Integer, nullable=True, default='')
cpu_model = db.Column(db.String(50), nullable=True, default='')
memory_size = db.Column(db.Integer, nullable=True, default='')
memory_slots_count = db.Column(db.Integer, nullable=True, default='')
memory_slot_use = db.Column(db.Integer, nullable=True, default='')
memory_slot_info = db.Column(db.Text, nullable=True, default='')
disk_info = db.Column(db.Text, nullable=True, default='')
nic_info = db.Column(db.Text, nullable=True, default='')
last_op_time = db.Column(db.DateTime,
nullable=True,
default=datetime.utcnow())
dev_interface = db.Column(db.Integer, nullable=True, default=0)
is_vm = db.Column(db.Integer, index=True, nullable=True, default=0)
status = db.Column(db.Integer, nullable=False, index=True, default=1)
product_id = db.Column(db.Integer, db.ForeignKey('product.id'), default=0)
ops_interface = db.Column(db.Integer,
db.ForeignKey('people.id'),
default=0)
idc_id = db.Column(db.Integer, db.ForeignKey('idc.id'), default=0)
people = db.relationship('People')
product = db.relationship('Product')
idc = db.relationship('Idc')
def sync(config, state, catalog):
""" Sync data from tap source """
if not bool(state):
state = state_hash()
# Loop over selected streams in catalog
for stream in catalog.get_selected_streams(state):
LOGGER.info('Syncing stream:' + stream.tap_stream_id)
singer.write_schema(
stream_name=stream.tap_stream_id,
schema=stream.schema.to_dict(),
key_properties=stream.key_properties,
)
current_time = datetime.utcnow().isoformat(sep='T',
timespec='milliseconds')
filter_datetime = state.get(stream.tap_stream_id,
{}).get('last_synced',
'1970-01-01T00:00:00.000')
# Sync records via API
api_sync.sync(stream.tap_stream_id, filter_datetime)
state[stream.tap_stream_id] = {
'synced': True,
'last_synced': current_time
}
singer.write_state(state)
async def on_ready(self):
LOGGER.info('Bot is ready.')
self.start_time = datetime.utcnow()
await self.change_presence(activity=discord.Game(name=config.PLAYING))
# make mentionable.
self.command_prefix.extend(
[f'<@!{self.user.id}> ', f'<@{self.user.id}> '])
def post(self, request, *args, **kwargs):
request_data = request.data
if 'email' in request_data:
request_data['email'] = request_data.get('email').lower()
serializer = self.get_serializer(data=request_data,
context={'request': request})
if serializer.is_valid():
user = serializer.object.get('user') or request.user
token = serializer.object.get('token')
response_data = jwt_response_payload_handler(token, user, request)
response = Response(response_data)
if api_settings.JWT_AUTH_COOKIE:
expiration = (datetime.utcnow() +
api_settings.JWT_EXPIRATION_DELTA)
response.set_cookie(api_settings.JWT_AUTH_COOKIE,
response.data['token'],
expires=expiration,
httponly=True)
return response
return Response({'message': 'Invalid Password'},
status=status.HTTP_400_BAD_REQUEST)
class Book(db.Model):
__tablename__ = 'book'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(500), nullable=False, index=True)
author = db.Column(db.String(350))
avg_rating = db.Column(db.Float)
format = db.Column(db.String(50))
image = db.Column(db.String(100), unique=True)
num_pages = db.Column(db.Integer)
pub_date = db.Column(db.DateTime, default=datetime.utcnow())
# Relationship
pub_id = db.Column(db.Integer, db.ForeignKey('publication.id'))
def __init__(self, title, author, avg_rating, book_format, image,
num_pages, pub_id):
self.title = title
self.author = author
self.avg_rating = avg_rating
self.format = book_format
self.image = image
self.num_pages = num_pages
self.pub_id = pub_id
def __repr__(self):
return '{} by {}'.format(self.title, self.author)
def make_payload(user):
print("make_payload")
return {
'id_usuario': user.id_usuario,
'email': user.email,
'exp': (datetime.utcnow()+ app.config['JWT_EXPIRATION_DELTA']).isoformat()
}
async def mod_message_watchdog_phrase(self, message):
server_id = message.server.id
watchdog_channel_id = self.settings.getWatchdogChannel(server_id)
for phrase_settings in self.settings.getWatchdogPhrases(server_id).values():
name = phrase_settings['name']
cooldown = phrase_settings['cooldown']
request_user_id = phrase_settings['request_user_id']
phrase = phrase_settings['phrase']
if cooldown <= 0:
continue
now = datetime.utcnow()
last_spoke_at = self.server_phrase_last[server_id].get(name)
time_since = (now - last_spoke_at).total_seconds() if last_spoke_at else 9999
report = time_since > cooldown
if not report:
continue
p = re.compile(phrase, re.IGNORECASE | re.MULTILINE | re.DOTALL)
if p.match(message.clean_content):
self.server_phrase_last[server_id][name] = now
output_msg = '**Watchdog:** {} spoke in {} `(rule [{}] matched phrase [{}])`\n{}'.format(
message.author.mention, message.channel.mention,
name, phrase, box(message.clean_content))
await self._watchdog_print(watchdog_channel_id, output_msg)
return
async def timer(self, ctx, hours: int, minutes: int, *, event: str):
conn, c = await load_db()
# format !events timer h m "event"
dt = datetime.utcnow()
td = timedelta(hours=hours, minutes=minutes)
dt = dt + td
while True:
event_id = random.randint(1, 99999)
event_exists = await self.check_if_event_exists(event_id)
if not event_exists:
dt_long, dt_short = await self.make_string(dt)
with conn:
c.execute(
"INSERT INTO events VALUES(:id, :title, :datetime, :creator_id, :guild_id)",
{
'id': event_id,
'title': event,
'datetime': dt_long,
'creator_id': ctx.author.id,
'guild_id': ctx.guild.id
})
embed = await self.embed_handler(ctx,
dt,
event,
event_id,
update=False)
await ctx.send(embed=embed)
fmt = (ctx.message.author, event, event_id, dt_long)
msg = 'An event was created by {0}.\n{1} [{2}]\n{3}'.format(
*fmt)
await self.spam(ctx, msg)
async def mirror_msg_new(self, message):
if message.author.id == self.bot.user.id or message.channel.is_private:
return
channel = message.channel
mirrored_channels = self.settings.get_mirrored_channels(channel.id)
if not mirrored_channels:
return
last_spoke, last_spoke_timestamp = self.settings.get_last_spoke(channel.id)
now_time = datetime.utcnow()
last_spoke_time = datetime.utcfromtimestamp(
last_spoke_timestamp) if last_spoke_timestamp else now_time
attribution_required = last_spoke != message.author.id
attribution_required |= (
now_time - last_spoke_time).total_seconds() > ATTRIBUTION_TIME_SECONDS
self.settings.set_last_spoke(channel.id, message.author.id)
attachment_bytes = None
if message.attachments:
# If we know we're copying a message and that message has an attachment,
# pre download it and reuse it for every upload.
attachment = message.attachments[0]
if 'url' and 'filename' in attachment:
url = attachment['url']
filename = attachment['filename']
async with aiohttp.ClientSession() as session:
async with session.get(url) as response:
attachment_bytes = io.BytesIO(await response.read())
for dest_channel_id in mirrored_channels:
try:
dest_channel = self.bot.get_channel(dest_channel_id)
if not dest_channel:
continue
if attribution_required:
msg = 'Posted by **{}** in *{} - #{}*:'.format(message.author.name,
message.server.name,
message.channel.name)
await self.bot.send_message(dest_channel, msg)
if attachment_bytes:
dest_message = await self.bot.send_file(dest_channel, attachment_bytes, filename=filename, content=message.content)
attachment_bytes.seek(0)
elif message.content:
dest_message = await self.bot.send_message(dest_channel, message.content)
else:
print('Failed to mirror message from ', channel.id, 'no action to take')
self.settings.add_mirrored_message(
channel.id, message.id, dest_channel.id, dest_message.id)
except Exception as ex:
print('Failed to mirror message from ', channel.id, 'to', dest_channel_id, ':', ex)
traceback.print_exc()
if attachment_bytes:
attachment_bytes.close()
def formatStrikeDateAndDateTime(self, date):
numArray = date.split("/")
strikeMonth = numArray[0].lstrip('0')
strikeDay = numArray[1].lstrip('0')
currentMonth = str(datetime.utcnow().strftime("%m")).lstrip('0')
currentYear = str(datetime.utcnow().strftime("%Y"))
if (strikeMonth < currentMonth):
currentYear = str(int(currentYear) + 1)
self.strikeDate = date
strikeMonth = re.sub('[^0-9]', '', strikeMonth)
strikeDay = re.sub('[^0-9]', '', strikeDay)
self.strikeDateTime = self.getDateTimeObjectFromStrikeDate(
strikeDay, strikeMonth, currentYear)
def onUpdate(self):
self.root.title(str(datetime.utcnow()))
for ele in self._elements:
ele.render(self.__canvas)
self.after(1000, self.onUpdate)
class Userlog(db.Model):
__tablename__ = "userlog"
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("user.id")) # 定义外键
ip = db.Column(db.String(100))
addtime = db.Column(db.DateTime, index=True, default=datetime.utcnow())
def __repr__(self):
return "<Userlog %r>" % self.id
def now():
now = datetime.utcnow()
return DatetimePayload(year=now.year,
month=now.month,
date=now.day,
hour=now.hour,
minute=now.minute,
second=now.second,
meridiem=now.strftime("%p"))
class Preview(db.Model):
__tablename__ = 'preview'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(128), unique=True)
logo = db.Column(db.String(255), unique=True)
addtime = db.Column(db.DateTime, index=True, default=datetime.utcnow())
def __repr__(self):
return '<Preview %r>' % self.title
class Tag(db.Model):
__tablename__ = "tag"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), unique=True)
addtime = db.Column(db.DateTime, index=True, default=datetime.utcnow())
movies = db.relationship("Movie", backref="tag")
def __repr__(self):
return "<Tag %r>" % self.id
class Userlog(db.Model):
__tablename__ = 'userlog'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id')) # 所属会员ID
ip = db.Column(db.String(128)) # 登陆IP
addtime = db.Column(db.DateTime, index=True, default=datetime.utcnow())
def __repr__(self):
return '<Userlog %r>' % self.id
class Tag(db.Model):
__tablename__ = 'tag'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(128), unique=True)
addtime = db.Column(db.DateTime, index=True, default=datetime.utcnow())
movies = db.relationship('Movie', backref='tag') # 电影外键关联
def __repr__(self):
return '<Tag %r>' % self.name
class Auth(db.Model):
__tablename__ = 'auth'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True)
url = db.Column(db.String(255), unique=True)
addtime = db.Column(db.DateTime, index=True, default=datetime.utcnow())
def __repr__(self):
return '<Auth %r>' % self.name
class Moviecol(db.Model):
__tablename__ = 'moviecol'
id = db.Column(db.Integer, primary_key=True)
movie_id = db.Column(db.Integer, db.ForeignKey('movie.id')) # 所属电影ID
user_id = db.Column(db.Integer, db.ForeignKey('user.id')) # 所属用户ID
addtime = db.Column(db.DateTime, index=True, default=datetime.utcnow())
def __repr__(self):
return '<Moviecol %r>' % self.id
def register_user_data(self, user):
""" register user data """
user_data = self.get_user_data_for_given_username(
username=user.username)
if bool(user_data):
raise UserAlreadyExistException()
query_parameters = [
user.email, "", user.origin, user.name, user.email,
user.email_verified, user.email_verified, "", "",
dt.utcnow(),
dt.utcnow()
]
query_response = self._repo.execute(
"INSERT INTO user (username, account_id, origin, name, email, email_verified, status, request_id, "
"request_time_epoch, row_created, row_updated) "
"VALUES(%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)",
query_parameters)
return "SUCCESS"
class Role(db.Model):
__talbename__ = 'role'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True)
auths = db.Column(db.String(512))
addtime = db.Column(db.DateTime, index=True, default=datetime.utcnow())
admins = db.relationship("Admin", backref='role') # 管理员外键关系关联
def __repr__(self):
return '<Role %r>' % self.name
class Role(db.Model):
__tablename__ = "role"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), unique=True)
auths = db.Column(db.String(600))
addtime = db.Column(db.DateTime, index=True, default=datetime.utcnow())
admins = db.relationship("Admin", backref="role")
def __repr__(self):
return "<Role %r" % self.id
class Oplog(db.Model):
__tablename__ = "oplog"
id = db.Column(db.Integer, primary_key=True)
admin_id = db.Column(db.Integer, db.ForeignKey("admin.id"))
ip = db.Column(db.String(100))
reason = db.Column(db.String(600))
addtime = db.Column(db.DateTime, index=True, default=datetime.utcnow())
def __repr__(self):
return "<Oplog %r>" % self.id
class Comment(db.Model):
__tablename__ = "comment"
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.Text)
movie_id = db.Column(db.Integer, db.ForeignKey("movie.id"))
user_id = db.Column(db.Integer, db.ForeignKey("user.id"))
addtime = db.Column(db.DateTime, index=True, default=datetime.utcnow())
def __repr__(self):
return "<Comment %r>" % self.id
